From affd240a347ad8e57a334f33e7b8389eecbd7132 Mon Sep 17 00:00:00 2001
From: Max Katz <maxkatz6@outlook.com>
Date: Mon, 8 Jun 2026 21:53:10 -0700
Subject: [PATCH 001/196] Add sleep timer option for the headless platform
 (#21423)

* Add ShouldRenderOnUIThread//Fps options to the AvaloniaHeadlessPlatformOptions, allowing SleepLoopRenderTimer to be enabled

* Don't throw from ForceRenderTimerTick

* Run DispatcherFrame on RequestCommitAsync, when HeadlessRenderTimer is not available

* This method apparently was public
---
 .../AvaloniaHeadlessPlatform.cs               | 105 +++++++++---------
 .../Avalonia.Headless/HeadlessRenderTimer.cs  |  40 +++++++
 2 files changed, 95 insertions(+), 50 deletions(-)
 create mode 100644 src/Headless/Avalonia.Headless/HeadlessRenderTimer.cs

diff --git a/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs b/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs
index 8e44942d32..838301a6b5 100644
--- a/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs
+++ b/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs
@@ -1,64 +1,22 @@
 using System;
-using System.Diagnostics;
-using Avalonia.Controls.Platform;
-using Avalonia.Reactive;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Platform;
 using Avalonia.Rendering;
 using Avalonia.Rendering.Composition;
-using Avalonia.Threading;
 using System.Collections.Generic;
+using Avalonia.Threading;
 
 namespace Avalonia.Headless
 {
     public static class AvaloniaHeadlessPlatform
     {
         internal static Compositor? Compositor { get; private set; }
-        private static RenderTimer? s_renderTimer;
-
-        private class RenderTimer : DefaultRenderTimer
-        {
-            private readonly int _framesPerSecond;
-            private Action? _forceTick; 
-            protected override IDisposable StartCore(Action<TimeSpan> tick)
-            {
-                var st = Stopwatch.StartNew();
-                _forceTick = () => tick(st.Elapsed);
-
-                var timer = new DispatcherTimer(DispatcherPriority.UiThreadRender)
-                {
-                    Interval = TimeSpan.FromSeconds(1.0 / _framesPerSecond),
-                    Tag = "HeadlessRenderTimer"
-                };
-                timer.Tick += (s, e) => tick(st.Elapsed);
-                timer.Start();
-
-                return Disposable.Create(() =>
-                {
-                    _forceTick = null;
-                    timer.Stop();
-                });
-            }
+        private static IRenderTimer? s_renderTimer;
 
-            public RenderTimer(int framesPerSecond) : base(framesPerSecond)
-            {
-                _framesPerSecond = framesPerSecond;
-            }
-
-            public override bool RunsInBackground => false;
-
-            public void ForceTick() => _forceTick?.Invoke();
-        }
-
-        private class HeadlessWindowingPlatform : IWindowingPlatform
+        private class HeadlessWindowingPlatform(PixelFormat frameBufferFormat) : IWindowingPlatform
         {
-            readonly PixelFormat _frameBufferFormat;
-            public HeadlessWindowingPlatform(PixelFormat frameBufferFormat)
-            {
-                _frameBufferFormat = frameBufferFormat;
-            }
-            public IWindowImpl CreateWindow() => new HeadlessWindowImpl(false, _frameBufferFormat);
+            public IWindowImpl CreateWindow() => new HeadlessWindowImpl(false, frameBufferFormat);
             public ITopLevelImpl CreateEmbeddableTopLevel() => CreateEmbeddableWindow();
 
             public IWindowImpl CreateEmbeddableWindow() => throw new PlatformNotSupportedException();
@@ -73,12 +31,16 @@ namespace Avalonia.Headless
                 }
             }
         }
-        
+
         internal static void Initialize(AvaloniaHeadlessPlatformOptions opts)
         {
             var clipboardImpl = new HeadlessClipboardImplStub();
             var clipboard = new Clipboard(clipboardImpl);
 
+            s_renderTimer = opts.ShouldRenderOnUIThread
+                ? new HeadlessRenderTimer(opts.Fps)
+                : new SleepLoopRenderTimer(opts.Fps);
+
             AvaloniaLocator.CurrentMutable
                 .Bind<IClipboardImpl>().ToConstant(clipboardImpl)
                 .Bind<IClipboard>().ToConstant(clipboard)
@@ -86,7 +48,7 @@ namespace Avalonia.Headless
                 .Bind<IPlatformSettings>().ToSingleton<DefaultPlatformSettings>()
                 .Bind<IPlatformIconLoader>().ToSingleton<HeadlessIconLoaderStub>()
                 .Bind<IKeyboardDevice>().ToConstant(new KeyboardDevice())
-                .Bind<IRenderLoop>().ToConstant(Rendering.RenderLoop.FromTimer(s_renderTimer = new RenderTimer(60)))
+                .Bind<IRenderLoop>().ToConstant(Rendering.RenderLoop.FromTimer(s_renderTimer))
                 .Bind<IWindowingPlatform>().ToConstant(new HeadlessWindowingPlatform(opts.FrameBufferFormat))
                 .Bind<PlatformHotkeyConfiguration>().ToSingleton<PlatformHotkeyConfiguration>()
                 .Bind<KeyGestureFormatInfo>().ToConstant(new KeyGestureFormatInfo(new Dictionary<Key, string>() { }));
@@ -100,15 +62,58 @@ namespace Avalonia.Headless
         /// <param name="count">Count of frames to be ticked on the timer.</param>
         public static void ForceRenderTimerTick(int count = 1)
         {
-            for (var c = 0; c < count; c++)
-                s_renderTimer?.ForceTick();
+            if (s_renderTimer is HeadlessRenderTimer timer)
+            {
+                for (var c = 0; c < count; c++)
+                {
+                    timer.ForceTick();
+                }
+            }
+            else
+            {
+                if (Compositor is not { } compositor)
+                {
+                    throw new InvalidOperationException("Compositor is not initialized.");
+                }
 
+                var frame = new DispatcherFrame();
+                var task = compositor.RequestCommitAsync();
+                task.ContinueWith(static (_, s) => ((DispatcherFrame)s!).Continue = false, frame);
+                Dispatcher.CurrentDispatcher.PushFrame(frame);
+                task.GetAwaiter().GetResult();
+            }
         }
     }
 
+    /// <summary>
+    /// Options for configuring the Avalonia headless platform.
+    /// </summary>
     public class AvaloniaHeadlessPlatformOptions
     {
+        /// <summary>
+        /// Gets or sets the number of frames per second at which the renderer should run.
+        /// Default 60.
+        /// </summary>
+        public int Fps { get; set; } = 60;
+
+        /// <summary>
+        /// Render directly on the UI thread instead of using a dedicated render thread.
+        /// This can be usable if your device doesn't have multiple cores to begin with.
+        /// This setting is false by default.
+        /// </summary>
+        public bool ShouldRenderOnUIThread { get; set; } = true;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to use headless drawing mode, which allows rendering without creating an actual window.
+        /// </summary>
+        /// <remarks>
+        /// Disable this option if you are using Avalonia.Skia or another drawing backend.
+        /// </remarks>
         public bool UseHeadlessDrawing { get; set; } = true;
+
+        /// <summary>
+        /// Gets or sets the pixel format to be used for the headless Window framebuffers.
+        /// </summary>
         public PixelFormat FrameBufferFormat { get; set; } = PixelFormat.Rgba8888;
     }
 
diff --git a/src/Headless/Avalonia.Headless/HeadlessRenderTimer.cs b/src/Headless/Avalonia.Headless/HeadlessRenderTimer.cs
new file mode 100644
index 0000000000..6cbbd3d425
--- /dev/null
+++ b/src/Headless/Avalonia.Headless/HeadlessRenderTimer.cs
@@ -0,0 +1,40 @@
+using System;
+using System.Diagnostics;
+using Avalonia.Reactive;
+using Avalonia.Rendering;
+using Avalonia.Threading;
+
+namespace Avalonia.Headless;
+
+/// <summary>
+/// A render timer implementation for headless environments that uses a DispatcherTimer to schedule ticks on the UI thread.
+/// Can be controlled with <see cref="ForceTick"/> method. 
+/// </summary>
+internal class HeadlessRenderTimer(int framesPerSecond) : DefaultRenderTimer(framesPerSecond)
+{
+    private readonly int _framesPerSecond = framesPerSecond;
+    private Action? _forceTick; 
+    protected override IDisposable StartCore(Action<TimeSpan> tick)
+    {
+        var st = Stopwatch.StartNew();
+        _forceTick = () => tick(st.Elapsed);
+
+        var timer = new DispatcherTimer(DispatcherPriority.UiThreadRender)
+        {
+            Interval = TimeSpan.FromSeconds(1.0 / _framesPerSecond),
+            Tag = "HeadlessRenderTimer"
+        };
+        timer.Tick += (s, e) => tick(st.Elapsed);
+        timer.Start();
+
+        return Disposable.Create(() =>
+        {
+            _forceTick = null;
+            timer.Stop();
+        });
+    }
+
+    public override bool RunsInBackground => false;
+
+    public void ForceTick() => _forceTick?.Invoke();
+}

From 16cd5ff650e48a8d3948b2604b7389a34f5161d8 Mon Sep 17 00:00:00 2001
From: Tim Miller <drasticactions@users.noreply.github.com>
Date: Tue, 9 Jun 2026 21:28:57 +0900
Subject: [PATCH 002/196] [WinUI] Create Avalonia.WinUI for initial WinUI embed
 support (#21430)

* Init 1

Init 2

Init 3

Init 4

Init 5

Add Windows SDK

* Add WinUI to slnx

* Update sample

* Add clipboard support

* Only handle text down if Avalonia didn't first

* Start WinUIEmbedSample.csproj

* Migrate from Avalonia.WinUI to Avalonia.Win32

* Input handling

* Update sample

* Hover

* Update sample

* IME Fixes

* Fix keyscan

* Update sample

* Add cursor support

* Update samples

* Dispose _mouseDevice

* Implement Drag Source (And fix logging)

* Update samples

* Update clipboard sample

* Fix Focus/Tabs

* Peer Proxy

* Cleanup

* Cleanup

* Fix proj for WinUI

* Refactor log

* Fix proj

* Remove internal using

* try/finally contextLock

* Remove systemAIModels

* Fix IME

* Cleanup

* More IME changes

* Update comment

* Update logic

* Handle Win32 Cursors

* Fix AOT

* Update description

* Remove test code

* Fix sample
---
 Avalonia.slnx                                 |   9 +
 Directory.Packages.props                      |   2 +
 build/TargetFrameworks.props                  |   1 +
 dirs.proj                                     |   6 +
 samples/ControlGallery.WinUI/App.xaml         |  16 +
 samples/ControlGallery.WinUI/App.xaml.cs      |  40 +
 .../Assets/LockScreenLogo.scale-200.png       | Bin 0 -> 432 bytes
 .../Assets/SplashScreen.scale-200.png         | Bin 0 -> 5372 bytes
 .../Assets/Square150x150Logo.scale-200.png    | Bin 0 -> 1755 bytes
 .../Assets/Square44x44Logo.scale-200.png      | Bin 0 -> 637 bytes
 ...x44Logo.targetsize-24_altform-unplated.png | Bin 0 -> 283 bytes
 .../ControlGallery.WinUI/Assets/StoreLogo.png | Bin 0 -> 456 bytes
 .../Assets/Wide310x150Logo.scale-200.png      | Bin 0 -> 2097 bytes
 .../ControlGallery.WinUI.csproj               |  67 ++
 samples/ControlGallery.WinUI/MainWindow.xaml  |  15 +
 .../ControlGallery.WinUI/MainWindow.xaml.cs   |  11 +
 .../ControlGallery.WinUI/Package.appxmanifest |  51 +
 .../Properties/launchSettings.json            |  10 +
 samples/ControlGallery.WinUI/app.manifest     |  19 +
 samples/WinUIEmbedSample/App.xaml             |  14 +
 samples/WinUIEmbedSample/App.xaml.cs          |  40 +
 samples/WinUIEmbedSample/AvaloniaApp.axaml    |   7 +
 samples/WinUIEmbedSample/AvaloniaApp.axaml.cs |  13 +
 samples/WinUIEmbedSample/EmbeddedView.axaml   | 228 +++++
 .../WinUIEmbedSample/EmbeddedView.axaml.cs    | 183 ++++
 samples/WinUIEmbedSample/MainWindow.xaml      | 114 +++
 samples/WinUIEmbedSample/MainWindow.xaml.cs   | 175 ++++
 samples/WinUIEmbedSample/Package.appxmanifest |  51 +
 .../Properties/launchSettings.json            |  10 +
 .../WinUIEmbedSample/WinUIEmbedSample.csproj  |  66 ++
 samples/WinUIEmbedSample/app.manifest         |  16 +
 src/Avalonia.Base/Avalonia.Base.csproj        |   1 +
 src/Avalonia.Base/Logging/LogArea.cs          |   5 +
 .../Avalonia.Win32/Avalonia.Win32.csproj      |   1 +
 .../OpenGl/Angle/SwapChainGlSurface.cs        | 252 +++++
 .../Avalonia.Win32/SwapChainTopLevelImpl.cs   | 122 +++
 .../AvaloniaSwapChainPanelAutomationPeer.cs   | 143 +++
 .../AvaloniaToXamlPeerProxy.ExpandCollapse.cs |  29 +
 .../AvaloniaToXamlPeerProxy.Invoke.cs         |   9 +
 .../AvaloniaToXamlPeerProxy.RangeValue.cs     |  16 +
 .../AvaloniaToXamlPeerProxy.Scroll.cs         |  33 +
 .../AvaloniaToXamlPeerProxy.Selection.cs      |  51 +
 .../AvaloniaToXamlPeerProxy.Toggle.cs         |  27 +
 .../AvaloniaToXamlPeerProxy.Value.cs          |  13 +
 .../Automation/AvaloniaToXamlPeerProxy.cs     | 141 +++
 .../Automation/ControlTypeMap.cs              |  52 +
 .../Avalonia.WinUI/Avalonia.WinUI.csproj      |  30 +
 .../Avalonia.WinUI/AvaloniaSwapChainPanel.cs  | 915 ++++++++++++++++++
 .../Avalonia.WinUI/WinUICursorFactory.cs      |  91 ++
 src/Windows/Avalonia.WinUI/WinUIDragSource.cs |  42 +
 src/Windows/Avalonia.WinUI/WinUIKeyInterop.cs |  62 ++
 .../Avalonia.WinUI/WinUITextInputMethod.cs    | 384 ++++++++
 52 files changed, 3583 insertions(+)
 create mode 100644 samples/ControlGallery.WinUI/App.xaml
 create mode 100644 samples/ControlGallery.WinUI/App.xaml.cs
 create mode 100644 samples/ControlGallery.WinUI/Assets/LockScreenLogo.scale-200.png
 create mode 100644 samples/ControlGallery.WinUI/Assets/SplashScreen.scale-200.png
 create mode 100644 samples/ControlGallery.WinUI/Assets/Square150x150Logo.scale-200.png
 create mode 100644 samples/ControlGallery.WinUI/Assets/Square44x44Logo.scale-200.png
 create mode 100644 samples/ControlGallery.WinUI/Assets/Square44x44Logo.targetsize-24_altform-unplated.png
 create mode 100644 samples/ControlGallery.WinUI/Assets/StoreLogo.png
 create mode 100644 samples/ControlGallery.WinUI/Assets/Wide310x150Logo.scale-200.png
 create mode 100644 samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj
 create mode 100644 samples/ControlGallery.WinUI/MainWindow.xaml
 create mode 100644 samples/ControlGallery.WinUI/MainWindow.xaml.cs
 create mode 100644 samples/ControlGallery.WinUI/Package.appxmanifest
 create mode 100644 samples/ControlGallery.WinUI/Properties/launchSettings.json
 create mode 100644 samples/ControlGallery.WinUI/app.manifest
 create mode 100644 samples/WinUIEmbedSample/App.xaml
 create mode 100644 samples/WinUIEmbedSample/App.xaml.cs
 create mode 100644 samples/WinUIEmbedSample/AvaloniaApp.axaml
 create mode 100644 samples/WinUIEmbedSample/AvaloniaApp.axaml.cs
 create mode 100644 samples/WinUIEmbedSample/EmbeddedView.axaml
 create mode 100644 samples/WinUIEmbedSample/EmbeddedView.axaml.cs
 create mode 100644 samples/WinUIEmbedSample/MainWindow.xaml
 create mode 100644 samples/WinUIEmbedSample/MainWindow.xaml.cs
 create mode 100644 samples/WinUIEmbedSample/Package.appxmanifest
 create mode 100644 samples/WinUIEmbedSample/Properties/launchSettings.json
 create mode 100644 samples/WinUIEmbedSample/WinUIEmbedSample.csproj
 create mode 100644 samples/WinUIEmbedSample/app.manifest
 create mode 100644 src/Windows/Avalonia.Win32/OpenGl/Angle/SwapChainGlSurface.cs
 create mode 100644 src/Windows/Avalonia.Win32/SwapChainTopLevelImpl.cs
 create mode 100644 src/Windows/Avalonia.WinUI/Automation/AvaloniaSwapChainPanelAutomationPeer.cs
 create mode 100644 src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.ExpandCollapse.cs
 create mode 100644 src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Invoke.cs
 create mode 100644 src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.RangeValue.cs
 create mode 100644 src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Scroll.cs
 create mode 100644 src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Selection.cs
 create mode 100644 src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Toggle.cs
 create mode 100644 src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Value.cs
 create mode 100644 src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.cs
 create mode 100644 src/Windows/Avalonia.WinUI/Automation/ControlTypeMap.cs
 create mode 100644 src/Windows/Avalonia.WinUI/Avalonia.WinUI.csproj
 create mode 100644 src/Windows/Avalonia.WinUI/AvaloniaSwapChainPanel.cs
 create mode 100644 src/Windows/Avalonia.WinUI/WinUICursorFactory.cs
 create mode 100644 src/Windows/Avalonia.WinUI/WinUIDragSource.cs
 create mode 100644 src/Windows/Avalonia.WinUI/WinUIKeyInterop.cs
 create mode 100644 src/Windows/Avalonia.WinUI/WinUITextInputMethod.cs

diff --git a/Avalonia.slnx b/Avalonia.slnx
index 80b4042e7a..dba476ed4a 100644
--- a/Avalonia.slnx
+++ b/Avalonia.slnx
@@ -65,6 +65,10 @@
     <Project Path="samples/ControlCatalog.MacCatalyst/ControlCatalog.MacCatalyst.csproj" />
     <Project Path="samples/ControlCatalog.tvOS/ControlCatalog.tvOS.csproj" />
     <Project Path="samples/ControlCatalog/ControlCatalog.csproj" />
+    <Project Path="samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj">
+      <Platform Project="x64" />
+      <Deploy />
+    </Project>
     <Project Path="samples/Generators.Sandbox/Generators.Sandbox.csproj" />
     <Project Path="samples/GpuInterop/GpuInterop.csproj" />
     <Project Path="samples/IntegrationTestApp/IntegrationTestApp.csproj" />
@@ -84,6 +88,10 @@
     <Project Path="samples/SingleProjectSandbox/SingleProjectSandbox.csproj" />
     <Project Path="samples/TextTestApp/TextTestApp.csproj" />
     <Project Path="samples/VirtualizationDemo/VirtualizationDemo.csproj" />
+    <Project Path="samples/WinUIEmbedSample/WinUIEmbedSample.csproj">
+      <Platform Project="x64" />
+      <Deploy />
+    </Project>
     <Project Path="samples/XEmbedSample/XEmbedSample.csproj" />
   </Folder>
   <Folder Name="/Samples/Interop/">
@@ -178,6 +186,7 @@
     <Project Path="src/Windows/Avalonia.Win32.Automation/Avalonia.Win32.Automation.csproj" />
     <Project Path="src/Windows/Avalonia.Win32.Interoperability/Avalonia.Win32.Interoperability.csproj" />
     <Project Path="src/Windows/Avalonia.Win32/Avalonia.Win32.csproj" />
+    <Project Path="src/Windows/Avalonia.WinUI/Avalonia.WinUI.csproj" />
   </Folder>
   <Project Path="nukebuild/_build.csproj">
     <Build Project="false" />
diff --git a/Directory.Packages.props b/Directory.Packages.props
index f4e677d631..cac3db9cc9 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -31,6 +31,8 @@
     <PackageVersion Include="Microsoft.Reactive.Testing" Version="6.1.0" />
     <PackageVersion Include="Microsoft.Testing.Extensions.TrxReport" Version="2.0.2" />
     <PackageVersion Include="Microsoft.Windows.CsWin32" Version="0.3.257" />
+    <PackageVersion Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.26100.7705" />
+    <PackageVersion Include="Microsoft.WindowsAppSDK" Version="1.8.260209005" />
     <PackageVersion Include="Mono.Cecil" Version="0.11.6" />
     <PackageVersion Include="MonoMac.NetStandard" Version="0.0.4" />
     <PackageVersion Include="Moq" Version="4.20.72" />
diff --git a/build/TargetFrameworks.props b/build/TargetFrameworks.props
index 96541e7ecf..a380009e23 100644
--- a/build/TargetFrameworks.props
+++ b/build/TargetFrameworks.props
@@ -8,6 +8,7 @@
     <AvsCurrentIOSTargetFramework>$(AvsCurrentTargetFramework)-ios26.0</AvsCurrentIOSTargetFramework>
     <AvsCurrentTvOSTargetFramework>$(AvsCurrentTargetFramework)-tvos26.0</AvsCurrentTvOSTargetFramework>
     <AvsCurrentBrowserTargetFramework>$(AvsCurrentTargetFramework)-browser</AvsCurrentBrowserTargetFramework>
+    <AvsCurrentWinUITargetFramework>$(AvsCurrentTargetFramework)-windows10.0.19041.0</AvsCurrentWinUITargetFramework>
   </PropertyGroup>
   <PropertyGroup Condition="'$(AvsSkipBuildingLegacyTargetFrameworks)' != 'True'">
     <AvsLegacyTargetFrameworks>net8.0</AvsLegacyTargetFrameworks>
diff --git a/dirs.proj b/dirs.proj
index 20df84439e..43c2518f78 100644
--- a/dirs.proj
+++ b/dirs.proj
@@ -14,12 +14,18 @@
     <ProjectReference Remove="samples/*.Android/*.csproj" />
     <ProjectReference Remove="samples/*.Browser/*.csproj" />
     <ProjectReference Remove="samples/SingleProjectSandbox/*.csproj" />
+    <!-- Exclude WinUI samples when Platform is not specified or is AnyCPU -->
+    <ProjectReference Remove="samples/*.WinUI/*.csproj" Condition="'$(Platform)' == '' Or '$(Platform)' == 'AnyCPU'" />
+    <ProjectReference Remove="samples/WinUIEmbedSample/*.csproj" Condition="'$(Platform)' == '' Or '$(Platform)' == 'AnyCPU'" />
   </ItemGroup>
 
   <ItemGroup Condition="!$([MSBuild]::IsOsPlatform('Windows'))">
     <!-- Build mobile backends only on Windows, where we have installed android workload -->
     <ProjectReference Remove="src/Android/**/*.*proj" />
     <ProjectReference Remove="src/iOS/**/*.*proj" />
+    <ProjectReference Remove="src/Windows/Avalonia.WinUI/**/*.*proj" />
+    <ProjectReference Remove="samples/*.WinUI/*.csproj" />
+    <ProjectReference Remove="samples/WinUIEmbedSample/*.csproj" />
   </ItemGroup>
 
 </Project>
diff --git a/samples/ControlGallery.WinUI/App.xaml b/samples/ControlGallery.WinUI/App.xaml
new file mode 100644
index 0000000000..88b20eca37
--- /dev/null
+++ b/samples/ControlGallery.WinUI/App.xaml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Application
+    x:Class="ControlGallery.WinUI.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:ControlGallery.WinUI">
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
+                <!-- Other merged dictionaries here -->
+            </ResourceDictionary.MergedDictionaries>
+            <!-- Other app resources here -->
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>
diff --git a/samples/ControlGallery.WinUI/App.xaml.cs b/samples/ControlGallery.WinUI/App.xaml.cs
new file mode 100644
index 0000000000..5d26d06383
--- /dev/null
+++ b/samples/ControlGallery.WinUI/App.xaml.cs
@@ -0,0 +1,40 @@
+using global::Avalonia;
+using global::Avalonia.Controls;
+using global::Avalonia.Controls.ApplicationLifetimes;
+using global::Avalonia.Skia;
+using global::Avalonia.Win32;
+using WinUIApplication = Microsoft.UI.Xaml.Application;
+using LaunchActivatedEventArgs = Microsoft.UI.Xaml.LaunchActivatedEventArgs;
+using Window = Microsoft.UI.Xaml.Window;
+
+namespace ControlGallery.WinUI
+{
+    public partial class App : WinUIApplication
+    {
+        private Window? _window;
+
+        internal static SingleViewLifetime Lifetime { get; } = new();
+
+        public App()
+        {
+            InitializeComponent();
+        }
+
+        protected override void OnLaunched(LaunchActivatedEventArgs args)
+        {
+            AppBuilder.Configure<ControlCatalog.App>()
+                .UseWin32()
+                .UseSkia()
+                .UseHarfBuzz()
+                .SetupWithLifetime(Lifetime);
+
+            _window = new MainWindow();
+            _window.Activate();
+        }
+    }
+
+    internal sealed class SingleViewLifetime : ISingleViewApplicationLifetime
+    {
+        public Control? MainView { get; set; }
+    }
+}
diff --git a/samples/ControlGallery.WinUI/Assets/LockScreenLogo.scale-200.png b/samples/ControlGallery.WinUI/Assets/LockScreenLogo.scale-200.png
new file mode 100644
index 0000000000000000000000000000000000000000..7440f0d4bf7c7e26e4e36328738c68e624ee851e
GIT binary patch
literal 432
zcmeAS@N?(olHy`uVBq!ia0vp^1|ZDA1|-9oezr3(FqV6|IEGZ*x-#9g>~Mkr+x6^F
zy~CDX2QIMs&Gcs3RnRBoxBA!*(Mfw0KTCYuYk0Wl<A3kFdDp`#?}XI|oqqQ0*|D%p
zsa`i8jb+)Z4OKr{E6gsxDCoZ^_q1W^M*Wx^PHB+~V!M-K=X6~WvlcB>EIV>qBmPl!
zq4ukrvfADX@#p8fbLY(H47N+k`FZ(FZh?cDro7>{8mkBO3>^oaIx`3!Jl)Qq)HI!+
z(S=1{o~eT)&W^=Ea8C`-17(Jv5(nHFJ{dOjGdxLVkY_y6&S1whfuFI4MM0kF0f&cO
zPDVpV%nz;Id$>+0Ga5e9625-JcI)oq=#Pa3p^>8BB}21BUw@eN!-6@w%X+^`+Vn?!
zryu|3T>kVWNBYyBc=7Y6H#s1<v*REmr-J?Jj+807siAL#J{jLg-rpk>Ah!OI_nezW
zXTqOdkv2Az6KKBV=$yHdF^R3Fqw(TZEoNSZX>reXJ#bwX42%f|Pgg&ebxsLQ010xn
AssI20

literal 0
HcmV?d00001

diff --git a/samples/ControlGallery.WinUI/Assets/SplashScreen.scale-200.png b/samples/ControlGallery.WinUI/Assets/SplashScreen.scale-200.png
new file mode 100644
index 0000000000000000000000000000000000000000..32f486a86792a5e34cd9a8261b394c49b48f86be
GIT binary patch
literal 5372
zcmd5=Z){Ul6u)iv53sCbIJKLzl(EF%0tzcEY@|pLrfgF~2Dk$KFtU+$kbYqDN5W%7
z>?DBo!@y06eh{Oux>brrNT^{MO(tkiC@nH(2}}G_1|uvcMD(0{?|W<a-a0~n*biHG
zf9L+rIlpu6dH1dP^~%NC@%r(E5N-Jq%bSFxTp~ohA|nk}Ixf~6BxLgGa?65cn<BBx
z(>^Gxo!tG~hW2Rn&7%b`-Kd_^`BCrb>XVtRKONoEw6%NswzMxk+kbocuk&}kJ#hSP
z>8uR{r%LJ?I#)aaWW;uEixz+DzyTp<n+AXFpi3#HQI?o(f|bH{g{8;N$n#--6#`ON
z8Y9NX&lrr4ess~}tsYJpA3mcgo#b_dR&Q+}f$h#K8$()bySabmT)V0fe4SsBn?`JT
zqRz#ih7J|{6av`ud?~|$-xZb;Y?)QU(in_^{=cV@zO#`s-@utQs=lVkPT#EV8Pt(=
z)rrH6b+Hq-7L!Y!vgbYjJVQ>p)MTEo&R%nEA92~g{^eXQwKV1m{xl5K<@k3FacT+Z
zrwfy=VocIptI>t%@p5a;Rt=WXVnU;2SUdr7Yk>gw_2z_ICK^23$|Cg7{3Eg5j@N*F
zetT?>30(*S_7ld-Yt&u7<vX3R{>T{(hEjjM#vPlXibjrq?;pBBx3*>_2~VFGdsH5L
zQKme_LAe<h!eZii1Fy3}l)!Aw9wE!2W(SGt2^7)bZFX=;4PF(jK}m&RONz@*d&8J(
z@Ti#Hn-$E`<z{9LBNl>bV}aOX#+rQafZtp+4jK}V!>pn1?+eUH$0%6}z(Kul9!^2z
zXi+d@jnx)RW7!j9uFEdv5N&1sCW#Z6Ej5Y7<kmvx;UKV>c;o28Q7i%U0(2v5J>o9P
zl$#C8&9r)nL;?J65^GIeSOHYr3B7}}R~}@2Tx_xo5<y?a$o$OKo{{+tbGWrUXN#$;
zSWI6_TQOb|VI7K0g?BlOxm<Xc1J+m>*YdU#g1bO}95cq69J!efdlE+x<zPjYI5xf;
z4<bjLgW^$k_B;!UVem9<T^K7uBVPzrt<OycX30S>j1qG#ZUqh~1Sn#dBsZfDvcupM
zXOFoyJ0$s+RHQKpzr#T>c&EUbq)lGvZDxuI!9unMI=#;ob2&gT)WqOjt6<h5H@jmL
zN!k>^X`_N21r`&eh6h0xpT!n6Z9rvE&+bF<pl_}u09Bp1E3nzHi4)99$2L1qAW9P`
z02W44*epsivm8XGK7?|knC#L?V(_*PgF_!n65L*&#cbguS8=NNcv#tldy*doaBnj3
z9WfY8n1#CJm0?9!KfQ9`!hF!{2rArnK5~8PpWTsfeC;Y?z6SLTG{!DON~Uh8d(z0B
zk_OKw^9C)@aoA1Pp2hGD`_EZX%gDQm-Mm^MZYA7H2398nYpr*W4tay@l>U$vTJO2?
z#^tBNOx*2N)~(+TH8d>ep6``8V=3JEfdUUahVZ-xN+k#V&32x|%qnX(XBii5<@`%^
zV#Ky4f1!6RJqJXBU3M4~tmj2;;r`8_j&w?h5g35uMH(QI$Xpe<SoDfuyBvJ$AWs6K
z6zg=ID-g$VpJuH=3<<;&{JVg6CeE#{VqQ)i3=pm|43N08<5$`WT7dCf(JjIzJh>sb
zG|*XRT?kh6M(jj0Y&vF^M*9g-iDMW%G%9%Pa}6ERQ9b0%6z1v}Ja=|L@G#5ZI>JS9
z*(K12nMvS?oyG8s9|q~{w`ajtI`KSHSiJ;)%X@M&eCE(VqI#F(XL?L@A$TUT?6av5
zkPWIR391XjSC%d6L}7F71Qpw(;c_~)mSZo-&Fm^FHlPX|Fu}1B3E+9j0}o1a(4HFS
zUItE22CC%XZi!b4%~vWn>rpV9&CUEvt!?Q{Pr*L~51&(0Sz{VJJFrJtWw2PwXd|J{
zgH%3vAY$flodH=4&ruCHX;(3t;o}n?!0~3EE|5qRz$!VIkphxa4@_jyfiE9<B@ip?
z)JovR1W?*3um<3*q6-Zsm{E?ROduKC3|v9dEPGw}5LGFvN0rp@as&5IxNxF!c>m;0
zjcYJ2;26N&MTB8X4joZ&?SUe|VS$^I%dt{!c2O;%3SdqW@K_14r8eyC1s&VcU5+2~
z_O1Cc*w|aIA=VC6AT_EFoL}W#Rl;7CZe)e}RS*e;8CVyM6i8a(yO@|S709VYY(y2g
zc+QxB>Bw^B^2Db~*o)=i$m-aUNQFkYy5(eJW$cez>C{POds*p3cy#tHnvActP;dBP
zdEf)C;lq}&#PE?XCD<~ngrzYUg|nS`#MS`Rd7cT>xlR19P#~4Qg5!J}@glCUq)z_2
zj<XRy%t~Rq!qTH+WUjDx6$5&J82?9%V~F+uSwAX9-8kA;fhtqag;&?-m-?|B<%=pU
Jo|kP+{{fTh%QOH0

literal 0
HcmV?d00001

diff --git a/samples/ControlGallery.WinUI/Assets/Square150x150Logo.scale-200.png b/samples/ControlGallery.WinUI/Assets/Square150x150Logo.scale-200.png
new file mode 100644
index 0000000000000000000000000000000000000000..53ee3777ea27e31b260014cf4074099874ff933a
GIT binary patch
literal 1755
zcmZvde@q)?7{{+i3tS0qt7{iJ0{^s_^@sZdMMEaBz#P|xjghsxG)6Bvp>vyv%aSq0
z)njao1dV0XNw&c@qmj1e*jgQ$l@_urW5G4RSY#rT1z`#%3;{EB`aJK|TH^lb_3nAT
z-_Q4X-(K&IS8UyqsnjYdippfmN-HT!X2MT;Dpcy~-#<W6spr^I%Z`I%bK{M*>$k6V
z|M<iW^=g++e@Rx7_LHHnqU2;@`i?tCD}@7f%KSi0pe1~`>R4vU#O&p7TC46pTflb3
zoUJ;ZRf#&8&EwXy5s%!&(q6cN62swD#FH%O-RJsjWPZN3^^@FCIQ&MxXIFo7!I#VI
zkpIstuWqUV5uhgs07?k$*!`uiZ=5b#$lI|0c+XJv<J{p}RUOaNKQ<im@QX7O-EXm%
zZcW#Y{k<Xj`b3r{sN?i*g_&_g1h3pjaUinim|Uz#k6!n{*P)(fetc%Zzt*YppIPkb
zZsrI7$ZjjP2{*TQ)Rl{qr%&KH`*A*c407bjGC(`YTWo?_?9@jM>j(}zSE3MN#EyOK
zql(#yA}~Ibl*r(s1}Z^5mmn*-n93g?-ccM+^PN?6HH~h0hjy6@XY*^i<-V)+OZ;p7
z7j`p_sT55xnYsedNIIel^QIIg7i@`2Qi}x5$!t<wREe9#D@+!fNFxx26>k29$2OQI
zs^kQXAKE}5ZJu$)2@Dxn?}}O@f@6@^!%9Tj+o>=jd!^ZuvBE4jb4g}Z5WMBtcmy^~
zoFGVS5|0FA!(1Q%fL?Bj*L+9ZL<k)9Dx8*ddZZzsW5_{0!wC)<wtN(l?357%26r2H
z)e$Rfj*{dnkRG6kTutOTQgC@J7A}iDXxc^vHXjS@l%c&nv^>{mjSO8lzqrQ0UCZ)X
zPwk$1HNFgaK%NxGpuXz}#ywXvf2JQ?BQ5uOZM2up4S#ieaxS$<UJ>!o9o6<b*PRMe
zw2N}mUfxcbWj4{^_PX_)#THTdzfHx$q43G!7i`-0rv|IVjoNMZ?s})oX>Z=czNQb}
zwAh|xLZ>+WyN%o?^uCAQw&&4o?S$DJ`WP(Hr*grL*qNXlqU0osCQ(Up<yn-Y+UUBH
z0`~|C21=1cK(XdDQ&fpwMc`nfH~_za8nMvP_<v3_Cm2%+xmlLs@U08}yC|SVtuf?a
zLlnGjh0&5BVK|8+M~tFDgR?Lk+<}n5F-|E}GV5KkJ@<Jy+C)_l2)JQFTPN%#u<<5B
zxPSy;gG2(fZvqUoAprgg&;|koNCXG~f;64RuX7>5F(^$Z5;n&oJIO4uF`k&QL*j{f
zU=;#MZ5{@b%qMbjTB3dh-5#mqY><S4qcBmkQW*|18RL|}ppv?cijSrWPC^)2g5{Tu
zT0W#@oVoK%XJ|$oIjS&T`!v+Nezc|NwrKchuXB25ZNFe2+%-J5#HIKRux*I`4`57B
zQ0dHlb#ISPztmwXuXHRwcyab3<L}+G@K@Q;cQ31~kA4Gu{(I}M7xUNx6YKkaZ}wGk
s29I{~!hlCRd13tTX`du`*!lx~{^^p-x%)@fz)Oo_H*YQdqL>%{0jgS+WdHyG

literal 0
HcmV?d00001

diff --git a/samples/ControlGallery.WinUI/Assets/Square44x44Logo.scale-200.png b/samples/ControlGallery.WinUI/Assets/Square44x44Logo.scale-200.png
new file mode 100644
index 0000000000000000000000000000000000000000..f713bba67f551ef91020b75716a4dc8ebd744b1c
GIT binary patch
literal 637
zcmeAS@N?(olHy`uVBq!ia0vp^5g^RL1|$oo8kjIJFu8cTIEGZ*dUI*J;2{SImxtDO
zm%3!R$UazoY}x{$j0P5ABYXWr(l=jxJ6ps1W{tV=^>{Dl><3nv3A}sm=EZ)#l3`NR
zpZda3^rNox*D1%NC98Z~L*6zipLw~Gxn&(Y-;KmJ+aR6eLabU-L#y8HW%7P<VMos8
zqX*Kbh`RaZ-Vu7P$7Xg$t7p!w9mNuLWx4O|3Z&Q;DexQ@4z03gU_T+dV)?TB4XaLx
zKHv%Qc0OMANu|zE*>-E_-<YK1`Q@gsru}A0v3eK#yt;t5sDM}IiBJqP`%aeY2ORYd
znig=vgoGzD?qE|>VlLqIabbHPHKT*)fT@9iWJ7iWgOT9%0}Lrj>lztPxWq6sPw3pi
z#-<=#$jjrP_DD*i!RLsn0mIA=><W)5lpnuqp4YHjx%_x(aT1U|479<C?V*%JOU*Sg
z#_I<Zo_I#HfQ-%GC$U@ez*0u_CX-g5eG;<;W<|4PbM4IJzI;b1;`rIJXmOF0#Dc%g
zZLbuBxUL^m=x+0N7USD){mHGN{Xv<#-5>4~N)IMYWIf=j%-zuKCdMG%tHYot70D1|
zvWa0wMhauW#S>1CnI_;>!1Q3zMA17@DOVq{MQ+{U7^a&yA+%dMCG;WNPV0i;w$tu;
zX^b}UKziPM)(<;)ruW;-`)bBN+rQNM*Zs_>?n$|FVFo-e*PZb*@U7VAd+tHb4e<vm
d2N?b27$xG?o#1Ly5CkSG22WQ%mvv4FO#oV^_;~;T

literal 0
HcmV?d00001

diff --git a/samples/ControlGallery.WinUI/Assets/Square44x44Logo.targetsize-24_altform-unplated.png b/samples/ControlGallery.WinUI/Assets/Square44x44Logo.targetsize-24_altform-unplated.png
new file mode 100644
index 0000000000000000000000000000000000000000..dc9f5bea0c3b191b5e9e13e92fcb488a8a766bd0
GIT binary patch
literal 283
zcmV+$0p$LPP)<h;3K|Lk000e1NJLTq000;O000;W1^@s6;CDUv0002uNkl<Zc-pm;
z$63TM6bA9G*Xc}XfD+UJ=|T=ys-PH76hMXs+<+P&S3!<LhDZG6)%(7=&RDjelDe*Y
zVonR9P71Gc1N(5+&{@F%lu&&PoInMO-~;6j)?f@)>?=Blc~}S6K)wL}r*Gf`BM#QB
z+y>N$mCswb4d{^{<t89R6uAiq5i9?54}{1(JkAEp8F^U1M0O#83GgwliUjUs+(iyH
zU;-wUJ!uK@Iq>S9v_!eQj4fTRMOwOCi?lSk9%<=vAz}jM-*PQtH@Odn1LZcd^j#o>
hW$4xn+CT+ep9lJ{OAO?njobhL002ovPDHLkV1nYebbkN<

literal 0
HcmV?d00001

diff --git a/samples/ControlGallery.WinUI/Assets/StoreLogo.png b/samples/ControlGallery.WinUI/Assets/StoreLogo.png
new file mode 100644
index 0000000000000000000000000000000000000000..a4586f26bdf7841cad10f39cdffe2aca3af252c1
GIT binary patch
literal 456
zcmeAS@N?(olHy`uVBq!ia0vp^Mj*_=1|;R|J2o;fF!p=8IEGZ*dUM0H=rDtTTVkd2
z(%lbKn@VS_lUaADVB&;Z6F#LM+mPsa?e>FnHo;HND^!P`-lX%BH~FOg%y&x+t*x!?
zg$#_1A1kgsSvO(fw`bOmo;lrJX<ItGX8p^+)vNqf=Q|piE^xcD$ZJ36qIG6c9Wn9W
zgiF^fyRvIlz4DPIUZ0)bU14fm$xyiFTenPIFjFvNlH=XI+>8byO1j^gf7qohR%mmt
z@L)WX;>gqgK|tWJvQ5j;4;=gt4HXVKSMYRv5RhY5vS~TqfK_NAP*r{h!!g^BZ;w4r
z7CGdsai)y<gGsuj!2jo4dH!kJEjuUGJ5jrV^^fTM+?I6=Vq5$l{O<YKaqNHux6=a&
zZkGiT+-?aH-R=fh@nb<l3GD`pLjs}+YZ#IQokJQ7861;$eO|ZgF2kZz#SEEoCmzcz
z2tM$>;fJQc`7{Zc2b==h%o`Op$|bg6a&nL{*m7-=0>k4M4-PXlU;G-?%*(*g>iFt^
U$m#7DfHB12>FVdQ&MBb@0G`#n8vp<R

literal 0
HcmV?d00001

diff --git a/samples/ControlGallery.WinUI/Assets/Wide310x150Logo.scale-200.png b/samples/ControlGallery.WinUI/Assets/Wide310x150Logo.scale-200.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b4a5d0dd5f6c6ab408e1edf04a07888859a9eab
GIT binary patch
literal 2097
zcmc&$ZA@EL7(Q+3r2+3&!t4k)FxZ4;Vj0QoMdu<_3Kciz7YR4=A(qT^w)Jxi;?x!9
zuyq6dMF?b>c0sq%A~kJcD9FY~qQRMt?ZR3YyDZt}Od;|mgpc{2dv9AHF){kXU%k({
z=Y8JidEayHTkG@twPZ|U3_^%3ct-OgLSiFAqDN!|tbCX@c@?4P`2x*TMK!+Q4b?k0
ziW7!!KF6dPWcF<%I|iznM~`QJ_V7sHGV_D`dhgpA9Vd@&X}ErK+j~_rdv;Bp?OA@a
zFXOk7eWOJe5NcK;6h$FaM<R8n2&If8B!^r8(M2K*Wi$uP6%uY2h7c5jIOy*=@GeaG
zk2zK+7IduRP}>&7JxNc#-@QTwzW6x#d_z<n*&H+f#4hRlvzx*`m}NokI(>mQNkz5)
zPI;kh;3d;5UCJU+9a(cOxX(|edWoOiAEdGU#kPJ&xnc2||3vDbuhBCkj-pb0as$Zl
z5;}4n=**n6(1g`JEtSy;SG6X;#-F~Oz3lESG2b5`j<s|Qk9||T+vZq0?LoR=o9C9a
zyR%`V_x2UfL94qBs88m)Qdw|qBL@>@wAwY4Yp<=4Xeb>iH=6aicF?DxD&q{`!&}ct
zBI)aycwuobQAf&678Uf+Mmh-@9RUhyH~>?w0dixO0#jZjEc9R^=5NZw=|a(kcB?9^
zfnTiEFXp-q#B;Tn>(O%$A*ud^Rg&eVH6Y_5Y%!E39RR&s?XpG`gKwU!6<ah5%>FE1
z7X)DC7)*(5g}lh`4`{i~DZcWupZI`K)_4P)VE{@gc7@Xsd^86zl~_mOYH?I4!aGeX
z^E(_=L6?PgveDQ+r%P@UISEXrkn`LHJZ##+!-anV>6h)Ik<DtItE{23QQzKv`Y4^v
z8=ZLL+Z^FB*^&Mzi<UM}f$ETGCC%@es^mN<bJoD1diHUjr;FVL=e5QYT)8(ruH3ox
zkOXdF(#8wbdn$2F#5!fF57(5PI)h1c%A7SYSn6N-MGrA%=E%9A)svHNrOgZCgbcRn
z-X~*U=P_DW+2T?W$~2<(Btuu9C2$3fow=WhZKQFd-2p!Mzrc7CIFL1}yqGz_a8Pcr
zIbuP-Go6>Kp;E@p8+3&(5%kS2)ld*J*rJccZM0iyaAx7+F~GW1UWFK&3X$PE1^}NH
zgAG9ck5<?(B)~qL97!mF)l<VKz}JwKV}X!OlArx6Y&~U))tQoP!Ph^k(v*}fFBO?%
zsjN)rZCn|(9m<XQu5IUjRaiLZ0*m5-LhHhp&tSo_amEO6e5w~R{(;|-xFiDQslh}n
z+|1<SfCv~8MVRaL_>K!{07OwU@j@Do>TbH=CDEo#4m0cEyAuXy_<&jlzJVcKweSJ5
z&=q~iIn18$w8yb=rmEmHxVEUA^?RwnB?6Qlp1os8@*dWTGL2bhzZ!s*xqScR?EPL`
zo(JwNdKUUYy7GtvZ3asXm)cgFvCx9EmAi;|w=a0iGiv%%VYKh`P0Wma4y`Xyx|T~(
zAmfGbgbEEC7)j8b@WA@+5W3a61HJXC1dX@6_T|Czk0I0zBk%tnW~()VWITGI!`$c<
gARL?UBrYYkwoDw4eo*CrzXGTrZ@;GF>596)00d&n@&Et;

literal 0
HcmV?d00001

diff --git a/samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj b/samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj
new file mode 100644
index 0000000000..4b3d246aaf
--- /dev/null
+++ b/samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj
@@ -0,0 +1,67 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>$(AvsCurrentWinUITargetFramework)</TargetFramework>
+    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
+    <RootNamespace>ControlGallery.WinUI</RootNamespace>
+    <ApplicationManifest>app.manifest</ApplicationManifest>
+    <Platforms>x86;x64;ARM64</Platforms>
+    <RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
+    <PublishProfile>win-$(Platform).pubxml</PublishProfile>
+    <UseWinUI>true</UseWinUI>
+    <WinUISDKReferences>false</WinUISDKReferences>
+    <EnableMsixTooling>true</EnableMsixTooling>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="Assets\SplashScreen.scale-200.png" />
+    <Content Include="Assets\LockScreenLogo.scale-200.png" />
+    <Content Include="Assets\Square150x150Logo.scale-200.png" />
+    <Content Include="Assets\Square44x44Logo.scale-200.png" />
+    <Content Include="Assets\Square44x44Logo.targetsize-24_altform-unplated.png" />
+    <Content Include="Assets\StoreLogo.png" />
+    <Content Include="Assets\Wide310x150Logo.scale-200.png" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Manifest Include="$(ApplicationManifest)" />
+  </ItemGroup>
+
+  <!--
+    Defining the "Msix" ProjectCapability here allows the Single-project MSIX Packaging
+    Tools extension to be activated for this project even if the Windows App SDK Nuget
+    package has not yet been restored.
+  -->
+  <ItemGroup Condition="'$(DisableMsixProjectCapabilityAddedByProject)'!='true' and '$(EnableMsixTooling)'=='true'">
+    <ProjectCapability Include="Msix" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Windows.SDK.BuildTools" />
+    <PackageReference Include="Microsoft.WindowsAppSDK" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ControlCatalog\ControlCatalog.csproj" />
+    <ProjectReference Include="..\..\src\Windows\Avalonia.Win32\Avalonia.Win32.csproj" />
+    <ProjectReference Include="..\..\src\Windows\Avalonia.WinUI\Avalonia.WinUI.csproj" />
+    <ProjectReference Include="..\..\src\HarfBuzz\Avalonia.HarfBuzz\Avalonia.HarfBuzz.csproj" />
+  </ItemGroup>
+
+  <!--
+    Defining the "HasPackageAndPublishMenuAddedByProject" property here allows the Solution
+    Explorer "Package and Publish" context menu entry to be enabled for this project even if
+    the Windows App SDK Nuget package has not yet been restored.
+  -->
+  <PropertyGroup Condition="'$(DisableHasPackageAndPublishMenuAddedByProject)'!='true' and '$(EnableMsixTooling)'=='true'">
+    <HasPackageAndPublishMenu>true</HasPackageAndPublishMenu>
+  </PropertyGroup>
+
+  <!-- Publish Properties -->
+  <PropertyGroup>
+    <PublishReadyToRun Condition="'$(Configuration)' == 'Debug'">False</PublishReadyToRun>
+    <PublishReadyToRun Condition="'$(Configuration)' != 'Debug'">True</PublishReadyToRun>
+    <PublishTrimmed Condition="'$(Configuration)' == 'Debug'">False</PublishTrimmed>
+    <PublishTrimmed Condition="'$(Configuration)' != 'Debug'">True</PublishTrimmed>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/samples/ControlGallery.WinUI/MainWindow.xaml b/samples/ControlGallery.WinUI/MainWindow.xaml
new file mode 100644
index 0000000000..9595ef8253
--- /dev/null
+++ b/samples/ControlGallery.WinUI/MainWindow.xaml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Window
+    x:Class="ControlGallery.WinUI.MainWindow"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:avalonia="using:Avalonia.WinUI"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    mc:Ignorable="d"
+    Title="ControlGallery.WinUI">
+
+    <Grid>
+        <avalonia:AvaloniaSwapChainPanel x:Name="AvaloniaPanel" />
+    </Grid>
+</Window>
diff --git a/samples/ControlGallery.WinUI/MainWindow.xaml.cs b/samples/ControlGallery.WinUI/MainWindow.xaml.cs
new file mode 100644
index 0000000000..7f9b40b82e
--- /dev/null
+++ b/samples/ControlGallery.WinUI/MainWindow.xaml.cs
@@ -0,0 +1,11 @@
+namespace ControlGallery.WinUI
+{
+    public sealed partial class MainWindow : Microsoft.UI.Xaml.Window
+    {
+        public MainWindow()
+        {
+            InitializeComponent();
+            AvaloniaPanel.Content = App.Lifetime.MainView;
+        }
+    }
+}
diff --git a/samples/ControlGallery.WinUI/Package.appxmanifest b/samples/ControlGallery.WinUI/Package.appxmanifest
new file mode 100644
index 0000000000..fcd91fc1ac
--- /dev/null
+++ b/samples/ControlGallery.WinUI/Package.appxmanifest
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<Package
+  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
+  xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
+  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
+  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
+  IgnorableNamespaces="uap rescap">
+
+  <Identity
+    Name="2787a268-3e4a-4dd9-b385-8f677d254cb7"
+    Publisher="CN=drasticactions"
+    Version="1.0.0.0" />
+
+  <mp:PhoneIdentity PhoneProductId="2787a268-3e4a-4dd9-b385-8f677d254cb7" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
+
+  <Properties>
+    <DisplayName>ControlGallery.WinUI</DisplayName>
+    <PublisherDisplayName>drasticactions</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26226.0" />
+    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26226.0" />
+  </Dependencies>
+
+  <Resources>
+    <Resource Language="x-generate"/>
+  </Resources>
+
+  <Applications>
+    <Application Id="App"
+      Executable="$targetnametoken$.exe"
+      EntryPoint="$targetentrypoint$">
+      <uap:VisualElements
+        DisplayName="ControlGallery.WinUI"
+        Description="ControlGallery.WinUI"
+        BackgroundColor="transparent"
+        Square150x150Logo="Assets\Square150x150Logo.png"
+        Square44x44Logo="Assets\Square44x44Logo.png">
+        <uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png" />
+        <uap:SplashScreen Image="Assets\SplashScreen.png" />
+      </uap:VisualElements>
+    </Application>
+  </Applications>
+
+  <Capabilities>
+    <rescap:Capability Name="runFullTrust" />
+  </Capabilities>
+</Package>
diff --git a/samples/ControlGallery.WinUI/Properties/launchSettings.json b/samples/ControlGallery.WinUI/Properties/launchSettings.json
new file mode 100644
index 0000000000..ddb3c41a5a
--- /dev/null
+++ b/samples/ControlGallery.WinUI/Properties/launchSettings.json
@@ -0,0 +1,10 @@
+{
+  "profiles": {
+    "ControlGallery.WinUI (Package)": {
+      "commandName": "MsixPackage"
+    },
+    "ControlGallery.WinUI (Unpackaged)": {
+      "commandName": "Project"
+    }
+  }
+}
\ No newline at end of file
diff --git a/samples/ControlGallery.WinUI/app.manifest b/samples/ControlGallery.WinUI/app.manifest
new file mode 100644
index 0000000000..e6d75d93fc
--- /dev/null
+++ b/samples/ControlGallery.WinUI/app.manifest
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="1.0.0.0" name="ControlGallery.WinUI.app"/>
+
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <!-- The ID below informs the system that this application is compatible with OS features first introduced in Windows 10. 
+      It is necessary to support features in unpackaged applications, for example the custom titlebar implementation.
+      For more info see https://docs.microsoft.com/windows/apps/windows-app-sdk/use-windows-app-sdk-run-time#declare-os-compatibility-in-your-application-manifest -->
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
+    </application>
+  </compatibility>
+  
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
+    </windowsSettings>
+  </application>
+</assembly>
\ No newline at end of file
diff --git a/samples/WinUIEmbedSample/App.xaml b/samples/WinUIEmbedSample/App.xaml
new file mode 100644
index 0000000000..0bfa0c7b64
--- /dev/null
+++ b/samples/WinUIEmbedSample/App.xaml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Application
+    x:Class="WinUIEmbedSample.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:WinUIEmbedSample">
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>
diff --git a/samples/WinUIEmbedSample/App.xaml.cs b/samples/WinUIEmbedSample/App.xaml.cs
new file mode 100644
index 0000000000..6524572edd
--- /dev/null
+++ b/samples/WinUIEmbedSample/App.xaml.cs
@@ -0,0 +1,40 @@
+using global::Avalonia;
+using global::Avalonia.Controls;
+using global::Avalonia.Controls.ApplicationLifetimes;
+using global::Avalonia.Skia;
+using global::Avalonia.Win32;
+using WinUIApplication = Microsoft.UI.Xaml.Application;
+using LaunchActivatedEventArgs = Microsoft.UI.Xaml.LaunchActivatedEventArgs;
+using Window = Microsoft.UI.Xaml.Window;
+
+namespace WinUIEmbedSample
+{
+    public partial class App : WinUIApplication
+    {
+        private Window? _window;
+
+        internal static SingleViewLifetime Lifetime { get; } = new();
+
+        public App()
+        {
+            InitializeComponent();
+        }
+
+        protected override void OnLaunched(LaunchActivatedEventArgs args)
+        {
+            AppBuilder.Configure<AvaloniaApp>()
+                .UseWin32()
+                .UseSkia()
+                .UseHarfBuzz()
+                .SetupWithLifetime(Lifetime);
+
+            _window = new MainWindow();
+            _window.Activate();
+        }
+    }
+
+    internal sealed class SingleViewLifetime : ISingleViewApplicationLifetime
+    {
+        public Control? MainView { get; set; }
+    }
+}
diff --git a/samples/WinUIEmbedSample/AvaloniaApp.axaml b/samples/WinUIEmbedSample/AvaloniaApp.axaml
new file mode 100644
index 0000000000..03c11e5146
--- /dev/null
+++ b/samples/WinUIEmbedSample/AvaloniaApp.axaml
@@ -0,0 +1,7 @@
+<Application xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             x:Class="WinUIEmbedSample.AvaloniaApp">
+    <Application.Styles>
+        <FluentTheme />
+    </Application.Styles>
+</Application>
diff --git a/samples/WinUIEmbedSample/AvaloniaApp.axaml.cs b/samples/WinUIEmbedSample/AvaloniaApp.axaml.cs
new file mode 100644
index 0000000000..854a7bd186
--- /dev/null
+++ b/samples/WinUIEmbedSample/AvaloniaApp.axaml.cs
@@ -0,0 +1,13 @@
+using global::Avalonia;
+using global::Avalonia.Markup.Xaml;
+using AvApplication = global::Avalonia.Application;
+
+namespace WinUIEmbedSample;
+
+public partial class AvaloniaApp : AvApplication
+{
+    public override void Initialize()
+    {
+        AvaloniaXamlLoader.Load(this);
+    }
+}
diff --git a/samples/WinUIEmbedSample/EmbeddedView.axaml b/samples/WinUIEmbedSample/EmbeddedView.axaml
new file mode 100644
index 0000000000..9cfbd4cb1b
--- /dev/null
+++ b/samples/WinUIEmbedSample/EmbeddedView.axaml
@@ -0,0 +1,228 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             mc:Ignorable="d"
+             x:Class="WinUIEmbedSample.EmbeddedView">
+    <Border>
+        <ScrollViewer>
+            <StackPanel Margin="16" Spacing="8">
+                <TextBlock Text="Avalonia"
+                           FontSize="22"
+                           FontWeight="SemiBold"
+                           Margin="0,0,0,4" />
+
+                <Button x:Name="AvButton"
+                        Content="Avalonia button"
+                        HorizontalAlignment="Stretch"
+                        Click="OnAvButtonClick" />
+                <TextBlock x:Name="AvClickCount" Text="Clicked 0 times" />
+
+                <Slider x:Name="AvSlider"
+                        Minimum="0"
+                        Maximum="100"
+                        Value="25" />
+                <TextBlock x:Name="AvSliderValue" Text="Slider: 25" />
+
+                <TextBox PlaceholderText="Type something…"
+                         Text="Hello from Avalonia" />
+
+                <ToggleSwitch Content="ToggleSwitch" IsChecked="True" />
+
+                <TextBlock Text="Selection &amp; expand patterns"
+                           FontSize="16"
+                           FontWeight="SemiBold"
+                           Margin="0,16,0,0" />
+                <ComboBox x:Name="AvComboBox"
+                          PlaceholderText="Pick a color"
+                          HorizontalAlignment="Stretch">
+                    <ComboBoxItem Content="Red" />
+                    <ComboBoxItem Content="Green" />
+                    <ComboBoxItem Content="Blue" IsSelected="True" />
+                </ComboBox>
+                <ListBox x:Name="AvListBox"
+                         Height="100"
+                         SelectionMode="Single">
+                    <ListBoxItem Content="Item 1" />
+                    <ListBoxItem Content="Item 2" IsSelected="True" />
+                    <ListBoxItem Content="Item 3" />
+                    <ListBoxItem Content="Item 4" />
+                </ListBox>
+                <StackPanel Orientation="Horizontal" Spacing="8">
+                    <RadioButton x:Name="AvRadioOne" GroupName="DemoGroup" Content="Option A" IsChecked="True" />
+                    <RadioButton x:Name="AvRadioTwo" GroupName="DemoGroup" Content="Option B" />
+                    <RadioButton x:Name="AvRadioThree" GroupName="DemoGroup" Content="Option C" />
+                </StackPanel>
+                <Expander x:Name="AvExpander" Header="Expandable section">
+                    <StackPanel Spacing="4">
+                        <TextBlock Text="Content inside the expander." />
+                        <TextBlock Text="Used to verify ExpandCollapse pattern."
+                                   Opacity="0.7"
+                                   FontSize="12" />
+                    </StackPanel>
+                </Expander>
+                <TextBlock Text="Keys"
+                           FontSize="16"
+                           FontWeight="SemiBold"
+                           Margin="0,16,0,0" />
+                <Border BorderThickness="1"
+                        CornerRadius="4"
+                        Padding="8"
+                        Focusable="True"
+                        BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}"
+                        Background="{DynamicResource SystemControlBackgroundAltHighBrush}">
+                    <StackPanel Spacing="2">
+                        <TextBlock x:Name="KeyReadout"
+                                   FontFamily="Cascadia Code,Consolas,monospace"
+                                   Text="(focus here and press a key)" />
+                    </StackPanel>
+                </Border>
+
+                <TextBlock Text="Clipboard"
+                           FontSize="16"
+                           FontWeight="SemiBold"
+                           Margin="0,16,0,0" />
+                <TextBox x:Name="ClipboardText"
+                         Text="Hello clipboard" />
+                <StackPanel Orientation="Horizontal" Spacing="8">
+                    <Button Content="Copy" Click="OnClipboardCopy" />
+                    <Button Content="Paste" Click="OnClipboardPaste" />
+                    <TextBlock x:Name="ClipboardStatus"
+                               VerticalAlignment="Center"
+                               Opacity="0.7"
+                               Text="" />
+                </StackPanel>
+
+                <TextBlock Text="Drag source"
+                           FontSize="16"
+                           FontWeight="SemiBold"
+                           Margin="0,16,0,0" />
+                <Border x:Name="DragSourceBorder"
+                        Height="40"
+                        CornerRadius="4"
+                        BorderThickness="1"
+                        Padding="8"
+                        Cursor="SizeAll"
+                        BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}"
+                        Background="{DynamicResource SystemControlBackgroundAltHighBrush}">
+                    <TextBlock Text="Drag me — payload: &quot;Hello from Avalonia&quot;"
+                               VerticalAlignment="Center" />
+                </Border>
+
+                <TextBlock Text="Drop target"
+                           FontSize="16"
+                           FontWeight="SemiBold"
+                           Margin="0,16,0,0" />
+                <Border x:Name="DropTargetBorder"
+                        Height="80"
+                        CornerRadius="4"
+                        BorderThickness="1"
+                        Padding="8"
+                        BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}"
+                        Background="{DynamicResource SystemControlBackgroundAltHighBrush}">
+                    <TextBlock x:Name="DropStatus"
+                               Text="(drop something here)"
+                               TextWrapping="Wrap"
+                               VerticalAlignment="Center" />
+                </Border>
+
+                <TextBlock Text="Cursors"
+                           FontSize="16"
+                           FontWeight="SemiBold"
+                           Margin="0,16,0,0" />
+                <TextBlock Text="Hover each tile — the system cursor should change to match the label."
+                           TextWrapping="Wrap"
+                           Opacity="0.7" />
+                <UniformGrid Columns="4" Rows="2">
+                    <Border Margin="2" Padding="6" BorderThickness="1" CornerRadius="3"
+                            Cursor="Ibeam"
+                            BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}">
+                        <TextBlock Text="IBeam" HorizontalAlignment="Center" />
+                    </Border>
+                    <Border Margin="2" Padding="6" BorderThickness="1" CornerRadius="3"
+                            Cursor="Hand"
+                            BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}">
+                        <TextBlock Text="Hand" HorizontalAlignment="Center" />
+                    </Border>
+                    <Border Margin="2" Padding="6" BorderThickness="1" CornerRadius="3"
+                            Cursor="Cross"
+                            BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}">
+                        <TextBlock Text="Cross" HorizontalAlignment="Center" />
+                    </Border>
+                    <Border Margin="2" Padding="6" BorderThickness="1" CornerRadius="3"
+                            Cursor="Wait"
+                            BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}">
+                        <TextBlock Text="Wait" HorizontalAlignment="Center" />
+                    </Border>
+                    <Border Margin="2" Padding="6" BorderThickness="1" CornerRadius="3"
+                            Cursor="SizeAll"
+                            BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}">
+                        <TextBlock Text="SizeAll" HorizontalAlignment="Center" />
+                    </Border>
+                    <Border Margin="2" Padding="6" BorderThickness="1" CornerRadius="3"
+                            Cursor="SizeWestEast"
+                            BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}">
+                        <TextBlock Text="SizeWE" HorizontalAlignment="Center" />
+                    </Border>
+                    <Border Margin="2" Padding="6" BorderThickness="1" CornerRadius="3"
+                            Cursor="Help"
+                            BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}">
+                        <TextBlock Text="Help" HorizontalAlignment="Center" />
+                    </Border>
+                    <Border Margin="2" Padding="6" BorderThickness="1" CornerRadius="3"
+                            Cursor="No"
+                            BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}">
+                        <TextBlock Text="No" HorizontalAlignment="Center" />
+                    </Border>
+                </UniformGrid>
+
+                <TextBlock Text="Hover"
+                           FontSize="16"
+                           FontWeight="SemiBold"
+                           Margin="0,16,0,0" />
+                <Border x:Name="HoverPanel"
+                        Height="60"
+                        CornerRadius="4"
+                        BorderThickness="1"
+                        BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}"
+                        Background="{DynamicResource SystemControlBackgroundAltHighBrush}">
+                    <Border.Styles>
+                        <Style Selector="Border#HoverPanel:pointerover">
+                            <Setter Property="Background"
+                                    Value="{DynamicResource SystemControlBackgroundAccentBrush}" />
+                        </Style>
+                    </Border.Styles>
+                    <TextBlock x:Name="HoverState"
+                               Text="out"
+                               HorizontalAlignment="Center"
+                               VerticalAlignment="Center" />
+                </Border>
+
+                <TextBlock Text="Ink"
+                           FontSize="16"
+                           FontWeight="SemiBold"
+                           Margin="0,16,0,0" />
+                <Border Background="{DynamicResource SystemControlBackgroundAltHighBrush}"
+                        BorderBrush="{DynamicResource SystemControlForegroundBaseMediumLowBrush}"
+                        BorderThickness="1"
+                        CornerRadius="4"
+                        Height="240">
+                    <Canvas x:Name="InkCanvas"
+                            Background="Transparent"
+                            ClipToBounds="True"
+                            PointerPressed="OnInkPointerPressed"
+                            PointerMoved="OnInkPointerMoved"
+                            PointerReleased="OnInkPointerReleased" />
+                </Border>
+                <StackPanel Orientation="Horizontal" Spacing="8">
+                    <Button Content="Clear" Click="OnClearInk" />
+                    <TextBlock x:Name="InkStats"
+                               VerticalAlignment="Center"
+                               Opacity="0.7"
+                               Text="0 points / 0 intermediate" />
+                </StackPanel>
+
+            </StackPanel>
+        </ScrollViewer>
+    </Border>
+</UserControl>
diff --git a/samples/WinUIEmbedSample/EmbeddedView.axaml.cs b/samples/WinUIEmbedSample/EmbeddedView.axaml.cs
new file mode 100644
index 0000000000..0c918b0695
--- /dev/null
+++ b/samples/WinUIEmbedSample/EmbeddedView.axaml.cs
@@ -0,0 +1,183 @@
+using System.Linq;
+using global::Avalonia;
+using global::Avalonia.Controls;
+using global::Avalonia.Controls.Shapes;
+using global::Avalonia.Input;
+using global::Avalonia.Interactivity;
+using global::Avalonia.Markup.Xaml;
+using global::Avalonia.Markup.Xaml.MarkupExtensions;
+using global::Avalonia.Media;
+using global::Avalonia.Platform.Storage;
+
+namespace WinUIEmbedSample;
+
+public partial class EmbeddedView : UserControl
+{
+    private int _clicks;
+    private int _pointCount;
+    private int _intermediateCount;
+
+    public EmbeddedView()
+    {
+        InitializeComponent();
+        AvSlider.PropertyChanged += OnSliderPropertyChanged;
+        HoverPanel.PointerEntered += (_, _) => HoverState.Text = "over";
+        HoverPanel.PointerExited += (_, _) => HoverState.Text = "out";
+        AddHandler(KeyDownEvent, OnKeyReadout, handledEventsToo: true);
+
+        DragDrop.SetAllowDrop(DropTargetBorder, true);
+        DropTargetBorder.AddHandler(DragDrop.DragOverEvent, OnDropDragOver);
+        DropTargetBorder.AddHandler(DragDrop.DropEvent, OnDrop);
+
+        DragSourceBorder.PointerPressed += OnDragSourcePointerPressed;
+    }
+
+    private async void OnClipboardCopy(object? sender, RoutedEventArgs e)
+    {
+        var clipboard = TopLevel.GetTopLevel(this)?.Clipboard;
+        if (clipboard is null)
+        {
+            ClipboardStatus.Text = "no clipboard";
+            return;
+        }
+        var data = new global::Avalonia.Input.DataTransfer();
+        data.Add(DataTransferItem.CreateText(ClipboardText.Text ?? ""));
+        await clipboard.SetDataAsync(data);
+        ClipboardStatus.Text = $"copied {(ClipboardText.Text ?? "").Length} chars";
+    }
+
+    private async void OnClipboardPaste(object? sender, RoutedEventArgs e)
+    {
+        var clipboard = TopLevel.GetTopLevel(this)?.Clipboard;
+        if (clipboard is null)
+        {
+            ClipboardStatus.Text = "no clipboard";
+            return;
+        }
+        using var data = await clipboard.TryGetDataAsync();
+        var text = data is null ? null : await data.TryGetTextAsync();
+        if (text is not null)
+        {
+            ClipboardText.Text = text;
+            ClipboardStatus.Text = $"pasted {text.Length} chars";
+        }
+        else
+        {
+            ClipboardStatus.Text = "no text on clipboard";
+        }
+    }
+
+    private async void OnDragSourcePointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        var data = new global::Avalonia.Input.DataTransfer();
+        data.Add(DataTransferItem.CreateText("Hello from Avalonia"));
+        try
+        {
+            await DragDrop.DoDragDropAsync(e, data, DragDropEffects.Copy | DragDropEffects.Move);
+        }
+        catch
+        {
+            // Ignore — drag may be cancelled or the source unavailable.
+        }
+    }
+
+    private void OnDropDragOver(object? sender, DragEventArgs e)
+    {
+        e.DragEffects = e.DragEffects & (DragDropEffects.Copy | DragDropEffects.Link | DragDropEffects.Move);
+        if (e.DragEffects == DragDropEffects.None)
+            e.DragEffects = DragDropEffects.Copy;
+        e.Handled = true;
+    }
+
+    private void OnDrop(object? sender, DragEventArgs e)
+    {
+        var dt = e.DataTransfer;
+        var files = dt.TryGetValues(DataFormat.File)?.ToArray() ?? System.Array.Empty<IStorageItem>();
+        var text = dt.TryGetValue(DataFormat.Text);
+
+        if (files.Length > 0)
+            DropStatus.Text = $"{files.Length} file(s):\n" +
+                string.Join('\n', files.Select(f => f.Path.LocalPath));
+        else if (!string.IsNullOrEmpty(text))
+            DropStatus.Text = $"text: {text}";
+        else
+            DropStatus.Text = "(unknown payload)";
+
+        e.Handled = true;
+    }
+
+    private void OnKeyReadout(object? sender, KeyEventArgs e)
+    {
+        var symbol = e.KeySymbol is { Length: > 0 } s ? $"\"{s}\"" : "null";
+        KeyReadout.Text =
+            $"Key={e.Key}  Physical={e.PhysicalKey}  Symbol={symbol}\n" +
+            $"Modifiers={e.KeyModifiers}";
+    }
+
+    private void OnAvButtonClick(object? sender, RoutedEventArgs e)
+    {
+        AvClickCount.Text = $"Clicked {++_clicks} times";
+    }
+
+    private void OnSliderPropertyChanged(object? sender, AvaloniaPropertyChangedEventArgs e)
+    {
+        if (e.Property == Slider.ValueProperty)
+            AvSliderValue.Text = $"Slider: {AvSlider.Value:F0}";
+    }
+
+    private void OnInkPointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        AddDot(e.GetPosition(InkCanvas), Brushes.Red);
+        _pointCount++;
+        e.Pointer.Capture(InkCanvas);
+        UpdateStats();
+        e.Handled = true;
+    }
+
+    private void OnInkPointerMoved(object? sender, PointerEventArgs e)
+    {
+        var intermediates = e.GetIntermediatePoints(InkCanvas);
+        for (var i = 0; i < intermediates.Count; i++)
+            AddDot(intermediates[i].Position, Brushes.Orange);
+        _intermediateCount += intermediates.Count;
+
+        AddDot(e.GetPosition(InkCanvas), Brushes.Green);
+        _pointCount++;
+        UpdateStats();
+    }
+
+    private void OnInkPointerReleased(object? sender, PointerReleasedEventArgs e)
+    {
+        AddDot(e.GetPosition(InkCanvas), Brushes.Blue);
+        _pointCount++;
+        UpdateStats();
+        e.Handled = true;
+    }
+
+    private void AddDot(Point position, IBrush brush)
+    {
+        const double size = 6;
+        var dot = new Ellipse
+        {
+            Width = size,
+            Height = size,
+            Fill = brush,
+        };
+        Canvas.SetLeft(dot, position.X - size / 2);
+        Canvas.SetTop(dot, position.Y - size / 2);
+        InkCanvas.Children.Add(dot);
+    }
+
+    private void OnClearInk(object? sender, RoutedEventArgs e)
+    {
+        InkCanvas.Children.Clear();
+        _pointCount = 0;
+        _intermediateCount = 0;
+        UpdateStats();
+    }
+
+    private void UpdateStats()
+    {
+        InkStats.Text = $"{_pointCount} points / {_intermediateCount} intermediate";
+    }
+}
diff --git a/samples/WinUIEmbedSample/MainWindow.xaml b/samples/WinUIEmbedSample/MainWindow.xaml
new file mode 100644
index 0000000000..bc5f9daaf2
--- /dev/null
+++ b/samples/WinUIEmbedSample/MainWindow.xaml
@@ -0,0 +1,114 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Window
+    x:Class="WinUIEmbedSample.MainWindow"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:avalonia="using:Avalonia.WinUI"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    mc:Ignorable="d"
+    Title="WinUI + Avalonia side by side">
+
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="*" />
+            <ColumnDefinition Width="*" />
+        </Grid.ColumnDefinitions>
+
+        <!-- Left: native WinUI controls -->
+        <Border Grid.Column="0" Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
+            <ScrollViewer Padding="16">
+                <StackPanel Spacing="8">
+                    <TextBlock Text="WinUI"
+                               FontSize="22"
+                               FontWeight="SemiBold"
+                               Margin="0,0,0,4" />
+                  
+                    <Button x:Name="WinUiButton"
+                            Content="WinUI button"
+                            HorizontalAlignment="Stretch"
+                            Click="WinUiButton_Click" />
+                    <TextBlock x:Name="WinUiClickCount" Text="Clicked 0 times" />
+
+                    <Slider x:Name="WinUiSlider"
+                            Minimum="0"
+                            Maximum="100"
+                            Value="25"
+                            ValueChanged="WinUiSlider_ValueChanged" />
+                    <TextBlock x:Name="WinUiSliderValue" Text="Slider: 25" />
+
+                    <TextBox PlaceholderText="Type something…"
+                             Text="Hello from WinUI" />
+
+                    <ToggleSwitch Header="ToggleSwitch" IsOn="True" />
+
+                    <TextBlock Text="Drag source (native WinUI baseline)"
+                               FontWeight="SemiBold"
+                               Margin="0,16,0,0" />
+                    <TextBlock Text="Drag the box below — payload: 'Hello from WinUI'. Drop into Notepad, this TextBox, or the Avalonia drop target. Use this to compare against the Avalonia drag source."
+                               TextWrapping="Wrap"
+                               Opacity="0.7"
+                               FontSize="12" />
+                    <Border x:Name="WinUiDragSource"
+                            CanDrag="True"
+                            Height="40"
+                            BorderThickness="1"
+                            CornerRadius="4"
+                            Padding="8"
+                            DragStarting="WinUiDragSource_DragStarting"
+                            BorderBrush="{ThemeResource SystemControlForegroundBaseMediumLowBrush}"
+                            Background="{ThemeResource SystemControlBackgroundAltHighBrush}">
+                        <TextBlock Text="Drag me (native WinUI)"
+                                   VerticalAlignment="Center" />
+                    </Border>
+
+                    <TextBlock Text="Theme" Margin="0,8,0,0" />
+                    <ComboBox x:Name="WinUiThemeCombo"
+                              SelectedIndex="2"
+                              HorizontalAlignment="Stretch"
+                              SelectionChanged="WinUiThemeCombo_SelectionChanged">
+                        <x:String>Light</x:String>
+                        <x:String>Dark</x:String>
+                        <x:String>System</x:String>
+                    </ComboBox>
+
+                    <TextBlock Text="Automation diagnostics"
+                               FontWeight="SemiBold"
+                               Margin="0,16,0,0" />
+                    <TextBlock Text="Verifies the WinUI automation peer over the Avalonia content. Click Probe peer at different lifecycle points to confirm reachability; the scale readout updates live."
+                               TextWrapping="Wrap"
+                               Opacity="0.7"
+                               FontSize="12" />
+                    <Button x:Name="ProbePeerButton"
+                            Content="Probe peer + log children"
+                            HorizontalAlignment="Stretch"
+                            Click="ProbePeerButton_Click" />
+                    <Button x:Name="ProbeDeepButton"
+                            Content="Probe deep (walk full tree)"
+                            HorizontalAlignment="Stretch"
+                            Click="ProbeDeepButton_Click" />
+                    <Button x:Name="ProbeWorkerButton"
+                            Content="Probe deep on worker thread"
+                            HorizontalAlignment="Stretch"
+                            Click="ProbeWorkerButton_Click" />
+                    <TextBlock x:Name="ScaleReadout"
+                               Text="Scales: (waiting for Loaded)"
+                               FontFamily="Consolas"
+                               FontSize="12"
+                               TextWrapping="Wrap" />
+                    <TextBox x:Name="DiagnosticsLog"
+                             IsReadOnly="True"
+                             AcceptsReturn="True"
+                             TextWrapping="Wrap"
+                             FontFamily="Consolas"
+                             FontSize="11"
+                             Height="160"
+                             Text="" />
+                </StackPanel>
+            </ScrollViewer>
+        </Border>
+
+        <!-- Right: Avalonia content embedded via AvaloniaSwapChainPanel -->
+        <avalonia:AvaloniaSwapChainPanel Grid.Column="1" x:Name="AvaloniaPanel" />
+    </Grid>
+</Window>
diff --git a/samples/WinUIEmbedSample/MainWindow.xaml.cs b/samples/WinUIEmbedSample/MainWindow.xaml.cs
new file mode 100644
index 0000000000..9613b2da81
--- /dev/null
+++ b/samples/WinUIEmbedSample/MainWindow.xaml.cs
@@ -0,0 +1,175 @@
+using System;
+using System.Text;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Automation.Peers;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Controls.Primitives;
+using global::Avalonia.Styling;
+using AvApplication = global::Avalonia.Application;
+
+namespace WinUIEmbedSample
+{
+    public sealed partial class MainWindow : Microsoft.UI.Xaml.Window
+    {
+        private int _clicks;
+
+        public MainWindow()
+        {
+            InitializeComponent();
+
+            App.Lifetime.MainView = new EmbeddedView();
+            AvaloniaPanel.Content = App.Lifetime.MainView;
+
+            // Probe the automation peer *before* the panel is loaded — answers the
+            // open question of whether GetChildren() works before _root.Prepare().
+            AppendDiagnostic("ctor: " + DescribePeer());
+
+            AvaloniaPanel.Loading += (_, _) => AppendDiagnostic("Loading: " + DescribePeer());
+            AvaloniaPanel.Loaded += (_, _) =>
+            {
+                AppendDiagnostic("Loaded: " + DescribePeer());
+            };
+        }
+
+        private string DescribePeer()
+        {
+            try
+            {
+                var peer = FrameworkElementAutomationPeer.CreatePeerForElement(AvaloniaPanel);
+                if (peer is null)
+                    return "peer=null";
+                var children = peer.GetChildren();
+                var count = children?.Count ?? 0;
+                var sb = new StringBuilder();
+                sb.Append("peer=").Append(peer.GetType().Name)
+                  .Append(" class=").Append(peer.GetClassName())
+                  .Append(" childCount=").Append(count);
+                if (count > 0)
+                {
+                    sb.Append(" first=[");
+                    var first = children![0];
+                    sb.Append(first.GetClassName()).Append('/').Append(first.GetAutomationControlType());
+                    sb.Append("] firstChildren=").Append(first.GetChildren()?.Count ?? 0);
+                }
+                return sb.ToString();
+            }
+            catch (Exception ex)
+            {
+                return "threw: " + ex.GetType().Name + ": " + ex.Message;
+            }
+        }
+
+        private void ProbePeerButton_Click(object sender, RoutedEventArgs e)
+        {
+            AppendDiagnostic("Probe: " + DescribePeer());
+        }
+
+        private async void ProbeWorkerButton_Click(object sender, RoutedEventArgs e)
+        {
+            // Cache the peer on the UI thread (CreatePeerForElement is UI-thread bound).
+            var peer = FrameworkElementAutomationPeer.CreatePeerForElement(AvaloniaPanel);
+
+            // Walk on a worker thread — mimics how UIA queries (it calls from a separate thread).
+            var result = await System.Threading.Tasks.Task.Run(() =>
+            {
+                var sb = new StringBuilder();
+                sb.Append("Worker-thread walk (TID=").Append(Environment.CurrentManagedThreadId).Append("):\n");
+                try { WalkPeer(peer, 0, sb, maxDepth: 20); }
+                catch (Exception ex) { sb.Append("THREW: ").Append(ex); }
+                return sb.ToString();
+            });
+
+            AppendDiagnostic(result);
+        }
+
+        private void ProbeDeepButton_Click(object sender, RoutedEventArgs e)
+        {
+            try
+            {
+                var peer = FrameworkElementAutomationPeer.CreatePeerForElement(AvaloniaPanel);
+                var sb = new StringBuilder();
+                sb.Append("Deep walk:\n");
+                WalkPeer(peer, 0, sb, maxDepth: 20);
+                AppendDiagnostic(sb.ToString());
+            }
+            catch (Exception ex)
+            {
+                AppendDiagnostic("Deep probe threw: " + ex.Message);
+            }
+        }
+
+        private static void WalkPeer(AutomationPeer peer, int depth, StringBuilder sb, int maxDepth)
+        {
+            if (peer is null || depth > maxDepth)
+                return;
+
+            for (var i = 0; i < depth; i++) sb.Append("  ");
+            var className = peer.GetClassName();
+            var name = peer.GetName();
+            var type = peer.GetAutomationControlType();
+            var children = peer.GetChildren();
+            sb.Append('[').Append(className).Append(']')
+              .Append(" type=").Append(type)
+              .Append(" name=\"").Append(name).Append('"')
+              .Append(" children=").Append(children?.Count ?? 0)
+              .Append('\n');
+
+            if (children is null) return;
+            foreach (var child in children)
+                WalkPeer(child, depth + 1, sb, maxDepth);
+        }
+
+        private void AppendDiagnostic(string line)
+        {
+            if (DiagnosticsLog is null)
+                return;
+            DiagnosticsLog.Text += "[" + DateTime.Now.ToString("HH:mm:ss.fff") + "] " + line + "\n";
+        }
+
+        private void WinUiButton_Click(object sender, Microsoft.UI.Xaml.RoutedEventArgs e)
+        {
+            WinUiClickCount.Text = $"Clicked {++_clicks} times";
+        }
+
+        private void WinUiDragSource_DragStarting(
+            Microsoft.UI.Xaml.UIElement sender,
+            Microsoft.UI.Xaml.DragStartingEventArgs e)
+        {
+            e.Data.SetText("Hello from WinUI");
+            e.AllowedOperations =
+                Windows.ApplicationModel.DataTransfer.DataPackageOperation.Copy |
+                Windows.ApplicationModel.DataTransfer.DataPackageOperation.Move;
+        }
+
+        private void WinUiSlider_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
+        {
+            if (WinUiSliderValue is not null)
+                WinUiSliderValue.Text = $"Slider: {e.NewValue:F0}";
+        }
+
+        private void WinUiThemeCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
+        {
+            var selected = WinUiThemeCombo.SelectedIndex;
+
+            if (Content is FrameworkElement root)
+            {
+                root.RequestedTheme = selected switch
+                {
+                    0 => ElementTheme.Light,
+                    1 => ElementTheme.Dark,
+                    _ => ElementTheme.Default
+                };
+            }
+
+            if (AvApplication.Current is { } avApp)
+            {
+                avApp.RequestedThemeVariant = selected switch
+                {
+                    0 => ThemeVariant.Light,
+                    1 => ThemeVariant.Dark,
+                    _ => ThemeVariant.Default
+                };
+            }
+        }
+    }
+}
diff --git a/samples/WinUIEmbedSample/Package.appxmanifest b/samples/WinUIEmbedSample/Package.appxmanifest
new file mode 100644
index 0000000000..7601bc9f58
--- /dev/null
+++ b/samples/WinUIEmbedSample/Package.appxmanifest
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<Package
+  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
+  xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
+  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
+  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
+  IgnorableNamespaces="uap rescap">
+
+  <Identity
+    Name="9f5f4d4e-5b3a-4d7c-9c2a-1f0e1a2b3c4d"
+    Publisher="CN=AvaloniaUI"
+    Version="1.0.0.0" />
+
+  <mp:PhoneIdentity PhoneProductId="9f5f4d4e-5b3a-4d7c-9c2a-1f0e1a2b3c4d" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
+
+  <Properties>
+    <DisplayName>WinUIEmbedSample</DisplayName>
+    <PublisherDisplayName>AvaloniaUI</PublisherDisplayName>
+    <Logo>Assets\StoreLogo.png</Logo>
+  </Properties>
+
+  <Dependencies>
+    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26226.0" />
+    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26226.0" />
+  </Dependencies>
+
+  <Resources>
+    <Resource Language="x-generate"/>
+  </Resources>
+
+  <Applications>
+    <Application Id="App"
+      Executable="$targetnametoken$.exe"
+      EntryPoint="$targetentrypoint$">
+      <uap:VisualElements
+        DisplayName="WinUIEmbedSample"
+        Description="Side-by-side WinUI and Avalonia controls"
+        BackgroundColor="transparent"
+        Square150x150Logo="Assets\Square150x150Logo.png"
+        Square44x44Logo="Assets\Square44x44Logo.png">
+        <uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png" />
+        <uap:SplashScreen Image="Assets\SplashScreen.png" />
+      </uap:VisualElements>
+    </Application>
+  </Applications>
+
+  <Capabilities>
+    <rescap:Capability Name="runFullTrust" />
+  </Capabilities>
+</Package>
diff --git a/samples/WinUIEmbedSample/Properties/launchSettings.json b/samples/WinUIEmbedSample/Properties/launchSettings.json
new file mode 100644
index 0000000000..f4df532519
--- /dev/null
+++ b/samples/WinUIEmbedSample/Properties/launchSettings.json
@@ -0,0 +1,10 @@
+{
+  "profiles": {
+    "WinUIEmbedSample (Package)": {
+      "commandName": "MsixPackage"
+    },
+    "WinUIEmbedSample (Unpackaged)": {
+      "commandName": "Project"
+    }
+  }
+}
diff --git a/samples/WinUIEmbedSample/WinUIEmbedSample.csproj b/samples/WinUIEmbedSample/WinUIEmbedSample.csproj
new file mode 100644
index 0000000000..a19b06e24c
--- /dev/null
+++ b/samples/WinUIEmbedSample/WinUIEmbedSample.csproj
@@ -0,0 +1,66 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>$(AvsCurrentWinUITargetFramework)</TargetFramework>
+    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
+    <RootNamespace>WinUIEmbedSample</RootNamespace>
+    <ApplicationManifest>app.manifest</ApplicationManifest>
+    <Platforms>x86;x64;ARM64</Platforms>
+    <RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
+    <PublishProfile>win-$(Platform).pubxml</PublishProfile>
+    <UseWinUI>true</UseWinUI>
+    <WinUISDKReferences>false</WinUISDKReferences>
+    <EnableMsixTooling>true</EnableMsixTooling>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <IncludeAvaloniaGenerators>true</IncludeAvaloniaGenerators>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="..\ControlGallery.WinUI\Assets\SplashScreen.scale-200.png" Link="Assets\SplashScreen.scale-200.png" />
+    <Content Include="..\ControlGallery.WinUI\Assets\LockScreenLogo.scale-200.png" Link="Assets\LockScreenLogo.scale-200.png" />
+    <Content Include="..\ControlGallery.WinUI\Assets\Square150x150Logo.scale-200.png" Link="Assets\Square150x150Logo.scale-200.png" />
+    <Content Include="..\ControlGallery.WinUI\Assets\Square44x44Logo.scale-200.png" Link="Assets\Square44x44Logo.scale-200.png" />
+    <Content Include="..\ControlGallery.WinUI\Assets\Square44x44Logo.targetsize-24_altform-unplated.png" Link="Assets\Square44x44Logo.targetsize-24_altform-unplated.png" />
+    <Content Include="..\ControlGallery.WinUI\Assets\StoreLogo.png" Link="Assets\StoreLogo.png" />
+    <Content Include="..\ControlGallery.WinUI\Assets\Wide310x150Logo.scale-200.png" Link="Assets\Wide310x150Logo.scale-200.png" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Manifest Include="$(ApplicationManifest)" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(DisableMsixProjectCapabilityAddedByProject)'!='true' and '$(EnableMsixTooling)'=='true'">
+    <ProjectCapability Include="Msix" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Windows.SDK.BuildTools" />
+    <PackageReference Include="Microsoft.WindowsAppSDK" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\packages\Avalonia\Avalonia.csproj" />
+    <ProjectReference Include="..\..\src\Avalonia.Controls.ColorPicker\Avalonia.Controls.ColorPicker.csproj" />
+    <ProjectReference Include="..\..\src\Avalonia.Themes.Fluent\Avalonia.Themes.Fluent.csproj" />
+    <ProjectReference Include="..\..\src\Avalonia.Fonts.Inter\Avalonia.Fonts.Inter.csproj" />
+    <ProjectReference Include="..\..\src\Windows\Avalonia.Win32\Avalonia.Win32.csproj" />
+    <ProjectReference Include="..\..\src\Windows\Avalonia.WinUI\Avalonia.WinUI.csproj" />
+    <ProjectReference Include="..\..\src\HarfBuzz\Avalonia.HarfBuzz\Avalonia.HarfBuzz.csproj" />
+    <ProjectReference Include="..\..\src\Skia\Avalonia.Skia\Avalonia.Skia.csproj" />
+  </ItemGroup>
+
+  <Import Project="..\..\build\SourceGenerators.props" />
+  <Import Project="..\..\build\BuildTargets.targets" />
+
+  <PropertyGroup Condition="'$(DisableHasPackageAndPublishMenuAddedByProject)'!='true' and '$(EnableMsixTooling)'=='true'">
+    <HasPackageAndPublishMenu>true</HasPackageAndPublishMenu>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <PublishReadyToRun Condition="'$(Configuration)' == 'Debug'">False</PublishReadyToRun>
+    <PublishReadyToRun Condition="'$(Configuration)' != 'Debug'">True</PublishReadyToRun>
+    <PublishTrimmed Condition="'$(Configuration)' == 'Debug'">False</PublishTrimmed>
+    <PublishTrimmed Condition="'$(Configuration)' != 'Debug'">True</PublishTrimmed>
+  </PropertyGroup>
+</Project>
diff --git a/samples/WinUIEmbedSample/app.manifest b/samples/WinUIEmbedSample/app.manifest
new file mode 100644
index 0000000000..09e48a29d1
--- /dev/null
+++ b/samples/WinUIEmbedSample/app.manifest
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="1.0.0.0" name="WinUIEmbedSample.app"/>
+
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
+    </application>
+  </compatibility>
+
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
+    </windowsSettings>
+  </application>
+</assembly>
diff --git a/src/Avalonia.Base/Avalonia.Base.csproj b/src/Avalonia.Base/Avalonia.Base.csproj
index 99524857a7..69f5dd54fa 100644
--- a/src/Avalonia.Base/Avalonia.Base.csproj
+++ b/src/Avalonia.Base/Avalonia.Base.csproj
@@ -50,6 +50,7 @@
     <InternalsVisibleTo Include="Avalonia.Skia.UnitTests, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.UnitTests, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.Win32, PublicKey=$(AvaloniaPublicKey)" />
+    <InternalsVisibleTo Include="Avalonia.WinUI, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.Android, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.iOS, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.Tizen, PublicKey=$(AvaloniaPublicKey)" />
diff --git a/src/Avalonia.Base/Logging/LogArea.cs b/src/Avalonia.Base/Logging/LogArea.cs
index 07553a647e..36e2211581 100644
--- a/src/Avalonia.Base/Logging/LogArea.cs
+++ b/src/Avalonia.Base/Logging/LogArea.cs
@@ -49,6 +49,11 @@ namespace Avalonia.Logging
         /// The log event comes from Win32 Platform.
         /// </summary>
         public const string Win32Platform = nameof(Win32Platform);
+
+        /// <summary>
+        /// The log event comes from the WinUI Platform.
+        /// </summary>
+        public const string WinUIPlatform = nameof(WinUIPlatform);
         
         /// <summary>
         /// The log event comes from X11 Platform.
diff --git a/src/Windows/Avalonia.Win32/Avalonia.Win32.csproj b/src/Windows/Avalonia.Win32/Avalonia.Win32.csproj
index ea834e26a6..17796d2f9b 100644
--- a/src/Windows/Avalonia.Win32/Avalonia.Win32.csproj
+++ b/src/Windows/Avalonia.Win32/Avalonia.Win32.csproj
@@ -34,6 +34,7 @@
   </PropertyGroup>
   <ItemGroup>
     <InternalsVisibleTo Include="Avalonia.Win32.Interoperability, PublicKey=$(AvaloniaPublicKey)" />
+    <InternalsVisibleTo Include="Avalonia.WinUI, PublicKey=$(AvaloniaPublicKey)" />
   </ItemGroup>
   <ItemGroup>
     <!-- By default, any projects supports Windows, Linux, MacOS platforms. -->
diff --git a/src/Windows/Avalonia.Win32/OpenGl/Angle/SwapChainGlSurface.cs b/src/Windows/Avalonia.Win32/OpenGl/Angle/SwapChainGlSurface.cs
new file mode 100644
index 0000000000..9dfd692da3
--- /dev/null
+++ b/src/Windows/Avalonia.Win32/OpenGl/Angle/SwapChainGlSurface.cs
@@ -0,0 +1,252 @@
+using System;
+using System.Runtime.InteropServices;
+using Avalonia.OpenGL;
+using Avalonia.OpenGL.Egl;
+using Avalonia.OpenGL.Surfaces;
+using Avalonia.Platform;
+using Avalonia.Win32.DirectX;
+using MicroCom.Runtime;
+
+namespace Avalonia.Win32.OpenGl.Angle;
+
+internal unsafe class SwapChainGlSurface : EglGlPlatformSurfaceBase
+{
+    // QI for IDXGISwapChain2 fails on some Windows builds even though
+    // IDXGISwapChain3/4 succeed. Use IDXGISwapChain3 which inherits from
+    // IDXGISwapChain2 and has SetMatrixTransform at the same vtable slot.
+    private static readonly Guid IDXGISwapChain3Guid = new("94d99bdb-f1f8-4ab0-b236-7da0170edab1");
+
+    [DllImport("dxgi.dll", ExactSpelling = true)]
+    private static extern int CreateDXGIFactory2(uint Flags, in Guid riid, out IntPtr ppFactory);
+
+    private readonly Func<PixelSize> _getSizeFunc;
+    private readonly Func<double> _getScalingFunc;
+    private readonly Action<IntPtr> _setSwapChainCallback;
+    private IDXGISwapChain1? _swapChain;
+    private IntPtr _swapChain3Ptr;
+
+    public SwapChainGlSurface(
+        Func<PixelSize> getSizeFunc,
+        Func<double> getScalingFunc,
+        Action<IntPtr> setSwapChainCallback)
+    {
+        _getSizeFunc = getSizeFunc;
+        _getScalingFunc = getScalingFunc;
+        _setSwapChainCallback = setSwapChainCallback;
+    }
+
+    public override IGlPlatformSurfaceRenderTarget CreateGlRenderTarget(IGlContext context)
+    {
+        var eglContext = (EglContext)context;
+
+        if (_swapChain is null)
+        {
+            _swapChain = CreateSwapChain(eglContext);
+
+            var swapChainPtr = MicroComRuntime.GetNativeIntPtr(_swapChain);
+            var guid = IDXGISwapChain3Guid;
+            var qiHr = Marshal.QueryInterface(swapChainPtr, in guid, out _swapChain3Ptr);
+            if (qiHr != 0 || _swapChain3Ptr == IntPtr.Zero)
+                throw new InvalidOperationException(
+                    $"QI for IDXGISwapChain3 failed: HR=0x{qiHr:X8}, ptr={_swapChain3Ptr}");
+
+            SetInverseScaleTransform(_getScalingFunc());
+
+            _setSwapChainCallback(swapChainPtr);
+        }
+
+        return new SwapChainGlRenderTarget(eglContext, _swapChain, _getSizeFunc, _getScalingFunc, _swapChain3Ptr, this);
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct DXGI_MATRIX_3X2_F
+    {
+        public float _11, _12;
+        public float _21, _22;
+        public float _31, _32;
+    }
+
+    internal void SetInverseScaleTransform(double scaling)
+    {
+        if (_swapChain3Ptr == IntPtr.Zero || scaling <= 0)
+            return;
+
+        var inverseScale = new DXGI_MATRIX_3X2_F
+        {
+            _11 = 1.0f / (float)scaling,
+            _22 = 1.0f / (float)scaling
+        };
+
+        // IDXGISwapChain2::SetMatrixTransform vtable slot:
+        // IUnknown(3) + IDXGIObject(4) + IDXGIDeviceSubObject(1) +
+        // IDXGISwapChain(10) + IDXGISwapChain1(11) +
+        // SetSourceSize, GetSourceSize, SetMaximumFrameLatency,
+        // GetMaximumFrameLatency, GetFrameLatencyWaitableObject = 5
+        // → SetMatrixTransform is at slot 34
+        var vtable = *(IntPtr**)_swapChain3Ptr;
+        var setMatrixTransform = (delegate* unmanaged[Stdcall]<IntPtr, DXGI_MATRIX_3X2_F*, int>)vtable[34];
+        var hr = setMatrixTransform(_swapChain3Ptr, &inverseScale);
+        Marshal.ThrowExceptionForHR(hr);
+    }
+
+    private IDXGISwapChain1 CreateSwapChain(EglContext eglContext)
+    {
+        var eglDisplay = (AngleWin32EglDisplay)eglContext.Display;
+        var d3dDevicePtr = eglDisplay.GetDirect3DDevice();
+        var d3dDevice = MicroComRuntime.CreateProxyFor<IUnknown>(d3dDevicePtr, false);
+
+        IDXGIDevice dxgiDevice;
+        using (d3dDevice)
+            dxgiDevice = d3dDevice.QueryInterface<IDXGIDevice>();
+
+        Guid factoryGuid = MicroComRuntime.GetGuidFor(typeof(IDXGIFactory2));
+        var hr = CreateDXGIFactory2(0, in factoryGuid, out var factoryPtr);
+        Marshal.ThrowExceptionForHR(hr);
+        var dxgiFactory = MicroComRuntime.CreateProxyFor<IDXGIFactory2>(factoryPtr, true);
+
+        var pixelSize = _getSizeFunc();
+        var desc = new DXGI_SWAP_CHAIN_DESC1
+        {
+            Format = DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_UNORM,
+            SampleDesc = new DXGI_SAMPLE_DESC { Count = 1, Quality = 0 },
+            BufferUsage = DxgiRenderTarget.DXGI_USAGE_RENDER_TARGET_OUTPUT,
+            BufferCount = 2,
+            SwapEffect = DXGI_SWAP_EFFECT.DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL,
+            AlphaMode = DXGI_ALPHA_MODE.DXGI_ALPHA_MODE_PREMULTIPLIED,
+            Width = (uint)pixelSize.Width,
+            Height = (uint)pixelSize.Height,
+            Flags = 0
+        };
+
+        var swapChain = dxgiFactory.CreateSwapChainForComposition(dxgiDevice, &desc, null);
+
+        dxgiFactory.Dispose();
+        dxgiDevice.Dispose();
+
+        return swapChain;
+    }
+
+    public void DisposeSwapChain()
+    {
+        if (_swapChain3Ptr != IntPtr.Zero)
+        {
+            Marshal.Release(_swapChain3Ptr);
+            _swapChain3Ptr = IntPtr.Zero;
+        }
+        _swapChain?.Dispose();
+        _swapChain = null;
+    }
+}
+
+internal unsafe class SwapChainGlRenderTarget : EglPlatformSurfaceRenderTargetBase
+{
+    private static readonly Guid ID3D11Texture2DGuid = Guid.Parse("6F15AAF2-D208-4E89-9AB4-489535D34F9C");
+
+    private readonly IDXGISwapChain1 _swapChain;
+    private readonly Func<PixelSize> _getSizeFunc;
+    private readonly Func<double> _getScalingFunc;
+    private readonly IntPtr _swapChain3Ptr;
+    private readonly SwapChainGlSurface _owner;
+
+    private IUnknown? _renderTexture;
+    private EglSurface? _surface;
+    private PixelSize _lastSize;
+    private double _lastScaling;
+
+    public SwapChainGlRenderTarget(
+        EglContext context,
+        IDXGISwapChain1 swapChain,
+        Func<PixelSize> getSizeFunc,
+        Func<double> getScalingFunc,
+        IntPtr swapChain3Ptr,
+        SwapChainGlSurface owner) : base(context)
+    {
+        _swapChain = swapChain;
+        _getSizeFunc = getSizeFunc;
+        _getScalingFunc = getScalingFunc;
+        _swapChain3Ptr = swapChain3Ptr;
+        _owner = owner;
+    }
+
+    public override IGlPlatformSurfaceRenderingSession BeginDrawCore(IRenderTarget.RenderTargetSceneInfo sceneInfo)
+    {
+        var contextLock = Context.EnsureCurrent();
+        var success = false;
+        try
+        {
+            var size = _getSizeFunc();
+            var scaling = _getScalingFunc();
+
+            if (scaling != _lastScaling)
+            {
+                _owner.SetInverseScaleTransform(scaling);
+                _lastScaling = scaling;
+            }
+
+            if (size != _lastSize)
+            {
+                _surface?.Dispose();
+                _surface = null;
+                _renderTexture?.Dispose();
+                _renderTexture = null;
+
+                _swapChain.ResizeBuffers(2,
+                    (ushort)size.Width,
+                    (ushort)size.Height,
+                    DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_UNORM,
+                    0);
+
+                _lastSize = size;
+            }
+
+            if (_renderTexture is null)
+            {
+                _surface?.Dispose();
+                _surface = null;
+
+                Guid textureGuid = ID3D11Texture2DGuid;
+                _renderTexture = MicroComRuntime.CreateProxyFor<IUnknown>(
+                    _swapChain.GetBuffer(0, &textureGuid), true);
+            }
+
+            if (_surface is null)
+            {
+                _surface = ((AngleWin32EglDisplay)Context.Display).WrapDirect3D11Texture(
+                    MicroComRuntime.GetNativeIntPtr(_renderTexture),
+                    0, 0, size.Width, size.Height);
+            }
+
+            var res = base.BeginDraw(_surface, size, scaling, () =>
+            {
+                try
+                {
+                    _swapChain.Present(1, 0);
+                }
+                finally
+                {
+                    contextLock?.Dispose();
+                }
+            }, true);
+            success = true;
+            return res;
+        }
+        finally
+        {
+            if (!success)
+            {
+                _surface?.Dispose();
+                _surface = null;
+                _renderTexture?.Dispose();
+                _renderTexture = null;
+                contextLock.Dispose();
+            }
+        }
+    }
+
+    public override void Dispose()
+    {
+        base.Dispose();
+        _surface?.Dispose();
+        _renderTexture?.Dispose();
+    }
+}
diff --git a/src/Windows/Avalonia.Win32/SwapChainTopLevelImpl.cs b/src/Windows/Avalonia.Win32/SwapChainTopLevelImpl.cs
new file mode 100644
index 0000000000..15ea304709
--- /dev/null
+++ b/src/Windows/Avalonia.Win32/SwapChainTopLevelImpl.cs
@@ -0,0 +1,122 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using Avalonia.Input.Raw;
+using Avalonia.Input.TextInput;
+using Avalonia.OpenGL.Surfaces;
+using Avalonia.Platform;
+using Avalonia.Platform.Surfaces;
+using Avalonia.Rendering.Composition;
+
+namespace Avalonia.Win32;
+
+/// <summary>
+/// A minimal <see cref="ITopLevelImpl"/> that hosts an Avalonia content tree on top of an
+/// externally managed swap-chain surface (e.g. a WinUI <c>SwapChainPanel</c> or any other
+/// host that supplies an <see cref="IGlPlatformSurface"/>). Sizing, scaling and input
+/// pumping are driven by the host.
+/// </summary>
+internal class SwapChainTopLevelImpl : ITopLevelImpl
+{
+    private readonly IGlPlatformSurface _glSurface;
+    private Size _clientSize;
+    private double _scaling = 1.0;
+
+    public SwapChainTopLevelImpl(IGlPlatformSurface glSurface)
+    {
+        _glSurface = glSurface;
+        var platformGraphics = AvaloniaLocator.Current.GetService<IPlatformGraphics>();
+        Compositor = new Compositor(platformGraphics);
+    }
+
+    public Size ClientSize
+    {
+        get => _clientSize;
+        set
+        {
+            _clientSize = value;
+            Resized?.Invoke(value, WindowResizeReason.Unspecified);
+        }
+    }
+
+    public double RenderScaling
+    {
+        get => _scaling;
+        set
+        {
+            _scaling = value;
+            ScalingChanged?.Invoke(value);
+        }
+    }
+
+    public double DesktopScaling => _scaling;
+
+    public IPlatformHandle? Handle => null;
+
+    public Compositor Compositor { get; }
+
+    public IPlatformRenderSurface[] Surfaces => [_glSurface];
+
+    public Action<RawInputEventArgs>? Input { get; set; }
+
+    public Action<Rect>? Paint { get; set; }
+
+    public Action<Size, WindowResizeReason>? Resized { get; set; }
+
+    public Action<double>? ScalingChanged { get; set; }
+
+    public Action<WindowTransparencyLevel>? TransparencyLevelChanged { get; set; }
+
+    public Action? Closed { get; set; }
+
+    public Action? LostFocus { get; set; }
+
+    public WindowTransparencyLevel TransparencyLevel => WindowTransparencyLevel.None;
+
+    public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } = new(1, 1, 1);
+
+    public IInputRoot? InputRoot { get; private set; }
+
+    public void SetInputRoot(IInputRoot inputRoot) => InputRoot = inputRoot;
+
+    public Point PointToClient(PixelPoint point) => point.ToPoint(_scaling);
+
+    public PixelPoint PointToScreen(Point point) => PixelPoint.FromPoint(point, _scaling);
+
+    /// <summary>
+    /// Raised when Avalonia requests a cursor change. The host is responsible
+    /// for translating the (host-supplied) <see cref="ICursorImpl"/> into a
+    /// native cursor and applying it to its surface.
+    /// </summary>
+    public Action<ICursorImpl?>? CursorChanged { get; set; }
+
+    public void SetCursor(ICursorImpl? cursor) => CursorChanged?.Invoke(cursor);
+
+    // Uses overlays instead of popups.
+    public IPopupImpl? CreatePopup() => null;
+
+    public void SetTransparencyLevelHint(IReadOnlyList<WindowTransparencyLevel> transparencyLevels) { }
+
+    public void SetFrameThemeVariant(PlatformThemeVariant themeVariant) { }
+
+    /// <summary>
+    /// Optional IME implementation provided by the host.
+    /// </summary>
+    public ITextInputMethodImpl? TextInputMethod { get; set; }
+
+    public object? TryGetFeature(Type featureType)
+    {
+        if (featureType == typeof(IClipboard))
+            return AvaloniaLocator.Current.GetService<IClipboard>();
+        if (featureType == typeof(ITextInputMethodImpl))
+            return TextInputMethod;
+        return null;
+    }
+
+    public void Dispose()
+    {
+        Closed?.Invoke();
+    }
+}
diff --git a/src/Windows/Avalonia.WinUI/Automation/AvaloniaSwapChainPanelAutomationPeer.cs b/src/Windows/Avalonia.WinUI/Automation/AvaloniaSwapChainPanelAutomationPeer.cs
new file mode 100644
index 0000000000..4b6159a546
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/Automation/AvaloniaSwapChainPanelAutomationPeer.cs
@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using global::Avalonia.Automation.Provider;
+using Microsoft.UI.Xaml.Automation.Peers;
+using AvPeer = global::Avalonia.Automation.Peers.AutomationPeer;
+using AvControlPeer = global::Avalonia.Automation.Peers.ControlAutomationPeer;
+using XamlAutomationPeer = Microsoft.UI.Xaml.Automation.Peers.AutomationPeer;
+using XamlPoint = global::Windows.Foundation.Point;
+using AvPoint = global::Avalonia.Point;
+using AvRect = global::Avalonia.Rect;
+
+namespace Avalonia.WinUI.Automation;
+
+internal sealed partial class AvaloniaSwapChainPanelAutomationPeer : FrameworkElementAutomationPeer
+{
+    private readonly AvaloniaSwapChainPanel _panel;
+    private IEmbeddedRootProvider? _embeddedRoot;
+    private AvPeer? _embeddedRootPeer;
+
+    public AvaloniaSwapChainPanelAutomationPeer(AvaloniaSwapChainPanel panel) : base(panel)
+    {
+        _panel = panel;
+    }
+
+    internal AvaloniaSwapChainPanel Panel => _panel;
+
+    protected override string GetClassNameCore() => nameof(AvaloniaSwapChainPanel);
+
+    protected override AutomationControlType GetAutomationControlTypeCore() => AutomationControlType.Pane;
+
+    protected override IList<XamlAutomationPeer> GetChildrenCore()
+    {
+        var list = base.GetChildrenCore() ?? new List<XamlAutomationPeer>();
+
+        if (TryGetEmbeddedRootPeer() is { } rootPeer)
+        {
+            var proxy = AvaloniaToXamlPeerProxy.GetOrCreate(rootPeer, this);
+            proxy.SetParent(this);
+            list.Add(proxy);
+        }
+
+        return list;
+    }
+
+    protected override object GetFocusedElementCore()
+    {
+        EnsureSubscribed();
+        var focused = _embeddedRoot?.GetFocus();
+        return focused is null
+            ? base.GetFocusedElementCore()
+            : AvaloniaToXamlPeerProxy.GetOrCreate(focused, this);
+    }
+
+    protected override object GetElementFromPointCore(XamlPoint point)
+    {
+        EnsureSubscribed();
+        var hit = _embeddedRoot?.GetPeerFromPoint(new AvPoint(point.X, point.Y));
+        return hit is null
+            ? base.GetElementFromPointCore(point)
+            : AvaloniaToXamlPeerProxy.GetOrCreate(hit, this);
+    }
+
+    /// <summary>
+    /// Translate an Avalonia rectangle (in embedded-root coordinates) to screen pixels.
+    /// </summary>
+    internal (double x, double y, double width, double height) TransformAvaloniaRectToScreen(AvRect rect)
+    {
+        var transform = _panel.TransformToVisual(null);
+        var topLeft = transform.TransformPoint(new XamlPoint(rect.X, rect.Y));
+        var bottomRight = transform.TransformPoint(new XamlPoint(rect.Right, rect.Bottom));
+
+        var xamlRoot = _panel.XamlRoot;
+        var scale = xamlRoot?.RasterizationScale ?? 1.0;
+
+        var x = topLeft.X * scale;
+        var y = topLeft.Y * scale;
+        var w = (bottomRight.X - topLeft.X) * scale;
+        var h = (bottomRight.Y - topLeft.Y) * scale;
+
+        if (xamlRoot?.ContentIslandEnvironment is { } island)
+        {
+            var hwnd = Microsoft.UI.Win32Interop.GetWindowFromWindowId(island.AppWindowId);
+            if (hwnd != IntPtr.Zero)
+            {
+                var pt = new POINT { x = 0, y = 0 };
+                if (ClientToScreen(hwnd, ref pt))
+                {
+                    x += pt.x;
+                    y += pt.y;
+                }
+            }
+        }
+
+        return (x, y, w, h);
+    }
+
+    private AvPeer? TryGetEmbeddedRootPeer()
+    {
+        EnsureSubscribed();
+        return _embeddedRootPeer;
+    }
+
+    private void EnsureSubscribed()
+    {
+        if (_embeddedRootPeer is not null)
+            return;
+
+        var root = _panel.GetEmbeddedRootForAutomation();
+        if (root is null)
+            return;
+
+        _embeddedRootPeer = AvControlPeer.CreatePeerForElement(root);
+        _embeddedRoot = _embeddedRootPeer.GetProvider<IEmbeddedRootProvider>();
+
+        if (_embeddedRoot is not null)
+            _embeddedRoot.FocusChanged += OnEmbeddedFocusChanged;
+    }
+
+    private void OnEmbeddedFocusChanged(object? sender, EventArgs e)
+    {
+        if (!ListenerExists(AutomationEvents.AutomationFocusChanged))
+            return;
+
+        var focused = _embeddedRoot?.GetFocus();
+        if (focused is null)
+            return;
+
+        var proxy = AvaloniaToXamlPeerProxy.GetOrCreate(focused, this);
+        proxy.RaiseAutomationEvent(AutomationEvents.AutomationFocusChanged);
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct POINT
+    {
+        public int x;
+        public int y;
+    }
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool ClientToScreen(IntPtr hWnd, ref POINT lpPoint);
+}
diff --git a/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.ExpandCollapse.cs b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.ExpandCollapse.cs
new file mode 100644
index 0000000000..8bf2e34058
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.ExpandCollapse.cs
@@ -0,0 +1,29 @@
+using Microsoft.UI.Xaml.Automation;
+using Microsoft.UI.Xaml.Automation.Provider;
+using AvExpand = global::Avalonia.Automation.Provider.IExpandCollapseProvider;
+using AvExpandState = global::Avalonia.Automation.ExpandCollapseState;
+
+namespace Avalonia.WinUI.Automation;
+
+internal sealed partial class AvaloniaToXamlPeerProxy : IExpandCollapseProvider
+{
+    ExpandCollapseState IExpandCollapseProvider.ExpandCollapseState
+    {
+        get
+        {
+            var provider = _peer.GetProvider<AvExpand>();
+            if (provider is null)
+                return ExpandCollapseState.LeafNode;
+            return provider.ExpandCollapseState switch
+            {
+                AvExpandState.Collapsed => ExpandCollapseState.Collapsed,
+                AvExpandState.Expanded => ExpandCollapseState.Expanded,
+                AvExpandState.PartiallyExpanded => ExpandCollapseState.PartiallyExpanded,
+                _ => ExpandCollapseState.LeafNode,
+            };
+        }
+    }
+
+    void IExpandCollapseProvider.Expand() => _peer.GetProvider<AvExpand>()?.Expand();
+    void IExpandCollapseProvider.Collapse() => _peer.GetProvider<AvExpand>()?.Collapse();
+}
diff --git a/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Invoke.cs b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Invoke.cs
new file mode 100644
index 0000000000..93e9857b19
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Invoke.cs
@@ -0,0 +1,9 @@
+using Microsoft.UI.Xaml.Automation.Provider;
+using AvInvoke = global::Avalonia.Automation.Provider.IInvokeProvider;
+
+namespace Avalonia.WinUI.Automation;
+
+internal sealed partial class AvaloniaToXamlPeerProxy : IInvokeProvider
+{
+    void IInvokeProvider.Invoke() => _peer.GetProvider<AvInvoke>()?.Invoke();
+}
diff --git a/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.RangeValue.cs b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.RangeValue.cs
new file mode 100644
index 0000000000..71466b4baf
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.RangeValue.cs
@@ -0,0 +1,16 @@
+using Microsoft.UI.Xaml.Automation.Provider;
+using AvRange = global::Avalonia.Automation.Provider.IRangeValueProvider;
+
+namespace Avalonia.WinUI.Automation;
+
+internal sealed partial class AvaloniaToXamlPeerProxy : IRangeValueProvider
+{
+    bool IRangeValueProvider.IsReadOnly => _peer.GetProvider<AvRange>()?.IsReadOnly ?? true;
+    double IRangeValueProvider.Minimum => _peer.GetProvider<AvRange>()?.Minimum ?? 0;
+    double IRangeValueProvider.Maximum => _peer.GetProvider<AvRange>()?.Maximum ?? 0;
+    double IRangeValueProvider.Value => _peer.GetProvider<AvRange>()?.Value ?? 0;
+    double IRangeValueProvider.LargeChange => _peer.GetProvider<AvRange>()?.LargeChange ?? 0;
+    double IRangeValueProvider.SmallChange => _peer.GetProvider<AvRange>()?.SmallChange ?? 0;
+
+    void IRangeValueProvider.SetValue(double value) => _peer.GetProvider<AvRange>()?.SetValue(value);
+}
diff --git a/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Scroll.cs b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Scroll.cs
new file mode 100644
index 0000000000..65bc5507e0
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Scroll.cs
@@ -0,0 +1,33 @@
+using Microsoft.UI.Xaml.Automation;
+using Microsoft.UI.Xaml.Automation.Provider;
+using AvScroll = global::Avalonia.Automation.Provider.IScrollProvider;
+using AvScrollAmount = global::Avalonia.Automation.Provider.ScrollAmount;
+
+namespace Avalonia.WinUI.Automation;
+
+internal sealed partial class AvaloniaToXamlPeerProxy : IScrollProvider, IScrollItemProvider
+{
+    bool IScrollProvider.HorizontallyScrollable => _peer.GetProvider<AvScroll>()?.HorizontallyScrollable ?? false;
+    double IScrollProvider.HorizontalScrollPercent => _peer.GetProvider<AvScroll>()?.HorizontalScrollPercent ?? -1;
+    double IScrollProvider.HorizontalViewSize => _peer.GetProvider<AvScroll>()?.HorizontalViewSize ?? 100;
+    bool IScrollProvider.VerticallyScrollable => _peer.GetProvider<AvScroll>()?.VerticallyScrollable ?? false;
+    double IScrollProvider.VerticalScrollPercent => _peer.GetProvider<AvScroll>()?.VerticalScrollPercent ?? -1;
+    double IScrollProvider.VerticalViewSize => _peer.GetProvider<AvScroll>()?.VerticalViewSize ?? 100;
+
+    void IScrollProvider.Scroll(ScrollAmount horizontalAmount, ScrollAmount verticalAmount)
+        => _peer.GetProvider<AvScroll>()?.Scroll(ToAvalonia(horizontalAmount), ToAvalonia(verticalAmount));
+
+    void IScrollProvider.SetScrollPercent(double horizontalPercent, double verticalPercent)
+        => _peer.GetProvider<AvScroll>()?.SetScrollPercent(horizontalPercent, verticalPercent);
+
+    void IScrollItemProvider.ScrollIntoView() => _peer.BringIntoView();
+
+    private static AvScrollAmount ToAvalonia(ScrollAmount amount) => amount switch
+    {
+        ScrollAmount.LargeDecrement => AvScrollAmount.LargeDecrement,
+        ScrollAmount.SmallDecrement => AvScrollAmount.SmallDecrement,
+        ScrollAmount.LargeIncrement => AvScrollAmount.LargeIncrement,
+        ScrollAmount.SmallIncrement => AvScrollAmount.SmallIncrement,
+        _ => AvScrollAmount.NoAmount,
+    };
+}
diff --git a/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Selection.cs b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Selection.cs
new file mode 100644
index 0000000000..b544ca6528
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Selection.cs
@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.UI.Xaml.Automation.Peers;
+using Microsoft.UI.Xaml.Automation.Provider;
+using AvPeer = global::Avalonia.Automation.Peers.AutomationPeer;
+using AvSelection = global::Avalonia.Automation.Provider.ISelectionProvider;
+using AvSelectionItem = global::Avalonia.Automation.Provider.ISelectionItemProvider;
+
+namespace Avalonia.WinUI.Automation;
+
+internal sealed partial class AvaloniaToXamlPeerProxy : ISelectionProvider, ISelectionItemProvider
+{
+    bool ISelectionProvider.CanSelectMultiple => _peer.GetProvider<AvSelection>()?.CanSelectMultiple ?? false;
+    bool ISelectionProvider.IsSelectionRequired => _peer.GetProvider<AvSelection>()?.IsSelectionRequired ?? false;
+
+    IRawElementProviderSimple[] ISelectionProvider.GetSelection()
+    {
+        var provider = _peer.GetProvider<AvSelection>();
+        if (provider is null)
+            return System.Array.Empty<IRawElementProviderSimple>();
+
+        var list = new List<IRawElementProviderSimple>();
+        foreach (var avChild in provider.GetSelection() ?? (IReadOnlyList<AvPeer>)System.Array.Empty<AvPeer>())
+        {
+            var proxy = GetOrCreate(avChild, _host);
+            if (ProviderFromPeer(proxy) is IRawElementProviderSimple simple)
+                list.Add(simple);
+        }
+        return list.ToArray();
+    }
+
+    bool ISelectionItemProvider.IsSelected => _peer.GetProvider<AvSelectionItem>()?.IsSelected ?? false;
+
+    IRawElementProviderSimple? ISelectionItemProvider.SelectionContainer
+    {
+        get
+        {
+            var container = _peer.GetProvider<AvSelectionItem>()?.SelectionContainer;
+            if (container is AvPeer containerPeer)
+            {
+                var proxy = GetOrCreate(containerPeer, _host);
+                return ProviderFromPeer(proxy);
+            }
+            return null;
+        }
+    }
+
+    void ISelectionItemProvider.AddToSelection() => _peer.GetProvider<AvSelectionItem>()?.AddToSelection();
+    void ISelectionItemProvider.RemoveFromSelection() => _peer.GetProvider<AvSelectionItem>()?.RemoveFromSelection();
+    void ISelectionItemProvider.Select() => _peer.GetProvider<AvSelectionItem>()?.Select();
+}
diff --git a/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Toggle.cs b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Toggle.cs
new file mode 100644
index 0000000000..520dc111ad
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Toggle.cs
@@ -0,0 +1,27 @@
+using Microsoft.UI.Xaml.Automation;
+using Microsoft.UI.Xaml.Automation.Provider;
+using AvToggle = global::Avalonia.Automation.Provider.IToggleProvider;
+using AvToggleState = global::Avalonia.Automation.Provider.ToggleState;
+
+namespace Avalonia.WinUI.Automation;
+
+internal sealed partial class AvaloniaToXamlPeerProxy : IToggleProvider
+{
+    ToggleState IToggleProvider.ToggleState
+    {
+        get
+        {
+            var provider = _peer.GetProvider<AvToggle>();
+            if (provider is null)
+                return ToggleState.Indeterminate;
+            return provider.ToggleState switch
+            {
+                AvToggleState.Off => ToggleState.Off,
+                AvToggleState.On => ToggleState.On,
+                _ => ToggleState.Indeterminate,
+            };
+        }
+    }
+
+    void IToggleProvider.Toggle() => _peer.GetProvider<AvToggle>()?.Toggle();
+}
diff --git a/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Value.cs b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Value.cs
new file mode 100644
index 0000000000..926a5554b1
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.Value.cs
@@ -0,0 +1,13 @@
+using Microsoft.UI.Xaml.Automation.Provider;
+using AvValue = global::Avalonia.Automation.Provider.IValueProvider;
+
+namespace Avalonia.WinUI.Automation;
+
+internal sealed partial class AvaloniaToXamlPeerProxy : IValueProvider
+{
+    bool IValueProvider.IsReadOnly => _peer.GetProvider<AvValue>()?.IsReadOnly ?? true;
+
+    string IValueProvider.Value => _peer.GetProvider<AvValue>()?.Value ?? string.Empty;
+
+    void IValueProvider.SetValue(string value) => _peer.GetProvider<AvValue>()?.SetValue(value);
+}
diff --git a/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.cs b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.cs
new file mode 100644
index 0000000000..18b97964ef
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/Automation/AvaloniaToXamlPeerProxy.cs
@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using global::Avalonia.Controls.Automation.Peers;
+using Microsoft.UI.Xaml.Automation;
+using Microsoft.UI.Xaml.Automation.Peers;
+using AvPeer = global::Avalonia.Automation.Peers.AutomationPeer;
+using XamlAutomationPeer = Microsoft.UI.Xaml.Automation.Peers.AutomationPeer;
+using XamlRect = global::Windows.Foundation.Rect;
+
+namespace Avalonia.WinUI.Automation;
+
+/// <summary>
+/// Wraps an Avalonia <see cref="AvPeer"/> so it can be exposed to Microsoft UI Automation
+/// through WinUI XAML's automation infrastructure. Mirrors the role of
+/// <c>Avalonia.Win32.Automation.AutomationNode</c> but for WinUI hosts.
+/// </summary>
+internal sealed partial class AvaloniaToXamlPeerProxy : XamlAutomationPeer
+{
+    private static readonly ConditionalWeakTable<AvPeer, AvaloniaToXamlPeerProxy> s_cache = new();
+    private static long s_nextId;
+
+    private readonly AvaloniaSwapChainPanelAutomationPeer _host;
+    private readonly AvPeer _peer;
+    private readonly bool _isEmbeddedRoot;
+    private readonly string _uniqueId;
+
+    private AvaloniaToXamlPeerProxy(AvPeer peer, AvaloniaSwapChainPanelAutomationPeer host)
+    {
+        _peer = peer;
+        _host = host;
+        _isEmbeddedRoot = peer is EmbeddableControlRootAutomationPeer;
+        _uniqueId = "Avalonia.WinUI.Peer:" + System.Threading.Interlocked.Increment(ref s_nextId).ToString(
+            System.Globalization.CultureInfo.InvariantCulture);
+    }
+
+    internal AvPeer Peer => _peer;
+
+    public static AvaloniaToXamlPeerProxy GetOrCreate(AvPeer peer, AvaloniaSwapChainPanelAutomationPeer host)
+    {
+        return s_cache.GetValue(peer, p => new AvaloniaToXamlPeerProxy(p, host));
+    }
+
+    internal static AvaloniaToXamlPeerProxy? TryGet(AvPeer? peer)
+    {
+        if (peer is null)
+            return null;
+        return s_cache.TryGetValue(peer, out var proxy) ? proxy : null;
+    }
+
+    protected override IList<XamlAutomationPeer> GetChildrenCore()
+    {
+        var list = new List<XamlAutomationPeer>();
+        var children = _peer.GetChildren();
+        if (children is null)
+            return list;
+
+        foreach (var child in children)
+        {
+            var childProxy = GetOrCreate(child, _host);
+            childProxy.SetParent(this);
+            list.Add(childProxy);
+        }
+
+        return list;
+    }
+
+    protected override string GetClassNameCore() => _peer.GetClassName() ?? string.Empty;
+
+    protected override string GetNameCore() => _peer.GetName() ?? string.Empty;
+
+    protected override string GetAutomationIdCore() => _peer.GetAutomationId() ?? string.Empty;
+
+    protected override string GetHelpTextCore() => _peer.GetHelpText() ?? string.Empty;
+
+    protected override string GetAcceleratorKeyCore() => _peer.GetAcceleratorKey() ?? string.Empty;
+
+    protected override string GetAccessKeyCore() => _peer.GetAccessKey() ?? string.Empty;
+
+    protected override string GetItemStatusCore() => _peer.GetItemStatus() ?? string.Empty;
+
+    protected override string GetItemTypeCore() => _peer.GetItemType() ?? string.Empty;
+
+    protected override string GetLocalizedControlTypeCore()
+        => _peer.GetLocalizedControlType() ?? base.GetLocalizedControlTypeCore();
+
+    protected override AutomationControlType GetAutomationControlTypeCore()
+        => ControlTypeMap.ToXaml(_peer.GetAutomationControlType());
+
+    protected override XamlRect GetBoundingRectangleCore()
+    {
+        var rect = _peer.GetBoundingRectangle();
+        if (rect.Width <= 0 && rect.Height <= 0)
+            return default;
+
+        var (screenX, screenY, w, h) = _host.TransformAvaloniaRectToScreen(rect);
+        return new XamlRect(screenX, screenY, w, h);
+    }
+
+    protected override bool HasKeyboardFocusCore() => _peer.HasKeyboardFocus();
+
+    protected override bool IsKeyboardFocusableCore() => _peer.IsKeyboardFocusable();
+
+    protected override bool IsEnabledCore() => _peer.IsEnabled();
+
+    // Collapse the redundant Pane → Pane: the embedded root sits beneath the
+    // panel's own peer and adds nothing to the screen reader's view.
+    protected override bool IsContentElementCore() => !_isEmbeddedRoot && _peer.IsContentElement();
+
+    protected override bool IsControlElementCore() => !_isEmbeddedRoot && _peer.IsControlElement();
+
+    protected override bool IsOffscreenCore() => _peer.IsOffscreen();
+
+    protected override void SetFocusCore() => _peer.SetFocus();
+
+    protected override object GetPatternCore(PatternInterface patternInterface)
+    {
+        return patternInterface switch
+        {
+            PatternInterface.Invoke
+                when _peer.GetProvider<global::Avalonia.Automation.Provider.IInvokeProvider>() is not null => this,
+            PatternInterface.Toggle
+                when _peer.GetProvider<global::Avalonia.Automation.Provider.IToggleProvider>() is not null => this,
+            PatternInterface.Value
+                when _peer.GetProvider<global::Avalonia.Automation.Provider.IValueProvider>() is not null => this,
+            PatternInterface.RangeValue
+                when _peer.GetProvider<global::Avalonia.Automation.Provider.IRangeValueProvider>() is not null => this,
+            PatternInterface.Scroll
+                when _peer.GetProvider<global::Avalonia.Automation.Provider.IScrollProvider>() is not null => this,
+            // Every peer supports BringIntoView, so ScrollItem is always available.
+            PatternInterface.ScrollItem => this,
+            PatternInterface.Selection
+                when _peer.GetProvider<global::Avalonia.Automation.Provider.ISelectionProvider>() is not null => this,
+            PatternInterface.SelectionItem
+                when _peer.GetProvider<global::Avalonia.Automation.Provider.ISelectionItemProvider>() is not null => this,
+            PatternInterface.ExpandCollapse
+                when _peer.GetProvider<global::Avalonia.Automation.Provider.IExpandCollapseProvider>() is not null => this,
+            _ => null!,
+        };
+    }
+}
diff --git a/src/Windows/Avalonia.WinUI/Automation/ControlTypeMap.cs b/src/Windows/Avalonia.WinUI/Automation/ControlTypeMap.cs
new file mode 100644
index 0000000000..43bd221054
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/Automation/ControlTypeMap.cs
@@ -0,0 +1,52 @@
+using AvControlType = global::Avalonia.Automation.Peers.AutomationControlType;
+using XamlControlType = Microsoft.UI.Xaml.Automation.Peers.AutomationControlType;
+
+namespace Avalonia.WinUI.Automation;
+
+internal static class ControlTypeMap
+{
+    public static XamlControlType ToXaml(AvControlType type) => type switch
+    {
+        AvControlType.Button => XamlControlType.Button,
+        AvControlType.Calendar => XamlControlType.Calendar,
+        AvControlType.CheckBox => XamlControlType.CheckBox,
+        AvControlType.ComboBox => XamlControlType.ComboBox,
+        AvControlType.ComboBoxItem => XamlControlType.ListItem,
+        AvControlType.Edit => XamlControlType.Edit,
+        AvControlType.Hyperlink => XamlControlType.Hyperlink,
+        AvControlType.Image => XamlControlType.Image,
+        AvControlType.ListItem => XamlControlType.ListItem,
+        AvControlType.List => XamlControlType.List,
+        AvControlType.Menu => XamlControlType.Menu,
+        AvControlType.MenuBar => XamlControlType.MenuBar,
+        AvControlType.MenuItem => XamlControlType.MenuItem,
+        AvControlType.ProgressBar => XamlControlType.ProgressBar,
+        AvControlType.RadioButton => XamlControlType.RadioButton,
+        AvControlType.ScrollBar => XamlControlType.ScrollBar,
+        AvControlType.Slider => XamlControlType.Slider,
+        AvControlType.Spinner => XamlControlType.Spinner,
+        AvControlType.StatusBar => XamlControlType.StatusBar,
+        AvControlType.Tab => XamlControlType.Tab,
+        AvControlType.TabItem => XamlControlType.TabItem,
+        AvControlType.Text => XamlControlType.Text,
+        AvControlType.ToolBar => XamlControlType.ToolBar,
+        AvControlType.ToolTip => XamlControlType.ToolTip,
+        AvControlType.Tree => XamlControlType.Tree,
+        AvControlType.TreeItem => XamlControlType.TreeItem,
+        AvControlType.Group => XamlControlType.Group,
+        AvControlType.Thumb => XamlControlType.Thumb,
+        AvControlType.DataGrid => XamlControlType.DataGrid,
+        AvControlType.DataItem => XamlControlType.DataItem,
+        AvControlType.Document => XamlControlType.Document,
+        AvControlType.SplitButton => XamlControlType.SplitButton,
+        AvControlType.Window => XamlControlType.Window,
+        AvControlType.Pane => XamlControlType.Pane,
+        AvControlType.Header => XamlControlType.Header,
+        AvControlType.HeaderItem => XamlControlType.HeaderItem,
+        AvControlType.Table => XamlControlType.Table,
+        AvControlType.TitleBar => XamlControlType.TitleBar,
+        AvControlType.Separator => XamlControlType.Separator,
+        AvControlType.Expander => XamlControlType.Group,
+        _ => XamlControlType.Custom,
+    };
+}
diff --git a/src/Windows/Avalonia.WinUI/Avalonia.WinUI.csproj b/src/Windows/Avalonia.WinUI/Avalonia.WinUI.csproj
new file mode 100644
index 0000000000..ac25b8ca75
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/Avalonia.WinUI.csproj
@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>$(AvsCurrentWinUITargetFramework)</TargetFramework>
+    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
+    <UseWinUI>true</UseWinUI>
+    <WinUISDKReferences>false</WinUISDKReferences>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <EnableRuntimeMarshalling>true</EnableRuntimeMarshalling>
+    <Nullable>enable</Nullable>
+    <PackageDescription>Windows App SDK (WinUI 3) integration for Avalonia, enabling Avalonia content to be hosted inside WinUI applications on Windows.</PackageDescription>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Windows.SDK.BuildTools" />
+    <PackageReference Include="Microsoft.WindowsAppSDK" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\packages\Avalonia\Avalonia.csproj" />
+    <ProjectReference Include="..\Avalonia.Win32\Avalonia.Win32.csproj" />
+  </ItemGroup>
+  <Import Project="..\..\..\build\NullableEnable.props" />
+  <Import Project="..\..\..\build\DevAnalyzers.props" />
+  <Import Project="..\..\..\build\TrimmingEnable.props" />
+  <PropertyGroup Label="Warnings">
+    <NoWarn>$(NoWarn);CA1416</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+    <SupportedPlatform Remove="@(SupportedPlatform)" />
+    <SupportedPlatform Include="Windows" />
+  </ItemGroup>
+</Project>
diff --git a/src/Windows/Avalonia.WinUI/AvaloniaSwapChainPanel.cs b/src/Windows/Avalonia.WinUI/AvaloniaSwapChainPanel.cs
new file mode 100644
index 0000000000..3494305e31
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/AvaloniaSwapChainPanel.cs
@@ -0,0 +1,915 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+using global::Avalonia;
+using global::Avalonia.Controls.Embedding;
+using global::Avalonia.Input;
+using global::Avalonia.Input.Raw;
+using global::Avalonia.Logging;
+using global::Avalonia.Platform;
+using global::Avalonia.Win32;
+using global::Avalonia.Win32.OpenGl.Angle;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Input;
+using Windows.Foundation;
+using Microsoft.UI.Input;
+using WinUIPointerPoint = Microsoft.UI.Input.PointerPoint;
+using AvControl = global::Avalonia.Controls.Control;
+using AvSize = global::Avalonia.Size;
+using AvPoint = global::Avalonia.Point;
+using AvVector = global::Avalonia.Vector;
+using AvRect = global::Avalonia.Rect;
+
+namespace Avalonia.WinUI;
+
+public partial class AvaloniaSwapChainPanel : SwapChainPanel
+{
+    private SwapChainGlSurface? _glSurface;
+    private SwapChainTopLevelImpl? _topLevelImpl;
+    private EmbeddableControlRoot? _root;
+    private AvControl? _content;
+    private readonly MouseDevice _mouseDevice = new();
+    private readonly TouchDevice _touchDevice = new();
+    private readonly PenDevice _penDevice = new(releasePointerOnPenUp: false);
+    private PixelSize _cachedPixelSize = new(1, 1);
+    private double _cachedScaling = 1.0;
+
+    private static readonly List<RawPointerPoint> s_intermediatePoints = new();
+
+    private WinUITextInputMethod? _textInputMethod;
+    private bool _ignoreCharacterReceived;
+
+    private readonly CursorOverlay _cursorOverlay;
+
+    // ProtectedCursor is protected on UIElement; derive to expose it.
+    private sealed partial class CursorOverlay : Microsoft.UI.Xaml.Controls.Grid
+    {
+        public void SetCursor(Microsoft.UI.Input.InputCursor? cursor) => ProtectedCursor = cursor;
+    }
+
+    static AvaloniaSwapChainPanel()
+    {
+        AvaloniaLocator.CurrentMutable
+            .Bind<global::Avalonia.Input.Platform.IPlatformDragSource>()
+            .ToSingleton<WinUIDragSource>();
+    }
+
+    // Looking up panels from the drag source: keyed by the Avalonia toplevel
+    // PlatformImpl so multi-panel hosts work.
+    private static readonly System.Collections.Concurrent.ConcurrentDictionary<
+        global::Avalonia.Platform.ITopLevelImpl, AvaloniaSwapChainPanel> s_panelsByImpl = new();
+
+    internal static AvaloniaSwapChainPanel? GetPanelFor(global::Avalonia.Platform.ITopLevelImpl impl)
+        => s_panelsByImpl.TryGetValue(impl, out var p) ? p : null;
+
+    // Most recent WinUI PointerPoint observed by the panel — needed by
+    // StartDragAsync. Avalonia's IPointer.Id is assigned sequentially and
+    // does not correspond to WinUI's PointerId, so we can't look up per
+    // pointer; the latest is good enough for the dominant mouse-drag case.
+    private WinUIPointerPoint? _lastPointerPoint;
+
+    // Cleared in DragStarting and OnUnloaded.
+    private IDataTransfer? _outgoingDragData;
+    private DragDropEffects _outgoingDragAllowed;
+
+    public AvaloniaSwapChainPanel()
+    {
+        IsTabStop = true;
+        // SwapChainPanel disallows Background, but without a hit-testable
+        // surface WinUI won't resolve ProtectedCursor for the panel. Add a
+        // transparent overlay that fills the panel — it costs nothing
+        // visually but participates in cursor hit-testing.
+        _cursorOverlay = new CursorOverlay
+        {
+            Background = new Microsoft.UI.Xaml.Media.SolidColorBrush(Microsoft.UI.Colors.Transparent),
+            IsHitTestVisible = true,
+            AllowDrop = true,
+            CanDrag = true,
+        };
+        _cursorOverlay.DragEnter += OnDragEnter;
+        _cursorOverlay.DragOver += OnDragOver;
+        _cursorOverlay.DragLeave += OnDragLeave;
+        _cursorOverlay.Drop += OnDrop;
+        _cursorOverlay.DragStarting += OnDragStarting;
+        Children.Add(_cursorOverlay);
+
+        Loaded += OnLoaded;
+        Unloaded += OnUnloaded;
+        SizeChanged += OnSizeChanged;
+        CompositionScaleChanged += OnCompositionScaleChanged;
+
+        PointerPressed += OnPointerPressed;
+        PointerMoved += OnPointerMoved;
+        PointerReleased += OnPointerReleased;
+        PointerWheelChanged += OnPointerWheelChanged;
+        PointerCanceled += OnPointerCanceled;
+        PointerEntered += OnPointerEntered;
+        PointerExited += OnPointerExited;
+        GotFocus += OnGotFocus;
+        LostFocus += OnLostFocus;
+        AddHandler(KeyDownEvent, new KeyEventHandler(OnKeyDown), handledEventsToo: true);
+        AddHandler(KeyUpEvent, new KeyEventHandler(OnKeyUp), handledEventsToo: true);
+        AddHandler(CharacterReceivedEvent,
+            new TypedEventHandler<UIElement, CharacterReceivedRoutedEventArgs>(OnCharacterReceived),
+            handledEventsToo: true);
+    }
+
+    public AvControl? Content
+    {
+        get => _content;
+        set
+        {
+            _content = value;
+            if (_root is not null)
+                _root.Content = value;
+        }
+    }
+
+    protected override Microsoft.UI.Xaml.Automation.Peers.AutomationPeer OnCreateAutomationPeer()
+        => new global::Avalonia.WinUI.Automation.AvaloniaSwapChainPanelAutomationPeer(this);
+
+    // ---- Diagnostics / internal automation hooks ----
+
+    /// <summary>
+    /// Returns the embedded control root, or null if the panel has not loaded yet.
+    /// Used by the automation peer to enumerate Avalonia children; also exposed as
+    /// a diagnostic surface for WinUIEmbedSample to verify peer lifecycle.
+    /// </summary>
+    internal global::Avalonia.Controls.Embedding.EmbeddableControlRoot? GetEmbeddedRootForAutomation() => _root;
+
+    private void UpdateCachedSize()
+    {
+        var w = Math.Max(1, (int)(ActualWidth * CompositionScaleX));
+        var h = Math.Max(1, (int)(ActualHeight * CompositionScaleY));
+        _cachedPixelSize = new PixelSize(w, h);
+        _cachedScaling = CompositionScaleX;
+    }
+
+    private PixelSize GetPixelSize() => _cachedPixelSize;
+
+    private double GetScaling() => _cachedScaling;
+
+    private void OnLoaded(object sender, RoutedEventArgs e)
+    {
+        if (_glSurface is not null)
+            return;
+
+        UpdateCachedSize();
+
+        // Create the GL surface — swap chain creation is deferred to CreateGlRenderTarget
+        // where we have the actual rendering context's D3D device
+        _glSurface = new SwapChainGlSurface(GetPixelSize, GetScaling, OnSwapChainCreated);
+        _topLevelImpl = new SwapChainTopLevelImpl(_glSurface)
+        {
+            ClientSize = new AvSize(ActualWidth, ActualHeight),
+            RenderScaling = CompositionScaleX
+        };
+
+        _textInputMethod = new WinUITextInputMethod(
+            this,
+            () => _topLevelImpl?.Input,
+            () => _topLevelImpl?.InputRoot,
+            () => AvaloniaLocator.Current.GetService<IKeyboardDevice>());
+        _topLevelImpl.TextInputMethod = _textInputMethod;
+        _topLevelImpl.CursorChanged = OnAvaloniaCursorChanged;
+
+        // Create and start the EmbeddableControlRoot
+        _root = new EmbeddableControlRoot(_topLevelImpl)
+        {
+            Content = _content
+        };
+        _root.Prepare();
+        _root.StartRendering();
+
+        s_panelsByImpl[_topLevelImpl] = this;
+    }
+
+    private unsafe void OnSwapChainCreated(IntPtr swapChainPtr)
+    {
+        // Called from the render thread when the swap chain is first created.
+        // Set it on the panel via ISwapChainPanelNative COM interop.
+        DispatcherQueue.TryEnqueue(() =>
+        {
+            var panelUnknown = Marshal.GetIUnknownForObject(this);
+            try
+            {
+                var iid = new Guid("63aad0b8-7c24-40ff-85a8-640d944cc325");
+                Marshal.QueryInterface(panelUnknown, in iid, out var nativePtr);
+                if (nativePtr != IntPtr.Zero)
+                {
+                    try
+                    {
+                        var vtable = *(IntPtr**)nativePtr;
+                        var setSwapChain = (delegate* unmanaged[Stdcall]<IntPtr, IntPtr, int>)vtable[3];
+                        var hr = setSwapChain(nativePtr, swapChainPtr);
+                        Marshal.ThrowExceptionForHR(hr);
+                    }
+                    finally
+                    {
+                        Marshal.Release(nativePtr);
+                    }
+                }
+            }
+            finally
+            {
+                Marshal.Release(panelUnknown);
+            }
+        });
+    }
+
+    private void OnUnloaded(object sender, RoutedEventArgs e)
+    {
+        if (_topLevelImpl is not null)
+            s_panelsByImpl.TryRemove(_topLevelImpl, out _);
+        _root?.StopRendering();
+        _root?.Dispose();
+        _root = null;
+        _topLevelImpl = null;
+        _glSurface?.DisposeSwapChain();
+        _glSurface = null;
+        _mouseDevice.Dispose();
+        _touchDevice.Dispose();
+        _penDevice.Dispose();
+    }
+
+    private void OnSizeChanged(object sender, SizeChangedEventArgs e)
+    {
+        UpdateCachedSize();
+        if (_topLevelImpl is not null)
+            _topLevelImpl.ClientSize = new AvSize(e.NewSize.Width, e.NewSize.Height);
+    }
+
+    private void OnCompositionScaleChanged(SwapChainPanel sender, object args)
+    {
+        UpdateCachedSize();
+        if (_topLevelImpl is not null)
+            _topLevelImpl.RenderScaling = CompositionScaleX;
+    }
+
+    // Input forwarding
+
+    private IPointerDevice GetPointerDevice(PointerRoutedEventArgs e)
+    {
+        return e.Pointer.PointerDeviceType switch
+        {
+            Microsoft.UI.Input.PointerDeviceType.Touch => _touchDevice,
+            Microsoft.UI.Input.PointerDeviceType.Pen => _penDevice,
+            _ => _mouseDevice
+        };
+    }
+
+    private static RawPointerPoint CreateRawPointerPoint(WinUIPointerPoint point)
+    {
+        var props = point.Properties;
+        var pos = point.Position;
+
+        var rawPoint = new RawPointerPoint
+        {
+            Position = new AvPoint(pos.X, pos.Y),
+            Pressure = props.Pressure,
+            Twist = props.Twist,
+            XTilt = props.XTilt,
+            YTilt = props.YTilt,
+        };
+
+        if (props.ContactRect is { Width: > 0 } or { Height: > 0 })
+        {
+            var cr = props.ContactRect;
+            rawPoint.ContactRect = new AvRect(cr.X, cr.Y, cr.Width, cr.Height);
+        }
+
+        return rawPoint;
+    }
+
+    private RawPointerEventArgs CreatePointerArgs(
+        IInputDevice device, ulong timestamp, IInputRoot inputRoot,
+        RawPointerEventType type, RawPointerPoint point,
+        RawInputModifiers modifiers, uint pointerId)
+    {
+        return device is TouchDevice
+            ? new RawTouchEventArgs(device, timestamp, inputRoot, type, point, modifiers, pointerId)
+            : new RawPointerEventArgs(device, timestamp, inputRoot, type, point, modifiers)
+            {
+                RawPointerId = pointerId
+            };
+    }
+
+    private ulong GetTimestamp(PointerRoutedEventArgs e)
+    {
+        // WinUI PointerPoint.Timestamp is in microseconds; Avalonia expects milliseconds.
+        return e.GetCurrentPoint(this).Timestamp / 1000;
+    }
+
+    private RawInputModifiers GetPointerModifiers(PointerRoutedEventArgs e)
+    {
+        var point = e.GetCurrentPoint(this);
+        var props = point.Properties;
+        var mods = WinUIKeyInterop.ModifiersFromVirtualKeyModifiers(e.KeyModifiers);
+        if (props.IsLeftButtonPressed)
+            mods |= RawInputModifiers.LeftMouseButton;
+        if (props.IsRightButtonPressed)
+            mods |= RawInputModifiers.RightMouseButton;
+        if (props.IsMiddleButtonPressed)
+            mods |= RawInputModifiers.MiddleMouseButton;
+
+        if (e.Pointer.PointerDeviceType == Microsoft.UI.Input.PointerDeviceType.Pen)
+        {
+            if (props.IsBarrelButtonPressed)
+                mods |= RawInputModifiers.PenBarrelButton;
+            if (props.IsEraser)
+                mods |= RawInputModifiers.PenEraser;
+            if (props.IsInverted)
+                mods |= RawInputModifiers.PenInverted;
+        }
+
+        return mods;
+    }
+
+    private void OnPointerPressed(object sender, PointerRoutedEventArgs e)
+    {
+        _lastPointerPoint = e.GetCurrentPoint(this);
+        if (_topLevelImpl?.Input is not { } input || _topLevelImpl.InputRoot is not { } inputRoot)
+            return;
+
+        var device = GetPointerDevice(e);
+        var timestamp = GetTimestamp(e);
+        var rawPoint = CreateRawPointerPoint(e.GetCurrentPoint(this));
+        var modifiers = GetPointerModifiers(e);
+        var pointerId = e.Pointer.PointerId;
+
+        RawPointerEventType type;
+        if (device is TouchDevice)
+        {
+            type = RawPointerEventType.TouchBegin;
+        }
+        else
+        {
+            var point = e.GetCurrentPoint(this);
+            var props = point.Properties;
+            if (props.IsLeftButtonPressed)
+                type = RawPointerEventType.LeftButtonDown;
+            else if (props.IsRightButtonPressed)
+                type = RawPointerEventType.RightButtonDown;
+            else if (props.IsMiddleButtonPressed)
+                type = RawPointerEventType.MiddleButtonDown;
+            else
+                return;
+        }
+
+        Focus(FocusState.Pointer);
+        CapturePointer(e.Pointer);
+
+        input(CreatePointerArgs(device, timestamp, inputRoot, type, rawPoint, modifiers, pointerId));
+        e.Handled = true;
+    }
+
+    private void OnPointerMoved(object sender, PointerRoutedEventArgs e)
+    {
+        _lastPointerPoint = e.GetCurrentPoint(this);
+        if (_topLevelImpl?.Input is not { } input || _topLevelImpl.InputRoot is not { } inputRoot)
+            return;
+
+        var device = GetPointerDevice(e);
+        var timestamp = GetTimestamp(e);
+        var rawPoint = CreateRawPointerPoint(e.GetCurrentPoint(this));
+        var modifiers = GetPointerModifiers(e);
+        var pointerId = e.Pointer.PointerId;
+
+        var type = device is TouchDevice ? RawPointerEventType.TouchUpdate : RawPointerEventType.Move;
+
+        var args = CreatePointerArgs(device, timestamp, inputRoot, type, rawPoint, modifiers, pointerId);
+        args.IntermediatePoints = new Lazy<IReadOnlyList<RawPointerPoint>?>(() => GetIntermediatePoints(e));
+        input(args);
+    }
+
+    private IReadOnlyList<RawPointerPoint>? GetIntermediatePoints(PointerRoutedEventArgs e)
+    {
+        // WinUI returns the points oldest-first and includes the current point as the
+        // last entry; drop that last entry (it is the one we already dispatched).
+        var coalesced = e.GetIntermediatePoints(this);
+        if (coalesced is null || coalesced.Count <= 1)
+            return null;
+
+        s_intermediatePoints.Clear();
+        if (s_intermediatePoints.Capacity < coalesced.Count - 1)
+            s_intermediatePoints.Capacity = coalesced.Count - 1;
+
+        for (var i = 0; i < coalesced.Count - 1; i++)
+            s_intermediatePoints.Add(CreateRawPointerPoint(coalesced[i]));
+
+        return s_intermediatePoints;
+    }
+
+    private void OnPointerReleased(object sender, PointerRoutedEventArgs e)
+    {
+        if (_topLevelImpl?.Input is not { } input || _topLevelImpl.InputRoot is not { } inputRoot)
+            return;
+
+        var device = GetPointerDevice(e);
+        var timestamp = GetTimestamp(e);
+        var rawPoint = CreateRawPointerPoint(e.GetCurrentPoint(this));
+        var modifiers = GetPointerModifiers(e);
+        var pointerId = e.Pointer.PointerId;
+
+        RawPointerEventType type;
+        if (device is TouchDevice)
+        {
+            type = RawPointerEventType.TouchEnd;
+        }
+        else
+        {
+            var point = e.GetCurrentPoint(this);
+            var props = point.Properties;
+            switch (props.PointerUpdateKind)
+            {
+                case Microsoft.UI.Input.PointerUpdateKind.LeftButtonReleased:
+                    type = RawPointerEventType.LeftButtonUp;
+                    break;
+                case Microsoft.UI.Input.PointerUpdateKind.RightButtonReleased:
+                    type = RawPointerEventType.RightButtonUp;
+                    break;
+                case Microsoft.UI.Input.PointerUpdateKind.MiddleButtonReleased:
+                    type = RawPointerEventType.MiddleButtonUp;
+                    break;
+                default:
+                    return;
+            }
+        }
+
+        ReleasePointerCapture(e.Pointer);
+        input(CreatePointerArgs(device, timestamp, inputRoot, type, rawPoint, modifiers, pointerId));
+        e.Handled = true;
+    }
+
+    private void OnPointerWheelChanged(object sender, PointerRoutedEventArgs e)
+    {
+        if (_topLevelImpl?.Input is not { } input || _topLevelImpl.InputRoot is not { } inputRoot)
+            return;
+
+        var device = GetPointerDevice(e);
+        var timestamp = GetTimestamp(e);
+        var point = e.GetCurrentPoint(this);
+        var delta = point.Properties.MouseWheelDelta;
+        var pos = point.Position;
+
+        input(new RawMouseWheelEventArgs(device as MouseDevice ?? _mouseDevice, timestamp, inputRoot,
+            new AvPoint(pos.X, pos.Y), new AvVector(0, delta), GetPointerModifiers(e)));
+        e.Handled = true;
+    }
+
+    private void OnAvaloniaCursorChanged(ICursorImpl? cursor)
+    {
+        if (cursor is WinUICursorImpl winUiCursor)
+        {
+            _cursorOverlay.SetCursor(winUiCursor.Cursor);
+        }
+        else if (cursor is Win32.CursorImpl win32Cursor)
+        {
+            _cursorOverlay.SetCursor(MapWin32CursorToWinUI(win32Cursor));
+        }
+        else
+        {
+            _cursorOverlay.SetCursor(null);
+        }
+    }
+
+    private static InputCursor? MapWin32CursorToWinUI(Win32.CursorImpl cursor)
+    {
+        var handle = cursor.Handle;
+        if (handle == IntPtr.Zero)
+            return null;
+
+        foreach (StandardCursorType type in Enum.GetValues<StandardCursorType>())
+        {
+            var cached = Win32.CursorFactory.Instance.GetCursor(type);
+            if (cached is Win32.CursorImpl c && c.Handle == handle)
+            {
+                var shape = WinUICursorFactory.Instance.GetCursor(type);
+                return (shape as WinUICursorImpl)?.Cursor;
+            }
+        }
+
+        return InputSystemCursor.Create(InputSystemCursorShape.Arrow);
+    }
+
+    private void OnGotFocus(object sender, RoutedEventArgs e)
+        => _textInputMethod?.OnPanelFocusChanged(true);
+
+    private void OnLostFocus(object sender, RoutedEventArgs e)
+    {
+        _textInputMethod?.OnPanelFocusChanged(false);
+        // Clear Avalonia's internal focus so the previously focused control
+        // doesn't keep its :focus visual once keyboard focus moves to a
+        // native WinUI element.
+        if (_root is not null)
+            global::Avalonia.Input.FocusManager.GetFocusManager(_root)?.Focus(null);
+    }
+
+    private void OnPointerEntered(object sender, PointerRoutedEventArgs e)
+    {
+        // Touch never hovers — enter is implied by the press that produced it.
+        if (e.Pointer.PointerDeviceType == Microsoft.UI.Input.PointerDeviceType.Touch)
+            return;
+        if (_topLevelImpl?.Input is not { } input || _topLevelImpl.InputRoot is not { } inputRoot)
+            return;
+
+        var device = GetPointerDevice(e);
+        var timestamp = GetTimestamp(e);
+        var rawPoint = CreateRawPointerPoint(e.GetCurrentPoint(this));
+        var modifiers = GetPointerModifiers(e);
+        var pointerId = e.Pointer.PointerId;
+
+        input(CreatePointerArgs(device, timestamp, inputRoot,
+            RawPointerEventType.Move, rawPoint, modifiers, pointerId));
+    }
+
+    private void OnPointerExited(object sender, PointerRoutedEventArgs e)
+    {
+        if (e.Pointer.PointerDeviceType == Microsoft.UI.Input.PointerDeviceType.Touch)
+            return;
+        if (_topLevelImpl?.Input is not { } input || _topLevelImpl.InputRoot is not { } inputRoot)
+            return;
+
+        var device = GetPointerDevice(e);
+        var timestamp = GetTimestamp(e);
+        var rawPoint = CreateRawPointerPoint(e.GetCurrentPoint(this));
+        var modifiers = GetPointerModifiers(e);
+        var pointerId = e.Pointer.PointerId;
+
+        input(CreatePointerArgs(device, timestamp, inputRoot,
+            RawPointerEventType.LeaveWindow, rawPoint, modifiers, pointerId));
+    }
+
+    private void OnPointerCanceled(object sender, PointerRoutedEventArgs e)
+    {
+        if (_topLevelImpl?.Input is not { } input || _topLevelImpl.InputRoot is not { } inputRoot)
+            return;
+
+        var device = GetPointerDevice(e);
+        var timestamp = GetTimestamp(e);
+        var rawPoint = CreateRawPointerPoint(e.GetCurrentPoint(this));
+        var modifiers = GetPointerModifiers(e);
+        var pointerId = e.Pointer.PointerId;
+
+        var type = device is TouchDevice ? RawPointerEventType.TouchCancel : RawPointerEventType.LeaveWindow;
+
+        input(CreatePointerArgs(device, timestamp, inputRoot, type, rawPoint, modifiers, pointerId));
+        e.Handled = true;
+    }
+
+    private void OnKeyDown(object sender, KeyRoutedEventArgs e)
+        => DispatchKey(e, RawKeyEventType.KeyDown);
+
+    private void OnKeyUp(object sender, KeyRoutedEventArgs e)
+        => DispatchKey(e, RawKeyEventType.KeyUp);
+
+    private void DispatchKey(KeyRoutedEventArgs e, RawKeyEventType type)
+    {
+        if (_topLevelImpl?.Input is not { } input || _topLevelImpl.InputRoot is not { } inputRoot)
+            return;
+
+        var (key, physicalKey, keySymbol) = WinUIKeyInterop.Resolve(e.Key, e.KeyStatus);
+        if (key == Key.None && physicalKey == PhysicalKey.None)
+            return;
+
+        // Tab boundary: when Avalonia would wrap focus inside its toplevel
+        // (TopLevelHost.TabNavigation = Cycle), forward to WinUI so focus
+        // escapes to the next/previous native control instead.
+        if (type == RawKeyEventType.KeyDown && key == Key.Tab && TryEscapeTabBoundary(e))
+            return;
+
+        var keyboard = GetKeyboardDevice();
+        if (keyboard is null)
+            return;
+
+        var args = new RawKeyEventArgs(keyboard, (ulong)Environment.TickCount64, inputRoot,
+            type, key, GetCurrentModifiers(), physicalKey, keySymbol);
+        input(args);
+
+        if (type == RawKeyEventType.KeyDown)
+            _ignoreCharacterReceived = key == Key.ImeProcessed || args.Handled;
+        else if (type == RawKeyEventType.KeyUp)
+            _ignoreCharacterReceived = false;
+
+        // Only mark handled if Avalonia consumed the event — marking a KeyDown
+        // handled suppresses the matching CharacterReceived and breaks text input.
+        if (args.Handled)
+            e.Handled = true;
+    }
+
+    /// <summary>
+    /// If the current Avalonia focus is at the first or last tab stop in the
+    /// embedded content, handle Tab / Shift+Tab here by moving WinUI focus to
+    /// the next or previous native element. Returns true if the event was
+    /// consumed (the caller must not forward it to Avalonia).
+    /// </summary>
+    private bool TryEscapeTabBoundary(KeyRoutedEventArgs e)
+    {
+        if (_root is null)
+            return false;
+
+        var focusManager = global::Avalonia.Input.FocusManager.GetFocusManager(_root);
+        var current = focusManager?.GetFocusedElement();
+        if (current is null)
+            return false;
+
+        var shift = global::Microsoft.UI.Input.InputKeyboardSource
+            .GetKeyStateForCurrentThread(Windows.System.VirtualKey.Shift)
+            .HasFlag(Windows.UI.Core.CoreVirtualKeyStates.Down);
+
+        var first = global::Avalonia.Input.KeyboardNavigationHandler.GetNext(
+            _root, global::Avalonia.Input.NavigationDirection.Next);
+        if (first is null)
+            return false;
+
+        bool atBoundary;
+        if (shift)
+        {
+            // At the first tab stop — backward tab would wrap.
+            atBoundary = ReferenceEquals(current, first);
+        }
+        else
+        {
+            // At the last tab stop — forward tab would wrap. Cycle mode means
+            // GetNext from the last returns the first; detect that.
+            var next = global::Avalonia.Input.KeyboardNavigationHandler.GetNext(
+                current, global::Avalonia.Input.NavigationDirection.Next);
+            atBoundary = next is null || ReferenceEquals(next, first);
+        }
+
+        if (!atBoundary)
+            return false;
+
+        var direction = shift
+            ? Microsoft.UI.Xaml.Input.FocusNavigationDirection.Previous
+            : Microsoft.UI.Xaml.Input.FocusNavigationDirection.Next;
+
+        // WinUI Desktop requires SearchRoot — the parameterless TryMoveFocus
+        // overload only works in UWP. Use the panel's XamlRoot.Content as the
+        // search scope; that covers the whole window's visual tree.
+        var searchRoot = XamlRoot?.Content as DependencyObject;
+        if (searchRoot is null)
+        {
+            Logger.TryGet(LogEventLevel.Verbose, LogArea.WinUIPlatform)?.Log(this, "Tab boundary: no XamlRoot.Content available; letting Avalonia handle.");
+            return false;
+        }
+
+        var options = new Microsoft.UI.Xaml.Input.FindNextElementOptions
+        {
+            SearchRoot = searchRoot,
+        };
+        var moved = Microsoft.UI.Xaml.Input.FocusManager.TryMoveFocus(direction, options);
+        if (moved)
+        {
+            e.Handled = true;
+            Logger.TryGet(LogEventLevel.Verbose, LogArea.WinUIPlatform)?.Log(this, $"Tab boundary: moved WinUI focus {direction}.");
+            return true;
+        }
+
+        Logger.TryGet(LogEventLevel.Verbose, LogArea.WinUIPlatform)?.Log(this, "Tab boundary detected but TryMoveFocus returned false; letting Avalonia handle.");
+        return false;
+    }
+
+    private void OnCharacterReceived(UIElement sender, CharacterReceivedRoutedEventArgs e)
+    {
+        if (_ignoreCharacterReceived)
+            return;
+
+        if (_topLevelImpl?.Input is not { } input || _topLevelImpl.InputRoot is not { } inputRoot)
+            return;
+
+        var keyboard = GetKeyboardDevice();
+        if (keyboard is null) return;
+
+        var ch = e.Character;
+        if (!char.IsControl(ch) || ch == '\r' || ch == '\n' || ch == '\t')
+        {
+            input(new RawTextInputEventArgs(keyboard, (ulong)Environment.TickCount64, inputRoot,
+                new string(ch, 1)));
+            e.Handled = true;
+        }
+    }
+
+    // Incoming drag-and-drop
+    private DataTransfer? _activeDrag;
+
+    private async void OnDragEnter(object sender, Microsoft.UI.Xaml.DragEventArgs e)
+    {
+        var deferral = e.GetDeferral();
+        try
+        {
+            ((IDisposable?)_activeDrag)?.Dispose();
+            _activeDrag = await BuildDataTransferAsync(e.DataView);
+            UpdateDragUi(e, RawDragEventType.DragEnter);
+        }
+        finally
+        {
+            deferral.Complete();
+        }
+    }
+
+    private void OnDragOver(object sender, Microsoft.UI.Xaml.DragEventArgs e)
+        => UpdateDragUi(e, RawDragEventType.DragOver);
+
+    private void OnDragLeave(object sender, Microsoft.UI.Xaml.DragEventArgs e)
+    {
+        UpdateDragUi(e, RawDragEventType.DragLeave);
+        ((IDisposable?)_activeDrag)?.Dispose();
+        _activeDrag = null;
+    }
+
+    private void OnDrop(object sender, Microsoft.UI.Xaml.DragEventArgs e)
+    {
+        UpdateDragUi(e, RawDragEventType.Drop);
+        ((IDisposable?)_activeDrag)?.Dispose();
+        _activeDrag = null;
+    }
+
+    private void UpdateDragUi(Microsoft.UI.Xaml.DragEventArgs e, RawDragEventType type)
+    {
+        if (_topLevelImpl?.Input is not { } input
+            || _topLevelImpl.InputRoot is not { } inputRoot
+            || _activeDrag is null)
+            return;
+
+        var device = AvaloniaLocator.Current.GetService<IDragDropDevice>();
+        if (device is null)
+            return;
+
+        var pt = e.GetPosition(this);
+        var allowed = (DragDropEffects)(int)e.AllowedOperations;
+        if (allowed == DragDropEffects.None)
+            allowed = DragDropEffects.Copy | DragDropEffects.Move | DragDropEffects.Link;
+        var modifiers = GetCurrentModifiers();
+
+        var args = new RawDragEvent(device, type, inputRoot,
+            new AvPoint(pt.X, pt.Y), _activeDrag, allowed, modifiers);
+        input(args);
+
+        e.AcceptedOperation = (Windows.ApplicationModel.DataTransfer.DataPackageOperation)(int)args.Effects;
+        e.Handled = true;
+    }
+
+    private static async System.Threading.Tasks.Task<DataTransfer> BuildDataTransferAsync(
+        Windows.ApplicationModel.DataTransfer.DataPackageView view)
+    {
+        var dt = new DataTransfer();
+
+        if (view.Contains(Windows.ApplicationModel.DataTransfer.StandardDataFormats.StorageItems))
+        {
+            try
+            {
+                var items = await view.GetStorageItemsAsync();
+                foreach (var item in items)
+                {
+                    var path = item.Path;
+                    if (string.IsNullOrEmpty(path))
+                        continue;
+                    // Reuse Avalonia's BclStorage* via the same helper Win32 uses
+                    // (IVT-granted to Avalonia.WinUI on Avalonia.Base).
+                    if (global::Avalonia.Platform.Storage.FileIO.StorageProviderHelpers
+                        .TryCreateBclStorageItem(path) is { } storage)
+                    {
+                        dt.Add(DataTransferItem.CreateFile(storage));
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.TryGet(LogEventLevel.Warning, LogArea.WinUIPlatform)?.Log(null, "Failed to resolve dragged storage items: {Exception}", ex);
+            }
+        }
+
+        if (view.Contains(Windows.ApplicationModel.DataTransfer.StandardDataFormats.Text))
+        {
+            try
+            {
+                var text = await view.GetTextAsync();
+                if (!string.IsNullOrEmpty(text))
+                    dt.Add(DataTransferItem.CreateText(text));
+            }
+            catch (Exception ex)
+            {
+                Logger.TryGet(LogEventLevel.Warning, LogArea.WinUIPlatform)?.Log(null, "Failed to resolve dragged text: {Exception}", ex);
+            }
+        }
+
+        return dt;
+    }
+
+    // Outgoing drag — invoked by WinUIDragSource on the UI thread.
+    internal async Task<DragDropEffects> StartOutgoingDragAsync(
+        IDataTransfer data, DragDropEffects allowed)
+    {
+        if (_lastPointerPoint is not { } pp)
+        {
+            Logger.TryGet(LogEventLevel.Warning, LogArea.WinUIPlatform)?.Log(this, "StartOutgoingDragAsync called with no cached PointerPoint; drag suppressed.");
+            return DragDropEffects.None;
+        }
+
+        _outgoingDragData = data;
+        _outgoingDragAllowed = allowed;
+        try
+        {
+            var op = await _cursorOverlay.StartDragAsync(pp);
+            return (DragDropEffects)(int)op;
+        }
+        catch (Exception ex)
+        {
+            Logger.TryGet(LogEventLevel.Warning, LogArea.WinUIPlatform)?.Log(this, "StartDragAsync threw: {Exception}", ex);
+            return DragDropEffects.None;
+        }
+        finally
+        {
+            _outgoingDragData = null;
+            _outgoingDragAllowed = DragDropEffects.None;
+        }
+    }
+
+    private async void OnDragStarting(UIElement sender, DragStartingEventArgs e)
+    {
+        if (_outgoingDragData is null)
+        {
+            // The overlay was the drag origin (CanDrag=true) but no Avalonia
+            // drag was in flight — most likely a user grab on empty panel
+            // space. Suppress the native drag rather than emit an empty one.
+            Logger.TryGet(LogEventLevel.Verbose, LogArea.WinUIPlatform)?.Log(this, "DragStarting cancelled: no active Avalonia drag.");
+            e.Cancel = true;
+            return;
+        }
+
+        e.AllowedOperations = (Windows.ApplicationModel.DataTransfer.DataPackageOperation)(int)_outgoingDragAllowed;
+        var deferral = e.GetDeferral();
+        try
+        {
+            await PopulateDataPackageAsync(e.Data, _outgoingDragData);
+        }
+        catch (Exception ex)
+        {
+            Logger.TryGet(LogEventLevel.Warning, LogArea.WinUIPlatform)?.Log(this, "Populating outgoing DataPackage threw: {Exception}", ex);
+        }
+        finally
+        {
+            deferral.Complete();
+        }
+    }
+
+    private static async Task PopulateDataPackageAsync(
+        Windows.ApplicationModel.DataTransfer.DataPackage package, IDataTransfer source)
+    {
+        // Text — direct copy.
+        var text = source.TryGetValue(DataFormat.Text);
+        if (!string.IsNullOrEmpty(text))
+            package.SetText(text);
+
+        // Files — convert Avalonia IStorageItem paths to native
+        // Windows.Storage.IStorageItem instances via the OS APIs.
+        var avFiles = source.TryGetValues(DataFormat.File);
+        if (avFiles is not null)
+        {
+            var winuiItems = new System.Collections.Generic.List<Windows.Storage.IStorageItem>();
+            foreach (var av in avFiles)
+            {
+                string? path = null;
+                if (av.Path is { IsAbsoluteUri: true, Scheme: "file" } uri)
+                    path = uri.LocalPath;
+                if (string.IsNullOrEmpty(path))
+                    continue;
+                try
+                {
+                    Windows.Storage.IStorageItem item =
+                        System.IO.Directory.Exists(path)
+                            ? await Windows.Storage.StorageFolder.GetFolderFromPathAsync(path)
+                            : await Windows.Storage.StorageFile.GetFileFromPathAsync(path);
+                    winuiItems.Add(item);
+                }
+                catch (Exception ex)
+                {
+                    Logger.TryGet(LogEventLevel.Warning, LogArea.WinUIPlatform)?.Log(null, "Failed to expose dragged path '{Path}' as Windows.Storage item: {Exception}", path, ex);
+                }
+            }
+            if (winuiItems.Count > 0)
+                package.SetStorageItems(winuiItems);
+        }
+    }
+
+    private static IKeyboardDevice? GetKeyboardDevice()
+        => AvaloniaLocator.Current.GetService<IKeyboardDevice>();
+
+    private static RawInputModifiers GetCurrentModifiers()
+    {
+        var mods = RawInputModifiers.None;
+        var ctrlState = Microsoft.UI.Input.InputKeyboardSource.GetKeyStateForCurrentThread(Windows.System.VirtualKey.Control);
+        if (ctrlState.HasFlag(Windows.UI.Core.CoreVirtualKeyStates.Down))
+            mods |= RawInputModifiers.Control;
+        var shiftState = Microsoft.UI.Input.InputKeyboardSource.GetKeyStateForCurrentThread(Windows.System.VirtualKey.Shift);
+        if (shiftState.HasFlag(Windows.UI.Core.CoreVirtualKeyStates.Down))
+            mods |= RawInputModifiers.Shift;
+        var altState = Microsoft.UI.Input.InputKeyboardSource.GetKeyStateForCurrentThread(Windows.System.VirtualKey.Menu);
+        if (altState.HasFlag(Windows.UI.Core.CoreVirtualKeyStates.Down))
+            mods |= RawInputModifiers.Alt;
+        return mods;
+    }
+}
diff --git a/src/Windows/Avalonia.WinUI/WinUICursorFactory.cs b/src/Windows/Avalonia.WinUI/WinUICursorFactory.cs
new file mode 100644
index 0000000000..0987f73156
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/WinUICursorFactory.cs
@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Concurrent;
+using global::Avalonia;
+using global::Avalonia.Input;
+using global::Avalonia.Media.Imaging;
+using global::Avalonia.Platform;
+using Microsoft.UI.Input;
+
+namespace Avalonia.WinUI;
+
+/// <summary>
+/// Wraps a WinUI <see cref="InputCursor"/> so it can flow through Avalonia's
+/// platform-agnostic cursor APIs.
+/// </summary>
+internal sealed class WinUICursorImpl : ICursorImpl
+{
+    public WinUICursorImpl(InputCursor? cursor)
+    {
+        Cursor = cursor;
+    }
+
+    public InputCursor? Cursor { get; }
+
+    public void Dispose()
+    {
+        // InputSystemCursor instances are cached — never disposed.
+    }
+}
+
+internal sealed class WinUICursorFactory : ICursorFactory
+{
+    public static WinUICursorFactory Instance { get; } = new();
+
+    private readonly ConcurrentDictionary<StandardCursorType, WinUICursorImpl> _cache = new();
+
+    private WinUICursorFactory() { }
+
+    public ICursorImpl GetCursor(StandardCursorType cursorType)
+    {
+        return _cache.GetOrAdd(cursorType, static t =>
+        {
+            var shape = MapShape(t);
+            InputCursor? cursor = shape is { } s ? InputSystemCursor.Create(s) : null;
+            return new WinUICursorImpl(cursor);
+        });
+    }
+
+    public ICursorImpl CreateCursor(Bitmap cursor, PixelPoint hotSpot)
+    {
+        // WinUI 3 exposes no public API to build an InputCursor from an
+        // in-memory image (only InputSystemCursor.Create(shape) and
+        // InputDesktopResourceCursor.CreateFromResource(fileName) are
+        // available). Fall back to the default arrow so the caller still
+        // gets a usable cursor.
+
+        // TODO: Custom bitmap cursors...
+        return _cache.GetOrAdd(StandardCursorType.Arrow, static t =>
+            new WinUICursorImpl(InputSystemCursor.Create(InputSystemCursorShape.Arrow)));
+    }
+
+    private static InputSystemCursorShape? MapShape(StandardCursorType t) => t switch
+    {
+        StandardCursorType.None => null,
+        StandardCursorType.Arrow => InputSystemCursorShape.Arrow,
+        StandardCursorType.Ibeam => InputSystemCursorShape.IBeam,
+        StandardCursorType.Wait => InputSystemCursorShape.Wait,
+        StandardCursorType.AppStarting => InputSystemCursorShape.Wait,
+        StandardCursorType.Cross => InputSystemCursorShape.Cross,
+        StandardCursorType.Help => InputSystemCursorShape.Help,
+        StandardCursorType.Hand => InputSystemCursorShape.Hand,
+        StandardCursorType.No => InputSystemCursorShape.UniversalNo,
+        StandardCursorType.SizeAll => InputSystemCursorShape.SizeAll,
+        StandardCursorType.SizeNorthSouth => InputSystemCursorShape.SizeNorthSouth,
+        StandardCursorType.SizeWestEast => InputSystemCursorShape.SizeWestEast,
+        StandardCursorType.UpArrow => InputSystemCursorShape.UpArrow,
+        StandardCursorType.TopSide => InputSystemCursorShape.SizeNorthSouth,
+        StandardCursorType.BottomSide => InputSystemCursorShape.SizeNorthSouth,
+        StandardCursorType.LeftSide => InputSystemCursorShape.SizeWestEast,
+        StandardCursorType.RightSide => InputSystemCursorShape.SizeWestEast,
+        StandardCursorType.TopLeftCorner => InputSystemCursorShape.SizeNorthwestSoutheast,
+        StandardCursorType.BottomRightCorner => InputSystemCursorShape.SizeNorthwestSoutheast,
+        StandardCursorType.TopRightCorner => InputSystemCursorShape.SizeNortheastSouthwest,
+        StandardCursorType.BottomLeftCorner => InputSystemCursorShape.SizeNortheastSouthwest,
+        // No built-in drag cursors — fall back to Arrow; OLE drag operations on
+        // Win32 traditionally use ole32.dll resources we can't reach from here.
+        StandardCursorType.DragMove => InputSystemCursorShape.Arrow,
+        StandardCursorType.DragCopy => InputSystemCursorShape.Arrow,
+        StandardCursorType.DragLink => InputSystemCursorShape.Arrow,
+        _ => InputSystemCursorShape.Arrow,
+    };
+}
diff --git a/src/Windows/Avalonia.WinUI/WinUIDragSource.cs b/src/Windows/Avalonia.WinUI/WinUIDragSource.cs
new file mode 100644
index 0000000000..ed165aada9
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/WinUIDragSource.cs
@@ -0,0 +1,42 @@
+using System.Threading.Tasks;
+using global::Avalonia.Controls;
+using global::Avalonia.Input;
+using global::Avalonia.Input.Platform;
+using global::Avalonia.Logging;
+
+namespace Avalonia.WinUI;
+
+/// <summary>
+/// <see cref="IPlatformDragSource"/> implementation that initiates native WinUI
+/// drags (via <see cref="Microsoft.UI.Xaml.UIElement.StartDragAsync"/>) for
+/// content hosted inside an <see cref="AvaloniaSwapChainPanel"/>. WinUI only
+/// permits starting a drag with a <see cref="Microsoft.UI.Input.PointerPoint"/>
+/// captured during an active pointer interaction; the panel caches the most
+/// recent pointer point (regardless of pointer id) and uses it to start the drag.
+/// </summary>
+internal sealed class WinUIDragSource : IPlatformDragSource
+{
+    public async Task<DragDropEffects> DoDragDropAsync(
+        PointerPressedEventArgs triggerEvent,
+        IDataTransfer dataTransfer,
+        DragDropEffects allowedEffects)
+    {
+        // Resolve the panel that hosts the visual that started the drag.
+        var topLevel = TopLevel.GetTopLevel(triggerEvent.Source as Visual);
+        var panel = topLevel?.PlatformImpl is { } impl
+            ? AvaloniaSwapChainPanel.GetPanelFor(impl)
+            : null;
+
+        if (panel is null)
+        {
+            Logger.TryGet(LogEventLevel.Warning, LogArea.WinUIPlatform)?.Log(this,
+                "Could not resolve AvaloniaSwapChainPanel for drag source. " +
+                "TopLevel={TopLevel}, PlatformImpl={PlatformImpl}.",
+                topLevel?.GetType().Name ?? "null",
+                topLevel?.PlatformImpl?.GetType().Name ?? "null");
+            return DragDropEffects.None;
+        }
+
+        return await panel.StartOutgoingDragAsync(dataTransfer, allowedEffects);
+    }
+}
diff --git a/src/Windows/Avalonia.WinUI/WinUIKeyInterop.cs b/src/Windows/Avalonia.WinUI/WinUIKeyInterop.cs
new file mode 100644
index 0000000000..1c8f7f60ef
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/WinUIKeyInterop.cs
@@ -0,0 +1,62 @@
+using global::Avalonia.Input;
+using global::Avalonia.Input.Raw;
+using global::Avalonia.Win32.Input;
+using Windows.System;
+using Windows.UI.Core;
+
+namespace Avalonia.WinUI;
+
+internal static class WinUIKeyInterop
+{
+    /// <summary>
+    /// Resolves WinUI key-event metadata to Avalonia's <see cref="Key"/>,
+    /// <see cref="PhysicalKey"/> and key symbol, using the shared Win32 mapping
+    /// tables in <see cref="KeyInterop"/>. WinUI's <c>KeyRoutedEventArgs</c>
+    /// exposes virtual-key + scan-code + extended flag — packing those into the
+    /// same lParam layout the Win32 backend uses lets us reuse all of its
+    /// mapping logic (Numpad disambiguation, left/right modifier split, etc.).
+    /// </summary>
+    public static (Key Key, PhysicalKey PhysicalKey, string? KeySymbol) Resolve(
+        VirtualKey virtualKey, CorePhysicalKeyStatus status)
+    {
+        var keyData = EncodeKeyData(status);
+        var vk = (int)virtualKey;
+        var key = KeyInterop.KeyFromVirtualKey(vk, keyData);
+        var physical = KeyInterop.PhysicalKeyFromVirtualKey(vk, keyData);
+        var symbol = KeyInterop.GetKeySymbolFromVirtualKey(vk);
+        return (key, physical, symbol);
+    }
+
+    public static Key KeyFromVirtualKey(VirtualKey virtualKey)
+    {
+        // Fallback used by callers that don't have KeyStatus (rare).
+        return KeyInterop.KeyFromVirtualKey((int)virtualKey, 0);
+    }
+
+    public static RawInputModifiers ModifiersFromVirtualKeyModifiers(VirtualKeyModifiers modifiers)
+    {
+        var result = RawInputModifiers.None;
+        if (modifiers.HasFlag(VirtualKeyModifiers.Control))
+            result |= RawInputModifiers.Control;
+        if (modifiers.HasFlag(VirtualKeyModifiers.Shift))
+            result |= RawInputModifiers.Shift;
+        if (modifiers.HasFlag(VirtualKeyModifiers.Menu))
+            result |= RawInputModifiers.Alt;
+        if (modifiers.HasFlag(VirtualKeyModifiers.Windows))
+            result |= RawInputModifiers.Meta;
+        return result;
+    }
+
+    private static int EncodeKeyData(CorePhysicalKeyStatus status)
+    {
+        // Mirror the WM_KEYDOWN lParam layout that Win32's KeyInterop expects:
+        //   bits 16-23 : scan code (low byte)
+        //   bit 24     : extended-key flag
+        // Repeat count, context, previous/transition bits are unused by the
+        // key/physical-key/symbol resolvers, so leave them zero.
+        var data = (int)((status.ScanCode & 0xFF) << 16);
+        if (status.IsExtendedKey)
+            data |= 1 << 24;
+        return data;
+    }
+}
diff --git a/src/Windows/Avalonia.WinUI/WinUITextInputMethod.cs b/src/Windows/Avalonia.WinUI/WinUITextInputMethod.cs
new file mode 100644
index 0000000000..f1517a593d
--- /dev/null
+++ b/src/Windows/Avalonia.WinUI/WinUITextInputMethod.cs
@@ -0,0 +1,384 @@
+using System;
+using System.Runtime.InteropServices;
+using global::Avalonia;
+using global::Avalonia.Input;
+using global::Avalonia.Input.Raw;
+using global::Avalonia.Input.TextInput;
+using global::Avalonia.Logging;
+using Microsoft.UI.Xaml;
+using Windows.UI.Text.Core;
+using AvRect = global::Avalonia.Rect;
+
+namespace Avalonia.WinUI;
+
+/// <summary>
+/// Bridges Avalonia's <see cref="ITextInputMethodImpl"/> contract to the WinRT <see cref="CoreTextEditContext"/>.
+/// </summary>
+internal sealed class WinUITextInputMethod : ITextInputMethodImpl
+{
+    private readonly AvaloniaSwapChainPanel _panel;
+    private readonly Func<Action<RawInputEventArgs>?> _getInput;
+    private readonly Func<IInputRoot?> _getInputRoot;
+    private readonly Func<IKeyboardDevice?> _getKeyboardDevice;
+
+    private CoreTextEditContext? _editContext;
+    private TextInputMethodClient? _client;
+    private bool _hasFocus;
+    private bool _isComposing;
+
+    private string _imeText = string.Empty;
+    private CoreTextRange _imeSelection;
+    private int _compositionStart;
+    private int _compositionLength;
+    private AvRect _cursorRect;
+    private bool _suppressClientEcho;
+
+    public WinUITextInputMethod(
+        AvaloniaSwapChainPanel panel,
+        Func<Action<RawInputEventArgs>?> getInput,
+        Func<IInputRoot?> getInputRoot,
+        Func<IKeyboardDevice?> getKeyboardDevice)
+    {
+        _panel = panel;
+        _getInput = getInput;
+        _getInputRoot = getInputRoot;
+        _getKeyboardDevice = getKeyboardDevice;
+    }
+
+    private CoreTextEditContext GetOrCreateContext()
+    {
+        if (_editContext is not null)
+            return _editContext;
+
+        var manager = CoreTextServicesManager.GetForCurrentView();
+        var ctx = manager.CreateEditContext();
+        ctx.InputPaneDisplayPolicy = CoreTextInputPaneDisplayPolicy.Automatic;
+        ctx.InputScope = CoreTextInputScope.Text;
+
+        ctx.TextRequested += OnTextRequested;
+        ctx.SelectionRequested += OnSelectionRequested;
+        ctx.LayoutRequested += OnLayoutRequested;
+        ctx.TextUpdating += OnTextUpdating;
+        ctx.SelectionUpdating += OnSelectionUpdating;
+        ctx.FormatUpdating += OnFormatUpdating;
+        ctx.CompositionStarted += OnCompositionStarted;
+        ctx.CompositionCompleted += OnCompositionCompleted;
+        ctx.FocusRemoved += OnFocusRemoved;
+
+        _editContext = ctx;
+        return ctx;
+    }
+
+    public void SetClient(TextInputMethodClient? client)
+    {
+        if (_client is not null)
+        {
+            _client.SurroundingTextChanged -= OnClientSurroundingTextChanged;
+            _client.SelectionChanged -= OnClientSelectionChanged;
+        }
+
+        _client = client;
+        ResetCompositionState();
+
+        if (client is null)
+        {
+            if (_editContext is not null && _hasFocus)
+                _editContext.NotifyFocusLeave();
+            return;
+        }
+
+        client.SurroundingTextChanged += OnClientSurroundingTextChanged;
+        client.SelectionChanged += OnClientSelectionChanged;
+
+        var ctx = GetOrCreateContext();
+        SyncFromClient(notifyServer: true);
+        if (_hasFocus)
+            ctx.NotifyFocusEnter();
+    }
+
+    public void SetCursorRect(Rect rect)
+    {
+        _cursorRect = rect;
+        _editContext?.NotifyLayoutChanged();
+    }
+
+    public void SetOptions(TextInputOptions options)
+    {
+        if (_editContext is null)
+            return;
+        _editContext.InputScope = options.ContentType switch
+        {
+            TextInputContentType.Email => CoreTextInputScope.EmailAddress,
+            TextInputContentType.Number => CoreTextInputScope.Number,
+            TextInputContentType.Password => CoreTextInputScope.Password,
+            TextInputContentType.Digits => CoreTextInputScope.Digits,
+            TextInputContentType.Url => CoreTextInputScope.Url,
+            TextInputContentType.Search => CoreTextInputScope.Search,
+            _ => CoreTextInputScope.Text,
+        };
+    }
+
+    public void Reset()
+    {
+        if (_isComposing)
+            _client?.SetPreeditText(null);
+        ResetCompositionState();
+        SyncFromClient(notifyServer: true);
+    }
+
+    /// <summary>Called by the panel when it gains/loses focus.</summary>
+    public void OnPanelFocusChanged(bool hasFocus)
+    {
+        _hasFocus = hasFocus;
+        if (_editContext is null)
+            return;
+        if (hasFocus && _client is not null)
+            _editContext.NotifyFocusEnter();
+        else
+            _editContext.NotifyFocusLeave();
+    }
+
+    private void ResetCompositionState()
+    {
+        _isComposing = false;
+        _compositionStart = 0;
+        _compositionLength = 0;
+    }
+
+    private void SyncFromClient(bool notifyServer)
+    {
+        if (_client is null)
+        {
+            _imeText = string.Empty;
+            _imeSelection = default;
+            return;
+        }
+
+        _imeText = _client.SurroundingText ?? string.Empty;
+        var sel = _client.Selection;
+        _imeSelection = new CoreTextRange
+        {
+            StartCaretPosition = Math.Clamp(sel.Start, 0, _imeText.Length),
+            EndCaretPosition = Math.Clamp(sel.End, 0, _imeText.Length),
+        };
+
+        if (notifyServer && _editContext is not null)
+        {
+            _editContext.NotifyTextChanged(
+                new CoreTextRange { StartCaretPosition = 0, EndCaretPosition = int.MaxValue },
+                _imeText.Length,
+                _imeSelection);
+            _editContext.NotifyLayoutChanged();
+        }
+    }
+
+    private void OnClientSurroundingTextChanged(object? sender, EventArgs e)
+    {
+        if (_suppressClientEcho || _isComposing)
+            return;
+        SyncFromClient(notifyServer: true);
+    }
+
+    private void OnClientSelectionChanged(object? sender, EventArgs e)
+    {
+        if (_suppressClientEcho || _isComposing || _client is null || _editContext is null)
+            return;
+        var sel = _client.Selection;
+        _imeSelection = new CoreTextRange
+        {
+            StartCaretPosition = Math.Clamp(sel.Start, 0, _imeText.Length),
+            EndCaretPosition = Math.Clamp(sel.End, 0, _imeText.Length),
+        };
+        _editContext.NotifySelectionChanged(_imeSelection);
+    }
+
+    private void OnTextRequested(CoreTextEditContext sender, CoreTextTextRequestedEventArgs args)
+    {
+        var range = args.Request.Range;
+        var start = Math.Clamp(range.StartCaretPosition, 0, _imeText.Length);
+        var end = Math.Clamp(range.EndCaretPosition, start, _imeText.Length);
+        args.Request.Text = _imeText.Substring(start, end - start);
+    }
+
+    private void OnSelectionRequested(CoreTextEditContext sender, CoreTextSelectionRequestedEventArgs args)
+    {
+        args.Request.Selection = _imeSelection;
+    }
+
+    private void OnLayoutRequested(CoreTextEditContext sender, CoreTextLayoutRequestedEventArgs args)
+    {
+        try
+        {
+            var screenRect = ComputeScreenCursorRect();
+            args.Request.LayoutBounds.TextBounds = screenRect;
+            args.Request.LayoutBounds.ControlBounds = screenRect;
+        }
+        catch (Exception ex)
+        {
+            // Panel not in tree yet, or transform unavailable — leave bounds default.
+            Logger.TryGet(LogEventLevel.Verbose, LogArea.WinUIPlatform)?.Log(this, "LayoutRequested couldn't compute screen rect: {Message}", ex.Message);
+        }
+    }
+
+    private Windows.Foundation.Rect ComputeScreenCursorRect()
+    {
+        var transform = _panel.TransformToVisual(null);
+        var topLeft = transform.TransformPoint(
+            new Windows.Foundation.Point(_cursorRect.X, _cursorRect.Y));
+        var width = Math.Max(_cursorRect.Width, 1);
+        var height = Math.Max(_cursorRect.Height, 16);
+
+        var xamlRoot = _panel.XamlRoot;
+        var scale = xamlRoot?.RasterizationScale ?? 1.0;
+
+        var clientX = topLeft.X * scale;
+        var clientY = topLeft.Y * scale;
+        var w = width * scale;
+        var h = height * scale;
+
+        if (xamlRoot?.ContentIslandEnvironment is { } island)
+        {
+            var hwnd = Microsoft.UI.Win32Interop.GetWindowFromWindowId(island.AppWindowId);
+            if (hwnd != IntPtr.Zero)
+            {
+                var pt = new POINT { x = 0, y = 0 };
+                if (ClientToScreen(hwnd, ref pt))
+                {
+                    clientX += pt.x;
+                    clientY += pt.y;
+                }
+            }
+        }
+
+        return new Windows.Foundation.Rect(clientX, clientY, w, h);
+    }
+
+    private void OnTextUpdating(CoreTextEditContext sender, CoreTextTextUpdatingEventArgs args)
+    {
+        var newText = args.Text ?? string.Empty;
+        var range = args.Range;
+        var start = Math.Clamp(range.StartCaretPosition, 0, _imeText.Length);
+        var end = Math.Clamp(range.EndCaretPosition, start, _imeText.Length);
+
+        _imeText = _imeText.Substring(0, start) + newText + _imeText.Substring(end);
+        _imeSelection = args.NewSelection;
+
+        if (_isComposing)
+        {
+            if (_compositionLength == 0)
+                _compositionStart = start;
+            _compositionLength = Math.Max(0, _imeSelection.EndCaretPosition - _compositionStart);
+            _compositionLength = Math.Min(_compositionLength, _imeText.Length - _compositionStart);
+
+            var preedit = _imeText.Substring(_compositionStart, _compositionLength);
+            _client?.SetPreeditText(preedit, _imeSelection.EndCaretPosition - _compositionStart);
+        }
+        else if (!string.IsNullOrEmpty(newText))
+        {
+            DispatchRawText(newText, notifyServer: true);
+        }
+
+        args.Result = CoreTextTextUpdatingResult.Succeeded;
+    }
+
+    private void OnSelectionUpdating(CoreTextEditContext sender, CoreTextSelectionUpdatingEventArgs args)
+    {
+        _imeSelection = args.Selection;
+        if (!_isComposing && _client is not null)
+        {
+            _suppressClientEcho = true;
+            try
+            {
+                _client.Selection = new TextSelection(
+                    _imeSelection.StartCaretPosition, _imeSelection.EndCaretPosition);
+            }
+            finally { _suppressClientEcho = false; }
+        }
+        args.Result = CoreTextSelectionUpdatingResult.Succeeded;
+    }
+
+    private void OnFormatUpdating(CoreTextEditContext sender, CoreTextFormatUpdatingEventArgs args)
+    {
+        args.Result = CoreTextFormatUpdatingResult.Succeeded;
+    }
+
+    private void OnCompositionStarted(CoreTextEditContext sender, CoreTextCompositionStartedEventArgs args)
+    {
+        if (_imeSelection.StartCaretPosition != _imeSelection.EndCaretPosition)
+        {
+            var input = _getInput();
+            var inputRoot = _getInputRoot();
+            var keyboard = _getKeyboardDevice();
+            if (input is not null && inputRoot is not null && keyboard is not null)
+            {
+                _suppressClientEcho = true;
+                try
+                {
+                    var timestamp = (ulong)Environment.TickCount64;
+                    input(new RawKeyEventArgs(keyboard, timestamp, inputRoot,
+                        RawKeyEventType.KeyDown, Key.Delete, RawInputModifiers.None, PhysicalKey.Delete, null));
+                    input(new RawKeyEventArgs(keyboard, timestamp, inputRoot,
+                        RawKeyEventType.KeyUp, Key.Delete, RawInputModifiers.None, PhysicalKey.Delete, null));
+                }
+                finally
+                {
+                    _suppressClientEcho = false;
+                }
+            }
+        }
+
+        _isComposing = true;
+        _compositionStart = _imeSelection.StartCaretPosition;
+        _compositionLength = 0;
+    }
+
+    private void OnCompositionCompleted(CoreTextEditContext sender, CoreTextCompositionCompletedEventArgs args)
+    {
+        _isComposing = false;
+        var len = Math.Max(0, Math.Min(_compositionLength, _imeText.Length - _compositionStart));
+        var committed = len > 0 ? _imeText.Substring(_compositionStart, len) : string.Empty;
+
+        _client?.SetPreeditText(null);
+        _compositionLength = 0;
+
+        if (!string.IsNullOrEmpty(committed))
+            DispatchRawText(committed, notifyServer: false);
+    }
+
+    private void OnFocusRemoved(CoreTextEditContext sender, object args)
+    {
+        _hasFocus = false;
+    }
+
+    private void DispatchRawText(string text, bool notifyServer)
+    {
+        var input = _getInput();
+        var inputRoot = _getInputRoot();
+        var keyboard = _getKeyboardDevice();
+        if (input is null || inputRoot is null || keyboard is null)
+            return;
+
+        _suppressClientEcho = true;
+        try
+        {
+            input(new RawTextInputEventArgs(keyboard, (ulong)Environment.TickCount64, inputRoot, text));
+        }
+        finally
+        {
+            _suppressClientEcho = false;
+        }
+
+        SyncFromClient(notifyServer);
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct POINT
+    {
+        public int x;
+        public int y;
+    }
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool ClientToScreen(IntPtr hWnd, ref POINT lpPoint);
+}

From 69ecd315302b3e590e5c3dbf86904be5e10ef029 Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Wed, 10 Jun 2026 11:18:19 +0000
Subject: [PATCH 003/196] Listen to layout changes for ancestor visuals in text
 selection canvas (#21536)

* listen to layout changes for ancestor visuals in text selection canvas

* add tests
---
 .../Primitives/TextSelectionCanvas.cs         |  56 ++++++-
 .../TextSelectionCanvasTests.cs               | 152 ++++++++++++++++++
 2 files changed, 200 insertions(+), 8 deletions(-)
 create mode 100644 tests/Avalonia.Controls.UnitTests/TextSelectionCanvasTests.cs

diff --git a/src/Avalonia.Controls/Primitives/TextSelectionCanvas.cs b/src/Avalonia.Controls/Primitives/TextSelectionCanvas.cs
index 8875d8de00..bae5823b80 100644
--- a/src/Avalonia.Controls/Primitives/TextSelectionCanvas.cs
+++ b/src/Avalonia.Controls/Primitives/TextSelectionCanvas.cs
@@ -5,9 +5,12 @@ using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Primitives.PopupPositioning;
 using Avalonia.Input;
 using Avalonia.Interactivity;
+using Avalonia.Layout;
 using Avalonia.Media.TextFormatting;
+using Avalonia.Reactive;
 using Avalonia.Threading;
 using Avalonia.VisualTree;
+using static Avalonia.Reactive.Disposable;
 
 namespace Avalonia.Controls.Primitives
 {
@@ -97,9 +100,16 @@ namespace Avalonia.Controls.Primitives
         }
 
         private void LayoutListener_Invalidated(object? sender, EventArgs e)
+        {
+            InvalidateMeasure();
+        }
+
+        protected override Size MeasureOverride(Size availableSize)
         {
             if (ShowHandles)
                 MoveHandlesToSelection();
+
+            return base.MeasureOverride(availableSize);
         }
 
         private void Caret_ContextCanceled(object? sender, RoutedEventArgs e)
@@ -610,15 +620,48 @@ namespace Avalonia.Controls.Primitives
             private TextPresenter? _presenter;
 
             public event EventHandler? Invalidated;
+            
+            private CompositeDisposable? _disposables;
 
             public void Attach(TextPresenter presenter)
             {
                 if (_presenter != null)
                     throw new InvalidOperationException("Listener is already attached to a TextPresenter");
 
+                _disposables?.Dispose();
+                _disposables = new CompositeDisposable();
                 _presenter = presenter;
-                presenter.SizeChanged += Presenter_SizeChanged;
-                presenter.EffectiveViewportChanged += Visual_EffectiveViewportChanged;
+
+                Visual? current = presenter;
+                do
+                {
+                    AttachEvents(current);
+                    current = current?.VisualParent;
+                }
+                while (current != null);
+            }
+
+            private void AttachEvents(Visual? visual)
+            {
+                if (visual != null)
+                {
+                    if (visual is Layoutable layoutable)
+                    {
+                        layoutable.EffectiveViewportChanged += Visual_EffectiveViewportChanged;
+                        _disposables?.Add(new AnonymousDisposable(() =>
+                        {
+                            layoutable.EffectiveViewportChanged -= Visual_EffectiveViewportChanged;
+                        }));
+                    }
+                    if (visual is Control control)
+                    {
+                        control.SizeChanged += Visual_SizeChanged;
+                        _disposables?.Add(new AnonymousDisposable(() =>
+                        {
+                            control.SizeChanged -= Visual_SizeChanged;
+                        }));
+                    }
+                }
             }
 
             private void Visual_EffectiveViewportChanged(object? sender, Layout.EffectiveViewportChangedEventArgs e)
@@ -626,18 +669,15 @@ namespace Avalonia.Controls.Primitives
                 OnInvalidated();
             }
 
-            private void Presenter_SizeChanged(object? sender, SizeChangedEventArgs e)
+            private void Visual_SizeChanged(object? sender, SizeChangedEventArgs e)
             {
                 OnInvalidated();
             }
 
             public void Detach()
             {
-                if (_presenter is { } presenter)
-                {
-                    presenter.SizeChanged -= Presenter_SizeChanged;
-                    presenter.EffectiveViewportChanged -= Visual_EffectiveViewportChanged;
-                }
+                _disposables?.Dispose();
+                _disposables = null;
 
                 _presenter = null;
             }
diff --git a/tests/Avalonia.Controls.UnitTests/TextSelectionCanvasTests.cs b/tests/Avalonia.Controls.UnitTests/TextSelectionCanvasTests.cs
new file mode 100644
index 0000000000..6e1c9dcce3
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/TextSelectionCanvasTests.cs
@@ -0,0 +1,152 @@
+using System.Linq;
+using Avalonia.Controls.Presenters;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.Templates;
+using Avalonia.Harfbuzz;
+using Avalonia.Headless;
+using Avalonia.Input;
+using Avalonia.Platform;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using Moq;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests
+{
+    public class TextSelectionCanvasTests : ScopedTestBase
+    {
+        [Fact]
+        public void Text_Selection_Handle_Moves_With_Scrolling()
+        {
+            using (UnitTestApplication.Start(Services))
+            {
+                var touchHelper = new TouchTestHelper();
+                Border rootBorder = new Border()
+                {
+                    Width = 200,
+                    Height = 600
+                };
+                var visualLayerManager = new VisualLayerManager()
+                {
+                    Child = rootBorder,
+                    EnableTextSelectorLayer = true
+                };
+                var impl = CreateMockTopLevelImpl();
+                var topLevel = new TestTopLevel(impl.Object)
+                {
+                    Template = CreateTopLevelTemplate(),
+                    Content = visualLayerManager
+                };
+
+                var focusedTextBox = CreateTextBox();
+
+                var panel = new StackPanel()
+                {
+                    Orientation = Layout.Orientation.Vertical,
+                    Spacing = 20,
+                    Children =
+                    {
+                        focusedTextBox,
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                        CreateTextBox(),
+                    }
+                };
+
+                var scrollViewer = new ScrollViewer
+                {
+                    Template = new FuncControlTemplate<ScrollViewer>(ScrollViewerTests.CreateTemplate),
+                    Content = panel
+                };
+
+                rootBorder.Child = scrollViewer;
+
+                topLevel.LayoutManager.ExecuteInitialLayoutPass();
+
+                touchHelper.Tap(focusedTextBox);
+
+                topLevel.LayoutManager.ExecuteLayoutPass();
+
+                var presenter = focusedTextBox.FindDescendantOfType<TextPresenter>()!;
+                var canvas = presenter.TextSelectionHandleCanvas;
+
+                Assert.NotNull(canvas);
+
+                var handle = canvas.Children.FirstOrDefault() as TextSelectionHandle;
+
+                Assert.NotNull(handle);
+
+                Assert.Equal(new Point(25.5, 14.5), handle.GetTopLeft());
+
+                scrollViewer.Offset = new Vector(0, 50);
+
+                topLevel.LayoutManager.ExecuteLayoutPass();
+
+                Assert.Equal(new Point(25.5, -35.5), handle.GetTopLeft());
+            }
+
+            TextBox CreateTextBox()
+            {
+                return new TextBox
+                {
+                    Template = TextBoxTests.CreateTemplate(),
+                    Text = "Test",
+                    Width = 150
+                };
+            }
+        }
+
+        private class TestTopLevel(ITopLevelImpl impl) : TopLevel(impl)
+        {
+
+        }
+
+        static Mock<ITopLevelImpl> CreateMockTopLevelImpl()
+        {
+            var topLevel = new Mock<ITopLevelImpl>();
+            topLevel.Setup(x => x.RenderScaling).Returns(1);
+            topLevel.Setup(x => x.Compositor).Returns(RendererMocks.CreateDummyCompositor());
+            return topLevel;
+        }
+
+        private static FuncControlTemplate<TestTopLevel> CreateTopLevelTemplate()
+        {
+            return new FuncControlTemplate<TestTopLevel>((x, scope) =>
+                new ContentPresenter
+                {
+                    Name = "PART_ContentPresenter",
+                    [!ContentPresenter.ContentProperty] = x[!ContentControl.ContentProperty],
+                }.RegisterInNameScope(scope));
+        }
+
+        private static TestServices Services => TestServices.MockThreadingInterface.With(
+            standardCursorFactory: Mock.Of<ICursorFactory>(),
+            renderInterface: new HeadlessPlatformRenderInterface(),
+            textShaperImpl: new HarfBuzzTextShaper(),
+            fontManagerImpl: new TestFontManager(),
+            keyboardDevice: () => new KeyboardDevice(),
+            keyboardNavigation: () => new KeyboardNavigationHandler(),
+            inputManager: new InputManager(),
+            assetLoader: new StandardAssetLoader());
+    }
+}

From 2913dc59fa526e3a57efd1b07b13bbb988e922f9 Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Thu, 11 Jun 2026 00:05:22 +0800
Subject: [PATCH 004/196] Map macOS ListItem peer to AXRow instead of AXGroup
 (#21537)

Report AXRow with the AXTableRow subrole so list items are distinguishable from generic panels.
---
 native/Avalonia.Native/src/OSX/automation.mm | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/native/Avalonia.Native/src/OSX/automation.mm b/native/Avalonia.Native/src/OSX/automation.mm
index 6fd2cb6218..0f2ae3768c 100644
--- a/native/Avalonia.Native/src/OSX/automation.mm
+++ b/native/Avalonia.Native/src/OSX/automation.mm
@@ -96,7 +96,7 @@
         case AutomationEdit: return NSAccessibilityTextFieldRole;
         case AutomationHyperlink: return NSAccessibilityLinkRole;
         case AutomationImage: return NSAccessibilityImageRole;
-        case AutomationListItem: return NSAccessibilityGroupRole;
+        case AutomationListItem: return NSAccessibilityRowRole;
         case AutomationList: return NSAccessibilityListRole;
         case AutomationMenu: return NSAccessibilityMenuBarRole;
         case AutomationMenuBar: return NSAccessibilityMenuBarRole;
@@ -141,6 +141,7 @@
     auto controlType = _peer->GetAutomationControlType();
     switch (controlType) {
         case AutomationList: return @"AXContentList";
+        case AutomationListItem: return NSAccessibilityTableRowSubrole;
     }
 
     auto landmarkType = _peer->GetLandmarkType();

From a932c75dbbc06262e36276794502ad957d0f9110 Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Thu, 11 Jun 2026 02:20:24 +0800
Subject: [PATCH 005/196] Expose menu item toggle state to automation (#21541)

* Implement IToggleProvider on MenuItemAutomationPeer

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 .../Peers/MenuItemAutomationPeer.cs           | 55 ++++++++++-
 .../Automation/MenuItemAutomationPeerTests.cs | 95 +++++++++++++++++++
 2 files changed, 146 insertions(+), 4 deletions(-)
 create mode 100644 tests/Avalonia.Controls.UnitTests/Automation/MenuItemAutomationPeerTests.cs

diff --git a/src/Avalonia.Controls/Automation/Peers/MenuItemAutomationPeer.cs b/src/Avalonia.Controls/Automation/Peers/MenuItemAutomationPeer.cs
index 5ecfb29afc..9fa4ede3ca 100644
--- a/src/Avalonia.Controls/Automation/Peers/MenuItemAutomationPeer.cs
+++ b/src/Avalonia.Controls/Automation/Peers/MenuItemAutomationPeer.cs
@@ -1,17 +1,42 @@
-using Avalonia.Controls;
+using System;
+using Avalonia.Automation.Provider;
+using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
 
 namespace Avalonia.Automation.Peers
 {
-    public class MenuItemAutomationPeer : ControlAutomationPeer
+    public class MenuItemAutomationPeer : ControlAutomationPeer, IToggleProvider
     {
         public MenuItemAutomationPeer(MenuItem owner)
-            : base(owner) 
-        { 
+            : base(owner)
+        {
+            owner.PropertyChanged += OwnerPropertyChanged;
         }
 
         public new MenuItem Owner => (MenuItem)base.Owner;
 
+        ToggleState IToggleProvider.ToggleState
+            => Owner.IsChecked ? ToggleState.On : ToggleState.Off;
+
+        void IToggleProvider.Toggle()
+        {
+            EnsureEnabled();
+
+            if (Owner.HasSubMenu)
+                return;
+
+            switch (Owner.ToggleType)
+            {
+                case MenuItemToggleType.CheckBox:
+                    Owner.SetCurrentValue(MenuItem.IsCheckedProperty, !Owner.IsChecked);
+                    break;
+                case MenuItemToggleType.Radio:
+                    if (!Owner.IsChecked)
+                        Owner.SetCurrentValue(MenuItem.IsCheckedProperty, true);
+                    break;
+            }
+        }
+
         protected override string? GetAccessKeyCore()
         {
             var result = base.GetAccessKeyCore();
@@ -55,5 +80,27 @@ namespace Avalonia.Automation.Peers
 
             return result;
         }
+
+        protected override object? GetProviderCore(Type providerType)
+        {
+            if (providerType == typeof(IToggleProvider) && Owner.ToggleType == MenuItemToggleType.None)
+                return null;
+
+            return base.GetProviderCore(providerType);
+        }
+
+        private void OwnerPropertyChanged(object? sender, AvaloniaPropertyChangedEventArgs e)
+        {
+            if (e.Property == MenuItem.IsCheckedProperty && Owner.ToggleType != MenuItemToggleType.None)
+            {
+                RaisePropertyChangedEvent(
+                    TogglePatternIdentifiers.ToggleStateProperty,
+                    ToState(e.GetOldValue<bool>()),
+                    ToState(e.GetNewValue<bool>()));
+            }
+        }
+
+        private static ToggleState ToState(bool value)
+            => value ? ToggleState.On : ToggleState.Off;
     }
 }
diff --git a/tests/Avalonia.Controls.UnitTests/Automation/MenuItemAutomationPeerTests.cs b/tests/Avalonia.Controls.UnitTests/Automation/MenuItemAutomationPeerTests.cs
new file mode 100644
index 0000000000..0ef10c9a01
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/Automation/MenuItemAutomationPeerTests.cs
@@ -0,0 +1,95 @@
+using Avalonia.Automation;
+using Avalonia.Automation.Peers;
+using Avalonia.Automation.Provider;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests.Automation;
+
+public class MenuItemAutomationPeerTests : ScopedTestBase
+{
+    private static IToggleProvider GetProvider(MenuItem menuItem)
+    {
+        var provider = ControlAutomationPeer.CreatePeerForElement(menuItem).GetProvider<IToggleProvider>();
+        Assert.NotNull(provider);
+        return provider;
+    }
+
+    [Fact]
+    public void Toggle_Provider_Is_Not_Exposed_When_ToggleType_None()
+    {
+        var peer = ControlAutomationPeer.CreatePeerForElement(new MenuItem());
+
+        Assert.Null(peer.GetProvider<IToggleProvider>());
+    }
+
+    [Theory]
+    [InlineData(MenuItemToggleType.CheckBox)]
+    [InlineData(MenuItemToggleType.Radio)]
+    public void Toggle_Provider_Is_Exposed_For_Checkable_Items(MenuItemToggleType toggleType)
+    {
+        var peer = ControlAutomationPeer.CreatePeerForElement(new MenuItem { ToggleType = toggleType });
+
+        Assert.NotNull(peer.GetProvider<IToggleProvider>());
+    }
+
+    [Fact]
+    public void ToggleState_Reflects_IsChecked()
+    {
+        var menuItem = new MenuItem { ToggleType = MenuItemToggleType.CheckBox };
+        var provider = GetProvider(menuItem);
+
+        Assert.Equal(ToggleState.Off, provider.ToggleState);
+        menuItem.IsChecked = true;
+        Assert.Equal(ToggleState.On, provider.ToggleState);
+    }
+
+    [Fact]
+    public void Toggle_Flips_CheckBox_Item()
+    {
+        var menuItem = new MenuItem { ToggleType = MenuItemToggleType.CheckBox };
+        var provider = GetProvider(menuItem);
+
+        provider.Toggle();
+        Assert.True(menuItem.IsChecked);
+
+        provider.Toggle();
+        Assert.False(menuItem.IsChecked);
+    }
+
+    [Fact]
+    public void Toggle_Checks_But_Does_Not_Uncheck_Radio_Item()
+    {
+        var menuItem = new MenuItem { ToggleType = MenuItemToggleType.Radio };
+        var provider = GetProvider(menuItem);
+
+        provider.Toggle();
+        Assert.True(menuItem.IsChecked);
+
+        provider.Toggle();
+        Assert.True(menuItem.IsChecked);
+    }
+
+    [Fact]
+    public void Toggle_Raises_ToggleState_PropertyChanged()
+    {
+        var menuItem = new MenuItem { ToggleType = MenuItemToggleType.CheckBox };
+        var peer = ControlAutomationPeer.CreatePeerForElement(menuItem);
+        var provider = GetProvider(menuItem);
+
+        var raised = 0;
+        peer.PropertyChanged += (_, e) =>
+        {
+            if (e.Property == TogglePatternIdentifiers.ToggleStateProperty)
+            {
+                Assert.Equal(ToggleState.Off, e.OldValue);
+                Assert.Equal(ToggleState.On, e.NewValue);
+                raised++;
+            }
+        };
+
+        provider.Toggle();
+
+        Assert.Equal(1, raised);
+    }
+}

From 269d0f2b8e2a2972b2c4e750163b3417f60eddee Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Thu, 11 Jun 2026 02:51:00 +0800
Subject: [PATCH 006/196] Expose Calendar day button selection state to
 automation (#21540)

* Add CalendarDayButtonAutomationPeer with SelectionItem pattern

* Guard day button selection against None mode and blackout days, add peer tests

* Use NotNullWhen instead of null-forgiving out parameter
---
 .../Peers/CalendarDayButtonAutomationPeer.cs  |  78 ++++++++
 .../Calendar/CalendarDayButton.cs             |   3 +
 .../CalendarDayButtonAutomationPeerTests.cs   | 166 ++++++++++++++++++
 3 files changed, 247 insertions(+)
 create mode 100644 src/Avalonia.Controls/Automation/Peers/CalendarDayButtonAutomationPeer.cs
 create mode 100644 tests/Avalonia.Controls.UnitTests/Automation/CalendarDayButtonAutomationPeerTests.cs

diff --git a/src/Avalonia.Controls/Automation/Peers/CalendarDayButtonAutomationPeer.cs b/src/Avalonia.Controls/Automation/Peers/CalendarDayButtonAutomationPeer.cs
new file mode 100644
index 0000000000..49a56e7aea
--- /dev/null
+++ b/src/Avalonia.Controls/Automation/Peers/CalendarDayButtonAutomationPeer.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Avalonia.Automation.Provider;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+
+namespace Avalonia.Automation.Peers
+{
+    public class CalendarDayButtonAutomationPeer : ButtonAutomationPeer, ISelectionItemProvider
+    {
+        public CalendarDayButtonAutomationPeer(CalendarDayButton owner)
+            : base(owner)
+        {
+        }
+
+        public new CalendarDayButton Owner => (CalendarDayButton)base.Owner;
+
+        public bool IsSelected => Owner.IsSelected;
+
+        public ISelectionProvider? SelectionContainer
+            => Owner.Owner is { } calendar
+                ? GetOrCreate(calendar).GetProvider<ISelectionProvider>()
+                : null;
+
+        public void Select()
+        {
+            EnsureEnabled();
+
+            if (TryGetSelectableDate(out var calendar, out var date))
+                calendar.SelectedDate = date;
+        }
+
+        void ISelectionItemProvider.AddToSelection()
+        {
+            EnsureEnabled();
+
+            if (!TryGetSelectableDate(out var calendar, out var date) ||
+                calendar.SelectedDates.Contains(date))
+            {
+                return;
+            }
+
+            if (calendar.SelectionMode == CalendarSelectionMode.SingleDate)
+                calendar.SelectedDate = date;
+            else
+                calendar.SelectedDates.Add(date);
+        }
+
+        void ISelectionItemProvider.RemoveFromSelection()
+        {
+            EnsureEnabled();
+
+            if (Owner.Owner is { SelectionMode: not CalendarSelectionMode.None } calendar &&
+                Owner.DataContext is DateTime date)
+            {
+                calendar.SelectedDates.Remove(date);
+            }
+        }
+
+        private bool TryGetSelectableDate([NotNullWhen(true)] out Calendar? calendar, out DateTime date)
+        {
+            if (Owner.Owner is { SelectionMode: not CalendarSelectionMode.None } owner &&
+                Owner.DataContext is DateTime value &&
+                !Owner.IsBlackout)
+            {
+                calendar = owner;
+                date = value;
+                return true;
+            }
+
+            calendar = null;
+            date = default;
+            return false;
+        }
+
+        protected override string GetClassNameCore() => nameof(CalendarDayButton);
+    }
+}
diff --git a/src/Avalonia.Controls/Calendar/CalendarDayButton.cs b/src/Avalonia.Controls/Calendar/CalendarDayButton.cs
index c8556e444c..40a12e4ef5 100644
--- a/src/Avalonia.Controls/Calendar/CalendarDayButton.cs
+++ b/src/Avalonia.Controls/Calendar/CalendarDayButton.cs
@@ -5,6 +5,7 @@
 
 using System;
 using System.Globalization;
+using Avalonia.Automation.Peers;
 using Avalonia.Controls.Metadata;
 using Avalonia.Input;
 
@@ -157,6 +158,8 @@ namespace Avalonia.Controls.Primitives
             SetPseudoClasses();
         }
 
+        protected override AutomationPeer OnCreateAutomationPeer() => new CalendarDayButtonAutomationPeer(this);
+
         private void SetPseudoClasses()
         {
             if (_ignoringMouseOverState)
diff --git a/tests/Avalonia.Controls.UnitTests/Automation/CalendarDayButtonAutomationPeerTests.cs b/tests/Avalonia.Controls.UnitTests/Automation/CalendarDayButtonAutomationPeerTests.cs
new file mode 100644
index 0000000000..e4ac2de39a
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/Automation/CalendarDayButtonAutomationPeerTests.cs
@@ -0,0 +1,166 @@
+using System;
+using Avalonia.Automation.Peers;
+using Avalonia.Automation.Provider;
+using Avalonia.Controls.Primitives;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests.Automation;
+
+public class CalendarDayButtonAutomationPeerTests : ScopedTestBase
+{
+    private static readonly DateTime Date1 = new(2026, 6, 5);
+    private static readonly DateTime Date2 = new(2026, 6, 10);
+
+    private static (Calendar, CalendarDayButton, ISelectionItemProvider) CreateTarget(
+        CalendarSelectionMode mode, DateTime? date = null)
+    {
+        var calendar = new Calendar { SelectionMode = mode };
+        var dayButton = new CalendarDayButton { Owner = calendar, DataContext = date ?? Date1 };
+        var peer = ControlAutomationPeer.CreatePeerForElement(dayButton);
+        return (calendar, dayButton, Assert.IsAssignableFrom<ISelectionItemProvider>(peer));
+    }
+
+    [Fact]
+    public void Creates_CalendarDayButtonAutomationPeer()
+    {
+        var peer = ControlAutomationPeer.CreatePeerForElement(new CalendarDayButton());
+
+        Assert.IsType<CalendarDayButtonAutomationPeer>(peer);
+        Assert.IsAssignableFrom<ISelectionItemProvider>(peer);
+        Assert.IsAssignableFrom<IInvokeProvider>(peer);
+    }
+
+    [Fact]
+    public void IsSelected_Reflects_Owner_State()
+    {
+        var (_, dayButton, provider) = CreateTarget(CalendarSelectionMode.SingleDate);
+
+        Assert.False(provider.IsSelected);
+        dayButton.IsSelected = true;
+        Assert.True(provider.IsSelected);
+    }
+
+    [Fact]
+    public void SelectionContainer_Is_Calendar_Peer()
+    {
+        var (calendar, _, provider) = CreateTarget(CalendarSelectionMode.SingleDate);
+
+        var container = provider.SelectionContainer;
+
+        Assert.NotNull(container);
+        Assert.Same(ControlAutomationPeer.CreatePeerForElement(calendar), container);
+    }
+
+    [Fact]
+    public void Select_Sets_SelectedDate()
+    {
+        var (calendar, _, provider) = CreateTarget(CalendarSelectionMode.SingleDate);
+
+        provider.Select();
+
+        Assert.Equal(Date1, calendar.SelectedDate);
+    }
+
+    [Fact]
+    public void Select_Replaces_Existing_Selection_In_SingleDate_Mode()
+    {
+        var (calendar, _, provider) = CreateTarget(CalendarSelectionMode.SingleDate);
+        calendar.SelectedDate = Date2;
+
+        provider.Select();
+
+        Assert.Equal(Date1, calendar.SelectedDate);
+        Assert.Equal(1, calendar.SelectedDates.Count);
+    }
+
+    [Fact]
+    public void Select_Is_NoOp_When_SelectionMode_None()
+    {
+        var (calendar, _, provider) = CreateTarget(CalendarSelectionMode.None);
+
+        provider.Select();
+
+        Assert.Null(calendar.SelectedDate);
+        Assert.Empty(calendar.SelectedDates);
+    }
+
+    [Fact]
+    public void Select_Is_NoOp_For_Blackout_Day()
+    {
+        var (calendar, dayButton, provider) = CreateTarget(CalendarSelectionMode.SingleDate);
+        dayButton.IsBlackout = true;
+
+        provider.Select();
+
+        Assert.Null(calendar.SelectedDate);
+    }
+
+    [Fact]
+    public void AddToSelection_Replaces_Selection_In_SingleDate_Mode()
+    {
+        var (calendar, _, provider) = CreateTarget(CalendarSelectionMode.SingleDate);
+        calendar.SelectedDate = Date2;
+
+        provider.AddToSelection();
+
+        Assert.Equal(Date1, calendar.SelectedDate);
+        Assert.Equal(1, calendar.SelectedDates.Count);
+    }
+
+    [Fact]
+    public void AddToSelection_Appends_In_MultipleRange_Mode()
+    {
+        var (calendar, _, provider) = CreateTarget(CalendarSelectionMode.MultipleRange);
+        calendar.SelectedDates.Add(Date2);
+
+        provider.AddToSelection();
+
+        Assert.Equal(2, calendar.SelectedDates.Count);
+        Assert.Contains(Date1, calendar.SelectedDates);
+        Assert.Contains(Date2, calendar.SelectedDates);
+    }
+
+    [Fact]
+    public void AddToSelection_Is_NoOp_When_SelectionMode_None()
+    {
+        var (calendar, _, provider) = CreateTarget(CalendarSelectionMode.None);
+
+        provider.AddToSelection();
+
+        Assert.Empty(calendar.SelectedDates);
+    }
+
+    [Fact]
+    public void AddToSelection_Is_NoOp_For_Blackout_Day()
+    {
+        var (calendar, dayButton, provider) = CreateTarget(CalendarSelectionMode.MultipleRange);
+        dayButton.IsBlackout = true;
+
+        provider.AddToSelection();
+
+        Assert.Empty(calendar.SelectedDates);
+    }
+
+    [Fact]
+    public void RemoveFromSelection_Removes_Date()
+    {
+        var (calendar, _, provider) = CreateTarget(CalendarSelectionMode.MultipleRange);
+        calendar.SelectedDates.Add(Date1);
+        calendar.SelectedDates.Add(Date2);
+
+        provider.RemoveFromSelection();
+
+        Assert.Equal(Date2, Assert.Single(calendar.SelectedDates));
+    }
+
+    [Fact]
+    public void RemoveFromSelection_Is_NoOp_When_SelectionMode_None()
+    {
+        var (calendar, _, provider) = CreateTarget(CalendarSelectionMode.None);
+
+        provider.RemoveFromSelection();
+
+        Assert.Empty(calendar.SelectedDates);
+    }
+}

From 905e620b820925363e62da11075910f82bccee16 Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Thu, 11 Jun 2026 20:13:14 +0800
Subject: [PATCH 007/196] Support Value pattern on editable ComboBox automation
 peer (#21545)

* Support Value pattern on editable ComboBox automation peer

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 .../Peers/ComboBoxAutomationPeer.cs           | 34 +++++++-
 .../Automation/ComboBoxAutomationPeerTests.cs | 78 +++++++++++++++++++
 2 files changed, 108 insertions(+), 4 deletions(-)
 create mode 100644 tests/Avalonia.Controls.UnitTests/Automation/ComboBoxAutomationPeerTests.cs

diff --git a/src/Avalonia.Controls/Automation/Peers/ComboBoxAutomationPeer.cs b/src/Avalonia.Controls/Automation/Peers/ComboBoxAutomationPeer.cs
index 5d71e7a8e4..7f629db9e2 100644
--- a/src/Avalonia.Controls/Automation/Peers/ComboBoxAutomationPeer.cs
+++ b/src/Avalonia.Controls/Automation/Peers/ComboBoxAutomationPeer.cs
@@ -22,19 +22,28 @@ namespace Avalonia.Automation.Peers
         public bool ShowsMenu => true;
         public void Collapse() => Owner.IsDropDownOpen = false;
         public void Expand() => Owner.IsDropDownOpen = true;
-        bool IValueProvider.IsReadOnly => true;
+        bool IValueProvider.IsReadOnly => !Owner.IsEditable;
 
         string? IValueProvider.Value
         {
             get
             {
+                if (Owner.IsEditable)
+                    return Owner.Text;
+
                 var selection = GetSelection();
                 return selection.Count == 1 ? selection[0].GetName() : null;
             }
         }
-        
-        void IValueProvider.SetValue(string? value) => throw new NotSupportedException();
-        
+
+        void IValueProvider.SetValue(string? value)
+        {
+            if (!Owner.IsEditable)
+                throw new InvalidOperationException("Cannot set the value of a non-editable ComboBox.");
+
+            Owner.SetCurrentValue(ComboBox.TextProperty, value);
+        }
+
         protected override AutomationControlType GetAutomationControlTypeCore()
         {
             return AutomationControlType.ComboBox;
@@ -69,6 +78,23 @@ namespace Avalonia.Automation.Peers
                     ToState((bool)e.OldValue!),
                     ToState((bool)e.NewValue!));
             }
+            else if (e.Property == ComboBox.TextProperty && Owner.IsEditable)
+            {
+                RaisePropertyChangedEvent(
+                    ValuePatternIdentifiers.ValueProperty,
+                    e.OldValue as string,
+                    e.NewValue as string);
+            }
+            else if (e.Property == ComboBox.IsEditableProperty)
+            {
+                RaisePropertyChangedEvent(
+                    ValuePatternIdentifiers.IsReadOnlyProperty,
+                    !(bool)e.OldValue!,
+                    !(bool)e.NewValue!);
+
+                // The Value pattern switches between SelectedItem name and Text when IsEditable changes.
+                RaisePropertyChangedEvent(ValuePatternIdentifiers.ValueProperty, null, null);
+            }
         }
 
         private static ExpandCollapseState ToState(bool value)
diff --git a/tests/Avalonia.Controls.UnitTests/Automation/ComboBoxAutomationPeerTests.cs b/tests/Avalonia.Controls.UnitTests/Automation/ComboBoxAutomationPeerTests.cs
new file mode 100644
index 0000000000..fde3f2f8bd
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/Automation/ComboBoxAutomationPeerTests.cs
@@ -0,0 +1,78 @@
+using Avalonia.Automation;
+using Avalonia.Automation.Peers;
+using Avalonia.Automation.Provider;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests.Automation;
+
+public class ComboBoxAutomationPeerTests : ScopedTestBase
+{
+    private static IValueProvider Value(ComboBox comboBox)
+        => Assert.IsAssignableFrom<IValueProvider>(ControlAutomationPeer.CreatePeerForElement(comboBox));
+
+    [Fact]
+    public void Non_Editable_ComboBox_Is_ReadOnly()
+    {
+        var provider = Value(new ComboBox());
+
+        Assert.True(provider.IsReadOnly);
+    }
+
+    [Fact]
+    public void Editable_ComboBox_Is_Not_ReadOnly()
+    {
+        var provider = Value(new ComboBox { IsEditable = true });
+
+        Assert.False(provider.IsReadOnly);
+    }
+
+    [Fact]
+    public void Value_Returns_Text_When_Editable()
+    {
+        var provider = Value(new ComboBox { IsEditable = true, Text = "hello" });
+
+        Assert.Equal("hello", provider.Value);
+    }
+
+    [Fact]
+    public void SetValue_Updates_Text_When_Editable()
+    {
+        var comboBox = new ComboBox { IsEditable = true };
+        var provider = Value(comboBox);
+
+        provider.SetValue("typed");
+
+        Assert.Equal("typed", comboBox.Text);
+        Assert.Equal("typed", provider.Value);
+    }
+
+    [Fact]
+    public void SetValue_Throws_When_Not_Editable()
+    {
+        var provider = Value(new ComboBox());
+
+        Assert.Throws<System.InvalidOperationException>(() => provider.SetValue("x"));
+    }
+
+    [Fact]
+    public void Text_Change_Raises_Value_PropertyChanged()
+    {
+        var comboBox = new ComboBox { IsEditable = true };
+        var peer = ControlAutomationPeer.CreatePeerForElement(comboBox);
+
+        var raised = 0;
+        peer.PropertyChanged += (_, e) =>
+        {
+            if (e.Property == ValuePatternIdentifiers.ValueProperty)
+            {
+                Assert.Equal("abc", e.NewValue);
+                raised++;
+            }
+        };
+
+        comboBox.Text = "abc";
+
+        Assert.Equal(1, raised);
+    }
+}

From b7e173ab432075937327c75c614fde8f0417c3fe Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Thu, 11 Jun 2026 12:20:43 +0000
Subject: [PATCH 008/196] add support for hover events on android (#21551)

---
 src/Android/Avalonia.Android/AvaloniaView.Input.cs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/Android/Avalonia.Android/AvaloniaView.Input.cs b/src/Android/Avalonia.Android/AvaloniaView.Input.cs
index c829be56be..4862daaf0b 100644
--- a/src/Android/Avalonia.Android/AvaloniaView.Input.cs
+++ b/src/Android/Avalonia.Android/AvaloniaView.Input.cs
@@ -27,7 +27,13 @@ namespace Avalonia.Android
 
         protected override bool DispatchHoverEvent(MotionEvent? e)
         {
-            return _accessHelper.DispatchHoverEvent(e!) || base.DispatchHoverEvent(e);
+            var res = _view.PointerHelper.DispatchMotionEvent(e, out var callBase);
+            if (res == false)
+                callBase = !_accessHelper.DispatchHoverEvent(e!) && callBase;
+
+            var baseResult = callBase && base.DispatchHoverEvent(e);
+
+            return res ?? baseResult;
         }
 
         protected override bool DispatchGenericPointerEvent(MotionEvent? e)

From 289f9d76c8aaaffe82e49bb93798fc108c386ce9 Mon Sep 17 00:00:00 2001
From: Max Katz <maxkatz6@outlook.com>
Date: Thu, 11 Jun 2026 06:39:22 -0700
Subject: [PATCH 009/196] Enhance Roslyn-compiler visible metadata (#21546)

* Move "AdditionalFiles Include="@(AvaloniaXaml)"" to common AvaloniaBuildTasks

* Add AdditionalFiles Include="@(AvaloniaResource)"

* Add a comment

* Add extra CompilerVisibleProperty

* Rename _InjectAvaloniaAdditionalFiles, make it more specific...

* Do not duplicate AdditionalFiles with AvaloniaXaml AvaloniaResource
---
 packages/Avalonia/AvaloniaBuildTasks.targets          | 11 +++++++++++
 .../Avalonia.Generators/Avalonia.Generators.props     | 11 ++++++-----
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/packages/Avalonia/AvaloniaBuildTasks.targets b/packages/Avalonia/AvaloniaBuildTasks.targets
index d3750935f9..9ed50e6137 100644
--- a/packages/Avalonia/AvaloniaBuildTasks.targets
+++ b/packages/Avalonia/AvaloniaBuildTasks.targets
@@ -39,6 +39,17 @@
                       Condition="'$(ApplicationIcon)' != ''" />
   </ItemGroup>
 
+  <!-- Include AvaloniaXaml and AvaloniaResource as a Roslyn-visible additional files -->
+  <!-- This is necessary to use these files in source generators and other Roslyn-based extension -->
+  <Target Name="_InjectAvaloniaAdditionalFiles" BeforeTargets="GenerateMSBuildEditorConfigFileShouldRun">
+    <ItemGroup>
+      <AdditionalFiles Include="@(AvaloniaXaml)" SourceItemGroup="AvaloniaXaml" />
+      <_AvaloniaResourceOnly Include="@(AvaloniaResource)"
+                             Exclude="@(AvaloniaXaml)" />
+      <AdditionalFiles Include="@(_AvaloniaResourceOnly)" SourceItemGroup="AvaloniaResource" />
+    </ItemGroup>
+  </Target>
+
   <UsingTask TaskName="GenerateAvaloniaResourcesTask"
              AssemblyFile="$(AvaloniaBuildTasksLocation)"
              />
diff --git a/src/tools/Avalonia.Generators/Avalonia.Generators.props b/src/tools/Avalonia.Generators/Avalonia.Generators.props
index 7eb3adff3d..3712b390ee 100644
--- a/src/tools/Avalonia.Generators/Avalonia.Generators.props
+++ b/src/tools/Avalonia.Generators/Avalonia.Generators.props
@@ -9,7 +9,9 @@
     <AvaloniaNameGeneratorAttachDevTools Condition="'$(AvaloniaNameGeneratorAttachDevTools)' == ''">true</AvaloniaNameGeneratorAttachDevTools>
   </PropertyGroup>
   <ItemGroup>
+    <!-- Mark AvaloniaXaml/AvaloniaResource metadata visible for the Roslyn-compiler -->
     <CompilerVisibleItemMetadata Include="AdditionalFiles" MetadataName="SourceItemGroup"/>
+    <!-- Mark Avalonia.Generators config properties visible for the Roslyn-compiler  -->
     <CompilerVisibleProperty Include="AvaloniaNameGeneratorIsEnabled" />
     <CompilerVisibleProperty Include="AvaloniaNameGeneratorBehavior" />
     <CompilerVisibleProperty Include="AvaloniaNameGeneratorDefaultFieldModifier" />
@@ -17,10 +19,9 @@
     <CompilerVisibleProperty Include="AvaloniaNameGeneratorFilterByNamespace" />
     <CompilerVisibleProperty Include="AvaloniaNameGeneratorViewFileNamingStrategy" />
     <CompilerVisibleProperty Include="AvaloniaNameGeneratorAttachDevTools"/>
+    <!-- Mark additional Avalonia properties that might be useful for the Roslyn-compiler -->
+    <CompilerVisibleProperty Include="AvaloniaUseCompiledBindingsByDefault" />
+    <CompilerVisibleProperty Include="AvaloniaMainPackageVersion" />
+    <CompilerVisibleProperty Include="AvaloniaPreviewerNetCoreToolPath" />
   </ItemGroup>
-  <Target Name="_InjectAdditionalFiles" BeforeTargets="GenerateMSBuildEditorConfigFileShouldRun">
-    <ItemGroup>
-      <AdditionalFiles Include="@(AvaloniaXaml)" SourceItemGroup="AvaloniaXaml" />
-    </ItemGroup>
-  </Target>
 </Project>

From 486df8acbadadcbc6ab462e29ece840ddacc65e6 Mon Sep 17 00:00:00 2001
From: deryaza <46353085+deryaza@users.noreply.github.com>
Date: Thu, 11 Jun 2026 18:44:02 +0400
Subject: [PATCH 010/196] Fix mishandled cancellation in
 DBusTextInputMethodBase (#21527)

* Fix mishandled cancellation in DBusTextInputMethodBase

* Revert "Fix mishandled cancellation in DBusTextInputMethodBase"

This reverts commit ac18b6d878d08abb8bd19c12fd6cb933b3e37da6.

* review
---
 .../DBusIme/DBusTextInputMethodBase.cs              | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/Avalonia.FreeDesktop/DBusIme/DBusTextInputMethodBase.cs b/src/Avalonia.FreeDesktop/DBusIme/DBusTextInputMethodBase.cs
index cfd28b29aa..236276f805 100644
--- a/src/Avalonia.FreeDesktop/DBusIme/DBusTextInputMethodBase.cs
+++ b/src/Avalonia.FreeDesktop/DBusIme/DBusTextInputMethodBase.cs
@@ -64,9 +64,9 @@ namespace Avalonia.FreeDesktop.DBusIme
             _watchCts = new CancellationTokenSource();
             var cancellationToken = _watchCts.Token;
             foreach (var name in _knownNames)
-                WatchNameAsync(name);
+                _ = WatchNameAsync(name);
 
-            async void WatchNameAsync(string name)
+            async Task WatchNameAsync(string name)
             {
                 try
                 {
@@ -99,10 +99,13 @@ namespace Avalonia.FreeDesktop.DBusIme
                         OnOwnerChanged(name, owner);
                     }
                 }
-                catch (Exception e) when (!cancellationToken.IsCancellationRequested)
+                catch (Exception e)
                 {
-                    Logger.TryGet(LogEventLevel.Error, LogArea.FreeDesktopPlatform)
-                        ?.Log(this, $"WatchNameOwner for '{name}' failed: {e}");
+                    if (!cancellationToken.IsCancellationRequested)
+                    {
+                        Logger.TryGet(LogEventLevel.Error, LogArea.FreeDesktopPlatform)
+                            ?.Log(this, $"WatchNameOwner for '{name}' failed: {e}");
+                    }
                 }
             }
         }

From e00089a29fa6894f5271702bb6e3a3be9688360d Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Thu, 11 Jun 2026 17:14:54 +0200
Subject: [PATCH 011/196] Fix caption button background in dark mode (#21555)

---
 src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml | 2 +-
 src/Avalonia.Themes.Simple/Accents/Base.xaml                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml b/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml
index 80778a50db..f7d04ccd9b 100644
--- a/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml
+++ b/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml
@@ -1651,7 +1651,7 @@
 
       <!-- BaseResources for WindowDrawnDecorations.xaml -->
       <SolidColorBrush x:Key="CaptionButtonForeground" Color="White" />
-      <SolidColorBrush x:Key="CaptionButtonBackground" Color="#ffe5e5e5" />
+      <SolidColorBrush x:Key="CaptionButtonBackground" Color="#ff1d170f" />
       <SolidColorBrush x:Key="CaptionButtonBorderBrush" Color="#ffcacaca" />
       <StaticResource x:Key="TitleBarBackgroundBrush" ResourceKey="SystemControlBackgroundAltHighBrush" />
     </ResourceDictionary>
diff --git a/src/Avalonia.Themes.Simple/Accents/Base.xaml b/src/Avalonia.Themes.Simple/Accents/Base.xaml
index c81ba824d8..8b10f2735e 100644
--- a/src/Avalonia.Themes.Simple/Accents/Base.xaml
+++ b/src/Avalonia.Themes.Simple/Accents/Base.xaml
@@ -90,7 +90,7 @@
 
       <!-- BaseResources for WindowDrawnDecorations.xaml -->
       <SolidColorBrush x:Key="CaptionButtonForeground" Color="White" />
-      <SolidColorBrush x:Key="CaptionButtonBackground" Color="#ffe5e5e5" />
+      <SolidColorBrush x:Key="CaptionButtonBackground" Color="#ff1d170f" />
       <SolidColorBrush x:Key="CaptionButtonBorderBrush" Color="#ffcacaca" />
       <StaticResource x:Key="TitleBarBackgroundBrush" ResourceKey="ThemeBackgroundBrush" />
     </ResourceDictionary>

From 40033c104ffe1f5dc053224b4cc4f927261a0aee Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Fri, 12 Jun 2026 03:21:46 +0800
Subject: [PATCH 012/196] Expose placeholder text as the AT-SPI
 placeholder-text attribute (#21554)

* Expose placeholder text to UIA and AT-SPI automation

* Drop the UIA PlaceholderText property; placeholder is already exposed via HelpText on Windows
---
 .../Handlers/AtSpiAccessibleHandler.cs                        | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiAccessibleHandler.cs b/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiAccessibleHandler.cs
index 4e674a9ed5..ecca97de79 100644
--- a/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiAccessibleHandler.cs
+++ b/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiAccessibleHandler.cs
@@ -150,6 +150,10 @@ namespace Avalonia.FreeDesktop.AtSpi.Handlers
             if (!string.IsNullOrEmpty(accessKey))
                 attrs["access-key"] = accessKey;
 
+            var placeholderText = node.Peer.GetPlaceholderText();
+            if (!string.IsNullOrEmpty(placeholderText))
+                attrs["placeholder-text"] = placeholderText;
+
             return ValueTask.FromResult(attrs);
         }
 

From baa1e0127723f8ffccd01b935c14a3b3dd670f5d Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Fri, 12 Jun 2026 09:37:33 +0200
Subject: [PATCH 013/196] Fix system font caching when retrieved with a
 different name (#21557)

* Add failing cache test for font retrieved with different name

* Fix system font caching when retrieved with a different name
---
 .../Media/Fonts/SystemFontCollection.cs       |   4 +
 .../Media/FontManagerTests.cs                 | 106 ++++++++++++++++++
 2 files changed, 110 insertions(+)

diff --git a/src/Avalonia.Base/Media/Fonts/SystemFontCollection.cs b/src/Avalonia.Base/Media/Fonts/SystemFontCollection.cs
index c7b013729c..390f4f4719 100644
--- a/src/Avalonia.Base/Media/Fonts/SystemFontCollection.cs
+++ b/src/Avalonia.Base/Media/Fonts/SystemFontCollection.cs
@@ -67,6 +67,10 @@ namespace Avalonia.Media.Fonts
 
             //Add to cache with platform typeface family name first
             TryAddGlyphTypeface(platformTypeface.FamilyName, key, glyphTypeface);
+            
+            // Then the requested family name
+            if (familyName != platformTypeface.FamilyName)
+                TryAddGlyphTypeface(familyName, key, glyphTypeface);
 
             //Add to cache
             if (!TryAddGlyphTypeface(glyphTypeface))
diff --git a/tests/Avalonia.Skia.UnitTests/Media/FontManagerTests.cs b/tests/Avalonia.Skia.UnitTests/Media/FontManagerTests.cs
index b0d6e1bfd1..4f171b29ad 100644
--- a/tests/Avalonia.Skia.UnitTests/Media/FontManagerTests.cs
+++ b/tests/Avalonia.Skia.UnitTests/Media/FontManagerTests.cs
@@ -1,5 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.IO;
 using Avalonia.Fonts.Inter;
 using Avalonia.Logging;
 using Avalonia.Media;
@@ -643,5 +646,108 @@ namespace Avalonia.Skia.UnitTests.Media
             Assert.True(FontManager.Current.TryGetGlyphTypeface(new Typeface("Inter", FontStyle.Normal, (FontWeight)650), out var nearestMatchTypeface));
             Assert.Same(boldGlyphTypeface, nearestMatchTypeface);
         }
+
+        [Fact]
+        public void TryGetGlyphTypeface_Should_Cache_Matched_GlyphTypeface_Under_Requested_FamilyName()
+        {
+            var fontManagerImpl = new FamilyRemappingFontManagerImpl("NotInstalled", "Noto Mono");
+            using var app = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface.With(fontManagerImpl: fontManagerImpl));
+
+            // "NotInstalled" is not installed, so the platform substitutes it with a different
+            // family ("Noto Mono"), much like requesting "Arial" yields "Liberation Sans" on some Linux distributions.
+            Assert.True(FontManager.Current.TryGetGlyphTypeface(new Typeface("NotInstalled"), out var first));
+            Assert.Equal("Noto Mono", first.FamilyName);
+
+            // The substitute should now be cached under the requested "NotInstalled" name, so a second
+            // lookup must resolve from the cache instead of asking the platform again.
+            Assert.True(FontManager.Current.TryGetGlyphTypeface(new Typeface("NotInstalled"), out var second));
+            Assert.Same(first, second);
+            Assert.Equal(1, fontManagerImpl.RequestedFamilyCreateCount);
+        }
+
+        /// <summary>
+        /// A font manager whose every by-name lookup resolves to a single matched font whose family name
+        /// differs from the requested one.
+        /// </summary>
+        private sealed class FamilyRemappingFontManagerImpl(string requestedFamilyName, string matchedFamilyName)
+            : IFontManagerImpl, IDisposable
+        {
+            public int RequestedFamilyCreateCount { get; private set; }
+
+            public string GetDefaultFontFamilyName() 
+                => matchedFamilyName;
+
+            public string[] GetInstalledFontFamilyNames(bool checkForUpdates = false) 
+                => [matchedFamilyName];
+
+            public bool TryCreateGlyphTypeface(
+                string familyName,
+                FontStyle style,
+                FontWeight weight,
+                FontStretch stretch,
+                [NotNullWhen(true)] out IPlatformTypeface? platformTypeface)
+            {
+                if (string.Equals(familyName, requestedFamilyName, StringComparison.OrdinalIgnoreCase))
+                    RequestedFamilyCreateCount++;
+
+                platformTypeface = new SkiaTypeface(CreateMatchedTypeface(), FontSimulations.None);
+                return true;
+            }
+
+            public bool TryCreateGlyphTypeface(
+                Stream stream,
+                FontSimulations fontSimulations,
+                [NotNullWhen(true)] out IPlatformTypeface? platformTypeface)
+            {
+                platformTypeface = new SkiaTypeface(SKTypeface.FromStream(stream), fontSimulations);
+                return true;
+            }
+
+            public bool TryMatchCharacter(
+                int codepoint,
+                FontStyle fontStyle,
+                FontWeight fontWeight,
+                FontStretch fontStretch,
+                string? familyName,
+                CultureInfo? culture,
+                [NotNullWhen(true)] out IPlatformTypeface? platformTypeface)
+            {
+                platformTypeface = null;
+                return false;
+            }
+
+            public bool TryGetFamilyTypefaces(string familyName, [NotNullWhen(true)] out IReadOnlyList<Typeface>? familyTypefaces)
+            {
+                familyTypefaces = null;
+                return false;
+            }
+
+            private SKTypeface CreateMatchedTypeface()
+            {
+                var assetLoader = AvaloniaLocator.Current.GetRequiredService<IAssetLoader>();
+
+                // LoadFontAssets ignores the family fragment and returns every embedded font asset,
+                // so pick the one whose family name matches the substitute we want to return.
+                foreach (var fontAsset in FontFamilyLoader.LoadFontAssets(new Uri(s_fontUri)))
+                {
+                    var stream = assetLoader.Open(fontAsset);
+                    var typeface = SKTypeface.FromStream(stream);
+
+                    if (typeface is not null && 
+                        string.Equals(typeface.FamilyName, matchedFamilyName, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return typeface;
+                    }
+
+                    typeface?.Dispose();
+                }
+
+                throw new InvalidOperationException($"Could not load the '{matchedFamilyName}' font asset.");
+            }
+
+            public void Dispose()
+            {
+            }
+        }
     }
 }

From 892e9e1352385da60d690b375ea7038bbf549ba8 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Mon, 15 Jun 2026 09:48:38 +0200
Subject: [PATCH 014/196] Disable region dirty rect clipping by default
 (#21553)

---
 .../Rendering/Composition/Server/ServerCompositionTarget.cs     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionTarget.cs b/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionTarget.cs
index 8137dbf87d..3ce37aec28 100644
--- a/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionTarget.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionTarget.cs
@@ -62,7 +62,7 @@ namespace Avalonia.Rendering.Composition.Server
             _overlays = new CompositionTargetOverlays(this);
             var platformRender = AvaloniaLocator.Current.GetService<IPlatformRenderInterface>();
 
-            if (platformRender?.SupportsRegions == true && compositor.Options.UseRegionDirtyRectClipping != false)
+            if (platformRender?.SupportsRegions == true && compositor.Options.UseRegionDirtyRectClipping == true)
             {
                 var maxRects = compositor.Options.MaxDirtyRects ?? 8;
                 DirtyRects = maxRects <= 0

From aa1fcb4871ce71d55fe33cfd6be3f7e0c67ae2ef Mon Sep 17 00:00:00 2001
From: Matt <5415177+ZehMatt@users.noreply.github.com>
Date: Mon, 15 Jun 2026 13:17:51 +0300
Subject: [PATCH 015/196] Refactor per-draw render data allocations with a
 binary opcode stream (#21366)

* Add render data opcode enum

First step of the Drawing/Nodes binary stream refactor.

* Add render data resource table

* Add render data stream writer and reader

Encodes the opcode stream field-by-field via BinaryPrimitives to
avoid unsafe and blittability assumptions.

* Add RenderDataStream with recording and replay

* Add hit-test walker to RenderDataStream

* Add bounds walker to RenderDataStream

* Add render data stream serialization

* Switch render data to the binary stream

* Move node level test coverage to the stream

* Delete the render data node classes

* Small optimization, stackalloc the render data walker scope stacks

* Optimize serialization for blittable types

* Encode render data via payload structs, add render data visitor

* Rename RenderDataResources.Add to AppendDeserialized

* Add effect support to render data stream

* Simplify render data read/write with MemoryMarshal
---
 .../Drawing/CompositionRenderData.cs          |  50 +--
 .../Composition/Drawing/IRenderDataVisitor.cs |  30 ++
 .../ImmediateRenderDataSceneBrushContent.cs   |  54 +--
 .../Drawing/Nodes/RenderDataBitmapNode.cs     |  28 --
 .../Drawing/Nodes/RenderDataEllipseNode.cs    |  61 ---
 .../Drawing/Nodes/RenderDataGeometryNode.cs   |  29 --
 .../Drawing/Nodes/RenderDataGlyphRunNode.cs   |  35 --
 .../Drawing/Nodes/RenderDataLineNode.cs       |  65 ---
 .../Drawing/Nodes/RenderDataNodes.cs          | 294 --------------
 .../Drawing/Nodes/RenderDataPushMatrixNode.cs |  27 --
 .../Nodes/RenderDataPushOpacityMaskNode.cs    |  25 --
 .../Drawing/Nodes/RenderDataRectangleNode.cs  |  46 ---
 .../Drawing/RenderDataDrawingContext.cs       | 370 ++++++++----------
 .../Composition/Drawing/RenderDataOpcode.cs   |  22 ++
 .../Composition/Drawing/RenderDataPayloads.cs | 132 +++++++
 .../Composition/Drawing/RenderDataReader.cs   |  42 ++
 .../Drawing/RenderDataResources.cs            |  54 +++
 .../Drawing/RenderDataStream.Bounds.cs        |  93 +++++
 .../Drawing/RenderDataStream.HitTest.cs       | 250 ++++++++++++
 .../Drawing/RenderDataStream.Replay.cs        | 159 ++++++++
 .../Drawing/RenderDataStream.Visit.cs         | 177 +++++++++
 .../Composition/Drawing/RenderDataStream.cs   | 226 +++++++++++
 .../Composition/Drawing/RenderDataWriter.cs   |  57 +++
 .../Drawing/ServerCompositionRenderData.cs    |  94 ++---
 .../Composition/Transport/BatchStream.cs      |  46 +++
 .../Rendering/RenderDataEffectNodeTests.cs    |  50 ---
 .../SceneGraph/DrawOperationTests.cs          |  76 ----
 .../Rendering/SceneGraph/LineNodeTests.cs     |  67 ----
 .../SceneGraph/RenderDataResourcesTests.cs    | 103 +++++
 .../SceneGraph/RenderDataStreamBoundsTests.cs | 177 +++++++++
 .../SceneGraph/RenderDataStreamEffectTests.cs |  29 ++
 ...=> RenderDataStreamEllipseHitTestTests.cs} |  31 +-
 .../RenderDataStreamHitTestTests.cs           | 208 ++++++++++
 .../RenderDataStreamLineHitTestTests.cs       |  55 +++
 .../RenderDataStreamSerializationTests.cs     |  98 +++++
 .../SceneGraph/RenderDataStreamTests.cs       | 228 +++++++++++
 .../SceneGraph/RenderDataWriterReaderTests.cs | 237 +++++++++++
 37 files changed, 2642 insertions(+), 1183 deletions(-)
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/IRenderDataVisitor.cs
 delete mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataBitmapNode.cs
 delete mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataEllipseNode.cs
 delete mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataGeometryNode.cs
 delete mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataGlyphRunNode.cs
 delete mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataLineNode.cs
 delete mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataNodes.cs
 delete mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataPushMatrixNode.cs
 delete mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataPushOpacityMaskNode.cs
 delete mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataRectangleNode.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataOpcode.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataPayloads.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataReader.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataResources.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Bounds.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.HitTest.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Replay.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Visit.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataWriter.cs
 delete mode 100644 tests/Avalonia.Base.UnitTests/Rendering/RenderDataEffectNodeTests.cs
 delete mode 100644 tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/LineNodeTests.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataResourcesTests.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamBoundsTests.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamEffectTests.cs
 rename tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/{EllipseNodeTests.cs => RenderDataStreamEllipseHitTestTests.cs} (53%)
 create mode 100644 tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamHitTestTests.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamLineHitTestTests.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamSerializationTests.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamTests.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataWriterReaderTests.cs

diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/CompositionRenderData.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/CompositionRenderData.cs
index 0ad70d7102..feb0a93f61 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/CompositionRenderData.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/CompositionRenderData.cs
@@ -1,8 +1,4 @@
 using System;
-using System.Collections.Generic;
-using Avalonia.Media;
-using Avalonia.Media.Immutable;
-using Avalonia.Rendering.Composition.Drawing.Nodes;
 using Avalonia.Rendering.Composition.Server;
 using Avalonia.Rendering.Composition.Transport;
 using Avalonia.Utilities;
@@ -12,36 +8,33 @@ namespace Avalonia.Rendering.Composition.Drawing;
 internal class CompositionRenderData : ICompositorSerializable, IDisposable
 {
     private readonly Compositor _compositor;
+    private readonly RenderDataStream _stream;
+    private PooledInlineList<ICompositionRenderResource> _resources;
+    private bool _itemsSent;
 
-    public CompositionRenderData(Compositor compositor)
+    public CompositionRenderData(Compositor compositor, RenderDataStream stream)
     {
         _compositor = compositor;
+        _stream = stream;
         Server = new ServerCompositionRenderData(compositor.Server);
     }
 
     public ServerCompositionRenderData Server { get; }
-    private PooledInlineList<ICompositionRenderResource> _resources;
-    private PooledInlineList<IRenderDataItem> _items;
-    private bool _itemsSent;
+
     public void AddResource(ICompositionRenderResource resource) => _resources.Add(resource);
 
-    public void Add(IRenderDataItem item) => _items.Add(item);
-    
     public void Dispose()
     {
         if (!_itemsSent)
-        {
-            foreach(var i in _items)
-                if (i is IDisposable disp)
-                    disp.Dispose();
-        }
-        
-        _items.Dispose();
-        _itemsSent = false;
-        foreach(var r in _resources)
+            _stream.DisposeResources();
+
+        foreach (var r in _resources)
             r.ReleaseOnCompositor(_compositor);
         _resources.Dispose();
-        
+
+        _stream.Dispose();
+        _itemsSent = false;
+
         _compositor.DisposeOnNextBatch(Server);
     }
 
@@ -49,20 +42,9 @@ internal class CompositionRenderData : ICompositorSerializable, IDisposable
 
     public void SerializeChanges(Compositor c, BatchStreamWriter writer)
     {
-        writer.Write(_items.Count);
-        foreach (var item in _items) 
-            writer.WriteObject(item);
+        _stream.SerializeTo(writer);
         _itemsSent = true;
     }
 
-    public bool HitTest(Point pt)
-    {
-        foreach (var op in _items)
-        {
-            if (op.HitTest(pt))
-                return true;
-        }
-
-        return false;
-    }
-}
\ No newline at end of file
+    public bool HitTest(Point pt) => _stream.HitTest(pt);
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/IRenderDataVisitor.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/IRenderDataVisitor.cs
new file mode 100644
index 0000000000..3f5d4bc5e4
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/IRenderDataVisitor.cs
@@ -0,0 +1,30 @@
+using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Utilities;
+
+namespace Avalonia.Rendering.Composition.Drawing;
+
+internal interface IRenderDataVisitor<TScope> where TScope : unmanaged
+{
+    bool StopVisiting { get; }
+
+    void OnDrawLine(IPen? serverPen, IPen? clientPen, Point p1, Point p2);
+    void OnDrawRectangle(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, RoundedRect rect, BoxShadows boxShadows);
+    void OnDrawEllipse(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, Rect rect);
+    void OnDrawGeometry(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, IGeometryImpl? geometry);
+    void OnDrawGlyphRun(IBrush? serverBrush, IRef<IGlyphRunImpl>? glyphRun);
+    void OnDrawBitmap(IRef<IBitmapImpl>? bitmap, double opacity, Rect sourceRect, Rect destRect);
+    void OnDrawCustom(ICustomDrawOperation? operation);
+
+    TScope OnPushClip(RoundedRect clip);
+    TScope OnPushGeometryClip(IGeometryImpl? geometry);
+    TScope OnPushOpacity(double opacity);
+    TScope OnPushOpacityMask(IBrush? brush, Rect bounds);
+    TScope OnPushTransform(Matrix matrix);
+    TScope OnPushRenderOptions(RenderOptions options);
+    TScope OnPushTextOptions(TextOptions options);
+    TScope OnPushEffect(IEffect? effect, Rect bounds);
+    void OnPop(in TScope scope);
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/ImmediateRenderDataSceneBrushContent.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/ImmediateRenderDataSceneBrushContent.cs
index 00f75ec8f8..e3b43655bc 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/ImmediateRenderDataSceneBrushContent.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/ImmediateRenderDataSceneBrushContent.cs
@@ -1,32 +1,19 @@
-using System;
-using System.Collections.Generic;
 using Avalonia.Media;
 using Avalonia.Platform;
-using Avalonia.Rendering.Composition.Drawing.Nodes;
-using Avalonia.Threading;
 
 namespace Avalonia.Rendering.Composition.Drawing;
 
 internal class ImmediateRenderDataSceneBrushContent : ISceneBrushContent
 {
-    private List<IRenderDataItem>? _items;
-    private readonly ThreadSafeObjectPool<List<IRenderDataItem>> _pool;
+    private RenderDataStream? _stream;
 
-    public ImmediateRenderDataSceneBrushContent(ITileBrush brush, List<IRenderDataItem> items, Rect? rect,
-        bool useScalableRasterization, ThreadSafeObjectPool<List<IRenderDataItem>> pool)
+    public ImmediateRenderDataSceneBrushContent(ITileBrush brush, RenderDataStream stream, Rect? rect,
+        bool useScalableRasterization)
     {
         Brush = brush;
-        _items = items;
-        _pool = pool;
+        _stream = stream;
         UseScalableRasterization = useScalableRasterization;
-        if (rect == null)
-        {
-            foreach (var i in _items)
-                rect = Rect.Union(rect, i.Bounds);
-            rect = ServerCompositionRenderData.ApplyRenderBoundsRounding(rect);
-        }
-
-        Rect = rect ?? default;
+        Rect = rect ?? ServerCompositionRenderData.ApplyRenderBoundsRounding(stream.CalculateBounds()) ?? default;
     }
 
     public ITileBrush Brush { get; }
@@ -38,31 +25,15 @@ internal class ImmediateRenderDataSceneBrushContent : ISceneBrushContent
 
     public void Dispose()
     {
-        if(_items == null)
+        if (_stream == null)
             return;
-        foreach (var i in _items)
-            (i as IDisposable)?.Dispose();
-        _items.Clear();
-        _pool.ReturnAndSetNull(ref _items);
+        _stream.DisposeResources();
+        _stream.Dispose();
+        _stream = null;
     }
 
-    void Render(IDrawingContextImpl context)
-    {
-        if (_items == null)
-            return;
-        
-        var ctx = new RenderDataNodeRenderContext(context);
-        try
-        {
-            foreach (var i in _items)
-                i.Invoke(ref ctx);
-        }
-        finally
-        {
-            ctx.Dispose();
-        }
-    }
-    
+    private void Render(IDrawingContextImpl context) => _stream?.Replay(context);
+
     public void Render(IDrawingContextImpl context, Matrix? transform)
     {
         if (transform.HasValue)
@@ -77,5 +48,4 @@ internal class ImmediateRenderDataSceneBrushContent : ISceneBrushContent
     }
 
     public bool UseScalableRasterization { get; }
-
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataBitmapNode.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataBitmapNode.cs
deleted file mode 100644
index 11a1b87fc9..0000000000
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataBitmapNode.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-using System;
-using Avalonia.Platform;
-using Avalonia.Utilities;
-
-namespace Avalonia.Rendering.Composition.Drawing.Nodes;
-
-class RenderDataBitmapNode : IRenderDataItem, IDisposable
-{
-    public IRef<IBitmapImpl>? Bitmap { get; set; }
-    public double Opacity { get; set; }
-    public Rect SourceRect { get; set; }
-    public Rect DestRect { get; set; }
-    
-    public bool HitTest(Point p) => DestRect.Contains(p);
-
-    public void Invoke(ref RenderDataNodeRenderContext context)
-    {
-        if (Bitmap != null)
-            context.Context.DrawBitmap(Bitmap.Item, Opacity, SourceRect, DestRect);
-    }
-
-    public Rect? Bounds => DestRect;
-    public void Dispose()
-    {
-        Bitmap?.Dispose();
-        Bitmap = null;
-    }
-}
\ No newline at end of file
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataEllipseNode.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataEllipseNode.cs
deleted file mode 100644
index 4e77281cc5..0000000000
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataEllipseNode.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-using System;
-using Avalonia.Media;
-using Avalonia.Platform;
-
-namespace Avalonia.Rendering.Composition.Drawing.Nodes;
-
-class RenderDataEllipseNode :RenderDataBrushAndPenNode
-{
-    public Rect Rect { get; set; }
-    
-    bool Contains(double dx, double dy, double radiusX, double radiusY)
-    {
-        var rx2 = radiusX * radiusX;
-        var ry2 = radiusY * radiusY;
-
-        var distance = ry2 * dx * dx + rx2 * dy * dy;
-
-        return distance <= rx2 * ry2;
-    }
-    
-    public override bool HitTest(Point p)
-    {
-        var center = Rect.Center;
-
-        var strokeThickness = ClientPen?.Thickness ?? 0;
-
-        var rx = Rect.Width / 2 + strokeThickness / 2;
-        var ry = Rect.Height / 2 + strokeThickness / 2;
-
-        var dx = p.X - center.X;
-        var dy = p.Y - center.Y;
-
-        if (Math.Abs(dx) > rx || Math.Abs(dy) > ry)
-        {
-            return false;
-        }
-
-        if (ServerBrush != null)
-        {
-            return Contains(dx, dy, rx, ry);
-        }
-        else if (strokeThickness > 0)
-        {
-            bool inStroke = Contains(dx, dy, rx, ry);
-
-            rx = Rect.Width / 2 - strokeThickness / 2;
-            ry = Rect.Height / 2 - strokeThickness / 2;
-
-            bool inInner = Contains(dx, dy, rx, ry);
-
-            return inStroke && !inInner;
-        }
-        
-        return false;
-    }
-
-    public override void Invoke(ref RenderDataNodeRenderContext context) =>
-        context.Context.DrawEllipse(ServerBrush, ServerPen, Rect);
-
-    public override Rect? Bounds => Rect.Inflate(ServerPen?.Thickness ?? 0);
-}
\ No newline at end of file
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataGeometryNode.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataGeometryNode.cs
deleted file mode 100644
index 5a40a6b279..0000000000
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataGeometryNode.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using System.Diagnostics;
-using Avalonia.Media;
-using Avalonia.Platform;
-using Avalonia.Rendering.SceneGraph;
-
-namespace Avalonia.Rendering.Composition.Drawing.Nodes;
-
-class RenderDataGeometryNode : RenderDataBrushAndPenNode
-{
-    public IGeometryImpl? Geometry { get; set; }
-    
-    public override bool HitTest(Point p)
-    {
-        if (Geometry == null)
-            return false;
-        
-        return (ServerBrush != null // null check is safe
-                && Geometry.FillContains(p)) ||
-               (ClientPen != null && Geometry.StrokeContains(ClientPen, p));
-    }
-    
-    public override void Invoke(ref RenderDataNodeRenderContext context)
-    {
-        Debug.Assert(Geometry != null);
-        context.Context.DrawGeometry(ServerBrush, ServerPen, Geometry!);
-    }
-
-    public override Rect? Bounds => Geometry?.GetRenderBounds(ServerPen) ?? default;
-}
\ No newline at end of file
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataGlyphRunNode.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataGlyphRunNode.cs
deleted file mode 100644
index ca2748cd55..0000000000
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataGlyphRunNode.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using System;
-using System.Diagnostics;
-using Avalonia.Media;
-using Avalonia.Platform;
-using Avalonia.Utilities;
-
-namespace Avalonia.Rendering.Composition.Drawing.Nodes;
-
-class RenderDataGlyphRunNode : IRenderDataItemWithServerResources, IDisposable
-{
-    public IBrush? ServerBrush { get; set; }
-    // Dispose only happens once, so it's safe to have one reference
-    public IRef<IGlyphRunImpl>? GlyphRun { get; set; }
-
-    public bool HitTest(Point p) => GlyphRun?.Item.Bounds.ContainsExclusive(p) ?? false;
-    
-    public void Invoke(ref RenderDataNodeRenderContext context)
-    {
-        Debug.Assert(GlyphRun!.Item != null);
-        context.Context.DrawGlyphRun(ServerBrush, GlyphRun.Item);
-    }
-
-    public Rect? Bounds => GlyphRun?.Item?.Bounds ?? default;
-
-    public void Collect(IRenderDataServerResourcesCollector collector)
-    {
-        collector.AddRenderDataServerResource(ServerBrush);
-    }
-
-    public void Dispose()
-    {
-        GlyphRun?.Dispose();
-        GlyphRun = null;
-    }
-}
\ No newline at end of file
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataLineNode.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataLineNode.cs
deleted file mode 100644
index 6b6b9bdb01..0000000000
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataLineNode.cs
+++ /dev/null
@@ -1,65 +0,0 @@
-using System;
-using Avalonia.Media;
-using Avalonia.Platform;
-using Avalonia.Rendering.SceneGraph;
-
-namespace Avalonia.Rendering.Composition.Drawing.Nodes;
-
-class RenderDataLineNode : IRenderDataItemWithServerResources
-{
-    public IPen? ServerPen { get; set; }
-    public IPen? ClientPen { get; set; }
-    public Point P1 { get; set; }
-    public Point P2 { get; set; }
-    
-    public bool HitTest(Point p)
-    {
-        if (ClientPen == null)
-            return false;
-        var halfThickness = ClientPen.Thickness / 2;
-        var minX = Math.Min(P1.X, P2.X) - halfThickness;
-        var maxX = Math.Max(P1.X, P2.X) + halfThickness;
-        var minY = Math.Min(P1.Y, P2.Y) - halfThickness;
-        var maxY = Math.Max(P1.Y, P2.Y) + halfThickness;
-
-        if (p.X < minX || p.X > maxX || p.Y < minY || p.Y > maxY)
-            return false;
-
-        var a = P1;
-        var b = P2;
-
-        //If dot1 or dot2 is negative, then the angle between the perpendicular and the segment is obtuse.
-        //The distance from a point to a straight line is defined as the
-        //length of the vector formed by the point and the closest point of the segment
-
-        Vector ap = p - a;
-        var dot1 = Vector.Dot(b - a, ap);
-
-        if (dot1 < 0)
-            return ap.Length <= ClientPen.Thickness / 2;
-
-        Vector bp = p - b;
-        var dot2 = Vector.Dot(a - b, bp);
-
-        if (dot2 < 0)
-            return bp.Length <= halfThickness;
-
-        var bXaX = b.X - a.X;
-        var bYaY = b.Y - a.Y;
-
-        var distance = (bXaX * (p.Y - a.Y) - bYaY * (p.X - a.X)) /
-                       (Math.Sqrt(bXaX * bXaX + bYaY * bYaY));
-
-        return Math.Abs(distance) <= halfThickness;
-    }
-    
-
-    public void Invoke(ref RenderDataNodeRenderContext context) 
-        => context.Context.DrawLine(ServerPen, P1, P2);
-
-    public Rect? Bounds => LineBoundsHelper.CalculateBounds(P1, P2, ServerPen!);
-    public void Collect(IRenderDataServerResourcesCollector collector)
-    {
-        collector.AddRenderDataServerResource(ServerPen);
-    }
-}
\ No newline at end of file
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataNodes.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataNodes.cs
deleted file mode 100644
index 52098411cd..0000000000
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataNodes.cs
+++ /dev/null
@@ -1,294 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Avalonia.Media;
-using Avalonia.Platform;
-using Avalonia.Rendering.SceneGraph;
-using Avalonia.Threading;
-using Avalonia.Utilities;
-
-namespace Avalonia.Rendering.Composition.Drawing.Nodes;
-
-enum RenderDataPopNodeType
-{
-    Transform,
-    Clip,
-    GeometryClip,
-    Opacity,
-    OpacityMask,
-    Effect
-}
-
-interface IRenderDataServerResourcesCollector
-{
-    void AddRenderDataServerResource(object? obj);
-}
-
-interface IRenderDataItemWithServerResources : IRenderDataItem
-{
-    void Collect(IRenderDataServerResourcesCollector collector);
-}
-
-struct RenderDataNodeRenderContext : IDisposable
-{
-    private Stack<Matrix>? _stack;
-    private static readonly ThreadSafeObjectPool<Stack<Matrix>> s_matrixStackPool = new();
-    
-    public RenderDataNodeRenderContext(IDrawingContextImpl context)
-    {
-        Context = context;
-    }
-    public IDrawingContextImpl Context { get; }
-
-    public Stack<Matrix> MatrixStack
-    {
-        get => _stack ??= s_matrixStackPool.Get();
-    }
-
-    public void Dispose()
-    {
-        if (_stack != null)
-        {
-            _stack.Clear();
-            s_matrixStackPool.ReturnAndSetNull(ref _stack);
-        }
-    }
-}
-
-interface IRenderDataItem
-{
-    /// <summary>
-    /// Renders the node to a drawing context.
-    /// </summary>
-    /// <param name="context">The drawing context.</param>
-    void Invoke(ref RenderDataNodeRenderContext context);
-    
-    /// <summary>
-    /// Gets the bounds of the visible content in the node in global coordinates.
-    /// </summary>
-    Rect? Bounds { get; }
-    
-    /// <summary>
-    /// Hit test the geometry in this node.
-    /// </summary>
-    /// <param name="p">The point in global coordinates.</param>
-    /// <returns>True if the point hits the node's geometry; otherwise false.</returns>
-    /// <remarks>
-    /// This method does not recurse to childs, if you want
-    /// to hit test children they must be hit tested manually.
-    /// </remarks>
-    bool HitTest(Point p);
-}
-
-class RenderDataCustomNode : IRenderDataItem, IDisposable
-{
-    public ICustomDrawOperation? Operation { get; set; }
-    public bool HitTest(Point p) => Operation?.HitTest(p) ?? false;
-    public void Invoke(ref RenderDataNodeRenderContext context) => Operation?.Render(new(context.Context, false));
-
-    public Rect? Bounds => Operation?.Bounds;
-
-    public void Dispose()
-    {
-        Operation?.Dispose();
-        Operation = null;
-    }
-}
-
-abstract class RenderDataPushNode : IRenderDataItem, IDisposable
-{
-    public PooledInlineList<IRenderDataItem> Children;
-    public abstract void Push(ref RenderDataNodeRenderContext context);
-    public abstract void Pop(ref RenderDataNodeRenderContext context);
-    public void Invoke(ref RenderDataNodeRenderContext context)
-    {
-        if (Children.Count == 0)
-            return;
-        Push(ref context);
-        foreach (var ch in Children) 
-            ch.Invoke(ref context);
-        Pop(ref context);
-    }
-
-    public virtual Rect? Bounds
-    {
-        get
-        {
-            if (Children.Count == 0)
-                return null;
-            Rect? union = null;
-            foreach (var i in Children)
-                union = Rect.Union(union, i.Bounds);
-            return union;
-        }
-    }
-
-    public virtual bool HitTest(Point p)
-    {
-        if (Children.Count == 0)
-            return false;
-        foreach(var ch in Children)
-            if (ch.HitTest(p))
-                return true;
-        return false;
-    }
-
-    public void Dispose()
-    {
-        if (Children.Count > 0)
-        {
-            foreach(var ch in Children)
-                if (ch is IDisposable disposable)
-                    disposable.Dispose();
-            Children.Dispose();
-        }
-    }
-}
-
-class RenderDataClipNode : RenderDataPushNode
-{
-    public RoundedRect Rect { get; set; }
-    public override void Push(ref RenderDataNodeRenderContext context) =>
-        context.Context.PushClip(Rect);
-
-    public override void Pop(ref RenderDataNodeRenderContext context) =>
-        context.Context.PopClip();
-
-    public override bool HitTest(Point p)
-    {
-        if (!Rect.Rect.Contains(p))
-            return false;
-        return base.HitTest(p);
-    }
-}
-
-class RenderDataGeometryClipNode : RenderDataPushNode
-{
-    public IGeometryImpl? Geometry { get; set; }
-    public bool Contains(Point p) => Geometry?.FillContains(p) ?? false;
-    
-    public override void Push(ref RenderDataNodeRenderContext context)
-    {
-        if (Geometry != null)
-            context.Context.PushGeometryClip(Geometry);
-    }
-
-    public override void Pop(ref RenderDataNodeRenderContext context)
-    {
-        if (Geometry != null)
-            context.Context.PopGeometryClip();
-    }
-
-    public override bool HitTest(Point p)
-    {
-        if (Geometry != null && !Geometry.FillContains(p))
-            return false;
-        return base.HitTest(p);
-    }
-}
-
-class RenderDataOpacityNode : RenderDataPushNode
-{
-    public double Opacity { get; set; }
-    public override void Push(ref RenderDataNodeRenderContext context)
-    {
-        if (Opacity != 1)
-            context.Context.PushOpacity(Opacity, null);
-    }
-
-    public override void Pop(ref RenderDataNodeRenderContext context)
-    {
-        if (Opacity != 1)
-            context.Context.PopOpacity();
-    }
-}
-
-abstract class RenderDataBrushAndPenNode : IRenderDataItemWithServerResources
-{
-    public IBrush? ServerBrush { get; set; }
-    public IPen? ServerPen { get; set; }
-    public IPen? ClientPen { get; set; }
-    
-    public void Collect(IRenderDataServerResourcesCollector collector)
-    {
-        collector.AddRenderDataServerResource(ServerBrush);
-        collector.AddRenderDataServerResource(ServerPen);
-    }
-
-    public abstract void Invoke(ref RenderDataNodeRenderContext context);
-    public abstract Rect? Bounds { get; }
-    public abstract bool HitTest(Point p);
-}
-
-class RenderDataRenderOptionsNode : RenderDataPushNode
-{
-    public RenderOptions RenderOptions { get; set; }
-
-    public override void Push(ref RenderDataNodeRenderContext context)
-    {
-        context.Context.PushRenderOptions(RenderOptions);
-    }
-
-    public override void Pop(ref RenderDataNodeRenderContext context)
-    {
-        context.Context.PopRenderOptions();
-    }
-}
-
-class RenderDataTextOptionsNode : RenderDataPushNode
-{
-    public TextOptions TextOptions { get; set; }
-
-    public override void Push(ref RenderDataNodeRenderContext context)
-    {
-        context.Context.PushTextOptions(TextOptions);
-    }
-
-    public override void Pop(ref RenderDataNodeRenderContext context)
-    {
-        context.Context.PopTextOptions();
-    }
-}
-
-/// <summary>
-/// A render data node that pushes an effect.
-/// </summary>
-class RenderDataEffectNode : RenderDataPushNode
-{
-    /// <summary>
-    /// Gets or sets the effect to push.
-    /// </summary>
-    public IEffect? Effect { get; set; }
-
-    /// <summary>
-    /// Gets or sets the bounds of the effect.
-    /// </summary>
-    public Rect BoundsRect { get; set; }
-
-    /// <inheritdoc />
-    public override Rect? Bounds
-    {
-        get
-        {
-            var bounds = base.Bounds;
-            if (bounds is null)
-                return null;
-            return Effect is { } effect
-                ? bounds.Value.Inflate(effect.GetEffectOutputPadding())
-                : bounds;
-        }
-    }
-
-    /// <inheritdoc />
-    public override void Push(ref RenderDataNodeRenderContext context)
-    {
-        if (Effect != null && context.Context is IDrawingContextImplWithEffects effectImpl)
-            effectImpl.PushEffect(BoundsRect, Effect);
-    }
-
-    /// <inheritdoc />
-    public override void Pop(ref RenderDataNodeRenderContext context)
-    {
-        if (Effect != null && context.Context is IDrawingContextImplWithEffects effectImpl)
-            effectImpl.PopEffect();
-    }
-}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataPushMatrixNode.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataPushMatrixNode.cs
deleted file mode 100644
index 2ccfa0e7a5..0000000000
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataPushMatrixNode.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-namespace Avalonia.Rendering.Composition.Drawing.Nodes;
-
-class RenderDataPushMatrixNode : RenderDataPushNode
-{
-    public Matrix Matrix { get; set; }
-
-    public override void Push(ref RenderDataNodeRenderContext context)
-    {
-        var current = context.Context.Transform;
-        context.MatrixStack.Push(current);
-        context.Context.Transform = Matrix * current;
-    }
-
-    public override void Pop(ref RenderDataNodeRenderContext context)
-    {
-        context.Context.Transform = context.MatrixStack.Pop();
-    }
-
-    public override bool HitTest(Point p)
-    {
-        if (Matrix.TryInvert(out var inverted))
-            return base.HitTest(p.Transform(inverted));
-        return false;
-    }
-
-    public override Rect? Bounds => base.Bounds?.TransformToAABB(Matrix);
-}
\ No newline at end of file
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataPushOpacityMaskNode.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataPushOpacityMaskNode.cs
deleted file mode 100644
index 14607282da..0000000000
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataPushOpacityMaskNode.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-using Avalonia.Media;
-using Avalonia.Platform;
-
-namespace Avalonia.Rendering.Composition.Drawing.Nodes;
-
-class RenderDataOpacityMaskNode : RenderDataPushNode, IRenderDataItemWithServerResources
-{
-    public IBrush? ServerBrush { get; set; }
-
-    public Rect BoundsRect { get; set; }
-
-    public void Collect(IRenderDataServerResourcesCollector collector)
-    {
-        collector.AddRenderDataServerResource(ServerBrush);
-    }
-
-    public override void Push(ref RenderDataNodeRenderContext context)
-    {
-        if (ServerBrush != null)
-            context.Context.PushOpacityMask(ServerBrush, BoundsRect);
-    }
-
-    public override void Pop(ref RenderDataNodeRenderContext context) =>
-        context.Context.PopOpacityMask();
-}
\ No newline at end of file
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataRectangleNode.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataRectangleNode.cs
deleted file mode 100644
index c6a3859e3d..0000000000
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/Nodes/RenderDataRectangleNode.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using Avalonia.Media;
-
-namespace Avalonia.Rendering.Composition.Drawing.Nodes;
-
-class RenderDataRectangleNode : RenderDataBrushAndPenNode
-{
-    public RoundedRect Rect { get; set; }
-    public BoxShadows BoxShadows { get; set; }
-
-    public override bool HitTest(Point p)
-    {
-        var strokeThicknessAdjustment = (ClientPen?.Thickness / 2) ?? 0;
-
-        if (Rect.IsRounded)
-        {
-            var outerRoundedRect = Rect.Inflate(strokeThicknessAdjustment, strokeThicknessAdjustment);
-            if (outerRoundedRect.ContainsExclusive(p))
-            {
-                if (ServerBrush != null) // it's safe to check for null
-                    return true;
-
-                var innerRoundedRect = Rect.Deflate(strokeThicknessAdjustment, strokeThicknessAdjustment);
-                return !innerRoundedRect.ContainsExclusive(p);
-            } 
-        }
-        else
-        {
-            var outerRect = Rect.Rect.Inflate(strokeThicknessAdjustment);
-            if (outerRect.ContainsExclusive(p))
-            {
-                if (ServerBrush != null) // it's safe to check for null
-                    return true;
-
-                var innerRect = Rect.Rect.Deflate(strokeThicknessAdjustment);
-                return !innerRect.ContainsExclusive(p);
-            }
-        }
-
-        return false;
-    }
-
-    public override void Invoke(ref RenderDataNodeRenderContext context) =>
-        context.Context.DrawRectangle(ServerBrush, ServerPen, Rect, BoxShadows);
-
-    public override Rect? Bounds => BoxShadows.TransformBounds(Rect.Rect).Inflate((ServerPen?.Thickness ?? 0) / 2);
-}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs
index 28370d71e1..2472d69f08 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs
@@ -1,12 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
 using Avalonia.Media;
 using Avalonia.Media.Immutable;
 using Avalonia.Platform;
-using Avalonia.Rendering.Composition.Drawing.Nodes;
 using Avalonia.Rendering.SceneGraph;
 using Avalonia.Threading;
 using Avalonia.Utilities;
@@ -16,101 +13,47 @@ namespace Avalonia.Rendering.Composition.Drawing;
 internal class RenderDataDrawingContext : DrawingContext
 {
     private readonly Compositor? _compositor;
+    private RenderDataStream? _stream;
     private CompositionRenderData? _renderData;
     private HashSet<object>? _resourcesHashSet;
+    private Stack<PushEntry>? _pushStack;
     private static readonly ThreadSafeObjectPool<HashSet<object>> s_hashSetPool = new();
-    private CompositionRenderData RenderData
-    {
-        get
-        {
-            Debug.Assert(_compositor != null);
-            return _renderData ??= new(_compositor);
-        }
-    }
-    
-    struct ParentStackItem
+    private static readonly ThreadSafeObjectPool<Stack<PushEntry>> s_pushStackPool = new();
+
+    private struct PushEntry
     {
-        public RenderDataPushNode? Node;
-        public List<IRenderDataItem> Items;
+        public bool Emitted;
+        public int PositionBefore;
+        public int PositionAfter;
+        public int DepthBefore;
     }
-    
-    private List<IRenderDataItem>? _currentItemList;
-    private static readonly ThreadSafeObjectPool<List<IRenderDataItem>> s_listPool = new();
-
-    private Stack<ParentStackItem>? _parentNodeStack;
-    private static readonly ThreadSafeObjectPool<Stack<ParentStackItem>> s_parentStackPool = new();
 
     public RenderDataDrawingContext(Compositor? compositor)
     {
         _compositor = compositor;
     }
 
-    void Add(IRenderDataItem item)
-    {
-        _currentItemList ??= s_listPool.Get();
-        _currentItemList.Add(item);
-    }
-
-    void Push(RenderDataPushNode? node = null)
-    {
-        // Push a fake no-op node so something could be popped by the corresponding Pop call
-        // Since there is no nesting, we don't update the item list
-        if (node == null)
-        {
-            (_parentNodeStack ??= s_parentStackPool.Get()).Push(default);
-            return;
-        }    
-        Add(node);
-        (_parentNodeStack ??= s_parentStackPool.Get()).Push(new ParentStackItem
-        {
-            Node = node,
-            Items = _currentItemList!
-        });
-        _currentItemList = null;
-    }
-
-    void Pop<T>() where T : IRenderDataItem
-    {
-        var parent = _parentNodeStack!.Pop();
-        
-        // No-op node
-        if (parent.Node == null)
-            return;
+    private RenderDataStream Stream => _stream ??= new RenderDataStream();
 
-        if (!(parent.Node is T))
-            throw new InvalidOperationException("Invalid Pop operation");
+    private CompositionRenderData RenderData => _renderData ??= new CompositionRenderData(_compositor!, Stream);
 
-        var removeLastPush = true;
-        if (_currentItemList != null)
-        {
-            removeLastPush = _currentItemList.Count == 0;
-            foreach (var item in _currentItemList)
-                parent.Node.Children.Add(item);
-            _currentItemList.Clear();
-            s_listPool.ReturnAndSetNull(ref _currentItemList);
-        }
-        _currentItemList = parent.Items;
-        if (removeLastPush)
-            _currentItemList.RemoveAt(_currentItemList.Count - 1);
-    }
-
-    void AddResource(object? resource)
+    private void AddResource(object? resource)
     {
         if (_compositor == null)
             return;
-        
+
         if (resource == null
             || resource is IImmutableBrush
             || resource is ImmutablePen
             || resource is ImmutableTransform)
             return;
-        
+
         if (resource is ICompositionRenderResource renderResource)
         {
             _resourcesHashSet ??= s_hashSetPool.Get();
             if (!_resourcesHashSet.Add(renderResource))
                 return;
-            
+
             renderResource.AddRefOnCompositor(_compositor);
             RenderData.AddResource(renderResource);
             return;
@@ -118,19 +61,37 @@ internal class RenderDataDrawingContext : DrawingContext
 
         throw new InvalidOperationException(resource.GetType().FullName + " can not be used with this DrawingContext");
     }
-    
+
+    private void PushedScope(int positionBefore) =>
+        (_pushStack ??= s_pushStackPool.Get()).Push(new PushEntry
+        {
+            Emitted = true,
+            PositionBefore = positionBefore,
+            PositionAfter = Stream.OpcodeLength,
+            DepthBefore = Stream.Depth - 1
+        });
+
+    private void PushedNoOpScope() =>
+        (_pushStack ??= s_pushStackPool.Get()).Push(new PushEntry { Emitted = false });
+
+    private void PopCore()
+    {
+        var entry = _pushStack!.Pop();
+        if (!entry.Emitted)
+            return;
+
+        if (Stream.OpcodeLength == entry.PositionAfter)
+            Stream.Rewind(entry.PositionBefore, entry.DepthBefore);
+        else
+            Stream.Pop();
+    }
+
     protected override void DrawLineCore(IPen? pen, Point p1, Point p2)
     {
-        if(pen == null)
+        if (pen == null)
             return;
         AddResource(pen);
-        Add(new RenderDataLineNode
-        {
-            ClientPen = pen,
-            ServerPen = pen.GetServer(_compositor),
-            P1 = p1,
-            P2 = p2
-        });
+        Stream.DrawLine(pen.GetServer(_compositor), pen, p1, p2);
     }
 
     protected override void DrawGeometryCore(IBrush? brush, IPen? pen, IGeometryImpl geometry)
@@ -139,244 +100,223 @@ internal class RenderDataDrawingContext : DrawingContext
             return;
         AddResource(brush);
         AddResource(pen);
-        Add(new RenderDataGeometryNode
-        {
-            ServerBrush = brush.GetServer(_compositor),
-            ServerPen = pen.GetServer(_compositor),
-            ClientPen = pen,
-            Geometry = geometry
-        });
+        Stream.DrawGeometry(brush.GetServer(_compositor), pen.GetServer(_compositor), pen, geometry);
     }
 
     protected override void DrawRectangleCore(IBrush? brush, IPen? pen, RoundedRect rrect, BoxShadows boxShadows = default)
     {
         if (rrect.IsEmpty())
             return;
-        if(brush == null && pen == null && boxShadows == default)
+        if (brush == null && pen == null && boxShadows == default)
             return;
         AddResource(brush);
         AddResource(pen);
-        Add(new RenderDataRectangleNode
-        {
-            ServerBrush = brush.GetServer(_compositor),
-            ServerPen = pen.GetServer(_compositor),
-            ClientPen = pen,
-            Rect = rrect,
-            BoxShadows = boxShadows
-        });
+        Stream.DrawRectangle(brush.GetServer(_compositor), pen.GetServer(_compositor), pen, rrect, boxShadows);
     }
 
     protected override void DrawEllipseCore(IBrush? brush, IPen? pen, Rect rect)
     {
         if (rect.IsEmpty())
             return;
-        
-        if(brush == null && pen == null)
+        if (brush == null && pen == null)
             return;
         AddResource(brush);
         AddResource(pen);
-        Add(new RenderDataEllipseNode
-        {
-            ServerBrush = brush.GetServer(_compositor),
-            ServerPen = pen.GetServer(_compositor),
-            ClientPen = pen,
-            Rect = rect,
-        });
+        Stream.DrawEllipse(brush.GetServer(_compositor), pen.GetServer(_compositor), pen, rect);
     }
 
-    public override void Custom(ICustomDrawOperation custom) => Add(new RenderDataCustomNode
-    {
-        Operation = custom
-    });
+    public override void Custom(ICustomDrawOperation custom) => Stream.DrawCustom(custom);
 
     public override void DrawGlyphRun(IBrush? foreground, GlyphRun? glyphRun)
     {
         if (foreground == null || glyphRun == null)
             return;
         AddResource(foreground);
-        Add(new RenderDataGlyphRunNode
-        {
-            ServerBrush = foreground.GetServer(_compositor),
-            GlyphRun = glyphRun.PlatformImpl.Clone()
-        });
+        Stream.DrawGlyphRun(foreground.GetServer(_compositor), glyphRun.PlatformImpl.Clone());
     }
 
-    protected override void PushClipCore(RoundedRect rect) => Push(new RenderDataClipNode
+    internal override void DrawBitmap(IRef<IBitmapImpl>? source, double opacity, Rect sourceRect, Rect destRect)
     {
-        Rect = rect
-    });
+        if (source == null || sourceRect.IsEmpty() || destRect.IsEmpty())
+            return;
+        Stream.DrawBitmap(source.Clone(), opacity, sourceRect, destRect);
+    }
 
-    protected override void PushClipCore(Rect rect) => Push(new RenderDataClipNode
+    protected override void PushClipCore(RoundedRect rect)
     {
-        Rect = rect
-    });
+        var before = Stream.OpcodeLength;
+        Stream.PushClip(rect);
+        PushedScope(before);
+    }
+
+    protected override void PushClipCore(Rect rect)
+    {
+        var before = Stream.OpcodeLength;
+        Stream.PushClip(new RoundedRect(rect));
+        PushedScope(before);
+    }
 
     protected override void PushGeometryClipCore(Geometry? clip)
     {
         if (clip == null)
-            Push();
-        else
-            Push(new RenderDataGeometryClipNode
-            {
-                Geometry = clip?.PlatformImpl
-            });
+        {
+            PushedNoOpScope();
+            return;
+        }
+
+        var before = Stream.OpcodeLength;
+        Stream.PushGeometryClip(clip.PlatformImpl);
+        PushedScope(before);
     }
 
     protected override void PushOpacityCore(double opacity)
     {
         if (opacity == 1)
-            Push();
-        else
-            Push(new RenderDataOpacityNode
-            {
-                Opacity = opacity
-            });
+        {
+            PushedNoOpScope();
+            return;
+        }
+
+        var before = Stream.OpcodeLength;
+        Stream.PushOpacity(opacity);
+        PushedScope(before);
     }
 
     protected override void PushOpacityMaskCore(IBrush? mask, Rect bounds)
     {
-        if(mask == null)
-            Push();
-        else
+        if (mask == null)
         {
-            AddResource(mask);
-            Push(new RenderDataOpacityMaskNode
-            {
-                ServerBrush = mask.GetServer(_compositor),
-                BoundsRect = bounds
-            });
+            PushedNoOpScope();
+            return;
         }
+
+        AddResource(mask);
+        var before = Stream.OpcodeLength;
+        Stream.PushOpacityMask(mask.GetServer(_compositor), bounds);
+        PushedScope(before);
     }
 
     protected override void PushTransformCore(Matrix matrix)
     {
         if (matrix.IsIdentity)
-            Push();
-        else
-            Push(new RenderDataPushMatrixNode()
-            {
-                Matrix = matrix
-            });
+        {
+            PushedNoOpScope();
+            return;
+        }
+
+        var before = Stream.OpcodeLength;
+        Stream.PushTransform(matrix);
+        PushedScope(before);
     }
 
-    protected override void PushRenderOptionsCore(RenderOptions renderOptions) => Push(new RenderDataRenderOptionsNode()
+    protected override void PushRenderOptionsCore(RenderOptions renderOptions)
     {
-        RenderOptions = renderOptions
-    });
+        var before = Stream.OpcodeLength;
+        Stream.PushRenderOptions(renderOptions);
+        PushedScope(before);
+    }
 
-    protected override void PushTextOptionsCore(TextOptions textOptions) => Push(new RenderDataTextOptionsNode()
+    protected override void PushTextOptionsCore(TextOptions textOptions)
     {
-        TextOptions = textOptions
-    });
+        var before = Stream.OpcodeLength;
+        Stream.PushTextOptions(textOptions);
+        PushedScope(before);
+    }
 
-    /// <inheritdoc />
-    protected override void PushEffectCore(IEffect effect, Rect bounds) => Push(new RenderDataEffectNode()
+    protected override void PushEffectCore(IEffect effect, Rect bounds)
     {
-        Effect = effect.ToImmutable(),
-        BoundsRect = bounds.Inflate(effect.GetEffectOutputPadding())
-    });
+        var before = Stream.OpcodeLength;
+        Stream.PushEffect(effect.ToImmutable(), bounds.Inflate(effect.GetEffectOutputPadding()));
+        PushedScope(before);
+    }
 
-    protected override void PopClipCore() => Pop<RenderDataClipNode>();
+    protected override void PopClipCore() => PopCore();
 
-    protected override void PopGeometryClipCore() => Pop<RenderDataGeometryClipNode>();
+    protected override void PopGeometryClipCore() => PopCore();
 
-    protected override void PopOpacityCore() => Pop<RenderDataOpacityNode>();
+    protected override void PopOpacityCore() => PopCore();
 
-    protected override void PopOpacityMaskCore() => Pop<RenderDataOpacityMaskNode>();
+    protected override void PopOpacityMaskCore() => PopCore();
 
-    protected override void PopTransformCore() => Pop<RenderDataPushMatrixNode>();
+    protected override void PopTransformCore() => PopCore();
 
-    protected override void PopRenderOptionsCore() => Pop<RenderDataRenderOptionsNode>();
+    protected override void PopRenderOptionsCore() => PopCore();
 
-    protected override void PopTextOptionsCore() => Pop<RenderDataTextOptionsNode>();
+    protected override void PopTextOptionsCore() => PopCore();
 
-    /// <inheritdoc />
-    protected override void PopEffectCore() => Pop<RenderDataEffectNode>();
+    protected override void PopEffectCore() => PopCore();
 
-    internal override void DrawBitmap(IRef<IBitmapImpl>? source, double opacity, Rect sourceRect, Rect destRect)
+    private void FlushStack()
     {
-        if (source == null || sourceRect.IsEmpty() || destRect.IsEmpty())
-            return;
-        Add(new RenderDataBitmapNode
-        {
-            Bitmap = source.Clone(),
-            Opacity = opacity,
-            SourceRect = sourceRect,
-            DestRect = destRect
-        });
+        while (_pushStack is { Count: > 0 })
+            PopCore();
     }
 
-
-    void FlushStack()
-    {
-        // Flush stack
-        if (_parentNodeStack != null)
-        {
-            // TODO: throw error, unbalanced stack
-            while (_parentNodeStack.Count > 0) 
-                Pop<IRenderDataItem>();
-        }
-        
-
-    }
-    
     public CompositionRenderData? GetRenderResults()
     {
         Debug.Assert(_compositor != null);
-        
         FlushStack();
-        
-        // Transfer items to RenderData
-        if (_currentItemList is { Count: > 0 })
+
+        var rv = _renderData;
+        if (rv == null)
         {
-            foreach (var i in _currentItemList)
-                RenderData.Add(i);
-            _currentItemList.Clear();
+            if (_stream is { OpcodeLength: > 0 })
+                rv = new CompositionRenderData(_compositor!, _stream);
+            else
+            {
+                _stream?.Dispose();
+                _stream = null;
+                return null;
+            }
         }
 
-        var rv = _renderData;
         _renderData = null;
+        _stream = null;
         _resourcesHashSet?.Clear();
-        
-        if (rv != null)
-            _compositor.RegisterForSerialization(rv);
+
+        _compositor!.RegisterForSerialization(rv);
         return rv;
     }
 
     public ImmediateRenderDataSceneBrushContent? GetImmediateSceneBrushContent(ITileBrush brush, Rect? rect, bool useScalableRasterization)
     {
         Debug.Assert(_compositor == null);
-        Debug.Assert(_resourcesHashSet == null);
         Debug.Assert(_renderData == null);
-        
         FlushStack();
-        if (_currentItemList == null || _currentItemList.Count == 0)
-            return null;
 
-        var itemList = _currentItemList;
-        _currentItemList = null;
+        if (_stream is not { OpcodeLength: > 0 })
+        {
+            _stream?.Dispose();
+            _stream = null;
+            return null;
+        }
 
-        return new ImmediateRenderDataSceneBrushContent(brush, itemList, rect, useScalableRasterization, s_listPool);
+        var stream = _stream;
+        _stream = null;
+        return new ImmediateRenderDataSceneBrushContent(brush, stream, rect, useScalableRasterization);
     }
 
     public void Reset()
     {
-        // This means that render data should be discarded
         if (_renderData != null)
         {
             _renderData.Dispose();
             _renderData = null;
         }
+        else
+            _stream?.Dispose();
 
-        _currentItemList?.Clear();
-        _parentNodeStack?.Clear();
+        _stream = null;
+        _pushStack?.Clear();
         _resourcesHashSet?.Clear();
     }
-    
+
     protected override void DisposeCore()
     {
         Reset();
-        if (_resourcesHashSet != null) 
+        if (_resourcesHashSet != null)
             s_hashSetPool.ReturnAndSetNull(ref _resourcesHashSet);
+        if (_pushStack != null)
+            s_pushStackPool.ReturnAndSetNull(ref _pushStack);
     }
 }
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataOpcode.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataOpcode.cs
new file mode 100644
index 0000000000..888ee0cd12
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataOpcode.cs
@@ -0,0 +1,22 @@
+namespace Avalonia.Rendering.Composition.Drawing;
+
+internal enum RenderDataOpcode : byte
+{
+    Invalid = 0,
+    DrawLine,
+    DrawRectangle,
+    DrawEllipse,
+    DrawGeometry,
+    DrawGlyphRun,
+    DrawBitmap,
+    DrawCustom,
+    PushClip,
+    PushGeometryClip,
+    PushOpacity,
+    PushOpacityMask,
+    PushTransform,
+    PushRenderOptions,
+    PushTextOptions,
+    PushEffect,
+    Pop
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataPayloads.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataPayloads.cs
new file mode 100644
index 0000000000..6bb0c8b08c
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataPayloads.cs
@@ -0,0 +1,132 @@
+using Avalonia.Media;
+
+namespace Avalonia.Rendering.Composition.Drawing;
+
+internal interface IRenderDataPayload<TSelf> where TSelf : unmanaged, IRenderDataPayload<TSelf>
+{
+    static abstract RenderDataOpcode Opcode { get; }
+}
+
+internal struct DrawLinePayload : IRenderDataPayload<DrawLinePayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.DrawLine;
+
+    public int ServerPen;
+    public int ClientPen;
+    public Point P1;
+    public Point P2;
+}
+
+internal struct DrawRectanglePayload : IRenderDataPayload<DrawRectanglePayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.DrawRectangle;
+
+    public int ServerBrush;
+    public int ServerPen;
+    public int ClientPen;
+    public RoundedRect Rect;
+    public int BoxShadowCount;
+}
+
+internal struct DrawEllipsePayload : IRenderDataPayload<DrawEllipsePayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.DrawEllipse;
+
+    public int ServerBrush;
+    public int ServerPen;
+    public int ClientPen;
+    public Rect Rect;
+}
+
+internal struct DrawGeometryPayload : IRenderDataPayload<DrawGeometryPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.DrawGeometry;
+
+    public int ServerBrush;
+    public int ServerPen;
+    public int ClientPen;
+    public int Geometry;
+}
+
+internal struct DrawGlyphRunPayload : IRenderDataPayload<DrawGlyphRunPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.DrawGlyphRun;
+
+    public int ServerBrush;
+    public int GlyphRun;
+}
+
+internal struct DrawBitmapPayload : IRenderDataPayload<DrawBitmapPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.DrawBitmap;
+
+    public int Bitmap;
+    public double Opacity;
+    public Rect SourceRect;
+    public Rect DestRect;
+}
+
+internal struct DrawCustomPayload : IRenderDataPayload<DrawCustomPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.DrawCustom;
+
+    public int Operation;
+}
+
+internal struct PushClipPayload : IRenderDataPayload<PushClipPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.PushClip;
+
+    public RoundedRect Clip;
+}
+
+internal struct PushGeometryClipPayload : IRenderDataPayload<PushGeometryClipPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.PushGeometryClip;
+
+    public int Geometry;
+}
+
+internal struct PushOpacityPayload : IRenderDataPayload<PushOpacityPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.PushOpacity;
+
+    public double Opacity;
+}
+
+internal struct PushOpacityMaskPayload : IRenderDataPayload<PushOpacityMaskPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.PushOpacityMask;
+
+    public int Brush;
+    public Rect Bounds;
+}
+
+internal struct PushTransformPayload : IRenderDataPayload<PushTransformPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.PushTransform;
+
+    public Matrix Matrix;
+}
+
+internal struct PushRenderOptionsPayload : IRenderDataPayload<PushRenderOptionsPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.PushRenderOptions;
+
+    public RenderOptions Options;
+}
+
+internal struct PushTextOptionsPayload : IRenderDataPayload<PushTextOptionsPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.PushTextOptions;
+
+    public TextOptions Options;
+}
+
+internal struct PushEffectPayload : IRenderDataPayload<PushEffectPayload>
+{
+    public static RenderDataOpcode Opcode => RenderDataOpcode.PushEffect;
+
+    public int Effect;
+    public Rect Bounds;
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataReader.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataReader.cs
new file mode 100644
index 0000000000..b1b7199100
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataReader.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Avalonia.Rendering.Composition.Drawing;
+
+internal ref struct RenderDataReader
+{
+    private readonly ReadOnlySpan<byte> _buffer;
+    private int _position;
+
+    public RenderDataReader(ReadOnlySpan<byte> buffer)
+    {
+        _buffer = buffer;
+        _position = 0;
+    }
+
+    public int Position => _position;
+
+    public bool IsAtEnd => _position >= _buffer.Length;
+
+    public ReadOnlySpan<byte> Take(int count)
+    {
+        var span = _buffer.Slice(_position, count);
+        _position += count;
+        return span;
+    }
+
+    public T Read<T>() where T : unmanaged
+        => MemoryMarshal.Read<T>(Take(Unsafe.SizeOf<T>()));
+
+    public T Peek<T>() where T : unmanaged
+        => MemoryMarshal.Read<T>(_buffer.Slice(_position, Unsafe.SizeOf<T>()));
+
+    public T ReadPayload<T>() where T : unmanaged, IRenderDataPayload<T>
+    {
+        var opcode = Read<RenderDataOpcode>();
+        Debug.Assert(opcode == T.Opcode);
+        return Read<T>();
+    }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataResources.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataResources.cs
new file mode 100644
index 0000000000..9d8a43c628
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataResources.cs
@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Collections.Pooled;
+
+namespace Avalonia.Rendering.Composition.Drawing;
+
+internal struct RenderDataResources : IDisposable
+{
+    public const int NullHandle = -1;
+
+    private PooledList<object?>? _resources;
+    private Dictionary<object, int>? _internMap;
+
+    public int Count => _resources?.Count ?? 0;
+
+    // Recording path: dedupes by reference equality so a resource reused across many draws gets one slot.
+    public int Intern(object? resource)
+    {
+        if (resource is null)
+            return NullHandle;
+
+        _resources ??= new PooledList<object?>();
+        _internMap ??= new Dictionary<object, int>(ReferenceEqualityComparer.Instance);
+
+        if (_internMap.TryGetValue(resource, out var handle))
+            return handle;
+
+        handle = _resources.Count;
+        _resources.Add(resource);
+        _internMap.Add(resource, handle);
+        return handle;
+    }
+
+    // Deserialize path: appends without deduping since the wire format is already deduped.
+    public int AppendDeserialized(object? resource)
+    {
+        if (resource is null)
+            return NullHandle;
+
+        _resources ??= new PooledList<object?>();
+        var handle = _resources.Count;
+        _resources.Add(resource);
+        return handle;
+    }
+
+    public object? this[int handle] => handle == NullHandle ? null : _resources![handle];
+
+    public void Dispose()
+    {
+        _resources?.Dispose();
+        _resources = null;
+        _internMap = null;
+    }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Bounds.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Bounds.cs
new file mode 100644
index 0000000000..a1bc2d1a23
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Bounds.cs
@@ -0,0 +1,93 @@
+using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Utilities;
+
+namespace Avalonia.Rendering.Composition.Drawing;
+
+internal partial class RenderDataStream
+{
+    internal struct BoundsScope
+    {
+        public Rect? SavedBounds;
+        public bool IsTransform;
+        public Matrix Matrix;
+        public Thickness EffectPadding;
+    }
+
+    internal struct BoundsVisitor : IRenderDataVisitor<BoundsScope>
+    {
+        public Rect? Current;
+
+        public bool StopVisiting => false;
+
+        public void OnDrawLine(IPen? serverPen, IPen? clientPen, Point p1, Point p2)
+        {
+            if (serverPen != null)
+                Current = Rect.Union(Current, LineBoundsHelper.CalculateBounds(p1, p2, serverPen));
+        }
+
+        public void OnDrawRectangle(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, RoundedRect rect,
+            BoxShadows boxShadows)
+        {
+            var bounds = boxShadows.TransformBounds(rect.Rect)
+                .Inflate((serverPen?.Thickness ?? 0) / 2);
+            Current = Rect.Union(Current, bounds);
+        }
+
+        public void OnDrawEllipse(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, Rect rect)
+            => Current = Rect.Union(Current, rect.Inflate(serverPen?.Thickness ?? 0));
+
+        public void OnDrawGeometry(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, IGeometryImpl? geometry)
+            => Current = Rect.Union(Current, geometry?.GetRenderBounds(serverPen) ?? default);
+
+        public void OnDrawGlyphRun(IBrush? serverBrush, IRef<IGlyphRunImpl>? glyphRun)
+            => Current = Rect.Union(Current, glyphRun?.Item?.Bounds ?? default);
+
+        public void OnDrawBitmap(IRef<IBitmapImpl>? bitmap, double opacity, Rect sourceRect, Rect destRect)
+            => Current = Rect.Union(Current, destRect);
+
+        public void OnDrawCustom(ICustomDrawOperation? operation)
+            => Current = Rect.Union(Current, operation?.Bounds);
+
+        private BoundsScope EnterChildScope(bool isTransform = false, Matrix matrix = default,
+            Thickness effectPadding = default)
+        {
+            var scope = new BoundsScope
+            {
+                SavedBounds = Current, IsTransform = isTransform, Matrix = matrix, EffectPadding = effectPadding
+            };
+            Current = null;
+            return scope;
+        }
+
+        public BoundsScope OnPushClip(RoundedRect clip) => EnterChildScope();
+        public BoundsScope OnPushGeometryClip(IGeometryImpl? geometry) => EnterChildScope();
+        public BoundsScope OnPushOpacity(double opacity) => EnterChildScope();
+        public BoundsScope OnPushOpacityMask(IBrush? brush, Rect bounds) => EnterChildScope();
+        public BoundsScope OnPushTransform(Matrix matrix) => EnterChildScope(true, matrix);
+        public BoundsScope OnPushRenderOptions(RenderOptions options) => EnterChildScope();
+        public BoundsScope OnPushTextOptions(TextOptions options) => EnterChildScope();
+
+        public BoundsScope OnPushEffect(IEffect? effect, Rect bounds)
+            => EnterChildScope(effectPadding: effect.GetEffectOutputPadding());
+
+        public void OnPop(in BoundsScope scope)
+        {
+            var childUnion = Current;
+            if (scope.IsTransform)
+                childUnion = childUnion?.TransformToAABB(scope.Matrix);
+            else if (childUnion.HasValue && !scope.EffectPadding.Equals(default))
+                childUnion = childUnion.Value.Inflate(scope.EffectPadding);
+            Current = Rect.Union(scope.SavedBounds, childUnion);
+        }
+    }
+
+    public Rect? CalculateBounds()
+    {
+        var visitor = new BoundsVisitor();
+        Visit<BoundsVisitor, BoundsScope>(ref visitor);
+        return visitor.Current;
+    }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.HitTest.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.HitTest.cs
new file mode 100644
index 0000000000..38b39053f9
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.HitTest.cs
@@ -0,0 +1,250 @@
+using System;
+using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Utilities;
+
+namespace Avalonia.Rendering.Composition.Drawing;
+
+internal partial class RenderDataStream
+{
+    internal struct HitTestScope
+    {
+        public bool SavedLive;
+        public bool RestorePoint;
+        public Point SavedPoint;
+    }
+
+    internal struct HitTestVisitor : IRenderDataVisitor<HitTestScope>
+    {
+        public bool StopVisiting { get; private set; }
+        public bool HitFound;
+        public Point Current;
+        public bool Live;
+
+        public HitTestVisitor(Point point)
+        {
+            StopVisiting = false;
+            HitFound = false;
+            Current = point;
+            Live = true;
+        }
+
+        private void Hit()
+        {
+            HitFound = true;
+            StopVisiting = true;
+        }
+
+        public void OnDrawLine(IPen? serverPen, IPen? clientPen, Point p1, Point p2)
+        {
+            if (Live && HitTestLine(clientPen, p1, p2, Current))
+                Hit();
+        }
+
+        public void OnDrawRectangle(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, RoundedRect rect,
+            BoxShadows boxShadows)
+        {
+            if (Live && HitTestRectangle(serverBrush, clientPen, rect, Current))
+                Hit();
+        }
+
+        public void OnDrawEllipse(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, Rect rect)
+        {
+            if (Live && HitTestEllipse(serverBrush, clientPen, rect, Current))
+                Hit();
+        }
+
+        public void OnDrawGeometry(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, IGeometryImpl? geometry)
+        {
+            if (Live && geometry != null &&
+                ((serverBrush != null && geometry.FillContains(Current)) ||
+                 (clientPen != null && geometry.StrokeContains(clientPen, Current))))
+                Hit();
+        }
+
+        public void OnDrawGlyphRun(IBrush? serverBrush, IRef<IGlyphRunImpl>? glyphRun)
+        {
+            if (Live && glyphRun != null && glyphRun.Item.Bounds.ContainsExclusive(Current))
+                Hit();
+        }
+
+        public void OnDrawBitmap(IRef<IBitmapImpl>? bitmap, double opacity, Rect sourceRect, Rect destRect)
+        {
+            if (Live && destRect.Contains(Current))
+                Hit();
+        }
+
+        public void OnDrawCustom(ICustomDrawOperation? operation)
+        {
+            if (Live && operation != null && operation.HitTest(Current))
+                Hit();
+        }
+
+        public HitTestScope OnPushClip(RoundedRect clip)
+        {
+            var scope = new HitTestScope { SavedLive = Live };
+            if (Live && !clip.Rect.Contains(Current))
+                Live = false;
+            return scope;
+        }
+
+        public HitTestScope OnPushGeometryClip(IGeometryImpl? geometry)
+        {
+            var scope = new HitTestScope { SavedLive = Live };
+            if (Live && geometry != null && !geometry.FillContains(Current))
+                Live = false;
+            return scope;
+        }
+
+        public HitTestScope OnPushOpacity(double opacity)
+            => new HitTestScope { SavedLive = Live };
+
+        public HitTestScope OnPushOpacityMask(IBrush? brush, Rect bounds)
+            => new HitTestScope { SavedLive = Live };
+
+        public HitTestScope OnPushTransform(Matrix matrix)
+        {
+            var scope = new HitTestScope { SavedLive = Live };
+            if (Live)
+            {
+                if (matrix.TryInvert(out var inverted))
+                {
+                    scope.RestorePoint = true;
+                    scope.SavedPoint = Current;
+                    Current = Current.Transform(inverted);
+                }
+                else
+                    Live = false;
+            }
+            return scope;
+        }
+
+        public HitTestScope OnPushRenderOptions(RenderOptions options)
+            => new HitTestScope { SavedLive = Live };
+
+        public HitTestScope OnPushTextOptions(TextOptions options)
+            => new HitTestScope { SavedLive = Live };
+
+        public HitTestScope OnPushEffect(IEffect? effect, Rect bounds)
+            => new HitTestScope { SavedLive = Live };
+
+        public void OnPop(in HitTestScope scope)
+        {
+            Live = scope.SavedLive;
+            if (scope.RestorePoint)
+                Current = scope.SavedPoint;
+        }
+    }
+
+    public bool HitTest(Point point)
+    {
+        var visitor = new HitTestVisitor(point);
+        Visit<HitTestVisitor, HitTestScope>(ref visitor);
+        return visitor.HitFound;
+    }
+
+    private static bool HitTestLine(IPen? clientPen, Point p1, Point p2, Point p)
+    {
+        if (clientPen == null)
+            return false;
+
+        var halfThickness = clientPen.Thickness / 2;
+        var minX = Math.Min(p1.X, p2.X) - halfThickness;
+        var maxX = Math.Max(p1.X, p2.X) + halfThickness;
+        var minY = Math.Min(p1.Y, p2.Y) - halfThickness;
+        var maxY = Math.Max(p1.Y, p2.Y) + halfThickness;
+
+        if (p.X < minX || p.X > maxX || p.Y < minY || p.Y > maxY)
+            return false;
+
+        Vector ap = p - p1;
+        var dot1 = Vector.Dot(p2 - p1, ap);
+        if (dot1 < 0)
+            return ap.Length <= halfThickness;
+
+        Vector bp = p - p2;
+        var dot2 = Vector.Dot(p1 - p2, bp);
+        if (dot2 < 0)
+            return bp.Length <= halfThickness;
+
+        var bXaX = p2.X - p1.X;
+        var bYaY = p2.Y - p1.Y;
+        var distance = (bXaX * (p.Y - p1.Y) - bYaY * (p.X - p1.X)) /
+                       Math.Sqrt(bXaX * bXaX + bYaY * bYaY);
+        return Math.Abs(distance) <= halfThickness;
+    }
+
+    private static bool HitTestRectangle(IBrush? serverBrush, IPen? clientPen, RoundedRect rect, Point p)
+    {
+        var strokeThicknessAdjustment = (clientPen?.Thickness / 2) ?? 0;
+
+        if (rect.IsRounded)
+        {
+            var outer = rect.Inflate(strokeThicknessAdjustment, strokeThicknessAdjustment);
+            if (outer.ContainsExclusive(p))
+            {
+                if (serverBrush != null)
+                    return true;
+
+                var inner = rect.Deflate(strokeThicknessAdjustment, strokeThicknessAdjustment);
+                return !inner.ContainsExclusive(p);
+            }
+        }
+        else
+        {
+            var outer = rect.Rect.Inflate(strokeThicknessAdjustment);
+            if (outer.ContainsExclusive(p))
+            {
+                if (serverBrush != null)
+                    return true;
+
+                var inner = rect.Rect.Deflate(strokeThicknessAdjustment);
+                return !inner.ContainsExclusive(p);
+            }
+        }
+
+        return false;
+    }
+
+    private static bool HitTestEllipse(IBrush? serverBrush, IPen? clientPen, Rect rect, Point p)
+    {
+        var center = rect.Center;
+        var strokeThickness = clientPen?.Thickness ?? 0;
+
+        var rx = rect.Width / 2 + strokeThickness / 2;
+        var ry = rect.Height / 2 + strokeThickness / 2;
+
+        var dx = p.X - center.X;
+        var dy = p.Y - center.Y;
+
+        if (Math.Abs(dx) > rx || Math.Abs(dy) > ry)
+            return false;
+
+        if (serverBrush != null)
+            return EllipseContains(dx, dy, rx, ry);
+
+        if (strokeThickness > 0)
+        {
+            var inStroke = EllipseContains(dx, dy, rx, ry);
+
+            rx = rect.Width / 2 - strokeThickness / 2;
+            ry = rect.Height / 2 - strokeThickness / 2;
+
+            var inInner = EllipseContains(dx, dy, rx, ry);
+
+            return inStroke && !inInner;
+        }
+
+        return false;
+    }
+
+    private static bool EllipseContains(double dx, double dy, double radiusX, double radiusY)
+    {
+        var rx2 = radiusX * radiusX;
+        var ry2 = radiusY * radiusY;
+        var distance = ry2 * dx * dx + rx2 * dy * dy;
+        return distance <= rx2 * ry2;
+    }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Replay.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Replay.cs
new file mode 100644
index 0000000000..4ffb636d0d
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Replay.cs
@@ -0,0 +1,159 @@
+using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Utilities;
+
+namespace Avalonia.Rendering.Composition.Drawing;
+
+internal partial class RenderDataStream
+{
+    internal struct ReplayScope
+    {
+        public RenderDataOpcode Kind;
+        public bool Active;
+        public Matrix SavedTransform;
+    }
+
+    internal struct ReplayVisitor : IRenderDataVisitor<ReplayScope>
+    {
+        private readonly IDrawingContextImpl _context;
+
+        public ReplayVisitor(IDrawingContextImpl context)
+        {
+            _context = context;
+        }
+
+        public bool StopVisiting => false;
+
+        public void OnDrawLine(IPen? serverPen, IPen? clientPen, Point p1, Point p2)
+            => _context.DrawLine(serverPen, p1, p2);
+
+        public void OnDrawRectangle(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, RoundedRect rect,
+            BoxShadows boxShadows)
+            => _context.DrawRectangle(serverBrush, serverPen, rect, boxShadows);
+
+        public void OnDrawEllipse(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, Rect rect)
+            => _context.DrawEllipse(serverBrush, serverPen, rect);
+
+        public void OnDrawGeometry(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, IGeometryImpl? geometry)
+        {
+            if (geometry != null)
+                _context.DrawGeometry(serverBrush, serverPen, geometry);
+        }
+
+        public void OnDrawGlyphRun(IBrush? serverBrush, IRef<IGlyphRunImpl>? glyphRun)
+        {
+            if (glyphRun != null)
+                _context.DrawGlyphRun(serverBrush, glyphRun.Item);
+        }
+
+        public void OnDrawBitmap(IRef<IBitmapImpl>? bitmap, double opacity, Rect sourceRect, Rect destRect)
+        {
+            if (bitmap != null)
+                _context.DrawBitmap(bitmap.Item, opacity, sourceRect, destRect);
+        }
+
+        public void OnDrawCustom(ICustomDrawOperation? operation)
+            => operation?.Render(new ImmediateDrawingContext(_context, false));
+
+        public ReplayScope OnPushClip(RoundedRect clip)
+        {
+            _context.PushClip(clip);
+            return new ReplayScope { Kind = RenderDataOpcode.PushClip, Active = true };
+        }
+
+        public ReplayScope OnPushGeometryClip(IGeometryImpl? geometry)
+        {
+            if (geometry != null)
+                _context.PushGeometryClip(geometry);
+            return new ReplayScope
+                { Kind = RenderDataOpcode.PushGeometryClip, Active = geometry != null };
+        }
+
+        public ReplayScope OnPushOpacity(double opacity)
+        {
+            if (opacity != 1)
+                _context.PushOpacity(opacity, null);
+            return new ReplayScope { Kind = RenderDataOpcode.PushOpacity, Active = opacity != 1 };
+        }
+
+        public ReplayScope OnPushOpacityMask(IBrush? brush, Rect bounds)
+        {
+            if (brush != null)
+                _context.PushOpacityMask(brush, bounds);
+            return new ReplayScope { Kind = RenderDataOpcode.PushOpacityMask, Active = brush != null };
+        }
+
+        public ReplayScope OnPushTransform(Matrix matrix)
+        {
+            var saved = _context.Transform;
+            _context.Transform = matrix * saved;
+            return new ReplayScope
+                { Kind = RenderDataOpcode.PushTransform, Active = true, SavedTransform = saved };
+        }
+
+        public ReplayScope OnPushRenderOptions(RenderOptions options)
+        {
+            _context.PushRenderOptions(options);
+            return new ReplayScope { Kind = RenderDataOpcode.PushRenderOptions, Active = true };
+        }
+
+        public ReplayScope OnPushTextOptions(TextOptions options)
+        {
+            _context.PushTextOptions(options);
+            return new ReplayScope { Kind = RenderDataOpcode.PushTextOptions, Active = true };
+        }
+
+        public ReplayScope OnPushEffect(IEffect? effect, Rect bounds)
+        {
+            var active = false;
+            if (effect != null && _context is IDrawingContextImplWithEffects effectImpl)
+            {
+                effectImpl.PushEffect(bounds, effect);
+                active = true;
+            }
+            return new ReplayScope { Kind = RenderDataOpcode.PushEffect, Active = active };
+        }
+
+        public void OnPop(in ReplayScope scope)
+        {
+            if (!scope.Active)
+                return;
+
+            switch (scope.Kind)
+            {
+                case RenderDataOpcode.PushClip:
+                    _context.PopClip();
+                    break;
+                case RenderDataOpcode.PushGeometryClip:
+                    _context.PopGeometryClip();
+                    break;
+                case RenderDataOpcode.PushOpacity:
+                    _context.PopOpacity();
+                    break;
+                case RenderDataOpcode.PushOpacityMask:
+                    _context.PopOpacityMask();
+                    break;
+                case RenderDataOpcode.PushTransform:
+                    _context.Transform = scope.SavedTransform;
+                    break;
+                case RenderDataOpcode.PushRenderOptions:
+                    _context.PopRenderOptions();
+                    break;
+                case RenderDataOpcode.PushTextOptions:
+                    _context.PopTextOptions();
+                    break;
+                case RenderDataOpcode.PushEffect:
+                    ((IDrawingContextImplWithEffects)_context).PopEffect();
+                    break;
+            }
+        }
+    }
+
+    public void Replay(IDrawingContextImpl context)
+    {
+        var visitor = new ReplayVisitor(context);
+        Visit<ReplayVisitor, ReplayScope>(ref visitor);
+    }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Visit.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Visit.cs
new file mode 100644
index 0000000000..370a79403c
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Visit.cs
@@ -0,0 +1,177 @@
+using System;
+using System.Buffers;
+using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Utilities;
+
+namespace Avalonia.Rendering.Composition.Drawing;
+
+internal partial class RenderDataStream
+{
+    private const int MaxStackScopeDepth = 64;
+
+    public void Visit<TVisitor, TScope>(ref TVisitor visitor)
+        where TVisitor : struct, IRenderDataVisitor<TScope>
+        where TScope : unmanaged
+    {
+        var reader = new RenderDataReader(_writer.Written);
+        TScope[]? rented = null;
+        scoped Span<TScope> scopes;
+        if (_maxDepth == 0)
+            scopes = default;
+        else if (_maxDepth <= MaxStackScopeDepth)
+            scopes = stackalloc TScope[_maxDepth];
+        else
+            scopes = rented = ArrayPool<TScope>.Shared.Rent(_maxDepth);
+        var depth = 0;
+        try
+        {
+            while (!visitor.StopVisiting && !reader.IsAtEnd)
+            {
+                switch (reader.Peek<RenderDataOpcode>())
+                {
+                    case RenderDataOpcode.DrawLine:
+                    {
+                        var p = reader.ReadPayload<DrawLinePayload>();
+                        visitor.OnDrawLine(
+                            (IPen?)_resources[p.ServerPen],
+                            (IPen?)_resources[p.ClientPen],
+                            p.P1, p.P2);
+                        break;
+                    }
+                    case RenderDataOpcode.DrawRectangle:
+                    {
+                        var p = reader.ReadPayload<DrawRectanglePayload>();
+                        var shadows = ReadBoxShadows(ref reader, p.BoxShadowCount);
+                        visitor.OnDrawRectangle(
+                            (IBrush?)_resources[p.ServerBrush],
+                            (IPen?)_resources[p.ServerPen],
+                            (IPen?)_resources[p.ClientPen],
+                            p.Rect, shadows);
+                        break;
+                    }
+                    case RenderDataOpcode.DrawEllipse:
+                    {
+                        var p = reader.ReadPayload<DrawEllipsePayload>();
+                        visitor.OnDrawEllipse(
+                            (IBrush?)_resources[p.ServerBrush],
+                            (IPen?)_resources[p.ServerPen],
+                            (IPen?)_resources[p.ClientPen],
+                            p.Rect);
+                        break;
+                    }
+                    case RenderDataOpcode.DrawGeometry:
+                    {
+                        var p = reader.ReadPayload<DrawGeometryPayload>();
+                        visitor.OnDrawGeometry(
+                            (IBrush?)_resources[p.ServerBrush],
+                            (IPen?)_resources[p.ServerPen],
+                            (IPen?)_resources[p.ClientPen],
+                            (IGeometryImpl?)_resources[p.Geometry]);
+                        break;
+                    }
+                    case RenderDataOpcode.DrawGlyphRun:
+                    {
+                        var p = reader.ReadPayload<DrawGlyphRunPayload>();
+                        visitor.OnDrawGlyphRun(
+                            (IBrush?)_resources[p.ServerBrush],
+                            (IRef<IGlyphRunImpl>?)_resources[p.GlyphRun]);
+                        break;
+                    }
+                    case RenderDataOpcode.DrawBitmap:
+                    {
+                        var p = reader.ReadPayload<DrawBitmapPayload>();
+                        visitor.OnDrawBitmap(
+                            (IRef<IBitmapImpl>?)_resources[p.Bitmap],
+                            p.Opacity, p.SourceRect, p.DestRect);
+                        break;
+                    }
+                    case RenderDataOpcode.DrawCustom:
+                    {
+                        var p = reader.ReadPayload<DrawCustomPayload>();
+                        visitor.OnDrawCustom((ICustomDrawOperation?)_resources[p.Operation]);
+                        break;
+                    }
+                    case RenderDataOpcode.PushClip:
+                    {
+                        var p = reader.ReadPayload<PushClipPayload>();
+                        scopes[depth++] = visitor.OnPushClip(p.Clip);
+                        break;
+                    }
+                    case RenderDataOpcode.PushGeometryClip:
+                    {
+                        var p = reader.ReadPayload<PushGeometryClipPayload>();
+                        scopes[depth++] = visitor.OnPushGeometryClip((IGeometryImpl?)_resources[p.Geometry]);
+                        break;
+                    }
+                    case RenderDataOpcode.PushOpacity:
+                    {
+                        var p = reader.ReadPayload<PushOpacityPayload>();
+                        scopes[depth++] = visitor.OnPushOpacity(p.Opacity);
+                        break;
+                    }
+                    case RenderDataOpcode.PushOpacityMask:
+                    {
+                        var p = reader.ReadPayload<PushOpacityMaskPayload>();
+                        scopes[depth++] = visitor.OnPushOpacityMask(
+                            (IBrush?)_resources[p.Brush], p.Bounds);
+                        break;
+                    }
+                    case RenderDataOpcode.PushTransform:
+                    {
+                        var p = reader.ReadPayload<PushTransformPayload>();
+                        scopes[depth++] = visitor.OnPushTransform(p.Matrix);
+                        break;
+                    }
+                    case RenderDataOpcode.PushRenderOptions:
+                    {
+                        var p = reader.ReadPayload<PushRenderOptionsPayload>();
+                        scopes[depth++] = visitor.OnPushRenderOptions(p.Options);
+                        break;
+                    }
+                    case RenderDataOpcode.PushTextOptions:
+                    {
+                        var p = reader.ReadPayload<PushTextOptionsPayload>();
+                        scopes[depth++] = visitor.OnPushTextOptions(p.Options);
+                        break;
+                    }
+                    case RenderDataOpcode.PushEffect:
+                    {
+                        var p = reader.ReadPayload<PushEffectPayload>();
+                        scopes[depth++] = visitor.OnPushEffect(
+                            (IEffect?)_resources[p.Effect], p.Bounds);
+                        break;
+                    }
+                    case RenderDataOpcode.Pop:
+                    {
+                        reader.Read<RenderDataOpcode>();
+                        visitor.OnPop(in scopes[--depth]);
+                        break;
+                    }
+                }
+            }
+        }
+        finally
+        {
+            if (rented != null)
+                ArrayPool<TScope>.Shared.Return(rented);
+        }
+    }
+
+    private static BoxShadows ReadBoxShadows(ref RenderDataReader reader, int count)
+    {
+        if (count == 0)
+            return default;
+
+        var first = reader.Read<BoxShadow>();
+        if (count == 1)
+            return new BoxShadows(first);
+
+        var rest = new BoxShadow[count - 1];
+        for (var i = 0; i < rest.Length; i++)
+            rest[i] = reader.Read<BoxShadow>();
+        return new BoxShadows(first, rest);
+    }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.cs
new file mode 100644
index 0000000000..910043ffea
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.cs
@@ -0,0 +1,226 @@
+using System;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Rendering.Composition.Transport;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Utilities;
+
+namespace Avalonia.Rendering.Composition.Drawing;
+
+internal partial class RenderDataStream : IDisposable
+{
+    private RenderDataWriter _writer;
+    private RenderDataResources _resources;
+    private int _depth;
+    private int _maxDepth;
+
+    public ReadOnlySpan<byte> Opcodes => _writer.Written;
+
+    public int OpcodeLength => _writer.Length;
+
+    public int Depth => _depth;
+
+    public int ResourceCount => _resources.Count;
+
+    public object? GetResource(int handle) => _resources[handle];
+
+    public void Rewind(int length, int depth)
+    {
+        _writer.Rewind(length);
+        _depth = depth;
+    }
+
+    private void EnterScope()
+    {
+        _depth++;
+        if (_depth > _maxDepth)
+            _maxDepth = _depth;
+    }
+
+    public void DisposeResources()
+    {
+        for (var i = 0; i < _resources.Count; i++)
+        {
+            switch (_resources[i])
+            {
+                case IRef<IBitmapImpl> bitmap:
+                    bitmap.Dispose();
+                    break;
+                case IRef<IGlyphRunImpl> glyphRun:
+                    glyphRun.Dispose();
+                    break;
+                case ICustomDrawOperation operation:
+                    operation.Dispose();
+                    break;
+            }
+        }
+    }
+
+    public void DrawLine(IPen? serverPen, IPen? clientPen, Point p1, Point p2)
+    {
+        _writer.WritePayload(new DrawLinePayload
+        {
+            ServerPen = _resources.Intern(serverPen),
+            ClientPen = _resources.Intern(clientPen),
+            P1 = p1,
+            P2 = p2
+        });
+    }
+
+    public void DrawRectangle(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, RoundedRect rect,
+        BoxShadows boxShadows)
+    {
+        _writer.WritePayload(new DrawRectanglePayload
+        {
+            ServerBrush = _resources.Intern(serverBrush),
+            ServerPen = _resources.Intern(serverPen),
+            ClientPen = _resources.Intern(clientPen),
+            Rect = rect,
+            BoxShadowCount = boxShadows.Count
+        });
+        for (var i = 0; i < boxShadows.Count; i++)
+            _writer.Write(boxShadows[i]);
+    }
+
+    public void DrawEllipse(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, Rect rect)
+    {
+        _writer.WritePayload(new DrawEllipsePayload
+        {
+            ServerBrush = _resources.Intern(serverBrush),
+            ServerPen = _resources.Intern(serverPen),
+            ClientPen = _resources.Intern(clientPen),
+            Rect = rect
+        });
+    }
+
+    public void DrawGeometry(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, IGeometryImpl? geometry)
+    {
+        _writer.WritePayload(new DrawGeometryPayload
+        {
+            ServerBrush = _resources.Intern(serverBrush),
+            ServerPen = _resources.Intern(serverPen),
+            ClientPen = _resources.Intern(clientPen),
+            Geometry = _resources.Intern(geometry)
+        });
+    }
+
+    public void DrawGlyphRun(IBrush? serverBrush, IRef<IGlyphRunImpl>? glyphRun)
+    {
+        _writer.WritePayload(new DrawGlyphRunPayload
+        {
+            ServerBrush = _resources.Intern(serverBrush),
+            GlyphRun = _resources.Intern(glyphRun)
+        });
+    }
+
+    public void DrawBitmap(IRef<IBitmapImpl>? bitmap, double opacity, Rect sourceRect, Rect destRect)
+    {
+        _writer.WritePayload(new DrawBitmapPayload
+        {
+            Bitmap = _resources.Intern(bitmap),
+            Opacity = opacity,
+            SourceRect = sourceRect,
+            DestRect = destRect
+        });
+    }
+
+    public void DrawCustom(ICustomDrawOperation? operation)
+    {
+        _writer.WritePayload(new DrawCustomPayload
+        {
+            Operation = _resources.Intern(operation)
+        });
+    }
+
+    public void PushClip(RoundedRect clip)
+    {
+        _writer.WritePayload(new PushClipPayload { Clip = clip });
+        EnterScope();
+    }
+
+    public void PushGeometryClip(IGeometryImpl? geometry)
+    {
+        _writer.WritePayload(new PushGeometryClipPayload { Geometry = _resources.Intern(geometry) });
+        EnterScope();
+    }
+
+    public void PushOpacity(double opacity)
+    {
+        _writer.WritePayload(new PushOpacityPayload { Opacity = opacity });
+        EnterScope();
+    }
+
+    public void PushOpacityMask(IBrush? serverBrush, Rect bounds)
+    {
+        _writer.WritePayload(new PushOpacityMaskPayload
+        {
+            Brush = _resources.Intern(serverBrush),
+            Bounds = bounds
+        });
+        EnterScope();
+    }
+
+    public void PushTransform(Matrix matrix)
+    {
+        _writer.WritePayload(new PushTransformPayload { Matrix = matrix });
+        EnterScope();
+    }
+
+    public void PushRenderOptions(RenderOptions renderOptions)
+    {
+        _writer.WritePayload(new PushRenderOptionsPayload { Options = renderOptions });
+        EnterScope();
+    }
+
+    public void PushTextOptions(TextOptions textOptions)
+    {
+        _writer.WritePayload(new PushTextOptionsPayload { Options = textOptions });
+        EnterScope();
+    }
+
+    public void PushEffect(IImmutableEffect? effect, Rect bounds)
+    {
+        _writer.WritePayload(new PushEffectPayload
+        {
+            Effect = _resources.Intern(effect),
+            Bounds = bounds
+        });
+        EnterScope();
+    }
+
+    public void Pop()
+    {
+        _writer.WriteOpcode(RenderDataOpcode.Pop);
+        _depth--;
+    }
+
+    public void SerializeTo(BatchStreamWriter writer)
+    {
+        var opcodes = _writer.Written;
+        writer.Write(_maxDepth);
+        writer.Write(_resources.Count);
+        for (var i = 0; i < _resources.Count; i++)
+            writer.WriteObject(_resources[i]);
+        writer.Write(opcodes.Length);
+        writer.Write(opcodes);
+    }
+
+    public void DeserializeFrom(BatchStreamReader reader)
+    {
+        _maxDepth = reader.Read<int>();
+
+        var resourceCount = reader.Read<int>();
+        for (var i = 0; i < resourceCount; i++)
+            _resources.AppendDeserialized(reader.ReadObject());
+
+        var byteCount = reader.Read<int>();
+        if (byteCount > 0)
+            reader.Read(_writer.Reserve(byteCount));
+    }
+
+    public void Dispose()
+    {
+        _writer.Dispose();
+        _resources.Dispose();
+    }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataWriter.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataWriter.cs
new file mode 100644
index 0000000000..7cecf86ead
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataWriter.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Avalonia.Rendering.Composition.Drawing;
+
+internal struct RenderDataWriter : IDisposable
+{
+    private byte[]? _buffer;
+    private int _length;
+
+    public int Length => _length;
+
+    public ReadOnlySpan<byte> Written => _buffer is null ? default : _buffer.AsSpan(0, _length);
+
+    private Span<byte> Advance(int size)
+    {
+        var required = _length + size;
+        if (_buffer is null)
+            _buffer = ArrayPool<byte>.Shared.Rent(Math.Max(required, 256));
+        else if (_buffer.Length < required)
+        {
+            var grown = ArrayPool<byte>.Shared.Rent(Math.Max(required, _buffer.Length * 2));
+            Array.Copy(_buffer, grown, _length);
+            ArrayPool<byte>.Shared.Return(_buffer);
+            _buffer = grown;
+        }
+
+        var span = _buffer.AsSpan(_length, size);
+        _length += size;
+        return span;
+    }
+
+    public Span<byte> Reserve(int count) => Advance(count);
+
+    public void Rewind(int length) => _length = length;
+
+    public void Write<T>(T value) where T : unmanaged
+        => MemoryMarshal.Write(Advance(Unsafe.SizeOf<T>()), in value);
+
+    public void WriteOpcode(RenderDataOpcode opcode) => Write(opcode);
+
+    public void WritePayload<T>(T payload) where T : unmanaged, IRenderDataPayload<T>
+    {
+        Write(T.Opcode);
+        Write(payload);
+    }
+
+    public void Dispose()
+    {
+        if (_buffer != null)
+            ArrayPool<byte>.Shared.Return(_buffer);
+        _buffer = null;
+        _length = 0;
+    }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/ServerCompositionRenderData.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/ServerCompositionRenderData.cs
index 3745fb54d8..8c1b5a2585 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/ServerCompositionRenderData.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/ServerCompositionRenderData.cs
@@ -1,70 +1,39 @@
 using System;
-using System.Collections.Generic;
-using System.Diagnostics;
 using Avalonia.Platform;
-using Avalonia.Rendering.Composition.Drawing.Nodes;
 using Avalonia.Rendering.Composition.Server;
 using Avalonia.Rendering.Composition.Transport;
-using Avalonia.Threading;
 using Avalonia.Utilities;
 
 namespace Avalonia.Rendering.Composition.Drawing;
 
 class ServerCompositionRenderData : SimpleServerRenderResource
 {
-    private PooledInlineList<IRenderDataItem> _items;
+    private RenderDataStream? _stream;
     private PooledInlineList<IServerRenderResource> _referencedResources;
     private LtrbRect? _bounds;
     private bool _boundsValid;
-    private static readonly ThreadSafeObjectPool<Collector> s_resourceHashSetPool = new();
 
     public ServerCompositionRenderData(ServerCompositor compositor) : base(compositor)
     {
     }
 
-    class Collector : IRenderDataServerResourcesCollector
-    {
-        public readonly HashSet<IServerRenderResource> Resources = new();
-        public void AddRenderDataServerResource(object? obj)
-        {
-            if (obj is IServerRenderResource res)
-                Resources.Add(res);
-        }
-    }
-    
     protected override void DeserializeChangesCore(BatchStreamReader reader, TimeSpan committedAt)
     {
         Reset();
-        
-        var count = reader.Read<int>();
-        _items.EnsureCapacity(count);
-        for (var c = 0; c < count; c++)
-            _items.Add(reader.ReadObject<IRenderDataItem>());
-        
-        var collector = s_resourceHashSetPool.Get();
-        CollectResources(_items, collector);
-
-        foreach (var r in collector.Resources)
-        {
-            _referencedResources.Add(r);
-            r.AddObserver(this);
-        }
 
-        collector.Resources.Clear();
-        s_resourceHashSetPool.ReturnAndSetNull(ref collector);
-        
-        base.DeserializeChangesCore(reader, committedAt);
-    }
+        _stream = new RenderDataStream();
+        _stream.DeserializeFrom(reader);
 
-    private static void CollectResources(PooledInlineList<IRenderDataItem> items, IRenderDataServerResourcesCollector collector)
-    {
-        foreach (var item in items)
+        for (var i = 0; i < _stream.ResourceCount; i++)
         {
-            if (item is IRenderDataItemWithServerResources resourceItem)
-                resourceItem.Collect(collector);
-            else if (item is RenderDataPushNode pushNode)
-                CollectResources(pushNode.Children, collector);
+            if (_stream.GetResource(i) is IServerRenderResource resource)
+            {
+                _referencedResources.Add(resource);
+                resource.AddObserver(this);
+            }
         }
+
+        base.DeserializeChangesCore(reader, committedAt);
     }
 
     public LtrbRect? Bounds
@@ -82,11 +51,8 @@ class ServerCompositionRenderData : SimpleServerRenderResource
 
     private LtrbRect? CalculateRenderBounds()
     {
-        LtrbRect? totalBounds = null;
-        foreach (var item in _items) 
-            totalBounds = LtrbRect.FullUnion(totalBounds, item.Bounds);
-        
-        return ApplyRenderBoundsRounding(totalBounds);
+        var bounds = _stream?.CalculateBounds();
+        return bounds.HasValue ? ApplyRenderBoundsRounding(new LtrbRect(bounds.Value)) : null;
     }
 
     public static Rect? ApplyRenderBoundsRounding(Rect? rect)
@@ -95,7 +61,7 @@ class ServerCompositionRenderData : SimpleServerRenderResource
             return null;
         return ApplyRenderBoundsRounding(new LtrbRect(rect.Value))?.ToRect();
     }
-    
+
     public static LtrbRect? ApplyRenderBoundsRounding(LtrbRect? rect)
     {
         if (rect != null)
@@ -115,34 +81,26 @@ class ServerCompositionRenderData : SimpleServerRenderResource
         _boundsValid = false;
         base.DependencyQueuedInvalidate(sender);
     }
-    
-    public void Render(IDrawingContextImpl context)
-    {
-        var ctx = new RenderDataNodeRenderContext(context);
-        try
-        {
-            foreach (var item in _items) 
-                item.Invoke(ref ctx);
-        }
-        finally
-        {
-            ctx.Dispose();
-        }
-    }
 
-    void Reset()
+    public void Render(IDrawingContextImpl context) => _stream?.Replay(context);
+
+    private void Reset()
     {
         _bounds = null;
         _boundsValid = false;
+
         foreach (var r in _referencedResources)
             r.RemoveObserver(this);
         _referencedResources.Dispose();
-        foreach(var i in _items)
-            if (i is IDisposable disp)
-                disp.Dispose();
-        _items.Dispose();
+
+        if (_stream != null)
+        {
+            _stream.DisposeResources();
+            _stream.Dispose();
+            _stream = null;
+        }
     }
-    
+
     public override void Dispose()
     {
         Reset();
diff --git a/src/Avalonia.Base/Rendering/Composition/Transport/BatchStream.cs b/src/Avalonia.Base/Rendering/Composition/Transport/BatchStream.cs
index 1fcadae1c2..7bd3fe59dc 100644
--- a/src/Avalonia.Base/Rendering/Composition/Transport/BatchStream.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Transport/BatchStream.cs
@@ -113,6 +113,24 @@ internal class BatchStreamWriter : IDisposable
         _currentDataSegment.ElementCount += size;
     }
 
+    public unsafe void Write(ReadOnlySpan<byte> data)
+    {
+        while (data.Length > 0)
+        {
+            if (_currentDataSegment.Data == IntPtr.Zero ||
+                _currentDataSegment.ElementCount == _memoryPool.BufferSize)
+                NextDataSegment();
+
+            var chunk = Math.Min(_memoryPool.BufferSize - _currentDataSegment.ElementCount, data.Length);
+            var destination = new Span<byte>(
+                (byte*)_currentDataSegment.Data + _currentDataSegment.ElementCount, chunk);
+            data.Slice(0, chunk).CopyTo(destination);
+
+            _currentDataSegment.ElementCount += chunk;
+            data = data.Slice(chunk);
+        }
+    }
+
     public void WriteObject(object? item)
     {
         if (_currentObjectSegment.Data == null ||
@@ -180,6 +198,34 @@ internal class BatchStreamReader : IDisposable
         return rv;
     }
 
+    public unsafe void Read(Span<byte> destination)
+    {
+        while (destination.Length > 0)
+        {
+            if (_currentDataSegment.Data == IntPtr.Zero)
+            {
+                if (_input.Structs.Count == 0)
+                    throw new EndOfStreamException();
+                _currentDataSegment = _input.Structs.Dequeue();
+                _memoryOffset = 0;
+            }
+
+            var chunk = Math.Min(_currentDataSegment.ElementCount - _memoryOffset, destination.Length);
+            var source = new ReadOnlySpan<byte>(
+                (byte*)_currentDataSegment.Data + _memoryOffset, chunk);
+            source.CopyTo(destination);
+
+            _memoryOffset += chunk;
+            destination = destination.Slice(chunk);
+
+            if (_memoryOffset == _currentDataSegment.ElementCount)
+            {
+                _memoryPool.Return(_currentDataSegment.Data);
+                _currentDataSegment = new();
+            }
+        }
+    }
+
     public T ReadObject<T>() where T : class? => (T)ReadObject()!;
     
     public object? ReadObject()
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/RenderDataEffectNodeTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/RenderDataEffectNodeTests.cs
deleted file mode 100644
index e812e388ca..0000000000
--- a/tests/Avalonia.Base.UnitTests/Rendering/RenderDataEffectNodeTests.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-using Avalonia.Media;
-using Avalonia.Rendering.Composition.Drawing.Nodes;
-using Xunit;
-
-namespace Avalonia.Base.UnitTests.Rendering;
-
-public class RenderDataEffectNodeTests
-{
-    /// <summary>
-    /// Regression test: RenderDataEffectNode.Bounds was returning BoundsRect even when
-    /// there were no children, causing incorrect dirty rect tracking.
-    /// </summary>
-    [Fact]
-    public void Bounds_Should_Return_Null_When_No_Children()
-    {
-        var effect = new BlurEffect { Radius = 10 }.ToImmutable();
-        var node = new RenderDataEffectNode
-        {
-            Effect = effect,
-            BoundsRect = new Rect(0, 0, 200, 200)
-        };
-
-        Assert.Null(node.Bounds);
-    }
-
-    /// <summary>
-    /// RenderDataEffectNode.Bounds should expand child bounds by the effect output padding
-    /// so that dirty rects include effect output (blur/shadow extending beyond geometry bounds).
-    /// </summary>
-    [Fact]
-    public void Bounds_Should_Inflate_Child_Bounds_By_Effect_Output_Padding()
-    {
-        var effect = new BlurEffect { Radius = 10 }.ToImmutable();
-        var childBounds = new Rect(10, 10, 100, 100);
-        var node = new RenderDataEffectNode { Effect = effect };
-        node.Children.Add(new MockRenderDataItem { MockBounds = childBounds });
-
-        var expectedBounds = childBounds.Inflate(effect.GetEffectOutputPadding());
-
-        Assert.Equal(expectedBounds, node.Bounds);
-    }
-
-    private class MockRenderDataItem : IRenderDataItem
-    {
-        public Rect? MockBounds { get; set; }
-        public Rect? Bounds => MockBounds;
-        public bool HitTest(Point p) => false;
-        public void Invoke(ref RenderDataNodeRenderContext context) { }
-    }
-}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
index cd3ede7726..7ee04c32ad 100644
--- a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
@@ -7,7 +7,6 @@ using Avalonia.Media.Immutable;
 using Avalonia.Rendering;
 using Avalonia.Rendering.Composition;
 using Avalonia.Rendering.Composition.Drawing;
-using Avalonia.Rendering.Composition.Drawing.Nodes;
 using Avalonia.Threading;
 using Avalonia.UnitTests;
 using Moq;
@@ -356,33 +355,6 @@ namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
             Assert.Equal(1, op.DisposeCount);
         }
 
-        [Fact]
-        public void GlyphRun_Node_Releases_Reference_On_Direct_Dispose()
-        {
-            var glyphRunRef = RefCountable.Create(Mock.Of<IGlyphRunImpl>());
-            Assert.Equal(1, glyphRunRef.RefCount);
-
-            var node = new RenderDataGlyphRunNode { GlyphRun = glyphRunRef.Clone() };
-            Assert.Equal(2, glyphRunRef.RefCount);
-
-            node.Dispose();
-            Assert.Equal(1, glyphRunRef.RefCount);
-        }
-
-        [Fact]
-        public void GlyphRun_Node_Disposed_When_Containing_Push_Node_Disposed()
-        {
-            var glyphRunRef = RefCountable.Create(Mock.Of<IGlyphRunImpl>());
-            var glyphNode = new RenderDataGlyphRunNode { GlyphRun = glyphRunRef.Clone() };
-            Assert.Equal(2, glyphRunRef.RefCount);
-
-            var pushNode = new RenderDataOpacityNode { Opacity = 0.5 };
-            pushNode.Children.Add(glyphNode);
-
-            pushNode.Dispose();
-            Assert.Equal(1, glyphRunRef.RefCount);
-        }
-
         [Fact]
         public void PushOpacityMask_Brush_Is_AddRefed_Once_And_Released_On_Dispose()
         {
@@ -412,24 +384,6 @@ namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
             Assert.False(rd.HitTest(new Point(50, 50)));
         }
 
-        [Fact]
-        public void PushGeometryClip_HitTest_Restricts_By_FillContains()
-        {
-            var geomMock = new Mock<IGeometryImpl>();
-            geomMock.Setup(g => g.FillContains(new Point(5, 5))).Returns(true);
-            geomMock.Setup(g => g.FillContains(new Point(50, 50))).Returns(false);
-
-            var node = new RenderDataGeometryClipNode { Geometry = geomMock.Object };
-            node.Children.Add(new RenderDataRectangleNode
-            {
-                ServerBrush = Brushes.Black,
-                Rect = new RoundedRect(new Rect(0, 0, 100, 100))
-            });
-
-            Assert.True(node.HitTest(new Point(5, 5)));
-            Assert.False(node.HitTest(new Point(50, 50)));
-        }
-
         [Fact]
         public void Geometry_Node_AddRefs_Brush_And_Pen()
         {
@@ -478,36 +432,6 @@ namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
             Assert.False(rd.HitTest(new Point(50, 50)));
         }
 
-        [Fact]
-        public void PushRenderOptions_Forwards_Push_And_Pop_To_Drawing_Context_Impl()
-        {
-            var mockImpl = new Mock<IDrawingContextImpl>();
-            var ctx = new RenderDataNodeRenderContext(mockImpl.Object);
-            var opts = new RenderOptions { EdgeMode = EdgeMode.Aliased };
-            var node = new RenderDataRenderOptionsNode { RenderOptions = opts };
-
-            node.Push(ref ctx);
-            node.Pop(ref ctx);
-
-            mockImpl.Verify(x => x.PushRenderOptions(opts), Times.Once);
-            mockImpl.Verify(x => x.PopRenderOptions(), Times.Once);
-        }
-
-        [Fact]
-        public void PushTextOptions_Forwards_Push_And_Pop_To_Drawing_Context_Impl()
-        {
-            var mockImpl = new Mock<IDrawingContextImpl>();
-            var ctx = new RenderDataNodeRenderContext(mockImpl.Object);
-            var opts = new TextOptions { TextRenderingMode = TextRenderingMode.Antialias };
-            var node = new RenderDataTextOptionsNode { TextOptions = opts };
-
-            node.Push(ref ctx);
-            node.Pop(ref ctx);
-
-            mockImpl.Verify(x => x.PushTextOptions(opts), Times.Once);
-            mockImpl.Verify(x => x.PopTextOptions(), Times.Once);
-        }
-
         [Fact]
         public void Two_Distinct_Brushes_Are_AddRefed_Separately()
         {
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/LineNodeTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/LineNodeTests.cs
deleted file mode 100644
index 2e36bd6392..0000000000
--- a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/LineNodeTests.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-using System.Collections.Generic;
-using Avalonia.Media;
-using Avalonia.Rendering.Composition.Drawing.Nodes;
-using Avalonia.Rendering.SceneGraph;
-using Xunit;
-
-namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
-{
-    public class LineNodeTests
-    {
-        static RenderDataLineNode LineNode(IPen pen, Point p1, Point p2) => new RenderDataLineNode
-        {
-            P1 = p1,
-            P2 = p2,
-            ServerPen = pen,
-            ClientPen = pen
-        };
-        
-        [Fact]
-        public void HitTest_Should_Be_True()
-        {
-            var lineNode = LineNode(
-                new Pen(Brushes.Black, 3),
-                new Point(15, 10),
-                new Point(150, 73));
-
-            var pointsInside = new List<Point>()
-            {
-                new Point(14, 8.9),
-                new Point(15, 10),
-                new Point(30, 15.5),
-                new Point(30, 18.5),
-                new Point(150, 73),
-                new Point(151, 71.9),
-            };
-
-            foreach (var point in pointsInside)
-            {
-                Assert.True(lineNode.HitTest(point));
-            }
-        }
-
-        [Fact]
-        public void HitTest_Should_Be_False()
-        {
-            var lineNode = LineNode(
-                new Pen(Brushes.Black, 3),
-                new Point(15, 10),
-                new Point(150, 73));
-
-            var pointsOutside = new List<Point>()
-            {
-                new Point(14, 8),
-                new Point(14, 8.8),
-                new Point(30, 15.3),
-                new Point(30, 18.7),
-                new Point(151, 71.8),
-                new Point(155, 75),
-            };
-
-            foreach (var point in pointsOutside)
-            {
-                Assert.False(lineNode.HitTest(point));
-            }
-        }
-    }
-}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataResourcesTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataResourcesTests.cs
new file mode 100644
index 0000000000..7396f9a950
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataResourcesTests.cs
@@ -0,0 +1,103 @@
+using Avalonia.Rendering.Composition.Drawing;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
+{
+    public class RenderDataResourcesTests
+    {
+        [Fact]
+        public void Intern_Null_Returns_Null_Handle()
+        {
+            var resources = new RenderDataResources();
+            Assert.Equal(RenderDataResources.NullHandle, resources.Intern(null));
+            Assert.Equal(0, resources.Count);
+        }
+
+        [Fact]
+        public void Intern_Same_Reference_Returns_Same_Handle()
+        {
+            var resources = new RenderDataResources();
+            var obj = new object();
+
+            var first = resources.Intern(obj);
+            var second = resources.Intern(obj);
+
+            Assert.Equal(first, second);
+            Assert.Equal(1, resources.Count);
+        }
+
+        [Fact]
+        public void Intern_Distinct_References_Return_Distinct_Handles()
+        {
+            var resources = new RenderDataResources();
+            var a = resources.Intern(new object());
+            var b = resources.Intern(new object());
+
+            Assert.NotEqual(a, b);
+            Assert.Equal(2, resources.Count);
+        }
+
+        [Fact]
+        public void Intern_Equal_But_Distinct_References_Return_Distinct_Handles()
+        {
+            var resources = new RenderDataResources();
+            var a = resources.Intern(new EqualByValue());
+            var b = resources.Intern(new EqualByValue());
+
+            Assert.NotEqual(a, b);
+            Assert.Equal(2, resources.Count);
+        }
+
+        [Fact]
+        public void Indexer_Returns_Interned_Resource()
+        {
+            var resources = new RenderDataResources();
+            var obj = new object();
+
+            var handle = resources.Intern(obj);
+
+            Assert.Same(obj, resources[handle]);
+        }
+
+        [Fact]
+        public void Indexer_Null_Handle_Returns_Null()
+        {
+            var resources = new RenderDataResources();
+            resources.Intern(new object());
+
+            Assert.Null(resources[RenderDataResources.NullHandle]);
+        }
+
+        [Fact]
+        public void AppendDeserialized_Appends_Without_Deduplication()
+        {
+            var resources = new RenderDataResources();
+            var obj = new object();
+
+            var first = resources.AppendDeserialized(obj);
+            var second = resources.AppendDeserialized(obj);
+
+            Assert.NotEqual(first, second);
+            Assert.Equal(2, resources.Count);
+            Assert.Same(obj, resources[first]);
+            Assert.Same(obj, resources[second]);
+        }
+
+        [Fact]
+        public void Dispose_Resets_The_Table()
+        {
+            var resources = new RenderDataResources();
+            resources.Intern(new object());
+
+            resources.Dispose();
+
+            Assert.Equal(0, resources.Count);
+        }
+
+        private sealed class EqualByValue
+        {
+            public override bool Equals(object? obj) => obj is EqualByValue;
+            public override int GetHashCode() => 1;
+        }
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamBoundsTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamBoundsTests.cs
new file mode 100644
index 0000000000..1fa1f71894
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamBoundsTests.cs
@@ -0,0 +1,177 @@
+using Avalonia.Media;
+using Avalonia.Media.Immutable;
+using Avalonia.Platform;
+using Avalonia.Rendering.Composition.Drawing;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Utilities;
+using Moq;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
+{
+    public class RenderDataStreamBoundsTests
+    {
+        [Fact]
+        public void Empty_Stream_Has_Null_Bounds()
+        {
+            using var stream = new RenderDataStream();
+            Assert.Null(stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Filled_Rectangle_Bounds_Are_The_Rectangle()
+        {
+            using var stream = new RenderDataStream();
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+
+            Assert.Equal(new Rect(0, 0, 10, 10), stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Stroked_Rectangle_Bounds_Are_Inflated_By_Half_Thickness()
+        {
+            var pen = new ImmutablePen(Brushes.Black, 4);
+
+            using var stream = new RenderDataStream();
+            stream.DrawRectangle(null, pen, pen,
+                new RoundedRect(new Rect(10, 10, 20, 20)), default);
+
+            Assert.Equal(new Rect(8, 8, 24, 24), stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Bounds_Are_The_Union_Of_All_Draws()
+        {
+            using var stream = new RenderDataStream();
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(20, 20, 10, 10)), default);
+
+            Assert.Equal(new Rect(0, 0, 30, 30), stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Stroked_Ellipse_Bounds_Are_Inflated_By_Thickness()
+        {
+            var pen = new ImmutablePen(Brushes.Black, 4);
+
+            using var stream = new RenderDataStream();
+            stream.DrawEllipse(null, pen, pen, new Rect(0, 0, 10, 10));
+
+            Assert.Equal(new Rect(-4, -4, 18, 18), stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Bitmap_Bounds_Are_The_Destination_Rect()
+        {
+            using var bitmap = RefCountable.Create(Mock.Of<IBitmapImpl>());
+
+            using var stream = new RenderDataStream();
+            stream.DrawBitmap(bitmap, 1, new Rect(0, 0, 10, 10), new Rect(5, 5, 20, 20));
+
+            Assert.Equal(new Rect(5, 5, 20, 20), stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Custom_Operation_Bounds_Are_Used()
+        {
+            var operation = new Mock<ICustomDrawOperation>();
+            operation.Setup(x => x.Bounds).Returns(new Rect(1, 2, 3, 4));
+
+            using var stream = new RenderDataStream();
+            stream.DrawCustom(operation.Object);
+
+            Assert.Equal(new Rect(1, 2, 3, 4), stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Line_Bounds_Cover_The_Segment()
+        {
+            var pen = new ImmutablePen(Brushes.Black, 2);
+
+            using var stream = new RenderDataStream();
+            stream.DrawLine(pen, pen, new Point(0, 0), new Point(100, 0));
+
+            var bounds = Assert.NotNull(stream.CalculateBounds());
+            Assert.True(bounds.Contains(new Point(50, 0)));
+        }
+
+        [Fact]
+        public void Transform_Is_Applied_To_Bounds()
+        {
+            using var stream = new RenderDataStream();
+            stream.PushTransform(Matrix.CreateTranslation(50, 50));
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            stream.Pop();
+
+            Assert.Equal(new Rect(50, 50, 10, 10), stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Nested_Transforms_Compose_For_Bounds()
+        {
+            using var stream = new RenderDataStream();
+            stream.PushTransform(Matrix.CreateTranslation(20, 20));
+            stream.PushTransform(Matrix.CreateScale(2, 2));
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            stream.Pop();
+            stream.Pop();
+
+            Assert.Equal(new Rect(20, 20, 20, 20), stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Clip_Does_Not_Restrict_Bounds()
+        {
+            using var stream = new RenderDataStream();
+            stream.PushClip(new RoundedRect(new Rect(0, 0, 5, 5)));
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 100, 100)), default);
+            stream.Pop();
+
+            Assert.Equal(new Rect(0, 0, 100, 100), stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Opacity_Push_Is_Transparent_To_Bounds()
+        {
+            using var stream = new RenderDataStream();
+            stream.PushOpacity(0.5);
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            stream.Pop();
+
+            Assert.Equal(new Rect(0, 0, 10, 10), stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Empty_Push_Scope_Contributes_Nothing()
+        {
+            using var stream = new RenderDataStream();
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            stream.PushTransform(Matrix.CreateTranslation(1000, 1000));
+            stream.Pop();
+
+            Assert.Equal(new Rect(0, 0, 10, 10), stream.CalculateBounds());
+        }
+
+        [Fact]
+        public void Bounds_Handles_Deeply_Nested_Scopes()
+        {
+            using var stream = new RenderDataStream();
+            for (var i = 0; i < 100; i++)
+                stream.PushOpacity(0.5);
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            for (var i = 0; i < 100; i++)
+                stream.Pop();
+
+            Assert.Equal(new Rect(0, 0, 10, 10), stream.CalculateBounds());
+        }
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamEffectTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamEffectTests.cs
new file mode 100644
index 0000000000..bed5d7825b
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamEffectTests.cs
@@ -0,0 +1,29 @@
+using Avalonia.Media;
+using Avalonia.Rendering.Composition.Drawing;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Rendering.SceneGraph;
+
+public class RenderDataStreamEffectTests
+{
+    [Fact]
+    public void Effect_Inflates_Child_Bounds_By_Padding()
+    {
+        using var stream = new RenderDataStream();
+        stream.PushEffect(new ImmutableBlurEffect(5), new Rect(0, 0, 100, 100));
+        stream.DrawRectangle(null, null, null, new RoundedRect(new Rect(0, 0, 100, 100)), default);
+        stream.Pop();
+
+        var padding = ((IEffect)new ImmutableBlurEffect(5)).GetEffectOutputPadding();
+        Assert.Equal(new Rect(0, 0, 100, 100).Inflate(padding), stream.CalculateBounds());
+    }
+
+    [Fact]
+    public void Empty_Effect_Scope_Has_Null_Bounds()
+    {
+        using var stream = new RenderDataStream();
+        stream.PushEffect(new ImmutableBlurEffect(5), new Rect(0, 0, 100, 100));
+        stream.Pop();
+        Assert.Null(stream.CalculateBounds());
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/EllipseNodeTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamEllipseHitTestTests.cs
similarity index 53%
rename from tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/EllipseNodeTests.cs
rename to tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamEllipseHitTestTests.cs
index 89cc63edec..bd81f5391d 100644
--- a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/EllipseNodeTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamEllipseHitTestTests.cs
@@ -1,12 +1,11 @@
-using Avalonia.Media;
+using Avalonia.Media;
 using Avalonia.Media.Immutable;
-using Avalonia.Rendering.Composition.Drawing.Nodes;
-using Avalonia.Rendering.SceneGraph;
+using Avalonia.Rendering.Composition.Drawing;
 using Xunit;
 
-namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
+namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
 {
-    public class EllipseNodeTests
+    public class RenderDataStreamEllipseHitTestTests
     {
         [Theory]
         [InlineData(50, 50, true)]
@@ -19,15 +18,10 @@ namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
         [InlineData(0, 101, false)]
         public void FillOnly_HitTest(double x, double y, bool inside)
         {
-            var ellipseNode = new RenderDataEllipseNode()
-            {
-                Rect = new Rect(0, 0, 100, 100),
-                ServerBrush = Brushes.Black
-            };
-            
-            var point = new Point(x, y);
+            using var stream = new RenderDataStream();
+            stream.DrawEllipse(Brushes.Black, null, null, new Rect(0, 0, 100, 100));
 
-            Assert.True(ellipseNode.HitTest(point) == inside);
+            Assert.Equal(inside, stream.HitTest(new Point(x, y)));
         }
 
         [Theory]
@@ -43,16 +37,11 @@ namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
         public void StrokeOnly_HitTest(double x, double y, bool inside)
         {
             var pen = new ImmutablePen(Brushes.Black, 2);
-            var ellipseNode = new RenderDataEllipseNode()
-            {
-                Rect = new Rect(0, 0, 100, 100),
-                ServerPen =  pen,
-                ClientPen = pen
-            };
 
-            var point = new Point(x, y);
+            using var stream = new RenderDataStream();
+            stream.DrawEllipse(null, pen, pen, new Rect(0, 0, 100, 100));
 
-            Assert.Equal(inside, ellipseNode.HitTest(point));
+            Assert.Equal(inside, stream.HitTest(new Point(x, y)));
         }
     }
 }
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamHitTestTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamHitTestTests.cs
new file mode 100644
index 0000000000..65dc9470f3
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamHitTestTests.cs
@@ -0,0 +1,208 @@
+using Avalonia.Media;
+using Avalonia.Media.Immutable;
+using Avalonia.Platform;
+using Avalonia.Rendering.Composition.Drawing;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Utilities;
+using Moq;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
+{
+    public class RenderDataStreamHitTestTests
+    {
+        [Fact]
+        public void Filled_Rectangle_Is_Hit_Inside_And_Missed_Outside()
+        {
+            using var stream = new RenderDataStream();
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 100, 100)), default);
+
+            Assert.True(stream.HitTest(new Point(50, 50)));
+            Assert.False(stream.HitTest(new Point(150, 150)));
+        }
+
+        [Fact]
+        public void Stroked_Rectangle_Is_Hit_On_Border_And_Missed_In_Hollow_Center()
+        {
+            var pen = new ImmutablePen(Brushes.Black, 4);
+
+            using var stream = new RenderDataStream();
+            stream.DrawRectangle(null, pen, pen,
+                new RoundedRect(new Rect(0, 0, 100, 100)), default);
+
+            Assert.True(stream.HitTest(new Point(0, 50)));
+            Assert.False(stream.HitTest(new Point(50, 50)));
+        }
+
+        [Fact]
+        public void Line_Is_Hit_Along_Its_Length()
+        {
+            var pen = new ImmutablePen(Brushes.Black, 4);
+
+            using var stream = new RenderDataStream();
+            stream.DrawLine(pen, pen, new Point(0, 0), new Point(100, 0));
+
+            Assert.True(stream.HitTest(new Point(50, 1)));
+            Assert.False(stream.HitTest(new Point(50, 50)));
+        }
+
+        [Fact]
+        public void Filled_Ellipse_Is_Hit_At_Center_And_Missed_At_Corner()
+        {
+            using var stream = new RenderDataStream();
+            stream.DrawEllipse(Brushes.Black, null, null, new Rect(0, 0, 100, 100));
+
+            Assert.True(stream.HitTest(new Point(50, 50)));
+            Assert.False(stream.HitTest(new Point(2, 2)));
+        }
+
+        [Fact]
+        public void Geometry_Is_Hit_Via_FillContains()
+        {
+            var geometry = new Mock<IGeometryImpl>();
+            geometry.Setup(x => x.FillContains(new Point(5, 5))).Returns(true);
+            geometry.Setup(x => x.FillContains(new Point(50, 50))).Returns(false);
+
+            using var stream = new RenderDataStream();
+            stream.DrawGeometry(Brushes.Black, null, null, geometry.Object);
+
+            Assert.True(stream.HitTest(new Point(5, 5)));
+            Assert.False(stream.HitTest(new Point(50, 50)));
+        }
+
+        [Fact]
+        public void Bitmap_Is_Hit_Within_Its_Destination_Rect()
+        {
+            using var bitmap = RefCountable.Create(Mock.Of<IBitmapImpl>());
+
+            using var stream = new RenderDataStream();
+            stream.DrawBitmap(bitmap, 1, new Rect(0, 0, 10, 10), new Rect(20, 20, 30, 30));
+
+            Assert.True(stream.HitTest(new Point(25, 25)));
+            Assert.False(stream.HitTest(new Point(5, 5)));
+        }
+
+        [Fact]
+        public void Custom_Operation_Hit_Test_Is_Delegated()
+        {
+            var operation = new Mock<ICustomDrawOperation>();
+            operation.Setup(x => x.HitTest(new Point(5, 5))).Returns(true);
+
+            using var stream = new RenderDataStream();
+            stream.DrawCustom(operation.Object);
+
+            Assert.True(stream.HitTest(new Point(5, 5)));
+            Assert.False(stream.HitTest(new Point(99, 99)));
+        }
+
+        [Fact]
+        public void Clip_Restricts_The_Hit_Region()
+        {
+            using var stream = new RenderDataStream();
+            stream.PushClip(new RoundedRect(new Rect(0, 0, 10, 10)));
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 100, 100)), default);
+            stream.Pop();
+
+            Assert.True(stream.HitTest(new Point(5, 5)));
+            Assert.False(stream.HitTest(new Point(50, 50)));
+        }
+
+        [Fact]
+        public void Geometry_Clip_Restricts_The_Hit_Region()
+        {
+            var geometry = new Mock<IGeometryImpl>();
+            geometry.Setup(x => x.FillContains(new Point(5, 5))).Returns(true);
+            geometry.Setup(x => x.FillContains(new Point(50, 50))).Returns(false);
+
+            using var stream = new RenderDataStream();
+            stream.PushGeometryClip(geometry.Object);
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 100, 100)), default);
+            stream.Pop();
+
+            Assert.True(stream.HitTest(new Point(5, 5)));
+            Assert.False(stream.HitTest(new Point(50, 50)));
+        }
+
+        [Fact]
+        public void Transform_Maps_Hit_Test_Coordinates()
+        {
+            using var stream = new RenderDataStream();
+            stream.PushTransform(Matrix.CreateTranslation(50, 50));
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            stream.Pop();
+
+            Assert.True(stream.HitTest(new Point(55, 55)));
+            Assert.False(stream.HitTest(new Point(5, 5)));
+        }
+
+        [Fact]
+        public void Nested_Transforms_Compose()
+        {
+            using var stream = new RenderDataStream();
+            stream.PushTransform(Matrix.CreateTranslation(20, 20));
+            stream.PushTransform(Matrix.CreateScale(2, 2));
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            stream.Pop();
+            stream.Pop();
+
+            Assert.True(stream.HitTest(new Point(30, 30)));
+            Assert.False(stream.HitTest(new Point(5, 5)));
+        }
+
+        [Fact]
+        public void Singular_Transform_Excludes_Its_Scope()
+        {
+            using var stream = new RenderDataStream();
+            stream.PushTransform(new Matrix());
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 100, 100)), default);
+            stream.Pop();
+
+            Assert.False(stream.HitTest(new Point(50, 50)));
+        }
+
+        [Fact]
+        public void Opacity_Push_Is_Transparent_To_Hit_Testing()
+        {
+            using var stream = new RenderDataStream();
+            stream.PushOpacity(0.5);
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 100, 100)), default);
+            stream.Pop();
+
+            Assert.True(stream.HitTest(new Point(50, 50)));
+        }
+
+        [Fact]
+        public void Scope_State_Is_Restored_After_Pop()
+        {
+            using var stream = new RenderDataStream();
+            stream.PushTransform(Matrix.CreateTranslation(1000, 1000));
+            stream.Pop();
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+
+            Assert.True(stream.HitTest(new Point(5, 5)));
+        }
+
+        [Fact]
+        public void Hit_Test_Handles_Deeply_Nested_Scopes()
+        {
+            using var stream = new RenderDataStream();
+            for (var i = 0; i < 100; i++)
+                stream.PushOpacity(0.5);
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            for (var i = 0; i < 100; i++)
+                stream.Pop();
+
+            Assert.True(stream.HitTest(new Point(5, 5)));
+            Assert.False(stream.HitTest(new Point(50, 50)));
+        }
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamLineHitTestTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamLineHitTestTests.cs
new file mode 100644
index 0000000000..10ce87a7b9
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamLineHitTestTests.cs
@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Rendering.Composition.Drawing;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
+{
+    public class RenderDataStreamLineHitTestTests
+    {
+        private static RenderDataStream LineStream(IPen pen, Point p1, Point p2)
+        {
+            var stream = new RenderDataStream();
+            stream.DrawLine(pen, pen, p1, p2);
+            return stream;
+        }
+
+        [Fact]
+        public void HitTest_Should_Be_True()
+        {
+            using var stream = LineStream(new Pen(Brushes.Black, 3), new Point(15, 10), new Point(150, 73));
+
+            var pointsInside = new List<Point>
+            {
+                new Point(14, 8.9),
+                new Point(15, 10),
+                new Point(30, 15.5),
+                new Point(30, 18.5),
+                new Point(150, 73),
+                new Point(151, 71.9),
+            };
+
+            foreach (var point in pointsInside)
+                Assert.True(stream.HitTest(point));
+        }
+
+        [Fact]
+        public void HitTest_Should_Be_False()
+        {
+            using var stream = LineStream(new Pen(Brushes.Black, 3), new Point(15, 10), new Point(150, 73));
+
+            var pointsOutside = new List<Point>
+            {
+                new Point(14, 8),
+                new Point(14, 8.8),
+                new Point(30, 15.3),
+                new Point(30, 18.7),
+                new Point(151, 71.8),
+                new Point(155, 75),
+            };
+
+            foreach (var point in pointsOutside)
+                Assert.False(stream.HitTest(point));
+        }
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamSerializationTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamSerializationTests.cs
new file mode 100644
index 0000000000..4abae13451
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamSerializationTests.cs
@@ -0,0 +1,98 @@
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Rendering.Composition.Drawing;
+using Avalonia.Rendering.Composition.Transport;
+using Moq;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
+{
+    public class RenderDataStreamSerializationTests
+    {
+        [Fact]
+        public void Round_Trip_Preserves_Bounds()
+        {
+            using var source = new RenderDataStream();
+            source.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            source.PushTransform(Matrix.CreateTranslation(40, 40));
+            source.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            source.Pop();
+
+            using var result = RoundTrip(source);
+
+            Assert.Equal(source.CalculateBounds(), result.CalculateBounds());
+            Assert.Equal(new Rect(0, 0, 50, 50), result.CalculateBounds());
+        }
+
+        [Fact]
+        public void Round_Trip_Preserves_Hit_Testing()
+        {
+            using var source = new RenderDataStream();
+            source.PushClip(new RoundedRect(new Rect(0, 0, 10, 10)));
+            source.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 100, 100)), default);
+            source.Pop();
+
+            using var result = RoundTrip(source);
+
+            Assert.True(result.HitTest(new Point(5, 5)));
+            Assert.False(result.HitTest(new Point(50, 50)));
+        }
+
+        [Fact]
+        public void Round_Trip_Preserves_Resource_References()
+        {
+            var brush = Mock.Of<IBrush>();
+            using var source = new RenderDataStream();
+            source.DrawRectangle(brush, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+
+            using var result = RoundTrip(source);
+
+            var context = new Mock<IDrawingContextImpl>();
+            result.Replay(context.Object);
+            context.Verify(x => x.DrawRectangle(brush, null,
+                It.IsAny<RoundedRect>(), It.IsAny<BoxShadows>()), Times.Once);
+        }
+
+        [Fact]
+        public void Round_Trip_Of_Empty_Stream_Produces_Empty_Stream()
+        {
+            using var source = new RenderDataStream();
+            using var result = RoundTrip(source);
+
+            Assert.Null(result.CalculateBounds());
+        }
+
+        [Fact]
+        public void Round_Trip_Spanning_Multiple_Stream_Segments()
+        {
+            using var source = new RenderDataStream();
+            for (var i = 0; i < 50; i++)
+                source.DrawRectangle(Brushes.Black, null, null,
+                    new RoundedRect(new Rect(i, i, 1, 1)), default);
+
+            using var result = RoundTrip(source);
+
+            Assert.Equal(source.CalculateBounds(), result.CalculateBounds());
+        }
+
+        private static RenderDataStream RoundTrip(RenderDataStream source)
+        {
+            var data = new BatchStreamData();
+            var memoryPool = new BatchStreamMemoryPool(false, 64, _ => { });
+            var objectPool = new BatchStreamObjectPool<object?>(false, 8, _ => { });
+
+            using (var writer = new BatchStreamWriter(data, memoryPool, objectPool))
+                source.SerializeTo(writer);
+
+            var result = new RenderDataStream();
+            using (var reader = new BatchStreamReader(data, memoryPool, objectPool))
+                result.DeserializeFrom(reader);
+
+            return result;
+        }
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamTests.cs
new file mode 100644
index 0000000000..943ae19994
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamTests.cs
@@ -0,0 +1,228 @@
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Rendering.Composition.Drawing;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Utilities;
+using Moq;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
+{
+    public class RenderDataStreamTests
+    {
+        [Fact]
+        public void Replay_Forwards_Line()
+        {
+            var pen = Mock.Of<IPen>();
+            var context = new Mock<IDrawingContextImpl>();
+
+            using var stream = new RenderDataStream();
+            stream.DrawLine(pen, pen, new Point(1, 2), new Point(3, 4));
+            stream.Replay(context.Object);
+
+            context.Verify(x => x.DrawLine(pen, new Point(1, 2), new Point(3, 4)), Times.Once);
+        }
+
+        [Fact]
+        public void Replay_Forwards_Rectangle_With_Box_Shadows()
+        {
+            var brush = Mock.Of<IBrush>();
+            var pen = Mock.Of<IPen>();
+            var rect = new RoundedRect(new Rect(0, 0, 10, 20));
+            var shadows = new BoxShadows(
+                new BoxShadow { Blur = 1 },
+                new[] { new BoxShadow { Blur = 2 } });
+            var context = new Mock<IDrawingContextImpl>();
+
+            using var stream = new RenderDataStream();
+            stream.DrawRectangle(brush, pen, pen, rect, shadows);
+            stream.Replay(context.Object);
+
+            context.Verify(x => x.DrawRectangle(brush, pen, rect,
+                It.Is<BoxShadows>(s => s.Count == 2)), Times.Once);
+        }
+
+        [Fact]
+        public void Replay_Forwards_Custom_Operation()
+        {
+            var operation = new Mock<ICustomDrawOperation>();
+            var context = new Mock<IDrawingContextImpl>();
+
+            using var stream = new RenderDataStream();
+            stream.DrawCustom(operation.Object);
+            stream.Replay(context.Object);
+
+            operation.Verify(x => x.Render(It.IsAny<ImmediateDrawingContext>()), Times.Once);
+        }
+
+        [Fact]
+        public void Replay_Pop_Dispatches_To_Matching_Pop_In_Lifo_Order()
+        {
+            var calls = new List<string>();
+            var context = RecordingContext(calls);
+
+            using var stream = new RenderDataStream();
+            stream.PushClip(new RoundedRect(new Rect(0, 0, 10, 10)));
+            stream.PushOpacity(0.5);
+            stream.Pop();
+            stream.Pop();
+            stream.Replay(context.Object);
+
+            Assert.Equal(new[] { "PushClip", "PushOpacity", "PopOpacity", "PopClip" }, calls);
+        }
+
+        [Fact]
+        public void Replay_Applies_And_Restores_Transform()
+        {
+            var context = new Mock<IDrawingContextImpl>();
+            context.SetupProperty(x => x.Transform);
+            context.Object.Transform = Matrix.Identity;
+            var matrix = Matrix.CreateTranslation(5, 7);
+
+            using var stream = new RenderDataStream();
+            stream.PushTransform(matrix);
+            stream.Pop();
+
+            stream.Replay(context.Object);
+
+            Assert.Equal(Matrix.Identity, context.Object.Transform);
+        }
+
+        [Fact]
+        public void Replay_Skips_Opacity_One_Push()
+        {
+            var calls = new List<string>();
+            var context = RecordingContext(calls);
+
+            using var stream = new RenderDataStream();
+            stream.PushOpacity(1);
+            stream.Pop();
+            stream.Replay(context.Object);
+
+            Assert.Empty(calls);
+        }
+
+        [Fact]
+        public void Replay_Skips_Null_Geometry_Clip()
+        {
+            var calls = new List<string>();
+            var context = RecordingContext(calls);
+
+            using var stream = new RenderDataStream();
+            stream.PushGeometryClip(null);
+            stream.Pop();
+            stream.Replay(context.Object);
+
+            Assert.Empty(calls);
+        }
+
+        [Fact]
+        public void Replay_Walks_Nested_Pushes_In_Order()
+        {
+            var calls = new List<string>();
+            var context = RecordingContext(calls);
+
+            using var stream = new RenderDataStream();
+            stream.PushClip(new RoundedRect(new Rect(0, 0, 10, 10)));
+            stream.PushGeometryClip(Mock.Of<IGeometryImpl>());
+            stream.Pop();
+            stream.Pop();
+            stream.Replay(context.Object);
+
+            Assert.Equal(
+                new[] { "PushClip", "PushGeometryClip", "PopGeometryClip", "PopClip" },
+                calls);
+        }
+
+        [Fact]
+        public void Replay_Forwards_Render_Options()
+        {
+            var options = new RenderOptions { EdgeMode = EdgeMode.Aliased };
+            var context = new Mock<IDrawingContextImpl>();
+
+            using var stream = new RenderDataStream();
+            stream.PushRenderOptions(options);
+            stream.Pop();
+            stream.Replay(context.Object);
+
+            context.Verify(x => x.PushRenderOptions(options), Times.Once);
+            context.Verify(x => x.PopRenderOptions(), Times.Once);
+        }
+
+        [Fact]
+        public void Replay_Forwards_Text_Options()
+        {
+            var options = new TextOptions { TextRenderingMode = TextRenderingMode.Antialias };
+            var context = new Mock<IDrawingContextImpl>();
+
+            using var stream = new RenderDataStream();
+            stream.PushTextOptions(options);
+            stream.Pop();
+            stream.Replay(context.Object);
+
+            context.Verify(x => x.PushTextOptions(options), Times.Once);
+            context.Verify(x => x.PopTextOptions(), Times.Once);
+        }
+
+        [Fact]
+        public void Dispose_Resources_Disposes_Owned_Resources()
+        {
+            var bitmap = RefCountable.Create(Mock.Of<IBitmapImpl>());
+            var glyphRun = RefCountable.Create(Mock.Of<IGlyphRunImpl>());
+            var operation = new Mock<ICustomDrawOperation>();
+
+            using (var stream = new RenderDataStream())
+            {
+                stream.DrawBitmap(bitmap.Clone(), 1, new Rect(0, 0, 1, 1), new Rect(0, 0, 1, 1));
+                stream.DrawGlyphRun(null, glyphRun.Clone());
+                stream.DrawCustom(operation.Object);
+
+                Assert.Equal(2, bitmap.RefCount);
+                Assert.Equal(2, glyphRun.RefCount);
+
+                stream.DisposeResources();
+            }
+
+            Assert.Equal(1, bitmap.RefCount);
+            Assert.Equal(1, glyphRun.RefCount);
+            operation.Verify(x => x.Dispose(), Times.Once);
+
+            bitmap.Dispose();
+            glyphRun.Dispose();
+        }
+
+        [Fact]
+        public void Replay_Handles_Deeply_Nested_Scopes()
+        {
+            var context = new Mock<IDrawingContextImpl>();
+
+            using var stream = new RenderDataStream();
+            for (var i = 0; i < 100; i++)
+                stream.PushOpacity(0.5);
+            stream.DrawRectangle(Brushes.Black, null, null,
+                new RoundedRect(new Rect(0, 0, 10, 10)), default);
+            for (var i = 0; i < 100; i++)
+                stream.Pop();
+
+            stream.Replay(context.Object);
+
+            context.Verify(x => x.DrawRectangle(Brushes.Black, null,
+                It.IsAny<RoundedRect>(), It.IsAny<BoxShadows>()), Times.Once);
+        }
+
+        private static Mock<IDrawingContextImpl> RecordingContext(List<string> calls)
+        {
+            var context = new Mock<IDrawingContextImpl>();
+            context.Setup(x => x.PushClip(It.IsAny<RoundedRect>())).Callback(() => calls.Add("PushClip"));
+            context.Setup(x => x.PopClip()).Callback(() => calls.Add("PopClip"));
+            context.Setup(x => x.PushGeometryClip(It.IsAny<IGeometryImpl>()))
+                .Callback(() => calls.Add("PushGeometryClip"));
+            context.Setup(x => x.PopGeometryClip()).Callback(() => calls.Add("PopGeometryClip"));
+            context.Setup(x => x.PushOpacity(It.IsAny<double>(), It.IsAny<Rect?>()))
+                .Callback(() => calls.Add("PushOpacity"));
+            context.Setup(x => x.PopOpacity()).Callback(() => calls.Add("PopOpacity"));
+            return context;
+        }
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataWriterReaderTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataWriterReaderTests.cs
new file mode 100644
index 0000000000..97fa1d8740
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataWriterReaderTests.cs
@@ -0,0 +1,237 @@
+using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using Avalonia.Rendering.Composition.Drawing;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
+{
+    public class RenderDataWriterReaderTests
+    {
+        [Fact]
+        public void Primitives_Round_Trip()
+        {
+            var writer = new RenderDataWriter();
+            try
+            {
+                writer.Write<byte>(200);
+                writer.WriteOpcode(RenderDataOpcode.DrawGeometry);
+                writer.Write(-123456);
+                writer.Write(4000000000u);
+                writer.Write(3.14159);
+                writer.Write(true);
+                writer.Write(false);
+
+                var reader = new RenderDataReader(writer.Written);
+                Assert.Equal(200, reader.Read<byte>());
+                Assert.Equal(RenderDataOpcode.DrawGeometry, reader.Read<RenderDataOpcode>());
+                Assert.Equal(-123456, reader.Read<int>());
+                Assert.Equal(4000000000u, reader.Read<uint>());
+                Assert.Equal(3.14159, reader.Read<double>());
+                Assert.True(reader.Read<bool>());
+                Assert.False(reader.Read<bool>());
+                Assert.True(reader.IsAtEnd);
+            }
+            finally
+            {
+                writer.Dispose();
+            }
+        }
+
+        [Fact]
+        public void Geometric_Structs_Round_Trip()
+        {
+            var point = new Point(1, 2);
+            var vector = new Vector(3, 4);
+            var rect = new Rect(5, 6, 7, 8);
+            var roundedRect = new RoundedRect(new Rect(1, 2, 30, 40),
+                new Vector(1, 1), new Vector(2, 2), new Vector(3, 3), new Vector(4, 4));
+            var matrix = new Matrix(1, 2, 3, 4, 5, 6, 7, 8, 9);
+
+            var writer = new RenderDataWriter();
+            try
+            {
+                writer.Write(point);
+                writer.Write(vector);
+                writer.Write(rect);
+                writer.Write(roundedRect);
+                writer.Write(matrix);
+
+                var reader = new RenderDataReader(writer.Written);
+                Assert.Equal(point, reader.Read<Point>());
+                Assert.Equal(vector, reader.Read<Vector>());
+                Assert.Equal(rect, reader.Read<Rect>());
+
+                var readRounded = reader.Read<RoundedRect>();
+                Assert.Equal(roundedRect.Rect, readRounded.Rect);
+                Assert.Equal(roundedRect.RadiiTopLeft, readRounded.RadiiTopLeft);
+                Assert.Equal(roundedRect.RadiiTopRight, readRounded.RadiiTopRight);
+                Assert.Equal(roundedRect.RadiiBottomRight, readRounded.RadiiBottomRight);
+                Assert.Equal(roundedRect.RadiiBottomLeft, readRounded.RadiiBottomLeft);
+
+                Assert.Equal(matrix, reader.Read<Matrix>());
+                Assert.True(reader.IsAtEnd);
+            }
+            finally
+            {
+                writer.Dispose();
+            }
+        }
+
+        [Fact]
+        public void Color_And_BoxShadow_Round_Trip()
+        {
+            var color = Color.FromArgb(10, 20, 30, 40);
+            var shadow = new BoxShadow
+            {
+                OffsetX = 1.5,
+                OffsetY = -2.5,
+                Blur = 3,
+                Spread = 4,
+                Color = Color.FromArgb(255, 1, 2, 3),
+                IsInset = true
+            };
+
+            var writer = new RenderDataWriter();
+            try
+            {
+                writer.Write(color);
+                writer.Write(shadow);
+
+                var reader = new RenderDataReader(writer.Written);
+                Assert.Equal(color, reader.Read<Color>());
+
+                var readShadow = reader.Read<BoxShadow>();
+                Assert.Equal(shadow.OffsetX, readShadow.OffsetX);
+                Assert.Equal(shadow.OffsetY, readShadow.OffsetY);
+                Assert.Equal(shadow.Blur, readShadow.Blur);
+                Assert.Equal(shadow.Spread, readShadow.Spread);
+                Assert.Equal(shadow.Color, readShadow.Color);
+                Assert.Equal(shadow.IsInset, readShadow.IsInset);
+                Assert.True(reader.IsAtEnd);
+            }
+            finally
+            {
+                writer.Dispose();
+            }
+        }
+
+        [Fact]
+        public void RenderOptions_And_TextOptions_Round_Trip()
+        {
+            var renderOptions = new RenderOptions
+            {
+#pragma warning disable CS0618
+                TextRenderingMode = TextRenderingMode.Antialias,
+#pragma warning restore CS0618
+                BitmapInterpolationMode = BitmapInterpolationMode.HighQuality,
+                EdgeMode = EdgeMode.Aliased,
+                BitmapBlendingMode = BitmapBlendingMode.Plus,
+                RequiresFullOpacityHandling = true
+            };
+            var textOptions = new TextOptions
+            {
+                TextRenderingMode = TextRenderingMode.SubpixelAntialias,
+                TextHintingMode = TextHintingMode.Light,
+                BaselinePixelAlignment = BaselinePixelAlignment.Aligned
+            };
+
+            var writer = new RenderDataWriter();
+            try
+            {
+                writer.Write(renderOptions);
+                writer.Write(textOptions);
+
+                var reader = new RenderDataReader(writer.Written);
+                Assert.Equal(renderOptions, reader.Read<RenderOptions>());
+                Assert.Equal(textOptions, reader.Read<TextOptions>());
+                Assert.True(reader.IsAtEnd);
+            }
+            finally
+            {
+                writer.Dispose();
+            }
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void Nullable_Boolean_Round_Trips_All_Three_States(bool? value)
+        {
+            var writer = new RenderDataWriter();
+            try
+            {
+                writer.Write(new RenderOptions { RequiresFullOpacityHandling = value });
+
+                var reader = new RenderDataReader(writer.Written);
+                Assert.Equal(value, reader.Read<RenderOptions>().RequiresFullOpacityHandling);
+            }
+            finally
+            {
+                writer.Dispose();
+            }
+        }
+
+        [Fact]
+        public void Length_Tracks_Written_Bytes()
+        {
+            var writer = new RenderDataWriter();
+            try
+            {
+                Assert.Equal(0, writer.Length);
+                writer.Write<byte>(1);
+                Assert.Equal(1, writer.Length);
+                writer.Write(2);
+                Assert.Equal(5, writer.Length);
+                writer.Write(3d);
+                Assert.Equal(13, writer.Length);
+            }
+            finally
+            {
+                writer.Dispose();
+            }
+        }
+
+        [Fact]
+        public void Writer_Grows_Buffer_To_Fit_Large_Payloads()
+        {
+            var writer = new RenderDataWriter();
+            try
+            {
+                for (var i = 0; i < 1000; i++)
+                    writer.Write(i);
+
+                Assert.Equal(4000, writer.Length);
+
+                var reader = new RenderDataReader(writer.Written);
+                for (var i = 0; i < 1000; i++)
+                    Assert.Equal(i, reader.Read<int>());
+                Assert.True(reader.IsAtEnd);
+            }
+            finally
+            {
+                writer.Dispose();
+            }
+        }
+
+        [Fact]
+        public void Payload_Auto_Prepends_Opcode()
+        {
+            var writer = new RenderDataWriter();
+            try
+            {
+                writer.WritePayload(new PushOpacityPayload { Opacity = 0.5 });
+
+                var reader = new RenderDataReader(writer.Written);
+                Assert.Equal(RenderDataOpcode.PushOpacity, reader.Read<RenderDataOpcode>());
+                var payload = reader.Read<PushOpacityPayload>();
+                Assert.Equal(0.5, payload.Opacity);
+                Assert.True(reader.IsAtEnd);
+            }
+            finally
+            {
+                writer.Dispose();
+            }
+        }
+    }
+}

From 9808817e31a1fec0bc361df1a29b9ecd66639a5b Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Mon, 15 Jun 2026 13:46:27 +0200
Subject: [PATCH 016/196] Enable stencil buffers by default + add configurable
 option (#21586)

---
 src/Skia/Avalonia.Skia/Gpu/Metal/SkiaMetalGpu.cs   |  5 +++--
 src/Skia/Avalonia.Skia/Gpu/OpenGl/GlSkiaGpu.cs     |  5 +++--
 src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs |  6 ++++--
 src/Skia/Avalonia.Skia/PlatformRenderInterface.cs  | 10 ++++++----
 src/Skia/Avalonia.Skia/SkiaOptions.cs              |  6 ++++++
 src/Skia/Avalonia.Skia/SkiaPlatform.cs             |  2 +-
 6 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/src/Skia/Avalonia.Skia/Gpu/Metal/SkiaMetalGpu.cs b/src/Skia/Avalonia.Skia/Gpu/Metal/SkiaMetalGpu.cs
index ccb3a51705..05bcd9fa42 100644
--- a/src/Skia/Avalonia.Skia/Gpu/Metal/SkiaMetalGpu.cs
+++ b/src/Skia/Avalonia.Skia/Gpu/Metal/SkiaMetalGpu.cs
@@ -15,11 +15,12 @@ internal class SkiaMetalGpu : ISkiaGpu
 
     internal GRContext GrContext => _context ?? throw new ObjectDisposedException(nameof(SkiaMetalGpu));
 
-    public SkiaMetalGpu(IMetalDevice device, long? maxResourceBytes)
+    public SkiaMetalGpu(IMetalDevice device, long? maxResourceBytes, bool? useStencilBuffers = null)
     {
+        var avoidStencilBuffers = useStencilBuffers == false;
         _context = GRContext.CreateMetal(
                        new GRMtlBackendContext { DeviceHandle = device.Device, QueueHandle = device.CommandQueue, },
-                       new GRContextOptions { AvoidStencilBuffers = true })
+                       new GRContextOptions { AvoidStencilBuffers = avoidStencilBuffers })
                    ?? throw new InvalidOperationException("Unable to create GRContext from Metal device.");
         _device = device;
         if (device.TryGetFeature<IMetalExternalObjectsFeature>() is { } externalObjects)
diff --git a/src/Skia/Avalonia.Skia/Gpu/OpenGl/GlSkiaGpu.cs b/src/Skia/Avalonia.Skia/Gpu/OpenGl/GlSkiaGpu.cs
index ed29231adf..af957551e3 100644
--- a/src/Skia/Avalonia.Skia/Gpu/OpenGl/GlSkiaGpu.cs
+++ b/src/Skia/Avalonia.Skia/Gpu/OpenGl/GlSkiaGpu.cs
@@ -21,7 +21,7 @@ namespace Avalonia.Skia
         private bool? _canCreateSurfaces;
         private readonly IExternalObjectsRenderInterfaceContextFeature? _externalObjectsFeature;
 
-        public GlSkiaGpu(IGlContext context, long? maxResourceBytes)
+        public GlSkiaGpu(IGlContext context, long? maxResourceBytes, bool? useStencilBuffers)
         {
             _glContext = context;
             using (_glContext.EnsureCurrent())
@@ -40,7 +40,8 @@ namespace Avalonia.Skia
                 
                 using(iface)
                 {
-                    _grContext = GRContext.CreateGl(iface, new GRContextOptions { AvoidStencilBuffers = true });
+                    var avoidStencilBuffers = useStencilBuffers == false;
+                    _grContext = GRContext.CreateGl(iface, new GRContextOptions { AvoidStencilBuffers = avoidStencilBuffers });
                     if (maxResourceBytes.HasValue)
                     {
                         _grContext.SetResourceCacheLimit(maxResourceBytes.Value);
diff --git a/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs b/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs
index 476cb31d95..54dfd68fc0 100644
--- a/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs
+++ b/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs
@@ -13,7 +13,7 @@ internal class VulkanSkiaGpu : ISkiaGpu
     public IVulkanPlatformGraphicsContext Vulkan { get; private set; }
     public GRContext GrContext { get; private set; }
 
-    public VulkanSkiaGpu(IVulkanPlatformGraphicsContext vulkan, long? maxResourceBytes)
+    public VulkanSkiaGpu(IVulkanPlatformGraphicsContext vulkan, long? maxResourceBytes, bool? useStencilBuffers)
     {
         Vulkan = vulkan;
         var device = vulkan.Device;
@@ -48,7 +48,9 @@ internal class VulkanSkiaGpu : ISkiaGpu
                 GetProcedureAddress = GetProcAddressWrapper
             };
 
-            GrContext = GRContext.CreateVulkan(ctx) ??
+            var avoidStencilBuffers = useStencilBuffers == false;
+            
+            GrContext = GRContext.CreateVulkan(ctx, new GRContextOptions { AvoidStencilBuffers = avoidStencilBuffers }) ??
                          throw new VulkanException("Unable to create GrContext from IVulkanDevice");
             
             if (maxResourceBytes.HasValue)
diff --git a/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs b/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs
index df7f6cd48f..0376f1844b 100644
--- a/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs
+++ b/src/Skia/Avalonia.Skia/PlatformRenderInterface.cs
@@ -20,10 +20,12 @@ namespace Avalonia.Skia
     internal class PlatformRenderInterface : IPlatformRenderInterface
     {
         private readonly long? _maxResourceBytes;
+        private readonly bool? _useStencilBuffers;
 
-        public PlatformRenderInterface(long? maxResourceBytes = null)
+        public PlatformRenderInterface(long? maxResourceBytes = null, bool? useStencilBuffers = null)
         {
             _maxResourceBytes = maxResourceBytes;
+            _useStencilBuffers = useStencilBuffers;
             DefaultPixelFormat = SKImageInfo.PlatformColorType.ToPixelFormat();
         }
 
@@ -35,11 +37,11 @@ namespace Avalonia.Skia
             if (graphicsContext is ISkiaGpu skiaGpu)
                 return new SkiaContext(skiaGpu);
             if (graphicsContext is IGlContext gl)
-                return new SkiaContext(new GlSkiaGpu(gl, _maxResourceBytes));
+                return new SkiaContext(new GlSkiaGpu(gl, _maxResourceBytes, _useStencilBuffers));
             if (graphicsContext is IMetalDevice metal)
-                return new SkiaContext(new SkiaMetalGpu(metal, _maxResourceBytes));
+                return new SkiaContext(new SkiaMetalGpu(metal, _maxResourceBytes, _useStencilBuffers));
             if (graphicsContext is IVulkanPlatformGraphicsContext vulkanContext)
-                return new SkiaContext(new VulkanSkiaGpu(vulkanContext, _maxResourceBytes));
+                return new SkiaContext(new VulkanSkiaGpu(vulkanContext, _maxResourceBytes, _useStencilBuffers));
             throw new ArgumentException("Graphics context of type is not supported");
         }
 
diff --git a/src/Skia/Avalonia.Skia/SkiaOptions.cs b/src/Skia/Avalonia.Skia/SkiaOptions.cs
index 84ad547d6c..1a95919300 100644
--- a/src/Skia/Avalonia.Skia/SkiaOptions.cs
+++ b/src/Skia/Avalonia.Skia/SkiaOptions.cs
@@ -24,5 +24,11 @@ namespace Avalonia
         /// Enabling this might have performance implications.
         /// </remarks>
         public bool UseOpacitySaveLayer { get; set; } = false;
+        
+        /// <summary>
+        /// Gets whether stencil buffers can be used for various draw operations, improving performance.
+        /// If null (the default), Avalonia chooses whether to enable stencil buffers depending on the platform.
+        /// </summary>
+        public bool? UseStencilBuffers { get; set; }
     }
 }
diff --git a/src/Skia/Avalonia.Skia/SkiaPlatform.cs b/src/Skia/Avalonia.Skia/SkiaPlatform.cs
index a81b6d5413..c1415147e4 100644
--- a/src/Skia/Avalonia.Skia/SkiaPlatform.cs
+++ b/src/Skia/Avalonia.Skia/SkiaPlatform.cs
@@ -17,7 +17,7 @@ namespace Avalonia.Skia
 
         public static void Initialize(SkiaOptions options)
         {
-            var renderInterface = new PlatformRenderInterface(options.MaxGpuResourceSizeBytes);
+            var renderInterface = new PlatformRenderInterface(options.MaxGpuResourceSizeBytes, options.UseStencilBuffers);
 
             AvaloniaLocator.CurrentMutable
                 .Bind<IPlatformRenderInterface>().ToConstant(renderInterface)

From fcbd5d037a6be605b1d4145c5068f1b4cfb4433b Mon Sep 17 00:00:00 2001
From: Nicholas Lachapelle
 <102546121+NicholasLachapelle@users.noreply.github.com>
Date: Mon, 15 Jun 2026 10:44:11 -0400
Subject: [PATCH 017/196] Fix StackOverflow when a NaN offset is set on
 ScrollViewer (#21558)

ScrollViewer.Offset and ScrollContentPresenter.Offset form a two-way coerced
binding whose convergence is decided with the default equality comparer. Because
NaN != NaN, a NaN offset is reported "changed" on every pass, so the coerce/raise
cycle never converges and recurses until the stack overflows -- an unrecoverable
crash (on Mono/AOT targets such as Android it surfaces as a native SIGSEGV).

CoerceOffset's Clamp passed NaN straight through (NaN < min and NaN > max are
both false), so a NaN component survived coercion. Sanitize it to the lower
bound so the coerce always converges, regardless of where the NaN came from.

Fixes #21444

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 src/Avalonia.Controls/ScrollViewer.cs         |  8 ++++++++
 .../ScrollViewerTests.cs                      | 19 +++++++++++++++++++
 2 files changed, 27 insertions(+)

diff --git a/src/Avalonia.Controls/ScrollViewer.cs b/src/Avalonia.Controls/ScrollViewer.cs
index 2593c4b475..96580d9d49 100644
--- a/src/Avalonia.Controls/ScrollViewer.cs
+++ b/src/Avalonia.Controls/ScrollViewer.cs
@@ -696,6 +696,14 @@ namespace Avalonia.Controls
 
         private static double Clamp(double value, double min, double max)
         {
+            // A NaN offset must never survive. Offset is two-way coerced between the ScrollViewer and its
+            // ScrollContentPresenter; because NaN != NaN, a NaN offset never compares equal, so the
+            // coerce/raise cycle never converges and recurses until it overflows the stack (see #21444).
+            if (double.IsNaN(value))
+            {
+                return min;
+            }
+
             return (value < min) ? min : (value > max) ? max : value;
         }
 
diff --git a/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs b/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs
index ec1cd5fb66..35e25f6538 100644
--- a/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs
@@ -44,6 +44,25 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Vector(10, 10), target.Offset);
         }
 
+        [Fact]
+        public void Setting_Offset_To_NaN_Does_Not_Cause_Infinite_Coerce_Recursion()
+        {
+            var target = new ScrollViewer
+            {
+                Template = new FuncControlTemplate<ScrollViewer>(CreateTemplate),
+                Content = "Foo",
+                Extent = new Size(100, 100),
+                Viewport = new Size(10, 10),
+            };
+
+            InitializeScrollViewer(target);
+
+            target.Offset = new Vector(0, double.NaN);
+
+            Assert.False(double.IsNaN(target.Offset.X));
+            Assert.False(double.IsNaN(target.Offset.Y));
+        }
+
         [Fact]
         public void Test_ScrollToHome()
         {

From fdf1017cb53e6e0d0083ce3ca5b74aaee395a6b6 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Tue, 16 Jun 2026 05:01:53 +0200
Subject: [PATCH 018/196] Fix ClipboardUriListHelper not flushing (#21589)

---
 src/Avalonia.X11/Clipboard/ClipboardUriListHelper.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Avalonia.X11/Clipboard/ClipboardUriListHelper.cs b/src/Avalonia.X11/Clipboard/ClipboardUriListHelper.cs
index da175c5828..b6717c2d2f 100644
--- a/src/Avalonia.X11/Clipboard/ClipboardUriListHelper.cs
+++ b/src/Avalonia.X11/Clipboard/ClipboardUriListHelper.cs
@@ -47,6 +47,8 @@ internal static class ClipboardUriListHelper
         foreach (var item in items)
             writer.WriteLine(item.Path.AbsoluteUri);
 
+        writer.Flush();
+
         return stream.ToArray();
     }
 }

From 06af9e8c95510d41d1357fb0c322eeff037d0681 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Tue, 16 Jun 2026 13:26:33 +0500
Subject: [PATCH 019/196] Workarounds for NVIDIA EGL drivers (#21590)

* Workaround for nvidia EGL driver quirk with invalid draw/read/write buffers if surfaceless context was ever used

* X11: Fixed desktop EGL support for nvidia drivers
---
 src/Avalonia.OpenGL/Avalonia.OpenGL.csproj    |  4 +
 src/Avalonia.OpenGL/Egl/EglConsts.cs          |  5 +-
 src/Avalonia.OpenGL/Egl/EglDisplay.cs         | 15 ++-
 src/Avalonia.OpenGL/Egl/EglDisplayOptions.cs  |  9 ++
 src/Avalonia.OpenGL/Egl/EglDisplayUtils.cs    | 28 +++++-
 .../Egl/EglGlPlatformSurfaceBase.cs           | 15 +++
 src/Avalonia.OpenGL/Egl/EglInterface.cs       |  9 +-
 .../Egl/EglPlatformGraphics.cs                |  1 +
 src/Avalonia.OpenGL/GlConsts.cs               |  2 +-
 src/Avalonia.OpenGL/GlInterface.cs            |  9 ++
 src/Avalonia.X11/X11EglHelper.cs              | 97 +++++++++++++++++++
 src/Avalonia.X11/X11Platform.cs               | 34 +++++--
 src/Avalonia.X11/X11Window.cs                 | 24 ++++-
 src/Avalonia.X11/XLib.cs                      | 22 ++++-
 14 files changed, 252 insertions(+), 22 deletions(-)
 create mode 100644 src/Avalonia.X11/X11EglHelper.cs

diff --git a/src/Avalonia.OpenGL/Avalonia.OpenGL.csproj b/src/Avalonia.OpenGL/Avalonia.OpenGL.csproj
index fbe6a77974..887e375877 100644
--- a/src/Avalonia.OpenGL/Avalonia.OpenGL.csproj
+++ b/src/Avalonia.OpenGL/Avalonia.OpenGL.csproj
@@ -10,6 +10,10 @@
     <ProjectReference Include="..\Avalonia.Controls\Avalonia.Controls.csproj" />
   </ItemGroup>
 
+  <ItemGroup Label="InternalsVisibleTo">
+    <InternalsVisibleTo Include="Avalonia.X11, PublicKey=$(AvaloniaPublicKey)" />
+  </ItemGroup>
+
   <Import Project="..\..\build\DevAnalyzers.props" />
   <Import Project="..\..\build\SourceGenerators.props" />
   <Import Project="..\..\build\TrimmingEnable.props" />
diff --git a/src/Avalonia.OpenGL/Egl/EglConsts.cs b/src/Avalonia.OpenGL/Egl/EglConsts.cs
index b4fe8a99eb..295acef44b 100644
--- a/src/Avalonia.OpenGL/Egl/EglConsts.cs
+++ b/src/Avalonia.OpenGL/Egl/EglConsts.cs
@@ -35,7 +35,7 @@ namespace Avalonia.OpenGL.Egl
 //        public const int  EGL_MAX_PBUFFER_PIXELS = 0x302B;
 //        public const int  EGL_MAX_PBUFFER_WIDTH = 0x302C;
 //        public const int  EGL_NATIVE_RENDERABLE = 0x302D;
-//        public const int  EGL_NATIVE_VISUAL_ID = 0x302E;
+        public const int  EGL_NATIVE_VISUAL_ID = 0x302E;
 //        public const int  EGL_NATIVE_VISUAL_TYPE = 0x302F;
         public const int  EGL_NONE = 0x3038;
 //        public const int  EGL_NON_CONFORMANT_CONFIG = 0x3051;
@@ -200,6 +200,9 @@ namespace Avalonia.OpenGL.Egl
         // EXT_platform_device
         public const int EGL_PLATFORM_DEVICE_EXT = 0x313F;
 
+        // KHR_platform_x11 / EXT_platform_x11
+        public const int EGL_PLATFORM_X11_EXT = 0x31D5;
+
 
         //EXT_device_query
         public const int  EGL_DEVICE_EXT = 0x322C;
diff --git a/src/Avalonia.OpenGL/Egl/EglDisplay.cs b/src/Avalonia.OpenGL/Egl/EglDisplay.cs
index 373aa0e964..1aefc20850 100644
--- a/src/Avalonia.OpenGL/Egl/EglDisplay.cs
+++ b/src/Avalonia.OpenGL/Egl/EglDisplay.cs
@@ -45,7 +45,7 @@ namespace Avalonia.OpenGL.Egl
             if(_display == IntPtr.Zero)
                 throw new ArgumentException();
 
-            _config = EglDisplayUtils.InitializeAndGetConfig(_egl, display, options.GlVersions);
+            _config = EglDisplayUtils.InitializeAndGetConfig(_egl, display, options.GlVersions, options.ProbeConfig);
         }
         
         public EglInterface EglInterface => _egl;
@@ -84,7 +84,18 @@ namespace Avalonia.OpenGL.Egl
                     }
                 }
 
-                var ctx = _egl.CreateContext(_display, Config, share?.Context ?? IntPtr.Zero, _config.Attributes);
+                var previousApi = _egl.QueryApi();
+                _egl.BindApi(_config.Api);
+                IntPtr ctx;
+                try
+                {
+                    ctx = _egl.CreateContext(_display, Config, share?.Context ?? IntPtr.Zero, _config.Attributes);
+                }
+                finally
+                {
+                    if (previousApi != EGL_NONE)
+                        _egl.BindApi(previousApi);
+                }
                 if (ctx == IntPtr.Zero)
                 {
                     var ex = OpenGlException.GetFormattedException("eglCreateContext", _egl);
diff --git a/src/Avalonia.OpenGL/Egl/EglDisplayOptions.cs b/src/Avalonia.OpenGL/Egl/EglDisplayOptions.cs
index a2cbeb5b3d..2963890d32 100644
--- a/src/Avalonia.OpenGL/Egl/EglDisplayOptions.cs
+++ b/src/Avalonia.OpenGL/Egl/EglDisplayOptions.cs
@@ -3,6 +3,14 @@ using System.Collections.Generic;
 
 namespace Avalonia.OpenGL.Egl;
 
+/// <summary>
+/// Given every EGL config matched by eglChooseConfig, returns the one that should be used, or null if none
+/// are usable. This lets platforms filter out broken configs that can't be distinguished by their attributes
+/// (e.g. nvidia exposes duplicate, partially broken configs) and impose their own preference order between
+/// usable ones (e.g. preferring a transparent/32-bit X11 visual, which mesa lists after the opaque ones).
+/// </summary>
+public delegate IntPtr? EglConfigProbeCallback(EglInterface egl, IntPtr display, IntPtr[] configs);
+
 public class EglDisplayOptions
 {
     public EglInterface? Egl { get; set; }
@@ -12,6 +20,7 @@ public class EglDisplayOptions
     public Func<bool>? DeviceLostCheckCallback { get; set; }
     public Action? DisposeCallback { get; set; }
     public IEnumerable<GlVersion>? GlVersions { get; set; }
+    public EglConfigProbeCallback? ProbeConfig { get; set; }
 }
 
 public class EglContextOptions
diff --git a/src/Avalonia.OpenGL/Egl/EglDisplayUtils.cs b/src/Avalonia.OpenGL/Egl/EglDisplayUtils.cs
index 6ca7ab70c2..b214f6d85e 100644
--- a/src/Avalonia.OpenGL/Egl/EglDisplayUtils.cs
+++ b/src/Avalonia.OpenGL/Egl/EglDisplayUtils.cs
@@ -29,7 +29,28 @@ internal static class EglDisplayUtils
         return display;
     }
 
-    public static EglConfigInfo InitializeAndGetConfig(EglInterface egl, IntPtr display, IEnumerable<GlVersion>? versions)
+    // Enumerates every config matching the attribute list and lets the probe callback pick one (or simply
+    // takes the first one if no probe is supplied).
+    private static IntPtr? ChooseConfigWithProbe(EglInterface egl, IntPtr display, int[] attribs,
+        EglConfigProbeCallback? probe)
+    {
+        if (!egl.ChooseConfigs(display, attribs, null, 0, out var numConfigs) || numConfigs == 0)
+            return null;
+
+        var configs = new IntPtr[numConfigs];
+        if (!egl.ChooseConfigs(display, attribs, configs, configs.Length, out numConfigs) || numConfigs == 0)
+            return null;
+        if (numConfigs != configs.Length)
+            Array.Resize(ref configs, numConfigs);
+
+        if (probe == null)
+            return configs[0];
+
+        return probe(egl, display, configs);
+    }
+
+    public static EglConfigInfo InitializeAndGetConfig(EglInterface egl, IntPtr display,
+        IEnumerable<GlVersion>? versions, EglConfigProbeCallback? probeConfig = null)
     {
         if (!egl.Initialize(display, out _, out _))
             throw OpenGlException.GetFormattedException("eglInitialize", egl);
@@ -122,11 +143,8 @@ internal static class EglDisplayUtils
                     EGL_DEPTH_SIZE, depthSize,
                     EGL_NONE
                 };
-                if (!egl.ChooseConfig(display, attribs, out var config, 1, out int numConfigs))
+                if (ChooseConfigWithProbe(egl, display, attribs, probeConfig) is not { } config)
                     continue;
-                if (numConfigs == 0)
-                    continue;
-
 
                 egl.GetConfigAttrib(display, config, EGL_SAMPLES, out var sampleCount);
                 egl.GetConfigAttrib(display, config, EGL_STENCIL_SIZE, out var returnedStencilSize);
diff --git a/src/Avalonia.OpenGL/Egl/EglGlPlatformSurfaceBase.cs b/src/Avalonia.OpenGL/Egl/EglGlPlatformSurfaceBase.cs
index 8ee06266d8..d3deb3d102 100644
--- a/src/Avalonia.OpenGL/Egl/EglGlPlatformSurfaceBase.cs
+++ b/src/Avalonia.OpenGL/Egl/EglGlPlatformSurfaceBase.cs
@@ -53,6 +53,21 @@ namespace Avalonia.OpenGL.Egl
 
                 Context.GlInterface.BindFramebuffer(GlConsts.GL_FRAMEBUFFER, 0);
                 
+                // Workaround for driver quirk https://github.com/NVIDIA/egl-wayland2/issues/46
+                // This is NVIDIA-specific, but setting buffers to GL_BACK won't hurt for other drivers too
+                if (Context.Version.Type == GlProfileType.OpenGL)
+                {
+                    var gl = Context.GlInterface;
+                    gl.Viewport(0, 0, size.Width, size.Height);
+                    if (gl.IsReadBufferAvailable)
+                        gl.ReadBuffer(GlConsts.GL_BACK);
+                    if (gl.IsWriteBufferAvailable)
+                        gl.WriteBuffer(GlConsts.GL_BACK);
+                    if(gl.IsDrawBufferAvailable)
+                        gl.DrawBuffer(GlConsts.GL_BACK);
+                }
+
+                
                 success = true;
                 return new Session(Context.Display, Context, surface, size, scaling,  restoreContext, onFinish, isYFlipped, SkipWaits);
             }
diff --git a/src/Avalonia.OpenGL/Egl/EglInterface.cs b/src/Avalonia.OpenGL/Egl/EglInterface.cs
index a0210b544e..6b83731b49 100644
--- a/src/Avalonia.OpenGL/Egl/EglInterface.cs
+++ b/src/Avalonia.OpenGL/Egl/EglInterface.cs
@@ -75,7 +75,14 @@ namespace Avalonia.OpenGL.Egl
         [GetProcAddress("eglChooseConfig")]
         public partial bool ChooseConfig(IntPtr display, int[] attribs,
             out IntPtr surfaceConfig, int numConfigs, out int choosenConfig);
-        
+
+        // Returns all configs matching the attribute list. Pass a null `configs` array to query the
+        // available config count first. Some drivers (notably nvidia) expose multiple indistinguishable
+        // configs where only a subset is actually usable, so callers need to enumerate and probe them.
+        [GetProcAddress("eglChooseConfig")]
+        public partial bool ChooseConfigs(IntPtr display, int[] attribs,
+            IntPtr[]? configs, int configSize, out int numConfigs);
+
         [GetProcAddress("eglCreateContext")]
         public partial IntPtr CreateContext(IntPtr display, IntPtr config,
             IntPtr share, int[] attrs);
diff --git a/src/Avalonia.OpenGL/Egl/EglPlatformGraphics.cs b/src/Avalonia.OpenGL/Egl/EglPlatformGraphics.cs
index cf81999095..df0f80f1ce 100644
--- a/src/Avalonia.OpenGL/Egl/EglPlatformGraphics.cs
+++ b/src/Avalonia.OpenGL/Egl/EglPlatformGraphics.cs
@@ -7,6 +7,7 @@ namespace Avalonia.OpenGL.Egl
     public sealed class EglPlatformGraphics : IPlatformGraphics
     {
         private readonly EglDisplay _display;
+        internal EglDisplay Display => _display;
         public bool UsesSharedContext => false;
         public IPlatformGraphicsContext CreateContext() => _display.CreateContext(null);
         public IPlatformGraphicsContext GetSharedContext() => throw new NotSupportedException();
diff --git a/src/Avalonia.OpenGL/GlConsts.cs b/src/Avalonia.OpenGL/GlConsts.cs
index c1e1df0639..98b6e42da3 100644
--- a/src/Avalonia.OpenGL/GlConsts.cs
+++ b/src/Avalonia.OpenGL/GlConsts.cs
@@ -85,7 +85,7 @@ namespace Avalonia.OpenGL
 //        public const int GL_CW = 0x0900;
 //        public const int GL_CCW = 0x0901;
 //        public const int GL_FRONT = 0x0404;
-//        public const int GL_BACK = 0x0405;
+        public const int GL_BACK = 0x0405;
 //        public const int GL_POLYGON_MODE = 0x0B40;
 //        public const int GL_POLYGON_SMOOTH = 0x0B41;
 //        public const int GL_POLYGON_STIPPLE = 0x0B42;
diff --git a/src/Avalonia.OpenGL/GlInterface.cs b/src/Avalonia.OpenGL/GlInterface.cs
index 63d265c41e..55eab4563b 100644
--- a/src/Avalonia.OpenGL/GlInterface.cs
+++ b/src/Avalonia.OpenGL/GlInterface.cs
@@ -388,6 +388,15 @@ namespace Avalonia.OpenGL
         [GlExtensionEntryPoint("glGenVertexArraysOES", "GL_OES_vertex_array_object")]
         public partial void GenVertexArrays(int n, int* rv);
 
+        [GetProcAddress("glReadBuffer", true)]
+        public partial void ReadBuffer(int buffer);
+        
+        [GetProcAddress("glDrawBuffer", true)]
+        public partial void DrawBuffer(int buffer);
+        
+        [GetProcAddress("glWriteBuffer", true)]
+        public partial void WriteBuffer(int buffer);
+
         public int GenVertexArray()
         {
             int rv = 0;
diff --git a/src/Avalonia.X11/X11EglHelper.cs b/src/Avalonia.X11/X11EglHelper.cs
new file mode 100644
index 0000000000..2cb70a998a
--- /dev/null
+++ b/src/Avalonia.X11/X11EglHelper.cs
@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Logging;
+using Avalonia.OpenGL.Egl;
+using static Avalonia.OpenGL.Egl.EglConsts;
+using static Avalonia.X11.XLib;
+
+namespace Avalonia.X11
+{
+    internal static class X11EglHelper
+    {
+        /// <summary>
+        /// Resolves the <see cref="XVisualInfo"/> that matches the EGL config's native visual id.
+        /// nvidia's driver requires the X11 window visual to match the config used to create the surface,
+        /// otherwise eglCreateWindowSurface fails. Returns null when the config doesn't advertise a visual id
+        /// (e.g. mesa, where any visual works).
+        /// </summary>
+        public static XVisualInfo? GetVisualInfo(X11Info x11, EglInterface egl, IntPtr display, IntPtr config)
+        {
+            if (!egl.GetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, out var visualId) || visualId == 0)
+                return null;
+            return XGetVisualInfoById(x11.DeferredDisplay, new IntPtr(visualId));
+        }
+
+        public static XVisualInfo? GetVisualInfo(X11Info x11, EglDisplay display) =>
+            GetVisualInfo(x11, display.EglInterface, display.Handle, display.Config);
+
+        /// <summary>
+        /// Picks the EGL config to use out of the ones matched by eglChooseConfig. Each candidate is verified by
+        /// creating a throwaway window with the config's native visual and attempting to create an EGL window
+        /// surface on it: nvidia exposes multiple identical-looking configs where only a subset actually works,
+        /// so the broken ones are discarded here. A 32-bit (transparent-capable) X11 visual is preferred,
+        /// mirroring the GLX backend which selects a 32-bit visual; mesa lists those configs after the opaque
+        /// ones. We resolve the (cheap) native visuals up-front and probe in preference order, so the expensive
+        /// window-surface creation is attempted as few times as possible.
+        /// </summary>
+        public static IntPtr? ChooseConfig(X11Info x11, EglInterface egl, IntPtr display, IntPtr[] configs)
+        {
+            var candidates = new List<(IntPtr config, XVisualInfo visual)>(configs.Length);
+            foreach (var config in configs)
+            {
+                if (GetVisualInfo(x11, egl, display, config) is { } visual)
+                    candidates.Add((config, visual));
+                else
+                    Logger.TryGet(LogEventLevel.Verbose, "OpenGL")
+                        ?.Log(null, "EGL config {Config} has no native visual id", config);
+            }
+
+            // OrderByDescending is stable, so configs keep eglChooseConfig's relative order within each group.
+            foreach (var (config, visual) in candidates.OrderByDescending(c => c.visual.depth == 32))
+            {
+                if (ProbeConfig(x11, egl, display, config, visual))
+                    return config;
+            }
+
+            return null;
+        }
+
+        private static bool ProbeConfig(X11Info x11, EglInterface egl, IntPtr display, IntPtr config,
+            XVisualInfo vi)
+        {
+            var colormap = XCreateColormap(x11.DeferredDisplay, x11.RootWindow, vi.visual, 0);
+            var attr = new XSetWindowAttributes
+            {
+                colormap = colormap,
+                border_pixel = IntPtr.Zero
+            };
+
+            var window = XCreateWindow(x11.DeferredDisplay, x11.RootWindow, 0, 0, 1, 1, 0,
+                (int)vi.depth, (int)CreateWindowArgs.InputOutput, vi.visual,
+                new UIntPtr((uint)(SetWindowValuemask.ColorMap | SetWindowValuemask.BorderPixel)), ref attr);
+
+            if (window == IntPtr.Zero)
+            {
+                XFreeColormap(x11.DeferredDisplay, colormap);
+                return false;
+            }
+
+            XFlush(x11.DeferredDisplay);
+
+            var surface = egl.CreateWindowSurface(display, config, window, new[] { EGL_NONE, EGL_NONE });
+            var success = surface != IntPtr.Zero;
+            if (success)
+                egl.DestroySurface(display, surface);
+
+            XDestroyWindow(x11.DeferredDisplay, window);
+            XFreeColormap(x11.DeferredDisplay, colormap);
+
+            Logger.TryGet(LogEventLevel.Verbose, "OpenGL")?.Log(null,
+                "EGL config {Config}: visualId={VisualId} depth={Depth} usable={Usable}",
+                config, vi.visualid, vi.depth, success);
+
+            return success;
+        }
+    }
+}
diff --git a/src/Avalonia.X11/X11Platform.cs b/src/Avalonia.X11/X11Platform.cs
index 8b918aa27e..c043bf9bbf 100644
--- a/src/Avalonia.X11/X11Platform.cs
+++ b/src/Avalonia.X11/X11Platform.cs
@@ -227,13 +227,35 @@ namespace Avalonia.X11
 
                 if (renderingMode == X11RenderingMode.Egl)
                 {
-                    if (EglPlatformGraphics.TryCreate(()=>new EglDisplay(new EglDisplayCreationOptions()
+                    if (EglPlatformGraphics.TryCreate(() =>
                         {
-                            SupportsContextSharing = true,
-                            SupportsMultipleContexts = true,
-                            GlVersions = opts.GlProfiles,
-                            Egl = new EglInterface()
-                        })) is { } egl)
+                            var egl = new EglInterface();
+                            var options = new EglDisplayCreationOptions
+                            {
+                                SupportsContextSharing = true,
+                                SupportsMultipleContexts = true,
+                                GlVersions = opts.GlProfiles,
+                                Egl = egl,
+                                // nvidia exposes multiple indistinguishable configs of which only some work,
+                                // so we probe candidates by creating a throwaway window surface and pick a usable one.
+                                ProbeConfig = (probeEgl, display, configs) =>
+                                    X11EglHelper.ChooseConfig(info, probeEgl, display, configs)
+                            };
+
+                            // nvidia requires the display to be created through the X11 platform extension,
+                            // otherwise EGL_NATIVE_VISUAL_ID doesn't match the actual window visual.
+                            var clientExtensions = egl.QueryString(IntPtr.Zero, EglConsts.EGL_EXTENSIONS);
+                            if (egl.IsGetPlatformDisplayExtAvailable
+                                && clientExtensions != null
+                                && (clientExtensions.Contains("EGL_KHR_platform_x11")
+                                    || clientExtensions.Contains("EGL_EXT_platform_x11")))
+                            {
+                                options.PlatformType = EglConsts.EGL_PLATFORM_X11_EXT;
+                                options.PlatformDisplay = info.DeferredDisplay;
+                            }
+
+                            return new EglDisplay(options);
+                        }) is { } egl)
                     {
                         return egl;
                     }
diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index 91fbfb93d2..67b97979cc 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -125,8 +125,9 @@ namespace Avalonia.X11
 
             // OpenGL seems to be do weird things to it's current window which breaks resize sometimes
             _useRenderWindow = glfeature != null;
-            
+
             var glx = glfeature as GlxPlatformGraphics;
+            var egl = glfeature as EglPlatformGraphics;
             if (glx != null)
             {
                 visualInfo = *glx.Display.VisualInfo;
@@ -134,11 +135,13 @@ namespace Avalonia.X11
                 // the target sufrace currently is
                 _useCompositorDrivenRenderWindowResize = true;
             }
+            else if (egl != null)
+            {
+                visualInfo = X11EglHelper.GetVisualInfo(_x11, egl.Display);
+            }
             else if (glfeature == null)
                 visualInfo = _x11.TransparentVisualInfo;
 
-            var egl = glfeature as EglPlatformGraphics;
-            
             var visual = IntPtr.Zero;
             var depth = 24;
             if (visualInfo != null)
@@ -177,11 +180,17 @@ namespace Avalonia.X11
 
             if (_useRenderWindow)
             {
+                var renderValueMask = SetWindowValuemask.BorderPixel | SetWindowValuemask.BitGravity |
+                                      SetWindowValuemask.WinGravity | SetWindowValuemask.BackingStore;
+                // A window with a non-default visual must be created with a matching colormap, otherwise X11
+                // raises BadMatch. This is required by nvidia when a custom visual is selected for the EGL config.
+                if (visualInfo != null)
+                    renderValueMask |= SetWindowValuemask.ColorMap;
+
                 _renderHandle = XCreateWindow(_x11.Display, _handle, 0, 0, defaultWidth, defaultHeight, 0, depth,
                     (int)CreateWindowArgs.InputOutput,
                     visual,
-                    new UIntPtr((uint)(SetWindowValuemask.BorderPixel | SetWindowValuemask.BitGravity |
-                                       SetWindowValuemask.WinGravity | SetWindowValuemask.BackingStore)), ref attr);
+                    new UIntPtr((uint)renderValueMask), ref attr);
             }
             else
             {
@@ -281,6 +290,11 @@ namespace Avalonia.X11
             });
 
             platform.X11Screens.Changed += OnScreensChanged;
+
+            // The render surface (EGL/GLX) is created on the deferred display connection, which is a separate
+            // X11 connection from the one the windows were created on. Force a round-trip so the server has
+            // actually created the windows before anything on the other connection tries to use them.
+            XSync(_x11.Display, false);
         }
 
         private class SurfaceInfo  : EglGlPlatformSurface.IEglWindowGlPlatformSurfaceInfo
diff --git a/src/Avalonia.X11/XLib.cs b/src/Avalonia.X11/XLib.cs
index 595e996733..0b663d7a1b 100644
--- a/src/Avalonia.X11/XLib.cs
+++ b/src/Avalonia.X11/XLib.cs
@@ -459,7 +459,27 @@ namespace Avalonia.X11
         
         [DllImport(libX11)]
         public static extern IntPtr XCreateColormap(IntPtr display, IntPtr window, IntPtr visual, int create);
-        
+
+        [DllImport(libX11)]
+        public static extern int XFreeColormap(IntPtr display, IntPtr colormap);
+
+        public const long VisualIDMask = 0x1;
+
+        [DllImport(libX11)]
+        public static extern IntPtr XGetVisualInfo(IntPtr display, IntPtr vinfo_mask, ref XVisualInfo vinfo_template,
+            out int nitems);
+
+        public static unsafe XVisualInfo? XGetVisualInfoById(IntPtr display, IntPtr visualId)
+        {
+            var template = new XVisualInfo { visualid = visualId };
+            var ptr = XGetVisualInfo(display, new IntPtr(VisualIDMask), ref template, out var count);
+            if (ptr == IntPtr.Zero)
+                return null;
+            XVisualInfo? rv = count > 0 ? *(XVisualInfo*)ptr : null;
+            XFree(ptr);
+            return rv;
+        }
+
         public enum XLookupStatus : uint
         {
             XBufferOverflow = 0xffffffffu,

From 0050f0653510e208f72b13c86ddcb2af0c59226a Mon Sep 17 00:00:00 2001
From: yoyo <143886016+zrt2399@users.noreply.github.com>
Date: Tue, 16 Jun 2026 21:22:28 +0800
Subject: [PATCH 020/196] fix(TextBox): avoid read-only editing side effects in
 keyboard handlers (#21587)

---
 src/Avalonia.Controls/TextBox.cs              |  92 +++++++----
 .../TextBoxTests.cs                           | 155 +++++++++++++++++-
 2 files changed, 213 insertions(+), 34 deletions(-)

diff --git a/src/Avalonia.Controls/TextBox.cs b/src/Avalonia.Controls/TextBox.cs
index 962afb637f..dac2dd98c7 100644
--- a/src/Avalonia.Controls/TextBox.cs
+++ b/src/Avalonia.Controls/TextBox.cs
@@ -1040,6 +1040,10 @@ namespace Avalonia.Controls
                 UpdatePseudoclasses();
                 UpdateCommandStates();
             }
+            else if (change.Property == IsReadOnlyProperty || change.Property == PasswordCharProperty)
+            {
+                UpdateCommandStates();
+            }
             else if (change.Property == CaretIndexProperty)
             {
                 OnCaretIndexChanged(change);
@@ -1373,7 +1377,7 @@ namespace Avalonia.Controls
             }
             else if (Match(keymap.Copy))
             {
-                if (!IsPasswordBox)
+                if (CanCopy)
                 {
                     Copy();
                 }
@@ -1382,7 +1386,7 @@ namespace Avalonia.Controls
             }
             else if (Match(keymap.Cut))
             {
-                if (!IsPasswordBox)
+                if (CanCut)
                 {
                     Cut();
                 }
@@ -1391,18 +1395,28 @@ namespace Avalonia.Controls
             }
             else if (Match(keymap.Paste))
             {
-                Paste();
+                if (CanPaste)
+                {
+                    Paste();
+                }
+
                 handled = true;
             }
             else if (Match(keymap.Undo) && IsUndoEnabled)
             {
-                Undo();
+                if (!IsReadOnly)
+                {
+                    Undo();
+                }
 
                 handled = true;
             }
             else if (Match(keymap.Redo) && IsUndoEnabled)
             {
-                Redo();
+                if (!IsReadOnly)
+                {
+                    Redo();
+                }
 
                 handled = true;
             }
@@ -1546,6 +1560,7 @@ namespace Avalonia.Controls
                         break;
 
                     case Key.Back:
+                        if (!IsReadOnly)
                         {
                             SnapshotUndoRedo();
 
@@ -1591,38 +1606,42 @@ namespace Avalonia.Controls
                             }
 
                             SnapshotUndoRedo();
-
-                            handled = true;
-                            break;
                         }
-                    case Key.Delete:
-                        SnapshotUndoRedo();
 
-                        if (hasWholeWordModifiers && SelectionStart == SelectionEnd)
-                        {
-                            SetSelectionForControlDelete();
-                        }
+                        handled = true;
+                        break;
 
-                        if (!DeleteSelection())
+                    case Key.Delete:
+                        if (!IsReadOnly)
                         {
-                            var characterHit = _presenter.GetNextCharacterHit();
+                            SnapshotUndoRedo();
 
-                            var nextPosition = characterHit.FirstCharacterIndex + characterHit.TrailingLength;
+                            if (hasWholeWordModifiers && SelectionStart == SelectionEnd)
+                            {
+                                SetSelectionForControlDelete();
+                            }
 
-                            if (nextPosition != caretIndex)
+                            if (!DeleteSelection())
                             {
-                                var start = Math.Min(nextPosition, caretIndex);
-                                var end = Math.Max(nextPosition, caretIndex);
+                                var characterHit = _presenter.GetNextCharacterHit();
+
+                                var nextPosition = characterHit.FirstCharacterIndex + characterHit.TrailingLength;
 
-                                var sb = StringBuilderCache.Acquire(text.Length);
-                                sb.Append(text);
-                                sb.Remove(start, end - start);
+                                if (nextPosition != caretIndex)
+                                {
+                                    var start = Math.Min(nextPosition, caretIndex);
+                                    var end = Math.Max(nextPosition, caretIndex);
 
-                                SetCurrentValue(TextProperty, StringBuilderCache.GetStringAndRelease(sb));
+                                    var sb = StringBuilderCache.Acquire(text.Length);
+                                    sb.Append(text);
+                                    sb.Remove(start, end - start);
+
+                                    SetCurrentValue(TextProperty, StringBuilderCache.GetStringAndRelease(sb));
+                                }
                             }
-                        }
 
-                        SnapshotUndoRedo();
+                            SnapshotUndoRedo();
+                        }
 
                         handled = true;
                         break;
@@ -1630,8 +1649,12 @@ namespace Avalonia.Controls
                     case Key.Enter:
                         if (AcceptsReturn)
                         {
-                            SnapshotUndoRedo();
-                            HandleTextInput(NewLine);
+                            if (!IsReadOnly)
+                            {
+                                SnapshotUndoRedo();
+                                HandleTextInput(NewLine);
+                            }
+
                             handled = true;
                         }
 
@@ -1640,8 +1663,12 @@ namespace Avalonia.Controls
                     case Key.Tab:
                         if (AcceptsTab)
                         {
-                            SnapshotUndoRedo();
-                            HandleTextInput("\t");
+                            if (!IsReadOnly)
+                            {
+                                SnapshotUndoRedo();
+                                HandleTextInput("\t");
+                            }
+
                             handled = true;
                         }
                         else
@@ -1652,7 +1679,10 @@ namespace Avalonia.Controls
                         break;
 
                     case Key.Space:
-                        SnapshotUndoRedo(); // always snapshot in between words
+                        if (!IsReadOnly)
+                        {
+                            SnapshotUndoRedo(); // always snapshot in between words
+                        }
                         break;
 
                     default:
diff --git a/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs b/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
index 9d7b8a6118..bf0af90b27 100644
--- a/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
@@ -1482,6 +1482,117 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Command_States_Update_When_ReadOnly_And_PasswordChar_Change()
+        {
+            using (UnitTestApplication.Start(Services))
+            {
+                var tb = new TextBox
+                {
+                    Template = CreateTemplate(),
+                    Text = "1234",
+                    SelectionStart = 1,
+                    SelectionEnd = 3,
+                };
+
+                tb.Measure(Size.Infinity);
+
+                Assert.True(tb.CanCopy);
+                Assert.True(tb.CanCut);
+                Assert.True(tb.CanPaste);
+
+                tb.IsReadOnly = true;
+
+                Assert.True(tb.CanCopy);
+                Assert.False(tb.CanCut);
+                Assert.False(tb.CanPaste);
+
+                tb.PasswordChar = '*';
+
+                Assert.False(tb.CanCopy);
+                Assert.False(tb.CanCut);
+                Assert.False(tb.CanPaste);
+
+                tb.IsReadOnly = false;
+
+                Assert.False(tb.CanCopy);
+                Assert.False(tb.CanCut);
+                Assert.True(tb.CanPaste);
+
+                tb.PasswordChar = default;
+
+                Assert.True(tb.CanCopy);
+                Assert.True(tb.CanCut);
+                Assert.True(tb.CanPaste);
+            }
+        }
+
+        [Fact]
+        public void ReadOnly_Editing_Hotkeys_Do_Not_Modify_Text_Or_Undo_State()
+        {
+            using (UnitTestApplication.Start(Services))
+            {
+                var tb = new TextBox
+                {
+                    Template = CreateTemplate(),
+                    AcceptsReturn = true,
+                    AcceptsTab = true,
+                };
+
+                tb.Measure(Size.Infinity);
+
+                RaiseTextEvent(tb, "ABC");
+                RaiseKeyEvent(tb, Key.Space, KeyModifiers.None);
+                RaiseTextEvent(tb, "DEF");
+
+                Assert.Equal("ABCDEF", tb.Text);
+
+                tb.Undo();
+
+                Assert.Equal("ABC", tb.Text);
+                Assert.True(tb.CanUndo);
+                Assert.True(tb.CanRedo);
+
+                tb.IsReadOnly = true;
+                tb.CaretIndex = tb.Text!.Length;
+                tb.SelectionStart = 0;
+                tb.SelectionEnd = tb.Text.Length;
+
+                var originalText = tb.Text;
+                var originalCaretIndex = tb.CaretIndex;
+                var originalSelectionStart = tb.SelectionStart;
+                var originalSelectionEnd = tb.SelectionEnd;
+                var originalCanUndo = tb.CanUndo;
+                var originalCanRedo = tb.CanRedo;
+
+                var cutRaised = 0;
+                var pasteRaised = 0;
+                tb.CuttingToClipboard += (_, _) => cutRaised++;
+                tb.PastingFromClipboard += (_, _) => pasteRaised++;
+
+                AssertReadOnlyHotkeyLeavesStateUntouched(tb, Application.Current!.PlatformSettings!.HotkeyConfiguration.Cut, handled: true);
+                AssertReadOnlyHotkeyLeavesStateUntouched(tb, Application.Current.PlatformSettings.HotkeyConfiguration.Paste, handled: true);
+                AssertReadOnlyHotkeyLeavesStateUntouched(tb, Application.Current.PlatformSettings.HotkeyConfiguration.Undo, handled: true);
+                AssertReadOnlyHotkeyLeavesStateUntouched(tb, Application.Current.PlatformSettings.HotkeyConfiguration.Redo, handled: true);
+                AssertReadOnlyHotkeyLeavesStateUntouched(tb, Key.Back, KeyModifiers.None, handled: true);
+                AssertReadOnlyHotkeyLeavesStateUntouched(tb, Key.Back, KeyModifiers.Control, handled: true);
+                AssertReadOnlyHotkeyLeavesStateUntouched(tb, Key.Delete, KeyModifiers.None, handled: true);
+                AssertReadOnlyHotkeyLeavesStateUntouched(tb, Key.Delete, KeyModifiers.Control, handled: true);
+                AssertReadOnlyHotkeyLeavesStateUntouched(tb, Key.Enter, KeyModifiers.None, handled: true);
+                AssertReadOnlyHotkeyLeavesStateUntouched(tb, Key.Tab, KeyModifiers.None, handled: true);
+                AssertReadOnlyHotkeyLeavesStateUntouched(tb, Key.Space, KeyModifiers.None, handled: false);
+
+                Assert.Equal(originalText, tb.Text);
+                Assert.Equal(originalCaretIndex, tb.CaretIndex);
+                Assert.Equal(originalSelectionStart, tb.SelectionStart);
+                Assert.Equal(originalSelectionEnd, tb.SelectionEnd);
+                Assert.Equal(originalCanUndo, tb.CanUndo);
+                Assert.Equal(originalCanRedo, tb.CanRedo);
+                Assert.Equal(0, cutRaised);
+                Assert.Equal(0, pasteRaised);
+            }
+        }
+
         [Fact]
         public void UndoLimit_Count_Is_Respected()
         {
@@ -2247,14 +2358,52 @@ namespace Avalonia.Controls.UnitTests
             }.RegisterInNameScope(scope));
         }
 
-        private static void RaiseKeyEvent(TextBox textBox, Key key, KeyModifiers inputModifiers)
+        private static void AssertReadOnlyHotkeyLeavesStateUntouched(
+            TextBox textBox,
+            IReadOnlyList<KeyGesture> gestures,
+            bool handled)
+        {
+            Assert.NotEmpty(gestures);
+            var gesture = gestures[0];
+            AssertReadOnlyHotkeyLeavesStateUntouched(textBox, gesture.Key, gesture.KeyModifiers, handled);
+        }
+
+        private static void AssertReadOnlyHotkeyLeavesStateUntouched(
+            TextBox textBox,
+            Key key,
+            KeyModifiers inputModifiers,
+            bool handled)
+        {
+            var originalText = textBox.Text;
+            var originalCaretIndex = textBox.CaretIndex;
+            var originalSelectionStart = textBox.SelectionStart;
+            var originalSelectionEnd = textBox.SelectionEnd;
+            var originalCanUndo = textBox.CanUndo;
+            var originalCanRedo = textBox.CanRedo;
+
+            var args = RaiseKeyEvent(textBox, key, inputModifiers);
+
+            Assert.Equal(handled, args.Handled);
+            Assert.Equal(originalText, textBox.Text);
+            Assert.Equal(originalCaretIndex, textBox.CaretIndex);
+            Assert.Equal(originalSelectionStart, textBox.SelectionStart);
+            Assert.Equal(originalSelectionEnd, textBox.SelectionEnd);
+            Assert.Equal(originalCanUndo, textBox.CanUndo);
+            Assert.Equal(originalCanRedo, textBox.CanRedo);
+        }
+
+        private static KeyEventArgs RaiseKeyEvent(TextBox textBox, Key key, KeyModifiers inputModifiers)
         {
-            textBox.RaiseEvent(new KeyEventArgs
+            var args = new KeyEventArgs
             {
                 RoutedEvent = InputElement.KeyDownEvent,
                 KeyModifiers = inputModifiers,
                 Key = key
-            });
+            };
+
+            textBox.RaiseEvent(args);
+
+            return args;
         }
 
         private static void RaiseTextEvent(TextBox textBox, string text)

From b91207fbe271112805d3157b9adac9e6bc0d9e36 Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Wed, 17 Jun 2026 00:00:18 +0800
Subject: [PATCH 021/196] Expose macOS ScrollViewer scroll bars to
 accessibility (#21596)

ScrollViewerAutomationPeer surfaces the template scroll bar peers, which the native peer returns as AXHorizontalScrollBar and AXVerticalScrollBar.
---
 native/Avalonia.Native/src/OSX/automation.mm      | 14 ++++++++++++++
 .../Peers/ScrollViewerAutomationPeer.cs           |  6 ++++++
 src/Avalonia.Controls/ScrollViewer.cs             | 15 +++++++++++++++
 src/Avalonia.Native/AvnAutomationPeer.cs          |  6 ++++++
 src/Avalonia.Native/avn.idl                       |  5 ++++-
 5 files changed, 45 insertions(+), 1 deletion(-)

diff --git a/native/Avalonia.Native/src/OSX/automation.mm b/native/Avalonia.Native/src/OSX/automation.mm
index 0f2ae3768c..84b348e0c2 100644
--- a/native/Avalonia.Native/src/OSX/automation.mm
+++ b/native/Avalonia.Native/src/OSX/automation.mm
@@ -358,6 +358,20 @@
     return [AvnAccessibilityElement acquire:rootPeer];
 }
 
+- (id)accessibilityHorizontalScrollBar
+{
+    if (_peer == nullptr)
+        return nil;
+    return [AvnAccessibilityElement acquire:_peer->ScrollProvider_GetHorizontalScrollBar()];
+}
+
+- (id)accessibilityVerticalScrollBar
+{
+    if (_peer == nullptr)
+        return nil;
+    return [AvnAccessibilityElement acquire:_peer->ScrollProvider_GetVerticalScrollBar()];
+}
+
 - (BOOL)isAccessibilityExpanded
 {
     if (!_peer->IsExpandCollapseProvider())
diff --git a/src/Avalonia.Controls/Automation/Peers/ScrollViewerAutomationPeer.cs b/src/Avalonia.Controls/Automation/Peers/ScrollViewerAutomationPeer.cs
index 38fe21bf1f..9e62cf0c55 100644
--- a/src/Avalonia.Controls/Automation/Peers/ScrollViewerAutomationPeer.cs
+++ b/src/Avalonia.Controls/Automation/Peers/ScrollViewerAutomationPeer.cs
@@ -14,6 +14,12 @@ namespace Avalonia.Automation.Peers
 
         public new ScrollViewer Owner => (ScrollViewer)base.Owner;
 
+        internal AutomationPeer? GetHorizontalScrollBarPeer()
+            => Owner.HorizontalScrollBar is { } scrollBar ? GetOrCreate(scrollBar) : null;
+
+        internal AutomationPeer? GetVerticalScrollBarPeer()
+            => Owner.VerticalScrollBar is { } scrollBar ? GetOrCreate(scrollBar) : null;
+
         public bool HorizontallyScrollable
         {
             get => MathUtilities.GreaterThan(Owner.Extent.Width, Owner.Viewport.Width);
diff --git a/src/Avalonia.Controls/ScrollViewer.cs b/src/Avalonia.Controls/ScrollViewer.cs
index 96580d9d49..57b6664440 100644
--- a/src/Avalonia.Controls/ScrollViewer.cs
+++ b/src/Avalonia.Controls/ScrollViewer.cs
@@ -169,6 +169,18 @@ namespace Avalonia.Controls
         private Size _smallChange = new Size(DefaultSmallChange, DefaultSmallChange);
         private bool _isExpanded;
         private IDisposable? _scrollBarExpandSubscription;
+        private ScrollBar? _horizontalScrollBar;
+        private ScrollBar? _verticalScrollBar;
+
+        /// <summary>
+        /// Gets the horizontal scroll bar from the applied template, if any.
+        /// </summary>
+        internal ScrollBar? HorizontalScrollBar => _horizontalScrollBar;
+
+        /// <summary>
+        /// Gets the vertical scroll bar from the applied template, if any.
+        /// </summary>
+        internal ScrollBar? VerticalScrollBar => _verticalScrollBar;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ScrollViewer"/> class.
@@ -834,6 +846,9 @@ namespace Avalonia.Controls
             var horizontalScrollBar = e.NameScope.Find<ScrollBar>("PART_HorizontalScrollBar");
             var verticalScrollBar = e.NameScope.Find<ScrollBar>("PART_VerticalScrollBar");
 
+            _horizontalScrollBar = horizontalScrollBar;
+            _verticalScrollBar = verticalScrollBar;
+
             var horizontalExpanded = GetExpandedObservable(horizontalScrollBar);
             var verticalExpanded = GetExpandedObservable(verticalScrollBar);
 
diff --git a/src/Avalonia.Native/AvnAutomationPeer.cs b/src/Avalonia.Native/AvnAutomationPeer.cs
index b5e9641050..dae105c8a4 100644
--- a/src/Avalonia.Native/AvnAutomationPeer.cs
+++ b/src/Avalonia.Native/AvnAutomationPeer.cs
@@ -182,6 +182,12 @@ namespace Avalonia.Native
 
         public int IsSelectionItemProvider() => IsProvider<ISelectionItemProvider>();
         public int SelectionItemProvider_IsSelected() => SelectionItemProvider.IsSelected.AsComBool();
+
+        public IAvnAutomationPeer? ScrollProvider_GetHorizontalScrollBar()
+            => _inner is ScrollViewerAutomationPeer scrollViewer ? Wrap(scrollViewer.GetHorizontalScrollBarPeer()) : null;
+
+        public IAvnAutomationPeer? ScrollProvider_GetVerticalScrollBar()
+            => _inner is ScrollViewerAutomationPeer scrollViewer ? Wrap(scrollViewer.GetVerticalScrollBarPeer()) : null;
         
         public int IsToggleProvider() => IsProvider<IToggleProvider>();
         public int ToggleProvider_GetToggleState() => (int)ToggleProvider.ToggleState;
diff --git a/src/Avalonia.Native/avn.idl b/src/Avalonia.Native/avn.idl
index 14d77d17d1..3762126989 100644
--- a/src/Avalonia.Native/avn.idl
+++ b/src/Avalonia.Native/avn.idl
@@ -1317,7 +1317,10 @@ interface IAvnAutomationPeer : IUnknown
      
      bool IsSelectionItemProvider();
      bool SelectionItemProvider_IsSelected();
-     
+
+     IAvnAutomationPeer* ScrollProvider_GetHorizontalScrollBar();
+     IAvnAutomationPeer* ScrollProvider_GetVerticalScrollBar();
+
      bool IsToggleProvider();
      int ToggleProvider_GetToggleState();
      void ToggleProvider_Toggle();

From 376a6e2f0d871ffbaa6b502f7db8315efa76402c Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Wed, 17 Jun 2026 00:32:21 +0800
Subject: [PATCH 022/196] Fix macOS AXLayoutChanged notifications dropped for
 template-internal peers (#21595)

* Post macOS AXLayoutChanged on the changed peer's templated parent

The changed peer is usually a template-internal layout container that AppKit will not deliver notifications for; post on its templated parent (the owning control), falling back to the nearest exposed ancestor when there is none.

* Update with comment
---
 native/Avalonia.Native/src/OSX/automation.mm | 25 +++++++++++++++++++-
 src/Avalonia.Native/AvnAutomationPeer.cs     |  5 ++++
 src/Avalonia.Native/avn.idl                  |  1 +
 3 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/native/Avalonia.Native/src/OSX/automation.mm b/native/Avalonia.Native/src/OSX/automation.mm
index 84b348e0c2..a6ae754c43 100644
--- a/native/Avalonia.Native/src/OSX/automation.mm
+++ b/native/Avalonia.Native/src/OSX/automation.mm
@@ -516,8 +516,31 @@
     if (_children)
         [changed addObjectsFromArray:_children];
 
+	/*
+	For future reference, upon testing with a sample SwiftUI app:
+
+    1) Containers vanish. VStack/HStack don't appear in the accessibility tree at all, 
+      only real elements (Text, Button, List) do, parented to one root AXHostingView.
+
+    2) Changes post on the nearest real element, not the container. 
+       Toggling a child two VStack/HStack levels deep fired AXLayoutChanged on the AXHostingView 
+       (the nearest real element), never on the hidden containers.
+
+    3) Real controls get their own notification. The List (AXOutline) posted AXRowCountChanged on itself.
+
+	Apple never posts a structural notification on a non-accessibility container.
+    It targets the nearest element that's actually in the tree.
+    That's exactly what the code below does (templated parent, else walk to the nearest exposed ancestor).
+	*/
+
+    id target = [AvnAccessibilityElement acquire:_peer->GetTemplatedParent()];
+    if (target == nil)
+        target = self;
+    while ([target isKindOfClass:[AvnAccessibilityElement class]] && ![(AvnAccessibilityElement*)target isAccessibilityElement])
+        target = [(AvnAccessibilityElement*)target accessibilityParent];
+
     NSAccessibilityPostNotificationWithUserInfo(
-        self,
+        target,
         NSAccessibilityLayoutChangedNotification,
         @{ NSAccessibilityUIElementsKey: [changed allObjects]});
 }
diff --git a/src/Avalonia.Native/AvnAutomationPeer.cs b/src/Avalonia.Native/AvnAutomationPeer.cs
index dae105c8a4..659ba78200 100644
--- a/src/Avalonia.Native/AvnAutomationPeer.cs
+++ b/src/Avalonia.Native/AvnAutomationPeer.cs
@@ -6,6 +6,7 @@ using System.Runtime.CompilerServices;
 using Avalonia.Automation;
 using Avalonia.Automation.Peers;
 using Avalonia.Automation.Provider;
+using Avalonia.Controls;
 using Avalonia.Controls.Automation.Peers;
 using Avalonia.Native.Interop;
 
@@ -56,6 +57,10 @@ namespace Avalonia.Native
         public AvnLandmarkType LandmarkType => (AvnLandmarkType?)_inner.GetLandmarkType() ?? AvnLandmarkType.LandmarkNone;
         public int HeadingLevel => _inner.GetHeadingLevel();
         public IAvnAutomationPeer? Parent => Wrap(_inner.GetParent());
+        public IAvnAutomationPeer? TemplatedParent =>
+            _inner is ControlAutomationPeer { Owner.TemplatedParent: Control templatedParent } ? 
+                Wrap(ControlAutomationPeer.CreatePeerForElement(templatedParent))
+                : null;
         public IAvnAutomationPeer? VisualRoot => Wrap(_inner.GetAutomationRoot());
         public AvnLiveSetting LiveSetting => (AvnLiveSetting)_inner.GetLiveSetting();
 
diff --git a/src/Avalonia.Native/avn.idl b/src/Avalonia.Native/avn.idl
index 3762126989..1b9ee376c6 100644
--- a/src/Avalonia.Native/avn.idl
+++ b/src/Avalonia.Native/avn.idl
@@ -1274,6 +1274,7 @@ interface IAvnAutomationPeer : IUnknown
      IAvnAutomationPeer* GetLabeledBy();
      IAvnString* GetName();
      IAvnAutomationPeer* GetParent();
+     IAvnAutomationPeer* GetTemplatedParent();
      IAvnAutomationPeer* GetVisualRoot();
      bool HasKeyboardFocus();
      bool IsContentElement();

From 264612785157ac54b7e7fb65de33fd0ebbd03440 Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Wed, 17 Jun 2026 02:03:31 +0800
Subject: [PATCH 023/196] Report read-only value state to macOS accessibility
 (#21597)

AvnAccessibilityElement answers accessibilityIsAttributeSettable for the value attribute using IValueProvider.IsReadOnly, so AX clients see a read-only TextBox as not settable.
---
 native/Avalonia.Native/src/OSX/automation.mm | 14 ++++++++++++++
 src/Avalonia.Native/AvnAutomationPeer.cs     |  1 +
 src/Avalonia.Native/avn.idl                  |  1 +
 3 files changed, 16 insertions(+)

diff --git a/native/Avalonia.Native/src/OSX/automation.mm b/native/Avalonia.Native/src/OSX/automation.mm
index a6ae754c43..7897a76973 100644
--- a/native/Avalonia.Native/src/OSX/automation.mm
+++ b/native/Avalonia.Native/src/OSX/automation.mm
@@ -274,6 +274,20 @@
     }
 }
 
+- (BOOL)accessibilityIsAttributeSettable:(NSAccessibilityAttributeName)attribute
+{
+    if ([attribute isEqualToString:NSAccessibilityValueAttribute])
+    {
+        if (_peer->IsValueProvider())
+            return !_peer->ValueProvider_IsReadOnly();
+        if (_peer->IsRangeValueProvider())
+            return YES;
+        return NO;
+    }
+
+    return [super accessibilityIsAttributeSettable:attribute];
+}
+
 - (id)accessibilityMinValue
 {
     if (_peer->IsRangeValueProvider())
diff --git a/src/Avalonia.Native/AvnAutomationPeer.cs b/src/Avalonia.Native/AvnAutomationPeer.cs
index 659ba78200..4a679e3ed7 100644
--- a/src/Avalonia.Native/AvnAutomationPeer.cs
+++ b/src/Avalonia.Native/AvnAutomationPeer.cs
@@ -201,6 +201,7 @@ namespace Avalonia.Native
         public int IsValueProvider() => IsProvider<IValueProvider>();
         public IAvnString? ValueProvider_GetValue() => ValueProvider.Value.ToAvnString();
         public void ValueProvider_SetValue(string value) => ValueProvider.SetValue(value);
+        public int ValueProvider_IsReadOnly() => ValueProvider.IsReadOnly.AsComBool();
 
         [return: NotNullIfNotNull("peer")]
         public static AvnAutomationPeer? Wrap(AutomationPeer? peer)
diff --git a/src/Avalonia.Native/avn.idl b/src/Avalonia.Native/avn.idl
index 1b9ee376c6..a1b57f7d14 100644
--- a/src/Avalonia.Native/avn.idl
+++ b/src/Avalonia.Native/avn.idl
@@ -1329,6 +1329,7 @@ interface IAvnAutomationPeer : IUnknown
      bool IsValueProvider();
      IAvnString* ValueProvider_GetValue();
      void ValueProvider_SetValue([const] char* value);
+     bool ValueProvider_IsReadOnly();
 
      IAvnString* GetHelpText();
      IAvnString* GetPlaceholderText();

From e08c7f8149e45abac786637e44523e4a25fb139b Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Wed, 17 Jun 2026 03:47:25 +0800
Subject: [PATCH 024/196] Expose tree item selection to macOS accessibility
 (#21598)

TreeViewItemAutomationPeer implements ISelectionItemProvider, and AvnAccessibilityElement maps setAccessibilitySelected to it, so AX clients can select a TreeViewItem.
---
 native/Avalonia.Native/src/OSX/automation.mm  | 10 ++++
 .../Peers/TreeViewItemAutomationPeer.cs       | 49 ++++++++++++++++++-
 src/Avalonia.Native/AvnAutomationPeer.cs      |  1 +
 src/Avalonia.Native/avn.idl                   |  1 +
 4 files changed, 59 insertions(+), 2 deletions(-)

diff --git a/native/Avalonia.Native/src/OSX/automation.mm b/native/Avalonia.Native/src/OSX/automation.mm
index 7897a76973..f355634de4 100644
--- a/native/Avalonia.Native/src/OSX/automation.mm
+++ b/native/Avalonia.Native/src/OSX/automation.mm
@@ -474,6 +474,12 @@
     return NO;
 }
 
+- (void)setAccessibilitySelected:(BOOL)accessibilitySelected
+{
+    if (accessibilitySelected && _peer->IsSelectionItemProvider())
+        _peer->SelectionItemProvider_Select();
+}
+
 - (BOOL)isAccessibilitySelectorAllowed:(SEL)selector
 {
     if (selector == @selector(setAccessibilityValue:))
@@ -492,6 +498,10 @@
     {
         return _peer->IsInvokeProvider() || _peer->IsExpandCollapseProvider() || _peer->IsToggleProvider();
     }
+    else if (selector == @selector(setAccessibilitySelected:))
+    {
+        return _peer->IsSelectionItemProvider();
+    }
     else if (selector == @selector(accessibilityPerformIncrement) ||
              selector == @selector(accessibilityPerformDecrement) ||
              selector == @selector(accessibilityMinValue) ||
diff --git a/src/Avalonia.Controls/Automation/Peers/TreeViewItemAutomationPeer.cs b/src/Avalonia.Controls/Automation/Peers/TreeViewItemAutomationPeer.cs
index 9629a75267..74bbf53ef9 100644
--- a/src/Avalonia.Controls/Automation/Peers/TreeViewItemAutomationPeer.cs
+++ b/src/Avalonia.Controls/Automation/Peers/TreeViewItemAutomationPeer.cs
@@ -1,14 +1,59 @@
+using Avalonia.Automation.Provider;
 using Avalonia.Controls;
 
 namespace Avalonia.Automation.Peers;
 
-public class TreeViewItemAutomationPeer : ItemsControlAutomationPeer
+public class TreeViewItemAutomationPeer : ItemsControlAutomationPeer,
+    ISelectionItemProvider
 {
     public TreeViewItemAutomationPeer(TreeViewItem owner)
         : base(owner)
     {
     }
-   
+
+    public bool IsSelected => Owner.GetValue(TreeViewItem.IsSelectedProperty);
+
+    public ISelectionProvider? SelectionContainer
+    {
+        get
+        {
+            if (Owner is TreeViewItem { TreeViewOwner: { } treeView })
+            {
+                var parentPeer = GetOrCreate(treeView);
+                return parentPeer.GetProvider<ISelectionProvider>();
+            }
+
+            return null;
+        }
+    }
+
+    public void Select()
+    {
+        EnsureEnabled();
+
+        if (Owner is TreeViewItem item)
+        {
+            item.TreeViewOwner?.SelectedItems.Clear();
+            item.IsSelected = true;
+        }
+    }
+
+    void ISelectionItemProvider.AddToSelection()
+    {
+        EnsureEnabled();
+
+        if (Owner is TreeViewItem item)
+            item.IsSelected = true;
+    }
+
+    void ISelectionItemProvider.RemoveFromSelection()
+    {
+        EnsureEnabled();
+
+        if (Owner is TreeViewItem item)
+            item.IsSelected = false;
+    }
+
     protected override AutomationControlType GetAutomationControlTypeCore()
     {
         return AutomationControlType.TreeItem;
diff --git a/src/Avalonia.Native/AvnAutomationPeer.cs b/src/Avalonia.Native/AvnAutomationPeer.cs
index 4a679e3ed7..b448d5cb1a 100644
--- a/src/Avalonia.Native/AvnAutomationPeer.cs
+++ b/src/Avalonia.Native/AvnAutomationPeer.cs
@@ -187,6 +187,7 @@ namespace Avalonia.Native
 
         public int IsSelectionItemProvider() => IsProvider<ISelectionItemProvider>();
         public int SelectionItemProvider_IsSelected() => SelectionItemProvider.IsSelected.AsComBool();
+        public void SelectionItemProvider_Select() => SelectionItemProvider.Select();
 
         public IAvnAutomationPeer? ScrollProvider_GetHorizontalScrollBar()
             => _inner is ScrollViewerAutomationPeer scrollViewer ? Wrap(scrollViewer.GetHorizontalScrollBarPeer()) : null;
diff --git a/src/Avalonia.Native/avn.idl b/src/Avalonia.Native/avn.idl
index a1b57f7d14..5b1b97fa37 100644
--- a/src/Avalonia.Native/avn.idl
+++ b/src/Avalonia.Native/avn.idl
@@ -1318,6 +1318,7 @@ interface IAvnAutomationPeer : IUnknown
      
      bool IsSelectionItemProvider();
      bool SelectionItemProvider_IsSelected();
+     void SelectionItemProvider_Select();
 
      IAvnAutomationPeer* ScrollProvider_GetHorizontalScrollBar();
      IAvnAutomationPeer* ScrollProvider_GetVerticalScrollBar();

From 12cefeb74a965174708284481008e0edc25070dd Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Wed, 17 Jun 2026 10:28:09 +0500
Subject: [PATCH 025/196] Wayland protocol support (#21448)

---
 .github/copilot-instructions.md               |    1 +
 Avalonia.Desktop.slnf                         |    2 +
 Avalonia.slnx                                 |    2 +
 Directory.Packages.props                      |    8 +-
 api/Avalonia.nupkg.xml                        |   12 +
 .../ControlCatalog.Desktop.csproj             |    1 +
 src/Avalonia.Base/Avalonia.Base.csproj        |    1 +
 .../Avalonia.Controls.csproj                  |    1 +
 src/Avalonia.Dialogs/Avalonia.Dialogs.csproj  |    1 +
 .../Avalonia.FreeDesktop.csproj               |    1 +
 src/Avalonia.OpenGL/Egl/EglConsts.cs          |   35 +-
 src/Avalonia.OpenGL/Egl/EglDisplay.cs         |    2 +-
 .../Egl/EglGlPlatformImageSurfaceBase.cs      |  196 ++++
 .../Egl/EglGlPlatformSurface.cs               |    2 +-
 .../Egl/EglGlPlatformSurfaceBase.cs           |   13 +-
 src/Avalonia.OpenGL/Egl/EglImage.cs           |   46 +
 src/Avalonia.OpenGL/Egl/EglInterface.cs       |   17 +
 src/Avalonia.OpenGL/GlConsts.cs               |    6 +-
 src/Avalonia.OpenGL/GlInterface.cs            |    5 +
 src/Avalonia.Wayland/Avalonia.Wayland.csproj  |   29 +
 .../AvaloniaWaylandException.cs               |  111 ++
 .../AvaloniaWaylandPlatformExtensions.cs      |   28 +
 .../Clipboard/WaylandClipboardImpl.cs         |  129 ++
 .../Clipboard/WaylandDataTransfer.cs          |  265 +++++
 .../Clipboard/WaylandDragSource.cs            |   28 +
 .../Clipboard/WaylandMimeMapper.cs            |   68 ++
 .../Clipboard/WaylandOutgoingTransfer.cs      |  260 +++++
 .../IWaylandXdgTopLevelExport.cs              |   19 +
 src/Avalonia.Wayland/PopupImpl.Sink.cs        |   86 ++
 src/Avalonia.Wayland/PopupImpl.cs             |  118 ++
 src/Avalonia.Wayland/README.md                |  100 ++
 .../Screens/IWaylandOutputsSink.cs            |   21 +
 .../Screens/SnapshotScreensImpl.cs            |  105 ++
 .../Screens/WaylandOutputSnapshot.cs          |   37 +
 .../Interop/DrmGbmUnsafeNativeMethods.cs      |  118 ++
 .../Server/Interop/Pipe2Stream.cs             |   32 +
 .../Server/Interop/UnsafeNativeMethods.cs     |  110 ++
 .../Server/Interop/WakeupFd.cs                |   70 ++
 .../Server/Interop/WaylandConnection.cs       |  177 +++
 .../Server/Interop/WaylandEglNativeMethods.cs |   29 +
 .../Server/Interop/XkbCommonNativeMethods.cs  |  110 ++
 .../Server/Persistent/DecorationMode.cs       |   15 +
 .../Server/Persistent/IPersistentObject.cs    |   10 +
 .../Server/Persistent/IWSurface.cs            |   61 +
 .../Server/Persistent/IWSurfaceEventSink.cs   |  105 ++
 .../Server/Persistent/IWXdgTopLevel.cs        |   90 ++
 .../Server/Persistent/IWaylandCursor.cs       |   19 +
 .../Server/Persistent/WSurface.cs             | 1033 +++++++++++++++++
 .../Server/Persistent/WaylandBitmapCursor.cs  |   96 ++
 .../Server/Persistent/WaylandCursor.cs        |   45 +
 .../Persistent/WaylandInputEventCookie.cs     |   71 ++
 .../Server/Persistent/XdgConfigureBatch.cs    |   64 +
 .../Persistent/XdgPopupConfigureBatch.cs      |   15 +
 .../Persistent/XdgPopupPositionerParams.cs    |   31 +
 src/Avalonia.Wayland/Server/ServerSignaler.cs |   31 +
 .../Transient/Clipboard/WaylandDataDevice.cs  |  363 ++++++
 .../Transient/Clipboard/WaylandDataOffer.cs   |  131 +++
 .../Transient/Clipboard/WaylandDataSource.cs  |  113 ++
 .../Transient/Clipboard/WaylandOfferCookie.cs |   86 ++
 .../Transient/IWaylandTextInputV3Events.cs    |   50 +
 .../Rendering/IWaylandFramebufferSurface.cs   |   44 +
 .../Rendering/WaylandDmabufFeedback.cs        |  131 +++
 .../Transient/Rendering/WaylandEglDisplay.cs  |   26 +
 .../WaylandEglDmaBufPlatformGraphics.cs       |  231 ++++
 .../Rendering/WaylandEglDmaBufSurface.cs      |  371 ++++++
 .../WaylandEglWsiPlatformGraphics.cs          |   73 ++
 .../Rendering/WaylandEglWsiSurface.cs         |  135 +++
 .../Transient/Rendering/WaylandFramebuffer.cs |  113 ++
 .../Server/Transient/WaylandCursorManager.cs  |  120 ++
 .../Server/Transient/WaylandGlobals.cs        |  197 ++++
 .../WaylandInputDispatcher.Keyboard.cs        |  188 +++
 .../Transient/WaylandInputDispatcher.cs       |  636 ++++++++++
 .../Server/Transient/WaylandOutputsTracker.cs |  259 +++++
 .../Server/Transient/WaylandTextInputV3.cs    |  570 +++++++++
 .../Server/Transient/XdgToplevelExport.cs     |   66 ++
 .../Server/WaylandDispatchPriority.cs         |   19 +
 .../Server/WaylandMarshallers.cs              |   17 +
 .../Server/WaylandPlatformGraphics.cs         |   54 +
 .../Server/WaylandWorker.RenderTimer.cs       |  147 +++
 src/Avalonia.Wayland/Server/WaylandWorker.cs  |  316 +++++
 .../Server/WaylandWorkerClient.cs             |  123 ++
 .../TextInputOptionsConverter.cs              |   79 ++
 .../WaylandConversionExtensions.cs            |  103 ++
 src/Avalonia.Wayland/WaylandCursorFactory.cs  |   52 +
 src/Avalonia.Wayland/WaylandPlatform.cs       |   62 +
 .../WaylandPlatformOptions.cs                 |   75 ++
 .../WaylandSurfaceCreateResult.cs             |   31 +
 src/Avalonia.Wayland/WaylandTextUtils.cs      |  107 ++
 .../WaylandTopLevelFactory.cs                 |   53 +
 src/Avalonia.Wayland/WindowImpl.Sink.cs       |  164 +++
 src/Avalonia.Wayland/WindowImpl.TextInput.cs  |  233 ++++
 src/Avalonia.Wayland/WindowImpl.cs            |  396 +++++++
 .../WindowImplBase.DragDrop.cs                |  190 +++
 .../WindowImplBase.Keyboard.cs                |  144 +++
 .../WindowImplBase.Pointer.cs                 |   86 ++
 src/Avalonia.Wayland/WindowImplBase.cs        |  262 +++++
 src/Avalonia.Wayland/XkbCommonKeymap.cs       |  126 ++
 src/Avalonia.Wayland/XkbComposeState.cs       |   81 ++
 src/Avalonia.Wayland/XkbComposeTable.cs       |   42 +
 src/Avalonia.Wayland/XkbContext.cs            |   28 +
 src/Avalonia.Wayland/XkbKeyTransform.cs       |  580 +++++++++
 src/Shared/SourceGeneratorAttributes.cs       |   13 +
 .../CrossThreadProxyGenerator.cs              |  116 +-
 .../DefinitelyNotARecordGenerator.cs          |  126 ++
 .../CrossThreadProxyGeneratorTests.cs         |   85 ++
 .../Avalonia.Wayland.UnitTests.csproj         |   16 +
 .../TextInputOptionsConverterTests.cs         |   83 ++
 .../WaylandTextUtilsTests.cs                  |   98 ++
 108 files changed, 12064 insertions(+), 34 deletions(-)
 create mode 100644 src/Avalonia.OpenGL/Egl/EglGlPlatformImageSurfaceBase.cs
 create mode 100644 src/Avalonia.OpenGL/Egl/EglImage.cs
 create mode 100644 src/Avalonia.Wayland/Avalonia.Wayland.csproj
 create mode 100644 src/Avalonia.Wayland/AvaloniaWaylandException.cs
 create mode 100644 src/Avalonia.Wayland/AvaloniaWaylandPlatformExtensions.cs
 create mode 100644 src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs
 create mode 100644 src/Avalonia.Wayland/Clipboard/WaylandDataTransfer.cs
 create mode 100644 src/Avalonia.Wayland/Clipboard/WaylandDragSource.cs
 create mode 100644 src/Avalonia.Wayland/Clipboard/WaylandMimeMapper.cs
 create mode 100644 src/Avalonia.Wayland/Clipboard/WaylandOutgoingTransfer.cs
 create mode 100644 src/Avalonia.Wayland/IWaylandXdgTopLevelExport.cs
 create mode 100644 src/Avalonia.Wayland/PopupImpl.Sink.cs
 create mode 100644 src/Avalonia.Wayland/PopupImpl.cs
 create mode 100644 src/Avalonia.Wayland/README.md
 create mode 100644 src/Avalonia.Wayland/Screens/IWaylandOutputsSink.cs
 create mode 100644 src/Avalonia.Wayland/Screens/SnapshotScreensImpl.cs
 create mode 100644 src/Avalonia.Wayland/Screens/WaylandOutputSnapshot.cs
 create mode 100644 src/Avalonia.Wayland/Server/Interop/DrmGbmUnsafeNativeMethods.cs
 create mode 100644 src/Avalonia.Wayland/Server/Interop/Pipe2Stream.cs
 create mode 100644 src/Avalonia.Wayland/Server/Interop/UnsafeNativeMethods.cs
 create mode 100644 src/Avalonia.Wayland/Server/Interop/WakeupFd.cs
 create mode 100644 src/Avalonia.Wayland/Server/Interop/WaylandConnection.cs
 create mode 100644 src/Avalonia.Wayland/Server/Interop/WaylandEglNativeMethods.cs
 create mode 100644 src/Avalonia.Wayland/Server/Interop/XkbCommonNativeMethods.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/DecorationMode.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/IPersistentObject.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/IWSurface.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/IWSurfaceEventSink.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/IWXdgTopLevel.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/IWaylandCursor.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/WSurface.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/WaylandBitmapCursor.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/WaylandCursor.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/WaylandInputEventCookie.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/XdgConfigureBatch.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/XdgPopupConfigureBatch.cs
 create mode 100644 src/Avalonia.Wayland/Server/Persistent/XdgPopupPositionerParams.cs
 create mode 100644 src/Avalonia.Wayland/Server/ServerSignaler.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataDevice.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataOffer.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataSource.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandOfferCookie.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/IWaylandTextInputV3Events.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Rendering/IWaylandFramebufferSurface.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Rendering/WaylandDmabufFeedback.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDisplay.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufPlatformGraphics.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufSurface.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiPlatformGraphics.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/WaylandCursorManager.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/WaylandGlobals.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/WaylandInputDispatcher.Keyboard.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/WaylandInputDispatcher.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/WaylandOutputsTracker.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/WaylandTextInputV3.cs
 create mode 100644 src/Avalonia.Wayland/Server/Transient/XdgToplevelExport.cs
 create mode 100644 src/Avalonia.Wayland/Server/WaylandDispatchPriority.cs
 create mode 100644 src/Avalonia.Wayland/Server/WaylandMarshallers.cs
 create mode 100644 src/Avalonia.Wayland/Server/WaylandPlatformGraphics.cs
 create mode 100644 src/Avalonia.Wayland/Server/WaylandWorker.RenderTimer.cs
 create mode 100644 src/Avalonia.Wayland/Server/WaylandWorker.cs
 create mode 100644 src/Avalonia.Wayland/Server/WaylandWorkerClient.cs
 create mode 100644 src/Avalonia.Wayland/TextInputOptionsConverter.cs
 create mode 100644 src/Avalonia.Wayland/WaylandConversionExtensions.cs
 create mode 100644 src/Avalonia.Wayland/WaylandCursorFactory.cs
 create mode 100644 src/Avalonia.Wayland/WaylandPlatform.cs
 create mode 100644 src/Avalonia.Wayland/WaylandPlatformOptions.cs
 create mode 100644 src/Avalonia.Wayland/WaylandSurfaceCreateResult.cs
 create mode 100644 src/Avalonia.Wayland/WaylandTextUtils.cs
 create mode 100644 src/Avalonia.Wayland/WaylandTopLevelFactory.cs
 create mode 100644 src/Avalonia.Wayland/WindowImpl.Sink.cs
 create mode 100644 src/Avalonia.Wayland/WindowImpl.TextInput.cs
 create mode 100644 src/Avalonia.Wayland/WindowImpl.cs
 create mode 100644 src/Avalonia.Wayland/WindowImplBase.DragDrop.cs
 create mode 100644 src/Avalonia.Wayland/WindowImplBase.Keyboard.cs
 create mode 100644 src/Avalonia.Wayland/WindowImplBase.Pointer.cs
 create mode 100644 src/Avalonia.Wayland/WindowImplBase.cs
 create mode 100644 src/Avalonia.Wayland/XkbCommonKeymap.cs
 create mode 100644 src/Avalonia.Wayland/XkbComposeState.cs
 create mode 100644 src/Avalonia.Wayland/XkbComposeTable.cs
 create mode 100644 src/Avalonia.Wayland/XkbContext.cs
 create mode 100644 src/Avalonia.Wayland/XkbKeyTransform.cs
 create mode 100644 src/tools/DevGenerators/DefinitelyNotARecordGenerator.cs
 create mode 100644 tests/Avalonia.Wayland.UnitTests/Avalonia.Wayland.UnitTests.csproj
 create mode 100644 tests/Avalonia.Wayland.UnitTests/TextInputOptionsConverterTests.cs
 create mode 100644 tests/Avalonia.Wayland.UnitTests/WaylandTextUtilsTests.cs

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 43de3ddefd..228145f620 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -1,3 +1,4 @@
 
 When running code review, please refer to the following documents if they are relevant to the changed parts of the codebase:
 - `native/Avalonia.Native/**` -> `native/Avalonia.Native/README.md`
+- `src/Avalonia.Wayland/**` -> `src/Avalonia.Wayland/README.md`
diff --git a/Avalonia.Desktop.slnf b/Avalonia.Desktop.slnf
index 3edf421eb4..2d66481319 100644
--- a/Avalonia.Desktop.slnf
+++ b/Avalonia.Desktop.slnf
@@ -34,6 +34,7 @@
       "src\\Avalonia.Themes.Fluent\\Avalonia.Themes.Fluent.csproj",
       "src\\Avalonia.Themes.Simple\\Avalonia.Themes.Simple.csproj",
       "src\\Avalonia.Vulkan\\Avalonia.Vulkan.csproj",
+      "src\\Avalonia.Wayland\\Avalonia.Wayland.csproj",
       "src\\Avalonia.X11\\Avalonia.X11.csproj",
       "src\\HarfBuzz\\Avalonia.HarfBuzz\\Avalonia.HarfBuzz.csproj",
       "src\\Headless\\Avalonia.Headless.Vnc\\Avalonia.Headless.Vnc.csproj",
@@ -72,6 +73,7 @@
       "tests\\Avalonia.Skia.RenderTests\\Avalonia.Skia.RenderTests.csproj",
       "tests\\Avalonia.Skia.UnitTests\\Avalonia.Skia.UnitTests.csproj",
       "tests\\Avalonia.UnitTests\\Avalonia.UnitTests.csproj",
+      "tests\\Avalonia.Wayland.UnitTests\\Avalonia.Wayland.UnitTests.csproj",
       "tests\\TestFiles\\BuildTasks\\PInvoke\\PInvoke.csproj"
     ]
   }
diff --git a/Avalonia.slnx b/Avalonia.slnx
index dba476ed4a..d902fabe98 100644
--- a/Avalonia.slnx
+++ b/Avalonia.slnx
@@ -22,6 +22,7 @@
     <Project Path="src/Avalonia.FreeDesktop/Avalonia.FreeDesktop.csproj" />
     <Project Path="src/Avalonia.X11/Avalonia.X11.csproj" />
     <Project Path="src/Linux/Avalonia.LinuxFramebuffer/Avalonia.LinuxFramebuffer.csproj" />
+    <Project Path="src/Avalonia.Wayland/Avalonia.Wayland.csproj" />
   </Folder>
   <Folder Name="/Markup/">
     <Project Path="src/Markup/Avalonia.Markup.Xaml.Loader/Avalonia.Markup.Xaml.Loader.csproj" />
@@ -156,6 +157,7 @@
     <Project Path="tests/Avalonia.Skia.RenderTests/Avalonia.Skia.RenderTests.csproj" />
     <Project Path="tests/Avalonia.Skia.UnitTests/Avalonia.Skia.UnitTests.csproj" />
     <Project Path="tests/Avalonia.UnitTests/Avalonia.UnitTests.csproj" />
+    <Project Path="tests/Avalonia.Wayland.UnitTests/Avalonia.Wayland.UnitTests.csproj" />
   </Folder>
   <Folder Name="/Tests/TestFiles/" />
   <Folder Name="/Tests/TestFiles/BuildTasks/">
diff --git a/Directory.Packages.props b/Directory.Packages.props
index cac3db9cc9..176c4b731c 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -23,9 +23,9 @@
     <PackageVersion Include="Microsoft.Build.Framework" Version="18.0.2" />
     <PackageVersion Include="Microsoft.Build.Utilities.Core" Version="15.1.548" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.5.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.VisualBasic" Version="4.5.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="4.5.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.VisualBasic" Version="4.14.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="4.14.0" />
     <PackageVersion Include="Microsoft.CSharp" Version="4.5.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="Microsoft.Reactive.Testing" Version="6.1.0" />
@@ -42,6 +42,8 @@
     <PackageVersion Include="Numerge" Version="1.0.0" />
     <PackageVersion Include="NUnit" Version="4.5.1" />
     <PackageVersion Include="NUnit3TestAdapter" Version="6.2.0" />
+    <PackageVersion Include="NWayland" Version="0.11.0" />
+    <PackageVersion Include="NWayland.Server" Version="0.11.0" />
     <PackageVersion Include="Quamotion.RemoteViewing" Version="1.1.211" />
     <PackageVersion Include="SharpCompress" Version="0.48.0" />
     <PackageVersion Include="Silk.NET.Direct3D.Compilers" Version="2.22.0" />
diff --git a/api/Avalonia.nupkg.xml b/api/Avalonia.nupkg.xml
index fd711d37c0..aaf84068f5 100644
--- a/api/Avalonia.nupkg.xml
+++ b/api/Avalonia.nupkg.xml
@@ -25,6 +25,12 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.OpenGL.Egl.EglPlatformSurfaceRenderTargetBase.BeginDraw(Avalonia.OpenGL.Egl.EglSurface,Avalonia.PixelSize,System.Double,System.Action,System.Boolean)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.OpenGL.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.OpenGL.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:Avalonia.Input.PointerEventArgs.#ctor(Avalonia.Interactivity.RoutedEvent,System.Object,Avalonia.Input.IPointer,Avalonia.Visual,Avalonia.Point,System.UInt64,Avalonia.Input.PointerPointProperties,Avalonia.Input.KeyModifiers,System.Lazy{System.Collections.Generic.IReadOnlyList{Avalonia.Input.Raw.RawPointerPoint}})</Target>
@@ -49,4 +55,10 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.OpenGL.Egl.EglPlatformSurfaceRenderTargetBase.BeginDraw(Avalonia.OpenGL.Egl.EglSurface,Avalonia.PixelSize,System.Double,System.Action,System.Boolean)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Right>
+  </Suppression>
 </Suppressions>
\ No newline at end of file
diff --git a/samples/ControlCatalog.Desktop/ControlCatalog.Desktop.csproj b/samples/ControlCatalog.Desktop/ControlCatalog.Desktop.csproj
index 22a091449f..19fb2a0891 100644
--- a/samples/ControlCatalog.Desktop/ControlCatalog.Desktop.csproj
+++ b/samples/ControlCatalog.Desktop/ControlCatalog.Desktop.csproj
@@ -21,6 +21,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\..\src\Avalonia.Wayland\Avalonia.Wayland.csproj" />
     <ProjectReference Include="..\..\src\Headless\Avalonia.Headless.Vnc\Avalonia.Headless.Vnc.csproj" />
     <ProjectReference Include="..\..\src\Avalonia.Dialogs\Avalonia.Dialogs.csproj" />
     <ProjectReference Include="..\..\src\Linux\Avalonia.LinuxFramebuffer\Avalonia.LinuxFramebuffer.csproj" />
diff --git a/src/Avalonia.Base/Avalonia.Base.csproj b/src/Avalonia.Base/Avalonia.Base.csproj
index 69f5dd54fa..1d3929001b 100644
--- a/src/Avalonia.Base/Avalonia.Base.csproj
+++ b/src/Avalonia.Base/Avalonia.Base.csproj
@@ -40,6 +40,7 @@
     <InternalsVisibleTo Include="Avalonia.Native, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.FreeDesktop, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.X11, PublicKey=$(AvaloniaPublicKey)" />
+    <InternalsVisibleTo Include="Avalonia.Wayland, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.Browser, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.Controls.UnitTests, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.DesignerSupport, PublicKey=$(AvaloniaPublicKey)" />
diff --git a/src/Avalonia.Controls/Avalonia.Controls.csproj b/src/Avalonia.Controls/Avalonia.Controls.csproj
index 6e3f40892a..53f1df7358 100644
--- a/src/Avalonia.Controls/Avalonia.Controls.csproj
+++ b/src/Avalonia.Controls/Avalonia.Controls.csproj
@@ -26,6 +26,7 @@
     <InternalsVisibleTo Include="Avalonia.Win32, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.Win32.Automation, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.X11, PublicKey=$(AvaloniaPublicKey)" />
+    <InternalsVisibleTo Include="Avalonia.Wayland, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.LinuxFramebuffer, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.DesignerSupport.Remote, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.Browser, PublicKey=$(AvaloniaPublicKey)" />
diff --git a/src/Avalonia.Dialogs/Avalonia.Dialogs.csproj b/src/Avalonia.Dialogs/Avalonia.Dialogs.csproj
index 9f98c3a939..035b488cdd 100644
--- a/src/Avalonia.Dialogs/Avalonia.Dialogs.csproj
+++ b/src/Avalonia.Dialogs/Avalonia.Dialogs.csproj
@@ -18,6 +18,7 @@
     <!-- For managed dialogs dev testing -->
     <InternalsVisibleTo Include="ControlCatalog, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.X11, PublicKey=$(AvaloniaPublicKey)" />
+    <InternalsVisibleTo Include="Avalonia.Wayland, PublicKey=$(AvaloniaPublicKey)" />
   </ItemGroup>
 
   <Import Project="..\..\build\DevAnalyzers.props" />
diff --git a/src/Avalonia.FreeDesktop/Avalonia.FreeDesktop.csproj b/src/Avalonia.FreeDesktop/Avalonia.FreeDesktop.csproj
index 7f4416e4aa..f682d9245d 100644
--- a/src/Avalonia.FreeDesktop/Avalonia.FreeDesktop.csproj
+++ b/src/Avalonia.FreeDesktop/Avalonia.FreeDesktop.csproj
@@ -24,6 +24,7 @@
 
   <ItemGroup Label="InternalsVisibleTo">
     <InternalsVisibleTo Include="Avalonia.X11, PublicKey=$(AvaloniaPublicKey)" />
+    <InternalsVisibleTo Include="Avalonia.Wayland, PublicKey=$(AvaloniaPublicKey)" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/Avalonia.OpenGL/Egl/EglConsts.cs b/src/Avalonia.OpenGL/Egl/EglConsts.cs
index 295acef44b..a1969c7805 100644
--- a/src/Avalonia.OpenGL/Egl/EglConsts.cs
+++ b/src/Avalonia.OpenGL/Egl/EglConsts.cs
@@ -170,9 +170,40 @@ namespace Avalonia.OpenGL.Egl
 //        public const int  EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x30B6;
 //        public const int  EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x30B7;
 //        public const int  EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x30B8;
-//        public const int  EGL_IMAGE_PRESERVED = 0x30D2;
-//        public const int  EGL_NO_IMAGE = 0;
+        public const int  EGL_IMAGE_PRESERVED = 0x30D2;
+        public const int  EGL_NO_IMAGE = 0;
 
+        // EGL_KHR_image_base
+        public const int  EGL_IMAGE_PRESERVED_KHR = 0x30D2;
+
+        // EGL_EXT_image_dma_buf_import
+        public const int  EGL_LINUX_DMA_BUF_EXT = 0x3270;
+        public const int  EGL_LINUX_DRM_FOURCC_EXT = 0x3271;
+        public const int  EGL_DMA_BUF_PLANE0_FD_EXT = 0x3272;
+        public const int  EGL_DMA_BUF_PLANE0_OFFSET_EXT = 0x3273;
+        public const int  EGL_DMA_BUF_PLANE0_PITCH_EXT = 0x3274;
+        public const int  EGL_DMA_BUF_PLANE1_FD_EXT = 0x3275;
+        public const int  EGL_DMA_BUF_PLANE1_OFFSET_EXT = 0x3276;
+        public const int  EGL_DMA_BUF_PLANE1_PITCH_EXT = 0x3277;
+        public const int  EGL_DMA_BUF_PLANE2_FD_EXT = 0x3278;
+        public const int  EGL_DMA_BUF_PLANE2_OFFSET_EXT = 0x3279;
+        public const int  EGL_DMA_BUF_PLANE2_PITCH_EXT = 0x327A;
+
+        // EGL_EXT_image_dma_buf_import_modifiers
+        public const int  EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT = 0x3443;
+        public const int  EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT = 0x3444;
+        public const int  EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT = 0x3445;
+        public const int  EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT = 0x3446;
+        public const int  EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT = 0x3447;
+        public const int  EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT = 0x3448;
+        public const int  EGL_DMA_BUF_PLANE3_FD_EXT = 0x3440;
+        public const int  EGL_DMA_BUF_PLANE3_OFFSET_EXT = 0x3441;
+        public const int  EGL_DMA_BUF_PLANE3_PITCH_EXT = 0x3442;
+        public const int  EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT = 0x3449;
+        public const int  EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT = 0x344A;
+
+        // EGL_KHR_platform_gbm / EGL_MESA_platform_gbm
+        public const int  EGL_PLATFORM_GBM_KHR = 0x31D7;
 
         public const int  EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE = 0x3207;
         public const int  EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE = 0x3208;
diff --git a/src/Avalonia.OpenGL/Egl/EglDisplay.cs b/src/Avalonia.OpenGL/Egl/EglDisplay.cs
index 1aefc20850..1b0761eeb4 100644
--- a/src/Avalonia.OpenGL/Egl/EglDisplay.cs
+++ b/src/Avalonia.OpenGL/Egl/EglDisplay.cs
@@ -185,7 +185,7 @@ namespace Avalonia.OpenGL.Egl
         {
             lock (_lock)
             {
-                foreach(var ctx in _contexts)
+                foreach(var ctx in _contexts.ToList())
                     ctx.Dispose();
                 _contexts.Clear();
                 if (_display != IntPtr.Zero)
diff --git a/src/Avalonia.OpenGL/Egl/EglGlPlatformImageSurfaceBase.cs b/src/Avalonia.OpenGL/Egl/EglGlPlatformImageSurfaceBase.cs
new file mode 100644
index 0000000000..366df11e3e
--- /dev/null
+++ b/src/Avalonia.OpenGL/Egl/EglGlPlatformImageSurfaceBase.cs
@@ -0,0 +1,196 @@
+using System;
+using Avalonia.OpenGL.Surfaces;
+using Avalonia.Platform;
+using static Avalonia.OpenGL.GlConsts;
+
+namespace Avalonia.OpenGL.Egl
+{
+    /// <summary>
+    /// Base class for EGL-backed <see cref="IGlPlatformSurface"/> implementations that render into
+    /// an EGLImage. Derived types create a concrete render target bound to a given GL context.
+    /// </summary>
+    public abstract class EglGlPlatformImageSurfaceBase : IGlPlatformSurface
+    {
+        /// <summary>
+        /// Creates a render target for the given GL context.
+        /// </summary>
+        /// <param name="context">The GL context the render target will be used with.</param>
+        public abstract IGlPlatformSurfaceRenderTarget CreateGlRenderTarget(IGlContext context);
+    }
+
+    /// <summary>
+    /// Base class for EGLImage render targets. Manages a reusable framebuffer/texture pair and
+    /// binds an EGLImage as the color attachment for each draw.
+    /// </summary>
+    public abstract class EglPlatformImageSurfaceRenderTargetBase : IGlPlatformSurfaceRenderTarget
+    {
+        /// <summary>Gets the EGL context this render target draws with.</summary>
+        protected EglContext Context { get; }
+        private int _fbo;
+        private int _texture;
+        private PixelSize _fboSize;
+
+        /// <summary>
+        /// Initializes the render target for the given EGL context.
+        /// </summary>
+        /// <param name="context">The EGL context to render with.</param>
+        protected EglPlatformImageSurfaceRenderTargetBase(EglContext context)
+        {
+            Context = context;
+        }
+
+        /// <summary>Destroys the cached framebuffer and texture, if any.</summary>
+        public virtual void Dispose()
+        {
+            DestroyFbo();
+        }
+
+        /// <summary>
+        /// Begins a drawing session, throwing <see cref="RenderTargetCorruptedException"/> if the
+        /// context has been lost.
+        /// </summary>
+        /// <param name="sceneInfo">Scene information for the frame being drawn.</param>
+        public IGlPlatformSurfaceRenderingSession BeginDraw(IRenderTarget.RenderTargetSceneInfo sceneInfo)
+        {
+            if (Context.IsLost)
+                throw new RenderTargetCorruptedException();
+
+            return BeginDrawCore(sceneInfo);
+        }
+
+        /// <summary>
+        /// When overridden in a derived class, performs the actual begin-draw logic (typically by
+        /// resolving the EGLImage to render into and calling the protected
+        /// <see cref="BeginDraw(IntPtr,PixelSize,double,Action)"/> overload).
+        /// </summary>
+        /// <param name="sceneInfo">Scene information for the frame being drawn.</param>
+        public abstract IGlPlatformSurfaceRenderingSession BeginDrawCore(IRenderTarget.RenderTargetSceneInfo sceneInfo);
+
+        /// <summary>
+        /// Binds the given EGLImage as the framebuffer color attachment and begins a drawing session.
+        /// </summary>
+        /// <param name="eglImage">The EGLImage handle to render into.</param>
+        /// <param name="size">The target size in pixels.</param>
+        /// <param name="scaling">The render scaling factor.</param>
+        /// <param name="onFinishDraw">Callback invoked when the session is disposed (after flush).</param>
+        protected IGlPlatformSurfaceRenderingSession BeginDraw(IntPtr eglImage,
+            PixelSize size, double scaling, Action onFinishDraw)
+        {
+            var restoreContext = Context.MakeCurrent(null);
+            var success = false;
+            try
+            {
+                var gl = Context.GlInterface;
+
+                EnsureFbo(gl, size);
+
+                gl.BindFramebuffer(GL_FRAMEBUFFER, _fbo);
+                gl.BindTexture(GL_TEXTURE_2D, _texture);
+                gl.EGLImageTargetTexture2DOES(GL_TEXTURE_2D, eglImage);
+                gl.FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                    GL_TEXTURE_2D, _texture, 0);
+
+                var status = gl.CheckFramebufferStatus(GL_FRAMEBUFFER);
+                if (status != GL_FRAMEBUFFER_COMPLETE)
+                    throw new OpenGlException($"Framebuffer incomplete: 0x{status:X}");
+
+                gl.Viewport(0, 0, size.Width, size.Height);
+
+                success = true;
+                return new Session(Context, size, scaling, restoreContext, onFinishDraw);
+            }
+            finally
+            {
+                if (!success)
+                    restoreContext.Dispose();
+            }
+        }
+
+        private void EnsureFbo(GlInterface gl, PixelSize size)
+        {
+            if (_fbo != 0 && _fboSize == size)
+                return;
+
+            DestroyFboCore(gl);
+
+            _fbo = gl.GenFramebuffer();
+            _texture = gl.GenTexture();
+            _fboSize = size;
+
+            gl.BindTexture(GL_TEXTURE_2D, _texture);
+            gl.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+            gl.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+            gl.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+            gl.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        }
+
+        private void DestroyFbo()
+        {
+            if (_fbo == 0)
+                return;
+            try
+            {
+                using (Context.MakeCurrent(null))
+                    DestroyFboCore(Context.GlInterface);
+            }
+            catch
+            {
+                // Context may already be lost
+            }
+        }
+
+        private void DestroyFboCore(GlInterface gl)
+        {
+            if (_fbo != 0)
+            {
+                gl.DeleteFramebuffer(_fbo);
+                _fbo = 0;
+            }
+            if (_texture != 0)
+            {
+                gl.DeleteTexture(_texture);
+                _texture = 0;
+            }
+            _fboSize = default;
+        }
+
+        private class Session : IGlPlatformSurfaceRenderingSession
+        {
+            private readonly EglContext _context;
+            private readonly IDisposable _restoreContext;
+            private readonly Action _onFinishDraw;
+
+            public Session(EglContext context, PixelSize size, double scaling,
+                IDisposable restoreContext, Action onFinishDraw)
+            {
+                _context = context;
+                Size = size;
+                Scaling = scaling;
+                _restoreContext = restoreContext;
+                _onFinishDraw = onFinishDraw;
+            }
+
+            public void Dispose()
+            {
+                _context.GlInterface.Flush();
+                _restoreContext.Dispose();
+                _onFinishDraw();
+            }
+
+            public IGlContext Context => _context;
+            public PixelSize Size { get; }
+            public double Scaling { get; }
+            public bool IsYFlipped => true;
+        }
+
+        /// <summary>
+        /// Gets the render target state: <see cref="PlatformRenderTargetState.Corrupted"/> when
+        /// <see cref="IsCorrupted"/> is <c>true</c>, otherwise <see cref="PlatformRenderTargetState.Ready"/>.
+        /// </summary>
+        public virtual PlatformRenderTargetState State =>
+            IsCorrupted ? PlatformRenderTargetState.Corrupted : PlatformRenderTargetState.Ready;
+
+        /// <summary>Gets a value indicating whether the underlying GL context has been lost.</summary>
+        public virtual bool IsCorrupted => Context.IsLost;
+    }
+}
diff --git a/src/Avalonia.OpenGL/Egl/EglGlPlatformSurface.cs b/src/Avalonia.OpenGL/Egl/EglGlPlatformSurface.cs
index 10d1746086..5afe87f4a4 100644
--- a/src/Avalonia.OpenGL/Egl/EglGlPlatformSurface.cs
+++ b/src/Avalonia.OpenGL/Egl/EglGlPlatformSurface.cs
@@ -51,7 +51,7 @@ namespace Avalonia.OpenGL.Egl
                 SkipWaits = info is IEglWindowGlPlatformSurfaceInfoWithWaitPolicy { SkipWaits: true };
             }
 
-            private protected override bool SkipWaits { get; }
+            protected override bool SkipWaits { get; }
 
             public override void Dispose() => _glSurface?.Dispose();
 
diff --git a/src/Avalonia.OpenGL/Egl/EglGlPlatformSurfaceBase.cs b/src/Avalonia.OpenGL/Egl/EglGlPlatformSurfaceBase.cs
index d3deb3d102..ab64020bf3 100644
--- a/src/Avalonia.OpenGL/Egl/EglGlPlatformSurfaceBase.cs
+++ b/src/Avalonia.OpenGL/Egl/EglGlPlatformSurfaceBase.cs
@@ -31,12 +31,13 @@ namespace Avalonia.OpenGL.Egl
             return BeginDrawCore(sceneInfo);
         }
 
-        private protected virtual bool SkipWaits => false;
+        protected virtual bool SkipWaits => false;
 
         public abstract IGlPlatformSurfaceRenderingSession BeginDrawCore(IRenderTarget.RenderTargetSceneInfo sceneInfo);
 
         protected IGlPlatformSurfaceRenderingSession BeginDraw(EglSurface surface,
-            PixelSize size, double scaling, Action? onFinish = null, bool isYFlipped = false)
+            PixelSize size, double scaling, Action? onFinish = null, bool isYFlipped = false,
+            Action? beforeSwap = null)
         {
 
             var restoreContext = Context.MakeCurrent(surface);
@@ -69,7 +70,7 @@ namespace Avalonia.OpenGL.Egl
 
                 
                 success = true;
-                return new Session(Context.Display, Context, surface, size, scaling,  restoreContext, onFinish, isYFlipped, SkipWaits);
+                return new Session(Context.Display, Context, surface, size, scaling,  restoreContext, onFinish, isYFlipped, SkipWaits, beforeSwap);
             }
             finally
             {
@@ -85,11 +86,13 @@ namespace Avalonia.OpenGL.Egl
             private readonly EglDisplay _display;
             private readonly IDisposable _restoreContext;
             private readonly Action? _onFinish;
+            private readonly Action? _beforeSwap;
             private readonly bool _skipWaits;
 
             public Session(EglDisplay display, EglContext context,
                 EglSurface glSurface, PixelSize size, double scaling,
-                IDisposable restoreContext, Action? onFinish, bool isYFlipped, bool skipWaits)
+                IDisposable restoreContext, Action? onFinish, bool isYFlipped, bool skipWaits,
+                Action? beforeSwap = null)
             {
                 Size = size;
                 Scaling = scaling;
@@ -99,6 +102,7 @@ namespace Avalonia.OpenGL.Egl
                 _glSurface = glSurface;
                 _restoreContext = restoreContext;
                 _onFinish = onFinish;
+                _beforeSwap = beforeSwap;
                 _skipWaits = skipWaits;
             }
 
@@ -107,6 +111,7 @@ namespace Avalonia.OpenGL.Egl
                 _context.GlInterface.Flush();
                 if (!_skipWaits)
                     _display.EglInterface.WaitGL();
+                _beforeSwap?.Invoke();
                 _glSurface.SwapBuffers();
                 if (!_skipWaits)
                 {
diff --git a/src/Avalonia.OpenGL/Egl/EglImage.cs b/src/Avalonia.OpenGL/Egl/EglImage.cs
new file mode 100644
index 0000000000..df7b60ee71
--- /dev/null
+++ b/src/Avalonia.OpenGL/Egl/EglImage.cs
@@ -0,0 +1,46 @@
+using System;
+
+namespace Avalonia.OpenGL.Egl
+{
+    /// <summary>
+    /// Wraps a native <c>EGLImageKHR</c> handle and destroys it via <c>eglDestroyImageKHR</c> on disposal.
+    /// </summary>
+    public sealed class EglImage : IDisposable
+    {
+        private readonly EglDisplay _display;
+        private IntPtr _handle;
+
+        /// <summary>
+        /// Gets the native <c>EGLImageKHR</c> handle, or <see cref="IntPtr.Zero"/> once disposed.
+        /// </summary>
+        public IntPtr Handle => _handle;
+
+        /// <summary>
+        /// Initializes a new <see cref="EglImage"/> wrapping an existing <c>EGLImageKHR</c> handle.
+        /// </summary>
+        /// <param name="display">The EGL display that owns the image.</param>
+        /// <param name="handle">A valid (non-zero) <c>EGLImageKHR</c> handle.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="display"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentException"><paramref name="handle"/> is <see cref="IntPtr.Zero"/>.</exception>
+        public EglImage(EglDisplay display, IntPtr handle)
+        {
+            _display = display ?? throw new ArgumentNullException(nameof(display));
+            _handle = handle;
+            if (handle == IntPtr.Zero)
+                throw new ArgumentException("Invalid EGLImage handle", nameof(handle));
+        }
+
+        /// <summary>
+        /// Destroys the underlying <c>EGLImageKHR</c>. Safe to call more than once.
+        /// </summary>
+        public void Dispose()
+        {
+            if (_handle != IntPtr.Zero)
+            {
+                using (_display.Lock())
+                    _display.EglInterface.DestroyImageKHR(_display.Handle, _handle);
+                _handle = IntPtr.Zero;
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.OpenGL/Egl/EglInterface.cs b/src/Avalonia.OpenGL/Egl/EglInterface.cs
index 6b83731b49..7114fe5d8f 100644
--- a/src/Avalonia.OpenGL/Egl/EglInterface.cs
+++ b/src/Avalonia.OpenGL/Egl/EglInterface.cs
@@ -111,6 +111,9 @@ namespace Avalonia.OpenGL.Egl
         [GetProcAddress("eglSwapBuffers")]
         public partial void SwapBuffers(IntPtr display, IntPtr surface);
 
+        [GetProcAddress("eglSwapInterval")]
+        public partial bool SwapInterval(IntPtr display, int interval);
+
         [GetProcAddress("eglCreateWindowSurface")]
         public partial IntPtr CreateWindowSurface(IntPtr display, IntPtr config, IntPtr window, int[]? attrs);
 
@@ -152,5 +155,19 @@ namespace Avalonia.OpenGL.Egl
         
         [GetProcAddress("eglQueryDeviceAttribEXT", true)]
         public partial bool QueryDeviceAttribExt(IntPtr display, int attr, out IntPtr res);
+
+        // EGL_KHR_image_base
+        [GetProcAddress("eglCreateImageKHR", true)] 
+        public partial IntPtr CreateImageKHR(IntPtr display, IntPtr context, int target, IntPtr clientBuffer, int[] attribs);
+
+        [GetProcAddress("eglDestroyImageKHR", true)] 
+        public partial bool DestroyImageKHR(IntPtr display, IntPtr image);
+
+        // EGL_EXT_image_dma_buf_import_modifiers
+        [GetProcAddress("eglQueryDmaBufFormatsEXT", true)]
+        public partial bool QueryDmaBufFormatsEXT(IntPtr display, int maxFormats, int* formats, out int numFormats);
+
+        [GetProcAddress("eglQueryDmaBufModifiersEXT", true)]
+        public partial bool QueryDmaBufModifiersEXT(IntPtr display, int format, int maxModifiers, ulong* modifiers, bool* externalOnly, out int numModifiers);
     }
 }
diff --git a/src/Avalonia.OpenGL/GlConsts.cs b/src/Avalonia.OpenGL/GlConsts.cs
index 98b6e42da3..e75ea17077 100644
--- a/src/Avalonia.OpenGL/GlConsts.cs
+++ b/src/Avalonia.OpenGL/GlConsts.cs
@@ -412,8 +412,8 @@ namespace Avalonia.OpenGL
 //        public const int GL_TEXTURE_ENV_MODE = 0x2200;
 //        public const int GL_TEXTURE_1D = 0x0DE0;
         public const int GL_TEXTURE_2D = 0x0DE1;
-//        public const int GL_TEXTURE_WRAP_S = 0x2802;
-//        public const int GL_TEXTURE_WRAP_T = 0x2803;
+        public const int GL_TEXTURE_WRAP_S = 0x2802;
+        public const int GL_TEXTURE_WRAP_T = 0x2803;
         public const int GL_TEXTURE_MAG_FILTER = 0x2800;
         public const int GL_TEXTURE_MIN_FILTER = 0x2801;
 //        public const int GL_TEXTURE_ENV_COLOR = 0x2201;
@@ -530,7 +530,7 @@ namespace Avalonia.OpenGL
 //        public const int GL_ALL_CLIENT_ATTRIB_BITS = -1;
 //        public const int GL_CLIENT_ALL_ATTRIB_BITS = -1;
 //        public const int GL_RESCALE_NORMAL = 0x803A;
-//        public const int GL_CLAMP_TO_EDGE = 0x812F;
+        public const int GL_CLAMP_TO_EDGE = 0x812F;
 //        public const int GL_MAX_ELEMENTS_VERTICES = 0x80E8;
 //        public const int GL_MAX_ELEMENTS_INDICES = 0x80E9;
 //        public const int GL_BGR = 0x80E0;
diff --git a/src/Avalonia.OpenGL/GlInterface.cs b/src/Avalonia.OpenGL/GlInterface.cs
index 55eab4563b..7cbd11c072 100644
--- a/src/Avalonia.OpenGL/GlInterface.cs
+++ b/src/Avalonia.OpenGL/GlInterface.cs
@@ -404,6 +404,11 @@ namespace Avalonia.OpenGL
             return rv;
         }
 
+        // GL_OES_EGL_image
+        [GetProcAddress(true)]
+        [GlExtensionEntryPoint("glEGLImageTargetTexture2DOES", "GL_OES_EGL_image")]
+        public partial void EGLImageTargetTexture2DOES(int target, IntPtr image);
+
         public static GlInterface FromNativeUtf8GetProcAddress(GlVersion version, Func<IntPtr, IntPtr> getProcAddress)
         {
             return new GlInterface(version, s =>
diff --git a/src/Avalonia.Wayland/Avalonia.Wayland.csproj b/src/Avalonia.Wayland/Avalonia.Wayland.csproj
new file mode 100644
index 0000000000..2c9e941cac
--- /dev/null
+++ b/src/Avalonia.Wayland/Avalonia.Wayland.csproj
@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>$(AvsCurrentTargetFramework);$(AvsLegacyTargetFrameworks)</TargetFrameworks>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <EnableRuntimeMarshalling>true</EnableRuntimeMarshalling>
+  </PropertyGroup>
+
+  <ItemGroup Label="InternalsVisibleTo">
+    <InternalsVisibleTo Include="Avalonia.Wayland.UnitTests, PublicKey=$(AvaloniaPublicKey)" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="NWayland" />
+    <ProjectReference Include="..\..\packages\Avalonia\Avalonia.csproj" />
+    <ProjectReference Include="..\Avalonia.Dialogs\Avalonia.Dialogs.csproj" />
+    <ProjectReference Include="..\Avalonia.FreeDesktop\Avalonia.FreeDesktop.csproj" />
+    <Compile Include="..\Shared\RawEventGrouping.cs" />
+    <Compile Include="..\Avalonia.X11\X11IconLoader.cs" />
+    <Compile Include="..\Avalonia.X11\Clipboard\ClipboardUriListHelper.cs" />
+  </ItemGroup>
+  <Import Project="..\..\build\SourceGenerators.props" />
+  <Import Project="..\..\build\TrimmingEnable.props" />
+  <Import Project="..\..\build\NullableEnable.props" />
+
+  <ItemGroup>
+    <Compile Remove="..\Shared\SourceGeneratorAttributes.cs"/>
+    <None Include="..\Shared\SourceGeneratorAttributes.cs" Visible="false"/>
+  </ItemGroup>
+</Project>
diff --git a/src/Avalonia.Wayland/AvaloniaWaylandException.cs b/src/Avalonia.Wayland/AvaloniaWaylandException.cs
new file mode 100644
index 0000000000..c9e88ad4e0
--- /dev/null
+++ b/src/Avalonia.Wayland/AvaloniaWaylandException.cs
@@ -0,0 +1,111 @@
+using System;
+using Avalonia.Wayland.Server.Interop;
+
+namespace Avalonia.Wayland;
+
+public class AvaloniaWaylandException : Exception
+{
+    public AvaloniaWaylandException()
+    {
+    }
+
+    public AvaloniaWaylandException(string? message) : base(message)
+    {
+    }
+
+    public AvaloniaWaylandException(string? message, Exception? innerException) : base(message, innerException)
+    {
+    }
+}
+
+public class AvaloniaWaylandPollException : AvaloniaWaylandException
+{
+    public AvaloniaWaylandPollException() : base("poll failed")
+    {
+    }
+
+    public AvaloniaWaylandPollException(string? message) : base(message)
+    {
+    }
+
+    public AvaloniaWaylandPollException(string? message, Exception? innerException) : base(message, innerException)
+    {
+    }
+}
+
+public class AvaloniaWaylandNetworkException : AvaloniaWaylandException
+{
+    public AvaloniaWaylandNetworkException()
+    {
+    }
+
+    public AvaloniaWaylandNetworkException(string? message) : base(message)
+    {
+    }
+
+    public AvaloniaWaylandNetworkException(string? message, Exception? innerException) : base(message, innerException)
+    {
+    }
+}
+
+public class AvaloniaWaylandFlushException : AvaloniaWaylandNetworkException
+{
+    public AvaloniaWaylandFlushException()
+    {
+    }
+
+    public AvaloniaWaylandFlushException(string? message) : base(message)
+    {
+    }
+
+    public AvaloniaWaylandFlushException(string? message, Exception? innerException) : base(message, innerException)
+    {
+    }
+
+    internal AvaloniaWaylandFlushException(UnsafeNativeMethods.Errno errno) : base("wl_display_flush failed, errno: " + errno)
+    {
+    }
+}
+
+public class AvaloniaWaylandReadException : AvaloniaWaylandNetworkException
+{
+    public AvaloniaWaylandReadException()
+    {
+    }
+
+    public AvaloniaWaylandReadException(string? message) : base(message)
+    {
+    }
+
+    public AvaloniaWaylandReadException(string? message, Exception? innerException) : base(message, innerException)
+    {
+    }
+
+    internal AvaloniaWaylandReadException(UnsafeNativeMethods.Errno errno) : base("wl_display_read_events failed, errno: " + errno)
+    {
+    }
+}
+
+public class AvaloniaWaylandProtocolErrorException : AvaloniaWaylandException
+{
+    public AvaloniaWaylandProtocolErrorException() : base("protocol error")
+    {
+    }
+
+    public AvaloniaWaylandProtocolErrorException(string? message) : base(message)
+    {
+    }
+
+    public AvaloniaWaylandProtocolErrorException(string? message, Exception? innerException) : base(message, innerException)
+    {
+    }
+
+    internal AvaloniaWaylandProtocolErrorException(uint errorCode, string errorMessage) : base($"protocol error: {errorCode} {errorMessage}")
+    {
+        ErrorCode = errorCode;
+        ErrorMessage = errorMessage;
+    }
+
+    public uint ErrorCode { get; }
+    public string? ErrorMessage { get; }
+}
diff --git a/src/Avalonia.Wayland/AvaloniaWaylandPlatformExtensions.cs b/src/Avalonia.Wayland/AvaloniaWaylandPlatformExtensions.cs
new file mode 100644
index 0000000000..b0152b8422
--- /dev/null
+++ b/src/Avalonia.Wayland/AvaloniaWaylandPlatformExtensions.cs
@@ -0,0 +1,28 @@
+using Avalonia.Wayland;
+
+// UseXxx are deliberately in global Avalonia namespace
+// ReSharper disable once CheckNamespace
+namespace Avalonia;
+
+/// <summary>
+/// <see cref="AppBuilder"/> extensions for enabling the Wayland windowing backend.
+/// </summary>
+public static class AvaloniaWaylandPlatformExtensions
+{
+    /// <summary>
+    /// Configures the application to use the Wayland windowing backend. Options can be supplied by
+    /// registering a <see cref="WaylandPlatformOptions"/> instance with <see cref="AvaloniaLocator"/>.
+    /// </summary>
+    /// <param name="builder">The application builder.</param>
+    /// <returns>The same <paramref name="builder"/> for chaining.</returns>
+    public static AppBuilder UseWayland(this AppBuilder builder)
+    {
+        builder
+            .UseStandardRuntimePlatformSubsystem()
+            .UseWindowingSubsystem(() =>
+                WaylandPlatform.Initialize(AvaloniaLocator.Current.GetService<WaylandPlatformOptions>() ??
+                                           new WaylandPlatformOptions()));
+        return builder;
+    }
+
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs b/src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs
new file mode 100644
index 0000000000..8c0b7013bf
--- /dev/null
+++ b/src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs
@@ -0,0 +1,129 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform.Storage;
+using Avalonia.Wayland.Server;
+using Avalonia.Wayland.Server.Transient.Clipboard;
+using Avalonia.X11.Clipboard;
+
+namespace Avalonia.Wayland.Clipboard;
+
+/// <summary>
+/// Implements <see cref="IOwnedClipboardImpl"/> for the Wayland backend.
+/// All Wayland protocol calls happen on the Wayland thread via <see cref="WaylandWorker"/>.
+/// Data I/O (pipe reads/writes) happens on pool threads using .NET async APIs.
+/// No shared mutable state between threads — all cross-thread communication via messaging.
+/// </summary>
+class WaylandClipboardImpl : IOwnedClipboardImpl
+{
+    private readonly WaylandWorker _worker;
+
+    public WaylandClipboardImpl(WaylandWorker worker)
+    {
+        _worker = worker;
+    }
+
+    public async Task<IAsyncDataTransfer?> TryGetDataAsync()
+    {
+        var (cookie, mimeTypes) = await _worker.InvokeOobAsync(() =>
+        {
+            var device = _worker.Globals?.InputDispatcher.GetDataDevice();
+            if (device == null)
+                return ((WaylandOfferCookie?)null, (string[]?)null);
+            return device.GetSelectionInfo();
+        }).ConfigureAwait(false);
+
+        if (cookie == null || mimeTypes == null || mimeTypes.Length == 0)
+            return null;
+
+        // Build the item layout up front (one item per file + a shared item for the rest), reading
+        // the file URI list off the calling thread so item access later doesn't block.
+        var transfer = new WaylandDataTransfer(mimeTypes, cookie);
+        await transfer.PreloadAsync().ConfigureAwait(false);
+        return transfer;
+    }
+
+    public Task SetDataAsync(IAsyncDataTransfer dataTransfer)
+    {
+        var outgoing = new WaylandOutgoingTransfer(dataTransfer);
+        return outgoing.SetAsSelection(_worker);
+    }
+
+    public Task ClearAsync() => SetDataAsync(new DataTransfer());
+
+    public Task<bool> IsCurrentOwnerAsync()
+    {
+        return _worker.InvokeOobAsync(() =>
+        {
+            var device = _worker.Globals?.InputDispatcher.GetDataDevice();
+            return device?.ActiveSource != null;
+        });
+    }
+    
+    /// <summary>
+    /// Serializes data from an <see cref="IAsyncDataTransfer"/> for a specific MIME type directly
+    /// into <paramref name="stream"/>. Streaming avoids buffering the whole payload in memory, which
+    /// matters for large formats such as bitmaps. Writes nothing if no item provides the format.
+    /// </summary>
+    internal static async Task SerializeForMimeAsync(IAsyncDataTransfer transfer, string mimeType, Stream stream)
+    {
+        var format = WaylandMimeMapper.FromMimeType(mimeType);
+        if (format == null)
+            return;
+        
+        // Files span multiple items; gather them all and serialize as a text/uri-list.
+        if (DataFormat.File.Equals(format))
+        {
+            if (await transfer.TryGetFilesAsync().ConfigureAwait(false) is { Length: > 0 } files)
+                await stream.WriteAsync(ClipboardUriListHelper.FileUriListToUtf8Bytes(files)).ConfigureAwait(false);
+            return;
+        }
+        
+        foreach (var item in transfer.Items)
+        {
+            var value = await item.TryGetRawAsync(format);
+            if (value == null)
+                continue;
+
+            if (DataFormat.Text.Equals(format))
+            {
+                if (value is string text)
+                {
+                    await stream.WriteAsync(Encoding.UTF8.GetBytes(text)).ConfigureAwait(false);
+                    return;
+                }
+            }
+            else if (DataFormat.Bitmap.Equals(format))
+            {
+                if (value is Bitmap bitmap)
+                {
+                    // Clone the platform bitmap ref so it outlives the UI-thread retrieval, then
+                    // encode the PNG straight into the pipe from a pool thread. This avoids both
+                    // buffering the whole image as a byte[] and stalling the UI thread on pipe
+                    // backpressure during the encode.
+                    var bitmapRef = bitmap.PlatformImpl.Clone();
+                    await Task.Run(() =>
+                    {
+                        using (bitmapRef)
+                            bitmapRef.Item.Save(stream);
+                    }).ConfigureAwait(false);
+                    return;
+                }
+            }
+            else if (value is byte[] bytes)
+            {
+                await stream.WriteAsync(bytes).ConfigureAwait(false);
+                return;
+            }
+            else if (value is string strValue)
+            {
+                await stream.WriteAsync(Encoding.UTF8.GetBytes(strValue)).ConfigureAwait(false);
+                return;
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/Clipboard/WaylandDataTransfer.cs b/src/Avalonia.Wayland/Clipboard/WaylandDataTransfer.cs
new file mode 100644
index 0000000000..9634e6298c
--- /dev/null
+++ b/src/Avalonia.Wayland/Clipboard/WaylandDataTransfer.cs
@@ -0,0 +1,265 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Pipes;
+using System.Text;
+using System.Threading.Tasks;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform.Storage;
+using Avalonia.Platform.Storage.FileIO;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Transient.Clipboard;
+using Avalonia.X11.Clipboard;
+
+namespace Avalonia.Wayland.Clipboard;
+
+/// <summary>
+/// Data transfer backed by a Wayland <c>wl_data_offer</c>, implementing both sync and async interfaces.
+/// The offer cookie is validated on each read to detect stale offers.
+/// Reused by both clipboard and DnD.
+/// </summary>
+class WaylandDataTransfer : IDataTransfer, IAsyncDataTransfer
+{
+    private readonly string[] _mimeTypes;
+    private readonly WaylandOfferCookie _offerCookie;
+    private DataFormat[]? _formats;
+    private Dictionary<DataFormat, string>? _formatToMime;
+    private IReadOnlyList<IDataTransferItem>? _syncItems;
+    private IReadOnlyList<IAsyncDataTransferItem>? _asyncItems;
+
+    public WaylandDataTransfer(string[] mimeTypes, WaylandOfferCookie offerCookie)
+    {
+        _mimeTypes = mimeTypes;
+        _offerCookie = offerCookie;
+    }
+
+    private (DataFormat[] formats, Dictionary<DataFormat, string> formatToMime) BuildFormats()
+    {
+        if (_formats != null)
+            return (_formats, _formatToMime!);
+
+        var formatToMime = new Dictionary<DataFormat, string>();
+        var formats = new List<DataFormat>();
+        foreach (var mime in _mimeTypes)
+        {
+            var format = WaylandMimeMapper.FromMimeType(mime);
+            if (format != null && formatToMime.TryAdd(format, mime))
+                formats.Add(format);
+        }
+        _formats = formats.ToArray();
+        _formatToMime = formatToMime;
+        return (_formats, _formatToMime);
+    }
+
+    private DataFormat[] GetFormats() => BuildFormats().formats;
+
+    /// <summary>
+    /// Pre-reads the file list asynchronously and builds the item layout. Used by the clipboard read
+    /// path so the (cross-process) pipe read doesn't block the caller's thread.
+    /// </summary>
+    internal async Task PreloadAsync()
+    {
+        if (_syncItems != null)
+            return;
+        SetItems(BuildItems(await ReadFilesAsync().ConfigureAwait(false)));
+    }
+
+    private void EnsureItemsBlocking()
+    {
+        if (_syncItems != null)
+            return;
+        // Synchronous IDataTransfer contract — blocking here is allowed (DnD reads this path at drop
+        // on the UI thread). The offer read happens on a pool thread (the cookie posts to the Wayland
+        // thread, continuations use ConfigureAwait(false)), so it can't deadlock. wl_data_offer
+        // transfers are always cross-process — in-process drags use the original IDataTransfer.
+        SetItems(BuildItems(ReadFilesAsync().GetAwaiter().GetResult()));
+    }
+
+    private void SetItems(List<IDataTransferItem> items)
+    {
+        _syncItems = items;
+        _asyncItems = items.ConvertAll(static i => (IAsyncDataTransferItem)i);
+    }
+
+    /// <summary>
+    /// Builds the item layout: one item per file (each carrying a single <see cref="IStorageItem"/>,
+    /// matching <see cref="DataFormat.File"/>'s single-value contract) plus one shared item for all
+    /// remaining formats. Mirrors the other platforms so file copy/paste and drag-drop work.
+    /// </summary>
+    private List<IDataTransferItem> BuildItems(IReadOnlyList<IStorageItem>? files)
+    {
+        var (formats, formatToMime) = BuildFormats();
+        var items = new List<IDataTransferItem>();
+        List<DataFormat>? nonFileFormats = null;
+
+        foreach (var format in formats)
+        {
+            if (DataFormat.File.Equals(format))
+            {
+                if (files != null)
+                    foreach (var file in files)
+                        items.Add(PlatformDataTransferItem.Create(DataFormat.File, file));
+            }
+            else
+                (nonFileFormats ??= []).Add(format);
+        }
+
+        if (nonFileFormats is not null)
+            items.Add(new WaylandDataTransferItem(nonFileFormats.ToArray(), formatToMime, _offerCookie));
+
+        return items;
+    }
+
+    /// <summary>Reads and parses the <c>text/uri-list</c> into storage items, or null if no File format.</summary>
+    private async Task<IStorageItem[]?> ReadFilesAsync()
+    {
+        if (!BuildFormats().formatToMime.TryGetValue(DataFormat.File, out var mime))
+            return null;
+        var bytes = await WaylandDataTransferItem.ReadRawBytesAsync(_offerCookie, mime).ConfigureAwait(false);
+        return bytes is { Length: > 0 } ? ClipboardUriListHelper.Utf8BytesToFileUriList(bytes) : null;
+    }
+
+    IReadOnlyList<DataFormat> IDataTransfer.Formats => GetFormats();
+    IReadOnlyList<DataFormat> IAsyncDataTransfer.Formats => GetFormats();
+
+    // Synchronous interface: may block to resolve the file list (allowed by the IDataTransfer contract).
+    IReadOnlyList<IDataTransferItem> IDataTransfer.Items
+    {
+        get { EnsureItemsBlocking(); return _syncItems!; }
+    }
+
+    // The fallback here isn't supposed to be called since clipboard calls PreloadAsync, but we do a non-blocking
+    // fallback just in case
+    IReadOnlyList<IAsyncDataTransferItem> IAsyncDataTransfer.Items
+        => _asyncItems ?? BuildItems(null).ConvertAll(static i => (IAsyncDataTransferItem)i);
+
+    public void Dispose()
+    {
+        // The offer is owned by WaylandDataDevice — nothing to dispose here
+    }
+}
+
+/// <summary>
+/// A single data transfer item that reads from a Wayland data offer via pipe.
+/// The offer cookie is sent back to the Wayland thread on each read;
+/// the cookie validates the offer is still live and performs the receive internally.
+/// Implements both <see cref="IDataTransferItem"/> (sync, blocks) and
+/// <see cref="IAsyncDataTransferItem"/> (true async via pipe).
+/// </summary>
+class WaylandDataTransferItem : IDataTransferItem, IAsyncDataTransferItem
+{
+    private readonly DataFormat[] _formats;
+    private readonly Dictionary<DataFormat, string> _formatToMime;
+    private readonly WaylandOfferCookie _offerCookie;
+
+    public WaylandDataTransferItem(DataFormat[] formats,
+        Dictionary<DataFormat, string> formatToMime, WaylandOfferCookie offerCookie)
+    {
+        _formats = formats;
+        _formatToMime = formatToMime;
+        _offerCookie = offerCookie;
+    }
+
+    IReadOnlyList<DataFormat> IDataTransferItem.Formats => _formats;
+    IReadOnlyList<DataFormat> IAsyncDataTransferItem.Formats => _formats;
+
+    /// <summary>
+    /// Synchronous read — blocks the calling thread while async I/O completes on pool thread.
+    /// Used for DnD (sync data access during event handling).
+    /// </summary>
+    public object? TryGetRaw(DataFormat format)
+    {
+        if (Array.IndexOf(_formats, format) < 0)
+            return null;
+        var data = TryGetRawCoreAsync(format).GetAwaiter().GetResult();
+        return data != null ? ConvertData(format, data) : null;
+    }
+
+    /// <summary>
+    /// Asynchronous read — sends the offer cookie to the Wayland thread,
+    /// which validates and creates a pipe; data is read on the current/pool thread.
+    /// ConvertData runs on the dispatcher thread after resuming from the await.
+    /// </summary>
+    public async Task<object?> TryGetRawAsync(DataFormat format)
+    {
+        if (Array.IndexOf(_formats, format) < 0)
+            return null;
+        var data = await TryGetRawCoreAsync(format);
+        return data != null ? ConvertData(format, data) : null;
+    }
+
+    /// <summary>
+    /// Core async implementation shared by sync and async paths. Returns raw bytes; callers are
+    /// responsible for calling <see cref="ConvertData"/> on the correct thread.
+    /// </summary>
+    private Task<byte[]?> TryGetRawCoreAsync(DataFormat format)
+    {
+        var mimeType = FindMimeType(format);
+        return mimeType == null ? Task.FromResult<byte[]?>(null) : ReadRawBytesAsync(_offerCookie, mimeType);
+    }
+
+    /// <summary>
+    /// Reads the raw bytes offered for a MIME type through a pipe. Uses ConfigureAwait(false) so a
+    /// synchronous caller (<see cref="TryGetRaw"/>) doesn't deadlock on the dispatcher context.
+    /// </summary>
+    internal static async Task<byte[]?> ReadRawBytesAsync(WaylandOfferCookie offerCookie, string mimeType)
+    {
+        // Send cookie + MIME to Wayland thread; cookie.TryReceiveAsync posts and returns fd.
+        var readFd = await offerCookie.TryReceiveAsync(mimeType).ConfigureAwait(false);
+        if (readFd < 0)
+            return null;
+
+        try
+        {
+            await using var stream = new Pipe2Stream(readFd, PipeDirection.In);
+            using var ms = new MemoryStream();
+            await stream.CopyToAsync(ms).ConfigureAwait(false);
+            return ms.ToArray();
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    /// <summary>
+    /// Finds the MIME type to use for the given format.
+    /// Uses the preserved mapping from the original offer first (round-trippable),
+    /// then falls back to the mapper helper.
+    /// </summary>
+    private string? FindMimeType(DataFormat format)
+    {
+        if (_formatToMime.TryGetValue(format, out var mime))
+            return mime;
+
+        return null;
+    }
+
+    internal static object? ConvertData(DataFormat format, byte[] data)
+    {
+        if (data.Length == 0)
+            return null;
+
+        if (DataFormat.Text.Equals(format))
+            return Encoding.UTF8.GetString(data);
+
+        // Files are never read through a WaylandDataTransferItem: WaylandDataTransfer splits them
+        // into one PlatformDataTransferItem per file (DataFormat.File is a single-value format).
+
+        if (DataFormat.Bitmap.Equals(format))
+        {
+            using var ms = new MemoryStream(data);
+            return new Bitmap(ms);
+        }
+
+        if (format is DataFormat<string>)
+            return Encoding.UTF8.GetString(data);
+
+        if (format is DataFormat<byte[]>)
+            return data;
+
+        return null;
+    }
+}
diff --git a/src/Avalonia.Wayland/Clipboard/WaylandDragSource.cs b/src/Avalonia.Wayland/Clipboard/WaylandDragSource.cs
new file mode 100644
index 0000000000..065a837fc2
--- /dev/null
+++ b/src/Avalonia.Wayland/Clipboard/WaylandDragSource.cs
@@ -0,0 +1,28 @@
+using System.Threading.Tasks;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using Avalonia.Wayland.Server.Persistent;
+
+namespace Avalonia.Wayland.Clipboard;
+
+/// <summary>
+/// Implements <see cref="IPlatformDragSource"/> for the Wayland backend.
+/// Delegates to <see cref="WaylandOutgoingTransfer.SetAsDrag"/> to create a
+/// <c>wl_data_source</c> and call <c>wl_data_device.start_drag</c>.
+/// </summary>
+class WaylandDragSource : IPlatformDragSource
+{
+    public Task<DragDropEffects> DoDragDropAsync(
+        PointerPressedEventArgs triggerEvent,
+        IDataTransfer dataTransfer,
+        DragDropEffects allowedEffects)
+    {
+        triggerEvent.Pointer.Capture(null);
+        if (dataTransfer is not IAsyncDataTransfer asyncTransfer)
+            return Task.FromResult(DragDropEffects.None);
+        if (triggerEvent.PlatformInputEventCookie is not WaylandInputEventCookie inputCookie)
+            return Task.FromResult(DragDropEffects.None);
+        var outgoing = new WaylandOutgoingTransfer(asyncTransfer);
+        return outgoing.SetAsDrag(inputCookie, allowedEffects);
+    }
+}
diff --git a/src/Avalonia.Wayland/Clipboard/WaylandMimeMapper.cs b/src/Avalonia.Wayland/Clipboard/WaylandMimeMapper.cs
new file mode 100644
index 0000000000..155a95cce7
--- /dev/null
+++ b/src/Avalonia.Wayland/Clipboard/WaylandMimeMapper.cs
@@ -0,0 +1,68 @@
+using Avalonia.Input;
+
+namespace Avalonia.Wayland.Clipboard;
+
+/// <summary>
+/// Maps between Avalonia <see cref="DataFormat"/> and MIME type strings used by Wayland's
+/// wl_data_device protocol.
+/// </summary>
+static class WaylandMimeMapper
+{
+    public const string MimeTextPlainUtf8 = "text/plain;charset=utf-8";
+    public const string MimeTextPlain = "text/plain";
+    public const string MimeTextUriList = "text/uri-list";
+    public const string MimeImagePng = "image/png";
+    public const string AppPrefix = "application/x-avalonia-";
+
+    /// <summary>
+    /// Returns the MIME type strings that should be advertised for a given <see cref="DataFormat"/>.
+    /// For <see cref="DataFormat.Text"/>, both <c>text/plain;charset=utf-8</c> and <c>text/plain</c> are returned.
+    /// </summary>
+    public static string[] ToMimeTypes(DataFormat format)
+    {
+        if (DataFormat.Text.Equals(format))
+            return [MimeTextPlainUtf8, MimeTextPlain];
+
+        if (DataFormat.File.Equals(format))
+            return [MimeTextUriList];
+
+        if (DataFormat.Bitmap.Equals(format))
+            return [MimeImagePng];
+
+        return [format.ToSystemName(AppPrefix)];
+    }
+
+    /// <summary>
+    /// Returns the single preferred MIME type for reading a given <see cref="DataFormat"/>.
+    /// </summary>
+    public static string ToPreferredMimeType(DataFormat format)
+    {
+        if (DataFormat.Text.Equals(format))
+            return MimeTextPlainUtf8;
+
+        if (DataFormat.File.Equals(format))
+            return MimeTextUriList;
+
+        if (DataFormat.Bitmap.Equals(format))
+            return MimeImagePng;
+
+        return format.ToSystemName(AppPrefix);
+    }
+
+    /// <summary>
+    /// Converts a MIME type string to a <see cref="DataFormat"/>, or null if not mappable.
+    /// </summary>
+    public static DataFormat? FromMimeType(string mimeType)
+    {
+        if (mimeType is MimeTextPlainUtf8 or MimeTextPlain)
+            return DataFormat.Text;
+
+        if (mimeType is MimeTextUriList)
+            return DataFormat.File;
+
+        if (mimeType is MimeImagePng)
+            return DataFormat.Bitmap;
+
+        return DataFormat.FromSystemName<byte[]>(mimeType, AppPrefix);
+    }
+}
diff --git a/src/Avalonia.Wayland/Clipboard/WaylandOutgoingTransfer.cs b/src/Avalonia.Wayland/Clipboard/WaylandOutgoingTransfer.cs
new file mode 100644
index 0000000000..cdbb2b1dc4
--- /dev/null
+++ b/src/Avalonia.Wayland/Clipboard/WaylandOutgoingTransfer.cs
@@ -0,0 +1,260 @@
+using System;
+using System.Collections.Generic;
+using System.IO.Pipes;
+using System.Threading.Tasks;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using Avalonia.Threading;
+using Avalonia.Wayland.Server;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Persistent;
+using Avalonia.Wayland.Server.Transient;
+using Avalonia.Wayland.Server.Transient.Clipboard;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Clipboard;
+
+/// <summary>
+/// Manages the outgoing side of a data transfer (clipboard set or DnD initiate).
+/// Created on the UI thread; coordinates between UI-thread <see cref="IAsyncDataTransfer"/>
+/// and Wayland-thread <see cref="WaylandDataSource"/>.
+/// <para>
+/// The <c>send</c> callback dispatches to the UI thread via <see cref="Dispatcher.UIThread"/>
+/// so that user-provided data transfer methods run on the correct thread.
+/// </para>
+/// </summary>
+class WaylandOutgoingTransfer
+{
+    private const string InProcessMimePrefix = "application/x-avalonia-inproc-dnd-";
+
+    /// <summary>
+    /// Unique identifier for this application instance, used as part of the sentinel MIME type
+    /// to distinguish our own drags from drags originating in other Avalonia processes.
+    /// </summary>
+    private static readonly string s_instanceId = Guid.NewGuid().ToString("N");
+
+    /// <summary>
+    /// Full MIME prefix for this app instance: <c>application/x-avalonia-inproc-dnd-{instance}-</c>.
+    /// </summary>
+    private static readonly string s_instancePrefix = InProcessMimePrefix + s_instanceId + "-";
+
+    /// <summary>
+    /// Maps in-process DnD operation keys to the original <see cref="IDataTransfer"/>.
+    /// Accessed exclusively from the Wayland thread.
+    /// When the receive side sees a sentinel MIME type matching this instance's prefix,
+    /// it uses the original transfer directly instead of reading through Wayland pipes,
+    /// which would deadlock (the source's <c>send</c> handler dispatches to the UI thread).
+    /// </summary>
+    private static readonly Dictionary<string, IDataTransfer> s_inProcessDrags = new();
+
+    private readonly IAsyncDataTransfer _transfer;
+    private readonly List<string> _mimeTypes;
+
+    /// <summary>
+    /// Called on the UI thread when the data source is cancelled (lost ownership or DnD ended).
+    /// </summary>
+    public Action? Cancelled { get; set; }
+
+    public WaylandOutgoingTransfer(IAsyncDataTransfer transfer)
+    {
+        _transfer = transfer;
+        _mimeTypes = new List<string>();
+        foreach (var format in transfer.Formats)
+        {
+            // In-process formats are only meaningful within this process and must never be
+            // advertised to (or serialized for) other Wayland clients.
+            if (format.Kind == DataFormatKind.InProcess)
+                continue;
+            foreach (var mime in WaylandMimeMapper.ToMimeTypes(format))
+                _mimeTypes.Add(mime);
+        }
+    }
+
+    /// <summary>
+    /// Creates a <see cref="WaylandDataSource"/> on the Wayland thread, configures it,
+    /// and sets it as the clipboard selection.
+    /// Returns a task that completes when the selection has been set.
+    /// </summary>
+    public Task SetAsSelection(WaylandWorker worker)
+    {
+        return worker.InvokeOobAsync(() =>
+        {
+            var globals = worker.Globals;
+            if (globals == null)
+                return;
+
+            var device = globals.InputDispatcher.GetDataDevice();
+            if (device == null)
+                return;
+
+            var source = CreateSource(globals);
+            if (source == null)
+                return;
+
+            source.OnCancelled = () =>
+            {
+                device.ActiveSource = null;
+                source.Dispose();
+                Dispatcher.UIThread.Post(() => Cancelled?.Invoke());
+            };
+
+            device.SetSelection(source);
+        });
+    }
+
+    /// <summary>
+    /// Creates a <see cref="WaylandDataSource"/> on the Wayland thread, configures it,
+    /// and starts a drag-and-drop operation using <c>wl_data_device.start_drag</c>.
+    /// The <paramref name="inputCookie"/> carries the globals captured at input-event time,
+    /// ensuring reconnect-safe access to transient state.
+    /// Returns a task that resolves to the resulting <see cref="DragDropEffects"/> when
+    /// the DnD operation completes (finished, cancelled, or failed to start).
+    /// </summary>
+    public Task<DragDropEffects> SetAsDrag(WaylandInputEventCookie inputCookie, DragDropEffects allowedEffects)
+    {
+        var tcs = new TaskCompletionSource<DragDropEffects>();
+        DragDropEffects negotiatedEffects = DragDropEffects.None;
+
+        inputCookie.PostOob(globals =>
+        {
+            var device = globals.InputDispatcher.GetDataDevice();
+            if (device == null)
+            {
+                tcs.TrySetResult(DragDropEffects.None);
+                return;
+            }
+
+            var source = CreateSource(globals);
+            if (source == null)
+            {
+                tcs.TrySetResult(DragDropEffects.None);
+                return;
+            }
+
+            // Register for in-process detection so the receive side can use
+            // the original IDataTransfer directly instead of reading through
+            // Wayland pipes (which would deadlock).
+            var operationKey = Guid.NewGuid().ToString("N");
+            source.Offer(s_instancePrefix + operationKey);
+            s_inProcessDrags[operationKey] = (IDataTransfer)_transfer;
+
+            var allowedActions = WaylandDataDevice.EffectsToActions(allowedEffects);
+
+            source.OnAction = action =>
+            {
+                negotiatedEffects = WaylandDataDevice.ActionsToEffects(action);
+                var cursorType = action switch
+                {
+                    WlDataDeviceManager.DndActionEnum.Copy => StandardCursorType.DragCopy,
+                    WlDataDeviceManager.DndActionEnum.Move => StandardCursorType.DragMove,
+                    WlDataDeviceManager.DndActionEnum.Ask => StandardCursorType.DragLink,
+                    _ => StandardCursorType.No
+                };
+                globals.InputDispatcher.SetDndCursor(cursorType);
+            };
+
+            source.OnCancelled = () =>
+            {
+                s_inProcessDrags.Remove(operationKey);
+                source.Dispose();
+                Dispatcher.UIThread.Post(() =>
+                {
+                    Cancelled?.Invoke();
+                    tcs.TrySetResult(DragDropEffects.None);
+                });
+            };
+
+            source.OnDndFinished = () =>
+            {
+                s_inProcessDrags.Remove(operationKey);
+                source.Dispose();
+                var result = negotiatedEffects;
+                Dispatcher.UIThread.Post(() => tcs.TrySetResult(result));
+            };
+
+            source.OnDndDropPerformed = () =>
+            {
+                // Drop performed by user but destination may still reject —
+                // wait for DndFinished or Cancelled to resolve the TCS.
+            };
+
+            if (!device.StartDrag(source, inputCookie, allowedActions))
+            {
+                s_inProcessDrags.Remove(operationKey);
+                source.Dispose();
+                tcs.TrySetResult(DragDropEffects.None);
+            }
+        });
+
+        return tcs.Task;
+    }
+
+    /// <summary>
+    /// Creates and configures a <see cref="WaylandDataSource"/> with MIME type offers
+    /// and a send handler that dispatches to the UI thread.
+    /// </summary>
+    private WaylandDataSource? CreateSource(WaylandGlobals globals)
+    {
+        var manager = globals.DataDeviceManager;
+        if (manager == null)
+            return null;
+
+        var sourceListener = new WaylandDataSourceListener();
+        var wlSource = manager.CreateDataSource(sourceListener);
+        var source = new WaylandDataSource(wlSource);
+        sourceListener.SetWrapper(source);
+
+        foreach (var mime in _mimeTypes)
+            source.Offer(mime);
+
+        source.OnSend = HandleSend;
+
+        return source;
+    }
+
+    /// <summary>
+    /// Called on the Wayland thread when the compositor requests data.
+    /// Dispatches to the UI thread to read from the user's data transfer and write to the pipe fd.
+    /// </summary>
+    private void HandleSend(string mime, int fd)
+    {
+        var transfer = _transfer;
+        Dispatcher.UIThread.Post(async () =>
+        {
+            await using var stream = new Pipe2Stream(fd, PipeDirection.Out);
+            try
+            {
+                await WaylandClipboardImpl.SerializeForMimeAsync(transfer, mime, stream);
+            }
+            catch
+            {
+                // Stream disposal closes the fd
+            }
+        });
+    }
+
+    /// <summary>
+    /// Checks whether the offered MIME types contain an in-process sentinel from this app instance.
+    /// If so, returns the original <see cref="IDataTransfer"/> directly, avoiding
+    /// pipe-based reads that would deadlock on self-drags.
+    /// If the sentinel matches our instance but the operation key is not found
+    /// (e.g., source already cleaned up), returns an empty <see cref="DataTransfer"/>
+    /// as a safe dummy — we cannot interact with our own data offer via pipes.
+    /// Called from the Wayland thread during <c>data_device.enter</c>.
+    /// </summary>
+    internal static IDataTransfer? TryGetInProcessTransfer(string[] mimeTypes)
+    {
+        foreach (var mime in mimeTypes)
+        {
+            if (!mime.StartsWith(s_instancePrefix, StringComparison.Ordinal))
+                continue;
+
+            var operationKey = mime.Substring(s_instancePrefix.Length);
+            // Found our instance prefix — either return the real transfer or a safe dummy
+            return s_inProcessDrags.TryGetValue(operationKey, out var transfer)
+                ? transfer
+                : new DataTransfer();
+        }
+        return null;
+    }
+}
diff --git a/src/Avalonia.Wayland/IWaylandXdgTopLevelExport.cs b/src/Avalonia.Wayland/IWaylandXdgTopLevelExport.cs
new file mode 100644
index 0000000000..4029905747
--- /dev/null
+++ b/src/Avalonia.Wayland/IWaylandXdgTopLevelExport.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// UI-thread façade over a worker-thread <c>zxdg_exported_v2</c> handle. Restricts
+/// the UI side to the only two operations it should care about: awaiting the
+/// compositor-issued handle string and disposing the export. The underlying worker
+/// object is intentionally not exposed.
+/// </summary>
+internal interface IWaylandXdgTopLevelExport : IDisposable
+{
+    /// <summary>
+    /// Resolves to the raw compositor-issued handle string (no protocol prefix), or
+    /// <c>null</c> if the wayland connection died before the handle was delivered.
+    /// </summary>
+    Task<string?> HandleTask { get; }
+}
diff --git a/src/Avalonia.Wayland/PopupImpl.Sink.cs b/src/Avalonia.Wayland/PopupImpl.Sink.cs
new file mode 100644
index 0000000000..8576f2ba60
--- /dev/null
+++ b/src/Avalonia.Wayland/PopupImpl.Sink.cs
@@ -0,0 +1,86 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Wayland.Server;
+using Avalonia.Wayland.Server.Persistent;
+
+namespace Avalonia.Wayland;
+
+partial class PopupImpl
+{
+    private new sealed class Sink : WindowBaseImpl.Sink, IWXdgPopupEventSink
+    {
+        private new PopupImpl Parent => (PopupImpl)base.Parent;
+        private WaylandSurfaceCreateResult<WXdgPopupProxy>? _handle;
+        private WXdgPopupProxy? _surfaceProxy;
+
+        public Sink(PopupImpl parent) : base(parent)
+        {
+            // Worker→UI sink calls (OnPointerEnter, OnPopupConfigure, etc.)
+            // are invoked from the worker thread; wrap ourselves in a UI-
+            // thread proxy so they marshal onto the dispatcher.
+            var sinkProxy = new WXdgPopupEventSinkProxy(this, WaylandMarshallers.UIThread);
+
+            // The xdg_popup parent is the direct parent surface (toplevel
+            // or another popup). The compositor uses parent-relative
+            // coordinates and is free to reposition the popup; chaining
+            // through the real visual hierarchy lets it constrain each
+            // link's anchor rect against its direct parent.
+            var parentProxy = Parent._parent.SurfaceProxy
+                ?? throw new InvalidOperationException(
+                    "Cannot create popup: parent surface has not been mapped yet.");
+
+            _handle = Parent._workerClient.CreatePopupHandle(sinkProxy, parentProxy);
+            _surfaceProxy = _handle.Proxy;
+            Parent._handle = _handle;
+            Parent._surfaceProxy = _surfaceProxy;
+
+            // Replay the cached positioner (if Show was called after
+            // UpdatePositioner — common Avalonia ordering) so the worker
+            // can attach the popup as soon as the parent is mapped.
+            if (Parent._lastPositioner is { } pos)
+                _surfaceProxy.UpdatePositioner(pos);
+
+            // Re-apply cursor (defaults to Arrow on a fresh worker WSurface).
+            if (Parent.CurrentCursor is not null)
+                Parent.ApplyCurrentCursor(_surfaceProxy);
+        }
+
+        protected override void DisconnectFromSurface()
+        {
+            var proxy = Parent._surfaceProxy;
+            Parent._handle = null;
+            Parent._surfaceProxy = null;
+            proxy?.Disconnect();
+        }
+
+        public void OnPopupConfigure(XdgPopupConfigureBatch batch)
+        {
+            // Marshalled to UI thread by WXdgPopupEventSinkProxy.
+            if (IsDisposed)
+                return;
+
+            // The compositor's suggested size is intentionally IGNORED
+            // for now: per xdg_surface.configure, this is a *suggested*
+            // surface change, and the framework's positioner-supplied
+            // size is the authoritative one we use for layout. The
+            // worker→UI plumbing is kept because we may want to revisit
+            // this for compositor-driven shrink-to-fit behaviour.
+            _ = batch.Width;
+            _ = batch.Height;
+
+            // Ack the configure on next commit.
+            _surfaceProxy?.SetPendingAckSerial(batch.Serial);
+        }
+
+        public void OnPopupDone()
+        {
+            // Compositor dismissed the popup (click outside, parent
+            // unmapped, etc.). xdg-shell forbids any further use of the
+            // xdg_popup object after popup_done; treat this as a close
+            // and let Dispose tear it down.
+            if (IsDisposed)
+                return;
+            Parent.Dispose();
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/PopupImpl.cs b/src/Avalonia.Wayland/PopupImpl.cs
new file mode 100644
index 0000000000..0edd318f1b
--- /dev/null
+++ b/src/Avalonia.Wayland/PopupImpl.cs
@@ -0,0 +1,118 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives.PopupPositioning;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Platform;
+using Avalonia.Platform.Surfaces;
+using Avalonia.Wayland.Server;
+using Avalonia.Wayland.Server.Persistent;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// Wayland xdg_popup window implementation. Created via
+/// <see cref="WindowImpl.CreatePopup"/> (or another <see cref="PopupImpl.CreatePopup"/>
+/// for nested popups) and parented to either a top-level or another popup.
+///
+/// <para>We deliberately do NOT call <c>xdg_popup.grab()</c>. Dismissal is
+/// driven by: (1) framework light-dismiss, (2) the compositor's
+/// <c>popup_done</c> event, (3) focus-leave on the parent toplevel.</para>
+///
+/// <para>Coordinate convention: the <see cref="PopupPositioner"/>'s
+/// <see cref="IPopupPositioner.Update"/> receives anchor-rect coordinates
+/// in the parent's client-area logical pixels (i.e. parent
+/// buffer-relative). We forward them straight through to the worker via
+/// <see cref="WaylandConversionExtensions.ToWayland(PopupPositionerParameters)"/>;
+/// the worker handles the buffer→geometry origin shift and clamping.</para>
+/// </summary>
+internal partial class PopupImpl : WindowBaseImpl, IPopupImpl
+{
+    private readonly WindowBaseImpl _parent;
+    private readonly WaylandWorkerClient _workerClient;
+    private WaylandSurfaceCreateResult<WXdgPopupProxy>? _handle;
+    private WXdgPopupProxy? _surfaceProxy;
+    private XdgPopupPositionerParams? _lastPositioner;
+
+    public PopupImpl(WaylandWorkerClient client, WindowBaseImpl parent) : base(client)
+    {
+        _parent = parent;
+        _workerClient = client;
+        // Inherit the parent's render scale at construction time so the
+        // first layout pass uses something sensible. The compositor will
+        // re-issue scale events via OnScaleChanged once the popup is
+        // mapped — at which point we'll converge on the authoritative value.
+        RenderScaling = parent.RenderScaling;
+
+        PopupPositioner = new WaylandPopupPositioner(this);
+    }
+
+    public override IPlatformRenderSurface[] Surfaces => _handle?.GetRenderSurfaces() ?? [];
+
+    /// <summary>
+    /// Inherit the parent's auto-size hint (which on Wayland comes from
+    /// <c>xdg_toplevel.configure_bounds</c> — i.e. the usable area of
+    /// the output the parent is on). xdg_popup is constrained by the
+    /// compositor to fit on-screen, so the same bound applies.
+    /// </summary>
+    public override Size MaxAutoSizeHint => _parent.MaxAutoSizeHint;
+
+    internal override WXdgShellSurfaceProxy? SurfaceProxy => _surfaceProxy;
+
+    public IPopupPositioner PopupPositioner { get; }
+
+    public override void Show(bool activate, bool isDialog)
+    {
+        if (IsDisposed)
+            throw new ObjectDisposedException(nameof(PopupImpl));
+
+        if (CurrentSink == null)
+            CurrentSink = new Sink(this);
+
+        Client.AnyThreadWakeupRenderLoop();
+    }
+
+    public override IPopupImpl CreatePopup() => new PopupImpl(_workerClient, this);
+
+    /// <summary>
+    /// Avalonia drives popup positioning through this entry. We translate
+    /// the framework's bitfield enums into the protocol's dense enums and
+    /// hand the bundle to the worker, which (re-)builds an
+    /// <c>xdg_positioner</c> on every connect.
+    /// </summary>
+    internal void UpdatePositioner(PopupPositionerParameters parameters)
+    {
+        var translated = parameters.ToWayland();
+        _lastPositioner = translated;
+        // Adopt the requested popup size as our client-size up-front so
+        // the renderer paints at the right dimensions before the
+        // compositor's first popup configure event arrives. ClientSize's
+        // setter only stores + wakes the render loop, so fire Resized
+        // explicitly to drive Avalonia's layout pass.
+        if (translated.Size.Width > 0 && translated.Size.Height > 0
+            && translated.Size != ClientSize)
+        {
+            ClientSize = translated.Size;
+            Resized?.Invoke(translated.Size, WindowResizeReason.Layout);
+        }
+        _surfaceProxy?.UpdatePositioner(translated);
+    }
+
+    public void SetWindowManagerAddShadowHint(bool enabled)
+    {
+        // No-op on Wayland — the compositor doesn't draw popup shadows;
+        // CSD shadows (if any) are baked into the buffer by the framework.
+    }
+
+    public void TakeFocus()
+    {
+    }
+
+    /// <summary>
+    /// Bridges Avalonia's positioner contract to <see cref="UpdatePositioner"/>.
+    /// </summary>
+    private sealed class WaylandPopupPositioner(PopupImpl owner) : IPopupPositioner
+    {
+        public void Update(PopupPositionerParameters parameters) => owner.UpdatePositioner(parameters);
+    }
+}
diff --git a/src/Avalonia.Wayland/README.md b/src/Avalonia.Wayland/README.md
new file mode 100644
index 0000000000..63d5438573
--- /dev/null
+++ b/src/Avalonia.Wayland/README.md
@@ -0,0 +1,100 @@
+# Wayland platform
+
+
+## Special considerations
+
+Unlike other platforms where the OS provided window server is considered to be stable, with Wayland it's EXPECTED for
+compositor to crash and restart during normal usage. This means that applications need to be able to handle this situation
+gracefully. So Avalonia.Wayland platform maintains its own state of the wayland surfaces in a way that can be re-uploaded
+to the compositor on restart. It also means that all kinds of resources are considered to be transient and are a subject
+to be re-created as needed.
+
+Another difference with our other platform implementations, is that Wayland can't have the same render timer concept:
+the compositor is controlling when the application should render next frame for EACH toplevel by sending frame callbacks.
+This means that we need to react fast to said callbacks to provide acceptable frame rate. So our wayland event loop
+runs on a dedicated thread that also serves as our render thread. Yes, Wayland worker thread == Avalonia's render thread.
+
+
+
+NOTE: crash recovery is not yet supported when using an externally created wl_display.
+
+## Protocol docs
+
+Do NOT assume things about Wayland protocols. Those could be rather non-intuitive. Always check what the protocol says
+about a particular event.
+
+LLMs should expect to find protocol docs in `<solution_dir>/../NWayland/external/{wayland|wayland-protocols|plasma-wayland-protocols|wlr-protocols}`
+Humans using LLM agents are expected to clone NWayland (https://github.com/AvaloniaUI/NWayland) there.
+
+NWayland generally comments protocol docs as C# XML comments in generated bindings, so those can be used as the source of information too.
+LLMs should NEVER attempt to disassemble NWayland.dll or attempt to extract strings from it or use similar silly practices to extract protocol binding information, use .xml files from nuget cache instead.
+NWayland converts snake_case to CamelCase, but XML docs might still be mentioning things by snake_case naming.
+
+
+## Architecture 
+
+We are using NWayland as wayland bindings. We are always using a dedicated wayland queue for all of our wayland interactions so
+Avalonia can potentially be embedded into another toolkit (if said toolkit actually verifies that it gets events from objects it owns).
+
+Wayland interactions are running on a dedicated thread that also serves as our render thread.
+We are sending most of our UI->Wayland commands as a part of our composition batches, so they arrive alongside with
+the information required to render frame, so the wayland thread  always works with a consistent view of the UI state.
+There are also OOB commands for special cases that bypass regular Compositor's commit cycle.
+
+## "Persistence"
+
+To handle compositor restarts, we maintain a "persistent" state of our surfaces and resources (see Server/Persistent dir).
+Entities bound to a connection defined in Server/Transient dir, they should be considered to be ephemeral.
+
+## Render timer
+
+Since wayland asks us nicely to NOT render when we want to, but instead tells us when to, the render timer is not an actual
+timer, but something that gets triggered by frame callbacks. So if we expect the render timer to do something useful 
+for e. g. new surface, we need to wake it up explicitly.
+For inevitable oversights there is currently a "fallback" timer that ticks at 20FPS, but it should be removed once
+we are sure that all the cases are covered (this will likely require some refactoring of UI thread's animation engine).
+
+## Threading rules
+
+**NO CROSS-THREAD VARIABLE ACCESS. MESSAGING ONLY.**
+
+- Wayland interactions run on a dedicated thread (the wayland worker thread).
+- UI thread objects must NEVER directly access fields of wayland-thread objects (aside from initial creation / passing to constructors).
+- Wayland thread objects must NEVER directly read fields of UI-thread objects. No volatile fields, no locks, no "safe" shared state.
+- All cross-thread communication from UI to wayland goes through code-generated proxies that internally route calls through `WaylandWorker.PostOob()` / `PostWithCommit()` messages (dnd/clipboard is currently an exception to this rule that we'll probably refactor later)
+- ~~Input (mouse/touch/keyboard) events from wayland to UI flow through `AutomaticRawEventGrouperDispatchQueue` (enqueued on wayland thread, drained by UI thread dispatcher).~~ (this was the plan, but we need an input root to issue events from non-UI tread, so for now we simply make calls with default priority and let the auto-grouper to dispatch them, will think what to do about it later).
+- Server objects (in `Server/`) should not have their internal state modified from UI thread code. The UI thread may only call `Post` and pass values into server object constructors.
+
+## Wayland protocol rules
+
+### Globals and versioning
+
+- The compositor announces globals via `wl_registry.global` with the **maximum** version it supports.
+- The client chooses the version it wants when calling `Bind` (should be ≤ compositor's version, ≤ bindings version).
+- Use `Math.Min(compositorVersion, known-supported-version)` as the bind version; skip if below minimum required.
+- Once a proxy is bound at a version, all objects created through it (factory methods or arriving as events) inherit that version.
+- Events for versions higher than the bound version simply do not arrive (safe degradation).
+
+### Globals can come and go
+
+- Globals like `wl_seat` and `wl_output` can appear and disappear dynamically via `wl_registry.global` / `global_remove`.
+- There can be **multiple** instances of the same global type simultaneously (e.g., multiple seats representing different input device groups).
+- Track globals by their registry `name` (uint) so they can be properly cleaned up on `global_remove`.
+- Do not assume singletons — design data structures to handle multiple instances.
+
+### wl_pointer frame semantics
+
+- `wl_pointer` uses frame-based event delivery: events (enter, leave, motion, button, axis) accumulate, then a `frame` event signals the end of a logical group.
+- **All events within a frame must be dispatched in arrival order.** A frame can contain leave from surface A followed by enter on surface B — dispatching in an arbitrary hardcoded order will route events to the wrong surface.
+- Multiple `wl_pointer.axis` events within the same frame should be combined (e.g., H+V scroll into a single vector), but the combined result must be dispatched at the correct position in the event sequence (not after all other events).
+- Frame state (focused sink, position, modifiers, accumulated events) belongs to the **pointer**, not the seat. A seat manages device lifecycle; each `wl_pointer` has its own independent frame grouping.
+- Button codes are Linux `input-event-codes.h` constants: `BTN_LEFT=0x110`, `BTN_RIGHT=0x111`, `BTN_MIDDLE=0x112`, `BTN_SIDE=0x113`, `BTN_EXTRA=0x114`.
+
+### NWayland specifics
+
+- Listeners are passed at bind/creation time (e.g., `WlSeat.Bind(..., listener)`). There is no `SetListener` method. This is needed because of known race conditions in libwayland-client.
+- `WlFixed` supports explicit cast to double: `(double)surfaceX`.
+- Enums like `WlSeat.CapabilityEnum` support `.HasFlag()` and `==` comparison. Do not access `.value__` (those are actually enums it's just reference API file got generated by MSFT tool that turned them into classes for some reason)
+- Do NOT attempt to re-declare wayland protocol enums even if generated method accepts int/uint. This is due to XML protocol specs not actually providing machine-readable information about a particular enum being expected by the request/event. The enums themselves are still generated.
+- ALWAYS specify the version range of the protocol that's supported by Avalonia. NWayland supporting a particular protocol version binding-wise does NOT mean that we are ready to support it. Even if protocol says "stable" it does't mean that there aren't new requirements or invariants for the protocol clients to support.
+- Proxy version is available from Version property on all proxies. If some request is only available from version X, NWayland generates Is<Name>Available property (e. g. `public bool IsSetReactiveAvailable => Version >= 3;`) that can be used instead of `Version` checks.
diff --git a/src/Avalonia.Wayland/Screens/IWaylandOutputsSink.cs b/src/Avalonia.Wayland/Screens/IWaylandOutputsSink.cs
new file mode 100644
index 0000000000..e0958e0ad5
--- /dev/null
+++ b/src/Avalonia.Wayland/Screens/IWaylandOutputsSink.cs
@@ -0,0 +1,21 @@
+using Avalonia.SourceGenerator;
+using Avalonia.Threading;
+using Avalonia.Wayland.Server;
+
+namespace Avalonia.Wayland.Screens;
+
+/// <summary>
+/// Worker → UI sink delivering a full <see cref="WaylandOutputsSnapshot"/>
+/// whenever the compositor adds, removes, or finishes updating an output.
+/// Implemented on the UI thread by <see cref="SnapshotScreensImpl"/>; the
+/// worker holds the generated <c>WaylandOutputsSinkProxy</c> which marshals
+/// every call onto the UI dispatcher.
+/// </summary>
+[GenerateCrossThreadProxy(
+    typeof(DispatcherPriority),
+    "default",
+    GeneratedClassName = "WaylandOutputsSinkProxy")]
+internal interface IWaylandOutputsSink
+{
+    void OnOutputsChanged(WaylandOutputsSnapshot snapshot);
+}
diff --git a/src/Avalonia.Wayland/Screens/SnapshotScreensImpl.cs b/src/Avalonia.Wayland/Screens/SnapshotScreensImpl.cs
new file mode 100644
index 0000000000..828f0699cd
--- /dev/null
+++ b/src/Avalonia.Wayland/Screens/SnapshotScreensImpl.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Platform;
+
+namespace Avalonia.Wayland.Screens;
+
+/// <summary>
+/// UI-thread <see cref="IScreenImpl"/> driven entirely by snapshots
+/// pushed from the wayland worker via <see cref="IWaylandOutputsSink"/>.
+/// Per <c>Avalonia.Wayland</c> screen design, <see cref="Screen.Scaling"/>
+/// is always <c>1.0</c>: fractional / integer scaling is a per-window
+/// concern (matching the macOS model).
+/// </summary>
+internal sealed class SnapshotScreensImpl
+    : ScreensBase<object, WaylandSnapshotScreen>, IWaylandOutputsSink
+{
+    private WaylandOutputsSnapshot _latest = new(Array.Empty<WaylandOutputSnapshot>());
+
+    public void OnOutputsChanged(WaylandOutputsSnapshot snapshot)
+    {
+        _latest = snapshot;
+        OnChanged();
+    }
+
+    internal WaylandOutputSnapshot? Lookup(object id) =>
+        _latest.Outputs.FirstOrDefault(o => ReferenceEquals(o.Id, id));
+
+    protected override IReadOnlyList<object> GetAllScreenKeys() =>
+        _latest.Outputs.Select(o => o.Id).ToList();
+
+    protected override WaylandSnapshotScreen CreateScreenFromKey(object key) =>
+        new(this, key);
+
+    protected override void ScreenAdded(WaylandSnapshotScreen screen)
+    {
+        screen.Refresh();
+        base.ScreenAdded(screen);
+    }
+
+    protected override void ScreenChanged(WaylandSnapshotScreen screen) =>
+        screen.Refresh();
+
+    protected override Screen? ScreenFromTopLevelCore(ITopLevelImpl topLevel)
+    {
+        if (topLevel is WindowBaseImpl wb)
+        {
+            // Last-entered output is the "current" one. Walk in reverse
+            // so we prefer the freshest enter.
+            var ids = wb.CurrentOutputIds;
+            for (var i = ids.Count - 1; i >= 0; i--)
+            {
+                if (TryGetScreen(ids[i], out var s))
+                    return s;
+            }
+        }
+        return base.ScreenFromTopLevelCore(topLevel);
+    }
+}
+
+/// <summary>
+/// One screen view-model backed by the most recent snapshot. Reads its
+/// data on every <see cref="Refresh"/> from the owning
+/// <see cref="SnapshotScreensImpl"/>. Identity (the platform handle) is
+/// the worker-side opaque <c>Output</c> instance.
+/// </summary>
+internal sealed class WaylandSnapshotScreen(SnapshotScreensImpl owner, object id)
+    : PlatformScreen(new WaylandScreenHandle(id))
+{
+    internal object Id => id;
+
+    public void Refresh()
+    {
+        var snap = owner.Lookup(id);
+        if (snap is null)
+            return;
+
+        DisplayName = snap.Name ?? snap.Description ?? snap.Model;
+        // Per design: screen-level scale is always 1; per-window scaling
+        // is owned by WSurface (preferred_buffer_scale + wp_fractional_scale).
+        Scaling = 1;
+        Bounds = new PixelRect(snap.LogicalPosition, snap.LogicalSize);
+        // Wayland gives us no panel/strut info; treat the full bounds as
+        // working area (matches Mutter / KWin client expectations).
+        WorkingArea = Bounds;
+    }
+}
+
+/// <summary>
+/// Opaque platform handle for a Wayland screen. The handle's
+/// <see cref="IPlatformHandle.Handle"/> is unused; identity is carried
+/// by the wrapped <see cref="Id"/> reference equality.
+/// </summary>
+internal sealed class WaylandScreenHandle(object id) : IPlatformHandle, IEquatable<WaylandScreenHandle>
+{
+    public object Id { get; } = id;
+    public IntPtr Handle => IntPtr.Zero;
+    public string? HandleDescriptor => "WaylandOutput";
+
+    public bool Equals(WaylandScreenHandle? other) =>
+        other is not null && ReferenceEquals(Id, other.Id);
+
+    public override bool Equals(object? obj) => obj is WaylandScreenHandle h && Equals(h);
+    public override int GetHashCode() => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(Id);
+}
diff --git a/src/Avalonia.Wayland/Screens/WaylandOutputSnapshot.cs b/src/Avalonia.Wayland/Screens/WaylandOutputSnapshot.cs
new file mode 100644
index 0000000000..d44efd91f0
--- /dev/null
+++ b/src/Avalonia.Wayland/Screens/WaylandOutputSnapshot.cs
@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using Avalonia.SourceGenerator;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Screens;
+
+/// <summary>
+/// Immutable per-output snapshot pushed worker → UI on every
+/// add / remove / property change. <see cref="Id"/> is a process-unique
+/// opaque token whose identity is stable for the lifetime of the
+/// underlying wayland <c>wl_output</c> on the worker side, and is reused
+/// in <c>IWSurfaceEventSink.OnSurfaceOutputsChanged</c> snapshots so the
+/// UI thread can correlate per-surface output lists with screens.
+/// </summary>
+[DefinitelyNotARecord]
+internal sealed partial class WaylandOutputSnapshot(
+    object Id,
+    string? Name,
+    string? Description,
+    string? Manufacturer,
+    string? Model,
+    PixelPoint LogicalPosition,
+    PixelSize LogicalSize,
+    int IntegerScale,
+    double RefreshRateHz,
+    WlOutput.SubpixelEnum Subpixel,
+    WlOutput.TransformEnum Transform,
+    PixelSize PhysicalSizeMm);
+
+/// <summary>
+/// Full snapshot of all outputs the compositor currently has bound and
+/// fully initialised (i.e. at least their first <c>done</c> batch — and
+/// matching xdg_output done if applicable — has been received). Pushed
+/// to the UI thread by the worker.
+/// </summary>
+[DefinitelyNotARecord]
+internal sealed partial class WaylandOutputsSnapshot(IReadOnlyList<WaylandOutputSnapshot> Outputs);
diff --git a/src/Avalonia.Wayland/Server/Interop/DrmGbmUnsafeNativeMethods.cs b/src/Avalonia.Wayland/Server/Interop/DrmGbmUnsafeNativeMethods.cs
new file mode 100644
index 0000000000..e893a71802
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Interop/DrmGbmUnsafeNativeMethods.cs
@@ -0,0 +1,118 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Avalonia.Wayland.Server.Interop
+{
+    [Flags]
+    internal enum GbmBoFlags
+    {
+        GBM_BO_USE_SCANOUT = (1 << 0),
+        GBM_BO_USE_RENDERING = (1 << 2),
+        GBM_BO_USE_LINEAR = (1 << 4),
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    internal struct GbmBoHandle
+    {
+        [FieldOffset(0)]
+        public IntPtr Ptr;
+        [FieldOffset(0)]
+        public int S32;
+        [FieldOffset(0)]
+        public uint U32;
+        [FieldOffset(0)]
+        public long S64;
+        [FieldOffset(0)]
+        public ulong U64;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal unsafe struct DrmDevice
+    {
+        public IntPtr* Nodes; // char** — DRM_NODE_MAX sized array
+        public int AvailableNodes; // DRM_NODE_* bitmask
+        public int BusType;
+        public IntPtr BusInfo; // union of pointers
+        public IntPtr DeviceInfo; // union of pointers
+    }
+
+    internal static unsafe class DrmGbmUnsafeNativeMethods
+    {
+        private const string LibGbm = "libgbm.so.1";
+        private const string LibDrm = "libdrm.so.2";
+        private const string LibC = "libc";
+
+        // DRM format constants
+        public static uint DrmFormatCode(char a, char b, char c, char d) =>
+            (uint)a | ((uint)b << 8) | ((uint)c << 16) | ((uint)d << 24);
+
+        public static readonly uint DRM_FORMAT_ARGB8888 = DrmFormatCode('A', 'R', '2', '4');
+        public static readonly uint DRM_FORMAT_XRGB8888 = DrmFormatCode('X', 'R', '2', '4');
+        public const ulong DRM_FORMAT_MOD_INVALID = 0x00ffffffffffffffUL;
+
+        // GBM device
+        [DllImport(LibGbm)]
+        public static extern IntPtr gbm_create_device(int fd);
+
+        [DllImport(LibGbm)]
+        public static extern void gbm_device_destroy(IntPtr gbm);
+
+        // GBM buffer object - basic
+        [DllImport(LibGbm)]
+        public static extern IntPtr gbm_bo_create(IntPtr gbm, uint width, uint height,
+            uint format, GbmBoFlags flags);
+
+        [DllImport(LibGbm)]
+        public static extern IntPtr gbm_bo_create_with_modifiers2(IntPtr gbm, uint width, uint height,
+            uint format, ulong* modifiers, uint count, GbmBoFlags flags);
+
+        [DllImport(LibGbm)]
+        public static extern void gbm_bo_destroy(IntPtr bo);
+
+        // GBM buffer object - properties
+        [DllImport(LibGbm)]
+        public static extern uint gbm_bo_get_width(IntPtr bo);
+
+        [DllImport(LibGbm)]
+        public static extern uint gbm_bo_get_height(IntPtr bo);
+
+        [DllImport(LibGbm)]
+        public static extern uint gbm_bo_get_format(IntPtr bo);
+
+        [DllImport(LibGbm)]
+        public static extern ulong gbm_bo_get_modifier(IntPtr bo);
+
+        [DllImport(LibGbm)]
+        public static extern int gbm_bo_get_plane_count(IntPtr bo);
+
+        [DllImport(LibGbm)]
+        public static extern GbmBoHandle gbm_bo_get_handle_for_plane(IntPtr bo, int plane);
+
+        [DllImport(LibGbm)]
+        public static extern uint gbm_bo_get_stride_for_plane(IntPtr bo, int plane);
+
+        [DllImport(LibGbm)]
+        public static extern uint gbm_bo_get_offset(IntPtr bo, int plane);
+
+        // DRM
+        [DllImport(LibDrm)]
+        public static extern int drmPrimeHandleToFD(int fd, uint handle, uint flags, out int prime_fd);
+
+        [DllImport(LibDrm)]
+        public static extern int drmGetDeviceFromDevId(ulong devId, uint flags, out DrmDevice* device);
+
+        [DllImport(LibDrm)]
+        public static extern void drmFreeDevice(DrmDevice** device);
+
+        public const int DRM_NODE_RENDER = 2;
+
+        // libc
+        [DllImport(LibC)]
+        public static extern int open(string pathname, int flags);
+
+        [DllImport(LibC)]
+        public static extern int close(int fd);
+
+        public const int O_RDWR = 2;
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Interop/Pipe2Stream.cs b/src/Avalonia.Wayland/Server/Interop/Pipe2Stream.cs
new file mode 100644
index 0000000000..9f3cd01936
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Interop/Pipe2Stream.cs
@@ -0,0 +1,32 @@
+using System;
+using System.IO.Pipes;
+using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
+
+namespace Avalonia.Wayland.Server.Interop;
+
+/// <summary>
+/// A <see cref="PipeStream"/> backed by a file descriptor from <c>pipe2()</c>.
+/// Sets <c>O_NONBLOCK</c> to enable async I/O via the .NET pipe infrastructure.
+/// </summary>
+class Pipe2Stream : PipeStream
+{
+    [DllImport("libc", SetLastError = true)]
+    private static extern int fcntl(int fd, int cmd, int arg);
+
+    private const int F_GETFL = 3;
+    private const int F_SETFL = 4;
+    private const int O_NONBLOCK = 0x800; // Linux x86_64
+
+    public Pipe2Stream(int fd, PipeDirection direction)
+        : base(direction, 0)
+    {
+        int flags = fcntl(fd, F_GETFL, 0);
+        if (flags != -1)
+            fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+
+        var handle = new SafePipeHandle((IntPtr)fd, ownsHandle: true);
+        InitializeHandle(handle, isExposed: false, isAsync: true);
+        IsConnected = true;
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Interop/UnsafeNativeMethods.cs b/src/Avalonia.Wayland/Server/Interop/UnsafeNativeMethods.cs
new file mode 100644
index 0000000000..d349bd2ec8
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Interop/UnsafeNativeMethods.cs
@@ -0,0 +1,110 @@
+using System;
+using System.Runtime.InteropServices;
+#pragma warning disable CS8981 // The type name only contains lower-cased ascii characters. Such names may become reserved for the language.
+
+namespace Avalonia.Wayland.Server.Interop;
+
+
+unsafe class UnsafeNativeMethods
+{
+    public struct pollfd
+    {
+        public int fd;
+        public PollEvents events;
+        public PollEvents revents;
+    }
+    
+    
+    
+    
+    public const int O_NONBLOCK = 2048;
+    public const int O_CLOEXEC = 0x80000;
+
+    public const uint MFD_CLOEXEC = 1;
+
+    public const int PROT_READ = 1;
+    public const int PROT_WRITE = 2;
+
+    public const int MAP_SHARED = 1;
+    public const int MAP_PRIVATE = 2;
+
+    [Flags]
+    public enum PollEvents : short
+    {
+        POLLIN = 0x0001,
+        POLLPRI = 0x0002,
+        POLLOUT = 0x0004,
+        POLLERR = 0x0008,
+        POLLHUP = 0x0010,
+        POLLNVAL = 0x0020
+    }
+
+    public enum Errno
+    {
+        EINTR = 4,
+        EAGAIN = 11,
+        EPIPE = 32,
+        ECONNRESET = 104,
+        EPROTO = 71,
+    }
+
+    [DllImport("libc", SetLastError = true)]
+    public static extern int poll(pollfd* fds, IntPtr nfds, int timeout);
+    
+    [DllImport("libc")]
+    public static extern int pipe2(int* fds, int flags);
+
+    [DllImport("libc")]
+    public static extern IntPtr write(int fd, void* buf, IntPtr count);
+
+    [DllImport("libc")]
+    public static extern IntPtr read(int fd, void* buf, IntPtr count);
+    
+    [DllImport("libc")]
+    public static extern int memfd_create(string name, uint flags);
+    
+    [DllImport("libc", SetLastError = true)]
+    public static extern int ftruncate(int fd, IntPtr length);
+
+    [DllImport("libc")]
+    public static extern void close(int fd);
+    
+    [DllImport("libc", EntryPoint = "mmap", SetLastError = true)]
+    public static extern IntPtr mmap(IntPtr addr, IntPtr length, int prot, int flags,
+        int fd, IntPtr offset);
+    
+    [DllImport("libc", EntryPoint = "munmap", SetLastError = true)]
+    public static extern int munmap(IntPtr addr, IntPtr length);
+
+    // libwayland-cursor.so.0
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct wl_cursor_image
+    {
+        public uint width;
+        public uint height;
+        public uint hotspot_x;
+        public uint hotspot_y;
+        public uint delay;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct wl_cursor
+    {
+        public uint image_count;
+        public wl_cursor_image** images;
+        public byte* name;
+    }
+
+    [DllImport("libwayland-cursor.so.0")]
+    public static extern IntPtr wl_cursor_theme_load(string? name, int size, IntPtr shm);
+
+    [DllImport("libwayland-cursor.so.0")]
+    public static extern void wl_cursor_theme_destroy(IntPtr theme);
+
+    [DllImport("libwayland-cursor.so.0")]
+    public static extern wl_cursor* wl_cursor_theme_get_cursor(IntPtr theme, string name);
+
+    [DllImport("libwayland-cursor.so.0")]
+    public static extern IntPtr wl_cursor_image_get_buffer(wl_cursor_image* image);
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Server/Interop/WakeupFd.cs b/src/Avalonia.Wayland/Server/Interop/WakeupFd.cs
new file mode 100644
index 0000000000..67afd24aa3
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Interop/WakeupFd.cs
@@ -0,0 +1,70 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Avalonia.Wayland.Server.Interop;
+using static UnsafeNativeMethods;
+
+unsafe class WakeupFd : System.IDisposable
+{
+    private readonly int _read;
+    private readonly int _write;
+    private readonly object _lock = new();
+    private bool _signaled;
+    private bool _disposed;
+
+    public int PollFd => _read;
+
+    public WakeupFd()
+    {
+        int* fds = stackalloc int[2];
+        if (pipe2(fds, O_NONBLOCK | O_CLOEXEC) != 0)
+            throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error());
+        _read = fds[0];
+        _write = fds[1];
+    }
+
+    private static readonly void* s_readBuf = (void*)Marshal.AllocHGlobal(1024);
+    public void Clear()
+    {
+        lock (_lock)
+        {
+            if(!_signaled)
+                return;
+            var readNow = read(_read, s_readBuf, 1);
+            Debug.Assert(readNow <= 1);
+            _signaled = false;
+        }
+    }
+
+    public void Set()
+    {
+        lock (_lock)
+        {
+            if(_signaled)
+                return;
+            byte b = 0;
+            write(_write, &b, 1);
+            _signaled = true;
+        }
+    }
+
+    ~WakeupFd() => DisposeCore();
+
+    public void Dispose()
+    {
+        DisposeCore();
+        System.GC.SuppressFinalize(this);
+    }
+
+    private void DisposeCore()
+    {
+        lock (_lock)
+        {
+            if (_disposed)
+                return;
+            _disposed = true;
+            close(_read);
+            close(_write);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Server/Interop/WaylandConnection.cs b/src/Avalonia.Wayland/Server/Interop/WaylandConnection.cs
new file mode 100644
index 0000000000..22691dd053
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Interop/WaylandConnection.cs
@@ -0,0 +1,177 @@
+using System;
+using System.Runtime.InteropServices;
+using NWayland;
+using NWayland.Protocols.Wayland;
+using static Avalonia.Wayland.Server.Interop.UnsafeNativeMethods;
+namespace Avalonia.Wayland.Server.Interop;
+
+class WaylandConnection : IDisposable
+{
+    public WlDisplay Display { get; private set; }
+    public WlEventQueue Queue { get; private set; }
+    public bool IsConnected { get; private set; } = true;
+    private readonly bool _ownsDisplay;
+    private readonly int _fd;
+    
+    public WaylandConnection(string? path)
+    {
+        _ownsDisplay = true;
+        Display = WlDisplay.Connect(path);
+        Queue = Display.CreateEventQueue();
+        _fd = Display.GetFd();
+    }
+
+    public WaylandConnection(int fd)
+    {
+        _ownsDisplay = true;
+        Display = WlDisplay.ConnectToFd(fd);
+        Queue = Display.CreateEventQueue();
+        _fd = Display.GetFd();
+    }
+    
+    public WaylandConnection(WlDisplay foreignDisplay)
+    {
+        Display = foreignDisplay;
+        Queue = Display.CreateEventQueue();
+        _fd = Display.GetFd();
+    }
+
+    public void Dispose()
+    {
+        IsConnected = false;
+        Queue.Dispose();
+        if (_ownsDisplay)
+            Display.Dispose();
+    }
+
+        
+    public void DispatchQueueOrWakeup(int wakeupFd)
+    {
+	    DispatchQueueOrWakeup(Queue, wakeupFd);
+    }
+
+
+    unsafe void DoPoll(Span<pollfd> fds)
+    {
+        while (true)
+        {
+            int pollRet;
+            fixed (pollfd* fdsPtr = fds)
+                pollRet = poll(fdsPtr, new IntPtr(fds.Length), -1);
+            if (pollRet <= 0)
+            {
+                var errno = Marshal.GetLastPInvokeError();
+                // we need to check for this because poll ignores SA_RESTART set by .NET runtime
+                if (errno == (int)Errno.EINTR)
+                    continue;
+                
+                // Release the display read lock
+                Display.CancelRead();
+                // This is quite likely a non-recoverable error
+                throw new AvaloniaWaylandPollException();
+            }
+            return;
+        }
+    }
+
+    bool FlushDisplay(out Errno flushError)
+    {
+        var flushRet = Display.Flush();
+        if (flushRet >= 0) // Successful flush
+        {
+            flushError = default;
+            return true;
+        }
+        
+        flushError = (Errno)Marshal.GetLastPInvokeError();
+
+        if (flushError == Errno.EAGAIN)
+        {
+            // Not an error, just network buffers being full. We need to read our side of the socket and/or wait
+            // for the compositor to process the previous requests, so report success
+            flushError = default;
+            return true;
+        }
+        
+        return false;
+
+    }
+    
+    public enum DispatchResult
+    {
+        Dispatched,
+        Wakeup,
+        ConnectionReset
+    }
+
+    bool IsConnectionReset(Errno errno) => errno is Errno.EPIPE or Errno.ECONNRESET;
+
+    bool ClassifyErrorOrThrow(Errno errno, out DispatchResult result)
+    {
+        if (IsConnectionReset(errno))
+        {
+            result = DispatchResult.ConnectionReset;
+            return true;
+        }
+
+        if (errno == Errno.EPROTO)
+        {
+            throw new AvaloniaWaylandProtocolErrorException();
+        }
+
+        result = default;
+        return false;
+    }
+    
+    public unsafe DispatchResult DispatchQueueOrWakeup(WlEventQueue queue, int wakeupFd)
+    {
+        // This initiates the race of sorts for who will have to use the wayland socket
+        if (Queue.PrepareRead() == -1)
+        {
+            // Other thread has won the race and read from the display, we can safely dispatch pending events
+            queue.DispatchPending();
+            return DispatchResult.Dispatched;
+        }
+        
+        // We won the race and are now responsible to drive libwayland's flush/poll/read cycle
+        
+        
+        // First flush any pending data to the compositor
+        if (!FlushDisplay(out var flushError))
+        {
+            // If somebody wants to read errors they should call Display.Dispatch() 
+            Display.CancelRead();
+            if (ClassifyErrorOrThrow(flushError, out var dispatchResult))
+                return dispatchResult;
+            
+            throw new AvaloniaWaylandFlushException(flushError);
+        }
+
+
+        Span<pollfd> fds = stackalloc pollfd[]
+        {
+            new pollfd() { fd = _fd, events = PollEvents.POLLIN },
+            new pollfd() { fd = wakeupFd, events = PollEvents.POLLIN },
+        };
+        DoPoll(fds);
+
+        if (fds[0].revents == default)
+        {
+            // ppoll got woken up by the wakeup fd
+            Display.CancelRead();
+            return DispatchResult.Wakeup;
+        }
+
+        // Actual read call
+        if(Display.ReadEvents() == -1)
+        {
+            var errno = (Errno)Marshal.GetLastPInvokeError();
+            if (ClassifyErrorOrThrow(errno, out var dispatchResult))
+                return dispatchResult;
+            throw new AvaloniaWaylandReadException(errno);
+        }
+
+        Queue.DispatchPending();
+        return DispatchResult.Dispatched;
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Server/Interop/WaylandEglNativeMethods.cs b/src/Avalonia.Wayland/Server/Interop/WaylandEglNativeMethods.cs
new file mode 100644
index 0000000000..d8085d0f96
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Interop/WaylandEglNativeMethods.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Avalonia.Wayland.Server.Interop;
+
+internal static class WaylandEglNativeMethods
+{
+    private const string LibWaylandEgl = "libwayland-egl.so.1";
+
+    /// <summary>
+    /// Allocates a <c>wl_egl_window</c> wrapper around <paramref name="surface"/>
+    /// (a <c>wl_surface*</c>) at the given pixel size. The returned handle is
+    /// passed to <c>eglCreateWindowSurface</c> as the native window argument and
+    /// is owned by the caller.
+    /// </summary>
+    [DllImport(LibWaylandEgl)]
+    public static extern IntPtr wl_egl_window_create(IntPtr surface, int width, int height);
+
+    [DllImport(LibWaylandEgl)]
+    public static extern void wl_egl_window_destroy(IntPtr eglWindow);
+
+    /// <summary>
+    /// Resizes the <c>wl_egl_window</c>. The driver picks the new size up on the
+    /// next <c>eglSwapBuffers</c>; <paramref name="dx"/>/<paramref name="dy"/>
+    /// are reserved for sub-surface positioning and are 0 for our toplevel use.
+    /// </summary>
+    [DllImport(LibWaylandEgl)]
+    public static extern void wl_egl_window_resize(IntPtr eglWindow, int width, int height, int dx, int dy);
+}
diff --git a/src/Avalonia.Wayland/Server/Interop/XkbCommonNativeMethods.cs b/src/Avalonia.Wayland/Server/Interop/XkbCommonNativeMethods.cs
new file mode 100644
index 0000000000..f3c382f66f
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Interop/XkbCommonNativeMethods.cs
@@ -0,0 +1,110 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Avalonia.Wayland.Server.Interop;
+
+static unsafe class XkbCommonNativeMethods
+{
+    private const string LibXkbCommon = "libxkbcommon.so.0";
+
+    // xkb_context
+
+    [DllImport(LibXkbCommon)]
+    public static extern IntPtr xkb_context_new(int flags);
+
+    [DllImport(LibXkbCommon)]
+    public static extern void xkb_context_unref(IntPtr context);
+
+    // xkb_keymap
+
+    [DllImport(LibXkbCommon)]
+    public static extern IntPtr xkb_keymap_new_from_buffer(
+        IntPtr context, byte* buffer, IntPtr length, int format, int flags);
+
+    [DllImport(LibXkbCommon)]
+    public static extern void xkb_keymap_unref(IntPtr keymap);
+
+    [DllImport(LibXkbCommon)]
+    public static extern uint xkb_keymap_num_layouts(IntPtr keymap);
+
+    [DllImport(LibXkbCommon)]
+    public static extern int xkb_keymap_key_get_syms_by_level(
+        IntPtr keymap, uint key, uint layout, uint level, out uint* symsOut);
+
+    // xkb_state
+
+    [DllImport(LibXkbCommon)]
+    public static extern IntPtr xkb_state_new(IntPtr keymap);
+
+    [DllImport(LibXkbCommon)]
+    public static extern void xkb_state_unref(IntPtr state);
+
+    [DllImport(LibXkbCommon)]
+    public static extern uint xkb_state_key_get_one_sym(IntPtr state, uint key);
+
+    [DllImport(LibXkbCommon)]
+    public static extern int xkb_state_key_get_utf8(
+        IntPtr state, uint key, byte* buffer, IntPtr size);
+
+    [DllImport(LibXkbCommon)]
+    public static extern int xkb_state_update_mask(
+        IntPtr state,
+        uint modsDepressed, uint modsLatched, uint modsLocked,
+        uint layoutDepressed, uint layoutLatched, uint layoutLocked);
+
+    // Constants
+    public const int XKB_CONTEXT_NO_FLAGS = 0;
+    public const int XKB_KEYMAP_FORMAT_TEXT_V1 = 1;
+    public const int XKB_KEYMAP_COMPILE_NO_FLAGS = 0;
+
+    // mmap constants
+    public const int PROT_READ = 1;
+    public const int MAP_PRIVATE = 2;
+
+    // xkb_compose
+
+    [DllImport(LibXkbCommon)]
+    public static extern IntPtr xkb_compose_table_new_from_locale(
+        IntPtr context,
+        [MarshalAs(UnmanagedType.LPUTF8Str)] string locale,
+        int flags);
+
+    [DllImport(LibXkbCommon)]
+    public static extern void xkb_compose_table_unref(IntPtr table);
+
+    [DllImport(LibXkbCommon)]
+    public static extern IntPtr xkb_compose_state_new(IntPtr table, int flags);
+
+    [DllImport(LibXkbCommon)]
+    public static extern void xkb_compose_state_unref(IntPtr state);
+
+    [DllImport(LibXkbCommon)]
+    public static extern int xkb_compose_state_feed(IntPtr state, uint keysym);
+
+    [DllImport(LibXkbCommon)]
+    public static extern int xkb_compose_state_get_status(IntPtr state);
+
+    [DllImport(LibXkbCommon)]
+    public static extern uint xkb_compose_state_get_one_sym(IntPtr state);
+
+    [DllImport(LibXkbCommon)]
+    public static extern int xkb_compose_state_get_utf8(
+        IntPtr state, byte* buffer, IntPtr size);
+
+    [DllImport(LibXkbCommon)]
+    public static extern void xkb_compose_state_reset(IntPtr state);
+
+    // Compose constants
+    public const int XKB_COMPOSE_COMPILE_NO_FLAGS = 0;
+    public const int XKB_COMPOSE_STATE_NO_FLAGS = 0;
+
+    // xkb_compose_status
+    public const int XKB_COMPOSE_NOTHING = 0;
+    public const int XKB_COMPOSE_COMPOSING = 1;
+    public const int XKB_COMPOSE_COMPOSED = 2;
+    public const int XKB_COMPOSE_CANCELLED = 3;
+
+    // xkb_compose_feed_result
+    public const int XKB_COMPOSE_FEED_IGNORED = 0;
+    public const int XKB_COMPOSE_FEED_ACCEPTED = 1;
+}
diff --git a/src/Avalonia.Wayland/Server/Persistent/DecorationMode.cs b/src/Avalonia.Wayland/Server/Persistent/DecorationMode.cs
new file mode 100644
index 0000000000..5268baccab
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/DecorationMode.cs
@@ -0,0 +1,15 @@
+namespace Avalonia.Wayland.Server.Persistent;
+
+/// <summary>
+/// Effective xdg-decoration-v1 mode for a toplevel. Mirrors
+/// <c>zxdg_toplevel_decoration_v1.mode</c> but is decoupled from the
+/// NWayland type so the cross-thread sink interface doesn't pull in a
+/// protocol-bindings reference on the UI side.
+/// </summary>
+enum DecorationMode
+{
+    /// <summary>Client draws its own chrome.</summary>
+    ClientSide ,
+    /// <summary>Compositor draws the chrome.</summary>
+    ServerSide
+}
diff --git a/src/Avalonia.Wayland/Server/Persistent/IPersistentObject.cs b/src/Avalonia.Wayland/Server/Persistent/IPersistentObject.cs
new file mode 100644
index 0000000000..8af6b06bd5
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/IPersistentObject.cs
@@ -0,0 +1,10 @@
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Transient;
+
+namespace Avalonia.Wayland.Server.Persistent;
+
+interface IPersistentWaylandObject
+{
+    void OnConnected(WaylandConnection connection, WaylandGlobals globals);
+    void OnDisconnected();
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Server/Persistent/IWSurface.cs b/src/Avalonia.Wayland/Server/Persistent/IWSurface.cs
new file mode 100644
index 0000000000..94a6d1b009
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/IWSurface.cs
@@ -0,0 +1,61 @@
+using Avalonia.Input;
+using Avalonia.Input.TextInput;
+using Avalonia.SourceGenerator;
+using Avalonia.Wayland.Server.Transient;
+
+namespace Avalonia.Wayland.Server.Persistent;
+
+/// <summary>
+/// UI→worker proxy interface for the cross-thread surface API common to all WSurfaces.
+/// </summary>
+[GenerateCrossThreadProxy(
+    typeof(WaylandDispatchPriority),
+    "Avalonia.Wayland.Server.WaylandDispatchPriority.Normal",
+    GeneratedClassName = "WSurfaceProxy")]
+internal interface IWSurface
+{
+    /// <summary>Tears down all wayland-side resources and unregisters this surface.</summary>
+    void Disconnect();
+
+    /// <summary>
+    /// Sets the cursor and refreshes the pointer cursor if this surface is focused.
+    /// <c>null</c> falls back to the default arrow cursor.
+    /// </summary>
+    void SetCursor(IWaylandCursor? cursor);
+
+    /// <summary>
+    /// Registers the UI-thread sink to receive worker→UI text-input v3 events
+    /// (preedit/commit/delete-surrounding). Idempotent. Does nothing on
+    /// compositors that lack zwp_text_input_manager_v3.
+    /// </summary>
+    void RegisterTextInputSink(Avalonia.Wayland.Server.Transient.WaylandTextInputV3EventsProxy sink);
+
+    /// <summary>
+    /// Toggles the text-input client. Sets the compose-key gate
+    /// (XKB-compose runs only when a client is attached) and, when v3 is
+    /// available, drives enable/disable on all entered seats. The
+    /// <paramref name="sessionToken"/> stamps every subsequent worker→UI
+    /// IME callback so the UI broker can drop callbacks emitted for a
+    /// previous client.
+    /// </summary>
+    void SetTextInputActive(bool hasClient, bool supportsPreedit, bool supportsSurroundingText, int sessionToken);
+
+    /// <summary>Aborts any in-flight IME composition (disable+commit on entered seats).</summary>
+    void AbortTextInputComposition();
+
+    /// <summary>Updates the IME cursor rectangle (logical, surface-local coordinates).</summary>
+    void SetTextInputCursorRect(Rect rect);
+
+    /// <summary>Updates the IME content-type (hint+purpose).</summary>
+    void SetTextInputOptions(TextInputOptions options);
+
+    /// <summary>
+    /// Updates surrounding text + selection. <paramref name="cursorChar"/> /
+    /// <paramref name="anchorChar"/> are UTF-16 code-unit offsets into the
+    /// supplied string (.NET-native indexing).
+    /// </summary>
+    void SetTextInputSurroundingText(string text, int cursorChar, int anchorChar);
+
+    /// <summary>Resets the IME state (clears any pending preedit/commit).</summary>
+    void ResetTextInput();
+}
diff --git a/src/Avalonia.Wayland/Server/Persistent/IWSurfaceEventSink.cs b/src/Avalonia.Wayland/Server/Persistent/IWSurfaceEventSink.cs
new file mode 100644
index 0000000000..64cbc447eb
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/IWSurfaceEventSink.cs
@@ -0,0 +1,105 @@
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.SourceGenerator;
+using Avalonia.Threading;
+using Avalonia.Wayland.Server;
+using Avalonia.Wayland.Server.Transient.Clipboard;
+
+namespace Avalonia.Wayland.Server.Persistent;
+
+/// <summary>
+/// Worker → UI sink for surface-role-agnostic events (input, scale changes,
+/// keyboard focus loss, drag-and-drop). Both top-levels and popups receive
+/// these. Surface-role-specific events (xdg_toplevel configure/close,
+/// xdg_popup configure/done) live on the derived sink interfaces.
+/// </summary>
+[GenerateCrossThreadProxy(
+    typeof(DispatcherPriority),
+    "default",
+    GeneratedClassName = "WSurfaceEventSinkProxy")]
+internal interface IWSurfaceEventSink
+{
+    void OnPointerEnter(ulong timestamp, uint serial, Point position);
+    void OnPointerLeave(uint serial);
+    void OnPointerMotion(ulong timestamp, Point position, RawInputModifiers modifiers);
+    void OnPointerButton(ulong timestamp, uint serial, RawPointerEventType type, RawInputModifiers modifiers, Point position, object? platformCookie);
+    void OnPointerAxis(ulong timestamp, Vector delta, RawInputModifiers modifiers, Point position);
+
+    void OnTouchDown(ulong timestamp, int touchId, Point position, object? platformCookie);
+    void OnTouchMove(ulong timestamp, int touchId, Point position);
+    void OnTouchUp(ulong timestamp, int touchId, Point position);
+    void OnTouchCancel(int touchId, Point position);
+
+    void OnKeyDown(ulong timestamp, Key key, RawInputModifiers modifiers, PhysicalKey physicalKey, string? keySymbol);
+    void OnKeyUp(ulong timestamp, Key key, RawInputModifiers modifiers, PhysicalKey physicalKey, string? keySymbol);
+    void OnKeyboardLeave();
+    void OnKeyRepeatInfo(int rate, int delay);
+
+    void OnDragEnter(Point position, string[] mimeTypes, WaylandOfferCookie offerCookie, DragDropEffects sourceEffects, RawInputModifiers modifiers);
+    void OnDragMotion(Point position, RawInputModifiers modifiers);
+    void OnDragLeave();
+    void OnDrop(Point position, RawInputModifiers modifiers);
+
+    void OnScaleChanged(double scale);
+
+    /// <summary>
+    /// Pushed from the worker whenever this surface's set of
+    /// <c>wl_output</c> enters / leaves changes (also on disconnect).
+    /// The list contains the opaque identity objects used as
+    /// <see cref="Avalonia.Wayland.Screens.WaylandOutputSnapshot.Id"/>;
+    /// ordering is insertion (last-entered last), which the UI side uses
+    /// to pick "the" screen for the window.
+    /// </summary>
+    void OnSurfaceOutputsChanged(System.Collections.Generic.IReadOnlyList<object> outputIds);
+}
+
+/// <summary>
+/// Worker → UI sink for xdg_toplevel-specific events. Implemented on the UI
+/// thread by <see cref="WindowImpl.Sink"/>; the worker holds a generated
+/// <see cref="WXdgTopLevelEventSinkProxy"/> that marshals every call to the
+/// UI dispatcher.
+/// </summary>
+[GenerateCrossThreadProxy(
+    typeof(DispatcherPriority),
+    "default",
+    GeneratedClassName = "WXdgTopLevelEventSinkProxy")]
+internal interface IWXdgTopLevelEventSink : IWSurfaceEventSink
+{
+    void OnConfigure(XdgConfigureBatch batch);
+    void OnClose();
+    /// <summary>
+    /// The compositor changed the effective decoration mode for this
+    /// toplevel via <c>zxdg_toplevel_decoration_v1.configure</c>.
+    /// Delivered <em>after</em> the initial-handshake mode (which the
+    /// UI already sees via <see cref="XdgConfigureBatch.InitialDecorationMode"/>),
+    /// for every subsequent <c>decoration.configure</c> event. The
+    /// client is required by the protocol to obey the new mode.
+    /// </summary>
+    void OnDecorationModeChanged(DecorationMode mode);
+}
+
+/// <summary>
+/// Worker → UI sink for xdg_popup-specific events. Implemented on the UI
+/// thread by <c>PopupImpl.Sink</c>; the worker holds a generated
+/// <c>WXdgPopupEventSinkProxy</c> that marshals every call to the UI
+/// dispatcher.
+/// </summary>
+[GenerateCrossThreadProxy(
+    typeof(DispatcherPriority),
+    "default",
+    GeneratedClassName = "WXdgPopupEventSinkProxy")]
+internal interface IWXdgPopupEventSink : IWSurfaceEventSink
+{
+    /// <summary>
+    /// Compositor delivered a new popup configure (x, y, width, height),
+    /// sealed by the wrapping xdg_surface.configure(serial).
+    /// </summary>
+    void OnPopupConfigure(XdgPopupConfigureBatch batch);
+
+    /// <summary>
+    /// Compositor dismissed the popup (xdg_popup.popup_done). The popup
+    /// must be torn down; after this no further events arrive.
+    /// </summary>
+    void OnPopupDone();
+}
+
diff --git a/src/Avalonia.Wayland/Server/Persistent/IWXdgTopLevel.cs b/src/Avalonia.Wayland/Server/Persistent/IWXdgTopLevel.cs
new file mode 100644
index 0000000000..3be8276733
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/IWXdgTopLevel.cs
@@ -0,0 +1,90 @@
+using Avalonia.SourceGenerator;
+using NWayland.Protocols.XdgShell;
+namespace Avalonia.Wayland.Server.Persistent;
+
+/// <summary>
+/// UI→worker proxy interface for an xdg_surface (the part used from the UI thread).
+/// </summary>
+[GenerateCrossThreadProxy(
+    typeof(WaylandDispatchPriority),
+    "Avalonia.Wayland.Server.WaylandDispatchPriority.Normal",
+    GeneratedClassName = "WXdgShellSurfaceProxy")]
+internal interface IWXdgShellSurface : IWSurface
+{
+    void SetShadowExtents(Thickness extents);
+    void SetPendingAckSerial(uint serial);
+}
+
+/// <summary>
+/// UI→worker proxy interface for an xdg_toplevel.
+/// </summary>
+[GenerateCrossThreadProxy(
+    typeof(WaylandDispatchPriority),
+    "Avalonia.Wayland.Server.WaylandDispatchPriority.Normal",
+    GeneratedClassName = "WXdgTopLevelProxy")]
+internal interface IWXdgTopLevel : IWXdgShellSurface
+{
+    void SetMaximized();
+    void UnsetMaximized();
+    void SetFullscreen();
+    void UnsetFullscreen();
+    void SetMinimized();
+    void SetParent(IWXdgTopLevel? parent);
+    void Move(object? platformCookie);
+    void Resize(object? platformCookie, XdgToplevel.ResizeEdgeEnum edge);
+    /// <summary>
+    /// Sets the toplevel's preferred minimum and maximum size.
+    /// A <c>null</c> in either argument means "no constraint" for that
+    /// bound (the worker forwards 0 to the compositor, which is the
+    /// protocol-defined "unconstrained" value). Values are clamped
+    /// to ≥1.
+    /// </summary>
+    void SetMinMaxSize(Size? minSize, Size? maxSize);
+
+    /// <summary>
+    /// Sets the toplevel's title. The compositor may display this in
+    /// window decorations, task bars, etc. A <c>null</c> or empty value
+    /// clears the title. The worker caches the value so it survives
+    /// compositor reconnects.
+    /// </summary>
+    void SetTitle(string? title);
+
+    /// <summary>
+    /// Tear down the worker's <c>zxdg_toplevel_decoration_v1</c> object
+    /// (if any). Switches the compositor back to "client-side
+    /// decorations on next commit" per the v1 spec. Also latches the
+    /// worker into sticky-CSD mode: on reconnect, no new decoration
+    /// object will be created for this toplevel — matches Qt's v1
+    /// strategy where SSD cannot be re-enabled on a mapped toplevel
+    /// (v1 forbids creating a decoration object after the toplevel has
+    /// committed a buffer). Idempotent.
+    /// </summary>
+    void DestroyDecoration();
+    /// <summary>
+    /// Synchronously creates an xdg-foreign-v2 export of this toplevel; the returned
+    /// façade's HandleTask completes asynchronously when the compositor delivers the
+    /// handle event. Returns null if the exporter global isn't bound or the toplevel
+    /// isn't currently mapped. Generated proxy auto-wraps the result into Task&lt;...&gt;.
+    /// </summary>
+    IWaylandXdgTopLevelExport? ExportToplevel();
+}
+
+/// <summary>
+/// UI→worker proxy interface for an xdg_popup. The current
+/// <see cref="XdgPopupPositionerParams"/> are configured before the surface
+/// connects (or via re-positioner reconfigure later); the worker rebuilds
+/// the protocol-level <c>xdg_positioner</c> from these on every connect.
+/// </summary>
+[GenerateCrossThreadProxy(
+    typeof(WaylandDispatchPriority),
+    "Avalonia.Wayland.Server.WaylandDispatchPriority.Normal",
+    GeneratedClassName = "WXdgPopupProxy")]
+internal interface IWXdgPopup : IWXdgShellSurface
+{
+    /// <summary>
+    /// Updates the cached positioner parameters used to (re-)create the
+    /// xdg_popup on connect. Called from the UI thread before the popup is
+    /// shown for the first time, and when reposition is invoked.
+    /// </summary>
+    void UpdatePositioner(XdgPopupPositionerParams positioner);
+}
diff --git a/src/Avalonia.Wayland/Server/Persistent/IWaylandCursor.cs b/src/Avalonia.Wayland/Server/Persistent/IWaylandCursor.cs
new file mode 100644
index 0000000000..9a5c64252b
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/IWaylandCursor.cs
@@ -0,0 +1,19 @@
+using Avalonia.SourceGenerator;
+
+namespace Avalonia.Wayland.Server.Persistent;
+
+/// <summary>
+/// UI→worker proxy interface for a pointer cursor. The UI thread only ever holds the generated
+/// <c>WaylandCursorProxy</c> wrapper and never the worker-side <see cref="WaylandCursor"/>.
+/// Passing the wrapper to <see cref="IWSurface.SetCursor(IWaylandCursor)"/> auto-unwraps it to the
+/// real worker object on the worker thread.
+/// </summary>
+[GenerateCrossThreadProxy(
+    typeof(WaylandDispatchPriority),
+    "Avalonia.Wayland.Server.WaylandDispatchPriority.Normal",
+    GeneratedClassName = "WaylandCursorProxy")]
+internal interface IWaylandCursor
+{
+    /// <summary>Releases any worker-side resources held by this cursor.</summary>
+    void Destroy();
+}
diff --git a/src/Avalonia.Wayland/Server/Persistent/WSurface.cs b/src/Avalonia.Wayland/Server/Persistent/WSurface.cs
new file mode 100644
index 0000000000..0fd1745864
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/WSurface.cs
@@ -0,0 +1,1033 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Avalonia.Input;
+using Avalonia.Input.TextInput;
+using Avalonia.Platform;
+using Avalonia.Platform.Surfaces;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Transient;
+using Avalonia.Wayland.Server.Transient.Rendering;
+using NWayland.Protocols.FractionalScaleV1;
+using NWayland.Protocols.Viewporter;
+using NWayland.Protocols.Wayland;
+using NWayland.Protocols.XdgDecorationUnstableV1;
+using NWayland.Protocols.XdgShell;
+
+namespace Avalonia.Wayland.Server.Persistent;
+
+class WSurface : IPersistentWaylandObject, IWSurface, IWaylandFramebufferSurface
+{
+    protected WaylandWorker Worker { get; }
+    protected WaylandConnection? Connection { get; private set; }
+    public WaylandGlobals? Globals { get; private set; }
+    public WlSurface? WlSurface { get; private set; }
+    protected WpFractionalScaleV1? FractionalScale { get; private set; }
+    protected WpViewport? Viewport { get; private set; }
+    protected int? LastPreferredBufferScale { get; private set; }
+    protected double? PreferredFractionalScale { get; private set; }
+    protected List<WaylandOutputsTracker.Output> Outputs  { get; } = new();
+    private WlCallback? _frameCallback;
+    private double _currentScale = 1;
+    private const double ScaleEpsilon = 1e-6;
+    private readonly List<IDisposable> _activeRenderTargets = new();
+
+    public bool HasFractionalScaling => FractionalScale != null && Viewport != null;
+    public WlDisplay? CurrentDisplay => Connection?.Display;
+    internal double CurrentScale => _currentScale;
+
+    public WSurface(WaylandWorker worker)
+    {
+        Worker = worker;
+        worker.PostOob(() => worker.RegisterPersistentObject(this));
+    }
+
+    /// <summary>
+    /// Destroys this surface and unregisters it from the worker.
+    /// Called on the Wayland thread when the UI thread disposes the window.
+    /// </summary>
+    public void Disconnect()
+    {
+        Worker.UnregisterPersistentObject(this);
+    }
+
+    /// <summary>
+    /// Whether this surface currently has an active text input client.
+    /// Set via message from the UI thread, read on the Wayland thread to gate compose processing.
+    /// </summary>
+    internal bool HasTextInputClient { get; private set; }
+
+    private WaylandTextInputV3EventsProxy? _textInputSink;
+
+    /// <summary>
+    /// Session token last received via <see cref="SetTextInputActive"/>.
+    /// Stamped on every worker→UI IME callback so the UI broker can drop
+    /// callbacks belonging to a previous client (see
+    /// <c>WaylandTextInputMethod._clientEpoch</c>).
+    /// </summary>
+    internal int TextInputSessionToken { get; private set; }
+
+    private WaylandTextInputV3? TextInputV3 => Globals?.InputDispatcher?.TextInputV3;
+
+    /// <summary>
+    /// Cursor currently requested for this surface, or <c>null</c> for the default arrow. Lives on
+    /// the worker thread — updated via <see cref="SetCursor"/>, consumed by the
+    /// <see cref="WaylandInputDispatcher"/> when refreshing the pointer cursor.
+    /// </summary>
+    internal WaylandCursor? CurrentCursor { get; private set; }
+
+    public virtual void SetCursor(IWaylandCursor? cursor)
+    {
+        // The proxy auto-unwraps to the real worker-side object before reaching us.
+        CurrentCursor = (WaylandCursor?)cursor;
+        Globals?.InputDispatcher?.NotifyCursorChanged(this);
+    }
+
+    public virtual void RegisterTextInputSink(WaylandTextInputV3EventsProxy sink)
+    {
+        _textInputSink = sink;
+        TextInputV3?.RegisterSurface(this, sink);
+    }
+
+    public virtual void SetTextInputActive(bool hasClient, bool supportsPreedit, bool supportsSurroundingText, int sessionToken)
+    {
+        HasTextInputClient = hasClient;
+        TextInputSessionToken = sessionToken;
+        if (_textInputSink is { } sink && TextInputV3 is { } v3)
+        {
+            // RegisterSurface is idempotent and safe to re-issue here in case
+            // the V3 facade only became available after the broker registered.
+            v3.RegisterSurface(this, sink);
+            v3.AbortComposition(this);
+            v3.SetActive(this, hasClient, supportsPreedit, supportsSurroundingText);
+        }
+    }
+
+    public virtual void AbortTextInputComposition() => TextInputV3?.AbortComposition(this);
+
+    public virtual void SetTextInputCursorRect(Rect rect) => TextInputV3?.SetCursorRect(this, rect);
+
+    public virtual void SetTextInputOptions(TextInputOptions options) => TextInputV3?.SetOptions(this, options);
+
+    public virtual void SetTextInputSurroundingText(string text, int cursorChar, int anchorChar) =>
+        TextInputV3?.SetSurroundingText(this, text, cursorChar, anchorChar);
+
+    public virtual void ResetTextInput() => TextInputV3?.Reset(this);
+
+    public virtual void OnConnected(WaylandConnection connection, WaylandGlobals globals)
+    {
+        Connection = connection;
+        Globals = globals;
+        WlSurface = Globals.WlCompositor.CreateSurface(new Listener(this));
+
+        if (globals.HasFractionalScaling)
+        {
+            FractionalScale = globals.FractionalScaleManager!.GetFractionalScale(
+                WlSurface, new FractionalScaleListener(this), connection.Queue);
+            Viewport = globals.Viewporter!.GetViewport(WlSurface);
+        }
+    }
+
+    private IPlatformRenderSurface[]? _renderSurfaces;
+    private object? _renderSurfacesGraphicsKey;
+
+    /// <summary>
+    /// Render surfaces matching the currently active platform graphics
+    /// backend. Re-resolved when the backend changes (e.g. after a
+    /// disconnect/reconnect re-binds globals and possibly initializes a
+    /// different EGL platform). The framebuffer surface is always
+    /// included as a software fallback.
+    /// </summary>
+    public IPlatformRenderSurface[] RenderSurfaces
+    {
+        get
+        {
+            var graphics = Worker.PlatformGraphics.CurrentGraphics;
+            if (_renderSurfaces != null && ReferenceEquals(_renderSurfacesGraphicsKey, graphics))
+                return _renderSurfaces;
+
+            _renderSurfacesGraphicsKey = graphics;
+            _renderSurfaces = graphics != null
+                ? [graphics.CreateRenderSurface(this), new WaylandFramebuffer(this)]
+                : [new WaylandFramebuffer(this)];
+            return _renderSurfaces;
+        }
+    }
+
+    public bool IsFrameCallbackPending => _frameCallback != null;
+
+    public virtual PlatformRenderTargetState State =>
+        (Globals != null && WlSurface != null && !IsFrameCallbackPending) ? PlatformRenderTargetState.Ready : default;
+
+    public void RegisterRenderTarget(IDisposable renderTarget) => _activeRenderTargets.Add(renderTarget);
+    public void UnregisterRenderTarget(IDisposable renderTarget) => _activeRenderTargets.Remove(renderTarget);
+
+    // Toplevels/popups attach one buffer per frame inside the throttled render loop, which flushes
+    // naturally, so no eager roundtrip is needed (it would stall the render loop).
+    public bool EnforceBufferCreationRoundtrip => false;
+
+    protected virtual void OnOutputsChanged()
+    {
+        RecomputeScale();
+    }
+
+    /// <summary>
+    /// Recomputes the desired scale. Priority: fractional preferred_scale (when fractional path
+    /// is active) > preferred_buffer_scale (wl_surface v6+) > max scale of currently-entered outputs.
+    /// Called on the Wayland thread.
+    /// </summary>
+    private void RecomputeScale()
+    {
+        double newScale;
+        if (PreferredFractionalScale is { } fractional)
+        {
+            newScale = fractional;
+        }
+        else if (LastPreferredBufferScale is { } preferred)
+        {
+            newScale = preferred;
+        }
+        else
+        {
+            newScale = 1;
+            foreach (var o in Outputs)
+            {
+                if (o.Scale > newScale)
+                    newScale = o.Scale;
+            }
+        }
+
+        if (Math.Abs(newScale - _currentScale) > ScaleEpsilon)
+        {
+            _currentScale = newScale;
+            OnScaleChanged(newScale);
+        }
+    }
+
+    /// <summary>
+    /// Called on the Wayland thread when the computed render scale changes.
+    /// </summary>
+    protected virtual void OnScaleChanged(double scale)
+    {
+    }
+
+    /// <summary>
+    /// Invoked by the platform surface before attaching a buffer and
+    /// calling wl_surface::commit. EGL/Vulkan drivers want to make commits
+    /// themselves for some reason, so we have this kind of callback logic.
+    ///
+    /// Stages double-buffered per-frame state — frame callback,
+    /// ack_configure, set_window_geometry, viewport / buffer scale, min/max
+    /// constraints — into the next commit so they apply atomically with
+    /// the new buffer.
+    /// </summary>
+    public virtual void OnBeforeNewBufferAttached(IRenderTarget.RenderTargetSceneInfo sceneInfo)
+    {
+        if (HasFractionalScaling)
+        {
+            var lw = Math.Max(1, (int)Math.Round(sceneInfo.LogicalSize.Width));
+            var lh = Math.Max(1, (int)Math.Round(sceneInfo.LogicalSize.Height));
+            Viewport!.SetDestination(lw, lh);
+        }
+        else
+            WlSurface!.SetBufferScale(Math.Max(1, (int)Math.Ceiling(sceneInfo.Scaling)));
+
+        _frameCallback = WlSurface!.Frame(new FrameListener(this));
+    }
+
+    class FrameListener(WSurface p) : WlCallback.Listener
+    {
+        protected override void Done(WlCallback eventSender, uint callbackData)
+        {
+            p.Worker.WakeupRenderLoop();
+            eventSender.Dispose();
+            p._frameCallback = null;
+        }
+    }
+
+    class FractionalScaleListener(WSurface p) : WpFractionalScaleV1.Listener
+    {
+        protected override void PreferredScale(WpFractionalScaleV1 eventSender, uint scale)
+        {
+            // Per protocol: scale is preferred_scale * 120. Reject 0 (would be a compositor
+            // bug — value must be > 0 per the protocol) but otherwise accept whatever the
+            // compositor sent us, including sub-1.0 values.
+            if (scale == 0)
+                return;
+            p.PreferredFractionalScale = scale / 120.0;
+            p.RecomputeScale();
+        }
+    }
+
+    class Listener(WSurface p) : WlSurface.Listener
+    {
+        protected override void PreferredBufferScale(WlSurface eventSender, int factor)
+        {
+            p.LastPreferredBufferScale = factor;
+            p.RecomputeScale();
+        }
+
+        protected override void Enter(WlSurface eventSender, WlOutput? output)
+        {
+            var o = p.Globals?.Outputs.Outputs.FirstOrDefault(o => o.WlOutput == output);
+            if (o != null)
+                p.Outputs.Add(o);
+            p.OnOutputsChanged();
+        }
+
+        protected override void Leave(WlSurface eventSender, WlOutput? output)
+        {
+            var o = p.Globals?.Outputs.Outputs.FirstOrDefault(o => o.WlOutput == output);
+            if (o != null)
+                p.Outputs.Remove(o);
+            p.OnOutputsChanged();
+        }
+    }
+
+    public virtual void OnDisconnected()
+    {
+        Outputs.Clear();
+        LastPreferredBufferScale = null;
+        PreferredFractionalScale = null;
+        _frameCallback?.Dispose();
+        _frameCallback = null;
+        // Dispose render targets before destroying the wl_surface so EGL
+        // resources (images, DMA-BUF buffers) are torn down while the
+        // underlying wl_surface is still alive.
+        foreach (var rt in _activeRenderTargets.ToList())
+            rt.Dispose();
+        // Invalidate cached render surface array so reconnect builds fresh ones.
+        _renderSurfaces = null;
+        _renderSurfacesGraphicsKey = null;
+        // Per fractional-scale-v1 / viewporter protocol: child objects must be destroyed
+        // before their parent wl_surface to avoid protocol errors.
+        if (Viewport != null)
+        {
+            Viewport.Destroy();
+            Viewport.Dispose();
+            Viewport = null;
+        }
+        if (FractionalScale != null)
+        {
+            FractionalScale.Destroy();
+            FractionalScale.Dispose();
+            FractionalScale = null;
+        }
+        WlSurface?.Destroy();
+        WlSurface = null;
+        Globals = null;
+        Connection = null;
+    }
+}
+
+class WXdgShellSurface : WSurface, IWXdgShellSurface
+{
+    public XdgSurface? XdgSurface { get; private set; }
+    private uint? _pendingAckSerial;
+    private bool _initialConfigureAcknowledged;
+    // True once we've attached a buffer + acked the initial configure
+    // following the most recent OnConnected — i.e. the surface is now
+    // *mapped* in xdg-shell terms. xdg_surface.GetPopup against an
+    // unmapped parent is a protocol error, so child popups must wait
+    // for this transition before attaching.
+    private bool _mapped;
+
+    /// <summary>
+    /// Children popups whose parents weren't yet mapped when the popup
+    /// went through OnConnected (or when the child itself reconnected
+    /// before the parent finished mapping). Drained when this surface
+    /// transitions to mapped (in <see cref="OnBeforeNewBufferAttached"/>).
+    /// Cleared on disconnect — every child's OnDisconnected runs
+    /// independently, so on reconnect they will re-register if still pending.
+    /// </summary>
+    private readonly List<WXdgPopup> _pendingChildPopups = new();
+
+    /// <summary>True iff this surface is currently mapped (xdg-shell sense).</summary>
+    internal bool IsMapped => _mapped;
+
+    internal void RegisterPendingChildPopup(WXdgPopup popup) => _pendingChildPopups.Add(popup);
+    internal void UnregisterPendingChildPopup(WXdgPopup popup) => _pendingChildPopups.Remove(popup);
+
+    /// <summary>
+    /// The UI-thread event sink associated with this surface.
+    /// </summary>
+    internal WSurfaceEventSinkProxy EventSink { get; }
+
+    private Thickness? _shadowExtents;
+
+    internal Thickness ShadowExtents => _shadowExtents ?? default;
+
+    /// <summary>
+    /// The window-geometry rectangle (left, top, width, height in
+    /// surface-local logical pixels, *excluding* shadow margins) that we
+    /// last sent to the compositor via <c>xdg_surface.SetWindowGeometry</c>.
+    /// This is the authoritative parent geometry seen by the compositor;
+    /// child popups read it for buffer→geometry coordinate translation
+    /// and anchor-rect clamping. <c>null</c> until the first buffer is
+    /// attached on the current connection.
+    /// </summary>
+    internal (int Left, int Top, int Width, int Height)? LastWindowGeometry { get; private set; }
+
+    public WXdgShellSurface(WaylandWorker worker, WSurfaceEventSinkProxy eventSink) : base(worker)
+    {
+        EventSink = eventSink;
+    }
+
+    public void SetShadowExtents(Thickness extents)
+    {
+        _shadowExtents = extents;
+    }
+
+    protected override void OnScaleChanged(double scale) => EventSink.OnScaleChanged(scale);
+
+    protected override void OnOutputsChanged()
+    {
+        base.OnOutputsChanged();
+        // Snapshot the per-surface entered-outputs identity list and post
+        // it to the UI thread so IScreenImpl.ScreenFromTopLevel can map
+        // the window onto a Screen. Identity matches WaylandOutputSnapshot.Id.
+        var ids = Outputs.Count == 0
+            ? (IReadOnlyList<object>)Array.Empty<object>()
+            : Outputs.Select(o => o.Id).ToList();
+        EventSink.OnSurfaceOutputsChanged(ids);
+    }
+
+    public override void OnConnected(WaylandConnection connection, WaylandGlobals globals)
+    {
+        base.OnConnected(connection, globals);
+        WlSurface!.Tags[typeof(WXdgShellSurface)] = this;
+        _pendingAckSerial = null;
+        _initialConfigureAcknowledged = false;
+        _mapped = false;
+
+        XdgSurface = globals.XdgWmBase.GetXdgSurface(WlSurface!, new XdgSurfaceListener(this));
+
+        // NOTE: pending child popups are NOT finalised here — the parent
+        // isn't *mapped* yet (no buffer attached, no initial configure
+        // acked). xdg_surface.GetPopup against an unmapped parent is a
+        // protocol error. Children are drained from OnBeforeNewBufferAttached
+        // when the mapped transition completes.
+    }
+
+    public override void OnDisconnected()
+    {
+        Globals?.InputDispatcher?.TextInputV3?.UnregisterSurface(this);
+        WlSurface?.Tags.Remove(typeof(WXdgShellSurface));
+        XdgSurface?.Destroy();
+        XdgSurface = null;
+        _pendingAckSerial = null;
+        _initialConfigureAcknowledged = false;
+        _mapped = false;
+        _pendingChildPopups.Clear();
+        LastWindowGeometry = null;
+        EventSink.OnSurfaceOutputsChanged(Array.Empty<object>());
+        base.OnDisconnected();
+    }
+
+    /// <summary>
+    /// Called when the complete configure batch is sealed by xdg_surface.configure(serial).
+    /// Subclasses should call the event sink and then call base.
+    /// </summary>
+    protected virtual void OnConfigureBatchComplete(uint serial)
+    {
+        Worker.WakeupRenderLoop();
+    }
+
+    /// <summary>
+    /// Called from UI thread (via Post) to set the serial that should be acked on next commit.
+    /// </summary>
+    public void SetPendingAckSerial(uint serial)
+    {
+        _initialConfigureAcknowledged = true;
+        _pendingAckSerial = serial;
+    }
+
+    public override PlatformRenderTargetState State =>
+        _initialConfigureAcknowledged
+            ? base.State
+            : PlatformRenderTargetState.NotReadyWillWakeupRenderLoop;
+
+    public override void OnBeforeNewBufferAttached(IRenderTarget.RenderTargetSceneInfo sceneInfo)
+    {
+        if (_pendingAckSerial.HasValue)
+        {
+            XdgSurface!.AckConfigure(_pendingAckSerial.Value);
+            _pendingAckSerial = null;
+        }
+
+        MaybeEmitWindowGeometry(sceneInfo.Size, sceneInfo.Scaling, sceneInfo.LogicalSize);
+
+        base.OnBeforeNewBufferAttached(sceneInfo);
+
+        // First buffer attach + configure-ack since the most recent
+        // (re-)connect → we are now mapped. Drain any popups that were
+        // queued while we were unmapped; they can now safely call
+        // xdg_surface.GetPopup against us.
+        if (!_mapped)
+        {
+            _mapped = true;
+            if (_pendingChildPopups.Count > 0)
+            {
+                var snapshot = _pendingChildPopups.ToArray();
+                _pendingChildPopups.Clear();
+                foreach (var p in snapshot)
+                    p.TryAttachToParent();
+            }
+        }
+    }
+
+    /// <summary>
+    /// Computes and emits the surface's window geometry (the rectangle
+    /// inside the buffer that the compositor should treat as the visible
+    /// window, excluding decoration-area shadows). Default implementation
+    /// applies the cached <see cref="_shadowExtents"/> against the
+    /// post-scale logical size and calls <c>xdg_surface.SetWindowGeometry</c>.
+    ///
+    /// Skipped entirely until the surface receives its first
+    /// <see cref="SetShadowExtents"/> call — the compositor then treats
+    /// the whole buffer as the visible window (which is what we want for
+    /// surfaces that don't draw shadows, e.g. popups). Once extents have
+    /// been set we keep emitting geometry even if extents go back to all
+    /// zero (e.g. when a window is maximized): the compositor still needs
+    /// the explicit "geometry == buffer" call to discard the previous
+    /// shadow margins.
+    ///
+    /// Skipping until first set also dodges the fractional-scale rounding
+    /// artefact where 125% scaling can't align the geometry rect to the
+    /// pixel grid without clipping content.
+    /// </summary>
+    protected virtual void MaybeEmitWindowGeometry(PixelSize bufferPixelSize, double bufferScale, Size logicalSize)
+    {
+        if (_shadowExtents is not { } shadowExtents)
+            return;
+
+        // Compute surface-local geometry excluding shadows.
+        // Geometry must be >= 1x1 and lie within the buffer's logical size (protocol requirement).
+        // On the fractional-scale path the renderer passes the authoritative logical size from
+        // the latest configure (via composition's RenderTargetSceneInfo); for the integer-scale
+        // path we fall back to ceiling the buffer pixel size by the integer scale.
+        int surfaceWidth, surfaceHeight;
+        if (HasFractionalScaling && logicalSize.Width > 0 && logicalSize.Height > 0)
+        {
+            surfaceWidth = Math.Max(1, (int)Math.Round(logicalSize.Width));
+            surfaceHeight = Math.Max(1, (int)Math.Round(logicalSize.Height));
+        }
+        else
+        {
+            var intScale = Math.Max(1, (int)Math.Ceiling(bufferScale));
+            surfaceWidth = (bufferPixelSize.Width + intScale - 1) / intScale;
+            surfaceHeight = (bufferPixelSize.Height + intScale - 1) / intScale;
+        }
+
+        var left = Math.Clamp((int)shadowExtents.Left, 0, surfaceWidth - 1);
+        var top = Math.Clamp((int)shadowExtents.Top, 0, surfaceHeight - 1);
+        var right = Math.Clamp(
+            (int)Math.Ceiling(surfaceWidth - shadowExtents.Right), left + 1, surfaceWidth);
+        var bottom = Math.Clamp(
+            (int)Math.Ceiling(surfaceHeight - shadowExtents.Bottom), top + 1, surfaceHeight);
+
+        XdgSurface!.SetWindowGeometry(left, top, right - left, bottom - top);
+        LastWindowGeometry = (left, top, right - left, bottom - top);
+    }
+
+    internal class XdgSurfaceListener(WXdgShellSurface p) : XdgSurface.Listener
+    {
+        protected override void Configure(XdgSurface eventSender, uint serial) =>
+            p.OnConfigureBatchComplete(serial);
+    }
+}
+
+class WXdgTopLevel : WXdgShellSurface, IWXdgTopLevel
+{
+    protected TaskCompletionSource<XdgConfigureBatch> BasicInitCompletedTcs { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
+    private XdgToplevel? _xdgTopLevel;
+    public Task<XdgConfigureBatch> BasicInitCompleted => BasicInitCompletedTcs.Task;
+    private XdgConfigureBatch _pendingBatch = new();
+
+    // Active xdg-foreign exports for this surface (worker thread only).
+    // Cleared in OnDisconnected — the proxies belong to the dying connection.
+    private readonly List<XdgToplevelExport> _activeExports = new();
+
+    // Typed event sink for xdg_toplevel-specific events. Stored separately
+    // from the base IWSurfaceEventSink reference so OnConfigure/OnClose can
+    // be dispatched without an interface re-cast on every emit.
+    private readonly WXdgTopLevelEventSinkProxy _topLevelEventSink;
+
+    private Size? _minSize;
+    private Size? _maxSize;
+    private string? _title;
+
+    private ZxdgToplevelDecorationV1? _decoration;
+    // Disable SSD support completely and don't allow re-enabling it because we can't
+    // TODO: Wait for V2 version of the protocol to gain more adoption and implement it on our side
+    private bool _csdSticky;
+
+    public WXdgTopLevel(WaylandWorker worker, WXdgTopLevelEventSinkProxy eventSink) : base(worker, eventSink)
+    {
+        _topLevelEventSink = eventSink;
+    }
+
+    public override void OnConnected(WaylandConnection connection, WaylandGlobals globals)
+    {
+        base.OnConnected(connection, globals);
+        if (Globals!.Outputs.Outputs.Count == 0)
+            throw new AvaloniaWaylandException("Expected at least one wl_output at this point");
+        _pendingBatch = new();
+        _xdgTopLevel = XdgSurface!.GetToplevel(new TopLevelListener(this));
+        if (!_csdSticky && Globals.XdgDecorationManager is { } decoMgr)
+        {
+            _decoration = decoMgr.GetToplevelDecoration(
+                _xdgTopLevel,
+                new DecorationListener(this),
+                connection.Queue);
+            _decoration.SetMode(ZxdgToplevelDecorationV1.ModeEnum.ServerSide);
+        }
+
+        // Re-apply cached title on reconnect.
+        if (_title != null)
+            _xdgTopLevel.SetTitle(_title);
+
+        // Re-apply cached min/max if they were ever set on a previous
+        // (now-dead) connection. The OnConnected commit below will
+        // promote the queued double-buffered state.
+        if (_minSize.HasValue || _maxSize.HasValue)
+            EmitMinMaxSize();
+        WlSurface!.Commit();
+    }
+
+    private Size CalculateMaxSize()
+    {
+        // Prefer compositor-provided bounds
+        if (_pendingBatch.Bounds is { Width: > 0, Height: > 0 } bounds)
+            return new Size(bounds.Width, bounds.Height);
+        
+        // Fallback: compute from output geometry
+        Size? maxSize = null;  
+        var outputs = Outputs.Count > 0 ? Outputs : Globals!.Outputs.Outputs;
+        foreach (var o in outputs)
+        {
+            // Use the same logical-size derivation as the screen snapshot
+            // (xdg_output.logical_size when available with mutter-bogus
+            // workaround, else mode/scale). DPR == 1 here because o.LogicalSize
+            // is already in compositor logical pixels.
+            var size = o.LogicalSize.ToSize(1);
+            if (maxSize == null)
+                maxSize = size;
+            else
+                maxSize = new(Math.Min(maxSize.Value.Width, size.Width),
+                    Math.Min(maxSize.Value.Height, size.Height));
+        }
+
+        return maxSize ?? new Size(800, 600);
+    }
+
+    public void SetMaximized() => _xdgTopLevel?.SetMaximized();
+    public void UnsetMaximized() => _xdgTopLevel?.UnsetMaximized();
+    public void SetFullscreen() => _xdgTopLevel?.SetFullscreen(null!);
+    public void UnsetFullscreen() => _xdgTopLevel?.UnsetFullscreen();
+    public void SetMinimized() => _xdgTopLevel?.SetMinimized();
+
+    public void SetTitle(string? title)
+    {
+        _title = title;
+        _xdgTopLevel?.SetTitle(title ?? string.Empty);
+    }
+
+    public void SetMinMaxSize(Size? minSize, Size? maxSize)
+    {
+        if (minSize == _minSize && maxSize == _maxSize)
+            return;
+        _minSize = minSize;
+        _maxSize = maxSize;
+        // No-op if we aren't currently connected — _xdgTopLevel is null
+        // and _wlSurface is null on disconnect; OnConnected replays the
+        // cached values when a connection is (re)established.
+        if (_xdgTopLevel == null)
+            return;
+        EmitMinMaxSize();
+        // Push immediately so an idle window with no pending buffer still
+        // sees the new constraints take effect. A commit without an
+        // attach is well-defined: it promotes the double-buffered values
+        // without redrawing. Future buffer attaches will redundantly
+        // re-emit the same values, which the compositor accepts.
+        WlSurface!.Commit();
+    }
+
+    private void EmitMinMaxSize()
+    {
+        if (_xdgTopLevel == null)
+            return;
+
+        // null => "no constraint" => send 0 (per xdg-shell spec).
+        var (minW, minH) = _minSize is { } min
+            ? (Math.Max(1, (int)Math.Ceiling(min.Width)),
+               Math.Max(1, (int)Math.Ceiling(min.Height)))
+            : (0, 0);
+        var (maxW, maxH) = _maxSize is { } max
+            ? (Math.Max(1, (int)Math.Floor(max.Width)),
+               Math.Max(1, (int)Math.Floor(max.Height)))
+            : (0, 0);
+
+        // Spec: "Requesting a minimum size to be larger than the maximum
+        // size of a surface is illegal and will result in an invalid_size
+        // error." Clamp the minimum down to the maximum (≥0 maintained);
+        // 0 on max means "unconstrained" and lets any min through.
+        if (maxW > 0 && minW > maxW) minW = maxW;
+        if (maxH > 0 && minH > maxH) minH = maxH;
+
+        _xdgTopLevel.SetMinSize(minW, minH);
+        _xdgTopLevel.SetMaxSize(maxW, maxH);
+    }
+
+    public void SetParent(IWXdgTopLevel? parent)
+    {
+        _xdgTopLevel?.SetParent(((WXdgTopLevel?)parent)?._xdgTopLevel);
+    }
+
+    public void Move(object? platformCookie)
+    {
+        if (_xdgTopLevel != null
+            && platformCookie is WaylandInputEventCookie cookie
+            && CurrentDisplay is { } display
+            && cookie.TryConsume(display, out var seat, out var serial))
+            _xdgTopLevel.Move(seat, serial);
+    }
+
+    public void Resize(object? platformCookie, XdgToplevel.ResizeEdgeEnum edge)
+    {
+        if (_xdgTopLevel != null
+            && platformCookie is WaylandInputEventCookie cookie
+            && CurrentDisplay is { } display
+            && cookie.TryConsume(display, out var seat, out var serial))
+            _xdgTopLevel.Resize(seat, serial, edge);
+    }
+    
+    protected override void OnConfigureBatchComplete(uint serial)
+    {
+        var batch = _pendingBatch;
+        batch.Serial = serial;
+        batch.MaxSize = CalculateMaxSize();
+        _pendingBatch = new();
+        
+        _topLevelEventSink.OnConfigure(batch);
+        BasicInitCompletedTcs.TrySetResult(batch);
+        
+        base.OnConfigureBatchComplete(serial);
+    }
+
+    private class DecorationListener(WXdgTopLevel p) : ZxdgToplevelDecorationV1.Listener
+    {
+        protected override void Configure(ZxdgToplevelDecorationV1 eventSender, ZxdgToplevelDecorationV1.ModeEnum mode)
+        {
+            var translated = mode switch
+            {
+                ZxdgToplevelDecorationV1.ModeEnum.ServerSide => DecorationMode.ServerSide,
+                _ => DecorationMode.ClientSide,
+            };
+            if (p.BasicInitCompletedTcs.Task.IsCompleted)
+                p._topLevelEventSink.OnDecorationModeChanged(translated);
+            else
+                p._pendingBatch.InitialDecorationMode = translated;
+        }
+    }
+
+    public void DestroyDecoration()
+    {
+        _csdSticky = true;
+        _decoration?.Destroy();
+        _decoration?.Dispose();
+        _decoration = null;
+    }
+
+    internal class TopLevelListener(WXdgTopLevel p) : XdgToplevel.Listener
+    {
+        protected override void ConfigureBounds(XdgToplevel eventSender, int width, int height) => 
+            p._pendingBatch.Bounds = new(width, height);
+        
+        protected override void Configure(XdgToplevel eventSender, int width, int height, ReadOnlySpan<byte> states)
+        {
+            p._pendingBatch.Size = new(width, height);
+            p._pendingBatch.States = XdgConfigureBatch.ParseStates(states);
+        }
+
+        protected override void Close(XdgToplevel eventSender) =>
+            p._topLevelEventSink.OnClose();
+    }
+
+    public override void OnDisconnected()
+    {
+        EventSink.OnKeyboardLeave();
+        foreach (var ex in _activeExports.ToList())
+            ex.Dispose();
+        _activeExports.Clear();
+        _decoration?.Destroy();
+        _decoration = null;
+        _xdgTopLevel?.Destroy();
+        _xdgTopLevel = null;
+        _pendingBatch = new();
+        base.OnDisconnected();
+    }
+
+    /// <summary>
+    /// Worker-thread: exports this toplevel via xdg-foreign-unstable-v2, returning a
+    /// handle object whose Task resolves once the  compositor has emitted the handle event.
+    /// Returns <c>null</c> if the exporter  global is not bound on the current connection
+    /// or this toplevel isn't currently mapped.
+    /// </summary>
+    public IWaylandXdgTopLevelExport? ExportToplevel()
+    {
+        if (Globals?.XdgExporter is not { } exporter || WlSurface == null || _xdgTopLevel == null
+            || Connection == null)
+            return null;
+        var export = new XdgToplevelExport(this, Worker, exporter, WlSurface, Connection.Queue);
+        _activeExports.Add(export);
+        return export.GetUiThreadHandle();
+    }
+
+    internal void RemoveExport(XdgToplevelExport export) => _activeExports.Remove(export);
+}
+
+/// <summary>
+/// Worker-side xdg_popup surface. The UI thread keeps a
+/// <c>WXdgPopupProxy</c> handle and feeds positioner parameters via
+/// <see cref="UpdatePositioner"/>; the worker rebuilds the protocol-level
+/// <c>xdg_positioner</c> and calls <c>xdg_surface.GetPopup</c> on every
+/// (re-)connect (so the popup survives compositor reconnects). Popup
+/// configure events are accumulated in <see cref="_pendingBatch"/> and
+/// flushed to <see cref="IWXdgPopupEventSink.OnPopupConfigure"/> when the
+/// wrapping <c>xdg_surface.configure(serial)</c> seals the batch.
+/// </summary>
+class WXdgPopup : WXdgShellSurface, IWXdgPopup
+{
+    private readonly WXdgPopupEventSinkProxy _popupEventSink;
+    private readonly WXdgShellSurface _parent;
+
+    private XdgPopup? _xdgPopup;
+    private XdgPopupConfigureBatch _pendingBatch = new();
+    private XdgPopupPositionerParams? _positioner;
+    // 0 is reserved (means "no token"); start at 1 and bump on every reposition.
+    private uint _nextRepositionToken = 1;
+
+    public WXdgPopup(WaylandWorker worker, WXdgPopupEventSinkProxy eventSink, WXdgShellSurface parent)
+        : base(worker, eventSink)
+    {
+        _popupEventSink = eventSink;
+        _parent = parent;
+    }
+    
+    public void UpdatePositioner(XdgPopupPositionerParams positioner)
+    {
+        var hadPrevious = _positioner.HasValue;
+        _positioner = positioner;
+
+        if (!hadPrevious)
+        {
+            // First positioner — attempt to attach now (may still defer
+            // if the parent isn't mapped or we're not yet connected;
+            // OnConnected / parent's drain will retry).
+            TryAttachToParent();
+            return;
+        }
+
+        if (_xdgPopup == null || Connection == null)
+            return;
+
+        // Already mapped — issue a reposition. The compositor will reply
+        // with a fresh configure + repositioned(token) sequence; the
+        // pending batch is reset so the next OnPopupConfigure carries the
+        // post-reposition geometry.
+        var p = BuildPositioner(positioner);
+        if (p == null)
+            return;
+        try
+        {
+            _pendingBatch = new();
+            _xdgPopup.Reposition(p, _nextRepositionToken++);
+        }
+        finally
+        {
+            p.Destroy();
+            p.Dispose();
+        }
+    }
+
+    public override void OnConnected(WaylandConnection connection, WaylandGlobals globals)
+    {
+        // Always create wl_surface + xdg_surface (so any pending children of
+        // _ours_ can attach), even if our own popup creation is deferred
+        // because the parent isn't ready yet.
+        base.OnConnected(connection, globals);
+
+        TryAttachToParent();
+    }
+
+    /// <summary>
+    /// Called either from our own <see cref="OnConnected"/>, or from the
+    /// parent's <see cref="WXdgShellSurface.OnBeforeNewBufferAttached"/> when
+    /// finalising pending child popups whose creation was deferred because
+    /// the parent wasn't mapped yet. xdg_surface.GetPopup against an
+    /// unmapped parent is a protocol error, so we wait for the parent's
+    /// first frame.
+    /// </summary>
+    internal void TryAttachToParent()
+    {
+        if (_xdgPopup != null) return;                         // already attached
+        if (XdgSurface == null) return;                       // we're not connected
+        if (_positioner is not { } pos) return;                // UI hasn't supplied positioner yet
+        if (!_parent.IsMapped || _parent.XdgSurface is not { } parentXdgSurface)
+        {
+            // Parent not yet mapped — register; parent will call us back
+            // when its first buffer commits.
+            _parent.RegisterPendingChildPopup(this);
+            return;
+        }
+
+        var positioner = BuildPositioner(pos);
+        if (positioner == null)
+            return;
+        try
+        {
+            _pendingBatch = new();
+            _xdgPopup = XdgSurface.GetPopup(parentXdgSurface, positioner, new PopupListener(this));
+        }
+        finally
+        {
+            positioner.Destroy();
+            positioner.Dispose();
+        }
+        WlSurface!.Commit();
+    }
+
+    /// <summary>
+    /// Translates the cached <see cref="XdgPopupPositionerParams"/> into a
+    /// fresh <c>xdg_positioner</c> protocol object. The caller owns the
+    /// returned object and must <c>Destroy</c>+<c>Dispose</c> it after use.
+    /// Performs the buffer→geometry origin shift on the anchor rect (using
+    /// the parent's most recent <c>SetWindowGeometry</c> as the
+    /// authoritative source) and clamps it into the parent's window-geometry
+    /// rectangle as required by the xdg_positioner spec.
+    /// </summary>
+    private XdgPositioner? BuildPositioner(XdgPopupPositionerParams p)
+    {
+        if (Globals == null)
+            return null;
+
+        var positioner = Globals.XdgWmBase.CreatePositioner();
+
+        // Size: protocol requires positive integers.
+        var width = Math.Max(1, (int)Math.Ceiling(p.Size.Width));
+        var height = Math.Max(1, (int)Math.Ceiling(p.Size.Height));
+        positioner.SetSize(width, height);
+
+        // The anchor rect is given in the parent's *buffer-relative* logical
+        // frame (true top-left, includes shadow). Wayland's xdg_positioner
+        // wants coords in the parent's *window-geometry* frame (excludes
+        // shadow). Use the parent's most recent SetWindowGeometry as the
+        // single source of truth — it's what the compositor sees, and using
+        // it avoids any drift between our shadow-extent state and the
+        // geometry actually committed.
+        //
+        // If the parent hasn't reported geometry yet, that's a contract
+        // violation (we shouldn't be building a positioner before the
+        // parent is mapped) — fall back to assuming origin (0,0) and skip
+        // clamping rather than crashing.
+        var parentGeom = _parent.LastWindowGeometry;
+        var originX = parentGeom?.Left ?? 0;
+        var originY = parentGeom?.Top ?? 0;
+
+        var anchorX = (int)Math.Round(p.AnchorRect.X) - originX;
+        var anchorY = (int)Math.Round(p.AnchorRect.Y) - originY;
+        var anchorW = Math.Max(0, (int)Math.Round(p.AnchorRect.Width));
+        var anchorH = Math.Max(0, (int)Math.Round(p.AnchorRect.Height));
+
+        // Clamp into the parent's window geometry. The protocol forbids the
+        // anchor rect from extending outside the parent's geometry; rather
+        // than failing the call (which would protocol-error the connection)
+        // we clip it. UI-side may produce slightly off-edge anchor rects
+        // when, e.g., a context menu opens near the corner of a window.
+        //
+        // The clamp must produce a strictly positive (>= 1×1) rectangle:
+        // xdg_positioner accepts a zero-sized anchor rect via SetAnchorRect,
+        // but the spec considers such a positioner *incomplete* and the
+        // subsequent get_popup/reposition raises xdg_wm_base.invalid_positioner
+        // — a fatal error that disconnects every Avalonia window. So we
+        // shift the floor back by one when the clamp would collapse to zero.
+        if (parentGeom is { Width: > 0, Height: > 0 } g)
+        {
+            var maxX0 = Math.Max(0, g.Width - 1);
+            var maxY0 = Math.Max(0, g.Height - 1);
+            var x0 = Math.Clamp(anchorX, 0, maxX0);
+            var y0 = Math.Clamp(anchorY, 0, maxY0);
+            var x1 = Math.Clamp(anchorX + Math.Max(1, anchorW), x0 + 1, g.Width);
+            var y1 = Math.Clamp(anchorY + Math.Max(1, anchorH), y0 + 1, g.Height);
+            anchorX = x0;
+            anchorY = y0;
+            anchorW = x1 - x0;
+            anchorH = y1 - y0;
+        }
+        else
+        {
+            // No parent geometry to clamp against — still ensure the
+            // anchor rect is at least 1×1 to keep the positioner valid.
+            anchorW = Math.Max(1, anchorW);
+            anchorH = Math.Max(1, anchorH);
+        }
+
+        positioner.SetAnchorRect(anchorX, anchorY, anchorW, anchorH);
+        positioner.SetAnchor(p.Anchor);
+        positioner.SetGravity(p.Gravity);
+        positioner.SetConstraintAdjustment((XdgPositioner.ConstraintAdjustmentEnum)p.ConstraintAdjustment);
+
+        // Offset is post-resolution (popup-relative); no parent/shadow shift.
+        if (p.Offset.X != 0 || p.Offset.Y != 0)
+            positioner.SetOffset((int)Math.Round(p.Offset.X), (int)Math.Round(p.Offset.Y));
+
+        return positioner;
+    }
+
+    protected override void OnConfigureBatchComplete(uint serial)
+    {
+        var batch = _pendingBatch;
+        batch.Serial = serial;
+        _pendingBatch = new();
+
+        _popupEventSink.OnPopupConfigure(batch);
+
+        base.OnConfigureBatchComplete(serial);
+    }
+
+    internal class PopupListener(WXdgPopup p) : XdgPopup.Listener
+    {
+        protected override void Configure(XdgPopup eventSender, int x, int y, int width, int height)
+        {
+            p._pendingBatch.X = x;
+            p._pendingBatch.Y = y;
+            p._pendingBatch.Width = width;
+            p._pendingBatch.Height = height;
+        }
+
+        protected override void PopupDone(XdgPopup eventSender) =>
+            p._popupEventSink.OnPopupDone();
+
+        // Repositioned(token) acks a previous Reposition request. We don't
+        // currently surface the token to the UI side (the UI doesn't track
+        // outstanding reposition requests — the geometry already arrives
+        // via the matching configure event). If we ever need round-trip
+        // reposition acknowledgement, plumb the token through OnPopupConfigure.
+        protected override void Repositioned(XdgPopup eventSender, uint token) { }
+    }
+
+    public override void OnDisconnected()
+    {
+        EventSink.OnKeyboardLeave();
+        // Unregister from the parent's pending list in case we were
+        // deferred and the connection went down before we got attached.
+        _parent.UnregisterPendingChildPopup(this);
+        _xdgPopup?.Destroy();
+        _xdgPopup?.Dispose();
+        _xdgPopup = null;
+        _pendingBatch = new();
+        base.OnDisconnected();
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Server/Persistent/WaylandBitmapCursor.cs b/src/Avalonia.Wayland/Server/Persistent/WaylandBitmapCursor.cs
new file mode 100644
index 0000000000..716dd6ae99
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/WaylandBitmapCursor.cs
@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using Avalonia;
+using Avalonia.Platform;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Transient;
+using Avalonia.Wayland.Server.Transient.Rendering;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Server.Persistent;
+
+/// <summary>
+/// A custom bitmap cursor. A persistent worker-thread entity that owns a bare <c>wl_surface</c>
+/// holding the cursor image. Unlike <see cref="WSurface"/> it has no xdg-shell role, no configure
+/// handshake and no frame-callback throttling: the image is rendered once per connection and the
+/// surface is only ever referenced by <c>wl_pointer.set_cursor</c>. Rendering reuses
+/// <see cref="WaylandFramebuffer"/> via <see cref="IWaylandFramebufferSurface"/>.
+/// </summary>
+sealed class WaylandBitmapCursor : WaylandCursor, IPersistentWaylandObject, IWaylandFramebufferSurface
+{
+    private readonly WaylandWorker _worker;
+    private readonly byte[] _pixels; // tightly packed Bgra8888 premultiplied, stride = Width * 4
+    private readonly PixelSize _size;
+    private readonly int _hotspotX;
+    private readonly int _hotspotY;
+    private WaylandConnection? _connection;
+    private WaylandGlobals? _globals;
+    private WlSurface? _wlSurface;
+    private readonly List<IDisposable> _activeRenderTargets = new();
+
+    public WaylandBitmapCursor(WaylandWorker worker, byte[] pixels, PixelSize size, int hotspotX, int hotspotY)
+    {
+        _worker = worker;
+        _pixels = pixels;
+        _size = size;
+        _hotspotX = hotspotX;
+        _hotspotY = hotspotY;
+        worker.PostOob(() => worker.RegisterPersistentObject(this));
+    }
+
+    public WaylandGlobals? Globals => _globals;
+    public WlSurface? WlSurface => _wlSurface;
+
+    public PlatformRenderTargetState State =>
+        _globals != null && _wlSurface != null ? PlatformRenderTargetState.Ready : default;
+
+    public void RegisterRenderTarget(IDisposable renderTarget) => _activeRenderTargets.Add(renderTarget);
+    public void UnregisterRenderTarget(IDisposable renderTarget) => _activeRenderTargets.Remove(renderTarget);
+
+    // No xdg role and no frame-callback throttling: nothing to stage before a buffer attach.
+    public void OnBeforeNewBufferAttached(IRenderTarget.RenderTargetSceneInfo sceneInfo)
+    {
+    }
+
+    // Cursor buffers are created outside the throttled render loop, so flush their fds eagerly.
+    public bool EnforceBufferCreationRoundtrip => true;
+
+    public override WaylandCursorImage? Resolve(WaylandGlobals globals)
+        => _wlSurface is { } surface ? new WaylandCursorImage(surface, _hotspotX, _hotspotY) : null;
+
+    public void OnConnected(WaylandConnection connection, WaylandGlobals globals)
+    {
+        _connection = connection;
+        _globals = globals;
+        _wlSurface = globals.WlCompositor.CreateSurface(null);
+        Render();
+    }
+
+    private void Render()
+    {
+        if (_size.Width <= 0 || _size.Height <= 0)
+            return;
+
+        var framebuffer = new WaylandFramebuffer(this);
+        using var renderTarget = framebuffer.CreateFramebufferRenderTarget();
+        using var locked = renderTarget.Lock(new IRenderTarget.RenderTargetSceneInfo(_size, 1), out _);
+        // The locked framebuffer is Bgra8888 premultiplied with stride == Width * 4, matching the
+        // packed pixel data we captured on the UI thread. Disposing the lock attaches + commits.
+        Marshal.Copy(_pixels, 0, locked.Address, _pixels.Length);
+    }
+
+    public void OnDisconnected()
+    {
+        foreach (var rt in _activeRenderTargets.ToList())
+            rt.Dispose();
+        _wlSurface?.Destroy();
+        _wlSurface = null;
+        _globals = null;
+        _connection = null;
+    }
+
+    // Invoked on the worker thread via WaylandCursorProxy when the owning UI-thread cursor is disposed.
+    public override void Destroy() => _worker.UnregisterPersistentObject(this);
+}
diff --git a/src/Avalonia.Wayland/Server/Persistent/WaylandCursor.cs b/src/Avalonia.Wayland/Server/Persistent/WaylandCursor.cs
new file mode 100644
index 0000000000..73b48f080c
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/WaylandCursor.cs
@@ -0,0 +1,45 @@
+using Avalonia.Input;
+using Avalonia.SourceGenerator;
+using Avalonia.Wayland.Server.Transient;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Server.Persistent;
+
+/// <summary>The surface + hotspot to hand to <c>wl_pointer.set_cursor</c>.</summary>
+[DefinitelyNotARecord]
+readonly partial struct WaylandCursorImage(WlSurface Surface, int HotspotX, int HotspotY);
+
+/// <summary>
+/// Worker-side representation of a pointer cursor. The UI thread only ever holds the generated
+/// <c>WaylandCursorProxy</c> wrapper (see <see cref="IWaylandCursor"/>); resolving the actual
+/// <c>wl_surface</c> happens here, on the worker thread.
+/// </summary>
+abstract class WaylandCursor : IWaylandCursor
+{
+    /// <summary>
+    /// Resolves the surface + hotspot for <c>wl_pointer.set_cursor</c> on the worker thread, or
+    /// <c>null</c> to hide the pointer.
+    /// </summary>
+    public abstract WaylandCursorImage? Resolve(WaylandGlobals globals);
+
+    /// <inheritdoc/>
+    public abstract void Destroy();
+}
+
+/// <summary>
+/// A standard themed cursor. Stateless apart from the requested type — it owns no wl_surface and
+/// resolves the themed surface on demand from <see cref="WaylandCursorManager"/>, so it doesn't
+/// need to be a persistent object.
+/// </summary>
+sealed class WaylandStandardCursor(StandardCursorType cursorType) : WaylandCursor
+{
+    public override WaylandCursorImage? Resolve(WaylandGlobals globals)
+        => globals.CursorManager.GetCursor(cursorType) is { } c
+            ? new WaylandCursorImage(c.Surface, c.HotspotX, c.HotspotY)
+            : null;
+
+    // Nothing to release — the themed surfaces are owned by WaylandCursorManager.
+    public override void Destroy()
+    {
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Persistent/WaylandInputEventCookie.cs b/src/Avalonia.Wayland/Server/Persistent/WaylandInputEventCookie.cs
new file mode 100644
index 0000000000..521ae2d557
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/WaylandInputEventCookie.cs
@@ -0,0 +1,71 @@
+using System;
+using Avalonia.Wayland.Server.Transient;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Server.Persistent;
+
+/// <summary>
+/// Platform-specific cookie passed through Avalonia's input pipeline.
+/// Carries the Wayland seat and serial from the triggering input event,
+/// consumed by BeginMoveDrag/BeginResizeDrag to issue xdg_toplevel.move/resize.
+/// Single-use: TryConsume returns false on subsequent calls or if the display changed.
+/// Both TryConsume and Invalidate are called on the wayland thread.
+/// <para>
+/// Also captures the <see cref="WaylandGlobals"/> and <see cref="WaylandWorker"/> from the
+/// moment the input event was triggered, providing <see cref="PostOob"/> for reconnect-safe
+/// access to transient state (e.g. initiating DnD from a pointer press).
+/// </para>
+/// </summary>
+class WaylandInputEventCookie
+{
+    private WlSeat? _seat;
+    private readonly uint _serial;
+    private readonly WlDisplay _display;
+    private readonly WaylandWorker _worker;
+    private readonly WaylandGlobals _globals;
+
+    public WaylandInputEventCookie(WlSeat seat, uint serial, WlDisplay display,
+        WaylandWorker worker, WaylandGlobals globals)
+    {
+        _seat = seat;
+        _serial = serial;
+        _display = display;
+        _worker = worker;
+        _globals = globals;
+    }
+
+    /// <summary>
+    /// Attempts to consume the cookie for a surface that uses the given display.
+    /// Returns false if already consumed or if the display doesn't match (reconnection).
+    /// Must be called on the wayland thread.
+    /// </summary>
+    public bool TryConsume(WlDisplay currentDisplay, out WlSeat seat, out uint serial)
+    {
+        var s = _seat;
+        _seat = null;
+        if (s != null && ReferenceEquals(_display, currentDisplay))
+        {
+            seat = s;
+            serial = _serial;
+            return true;
+        }
+
+        seat = default!;
+        serial = 0;
+        return false;
+    }
+
+    /// <summary>
+    /// Posts a callback to the wayland thread that receives the <see cref="WaylandGlobals"/>
+    /// captured at input-event time. If a compositor reconnect occurred since then
+    /// (i.e. the current globals differ from the captured ones), the callback is not invoked.
+    /// </summary>
+    public void PostOob(Action<WaylandGlobals> cb)
+    {
+        _worker.PostOob(() =>
+        {
+            if (ReferenceEquals(_worker.Globals, _globals))
+                cb(_globals);
+        });
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Persistent/XdgConfigureBatch.cs b/src/Avalonia.Wayland/Server/Persistent/XdgConfigureBatch.cs
new file mode 100644
index 0000000000..98d1f87ebf
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/XdgConfigureBatch.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Avalonia.Wayland.Server.Persistent;
+
+[Flags]
+enum XdgToplevelStates
+{
+    None = 0,
+    Maximized = 1 << 0,
+    Fullscreen = 1 << 1,
+    Resizing = 1 << 2,
+    Activated = 1 << 3,
+    TiledLeft = 1 << 4,
+    TiledRight = 1 << 5,
+    TiledTop = 1 << 6,
+    TiledBottom = 1 << 7,
+    Suspended = 1 << 8,
+}
+
+class XdgConfigureBatch
+{
+    public PixelSize? Bounds;
+    public PixelSize Size;
+    public XdgToplevelStates States;
+    public uint Serial;
+
+    /// <summary>
+    /// Maximum usable surface size, computed from Bounds or output geometry.
+    /// </summary>
+    public Size MaxSize;
+
+    /// <summary>
+    /// Effective decoration mode after the initial handshake.
+    /// <c>null</c> = no decoration object was created (compositor doesn't
+    /// support zxdg_decoration_manager_v1, or sticky-CSD is on, or the
+    /// <c>ForceDrawnDecorations</c> option suppressed binding) — UI side
+    /// must draw client-side chrome.
+    /// </summary>
+    public DecorationMode? InitialDecorationMode;
+
+    public static XdgToplevelStates ParseStates(ReadOnlySpan<byte> data)
+    {
+        var states = XdgToplevelStates.None;
+        var uint32s = MemoryMarshal.Cast<byte, uint>(data);
+        foreach (var value in uint32s)
+        {
+            states |= value switch
+            {
+                1 => XdgToplevelStates.Maximized,
+                2 => XdgToplevelStates.Fullscreen,
+                3 => XdgToplevelStates.Resizing,
+                4 => XdgToplevelStates.Activated,
+                5 => XdgToplevelStates.TiledLeft,
+                6 => XdgToplevelStates.TiledRight,
+                7 => XdgToplevelStates.TiledTop,
+                8 => XdgToplevelStates.TiledBottom,
+                9 => XdgToplevelStates.Suspended,
+                _ => XdgToplevelStates.None,
+            };
+        }
+        return states;
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Persistent/XdgPopupConfigureBatch.cs b/src/Avalonia.Wayland/Server/Persistent/XdgPopupConfigureBatch.cs
new file mode 100644
index 0000000000..fc022abea3
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/XdgPopupConfigureBatch.cs
@@ -0,0 +1,15 @@
+namespace Avalonia.Wayland.Server.Persistent;
+
+/// <summary>
+/// Worker-side accumulator for a single xdg_popup configure batch, sealed by
+/// the wrapping xdg_surface.configure(serial). Mirrors <see cref="XdgConfigureBatch"/>
+/// but carries the popup-specific (x, y, width, height) payload.
+/// </summary>
+internal class XdgPopupConfigureBatch
+{
+    public int X;
+    public int Y;
+    public int Width;
+    public int Height;
+    public uint Serial;
+}
diff --git a/src/Avalonia.Wayland/Server/Persistent/XdgPopupPositionerParams.cs b/src/Avalonia.Wayland/Server/Persistent/XdgPopupPositionerParams.cs
new file mode 100644
index 0000000000..33d2dbbfd2
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Persistent/XdgPopupPositionerParams.cs
@@ -0,0 +1,31 @@
+using Avalonia.SourceGenerator;
+using NWayland.Protocols.XdgShell;
+
+namespace Avalonia.Wayland.Server.Persistent;
+
+/// <summary>
+/// Flat, immutable description of an xdg_positioner request. Built UI-side
+/// in the parent's <b>buffer-relative</b> logical coordinate system —
+/// i.e. relative to the true top-left of the parent surface, including any
+/// CSD shadow margins. The worker is responsible for translating into the
+/// parent's xdg_surface window-geometry coordinate system (subtracting the
+/// parent's shadow extents) and clamping the anchor rectangle to that
+/// geometry, since the protocol requires that <c>"the anchor rectangle may
+/// not extend outside the window geometry of the positioned child's parent
+/// surface"</c>. Doing the translation worker-side keeps the UI oblivious
+/// to the wayland buffer-vs-geometry distinction.
+/// </summary>
+/// <param name="Size">The size of the popup, in logical surface-local coordinates. Both width and height must be positive.</param>
+/// <param name="AnchorRect">The anchor rectangle in the parent's <b>buffer-relative</b> logical coordinates (true top-left, includes shadow).</param>
+/// <param name="Anchor">The edge/corner of the anchor rect that the popup is anchored to. Uses the NWayland-provided wire enum directly — Avalonia's bitfield <see cref="Avalonia.Controls.Primitives.PopupPositioning.PopupAnchor"/> must be translated explicitly UI-side.</param>
+/// <param name="Gravity">The direction the popup expands from the anchor point. Uses the NWayland-provided wire enum directly — same translation note as <paramref name="Anchor"/>.</param>
+/// <param name="ConstraintAdjustment">How the compositor may adjust the popup if it doesn't fit on screen. NWayland-provided <c>[Flags]</c> wire enum; Avalonia's <see cref="Avalonia.Controls.Primitives.PopupPositioning.PopupPositionerConstraintAdjustment"/> must be translated flag-by-flag UI-side, never reinterpret-cast.</param>
+/// <param name="Offset">Additional offset applied to the resolved popup position (after anchor + gravity have been resolved). Already relative to the popup itself, not the parent — no shadow translation applies.</param>
+[DefinitelyNotARecord]
+internal readonly partial struct XdgPopupPositionerParams(
+    Size Size,
+    Rect AnchorRect,
+    XdgPositioner.AnchorEnum Anchor,
+    XdgPositioner.GravityEnum Gravity,
+    XdgPositioner.ConstraintAdjustmentEnum ConstraintAdjustment,
+    Point Offset);
diff --git a/src/Avalonia.Wayland/Server/ServerSignaler.cs b/src/Avalonia.Wayland/Server/ServerSignaler.cs
new file mode 100644
index 0000000000..8c30662adb
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/ServerSignaler.cs
@@ -0,0 +1,31 @@
+using System;
+
+namespace Avalonia.Wayland.Server;
+
+class ServerSignaler(WaylandWorker worker, Action callback)
+{
+    private object _lock = new object();
+    private bool _signaled;
+    public void Signal()
+    {
+        lock (_lock)
+        {
+            if (_signaled)
+                return;
+            _signaled = true;
+            worker.PostOob(Callback);
+        }
+    }
+
+    void Callback()
+    {
+        lock (_lock)
+        {
+            _signaled = false;
+        }
+
+        callback();
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataDevice.cs b/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataDevice.cs
new file mode 100644
index 0000000000..ba044819ab
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataDevice.cs
@@ -0,0 +1,363 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.SourceGenerator;
+using Avalonia.Wayland.Server.Persistent;
+using NWayland;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Server.Transient.Clipboard;
+
+/// <summary>
+/// Per-seat <see cref="WlDataDevice"/> wrapper. Handles clipboard selection events and DnD events.
+/// Lives on the Wayland thread.
+/// </summary>
+partial class WaylandDataDevice : IDisposable
+{
+    private readonly WlDataDevice _device;
+    private readonly WaylandInputDispatcher _dispatcher;
+    private readonly WlDisplay _display;
+    private readonly WaylandWorker _worker;
+    private readonly Func<RawInputModifiers> _getKeyboardModifiers;
+
+    /// <summary>
+    /// The most recently announced data offer (not yet assigned to selection or DnD).
+    /// Set by the <c>data_offer</c> event, consumed by <c>selection</c> or <c>enter</c>.
+    /// </summary>
+    private WaylandDataOffer? _pendingOffer;
+
+    /// <summary>
+    /// Cookie for the current selection offer.
+    /// Encapsulates the offer and validates staleness on reads.
+    /// </summary>
+    private WaylandOfferCookie? _selectionCookie;
+
+    // DnD session state
+    private WaylandDataOffer? _dndOffer;
+    private WaylandOfferCookie? _dndCookie;
+    private uint _dndSerial;
+    private WSurfaceEventSinkProxy? _dndSink;
+    private Point _dndPosition;
+
+    // Pending drops: offer+cookie moved here on drop(), consumed by FinishDnd/CancelDnd from UI thread
+    [DefinitelyNotARecord]
+    private readonly partial struct PendingDrop(WaylandDataOffer Offer, WaylandOfferCookie Cookie);
+    private readonly List<PendingDrop> _pendingDropOperations = new();
+
+    /// <summary>
+    /// The current clipboard selection offer.
+    /// Valid until a new <c>selection</c> event replaces it or keyboard focus is lost.
+    /// </summary>
+    public WaylandDataOffer? SelectionOffer { get; private set; }
+
+    /// <summary>
+    /// The currently active source we set via <c>set_selection</c>.
+    /// Null if we don't own the clipboard.
+    /// </summary>
+    public WaylandDataSource? ActiveSource { get; set; }
+
+    /// <summary>
+    /// The serial from the most recent input event that can authorize <c>set_selection</c>
+    /// (keyboard enter/key, pointer button, touch down).
+    /// </summary>
+    public uint LastInputSerial { get; set; }
+
+    public WaylandDataDevice(WlDataDevice device, WaylandInputDispatcher dispatcher,
+        WlSeat wlSeat, WlDisplay display, WaylandWorker worker, Func<RawInputModifiers> getKeyboardModifiers)
+    {
+        _device = device;
+        _dispatcher = dispatcher;
+        _display = display;
+        _worker = worker;
+        _getKeyboardModifiers = getKeyboardModifiers;
+    }
+
+    /// <summary>
+    /// Sets the clipboard selection to the given source.
+    /// </summary>
+    public void SetSelection(WaylandDataSource? source)
+    {
+        ActiveSource?.Dispose();
+        ActiveSource = source;
+        _device.SetSelection(source?.WlSource!, LastInputSerial);
+    }
+
+    /// <summary>
+    /// Gets the cookie and MIME type list for the current selection offer.
+    /// Returns <c>(null, null)</c> if there is no valid selection.
+    /// Called from the Wayland thread on behalf of UI-thread queries.
+    /// </summary>
+    public (WaylandOfferCookie? Cookie, string[]? MimeTypes) GetSelectionInfo()
+    {
+        if (SelectionOffer == null || SelectionOffer.MimeTypes.Count == 0)
+            return (null, null);
+
+        var mimeTypes = new string[SelectionOffer.MimeTypes.Count];
+        for (var i = 0; i < SelectionOffer.MimeTypes.Count; i++)
+            mimeTypes[i] = SelectionOffer.MimeTypes[i];
+
+        return (_selectionCookie, mimeTypes);
+    }
+
+    internal void OnDataOffer(WlDataOffer wlOffer, WaylandDataOfferListener listener)
+    {
+        var offer = new WaylandDataOffer(wlOffer);
+        listener.SetWrapper(offer);
+        _pendingOffer = offer;
+    }
+
+    internal void OnSelection(WlDataOffer? wlOffer)
+    {
+        _selectionCookie?.Invalidate();
+        SelectionOffer?.Dispose();
+        _selectionCookie = null;
+
+        if (wlOffer != null && _pendingOffer != null)
+        {
+            SelectionOffer = _pendingOffer;
+            _selectionCookie = new WaylandOfferCookie(this, _pendingOffer, _worker);
+            _pendingOffer = null;
+        }
+        else
+        {
+            SelectionOffer = null;
+            _pendingOffer?.Dispose();
+            _pendingOffer = null;
+        }
+    }
+    
+    internal void OnDndEnter(uint serial, WlSurface? surface, double x, double y)
+    {
+        var offer = _pendingOffer;
+        _pendingOffer = null;
+
+        if (offer == null)
+            return;
+
+        var shellSurface = WaylandInputDispatcher.FindSurfaceForWlSurface(surface);
+        if (shellSurface == null)
+        {
+            offer.Dispose();
+            return;
+        }
+
+        // Clean up any lingering DnD session
+        CleanupDndState();
+
+        _dndOffer = offer;
+        _dndCookie = new WaylandOfferCookie(this, offer, _worker);
+        _dndSerial = serial;
+        _dndSink = shellSurface.EventSink;
+        _dndPosition = new Point(x, y);
+
+        var sourceEffects = ActionsToEffects(offer.SourceActions);
+
+        var mimeTypes = new string[offer.MimeTypes.Count];
+        for (var i = 0; i < offer.MimeTypes.Count; i++)
+            mimeTypes[i] = offer.MimeTypes[i];
+
+        var modifiers = _getKeyboardModifiers();
+
+        _dndSink.OnDragEnter(_dndPosition, mimeTypes, _dndCookie!, sourceEffects, modifiers);
+    }
+
+    internal void OnDndMotion(double x, double y)
+    {
+        _dndPosition = new Point(x, y);
+        _dndSink?.OnDragMotion(_dndPosition, _getKeyboardModifiers());
+    }
+
+    internal void OnDndLeave()
+    {
+        // If active session exists (no preceding drop), notify and clean up.
+        // After drop(), _dndSink is already null so this is a no-op.
+        _dndSink?.OnDragLeave();
+        CleanupDndState();
+    }
+
+    internal void OnDndDrop()
+    {
+        // Move offer+cookie to pending list so they survive CleanupDndState.
+        // The UI thread will consume them via FinishDnd/CancelDnd.
+        if (_dndOffer != null && _dndCookie != null)
+        {
+            _pendingDropOperations.Add(new PendingDrop(_dndOffer, _dndCookie));
+            _dndOffer = null;
+            _dndCookie = null;
+        }
+
+        _dndSink?.OnDrop(_dndPosition, _getKeyboardModifiers());
+
+        // Reset the active session state; pending drops keep the device alive.
+        _dndSink = null;
+        _dndSerial = 0;
+        _dndPosition = default;
+    }
+
+    /// <summary>
+    /// Called from the UI thread (via PostOob) after processing a DragEnter or DragOver event.
+    /// Updates the offer's accepted action and MIME type based on the UI's response.
+    /// </summary>
+    internal void UpdateDndFeedback(DragDropEffects effects)
+    {
+        if (_dndOffer == null)
+            return;
+
+        var (actions, preferred) = EffectsToActionsWithPreferred(effects);
+        _dndOffer.SetActions(actions, preferred);
+
+        if (effects == DragDropEffects.None) 
+            _dndOffer.Accept(_dndSerial, null);
+        else
+        {
+            foreach(var mime in _dndOffer.MimeTypes)
+                _dndOffer.Accept(_dndSerial, mime);
+        }
+    }
+
+    /// <summary>
+    /// Called from the UI thread (via PostOob) after a successful drop.
+    /// Signals to the source that the transfer is complete.
+    /// </summary>
+    internal void FinishDnd()
+    {
+        if (_pendingDropOperations.Count > 0)
+        {
+            var pending = _pendingDropOperations[0];
+            _pendingDropOperations.RemoveAt(0);
+            pending.Offer.Finish();
+            pending.Cookie.Invalidate();
+            pending.Offer.Dispose();
+        }
+    }
+
+    private void CleanupDndState()
+    {
+        _dndCookie?.Invalidate();
+        _dndCookie = null;
+        _dndOffer?.Dispose();
+        _dndOffer = null;
+        _dndSink = null;
+        _dndSerial = 0;
+        _dndPosition = default;
+    }
+    
+    /// <summary>
+    /// Starts a drag-and-drop operation from the given origin surface using the
+    /// trigger event's serial. Called from the Wayland thread.
+    /// </summary>
+    internal bool StartDrag(WaylandDataSource source, object? platformCookie,
+        WlDataDeviceManager.DndActionEnum allowedActions)
+    {
+        if (platformCookie is not WaylandInputEventCookie cookie
+            || !cookie.TryConsume(_display, out _, out var serial))
+            return false;
+
+        source.SetActions(allowedActions);
+
+        // Find the origin surface — the surface that has the implicit pointer grab
+        var originSurface = _dispatcher.FindOriginSurface();
+        if (originSurface == null)
+            return false;
+
+        _device.StartDrag(source.WlSource, originSurface, null!, serial);
+        return true;
+    }
+
+    internal static DragDropEffects ActionsToEffects(WlDataDeviceManager.DndActionEnum actions)
+    {
+        var effects = DragDropEffects.None;
+        if (actions.HasFlag(WlDataDeviceManager.DndActionEnum.Copy))
+            effects |= DragDropEffects.Copy;
+        if (actions.HasFlag(WlDataDeviceManager.DndActionEnum.Move))
+            effects |= DragDropEffects.Move;
+        return effects;
+    }
+
+    internal static WlDataDeviceManager.DndActionEnum EffectsToActions(DragDropEffects effects)
+    {
+        var actions = WlDataDeviceManager.DndActionEnum.None;
+        if (effects.HasFlag(DragDropEffects.Copy))
+            actions |= WlDataDeviceManager.DndActionEnum.Copy;
+        if (effects.HasFlag(DragDropEffects.Move))
+            actions |= WlDataDeviceManager.DndActionEnum.Move;
+        return actions;
+    }
+
+    private static (WlDataDeviceManager.DndActionEnum Actions, WlDataDeviceManager.DndActionEnum Preferred)
+        EffectsToActionsWithPreferred(DragDropEffects effects)
+    {
+        var actions = WlDataDeviceManager.DndActionEnum.None;
+        if (effects.HasFlag(DragDropEffects.Copy))
+            actions |= WlDataDeviceManager.DndActionEnum.Copy;
+        if (effects.HasFlag(DragDropEffects.Move))
+            actions |= WlDataDeviceManager.DndActionEnum.Move;
+
+        // Prefer copy if both are available
+        var preferred = actions.HasFlag(WlDataDeviceManager.DndActionEnum.Copy)
+            ? WlDataDeviceManager.DndActionEnum.Copy
+            : actions;
+
+        return (actions, preferred);
+    }
+
+    public void Dispose()
+    {
+        _selectionCookie?.Invalidate();
+        _selectionCookie = null;
+        SelectionOffer?.Dispose();
+        SelectionOffer = null;
+        CleanupDndState();
+        foreach (var pending in _pendingDropOperations)
+        {
+            pending.Cookie.Invalidate();
+            pending.Offer.Dispose();
+        }
+        _pendingDropOperations.Clear();
+        _pendingOffer?.Dispose();
+        _pendingOffer = null;
+        ActiveSource?.Dispose();
+        ActiveSource = null;
+        _device.Release();
+    }
+}
+
+class WaylandDataDeviceListener : WlDataDevice.Listener
+{
+    private WaylandDataDevice? _wrapper;
+
+    internal void SetWrapper(WaylandDataDevice wrapper) => _wrapper = wrapper;
+
+    protected override void DataOffer(WlDataDevice eventSender, NewId<WlDataOffer, WlDataOffer.Listener> id)
+    {
+        var listener = new WaylandDataOfferListener();
+        var wlOffer = id.GetAndConsume(listener);
+        _wrapper?.OnDataOffer(wlOffer, listener);
+    }
+
+    protected override void Enter(WlDataDevice eventSender, uint serial, WlSurface? surface, WlFixed x, WlFixed y, WlDataOffer? offer)
+    {
+        _wrapper?.OnDndEnter(serial, surface, (double)x, (double)y);
+    }
+
+    protected override void Leave(WlDataDevice eventSender)
+    {
+        _wrapper?.OnDndLeave();
+    }
+
+    protected override void Motion(WlDataDevice eventSender, uint time, WlFixed x, WlFixed y)
+    {
+        _wrapper?.OnDndMotion((double)x, (double)y);
+    }
+
+    protected override void Drop(WlDataDevice eventSender)
+    {
+        _wrapper?.OnDndDrop();
+    }
+
+    protected override void Selection(WlDataDevice eventSender, WlDataOffer? offer)
+    {
+        _wrapper?.OnSelection(offer);
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataOffer.cs b/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataOffer.cs
new file mode 100644
index 0000000000..78064de244
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataOffer.cs
@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Input;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Server.Transient.Clipboard;
+
+/// <summary>
+/// Wraps a <see cref="WlDataOffer"/> received from the compositor.
+/// Collects offered MIME types as they arrive and provides access to the offer's data.
+/// Lives on the Wayland thread.
+/// </summary>
+class WaylandDataOffer : IDisposable
+{
+    private readonly WlDataOffer _offer;
+    private readonly List<string> _mimeTypes = new();
+
+    public IReadOnlyList<string> MimeTypes => _mimeTypes;
+
+    /// <summary>
+    /// Source-advertised DnD actions (set by <c>source_actions</c> event).
+    /// </summary>
+    public WlDataDeviceManager.DndActionEnum SourceActions { get; internal set; }
+
+    /// <summary>
+    /// Compositor-negotiated DnD action (set by <c>action</c> event).
+    /// </summary>
+    public WlDataDeviceManager.DndActionEnum NegotiatedAction { get; internal set; }
+
+    public WaylandDataOffer(WlDataOffer offer)
+    {
+        _offer = offer;
+    }
+
+    internal void AddMimeType(string mimeType)
+    {
+        _mimeTypes.Add(mimeType);
+    }
+
+    /// <summary>
+    /// Checks whether the offer contains the given MIME type.
+    /// </summary>
+    public bool HasMimeType(string mimeType)
+    {
+        foreach (var m in _mimeTypes)
+        {
+            if (m == mimeType)
+                return true;
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// Calls <c>wl_data_offer.receive(mimeType, fd)</c> using a pipe.
+    /// Returns the read-end file descriptor. The caller must close it after reading.
+    /// Returns -1 on failure.
+    /// </summary>
+    public unsafe int Receive(string mimeType)
+    {
+        int* fds = stackalloc int[2];
+        if (Server.Interop.UnsafeNativeMethods.pipe2(fds,
+                Server.Interop.UnsafeNativeMethods.O_CLOEXEC) != 0)
+            return -1;
+
+        _offer.Receive(mimeType, fds[1]);
+        Server.Interop.UnsafeNativeMethods.close(fds[1]);
+        return fds[0];
+    }
+
+    /// <summary>
+    /// Sets accepted DnD actions on this offer.
+    /// </summary>
+    public void SetActions(WlDataDeviceManager.DndActionEnum dndActions,
+        WlDataDeviceManager.DndActionEnum preferredAction)
+    {
+        _offer.SetActions(dndActions, preferredAction);
+    }
+
+    /// <summary>
+    /// Accepts the given MIME type for DnD.
+    /// </summary>
+    public void Accept(uint serial, string? mimeType)
+    {
+        _offer.Accept(serial, mimeType!);
+    }
+
+    /// <summary>
+    /// Signals that the DnD operation is complete.
+    /// </summary>
+    public void Finish()
+    {
+        _offer.Finish();
+    }
+
+    public void Dispose()
+    {
+        _offer.Destroy();
+    }
+}
+
+/// <summary>
+/// Listener for <see cref="WlDataOffer"/> events.
+/// Collects MIME types and forwards DnD action changes.
+/// </summary>
+class WaylandDataOfferListener : WlDataOffer.Listener
+{
+    private WaylandDataOffer? _wrapper;
+
+    /// <summary>
+    /// Sets the wrapper that MIME types should be added to.
+    /// Must be called immediately after the offer is created.
+    /// </summary>
+    internal void SetWrapper(WaylandDataOffer wrapper) => _wrapper = wrapper;
+
+    protected override void Offer(WlDataOffer eventSender, string mimeType)
+    {
+        _wrapper?.AddMimeType(mimeType);
+    }
+
+    protected override void SourceActions(WlDataOffer eventSender, WlDataDeviceManager.DndActionEnum sourceActions)
+    {
+        if (_wrapper != null)
+            _wrapper.SourceActions = sourceActions;
+    }
+
+    protected override void Action(WlDataOffer eventSender, WlDataDeviceManager.DndActionEnum dndAction)
+    {
+        if (_wrapper != null)
+            _wrapper.NegotiatedAction = dndAction;
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataSource.cs b/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataSource.cs
new file mode 100644
index 0000000000..b5732752ca
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandDataSource.cs
@@ -0,0 +1,113 @@
+using System;
+using NWayland;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Server.Transient.Clipboard;
+
+/// <summary>
+/// Wraps a <see cref="WlDataSource"/> created by us (for clipboard set or DnD start).
+/// Handles <c>send</c> (compositor requests data) and <c>cancelled</c> (we lost ownership) events.
+/// Lives on the Wayland thread.
+/// </summary>
+class WaylandDataSource : IDisposable
+{
+    private readonly WlDataSource _source;
+    private bool _destroyed;
+
+    /// <summary>
+    /// Called on the Wayland thread when the compositor requests data for a MIME type.
+    /// The callback receives (mimeType, fd) and must write data and close the fd.
+    /// </summary>
+    public Action<string, int>? OnSend { get; set; }
+
+    /// <summary>
+    /// Called on the Wayland thread when this source has been cancelled
+    /// (another client took clipboard ownership, or DnD was cancelled).
+    /// </summary>
+    public Action? OnCancelled { get; set; }
+
+    /// <summary>
+    /// Called when DnD drop has been performed by the user.
+    /// </summary>
+    public Action? OnDndDropPerformed { get; set; }
+
+    /// <summary>
+    /// Called when the DnD operation has been completed by the destination.
+    /// </summary>
+    public Action? OnDndFinished { get; set; }
+
+    /// <summary>
+    /// Called when the compositor negotiates a DnD action.
+    /// </summary>
+    public Action<WlDataDeviceManager.DndActionEnum>? OnAction { get; set; }
+
+    public WaylandDataSource(WlDataSource source)
+    {
+        _source = source;
+    }
+
+    /// <summary>
+    /// Advertises a MIME type that this source can provide.
+    /// Must be called before <c>set_selection</c> or <c>start_drag</c>.
+    /// </summary>
+    public void Offer(string mimeType)
+    {
+        _source.Offer(mimeType);
+    }
+
+    /// <summary>
+    /// Sets the DnD actions supported by this source.
+    /// </summary>
+    public void SetActions(WlDataDeviceManager.DndActionEnum actions)
+    {
+        _source.SetActions(actions);
+    }
+
+    public WlDataSource WlSource => _source;
+
+    public void Dispose()
+    {
+        if (!_destroyed)
+        {
+            _destroyed = true;
+            _source.Destroy();
+        }
+    }
+}
+
+class WaylandDataSourceListener : WlDataSource.Listener
+{
+    private WaylandDataSource? _wrapper;
+
+    internal void SetWrapper(WaylandDataSource wrapper) => _wrapper = wrapper;
+
+    protected override void Send(WlDataSource eventSender, string mimeType, WaylandFd fd)
+    {
+        _wrapper?.OnSend?.Invoke(mimeType, fd.Consume());
+    }
+
+    protected override void Cancelled(WlDataSource eventSender)
+    {
+        _wrapper?.OnCancelled?.Invoke();
+    }
+
+    protected override void Target(WlDataSource eventSender, string? mimeType)
+    {
+        // DnD target notification — not needed for clipboard
+    }
+
+    protected override void DndDropPerformed(WlDataSource eventSender)
+    {
+        _wrapper?.OnDndDropPerformed?.Invoke();
+    }
+
+    protected override void DndFinished(WlDataSource eventSender)
+    {
+        _wrapper?.OnDndFinished?.Invoke();
+    }
+
+    protected override void Action(WlDataSource eventSender, WlDataDeviceManager.DndActionEnum dndAction)
+    {
+        _wrapper?.OnAction?.Invoke(dndAction);
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandOfferCookie.cs b/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandOfferCookie.cs
new file mode 100644
index 0000000000..d7ceb36ac2
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Clipboard/WaylandOfferCookie.cs
@@ -0,0 +1,86 @@
+using System.Threading.Tasks;
+using Avalonia.Input;
+
+namespace Avalonia.Wayland.Server.Transient.Clipboard;
+
+/// <summary>
+/// Opaque token representing a specific <see cref="WaylandDataOffer"/> on the Wayland thread.
+/// Passed to UI-thread code as an <c>object</c> reference.
+/// <para>
+/// For data reads the UI thread sends this cookie back to the Wayland thread
+/// via <c>InvokeOobAsync</c>, and the cookie performs the receive internally.
+/// For DnD sessions this cookie also carries feedback methods (<see cref="PostUpdateFeedback"/>,
+/// <see cref="PostFinish"/> that route through <c>PostOob</c>.
+/// </para>
+/// All field access happens on the Wayland thread — the UI thread only holds a reference.
+/// </summary>
+class WaylandOfferCookie
+{
+    private readonly WaylandDataDevice _device;
+    private readonly WaylandDataOffer _offer;
+    private readonly WaylandWorker? _worker;
+    private bool _invalidated;
+
+    internal WaylandOfferCookie(WaylandDataDevice device, WaylandDataOffer offer, WaylandWorker? worker)
+    {
+        _device = device;
+        _offer = offer;
+        _worker = worker;
+    }
+
+    /// <summary>
+    /// Called from the Wayland thread when this offer is superseded by a new selection
+    /// or when the device is disposed.
+    /// </summary>
+    internal void Invalidate() => _invalidated = true;
+
+    /// <summary>
+    /// Attempts to receive data for a MIME type from the underlying offer.
+    /// Returns the read-end pipe fd, or -1 if the offer has been invalidated.
+    /// Must be called on the Wayland thread.
+    /// </summary>
+    internal int TryReceive(string mimeType)
+    {
+        if (_invalidated)
+            return -1;
+        return _offer.Receive(mimeType);
+    }
+
+    /// <summary>
+    /// Asynchronously receives data for a MIME type by posting to the Wayland thread.
+    /// Returns the read-end pipe fd, or -1 if the offer has been invalidated.
+    /// Called from the UI thread.
+    /// </summary>
+    internal Task<int> TryReceiveAsync(string mimeType)
+    {
+        if (_worker is null)
+            return Task.FromResult(-1);
+        return _worker.InvokeOobAsync(() => TryReceive(mimeType));
+    }
+
+    /// <summary>
+    /// Posts a DnD feedback update to the Wayland thread.
+    /// Called from UI-thread code after processing a DragEnter or DragOver event.
+    /// </summary>
+    internal void PostUpdateFeedback(DragDropEffects effects)
+    {
+        _worker?.PostOob(() =>
+        {
+            if (!_invalidated)
+                _device.UpdateDndFeedback(effects);
+        });
+    }
+
+    /// <summary>
+    /// Posts a DnD finish signal to the Wayland thread.
+    /// Called from UI-thread code after a successful drop.
+    /// </summary>
+    internal void PostFinish()
+    {
+        _worker?.PostOob(() =>
+        {
+            if (!_invalidated)
+                _device.FinishDnd();
+        });
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/IWaylandTextInputV3Events.cs b/src/Avalonia.Wayland/Server/Transient/IWaylandTextInputV3Events.cs
new file mode 100644
index 0000000000..c93b2f977c
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/IWaylandTextInputV3Events.cs
@@ -0,0 +1,50 @@
+using Avalonia.SourceGenerator;
+using Avalonia.Threading;
+using Avalonia.Wayland.Server;
+
+namespace Avalonia.Wayland.Server.Transient;
+
+/// <summary>
+/// Worker → UI callback interface for <c>zwp_text_input_v3</c>.
+/// All indices are UTF-16 char positions (i.e. .NET <see cref="string"/> indices),
+/// not UTF-8 bytes — the worker performs the conversion before invoking the sink.
+/// </summary>
+/// <remarks>
+/// The worker invokes this method on the worker thread; the generated
+/// <c>WaylandTextInputV3EventsProxy</c> marshals each call to the UI thread.
+/// A single call corresponds to one wayland <c>done</c> batch — the four
+/// operations (clear-preedit, delete-surrounding, commit, new-preedit) are
+/// applied atomically by the UI broker so no other UI work can interleave
+/// between them.
+/// </remarks>
+[GenerateCrossThreadProxy(
+    typeof(DispatcherPriority),
+    "default",
+    GeneratedClassName = "WaylandTextInputV3EventsProxy")]
+internal interface IWaylandTextInputV3Events
+{
+    /// <summary>
+    /// Apply one IME update batch. Operations are applied in protocol
+    /// order: clear current preedit, delete surrounding, insert commit,
+    /// install new preedit.
+    /// </summary>
+    /// <param name="sessionToken">
+    /// The session token last received via <c>IWSurface.SetTextInputActive</c>;
+    /// the UI broker drops batches whose token doesn't match its current
+    /// client epoch.
+    /// </param>
+    /// <param name="deleteBeforeChars">UTF-16 chars to delete before cursor (0 = no delete).</param>
+    /// <param name="deleteAfterChars">UTF-16 chars to delete after cursor (0 = no delete).</param>
+    /// <param name="commitText">Text to commit; null/empty = no commit.</param>
+    /// <param name="preeditText">New preedit text; null/empty = clear preedit.</param>
+    /// <param name="preeditCursorBeginChar">Preedit cursor start (UTF-16 chars; -1 = hidden).</param>
+    /// <param name="preeditCursorEndChar">Preedit cursor end (UTF-16 chars; -1 = hidden).</param>
+    void OnImeUpdate(
+        int sessionToken,
+        int deleteBeforeChars,
+        int deleteAfterChars,
+        string? commitText,
+        string? preeditText,
+        int preeditCursorBeginChar,
+        int preeditCursorEndChar);
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/IWaylandFramebufferSurface.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/IWaylandFramebufferSurface.cs
new file mode 100644
index 0000000000..41e0a26825
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/IWaylandFramebufferSurface.cs
@@ -0,0 +1,44 @@
+using System;
+using Avalonia.Platform;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Server.Transient.Rendering;
+
+/// <summary>
+/// The minimal surface contract <see cref="WaylandFramebuffer"/> needs to attach shm buffers.
+/// Implemented by <see cref="Persistent.WSurface"/> (full toplevel/popup lifecycle) and by
+/// lightweight entities (e.g. cursor surfaces) that own a bare <c>wl_surface</c> without the
+/// xdg-shell configure handshake or frame-callback throttling.
+/// </summary>
+interface IWaylandFramebufferSurface
+{
+    /// <summary>The bound globals for the current connection, or <c>null</c> when disconnected.</summary>
+    WaylandGlobals? Globals { get; }
+
+    /// <summary>The target <c>wl_surface</c>, or <c>null</c> when disconnected.</summary>
+    WlSurface? WlSurface { get; }
+
+    /// <summary>Current readiness of the surface for buffer attachment.</summary>
+    PlatformRenderTargetState State { get; }
+
+    /// <summary>Tracks an active render target so it can be torn down on disconnect.</summary>
+    void RegisterRenderTarget(IDisposable renderTarget);
+
+    /// <summary>Stops tracking a render target.</summary>
+    void UnregisterRenderTarget(IDisposable renderTarget);
+
+    /// <summary>
+    /// Invoked right before a new buffer is attached and committed. Implementations stage any
+    /// per-commit double-buffered state here (frame callback, ack_configure, scale, geometry…).
+    /// Lightweight surfaces can leave this a no-op.
+    /// </summary>
+    void OnBeforeNewBufferAttached(IRenderTarget.RenderTargetSceneInfo sceneInfo);
+
+    /// <summary>
+    /// When <c>true</c>, <see cref="WaylandFramebuffer"/> forces a <c>wl_display</c> roundtrip after
+    /// creating each <c>wl_buffer</c>. libwayland-client only allows a bounded number of file
+    /// descriptors per <c>wl_display_flush</c> (~28, undocumented), so surfaces that create buffers
+    /// outside the throttled render loop (e.g. cursors) must flush eagerly to stay within budget.
+    /// </summary>
+    bool EnforceBufferCreationRoundtrip { get; }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandDmabufFeedback.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandDmabufFeedback.cs
new file mode 100644
index 0000000000..6339c54d0a
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandDmabufFeedback.cs
@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Avalonia.SourceGenerator;
+using NWayland;
+using NWayland.Protocols.LinuxDmabufV1;
+using static Avalonia.Wayland.Server.Interop.UnsafeNativeMethods;
+
+namespace Avalonia.Wayland.Server.Transient.Rendering;
+
+[DefinitelyNotARecord]
+partial struct DmabufFormatModifierPair(uint Format, ulong Modifier);
+
+class DmabufTranche
+{
+    public ulong TargetDevice { get; set; }
+    public List<DmabufFormatModifierPair> Formats { get; } = new();
+    public bool Scanout { get; set; }
+}
+
+class WaylandDmabufFeedback
+{
+    const int PROT_READ = 1;
+    const int MAP_PRIVATE = 2;
+    const int FormatTableEntrySize = 16;
+
+    readonly List<DmabufFormatModifierPair> _formatTable = new();
+
+    ulong _pendingTargetDevice;
+    List<DmabufFormatModifierPair> _pendingFormats = new();
+    bool _pendingScanout;
+
+    public ulong MainDevice { get; private set; }
+    public List<DmabufTranche> Tranches { get; } = new();
+    public bool IsComplete { get; private set; }
+    public FeedbackListener Listener { get; }
+
+    public WaylandDmabufFeedback()
+    {
+        Listener = new FeedbackListener(this);
+    }
+
+    void ResetPendingTranche()
+    {
+        _pendingTargetDevice = 0;
+        _pendingFormats = new List<DmabufFormatModifierPair>();
+        _pendingScanout = false;
+    }
+
+    internal unsafe class FeedbackListener(WaylandDmabufFeedback feedback) : ZwpLinuxDmabufFeedbackV1.Listener
+    {
+        protected override void FormatTable(ZwpLinuxDmabufFeedbackV1 eventSender, WaylandFd fd, uint size)
+        {
+            var rawFd = fd.Consume();
+            var length = (IntPtr)size;
+            var map = mmap(IntPtr.Zero, length, PROT_READ, MAP_PRIVATE, rawFd, IntPtr.Zero);
+            if (map == (IntPtr)(-1))
+            {
+                close(rawFd);
+                return;
+            }
+            try
+            {
+                // The table contains a tightly packed array of consecutive format + modifier
+                // pairs. Each pair is 16 bytes wide. It contains a format as a 32-bit unsigned
+                // integer, followed by 4 bytes of unused padding, and a modifier as a 64-bit
+                // unsigned integer. The native endianness is used.
+                var count = (int)(size / FormatTableEntrySize);
+                var ptr = (byte*)map;
+                feedback._formatTable.Clear();
+                for (var i = 0; i < count; i++)
+                {
+                    var entryPtr = ptr + i * FormatTableEntrySize;
+                    var format = *(uint*)entryPtr;
+                    var modifier = *(ulong*)(entryPtr + 8);
+                    feedback._formatTable.Add(new DmabufFormatModifierPair(format, modifier));
+                }
+            }
+            finally
+            {
+                munmap(map, length);
+                close(rawFd);
+            }
+        }
+
+        protected override void MainDevice(ZwpLinuxDmabufFeedbackV1 eventSender, ReadOnlySpan<byte> device)
+        {
+            feedback.MainDevice = MemoryMarshal.Read<ulong>(device);
+        }
+
+        protected override void TrancheTargetDevice(ZwpLinuxDmabufFeedbackV1 eventSender, ReadOnlySpan<byte> device)
+        {
+            feedback._pendingTargetDevice = MemoryMarshal.Read<ulong>(device);
+        }
+
+        protected override void TrancheFormats(ZwpLinuxDmabufFeedbackV1 eventSender, ReadOnlySpan<byte> indices)
+        {
+            var count = indices.Length / 2;
+            var span = MemoryMarshal.Cast<byte, ushort>(indices);
+            for (var i = 0; i < count; i++)
+            {
+                var index = span[i];
+                if (index < feedback._formatTable.Count)
+                    feedback._pendingFormats.Add(feedback._formatTable[index]);
+            }
+        }
+
+        protected override void TrancheFlags(ZwpLinuxDmabufFeedbackV1 eventSender,
+            ZwpLinuxDmabufFeedbackV1.TrancheFlagsEnum flags)
+        {
+            feedback._pendingScanout = flags.HasFlag(ZwpLinuxDmabufFeedbackV1.TrancheFlagsEnum.Scanout);
+        }
+
+        protected override void TrancheDone(ZwpLinuxDmabufFeedbackV1 eventSender)
+        {
+            var tranche = new DmabufTranche
+            {
+                TargetDevice = feedback._pendingTargetDevice,
+                Scanout = feedback._pendingScanout
+            };
+            tranche.Formats.AddRange(feedback._pendingFormats);
+            feedback.Tranches.Add(tranche);
+            feedback.ResetPendingTranche();
+        }
+
+        protected override void Done(ZwpLinuxDmabufFeedbackV1 eventSender)
+        {
+            feedback.IsComplete = true;
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDisplay.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDisplay.cs
new file mode 100644
index 0000000000..132a82b171
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDisplay.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.OpenGL.Egl;
+using NWayland.Protocols.LinuxDmabufV1;
+
+namespace Avalonia.Wayland.Server.Transient.Rendering;
+
+internal class WaylandEglDisplay : EglDisplay
+{
+    public IntPtr GbmDevice { get; }
+    public int DrmFd { get; }
+    public List<DmabufFormatModifierPair> SupportedFormats { get; }
+    public ZwpLinuxDmabufV1 LinuxDmabuf { get; }
+    
+    public WaylandEglDisplay(
+        EglDisplayCreationOptions options,
+        IntPtr gbmDevice,
+        int drmFd,
+        ZwpLinuxDmabufV1 linuxDmabuf) : base(options)
+    {
+        GbmDevice = gbmDevice;
+        DrmFd = drmFd;
+        SupportedFormats = new List<DmabufFormatModifierPair>();
+        LinuxDmabuf = linuxDmabuf;
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufPlatformGraphics.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufPlatformGraphics.cs
new file mode 100644
index 0000000000..8bfeb9a646
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufPlatformGraphics.cs
@@ -0,0 +1,231 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Avalonia.Logging;
+using Avalonia.OpenGL;
+using Avalonia.OpenGL.Egl;
+using Avalonia.Platform;
+using Avalonia.Platform.Surfaces;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Persistent;
+using static Avalonia.OpenGL.Egl.EglConsts;
+using static Avalonia.Wayland.Server.Interop.DrmGbmUnsafeNativeMethods;
+
+namespace Avalonia.Wayland.Server.Transient.Rendering;
+
+internal sealed unsafe class WaylandEglDmaBufPlatformGraphics : WaylandPlatformGraphics.IWaylandGraphics
+{
+    public WaylandEglDisplay Display { get; }
+
+    public IPlatformGraphicsContext CreateContext() => Display.CreateContext(null);
+
+    public IPlatformRenderSurface CreateRenderSurface(WSurface surface) => new WaylandEglDmaBufSurface(surface);
+
+    private WaylandEglDmaBufPlatformGraphics(WaylandEglDisplay display)
+    {
+        Display = display;
+    }
+
+    internal static WaylandEglDmaBufPlatformGraphics? TryCreate(WaylandConnection connection, WaylandGlobals globals,
+        IList<GlVersion> glProfiles)
+    {
+        try
+        {
+            return Create(connection, globals, glProfiles);
+        }
+        catch (Exception e)
+        {
+            Logger.TryGet(LogEventLevel.Error, "OpenGL")?.Log(null,
+                "Unable to initialize Wayland EGL rendering: {0}", e);
+            return null;
+        }
+    }
+
+    // libEGL.so.1 only exports EGL 1.5 core entry points. Extension entry
+    // points like eglGetPlatformDisplayEXT / eglQueryDmaBufFormatsEXT are
+    // NOT exported as symbols and can only be resolved via eglGetProcAddress.
+    [DllImport("libEGL.so.1", CharSet = CharSet.Ansi)]
+    private static extern IntPtr eglGetProcAddress(string proc);
+
+    private static WaylandEglDmaBufPlatformGraphics? Create(WaylandConnection connection, WaylandGlobals globals,
+        IList<GlVersion> glProfiles)
+    {
+        var dmabuf = globals.LinuxDmabuf;
+        if (dmabuf == null)
+        {
+            Logger.TryGet(LogEventLevel.Warning, "OpenGL")?.Log(null,
+                "zwp_linux_dmabuf_v1 not available");
+            return null;
+        }
+
+        // Request default feedback from the compositor
+        var feedback = new WaylandDmabufFeedback();
+        dmabuf.GetDefaultFeedback(feedback.Listener);
+        connection.Queue.Roundtrip();
+
+        if (!feedback.IsComplete)
+        {
+            Logger.TryGet(LogEventLevel.Warning, "OpenGL")?.Log(null,
+                "Dmabuf feedback not received from compositor");
+            return null;
+        }
+
+        // Find the DRM render node matching the compositor's main device
+        var renderNodePath = FindRenderNode(feedback.MainDevice);
+        if (renderNodePath == null)
+        {
+            Logger.TryGet(LogEventLevel.Warning, "OpenGL")?.Log(null,
+                "No DRM render node found for device {0}", feedback.MainDevice);
+            return null;
+        }
+
+        // Open the DRM render node and create GBM device
+        var drmFd = open(renderNodePath, O_RDWR);
+        if (drmFd < 0)
+            throw new InvalidOperationException($"Failed to open DRM render node: {renderNodePath}");
+
+        var gbmDevice = IntPtr.Zero;
+        WaylandEglDisplay? display = null;
+        try
+        {
+            gbmDevice = gbm_create_device(drmFd);
+            if (gbmDevice == IntPtr.Zero)
+                throw new InvalidOperationException("Failed to create GBM device");
+
+            // Capture for the dispose callback — closures capture variables, not values
+            var capturedDrmFd = drmFd;
+            var capturedGbm = gbmDevice;
+
+            var options = new EglDisplayCreationOptions
+            {
+                Egl = new EglInterface(eglGetProcAddress),
+                PlatformType = EGL_PLATFORM_GBM_KHR,
+                PlatformDisplay = gbmDevice,
+                SupportsMultipleContexts = true,
+                SupportsContextSharing = true,
+                DisposeCallback = () =>
+                {
+                    gbm_device_destroy(capturedGbm);
+                    close(capturedDrmFd);
+                },
+                GlVersions = glProfiles
+            };
+
+            display = new WaylandEglDisplay(options, gbmDevice, drmFd, dmabuf);
+
+            var extensions = display.EglInterface.QueryString(display.Handle, EGL_EXTENSIONS)?.Split(' ') ?? [];
+            void CheckExtension(string ext)
+            {
+                if (!extensions.Contains(ext))
+                    throw new OpenGlException($"Required EGL extension {ext} is not supported");
+            }
+            
+            CheckExtension("EGL_KHR_image_base");
+            CheckExtension("EGL_EXT_image_dma_buf_import");
+
+            var supportedFormats = NegotiateFormats(display, feedback);
+            if (supportedFormats.Count == 0)
+                supportedFormats.Add(new DmabufFormatModifierPair(DRM_FORMAT_ARGB8888, DRM_FORMAT_MOD_INVALID));
+            display.SupportedFormats.AddRange(supportedFormats);
+
+            return new WaylandEglDmaBufPlatformGraphics(display);
+        }
+        catch
+        {
+            if (display != null)
+            {
+                // EglDisplay.Dispose triggers DisposeCallback which handles GBM + DRM fd
+                display.Dispose();
+            }
+            else
+            {
+                if (gbmDevice != IntPtr.Zero)
+                    gbm_device_destroy(gbmDevice);
+                close(drmFd);
+            }
+
+            throw;
+        }
+    }
+
+    private static List<DmabufFormatModifierPair> NegotiateFormats(
+        EglDisplay display, WaylandDmabufFeedback feedback)
+    {
+        var egl = display.EglInterface;
+        var negotiated = new List<DmabufFormatModifierPair>();
+
+        // Collect all format/modifier pairs from feedback tranches
+        var feedbackFormats = new HashSet<(uint format, ulong modifier)>();
+        foreach (var tranche in feedback.Tranches)
+            foreach (var fmt in tranche.Formats)
+                feedbackFormats.Add((fmt.Format, fmt.Modifier));
+
+        if (feedbackFormats.Count == 0)
+            return negotiated;
+
+        var uniqueFormats = new HashSet<uint>();
+        foreach (var (format, _) in feedbackFormats)
+            uniqueFormats.Add(format);
+
+        foreach (var format in uniqueFormats)
+        {
+            if (!egl.IsQueryDmaBufModifiersEXTAvailable)
+            {
+                // Modifier query unavailable — only accept implicit modifier
+                foreach (var (fmt, mod) in feedbackFormats)
+                    if (fmt == format && mod == DRM_FORMAT_MOD_INVALID)
+                        negotiated.Add(new DmabufFormatModifierPair(fmt, mod));
+                continue;
+            }
+
+            // Query how many modifiers EGL supports for this format
+            if (!egl.QueryDmaBufModifiersEXT(display.Handle, (int)format, 0, null, null, out var count)
+                || count == 0)
+                continue;
+
+            // Retrieve the actual modifier list
+            var eglModifiers = new ulong[count];
+            fixed (ulong* ptr = eglModifiers)
+            {
+                if (!egl.QueryDmaBufModifiersEXT(display.Handle, (int)format, count, ptr, null, out _))
+                    continue;
+            }
+
+            var eglModSet = new HashSet<ulong>(eglModifiers);
+
+            // Keep formats whose modifier is supported by EGL or is the implicit modifier
+            foreach (var (fmt, mod) in feedbackFormats)
+            {
+                if (fmt != format)
+                    continue;
+                if (eglModSet.Contains(mod) || mod == DRM_FORMAT_MOD_INVALID)
+                    negotiated.Add(new DmabufFormatModifierPair(fmt, mod));
+            }
+        }
+
+        return negotiated;
+    }
+
+    private static unsafe string? FindRenderNode(ulong mainDevice)
+    {
+        if (drmGetDeviceFromDevId(mainDevice, 0, out var device) != 0 || device == null)
+            return null;
+
+        try
+        {
+            if ((device->AvailableNodes & (1 << DRM_NODE_RENDER)) == 0)
+                return null;
+
+            return Marshal.PtrToStringAnsi(device->Nodes[DRM_NODE_RENDER]);
+        }
+        finally
+        {
+            drmFreeDevice(&device);
+        }
+    }
+
+    public void Dispose()
+    {
+        Display.Dispose();
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufSurface.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufSurface.cs
new file mode 100644
index 0000000000..8917a6e18c
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufSurface.cs
@@ -0,0 +1,371 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.OpenGL;
+using Avalonia.OpenGL.Egl;
+using Avalonia.OpenGL.Surfaces;
+using Avalonia.Platform;
+using Avalonia.Platform.Surfaces;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Persistent;
+using NWayland;
+using NWayland.Protocols.LinuxDmabufV1;
+using NWayland.Protocols.Wayland;
+using static Avalonia.OpenGL.Egl.EglConsts;
+using static Avalonia.Wayland.Server.Interop.DrmGbmUnsafeNativeMethods;
+
+namespace Avalonia.Wayland.Server.Transient.Rendering;
+
+internal class WaylandEglDmaBufSurface : EglGlPlatformImageSurfaceBase, IPlatformRenderSurface
+{
+    private readonly WSurface _surface;
+
+    public WaylandEglDmaBufSurface(WSurface surface)
+    {
+        _surface = surface;
+    }
+
+    public bool IsReady => _surface.State.IsReady;
+
+    public override IGlPlatformSurfaceRenderTarget CreateGlRenderTarget(IGlContext context)
+        => new RenderTarget(this, (EglContext)context);
+
+    private class RenderTarget : EglPlatformImageSurfaceRenderTargetBase
+    {
+        private readonly WaylandEglDmaBufSurface _parent;
+        private readonly WaylandEglDisplay _waylandDisplay;
+
+        // TODO: Reduce to 2 or 3 if explicit sync is supported (once we implement it)
+        private const int SwapchainSize = 4;
+        private BufferSlot[]? _slots;
+        private List<BufferSlot>? _pendingDestroy;
+        private PixelSize _currentSize;
+        private ulong _frameCounter;
+
+        public RenderTarget(WaylandEglDmaBufSurface parent, EglContext context) : base(context)
+        {
+            _parent = parent;
+            _waylandDisplay = (WaylandEglDisplay)context.Display;
+            parent._surface.RegisterRenderTarget(this);
+        }
+
+        public override IGlPlatformSurfaceRenderingSession BeginDrawCore(
+            IRenderTarget.RenderTargetSceneInfo sceneInfo)
+        {
+            if (!_parent._surface.State.IsReady)
+                throw new RenderTargetNotReadyException();
+
+            EnsureSwapchain(sceneInfo.Size);
+
+            // Select least recently used free slot
+            BufferSlot? freeSlot = null;
+            foreach (var slot in _slots!)
+            {
+                if (!slot.Busy && (freeSlot == null || slot.LastUsedFrame < freeSlot.LastUsedFrame))
+                    freeSlot = slot;
+            }
+
+            if (freeSlot == null)
+                throw new InvalidOperationException("No free buffer slots available in swapchain");
+
+            var capturedSlot = freeSlot;
+            capturedSlot.LastUsedFrame = ++_frameCounter;
+            return BeginDraw(capturedSlot.EglImage!.Handle, sceneInfo.Size, sceneInfo.Scaling, () =>
+            {
+                // Stage per-frame state (frame callback + ack_configure +
+                // geometry + viewport/scale + min/max) into the next
+                // commit BEFORE binding the buffer, then commit explicitly
+                // after attach + damage. The base WSurface no longer
+                // issues the commit itself.
+                _parent._surface.OnBeforeNewBufferAttached(sceneInfo);
+                _parent._surface.WlSurface!.Attach(capturedSlot.WlBuffer!, 0, 0);
+                _parent._surface.WlSurface.DamageBuffer(0, 0, sceneInfo.Size.Width, sceneInfo.Size.Height);
+                capturedSlot.Busy = true;
+                _parent._surface.WlSurface.Commit();
+            });
+        }
+
+        public override PlatformRenderTargetState State =>
+            IsCorrupted ? PlatformRenderTargetState.Corrupted
+            : _disposed ? PlatformRenderTargetState.Disposed
+            : _parent._surface.State;
+
+        private bool _disposed;
+
+        public override void Dispose()
+        {
+            if (_disposed) return;
+            _disposed = true;
+            _parent._surface.UnregisterRenderTarget(this);
+            DestroySwapchain();
+            if (_pendingDestroy != null)
+            {
+                foreach (var slot in _pendingDestroy)
+                    slot.Dispose();
+                _pendingDestroy = null;
+            }
+            base.Dispose();
+        }
+
+        private unsafe void EnsureSwapchain(PixelSize size)
+        {
+            if (_slots != null && _currentSize == size)
+                return;
+
+            DestroySwapchain();
+
+            _slots = new BufferSlot[SwapchainSize];
+            _currentSize = size;
+
+            var format = DRM_FORMAT_ARGB8888;
+
+            // Collect modifiers for the chosen format
+            var modifiers = _waylandDisplay.SupportedFormats
+                .Where(f => f.Format == format)
+                .Select(f => f.Modifier)
+                .ToArray();
+
+            for (var i = 0; i < SwapchainSize; i++)
+            {
+                var slot = new BufferSlot { Format = format };
+                try
+                {
+                    // Allocate GBM buffer object
+                    IntPtr bo = IntPtr.Zero;
+                    if (modifiers.Length > 0)
+                    {
+                        fixed (ulong* modsPtr = modifiers)
+                        {
+                            bo = gbm_bo_create_with_modifiers2(
+                                _waylandDisplay.GbmDevice, (uint)size.Width, (uint)size.Height,
+                                format, modsPtr, (uint)modifiers.Length, GbmBoFlags.GBM_BO_USE_RENDERING);
+                        }
+                    }
+
+                    if (bo == IntPtr.Zero)
+                    {
+                        bo = gbm_bo_create(
+                            _waylandDisplay.GbmDevice, (uint)size.Width, (uint)size.Height,
+                            format, GbmBoFlags.GBM_BO_USE_RENDERING);
+                    }
+
+                    if (bo == IntPtr.Zero)
+                        throw new InvalidOperationException("Failed to create GBM buffer object");
+
+                    slot.GbmBo = bo;
+
+                    // Export DMA-BUF planes
+                    var planeCount = gbm_bo_get_plane_count(bo);
+                    slot.PlaneCount = planeCount;
+                    slot.Modifier = gbm_bo_get_modifier(bo);
+                    slot.DmaBufFds = new int[planeCount];
+                    slot.Strides = new uint[planeCount];
+                    slot.Offsets = new uint[planeCount];
+
+                    for (var p = 0; p < planeCount; p++)
+                    {
+                        var handle = gbm_bo_get_handle_for_plane(bo, p);
+                        if (drmPrimeHandleToFD(_waylandDisplay.DrmFd, handle.U32, 0, out slot.DmaBufFds[p]) != 0)
+                            throw new InvalidOperationException($"drmPrimeHandleToFD failed for plane {p}");
+                        slot.Strides[p] = gbm_bo_get_stride_for_plane(bo, p);
+                        slot.Offsets[p] = gbm_bo_get_offset(bo, p);
+                    }
+
+                    // Create EGLImage from DMA-BUF
+                    var attribs = new List<int>
+                    {
+                        EGL_WIDTH, (int)gbm_bo_get_width(bo),
+                        EGL_HEIGHT, (int)gbm_bo_get_height(bo),
+                        EGL_LINUX_DRM_FOURCC_EXT, (int)gbm_bo_get_format(bo),
+                    };
+
+                    for (var p = 0; p < planeCount; p++)
+                        AddPlaneAttribs(attribs, p, slot.DmaBufFds[p], slot.Offsets[p],
+                            slot.Strides[p], slot.Modifier);
+
+                    attribs.Add(EGL_NONE);
+
+                    var imageHandle = _waylandDisplay.EglInterface.CreateImageKHR(
+                        _waylandDisplay.Handle, EGL_NO_CONTEXT,
+                        EGL_LINUX_DMA_BUF_EXT, IntPtr.Zero, attribs.ToArray());
+
+                    if (imageHandle == IntPtr.Zero)
+                        throw new InvalidOperationException("eglCreateImageKHR failed");
+
+                    slot.EglImage = new EglImage(_waylandDisplay, imageHandle);
+
+                    // Create temp queue for roundtrip
+                    using var tempQueue = _waylandDisplay.LinuxDmabuf.Display.CreateEventQueue();
+                    // Create wl_buffer via zwp_linux_buffer_params_v1
+                    var result = new DmaBufCreateParamsListener(new BufferReleaseListener(this, slot));
+                    using var args = _waylandDisplay.LinuxDmabuf.CreateParams(result, tempQueue);
+                    for (var p = 0; p < planeCount; p++)
+                    {
+                        args.Add(slot.DmaBufFds[p], (uint)p, slot.Offsets[p], slot.Strides[p],
+                            (uint)(slot.Modifier >> 32), (uint)(slot.Modifier & 0xFFFFFFFF));
+                    }
+                    args.Create(size.Width, size.Height, format, default);
+                    tempQueue.Roundtrip();
+                    if (result.Buffer == null)
+                        throw new OpenGlException("Unable to create DMA-BUF on Wayland server side");
+                    slot.WlBuffer = result.Buffer;
+                    // Put buffer back on our main queue
+                    result.Buffer.SetQueue(_waylandDisplay.LinuxDmabuf.Queue);
+
+                    _slots[i] = slot;
+                }
+                catch
+                {
+                    slot.Dispose();
+                    throw;
+                }
+            }
+        }
+
+        class DmaBufCreateParamsListener(BufferReleaseListener bufferReleaseListener) : ZwpLinuxBufferParamsV1.Listener
+        {
+            public WlBuffer? Buffer { get; private set; } 
+            protected override void Created(ZwpLinuxBufferParamsV1 eventSender, NewId<WlBuffer, WlBuffer.Listener> buffer)
+            {
+                Buffer = buffer.GetAndConsume(bufferReleaseListener);
+            }
+        }
+
+        private static void AddPlaneAttribs(List<int> attribs, int plane, int fd,
+            uint offset, uint stride, ulong modifier)
+        {
+            int baseFd, baseOffset, basePitch, baseModLo, baseModHi;
+            switch (plane)
+            {
+                case 0:
+                    baseFd = EGL_DMA_BUF_PLANE0_FD_EXT;
+                    baseOffset = EGL_DMA_BUF_PLANE0_OFFSET_EXT;
+                    basePitch = EGL_DMA_BUF_PLANE0_PITCH_EXT;
+                    baseModLo = EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT;
+                    baseModHi = EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT;
+                    break;
+                case 1:
+                    baseFd = EGL_DMA_BUF_PLANE1_FD_EXT;
+                    baseOffset = EGL_DMA_BUF_PLANE1_OFFSET_EXT;
+                    basePitch = EGL_DMA_BUF_PLANE1_PITCH_EXT;
+                    baseModLo = EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT;
+                    baseModHi = EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT;
+                    break;
+                case 2:
+                    baseFd = EGL_DMA_BUF_PLANE2_FD_EXT;
+                    baseOffset = EGL_DMA_BUF_PLANE2_OFFSET_EXT;
+                    basePitch = EGL_DMA_BUF_PLANE2_PITCH_EXT;
+                    baseModLo = EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT;
+                    baseModHi = EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT;
+                    break;
+                case 3:
+                    baseFd = EGL_DMA_BUF_PLANE3_FD_EXT;
+                    baseOffset = EGL_DMA_BUF_PLANE3_OFFSET_EXT;
+                    basePitch = EGL_DMA_BUF_PLANE3_PITCH_EXT;
+                    baseModLo = EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT;
+                    baseModHi = EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT;
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(plane));
+            }
+
+            attribs.Add(baseFd);
+            attribs.Add(fd);
+            attribs.Add(baseOffset);
+            attribs.Add((int)offset);
+            attribs.Add(basePitch);
+            attribs.Add((int)stride);
+
+            if (modifier != DRM_FORMAT_MOD_INVALID)
+            {
+                attribs.Add(baseModLo);
+                attribs.Add((int)(modifier & 0xFFFFFFFF));
+                attribs.Add(baseModHi);
+                attribs.Add((int)(modifier >> 32));
+            }
+        }
+
+        private void DestroySwapchain()
+        {
+            if (_slots == null)
+                return;
+            foreach (var slot in _slots)
+            {
+                if (slot == null)
+                    continue;
+                if (slot.Busy)
+                {
+                    // Defer destruction of busy buffers until compositor releases them
+                    _pendingDestroy ??= new List<BufferSlot>();
+                    _pendingDestroy.Add(slot);
+                }
+                else
+                {
+                    slot.Dispose();
+                }
+            }
+            _slots = null;
+            _currentSize = default;
+        }
+
+        private void OnBufferReleased(BufferSlot slot)
+        {
+            slot.Busy = false;
+            if (_pendingDestroy != null && _pendingDestroy.Remove(slot))
+                slot.Dispose();
+        }
+
+        private class BufferSlot : IDisposable
+        {
+            public IntPtr GbmBo;
+            public int[]? DmaBufFds;
+            public uint[]? Strides;
+            public uint[]? Offsets;
+            public int PlaneCount;
+            public ulong Modifier;
+            public uint Format;
+            public EglImage? EglImage;
+            public WlBuffer? WlBuffer;
+            public bool Busy;
+            public ulong LastUsedFrame;
+
+            public void Dispose()
+            {
+                EglImage?.Dispose();
+                EglImage = null;
+
+                if (WlBuffer != null)
+                {
+                    WlBuffer.Destroy();
+                    WlBuffer.Dispose();
+                    WlBuffer = null;
+                }
+
+                if (DmaBufFds != null)
+                {
+                    foreach (var fd in DmaBufFds)
+                    {
+                        if (fd >= 0)
+                            close(fd);
+                    }
+
+                    DmaBufFds = null;
+                }
+
+                if (GbmBo != IntPtr.Zero)
+                {
+                    gbm_bo_destroy(GbmBo);
+                    GbmBo = IntPtr.Zero;
+                }
+            }
+        }
+
+        private class BufferReleaseListener(RenderTarget renderTarget, BufferSlot slot) : WlBuffer.Listener
+        {
+            protected override void Release(WlBuffer eventSender)
+            {
+                renderTarget.OnBufferReleased(slot);
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiPlatformGraphics.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiPlatformGraphics.cs
new file mode 100644
index 0000000000..b80c4d8e97
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiPlatformGraphics.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Avalonia.Logging;
+using Avalonia.OpenGL;
+using Avalonia.OpenGL.Egl;
+using Avalonia.Platform;
+using Avalonia.Platform.Surfaces;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Persistent;
+
+namespace Avalonia.Wayland.Server.Transient.Rendering;
+
+/// <summary>
+/// EGL platform-graphics backend that uses the standard Wayland WSI path:
+/// <c>EGL_PLATFORM_WAYLAND_KHR</c> over <c>wl_display*</c>, with per-surface
+/// <c>wl_egl_window</c> backing buffers. The driver owns buffer allocation,
+/// modifier negotiation, presentation and the implicit <c>wl_surface.commit</c>
+/// performed inside <c>eglSwapBuffers</c>.
+///
+/// This is the default backend; the dmabuf-based
+/// <see cref="WaylandEglDmaBufPlatformGraphics"/> path is opt-in via
+/// <c>WaylandPlatformOptions.UseDmabufSwapchain</c>.
+/// </summary>
+internal sealed class WaylandEglWsiPlatformGraphics : WaylandPlatformGraphics.IWaylandGraphics
+{
+    public EglDisplay Display { get; }
+
+    public IPlatformGraphicsContext CreateContext() => Display.CreateContext(null);
+
+    public IPlatformRenderSurface CreateRenderSurface(WSurface surface) => new WaylandEglWsiSurface(surface);
+
+    private WaylandEglWsiPlatformGraphics(EglDisplay display)
+    {
+        Display = display;
+    }
+
+    // libEGL.so.1 only exports EGL 1.5 core entry points. Extension entry
+    // points like eglGetPlatformDisplayEXT are NOT exported as symbols and
+    // can only be resolved via eglGetProcAddress; without this, EglInterface
+    // would fail to bind it and EGL_PLATFORM_WAYLAND_KHR display creation
+    // wouldn't work.
+    [DllImport("libEGL.so.1", CharSet = CharSet.Ansi)]
+    private static extern IntPtr eglGetProcAddress(string proc);
+
+    private const int EGL_PLATFORM_WAYLAND_KHR = 0x31D8;
+
+    public static WaylandEglWsiPlatformGraphics? TryCreate(WaylandConnection connection, IList<GlVersion> glProfiles)
+    {
+        try
+        {
+            var options = new EglDisplayCreationOptions
+            {
+                Egl = new EglInterface(eglGetProcAddress),
+                PlatformType = EGL_PLATFORM_WAYLAND_KHR,
+                PlatformDisplay = connection.Display.Handle,
+                SupportsMultipleContexts = true,
+                SupportsContextSharing = true,
+                GlVersions = glProfiles
+            };
+            var display = new EglDisplay(options);
+            return new WaylandEglWsiPlatformGraphics(display);
+        }
+        catch (Exception e)
+        {
+            Logger.TryGet(LogEventLevel.Error, "OpenGL")?.Log(null,
+                "Unable to initialize Wayland WSI EGL rendering: {0}", e);
+            return null;
+        }
+    }
+
+    public void Dispose() => Display.Dispose();
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs
new file mode 100644
index 0000000000..eac37ffc37
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs
@@ -0,0 +1,135 @@
+using System;
+using Avalonia.OpenGL;
+using Avalonia.OpenGL.Egl;
+using Avalonia.OpenGL.Surfaces;
+using Avalonia.Platform;
+using Avalonia.Platform.Surfaces;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Persistent;
+using static Avalonia.OpenGL.GlConsts;
+
+namespace Avalonia.Wayland.Server.Transient.Rendering;
+
+/// <summary>
+/// WSI-based EGL render surface. Wraps the owning <see cref="WSurface"/>'s
+/// <c>wl_surface</c> in a <c>wl_egl_window</c> and lets the EGL driver own
+/// buffer allocation and presentation. <c>eglSwapBuffers</c> is the
+/// implicit <c>wl_surface.commit</c> point — we never call commit ourselves
+/// on this path.
+/// </summary>
+internal sealed class WaylandEglWsiSurface : EglGlPlatformSurfaceBase, IPlatformRenderSurface
+{
+    private readonly WSurface _surface;
+
+    public WaylandEglWsiSurface(WSurface surface)
+    {
+        _surface = surface;
+    }
+
+    public bool IsReady => _surface.State.IsReady;
+
+    public override IGlPlatformSurfaceRenderTarget CreateGlRenderTarget(IGlContext context)
+        => new RenderTarget(_surface, (EglContext)context);
+
+    private sealed class RenderTarget : EglPlatformSurfaceRenderTargetBase
+    {
+        private readonly WSurface _surface;
+        private IntPtr _eglWindow;
+        private EglSurface? _eglSurface;
+        private PixelSize _currentSize;
+
+        public RenderTarget(WSurface surface, EglContext context) : base(context)
+        {
+            _surface = surface;
+        }
+        
+        protected override bool SkipWaits => true;
+
+        public override PlatformRenderTargetState State =>
+            IsCorrupted ? PlatformRenderTargetState.Corrupted : _surface.State;
+
+        public override IGlPlatformSurfaceRenderingSession BeginDrawCore(IRenderTarget.RenderTargetSceneInfo sceneInfo)
+        {
+            if (!_surface.State.IsReady)
+                throw new RenderTargetNotReadyException();
+
+            EnsureWindow(sceneInfo.Size);
+
+            // OnBeforeNewBufferAttached must run *immediately* before the
+            // implicit commit performed by eglSwapBuffers; the base class
+            // invokes beforeSwap right before the swap call.
+            //
+            // SwapInterval(0) is set inside beforeSwap (so it runs with our
+            // surface current); GTK re-asserts it every frame defensively
+            // and we follow suit — some drivers reset it on resize.
+            var session = BeginDraw(_eglSurface!, sceneInfo.Size, sceneInfo.Scaling,
+                beforeSwap: () =>
+                {
+                    var display = Context.Display;
+                    display.EglInterface.SwapInterval(display.Handle, 0);
+                    _surface.OnBeforeNewBufferAttached(sceneInfo);
+                });
+            var err = session.Context.GlInterface.GetError();
+            // Workaround for driver quirk https://github.com/NVIDIA/egl-wayland2/issues/46
+            // This is NVIDIA-specific, but setting buffers to GL_BACK won't hurt for other drivers too
+            if (session.Context.Version.Type == GlProfileType.OpenGL)
+            {
+                var gl = session.Context.GlInterface;
+                gl.Viewport(0, 0, sceneInfo.Size.Width, sceneInfo.Size.Height);
+                if (gl.IsReadBufferAvailable)
+                    gl.ReadBuffer(GL_BACK);
+                if (gl.IsWriteBufferAvailable)
+                    gl.WriteBuffer(GL_BACK);
+                if(gl.IsDrawBufferAvailable)
+                    gl.DrawBuffer(GL_BACK);
+            }
+
+            return session;
+        }
+
+        public override void Dispose()
+        {
+            _eglSurface?.Dispose();
+            _eglSurface = null;
+            if (_eglWindow != IntPtr.Zero)
+            {
+                WaylandEglNativeMethods.wl_egl_window_destroy(_eglWindow);
+                _eglWindow = IntPtr.Zero;
+            }
+            _currentSize = default;
+            base.Dispose();
+        }
+
+        private void EnsureWindow(PixelSize size)
+        {
+            if (_eglWindow != IntPtr.Zero && _currentSize == size)
+                return;
+
+            if (_eglWindow == IntPtr.Zero)
+            {
+                _eglWindow = WaylandEglNativeMethods.wl_egl_window_create(
+                    _surface.WlSurface!.Handle, Math.Max(1, size.Width), Math.Max(1, size.Height));
+                if (_eglWindow == IntPtr.Zero)
+                    throw new OpenGlException("wl_egl_window_create failed");
+
+                var display = Context.Display;
+                var raw = display.EglInterface.CreateWindowSurface(display.Handle, display.Config, _eglWindow, null);
+                if (raw == IntPtr.Zero)
+                {
+                    WaylandEglNativeMethods.wl_egl_window_destroy(_eglWindow);
+                    _eglWindow = IntPtr.Zero;
+                    throw OpenGlException.GetFormattedException("eglCreateWindowSurface", display.EglInterface);
+                }
+
+                _eglSurface = new EglSurface(display, raw);
+            }
+            else
+            {
+                WaylandEglNativeMethods.wl_egl_window_resize(_eglWindow,
+                    Math.Max(1, size.Width), Math.Max(1, size.Height), 0, 0);
+            }
+
+            _currentSize = size;
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs
new file mode 100644
index 0000000000..1c971f2f7b
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs
@@ -0,0 +1,113 @@
+using System;
+using System.Runtime.InteropServices;
+using Avalonia.Platform;
+using Avalonia.Platform.Surfaces;
+using NWayland.Protocols.Wayland;
+using static Avalonia.Wayland.Server.Interop.UnsafeNativeMethods;
+namespace Avalonia.Wayland.Server.Transient.Rendering;
+
+class WaylandFramebuffer(IWaylandFramebufferSurface surface) : IFramebufferPlatformSurface, IPlatformRenderSurface
+{
+    private readonly IWaylandFramebufferSurface _surface = surface;
+    public IFramebufferRenderTarget CreateFramebufferRenderTarget() => new RenderTarget(this);
+
+
+    class RenderTarget : IFramebufferRenderTarget, IPlatformRenderSurface
+    {
+        private readonly WaylandFramebuffer _p;
+        private bool _disposed;
+
+        public RenderTarget(WaylandFramebuffer p)
+        {
+            _p = p;
+            p._surface.RegisterRenderTarget(this);
+        }
+
+        public void Dispose()
+        {
+            if (_disposed) return;
+            _disposed = true;
+            _p._surface.UnregisterRenderTarget(this);
+        }
+
+        class BufferListener : WlBuffer.Listener
+        {
+            protected override void Release(WlBuffer eventSender)
+            {
+                // TODO: Pool buffers
+                eventSender.Destroy();
+                base.Release(eventSender);
+            }
+        }
+        
+
+        public ILockedFramebuffer Lock(IRenderTarget.RenderTargetSceneInfo sceneInfo, out FramebufferLockProperties properties)
+        {
+            if (!State.IsReady)
+                throw new RenderTargetNotReadyException();
+
+            var size = sceneInfo.Size;
+            var bufferLen = sceneInfo.Size.Width * sceneInfo.Size.Height * 4;
+            var stride = size.Width * 4;
+            
+            var fd = memfd_create("avalonia-wayland-framebuffer", MFD_CLOEXEC);
+            IntPtr map;
+            if (fd == -1
+                || ftruncate(fd, bufferLen) != 0
+                || new IntPtr(-1) == (map =
+                    mmap(IntPtr.Zero, bufferLen, PROT_READ | PROT_WRITE, MAP_SHARED, fd, IntPtr.Zero)))
+            {
+                close(fd);
+                throw new OutOfMemoryException("Unable to allocate framebuffer");
+            }
+
+            properties = default;
+            return new LockedFramebuffer(map, size, stride,
+                new Vector(96 * sceneInfo.Scaling, 96 * sceneInfo.Scaling),
+                PixelFormats.Bgra8888, AlphaFormat.Premul, () =>
+                {
+                    munmap(map, bufferLen);
+                    try
+                    {
+                        if (!State.IsReady)
+                            return;
+
+                        using var pool = _p._surface.Globals!.WlShm.CreatePool(fd, bufferLen);
+                        var listener = new BufferListener();
+                        var buffer = pool.CreateBuffer(0, size.Width, size.Height, stride,
+                            WlShm.FormatEnum.Argb8888, listener);
+                        
+                        // Stage per-frame state (frame callback +
+                        // ack_configure + geometry + viewport/scale +
+                        // min/max) into the next commit BEFORE binding the
+                        // buffer, then commit explicitly after attach +
+                        // damage. The base WSurface no longer issues the
+                        // commit itself.
+                        _p._surface.OnBeforeNewBufferAttached(sceneInfo);
+                        _p._surface.WlSurface!.Attach(buffer, 0, 0);
+                        // TODO: Support "damage" regions
+                        _p._surface.WlSurface.DamageBuffer(0, 0, size.Width, size.Height);
+                        _p._surface.WlSurface.Commit();
+
+                        // Surfaces that allocate buffers outside the throttled render loop must
+                        // flush the buffer's fd immediately: libwayland-client caps the number of
+                        // fds per wl_display_flush (~28, undocumented), and a roundtrip flushes.
+                        if (_p._surface.EnforceBufferCreationRoundtrip)
+                            _p._surface.Globals!.Connection.Queue.Roundtrip();
+                    }
+                    finally
+                    {
+                        close(fd);
+                    }
+                });
+        }
+
+        public bool RetainsFrameContents => false;
+
+        public PlatformRenderTargetState State =>
+            _disposed ? PlatformRenderTargetState.Disposed : _p._surface.State;
+    }
+
+
+    public bool IsReady => _surface.State.IsReady;
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/WaylandCursorManager.cs b/src/Avalonia.Wayland/Server/Transient/WaylandCursorManager.cs
new file mode 100644
index 0000000000..5e1c9a5708
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/WaylandCursorManager.cs
@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Input;
+using Avalonia.SourceGenerator;
+using Avalonia.Wayland.Server.Interop;
+using NWayland.Interop;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Server.Transient;
+
+partial class WaylandCursorManager : IDisposable
+{
+    private readonly IntPtr _theme;
+    private readonly Dictionary<StandardCursorType, CursorEntry?> _cursors = new();
+    private readonly WlDisplay _display;
+    private readonly WlCompositor _compositor;
+
+    [DefinitelyNotARecord]
+    internal readonly partial struct CursorEntry(WlSurface Surface, WlBuffer buffer, int HotspotX, int HotspotY);
+
+    private static readonly Dictionary<StandardCursorType, string[]> CursorNames = new()
+    {
+        { StandardCursorType.Arrow, ["default", "left_ptr"] },
+        { StandardCursorType.Ibeam, ["text", "xterm"] },
+        { StandardCursorType.Wait, ["wait", "watch"] },
+        { StandardCursorType.Cross, ["crosshair", "cross"] },
+        { StandardCursorType.UpArrow, ["up_arrow", "sb_up_arrow"] },
+        { StandardCursorType.SizeWestEast, ["ew-resize", "col-resize", "sb_h_double_arrow"] },
+        { StandardCursorType.SizeNorthSouth, ["ns-resize", "row-resize", "sb_v_double_arrow"] },
+        { StandardCursorType.SizeAll, ["all-scroll", "fleur"] },
+        { StandardCursorType.No, ["not-allowed", "crossed_circle"] },
+        { StandardCursorType.Hand, ["pointer", "hand2", "pointing_hand"] },
+        { StandardCursorType.AppStarting, ["progress", "left_ptr_watch"] },
+        { StandardCursorType.Help, ["help", "question_arrow"] },
+        { StandardCursorType.TopSide, ["top_side", "n-resize"] },
+        { StandardCursorType.BottomSide, ["bottom_side", "s-resize"] },
+        { StandardCursorType.LeftSide, ["left_side", "w-resize"] },
+        { StandardCursorType.RightSide, ["right_side", "e-resize"] },
+        { StandardCursorType.TopLeftCorner, ["top_left_corner", "nw-resize"] },
+        { StandardCursorType.TopRightCorner, ["top_right_corner", "ne-resize"] },
+        { StandardCursorType.BottomLeftCorner, ["bottom_left_corner", "sw-resize"] },
+        { StandardCursorType.BottomRightCorner, ["bottom_right_corner", "se-resize"] },
+        { StandardCursorType.DragMove, ["grabbing", "dnd-move"] },
+        { StandardCursorType.DragCopy, ["copy", "dnd-copy"] },
+        { StandardCursorType.DragLink, ["alias", "dnd-link"] },
+    };
+
+    public WaylandCursorManager(WlDisplay display, WlShm shm, WlCompositor compositor)
+    {
+        _display = display;
+        _compositor = compositor;
+        _theme = UnsafeNativeMethods.wl_cursor_theme_load(null, 24, shm.Handle);
+        if (_theme == IntPtr.Zero)
+            throw new AvaloniaWaylandException("Failed to load default cursor theme");
+
+        foreach (var type in CursorNames.Keys)
+            LoadCursor(type);
+    }
+
+    private unsafe void LoadCursor(StandardCursorType type)
+    {
+        if (!CursorNames.TryGetValue(type, out var names))
+            return;
+
+        UnsafeNativeMethods.wl_cursor* cursor = null;
+        foreach (var name in names)
+        {
+            cursor = UnsafeNativeMethods.wl_cursor_theme_get_cursor(_theme, name);
+            if (cursor != null)
+                break;
+        }
+
+        if (cursor == null || cursor->image_count == 0)
+        {
+            _cursors[type] = null;
+            return;
+        }
+
+        var image = cursor->images[0];
+        var buffer = UnsafeNativeMethods.wl_cursor_image_get_buffer(image);
+        if (buffer == IntPtr.Zero)
+        {
+            _cursors[type] = null;
+            return;
+        }
+
+        var surface = _compositor.CreateSurface(null);
+        var wlBuffer =  WlBuffer.Import(this._display, null, buffer, true, null);
+        surface.Attach(wlBuffer, 0, 0);
+        surface.Commit();
+
+        _cursors[type] = new CursorEntry(surface, wlBuffer, (int)image->hotspot_x, (int)image->hotspot_y);
+    }
+
+    /// <summary>
+    /// Gets the cursor surface and hotspot for the given cursor type.
+    /// Returns null for <see cref="StandardCursorType.None"/> or unknown cursors (hides cursor).
+    /// Falls back to Arrow if the specific cursor is not available.
+    /// </summary>
+    internal CursorEntry? GetCursor(StandardCursorType type)
+    {
+        if (type == StandardCursorType.None)
+            return null;
+
+        if (_cursors.TryGetValue(type, out var entry))
+            return entry ?? (type != StandardCursorType.Arrow ? GetCursor(StandardCursorType.Arrow) : null);
+
+        return GetCursor(StandardCursorType.Arrow);
+    }
+
+    public void Dispose()
+    {
+        foreach (var entry in _cursors.Values)
+            entry?.Surface.Dispose();
+        _cursors.Clear();
+
+        if (_theme != IntPtr.Zero)
+            UnsafeNativeMethods.wl_cursor_theme_destroy(_theme);
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/WaylandGlobals.cs b/src/Avalonia.Wayland/Server/Transient/WaylandGlobals.cs
new file mode 100644
index 0000000000..99b57e20bf
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/WaylandGlobals.cs
@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Platform;
+using Avalonia.Wayland.Screens;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Transient.Rendering;
+using NWayland;
+using NWayland.Interop;
+using NWayland.Protocols.FractionalScaleV1;
+using NWayland.Protocols.LinuxDmabufV1;
+using NWayland.Protocols.TextInputUnstableV3;
+using NWayland.Protocols.Viewporter;
+using NWayland.Protocols.Wayland;
+using NWayland.Protocols.XdgDecorationUnstableV1;
+using NWayland.Protocols.XdgForeignUnstableV2;
+using NWayland.Protocols.XdgOutputUnstableV1;
+using NWayland.Protocols.XdgShell;
+
+namespace Avalonia.Wayland.Server.Transient;
+
+class WaylandGlobals
+{
+    public WlRegistry Registry { get; }
+    private Dictionary<string, (uint name, uint version)> _knownGlobals = new();
+    public WaylandOutputsTracker Outputs { get; }
+    public event Action<uint>? GlobalRemoved;
+    public WlShm WlShm { get; }
+    public List<WlShm.FormatEnum> ShmFormats { get; } = new();
+    public WlCompositor WlCompositor { get; }
+    public XdgWmBase XdgWmBase { get; }
+    public WlDataDeviceManager? DataDeviceManager { get; }
+    public ZwpLinuxDmabufV1? LinuxDmabuf { get; }
+    public WpFractionalScaleManagerV1? FractionalScaleManager { get; }
+    public WpViewporter? Viewporter { get; }
+    public ZwpTextInputManagerV3? TextInputManagerV3 { get; }
+    public ZxdgExporterV2? XdgExporter { get; }
+    /// <summary>
+    /// Bound when the compositor advertises <c>zxdg_output_manager_v1</c>.
+    /// When present, screens use <c>zxdg_output_v1.logical_*</c> as the
+    /// authoritative logical bounds; otherwise we derive logical bounds
+    /// as <c>wl_output.mode / wl_output.scale</c>.
+    /// </summary>
+    public ZxdgOutputManagerV1? XdgOutputManager { get; }
+    /// <summary>
+    /// Bound only when the compositor advertises
+    /// <c>zxdg_decoration_manager_v1</c> AND the platform option
+    /// <see cref="WaylandPlatformOptions.ForceDrawnDecorations"/> is
+    /// false. <c>null</c> means we must use client-side decorations for
+    /// every toplevel (no SSD negotiation will be attempted).
+    /// </summary>
+    public ZxdgDecorationManagerV1? XdgDecorationManager { get; }
+
+    public bool HasFractionalScaling => FractionalScaleManager != null && Viewporter != null;
+
+    class RegistryListener(WaylandGlobals p) : NWayland.Protocols.Wayland.WlRegistry.Listener
+    {
+        protected override void Global(WlRegistry eventSender, uint name, string @interface, uint version)
+        {
+            p._knownGlobals[@interface] = (name, version);
+            if (@interface == WlOutput.ProxyType.Interface.Name)
+            {
+                p.Outputs.AddGlobal(p, name, version);
+            }
+            else if (@interface == WlSeat.ProxyType.Interface.Name)
+            {
+                p.OnSeatGlobal(name, version);
+            }
+        }
+
+        protected override void GlobalRemove(WlRegistry eventSender, uint name)
+        {
+            p.InputDispatcher.OnSeatRemoved(name);
+            p.GlobalRemoved?.Invoke(name);
+        }
+    }
+
+    private const uint SeatMinVersion = 5;
+
+    private void OnSeatGlobal(uint globalName, uint version)
+    {
+        var bindVersion = Math.Min(version, 9);
+        if (bindVersion < SeatMinVersion)
+            return;
+        InputDispatcher.OnSeatAdded(globalName, Registry, bindVersion);
+    }
+
+    T? Bind<T>(uint minVersion, uint maxVersion, IWlEventsListener? listener) where T : WlProxy, IWlProxyTypeDescriptorProvider
+    {
+        var descriptor = T.ProxyType;
+        if (descriptor.Interface.Version < maxVersion)
+            throw new AvaloniaWaylandException(
+                $"{descriptor.Interface.Name} v{maxVersion} is not supported by current bindings");
+        
+        if (!_knownGlobals.TryGetValue(descriptor.Interface.Name, out var global))
+            return null;
+        if (global.version < minVersion)
+            return null;
+        return Registry.Bind<T>(global.name, Math.Min(global.version, maxVersion), listener);
+    }
+
+    T BindRequired<T>(uint minVersion, uint maxVersion,
+        IWlEventsListener? listener) where T : WlProxy, IWlProxyTypeDescriptorProvider
+    {
+        var rv = Bind<T>(minVersion, maxVersion, listener);
+        if (rv == null)
+            throw new AvaloniaWaylandException(
+                $"Required wayland global {T.ProxyType.Interface.Name} (>={minVersion}) not found");
+        return rv;
+    }
+
+    class ShmListener(WaylandGlobals globals) : WlShm.Listener
+    {
+        protected override void Format(WlShm eventSender, WlShm.FormatEnum format)
+        {
+            globals.ShmFormats.Add(format);
+            base.Format(eventSender, format);
+        }
+    }
+
+    class XdgWmBaseListener : XdgWmBase.Listener
+    {
+        protected override void Ping(XdgWmBase eventSender, uint serial)
+        {
+            eventSender.Pong(serial);
+        }
+    }
+    
+    public WaylandGlobals(WaylandConnection connection, WaylandWorker worker, WaylandPlatformOptions platformOptions,
+        WaylandOutputsSinkProxy? outputsSink)
+    {
+        Connection = connection;
+        Worker = worker;
+        InputDispatcher = new WaylandInputDispatcher(this);
+        Outputs = new WaylandOutputsTracker(outputsSink);
+        Registry = connection.Display.GetRegistry(new RegistryListener(this), connection.Queue);
+        // Use a roundtrip to ensure we get all existing globals before our own event loop runs
+        connection.Queue.Roundtrip();
+        WlShm = BindRequired<WlShm>(1, 1, new ShmListener(this));
+        WlCompositor = BindRequired<WlCompositor>(4, 6, null);
+        XdgWmBase = BindRequired<XdgWmBase>(3, 4, new XdgWmBaseListener());
+        CursorManager = new WaylandCursorManager(connection.Display, WlShm, WlCompositor);
+        DataDeviceManager = Bind<WlDataDeviceManager>(3, 3, null);
+        LinuxDmabuf = Bind<ZwpLinuxDmabufV1>(4, 4, null);
+        FractionalScaleManager = Bind<WpFractionalScaleManagerV1>(1, 1, null);
+        Viewporter = Bind<WpViewporter>(1, 1, null);
+        TextInputManagerV3 = Bind<ZwpTextInputManagerV3>(1, 1, null);
+        XdgExporter = Bind<ZxdgExporterV2>(1, 1, null);
+        // Require v3 of zxdg_output_manager_v1 so wl_output.done acts as
+        // the unified terminator (xdg_output.done is deprecated since
+        // v3). Simplifies init-batch gating — same pragmatism as the
+        // wl_output v2 minimum.
+        XdgOutputManager = Bind<ZxdgOutputManagerV1>(3, 3, null);
+        if (XdgOutputManager != null)
+            Outputs.AttachXdgOutputManager(XdgOutputManager);
+        // ForceDrawnDecorations is a test/debug option: skip binding the
+        // SSD manager so toplevels behave as if the compositor never
+        // advertised support, exercising the CSD code path.
+        XdgDecorationManager = platformOptions.ForceDrawnDecorationsInternal
+            ? null
+            : Bind<ZxdgDecorationManagerV1>(1, 1, null);
+        
+        // Seats may have been announced before the data-device manager / text-input
+        // manager were bound — InputDispatcher backfills now and constructs the
+        // text-input-v3 facade if the manager is available.
+        // Seats are bound reactively via RegistryListener and managed by InputDispatcher
+        InputDispatcher.OnInitialGlobalsBound();
+
+        // Collect events from bound globals
+        connection.Queue.Roundtrip();
+
+        // GPU swapchain selection. Default is WSI (wl_egl_window +
+        // eglSwapBuffers) — required for NVIDIA and most resilient to driver
+        // quirks. Opt in to the dmabuf path (we own the allocator) by setting
+        // UseDmabufSwapchain = true.
+        var useDmabuf = platformOptions.UseDmabufSwapchain ?? false;
+        WaylandPlatformGraphics.IWaylandGraphics? gpu = null;
+        if (useDmabuf && LinuxDmabuf != null)
+            gpu = WaylandEglDmaBufPlatformGraphics.TryCreate(connection, this, platformOptions.GlProfiles);
+        else
+            gpu = WaylandEglWsiPlatformGraphics.TryCreate(connection, platformOptions.GlProfiles);
+
+        worker.PlatformGraphics.Initialize(gpu);
+
+        // TODO: sanity checks
+    }
+
+    public WaylandConnection Connection { get; }
+    public WaylandWorker Worker { get; }
+    public WaylandInputDispatcher InputDispatcher { get; }
+    public WaylandCursorManager CursorManager { get; }
+
+    public void Dispose()
+    {
+        InputDispatcher.Dispose();
+        Worker.PlatformGraphics.Reset();
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Server/Transient/WaylandInputDispatcher.Keyboard.cs b/src/Avalonia.Wayland/Server/Transient/WaylandInputDispatcher.Keyboard.cs
new file mode 100644
index 0000000000..45a1d531f8
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/WaylandInputDispatcher.Keyboard.cs
@@ -0,0 +1,188 @@
+using System;
+using Avalonia.Input;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Persistent;
+using NWayland;
+using NWayland.Protocols.Wayland;
+using static Avalonia.Wayland.Server.Interop.XkbCommonNativeMethods;
+
+namespace Avalonia.Wayland.Server.Transient;
+
+partial class WaylandInputDispatcher
+{
+    class KeyboardHandler : IDisposable
+    {
+        private readonly Seat _seat;
+        private readonly WlKeyboard _keyboard;
+
+        private readonly XkbContext _xkbContext;
+        private readonly XkbComposeTable? _composeTable;
+
+        private WXdgShellSurface? _focusedSurface;
+        private int _repeatRate;  // keys/sec (0 = disabled)
+        private int _repeatDelay; // ms before first repeat
+        private XkbCommonKeymap? _keymap;
+        private XkbComposeState? _composeState;
+
+        // Standard XKB modifier bit positions
+        private const uint ModShift = 1 << 0;
+        private const uint ModControl = 1 << 2;
+        private const uint ModAlt = 1 << 3;    // Mod1
+        private const uint ModMeta = 1 << 6;   // Mod4 / Super
+
+        public KeyboardHandler(Seat seat)
+        {
+            _seat = seat;
+            _xkbContext = new XkbContext();
+            _composeTable = XkbComposeTable.TryCreate(_xkbContext);
+
+            _keyboard = seat.WlSeat.GetKeyboard(new Listener(this));
+        }
+
+        private static RawInputModifiers ModifiersFromXkbMask(uint mask)
+        {
+            var mods = RawInputModifiers.None;
+            if ((mask & ModShift) != 0) mods |= RawInputModifiers.Shift;
+            if ((mask & ModControl) != 0) mods |= RawInputModifiers.Control;
+            if ((mask & ModAlt) != 0) mods |= RawInputModifiers.Alt;
+            if ((mask & ModMeta) != 0) mods |= RawInputModifiers.Meta;
+            return mods;
+        }
+
+        public void Dispose()
+        {
+            _keyboard.Release();
+            _composeState?.Dispose();
+            _composeState = null;
+            _keymap?.Dispose();
+            _keymap = null;
+            _composeTable?.Dispose();
+            _xkbContext.Dispose();
+        }
+
+        class Listener(KeyboardHandler handler) : WlKeyboard.Listener
+        {
+            protected override void Keymap(WlKeyboard eventSender, WlKeyboard.KeymapFormatEnum format, WaylandFd fd, uint size)
+            {
+                handler._composeState?.Dispose();
+                handler._composeState = null;
+                handler._keymap?.Dispose();
+                handler._keymap = null;
+
+                var rawFd = fd.Consume();
+                if (format == WlKeyboard.KeymapFormatEnum.XkbV1)
+                {
+                    try
+                    {
+                        handler._keymap = new XkbCommonKeymap(handler._xkbContext, rawFd, size);
+
+                        if (handler._composeTable != null)
+                            handler._composeState = new XkbComposeState(handler._composeTable);
+                    }
+                    catch
+                    {
+                        // If keymap creation fails, fall back to evdev-only mapping
+                    }
+                }
+                else
+                {
+                    UnsafeNativeMethods.close(rawFd);
+                }
+            }
+
+            protected override void Enter(WlKeyboard eventSender, uint serial, WlSurface? surface, ReadOnlySpan<byte> keys)
+            {
+                handler._focusedSurface = WaylandInputDispatcher.FindSurfaceForWlSurface(surface);
+                handler._focusedSurface?.EventSink.OnKeyRepeatInfo(handler._repeatRate, handler._repeatDelay);
+
+                if (handler._seat.DataDevice != null)
+                    handler._seat.DataDevice.LastInputSerial = serial;
+            }
+
+            protected override void Leave(WlKeyboard eventSender, uint serial, WlSurface? surface)
+            {
+                handler._composeState?.Reset();
+                handler._focusedSurface?.EventSink.OnKeyboardLeave();
+                handler._focusedSurface = null;
+                handler._seat.KeyboardModifiers = RawInputModifiers.None;
+            }
+
+            protected override void Key(WlKeyboard eventSender, uint serial, uint time, uint key, WlKeyboard.KeyStateEnum state)
+            {
+                if (handler._seat.DataDevice != null)
+                    handler._seat.DataDevice.LastInputSerial = serial;
+
+                var sink = handler._focusedSurface?.EventSink;
+                if (sink == null)
+                    return;
+
+                var physicalKey = XkbKeyTransform.PhysicalKeyFromEvdev(key);
+                var mods = handler._seat.KeyboardModifiers;
+
+                Key avKey;
+                string? keySymbol;
+
+                if (handler._keymap != null)
+                {
+                    (avKey, keySymbol) = XkbKeyTransform.ResolveKeyWithFallback(
+                        handler._keymap, key, physicalKey);
+
+                    // Process compose sequences on key press only, and only when the
+                    // focused surface has an active text input client (e.g. a TextBox)
+                    if (state == WlKeyboard.KeyStateEnum.Pressed
+                        && handler._composeState != null
+                        && handler._focusedSurface is { HasTextInputClient: true })
+                    {
+                        var (resolvedKeysym, _) = handler._keymap.ResolveKey(key);
+                        var composeStatus = handler._composeState.Feed(resolvedKeysym);
+
+                        switch (composeStatus)
+                        {
+                            case XKB_COMPOSE_COMPOSING:
+                                // In the middle of a compose sequence — suppress entire event
+                                return;
+                            case XKB_COMPOSE_COMPOSED:
+                                // Compose sequence complete — use composed text
+                                keySymbol = XkbKeyTransform.FilterKeySymbol(
+                                    handler._composeState.GetComposedText());
+                                var composedKeysym = handler._composeState.GetComposedKeysym();
+                                var composedKey = XkbKeyTransform.KeyFromKeysym(composedKeysym);
+                                if (composedKey != Avalonia.Input.Key.None)
+                                    avKey = composedKey;
+                                break;
+                            case XKB_COMPOSE_CANCELLED:
+                                // Sequence cancelled — normal processing of current key
+                                break;
+                            // XKB_COMPOSE_NOTHING — normal processing
+                        }
+                    }
+                }
+                else
+                {
+                    avKey = XkbKeyTransform.KeyFromEvdev(key);
+                    keySymbol = null;
+                }
+
+                if (state == WlKeyboard.KeyStateEnum.Pressed)
+                    sink.OnKeyDown(time, avKey, mods, physicalKey, keySymbol);
+                else
+                    sink.OnKeyUp(time, avKey, mods, physicalKey, keySymbol);
+            }
+
+            protected override void Modifiers(WlKeyboard eventSender, uint serial, uint modsDepressed, uint modsLatched, uint modsLocked, uint group)
+            {
+                handler._keymap?.UpdateModifiers(modsDepressed, modsLatched, modsLocked, group);
+
+                var effective = modsDepressed | modsLatched | modsLocked;
+                handler._seat.KeyboardModifiers = ModifiersFromXkbMask(effective);
+            }
+
+            protected override void RepeatInfo(WlKeyboard eventSender, int rate, int delay)
+            {
+                handler._repeatRate = rate;
+                handler._repeatDelay = delay;
+                handler._focusedSurface?.EventSink.OnKeyRepeatInfo(rate, delay);
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/WaylandInputDispatcher.cs b/src/Avalonia.Wayland/Server/Transient/WaylandInputDispatcher.cs
new file mode 100644
index 0000000000..eeabe238d6
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/WaylandInputDispatcher.cs
@@ -0,0 +1,636 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Wayland.Clipboard;
+using Avalonia.Wayland.Server.Transient.Clipboard;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Persistent;
+using NWayland;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Server.Transient;
+
+partial class WaylandInputDispatcher : IDisposable
+{
+    private readonly WaylandGlobals _globals;
+    private readonly Dictionary<uint, Seat> _seats = new();
+
+    internal static WXdgShellSurface? FindSurfaceForWlSurface(WlSurface? surface) =>
+        surface != null && surface.Tags.TryGetValue(typeof(WXdgShellSurface), out var tag)
+            ? (WXdgShellSurface)tag
+            : null;
+
+    internal void NotifyCursorChanged(WSurface surface)
+    {
+        foreach (var seat in _seats.Values)
+            seat.NotifyCursorChanged(surface);
+    }
+
+    /// <summary>
+    /// Sets the pointer cursor to provide visual DnD action feedback.
+    /// Called from the Wayland thread when <c>wl_data_source.action</c> fires during an active drag.
+    /// </summary>
+    internal void SetDndCursor(StandardCursorType cursorType)
+    {
+        foreach (var seat in _seats.Values)
+            seat.SetDndCursor(cursorType);
+    }
+
+    /// <summary>
+    /// Returns the <see cref="WlSurface"/> that currently has pointer focus.
+    /// Used as the origin surface for <see cref="WlDataDevice.StartDrag"/>.
+    /// </summary>
+    internal WlSurface? FindOriginSurface()
+    {
+        foreach (var seat in _seats.Values)
+        {
+            if (seat.PointerFocusedWlSurface is { } surface)
+                return surface;
+        }
+        return null;
+    }
+
+    public WaylandInputDispatcher(WaylandGlobals globals)
+    {
+        _globals = globals;
+    }
+
+    /// <summary>
+    /// Worker-side facade for <c>zwp_text_input_v3</c>. Null until
+    /// <see cref="OnInitialGlobalsBound"/> runs (and may stay null if the
+    /// compositor does not advertise the manager).
+    /// </summary>
+    internal WaylandTextInputV3? TextInputV3 { get; private set; }
+
+    /// <summary>
+    /// Returns the first available data device, or null if no seat has one.
+    /// Used by the clipboard implementation to access the active selection.
+    /// </summary>
+    internal WaylandDataDevice? GetDataDevice()
+    {
+        foreach (var seat in _seats.Values)
+        {
+            if (seat.DataDevice != null)
+                return seat.DataDevice;
+        }
+        return null;
+    }
+
+    internal void OnSeatAdded(uint globalName, WlRegistry registry, uint version)
+    {
+        var seat = new Seat(this, registry, globalName, version);
+        _seats[globalName] = seat;
+        TextInputV3?.OnSeatAdded(globalName, seat.WlSeat);
+    }
+
+    /// <summary>
+    /// Called once after <see cref="WaylandGlobals"/> has bound all available
+    /// globals. Constructs the text-input-v3 facade if the manager is present
+    /// and backfills per-seat objects (data devices, text-input-v3 proxies)
+    /// for any seats that were announced before this point.
+    /// </summary>
+    internal void OnInitialGlobalsBound()
+    {
+        if (_globals.TextInputManagerV3 is { } manager)
+            TextInputV3 = new WaylandTextInputV3(manager);
+        foreach (var (globalName, seat) in _seats)
+        {
+            seat.EnsureDataDevice();
+            TextInputV3?.OnSeatAdded(globalName, seat.WlSeat);
+        }
+    }
+
+    internal void OnSeatRemoved(uint globalName)
+    {
+        TextInputV3?.OnSeatRemoved(globalName);
+        if (_seats.Remove(globalName, out var seat))
+            seat.Dispose();
+    }
+    
+    public void Dispose()
+    {
+        foreach (var seat in _seats.Values)
+            seat.Dispose();
+        _seats.Clear();
+        TextInputV3?.Dispose();
+        TextInputV3 = null;
+    }
+
+    // Linux input-event-codes.h button constants
+    private const uint BTN_LEFT = 0x110;
+    private const uint BTN_RIGHT = 0x111;
+    private const uint BTN_MIDDLE = 0x112;
+    private const uint BTN_SIDE = 0x113;
+    private const uint BTN_EXTRA = 0x114;
+
+    private static RawPointerEventType? MapButton(uint button, bool pressed) => button switch
+    {
+        BTN_LEFT => pressed ? RawPointerEventType.LeftButtonDown : RawPointerEventType.LeftButtonUp,
+        BTN_RIGHT => pressed ? RawPointerEventType.RightButtonDown : RawPointerEventType.RightButtonUp,
+        BTN_MIDDLE => pressed ? RawPointerEventType.MiddleButtonDown : RawPointerEventType.MiddleButtonUp,
+        BTN_SIDE => pressed ? RawPointerEventType.XButton1Down : RawPointerEventType.XButton1Up,
+        BTN_EXTRA => pressed ? RawPointerEventType.XButton2Down : RawPointerEventType.XButton2Up,
+        _ => null
+    };
+
+    private static RawInputModifiers ButtonToModifier(uint button) => button switch
+    {
+        BTN_LEFT => RawInputModifiers.LeftMouseButton,
+        BTN_RIGHT => RawInputModifiers.RightMouseButton,
+        BTN_MIDDLE => RawInputModifiers.MiddleMouseButton,
+        BTN_SIDE => RawInputModifiers.XButton1MouseButton,
+        BTN_EXTRA => RawInputModifiers.XButton2MouseButton,
+        _ => RawInputModifiers.None
+    };
+
+    class Seat : IDisposable
+    {
+        private readonly WaylandInputDispatcher _dispatcher;
+        private readonly WlSeat _wlSeat;
+        private PointerHandler? _pointerHandler;
+        private TouchHandler? _touchHandler;
+        private KeyboardHandler? _keyboardHandler;
+
+        public WlSeat WlSeat => _wlSeat;
+        public WaylandDataDevice? DataDevice { get; private set; }
+
+        /// <summary>
+        /// The WlSurface currently under pointer focus, exposed for DnD origin lookup.
+        /// </summary>
+        internal WlSurface? PointerFocusedWlSurface => _pointerHandler?._focusedWlSurface;
+
+        /// <summary>
+        /// Current keyboard modifiers (Shift/Ctrl/Alt/Meta), updated by the keyboard handler.
+        /// Read by pointer/touch handlers for combined modifier state.
+        /// </summary>
+        internal RawInputModifiers KeyboardModifiers;
+
+        public Seat(WaylandInputDispatcher dispatcher, WlRegistry registry, uint globalName, uint version)
+        {
+            _dispatcher = dispatcher;
+            _wlSeat = WlSeat.Bind(registry, globalName, version, new SeatListener(this));
+            EnsureDataDevice();
+        }
+
+        /// <summary>
+        /// Creates the data device for this seat if a <see cref="WlDataDeviceManager"/> is available
+        /// and the device hasn't been created yet. Called from the constructor and also after
+        /// the manager global becomes available (seats can be announced before the manager).
+        /// </summary>
+        internal void EnsureDataDevice()
+        {
+            if (DataDevice != null)
+                return;
+
+            var manager = _dispatcher._globals.DataDeviceManager;
+            if (manager == null)
+                return;
+
+            var deviceListener = new WaylandDataDeviceListener();
+            var wlDataDevice = manager.GetDataDevice(_wlSeat, deviceListener);
+            DataDevice = new WaylandDataDevice(wlDataDevice, _dispatcher, _wlSeat,
+                _dispatcher._globals.Connection.Display, _dispatcher._globals.Worker, () => KeyboardModifiers);
+            deviceListener.SetWrapper(DataDevice);
+        }
+
+        private void OnCapabilities(WlSeat.CapabilityEnum capabilities)
+        {
+            var hasPointer = capabilities.HasFlag(WlSeat.CapabilityEnum.Pointer);
+
+            if (hasPointer && _pointerHandler == null)
+            {
+                _pointerHandler = new PointerHandler(_dispatcher, this);
+            }
+            else if (!hasPointer && _pointerHandler != null)
+            {
+                _pointerHandler.Dispose();
+                _pointerHandler = null;
+            }
+
+            var hasTouch = capabilities.HasFlag(WlSeat.CapabilityEnum.Touch);
+
+            if (hasTouch && _touchHandler == null)
+            {
+                _touchHandler = new TouchHandler(_dispatcher, this);
+            }
+            else if (!hasTouch && _touchHandler != null)
+            {
+                _touchHandler.Dispose();
+                _touchHandler = null;
+            }
+
+            var hasKeyboard = capabilities.HasFlag(WlSeat.CapabilityEnum.Keyboard);
+
+            if (hasKeyboard && _keyboardHandler == null)
+            {
+                _keyboardHandler = new KeyboardHandler(this);
+            }
+            else if (!hasKeyboard && _keyboardHandler != null)
+            {
+                _keyboardHandler.Dispose();
+                _keyboardHandler = null;
+            }
+        }
+
+        public void Dispose()
+        {
+            _pointerHandler?.Dispose();
+            _pointerHandler = null;
+            _touchHandler?.Dispose();
+            _touchHandler = null;
+            _keyboardHandler?.Dispose();
+            _keyboardHandler = null;
+            DataDevice?.Dispose();
+            _wlSeat.Dispose();
+        }
+
+        internal void NotifyCursorChanged(WSurface surface)
+        {
+            _pointerHandler?.NotifyCursorChanged(surface);
+        }
+
+        internal void SetDndCursor(StandardCursorType cursorType)
+        {
+            _pointerHandler?.SetDndCursor(cursorType);
+        }
+
+        class SeatListener(Seat seat) : WlSeat.Listener
+        {
+            protected override void Capabilities(WlSeat eventSender, WlSeat.CapabilityEnum capabilities)
+            {
+                seat.OnCapabilities(capabilities);
+            }
+        }
+    }
+
+    class PointerHandler : IDisposable
+    {
+        private readonly WaylandInputDispatcher _dispatcher;
+        private readonly Seat _seat;
+        private readonly WlPointer _pointer;
+
+        // Persistent pointer state (survives across frames)
+        private WSurfaceEventSinkProxy? _focusedSink;
+        private WSurface? _focusedSurface;
+        internal WlSurface? _focusedWlSurface;
+        private Point _pointerPosition;
+        private RawInputModifiers _modifiers;
+        private uint _lastEnterSerial;
+
+        // Per-frame: ordered event actions dispatched during Frame
+        private readonly List<Action> _frameActions = new();
+
+        // Per-frame: axis accumulation (protocol mandates combining within a frame).
+        //
+        // Wayland sends two related events for scrolling:
+        //  - axis_value120 (since v8) — discrete-step indicator: 120 == one wheel detent.
+        //    Replaces the deprecated axis_discrete in v8+. Sent for wheel sources.
+        //  - axis — continuous magnitude in surface-local pixel-equivalent units. Sent for
+        //    every scroll source (wheel + touchpad/continuous), regardless of version.
+        //
+        // For Avalonia (1.0 == one detent), value120/120 is the right unit when present.
+        // For continuous sources (touchpad), there is no value120 and we fall back to the
+        // raw axis value. We accumulate the two streams independently and combine at frame
+        // flush time, preferring v120 per axis when present). This is robust to either event order.
+        private bool _frameHasAxis;
+        private ulong _frameAxisTimestamp;
+        private double _frameAxisRawX;
+        private double _frameAxisRawY;
+        private double _frameV120X;
+        private double _frameV120Y;
+        private bool _frameV120SeenX;
+        private bool _frameV120SeenY;
+
+        public PointerHandler(WaylandInputDispatcher dispatcher, Seat seat)
+        {
+            _dispatcher = dispatcher;
+            _seat = seat;
+            _pointer = seat.WlSeat.GetPointer(new Listener(this));
+        }
+
+        // Shared, stateless fallback used when a surface hasn't requested a specific cursor.
+        private static readonly WaylandStandardCursor s_defaultCursor = new(StandardCursorType.Arrow);
+
+        private void UpdateCursor()
+        {
+            if (_focusedSurface == null)
+                return;
+            var image = (_focusedSurface.CurrentCursor ?? s_defaultCursor).Resolve(_dispatcher._globals);
+            if (image is { } c)
+                _pointer.SetCursor(_lastEnterSerial, c.Surface, c.HotspotX, c.HotspotY);
+            else
+                _pointer.SetCursor(_lastEnterSerial, null, 0, 0);
+        }
+
+        internal void NotifyCursorChanged(WSurface surface)
+        {
+            if (ReferenceEquals(_focusedSurface, surface))
+                UpdateCursor();
+        }
+
+        /// <summary>
+        /// Sets the pointer cursor to reflect the current DnD action.
+        /// Called from <see cref="WaylandDataSource.OnAction"/> during an active drag source operation.
+        /// </summary>
+        /// <remarks>
+        /// TODO: Weston does not honor <c>wl_pointer.set_cursor</c> during drag.
+        /// To support Weston, we'd need to attach cursor buffers to the drag icon surface
+        /// passed to <c>wl_data_device.start_drag</c>. Our current approach matches Qt behavior
+        /// and works correctly with KWin/Mutter. Weston compat is low priority.
+        /// </remarks>
+        internal void SetDndCursor(StandardCursorType cursorType)
+        {
+            var cursorInfo = _dispatcher._globals.CursorManager.GetCursor(cursorType);
+            if (cursorInfo is { } c)
+                _pointer.SetCursor(_lastEnterSerial, c.Surface, c.HotspotX, c.HotspotY);
+            else
+                _pointer.SetCursor(_lastEnterSerial, null!, 0, 0);
+        }
+
+        private void ResetFrameState()
+        {
+            _frameActions.Clear();
+            _frameHasAxis = false;
+            _frameAxisRawX = 0;
+            _frameAxisRawY = 0;
+            _frameV120X = 0;
+            _frameV120Y = 0;
+            _frameV120SeenX = false;
+            _frameV120SeenY = false;
+        }
+
+        public void Dispose()
+        {
+            _pointer.Release();
+        }
+
+        class Listener(PointerHandler handler) : WlPointer.Listener
+        {
+            protected override void Enter(WlPointer eventSender, uint serial, WlSurface? surface, WlFixed surfaceX, WlFixed surfaceY)
+            {
+                var shellSurface = WaylandInputDispatcher.FindSurfaceForWlSurface(surface);
+                var pos = new Point((double)surfaceX, (double)surfaceY);
+                handler._pointerPosition = pos;
+                handler._frameActions.Add(() =>
+                {
+                    handler._focusedSink = shellSurface?.EventSink;
+                    handler._focusedSurface = shellSurface;
+                    handler._focusedWlSurface = surface;
+                    handler._lastEnterSerial = serial;
+                    handler.UpdateCursor();
+                    shellSurface?.EventSink.OnPointerEnter(0, serial, pos);
+                });
+            }
+
+            protected override void Leave(WlPointer eventSender, uint serial, WlSurface? surface)
+            {
+                handler._frameActions.Add(() =>
+                {
+                    var leaveSink = handler._focusedSink;
+                    handler._focusedSink = null;
+                    handler._focusedSurface = null;
+                    handler._focusedWlSurface = null;
+                    leaveSink?.OnPointerLeave(serial);
+                });
+            }
+
+            protected override void Motion(WlPointer eventSender, uint time, WlFixed surfaceX, WlFixed surfaceY)
+            {
+                var pos = new Point((double)surfaceX, (double)surfaceY);
+                handler._pointerPosition = pos;
+                var mods = handler._modifiers | handler._seat.KeyboardModifiers;
+                handler._frameActions.Add(() =>
+                {
+                    handler._focusedSink?.OnPointerMotion(time, pos, mods);
+                });
+            }
+
+            protected override void Button(WlPointer eventSender, uint serial, uint time, uint button, WlPointer.ButtonStateEnum state)
+            {
+                if (handler._seat.DataDevice != null)
+                    handler._seat.DataDevice.LastInputSerial = serial;
+
+                var pressed = state == WlPointer.ButtonStateEnum.Pressed;
+                var type = MapButton(button, pressed);
+                if (type == null)
+                    return;
+
+                var mod = ButtonToModifier(button);
+                if (pressed)
+                    handler._modifiers |= mod;
+                else
+                    handler._modifiers &= ~mod;
+
+                var mods = handler._modifiers | handler._seat.KeyboardModifiers;
+                var pos = handler._pointerPosition;
+                var cookie = pressed ? new WaylandInputEventCookie(handler._seat.WlSeat, serial, handler._dispatcher._globals.Connection.Display, handler._dispatcher._globals.Worker, handler._dispatcher._globals) : null;
+                handler._frameActions.Add(() =>
+                {
+                    handler._focusedSink?.OnPointerButton(time, serial, type.Value, mods, pos, cookie);
+                });
+            }
+
+            private void EnqueueAxisDispatchIfNeeded()
+            {
+                if (handler._frameHasAxis)
+                    return;
+                handler._frameHasAxis = true;
+                handler._frameActions.Add(() =>
+                {
+                    // Combine v120 (notches) with raw axis (continuous). Per axis, prefer v120
+                    // if any v120 event fired this frame; otherwise fall back to the raw axis.
+                    var deltaX = handler._frameV120SeenX ? handler._frameV120X : handler._frameAxisRawX;
+                    var deltaY = handler._frameV120SeenY ? handler._frameV120Y : handler._frameAxisRawY;
+                    if (deltaX != 0 || deltaY != 0)
+                    {
+                        // Wayland: positive = scroll down/right. Avalonia: positive Y = scroll up.
+                        var delta = new Vector(-deltaX, -deltaY);
+                        handler._focusedSink?.OnPointerAxis(handler._frameAxisTimestamp, delta,
+                            handler._modifiers | handler._seat.KeyboardModifiers, handler._pointerPosition);
+                    }
+                });
+            }
+
+            protected override void Axis(WlPointer eventSender, uint time, WlPointer.AxisEnum axis, WlFixed value)
+            {
+                handler._frameAxisTimestamp = time;
+
+                if (axis == WlPointer.AxisEnum.VerticalScroll)
+                    handler._frameAxisRawY += (double)value;
+                else if (axis == WlPointer.AxisEnum.HorizontalScroll)
+                    handler._frameAxisRawX += (double)value;
+
+                EnqueueAxisDispatchIfNeeded();
+            }
+
+            protected override void AxisSource(WlPointer eventSender, WlPointer.AxisSourceEnum axisSource)
+            {
+            }
+
+            protected override void AxisStop(WlPointer eventSender, uint time, WlPointer.AxisEnum axis)
+            {
+            }
+
+            protected override void AxisDiscrete(WlPointer eventSender, WlPointer.AxisEnum axis, int discrete)
+            {
+                // wl_pointer v5–v7 discrete-step indicator. 1 == one wheel detent. Deprecated
+                // and not sent in v8+ (replaced by axis_value120). Folded into the v120
+                // accumulator (since their semantics align: 1 detent each).
+                if (axis == WlPointer.AxisEnum.VerticalScroll)
+                {
+                    handler._frameV120Y += discrete;
+                    handler._frameV120SeenY = true;
+                }
+                else if (axis == WlPointer.AxisEnum.HorizontalScroll)
+                {
+                    handler._frameV120X += discrete;
+                    handler._frameV120SeenX = true;
+                }
+
+                EnqueueAxisDispatchIfNeeded();
+            }
+
+            protected override void AxisValue120(WlPointer eventSender, WlPointer.AxisEnum axis, int value120)
+            {
+                // Higher-resolution scroll: 120 units = one notch. Multiple value120 events
+                // for the same axis in a frame must be summed (per spec example: a single
+                // hardware event can produce -240 = two negative notches).
+                if (axis == WlPointer.AxisEnum.VerticalScroll)
+                {
+                    handler._frameV120Y += value120 / 120.0;
+                    handler._frameV120SeenY = true;
+                }
+                else if (axis == WlPointer.AxisEnum.HorizontalScroll)
+                {
+                    handler._frameV120X += value120 / 120.0;
+                    handler._frameV120SeenX = true;
+                }
+
+                EnqueueAxisDispatchIfNeeded();
+            }
+
+            protected override void Frame(WlPointer eventSender)
+            {
+                try
+                {
+                    foreach (var action in handler._frameActions)
+                        action();
+                }
+                finally
+                {
+                    handler.ResetFrameState();
+                }
+            }
+        }
+    }
+
+    class TouchHandler : IDisposable
+    {
+        private readonly WaylandInputDispatcher _dispatcher;
+        private readonly Seat _seat;
+        private readonly WlTouch _touch;
+
+        // Track active touch point ID → (surface sink, last position)
+        private readonly Dictionary<int, (WSurfaceEventSinkProxy Sink, Point Position)> _activeTouchPoints = new();
+
+        // Per-frame: ordered event actions dispatched during Frame
+        private readonly List<Action> _frameActions = new();
+
+        public TouchHandler(WaylandInputDispatcher dispatcher, Seat seat)
+        {
+            _dispatcher = dispatcher;
+            _seat = seat;
+            _touch = seat.WlSeat.GetTouch(new Listener(this));
+        }
+
+        private void ResetFrameState()
+        {
+            _frameActions.Clear();
+        }
+
+        public void Dispose()
+        {
+            _touch.Release();
+        }
+
+        class Listener(TouchHandler handler) : WlTouch.Listener
+        {
+            protected override void Down(WlTouch eventSender, uint serial, uint time, WlSurface? surface,
+                int id, WlFixed x, WlFixed y)
+            {
+                if (handler._seat.DataDevice != null)
+                    handler._seat.DataDevice.LastInputSerial = serial;
+
+                var shellSurface = WaylandInputDispatcher.FindSurfaceForWlSurface(surface);
+                var pos = new Point((double)x, (double)y);
+                var cookie = new WaylandInputEventCookie(handler._seat.WlSeat, serial, handler._dispatcher._globals.Connection.Display, handler._dispatcher._globals.Worker, handler._dispatcher._globals);
+                handler._frameActions.Add(() =>
+                {
+                    if (shellSurface != null)
+                    {
+                        handler._activeTouchPoints[id] = (shellSurface.EventSink, pos);
+                        shellSurface.EventSink.OnTouchDown(time, id, pos, cookie);
+                    }
+                });
+            }
+
+            protected override void Motion(WlTouch eventSender, uint time, int id, WlFixed x, WlFixed y)
+            {
+                var pos = new Point((double)x, (double)y);
+                handler._frameActions.Add(() =>
+                {
+                    if (handler._activeTouchPoints.TryGetValue(id, out var entry))
+                    {
+                        entry.Position = pos;
+                        handler._activeTouchPoints[id] = entry;
+                        entry.Sink.OnTouchMove(time, id, pos);
+                    }
+                });
+            }
+
+            protected override void Up(WlTouch eventSender, uint serial, uint time, int id)
+            {
+                handler._frameActions.Add(() =>
+                {
+                    if (handler._activeTouchPoints.Remove(id, out var entry))
+                        entry.Sink.OnTouchUp(time, id, entry.Position);
+                });
+            }
+
+            protected override void Cancel(WlTouch eventSender)
+            {
+                handler._frameActions.Add(() =>
+                {
+                    foreach (var (id, entry) in handler._activeTouchPoints)
+                        entry.Sink.OnTouchCancel(id, entry.Position);
+                    handler._activeTouchPoints.Clear();
+                });
+            }
+
+            protected override void Frame(WlTouch eventSender)
+            {
+                try
+                {
+                    foreach (var action in handler._frameActions)
+                        action();
+                }
+                finally
+                {
+                    handler.ResetFrameState();
+                }
+            }
+
+            protected override void Shape(WlTouch eventSender, int id, WlFixed major, WlFixed minor)
+            {
+                // Shape info not currently used
+            }
+
+            protected override void Orientation(WlTouch eventSender, int id, WlFixed orientation)
+            {
+                // Orientation info not currently used
+            }
+        }
+    }
+
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/WaylandOutputsTracker.cs b/src/Avalonia.Wayland/Server/Transient/WaylandOutputsTracker.cs
new file mode 100644
index 0000000000..f90bf04480
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/WaylandOutputsTracker.cs
@@ -0,0 +1,259 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Wayland.Screens;
+using NWayland.Protocols.Wayland;
+using NWayland.Protocols.XdgOutputUnstableV1;
+
+namespace Avalonia.Wayland.Server.Transient;
+
+/// <summary>
+/// Worker-thread tracker for <c>wl_output</c> globals (plus optional
+/// <c>zxdg_output_v1</c> companions). Produces an immutable
+/// <see cref="WaylandOutputsSnapshot"/> on every change and pushes it
+/// to the UI thread
+/// </summary>
+internal sealed class WaylandOutputsTracker
+{
+    public WaylandOutputsTracker(WaylandOutputsSinkProxy? sink)
+    {
+        _sink = sink;
+    }
+
+    // Track outputs that haven't got their first done event
+    private readonly List<Output> _pendingOutputs = new();
+    public List<Output> Outputs { get; } = new();
+
+    private readonly WaylandOutputsSinkProxy? _sink;
+    private ZxdgOutputManagerV1? _xdgOutputManager;
+
+    /// <summary>
+    /// Wires the xdg-output manager once <see cref="WaylandGlobals"/> has
+    /// finished its initial round-trip. Any outputs already present (in
+    /// either <see cref="_pendingOutputs"/> or <see cref="Outputs"/>) get
+    /// their <c>zxdg_output_v1</c> attached on the spot; outputs added
+    /// later attach inside their constructor.
+    /// </summary>
+    public void AttachXdgOutputManager(ZxdgOutputManagerV1 manager)
+    {
+        if (_xdgOutputManager != null)
+            return;
+        _xdgOutputManager = manager;
+        foreach (var o in _pendingOutputs.Concat(Outputs))
+            o.AttachXdgOutput(manager);
+    }
+
+    public void AddGlobal(WaylandGlobals globals, uint name, uint version)
+    {
+        if (version < 2)
+            return;
+
+        var output = new Output(this, globals.Registry, name, version);
+        _pendingOutputs.Add(output);
+        if (_xdgOutputManager != null)
+            output.AttachXdgOutput(_xdgOutputManager);
+
+        globals.GlobalRemoved += removedName =>
+        {
+            // Snapshot before mutating to avoid double-handling.
+            foreach (var o in _pendingOutputs.Concat(Outputs).ToList())
+            {
+                if (o.Name == removedName)
+                {
+                    _pendingOutputs.Remove(o);
+                    var wasVisible = Outputs.Remove(o);
+                    o.Dispose();
+                    if (wasVisible) 
+                        PushSnapshot();
+                    break;
+                }
+            }
+        };
+    }
+
+    /// <summary>
+    /// Promotes an output to <see cref="Outputs"/> once its initial done
+    /// batch has arrived (or just rebuilds the snapshot if it was already
+    /// visible and just had post-init changes applied).
+    /// </summary>
+    internal void OnOutputDone(Output output)
+    {
+        var becameVisible = _pendingOutputs.Remove(output);
+        if (becameVisible)
+            Outputs.Add(output);
+        PushSnapshot();
+    }
+
+    private void PushSnapshot()
+    {
+        if (_sink == null)
+            return;
+        var list = new List<WaylandOutputSnapshot>(Outputs.Count);
+        foreach (var o in Outputs)
+            list.Add(o.ToSnapshot());
+        _sink.OnOutputsChanged(new WaylandOutputsSnapshot(list));
+    }
+
+    internal sealed class Output : IDisposable
+    {
+        public uint Name { get; }
+        private readonly WaylandOutputsTracker _tracker;
+        private readonly WlOutput _output;
+        private ZxdgOutputV1? _xdgOutput;
+
+        // wl_output state
+        public PixelPoint ModePosition { get; private set; }
+        public PixelSize ModeSize { get; private set; }
+        public int Scale { get; private set; } = 1;
+        public int RefreshMilliHz { get; private set; }
+        public WlOutput.SubpixelEnum Subpixel { get; private set; } = WlOutput.SubpixelEnum.Unknown;
+        public WlOutput.TransformEnum Transform { get; private set; } = WlOutput.TransformEnum.Normal;
+        public PixelSize PhysicalSizeMm { get; private set; }
+        public string? Manufacturer { get; private set; }
+        public string? Model { get; private set; }
+        public string? OutputName { get; private set; }
+        public string? OutputDescription { get; private set; }
+
+        // xdg_output state
+        public bool HasXdgOutput { get; private set; }
+        public PixelPoint XdgPosition { get; private set; }
+        public PixelSize XdgSize { get; private set; }
+        public string? XdgName { get; private set; }
+        public string? XdgDescription { get; private set; }
+
+        public object Id { get; } = new();
+
+        public WlOutput WlOutput => _output;
+
+        public Output(WaylandOutputsTracker tracker, WlRegistry registry, uint name, uint version)
+        {
+            Name = name;
+            _tracker = tracker;
+            _output = WlOutput.Bind(registry, name, Math.Min(4u, version), new WlListener(this));
+        }
+
+        public void AttachXdgOutput(ZxdgOutputManagerV1 manager)
+        {
+            if (_xdgOutput != null)
+                return;
+            // Manager bind is gated to v3+ in WaylandGlobals, so
+            // wl_output.done is the unified terminator for both wl_output
+            // and zxdg_output_v1 events.
+            _xdgOutput = manager.GetXdgOutput(_output, new XdgListener(this));
+        }
+
+        internal void OnWlOutputDone()
+        {
+            _tracker.OnOutputDone(this);
+        }
+
+        public WaylandOutputSnapshot ToSnapshot()
+        {
+            var (pos, size) = ComputeLogical();
+            return new WaylandOutputSnapshot(
+                Id: Id,
+                Name: XdgName ?? OutputName,
+                Description: XdgDescription ?? OutputDescription,
+                Manufacturer: Manufacturer,
+                Model: Model,
+                LogicalPosition: pos,
+                LogicalSize: size,
+                IntegerScale: Scale,
+                RefreshRateHz: RefreshMilliHz / 1000.0,
+                Subpixel: Subpixel,
+                Transform: Transform,
+                PhysicalSizeMm: PhysicalSizeMm);
+        }
+
+        public PixelPoint LogicalPosition => ComputeLogical().pos;
+        public PixelSize LogicalSize => ComputeLogical().size;
+
+        private (PixelPoint pos, PixelSize size) ComputeLogical()
+        {
+            if (HasXdgOutput)
+            {
+                // https://gitlab.gnome.org/GNOME/mutter/-/issues/2631
+                // If integer scale > 1 and xdg_output reports the same size
+                // as wl_output.mode (which is in physical pixels), mutter
+                // is lying. Fall through to the mode/scale derivation.
+                var mutterpt = Scale > 1 && XdgSize == ModeSize;
+                if (!mutterpt)
+                    return (XdgPosition, XdgSize);
+            }
+            // Fallback: derive logical pixels from wl_output.mode divided
+            // by wl_output.scale (geometry top-left is already in
+            // compositor surface coords, no division needed). Matches
+            // GTK/Qt fallback when xdg_output is absent.
+            return (ModePosition, new PixelSize(
+                Math.Max(1, ModeSize.Width / Math.Max(1, Scale)),
+                Math.Max(1, ModeSize.Height / Math.Max(1, Scale))));
+        }
+
+        public void Dispose()
+        {
+            if (_xdgOutput != null)
+            {
+                _xdgOutput.Destroy();
+                _xdgOutput.Dispose();
+                _xdgOutput = null;
+            }
+            if (_output.IsReleaseAvailable)
+                _output.Release();
+            else
+                _output.Dispose();
+        }
+
+        private sealed class WlListener(Output p) : WlOutput.Listener
+        {
+            protected override void Name(WlOutput eventSender, string name) => p.OutputName = name;
+
+            protected override void Description(WlOutput eventSender, string description) => p.OutputDescription = description;
+
+            protected override void Done(WlOutput eventSender) => p.OnWlOutputDone();
+
+            protected override void Geometry(WlOutput eventSender, int x, int y, int physicalWidth, int physicalHeight,
+                WlOutput.SubpixelEnum subpixel, string make, string model, WlOutput.TransformEnum transform)
+            {
+                p.ModePosition = new PixelPoint(x, y);
+                p.PhysicalSizeMm = new PixelSize(physicalWidth, physicalHeight);
+                p.Subpixel = subpixel;
+                p.Manufacturer = make;
+                p.Model = model;
+                p.Transform = transform;
+            }
+
+            protected override void Mode(WlOutput eventSender, WlOutput.ModeEnum flags, int width, int height, int refresh)
+            {
+                if (!flags.HasFlag(WlOutput.ModeEnum.Current))
+                    return;
+                p.ModeSize = new PixelSize(width, height);
+                p.RefreshMilliHz = refresh;
+            }
+
+            protected override void Scale(WlOutput eventSender, int factor) => p.Scale = factor;
+        }
+
+        private sealed class XdgListener(Output p) : ZxdgOutputV1.Listener
+        {
+            protected override void LogicalPosition(ZxdgOutputV1 eventSender, int x, int y)
+            {
+                p.HasXdgOutput = true;
+                p.XdgPosition = new PixelPoint(x, y);
+            }
+
+            protected override void LogicalSize(ZxdgOutputV1 eventSender, int width, int height)
+            {
+                p.HasXdgOutput = true;
+                p.XdgSize = new PixelSize(width, height);
+            }
+
+            // zxdg_output_v1.done is deprecated since v3 (we only bind
+            // v3+); wl_output.done is the unified terminator.
+            protected override void Done(ZxdgOutputV1 eventSender) { }
+
+            protected override void Name(ZxdgOutputV1 eventSender, string name) => p.XdgName = name;
+
+            protected override void Description(ZxdgOutputV1 eventSender, string description) => p.XdgDescription = description;
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/WaylandTextInputV3.cs b/src/Avalonia.Wayland/Server/Transient/WaylandTextInputV3.cs
new file mode 100644
index 0000000000..a06f9bd5e2
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/WaylandTextInputV3.cs
@@ -0,0 +1,570 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Input.TextInput;
+using Avalonia.Logging;
+using Avalonia.Wayland.Server.Persistent;
+using NWayland.Protocols.TextInputUnstableV3;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Server.Transient;
+
+/// <summary>
+/// Worker-side facade for <c>zwp_text_input_v3</c>. Owns the per-seat protocol
+/// proxies and per-surface state cache. Bridges incoming compositor events into
+/// the broker via <see cref="IWaylandTextInputV3Events"/>.
+/// </summary>
+/// <remarks>
+/// All public methods must be called on the Wayland worker thread (post via
+/// <c>WaylandWorkerClient.PostOob</c> from the UI thread).
+/// </remarks>
+internal sealed class WaylandTextInputV3(ZwpTextInputManagerV3 manager)
+{
+    private readonly Dictionary<uint, PerSeat> _seats = new();
+    private readonly Dictionary<WSurface, PerSurface> _surfaces = new();
+
+    public void OnSeatAdded(uint seatGlobalName, WlSeat wlSeat)
+    {
+        if (_seats.ContainsKey(seatGlobalName))
+            return;
+        var seat = new PerSeat(this, seatGlobalName);
+        seat.Proxy = manager.GetTextInput(wlSeat, seat.CreateListener(), null);
+        _seats[seatGlobalName] = seat;
+    }
+
+    public void OnSeatRemoved(uint seatGlobalName)
+    {
+        if (!_seats.Remove(seatGlobalName, out var seat))
+            return;
+        if (seat.FocusedSurface is { } surface
+            && _surfaces.TryGetValue(surface, out var perSurface))
+        {
+            perSurface.EnteredSeats.Remove(seat);
+        }
+        try { seat.Proxy?.Destroy(); } catch { }
+        seat.Proxy?.Dispose();
+    }
+
+    public void Dispose()
+    {
+        foreach (var seat in _seats.Values)
+        {
+            try { seat.Proxy?.Destroy(); } catch { }
+            seat.Proxy?.Dispose();
+        }
+        _seats.Clear();
+        _surfaces.Clear();
+        try { manager.Destroy(); } catch { }
+        manager.Dispose();
+    }
+
+    public void RegisterSurface(WSurface s, WaylandTextInputV3EventsProxy sink)
+    {
+        if (_surfaces.ContainsKey(s))
+            return;
+        var ps = new PerSurface(s, sink);
+        // Reconcile: if any seat's text-input-v3 already has focus on this
+        // surface (enter event arrived before the broker registered), record
+        // it now so a subsequent SetActive(true) can issue Enable+Commit.
+        foreach (var seat in _seats.Values)
+        {
+            if (ReferenceEquals(seat.FocusedSurface, s))
+                ps.EnteredSeats.Add(seat);
+        }
+        _surfaces[s] = ps;
+    }
+
+    public void UnregisterSurface(WSurface s)
+    {
+        if (!_surfaces.Remove(s, out var perSurface))
+            return;
+        // For each seat currently entered on this surface, send disable+commit
+        // so the compositor stops routing IME events to a now-dead surface.
+        foreach (var seat in perSurface.EnteredSeats)
+        {
+            if (ReferenceEquals(seat.FocusedSurface, s))
+                seat.FocusedSurface = null;
+            DisableAndClear(seat, perSurface);
+        }
+    }
+
+    public void SetActive(WSurface s, bool hasClient, bool supportsPreedit, bool supportsSurroundingText)
+    {
+        if (!_surfaces.TryGetValue(s, out var ps))
+            return;
+        ps.HasClient = hasClient;
+        ps.SupportsPreedit = supportsPreedit;
+        ps.SupportsSurroundingText = supportsSurroundingText;
+        PushStateToEnteredSeats(s, ps);
+    }
+
+    /// <summary>
+    /// Aborts any in-flight IME composition for this surface: sends
+    /// disable+commit on every entered seat and clears the per-seat
+    /// last-delivered state so the next preedit is not deduped away.
+    /// Also clears cached surrounding text so the next client starts clean.
+    /// Called when the broker's TextInputMethodClient changes.
+    /// </summary>
+    public void AbortComposition(WSurface s)
+    {
+        if (!_surfaces.TryGetValue(s, out var ps))
+            return;
+        foreach (var seat in ps.EnteredSeats)
+        {
+            DisableAndClear(seat, ps);
+            seat.ClearLastDelivered();
+        }
+        ps.LastSentEnabled = false;
+        ps.SurroundingText = null;
+        ps.SurroundingCursorChar = 0;
+        ps.SurroundingAnchorChar = 0;
+        ps.CursorRect = null;
+        ps.Options = null;
+        ps.HasClient = false;
+    }
+
+    public void SetCursorRect(WSurface s, Rect logical)
+    {
+        if (!_surfaces.TryGetValue(s, out var ps))
+            return;
+        ps.CursorRect = logical;
+        if (!ps.LastSentEnabled)
+            return;
+        var pixelRect = TranslateCursorRect(s, logical);
+        foreach (var seat in ps.EnteredSeats)
+        {
+            if (seat.Proxy is not { } proxy)
+                continue;
+            proxy.SetCursorRectangle(pixelRect.x, pixelRect.y, pixelRect.w, pixelRect.h);
+            seat.Commit();
+        }
+    }
+
+    public void SetOptions(WSurface s, TextInputOptions options)
+    {
+        if (!_surfaces.TryGetValue(s, out var ps))
+            return;
+        ps.Options = options;
+        if (!ps.LastSentEnabled)
+            return;
+        var (hint, purpose) = TextInputOptionsConverter.Convert(options);
+        foreach (var seat in ps.EnteredSeats)
+        {
+            if (seat.Proxy is not { } proxy)
+                continue;
+            proxy.SetContentType(hint, purpose);
+            seat.Commit();
+        }
+    }
+
+    public void SetSurroundingText(WSurface s, string text, int cursorChar, int anchorChar)
+    {
+        if (!_surfaces.TryGetValue(s, out var ps))
+            return;
+        ps.SurroundingText = text;
+        ps.SurroundingCursorChar = cursorChar;
+        ps.SurroundingAnchorChar = anchorChar;
+        if (!ps.LastSentEnabled || !ps.SupportsSurroundingText)
+            return;
+
+        // Compositors enforce a 4000-byte cap per spec; truncate around cursor.
+        var (clampedText, cursorByte, anchorByte) = ClampSurroundingForWayland(text, cursorChar, anchorChar);
+
+        foreach (var seat in ps.EnteredSeats)
+        {
+            if (seat.Proxy is not { } proxy)
+                continue;
+            proxy.SetSurroundingText(clampedText, cursorByte, anchorByte);
+            proxy.SetTextChangeCause(ZwpTextInputV3.ChangeCauseEnum.Other);
+            seat.Commit();
+        }
+    }
+
+    public void Reset(WSurface s)
+    {
+        // v3 has no reset request. Closest safe behaviour: drop pending preedit
+        // by issuing disable + enable + commit. Compositor treats this as a fresh
+        // session and discards in-flight preedit.
+        if (!_surfaces.TryGetValue(s, out var ps) || !ps.HasClient)
+            return;
+        var hadDeliveredPreedit = false;
+        foreach (var seat in ps.EnteredSeats)
+        {
+            if (seat.Proxy is not { } proxy)
+                continue;
+            if (!string.IsNullOrEmpty(seat.LastDeliveredPreedit))
+                hadDeliveredPreedit = true;
+            seat.ClearPending();
+            seat.ClearLastDelivered();
+            proxy.Disable();
+            seat.Commit();
+            proxy.Enable();
+            PushSeatStateLocked(seat, s, ps);
+            seat.Commit();
+        }
+        // Clear stale composition on the client side too — otherwise the visible
+        // preedit lingers until the IME (re-)sends one, which may be deduped.
+        if (hadDeliveredPreedit)
+            ps.Sink.OnImeUpdate(ps.Surface.TextInputSessionToken, 0, 0, null, null, -1, -1);
+    }
+
+    private static void DisableAndClear(PerSeat seat, PerSurface ps)
+    {
+        if (ps.LastSentEnabled && seat.Proxy is { } proxy)
+        {
+            try
+            {
+                proxy.Disable();
+                seat.Commit();
+            }
+            catch { }
+        }
+        seat.ClearPending();
+    }
+
+    private static void PushStateToEnteredSeats(WSurface s, PerSurface ps)
+    {
+        var enable = ps.HasClient;
+        foreach (var seat in ps.EnteredSeats)
+        {
+            if (seat.Proxy is not { } proxy)
+                continue;
+            if (enable)
+            {
+                proxy.Enable();
+                PushSeatStateLocked(seat, s, ps);
+            }
+            else if (ps.LastSentEnabled)
+            {
+                proxy.Disable();
+            }
+            seat.Commit();
+        }
+        ps.LastSentEnabled = enable;
+    }
+
+    private static void PushSeatStateLocked(PerSeat seat, WSurface s, PerSurface ps)
+    {
+        if (seat.Proxy is not { } proxy)
+            return;
+        if (ps.Options is { } options)
+        {
+            var (hint, purpose) = TextInputOptionsConverter.Convert(options);
+            proxy.SetContentType(hint, purpose);
+        }
+        if (ps.CursorRect is { } rect)
+        {
+            var (x, y, w, h) = TranslateCursorRect(s, rect);
+            proxy.SetCursorRectangle(x, y, w, h);
+        }
+        if (ps.SupportsSurroundingText && ps.SurroundingText is { } text)
+        {
+            var (clampedText, cursorByte, anchorByte) =
+                ClampSurroundingForWayland(text, ps.SurroundingCursorChar, ps.SurroundingAnchorChar);
+            proxy.SetSurroundingText(clampedText, cursorByte, anchorByte);
+            proxy.SetTextChangeCause(ZwpTextInputV3.ChangeCauseEnum.Other);
+        }
+    }
+
+    private static (int x, int y, int w, int h) TranslateCursorRect(WSurface s, Rect logical)
+    {
+        // The cursor rectangle is in surface-local logical units. Under fractional
+        // scaling this matches wp_viewport.set_destination units (also surface-local
+        // logical). Add shadow extents so the candidate window appears next to the
+        // editable content area, not next to the drop shadow.
+        var shadow = (s as WXdgShellSurface)?.ShadowExtents ?? default;
+        var x = (int)Math.Round(logical.X) + (int)Math.Round(shadow.Left);
+        var y = (int)Math.Round(logical.Y) + (int)Math.Round(shadow.Top);
+        var w = Math.Max(1, (int)Math.Round(logical.Width));
+        var h = Math.Max(1, (int)Math.Round(logical.Height));
+        return (x, y, w, h);
+    }
+
+    private static (string text, int cursorByte, int anchorByte) ClampSurroundingForWayland(
+        string text, int cursorChar, int anchorChar)
+    {
+        const int MaxBytes = 4000;
+        var totalBytes = System.Text.Encoding.UTF8.GetByteCount(text);
+        if (totalBytes <= MaxBytes)
+        {
+            return (
+                text,
+                WaylandTextUtils.Utf8ByteIndexFromCharIndex(text, cursorChar),
+                WaylandTextUtils.Utf8ByteIndexFromCharIndex(text, anchorChar));
+        }
+
+        // Trim around cursor: keep ~half of MaxBytes on each side. The protocol
+        // accepts text that doesn't extend to start/end as a partial window.
+        var half = MaxBytes / 2;
+        var cursorClamped = Math.Clamp(cursorChar, 0, text.Length);
+        var startChar = WaylandTextUtils.CharIndexFromUtf8Offset(text, -half, cursorClamped);
+        var endChar = WaylandTextUtils.CharIndexFromUtf8Offset(text, half, cursorClamped);
+        var trimmed = text.Substring(startChar, endChar - startChar);
+
+        var cursorByte = WaylandTextUtils.Utf8ByteIndexFromCharIndex(trimmed,
+            Math.Clamp(cursorChar - startChar, 0, trimmed.Length));
+        var anchorByte = WaylandTextUtils.Utf8ByteIndexFromCharIndex(trimmed,
+            Math.Clamp(anchorChar - startChar, 0, trimmed.Length));
+        return (trimmed, cursorByte, anchorByte);
+    }
+
+    // ----- inner state types -----
+
+    private sealed class PerSurface(WSurface surface, WaylandTextInputV3EventsProxy sink)
+    {
+        public WSurface Surface { get; } = surface;
+        public WaylandTextInputV3EventsProxy Sink { get; } = sink;
+        public List<PerSeat> EnteredSeats { get; } = new();
+        public bool HasClient;
+        public bool SupportsPreedit;
+        public bool SupportsSurroundingText;
+        public bool LastSentEnabled;
+        public Rect? CursorRect;
+        public TextInputOptions? Options;
+        public string? SurroundingText;
+        public int SurroundingCursorChar;
+        public int SurroundingAnchorChar;
+    }
+
+    private sealed class PerSeat(WaylandTextInputV3 owner, uint globalName)
+    {
+        public uint GlobalName { get; } = globalName;
+        public ZwpTextInputV3? Proxy;
+        public WSurface? FocusedSurface;
+        public uint CommitSerial;
+        public uint LastDoneSerial;
+
+        // Pending state, accumulated until a done event. The protocol uses
+        // a double-buffered model: preedit_string / commit_string /
+        // delete_surrounding_text events stage values that are applied — and
+        // reset — atomically on each done. So a done with no preceding
+        // preedit_string event clears the preedit; this is how the protocol
+        // model works, not a special-case rule.
+        public string PendingPreedit = string.Empty;
+        public int PendingPreeditCursorBeginByte;
+        public int PendingPreeditCursorEndByte = -1;
+        public string PendingCommit = string.Empty;
+        public bool HasDelete;
+        public uint PendingDeleteBeforeBytes;
+        public uint PendingDeleteAfterBytes;
+
+        // Last delivered preedit (for done-event dedup).
+        public string? LastDeliveredPreedit;
+        public int LastDeliveredCursorBeginChar;
+        public int LastDeliveredCursorEndChar;
+
+        public ZwpTextInputV3.Listener CreateListener() => new SeatListener(owner, this);
+
+        public void Commit()
+        {
+            CommitSerial++;
+            Proxy?.Commit();
+        }
+
+        public void ClearPending()
+        {
+            PendingPreedit = string.Empty;
+            PendingPreeditCursorBeginByte = 0;
+            PendingPreeditCursorEndByte = -1;
+            PendingCommit = string.Empty;
+            HasDelete = false;
+            PendingDeleteBeforeBytes = PendingDeleteAfterBytes = 0;
+        }
+
+        public void ClearLastDelivered()
+        {
+            LastDeliveredPreedit = null;
+            LastDeliveredCursorBeginChar = 0;
+            LastDeliveredCursorEndChar = 0;
+        }
+    }
+
+    private sealed class SeatListener(WaylandTextInputV3 owner, PerSeat seat) : ZwpTextInputV3.Listener
+    {
+        protected override void Enter(ZwpTextInputV3 sender, WlSurface? surface)
+        {
+            var ws = ResolveSurface(surface);
+            if (ws == null)
+                return;
+            seat.FocusedSurface = ws;
+            if (!owner._surfaces.TryGetValue(ws, out var ps))
+                return;
+            ps.EnteredSeats.Remove(seat);
+            ps.EnteredSeats.Add(seat);
+            seat.ClearPending();
+
+            if (ps.HasClient && seat.Proxy is { } proxy)
+            {
+                proxy.Enable();
+                PushSeatStateLocked(seat, ws, ps);
+                seat.Commit();
+                ps.LastSentEnabled = true;
+            }
+        }
+
+        protected override void Leave(ZwpTextInputV3 sender, WlSurface? surface)
+        {
+            var ws = ResolveSurface(surface);
+            if (ws == null && seat.FocusedSurface == null)
+                return;
+            ws ??= seat.FocusedSurface;
+            seat.FocusedSurface = null;
+            seat.ClearPending();
+            if (ws != null && owner._surfaces.TryGetValue(ws, out var ps))
+            {
+                ps.EnteredSeats.Remove(seat);
+                if (ps.EnteredSeats.Count == 0)
+                    ps.LastSentEnabled = false;
+
+                // Per spec, leaving invalidates any in-flight preedit. If we
+                // had delivered preedit text from this seat, clear it on the
+                // client side so the user doesn't see stale composition text.
+                if (!string.IsNullOrEmpty(seat.LastDeliveredPreedit))
+                {
+                    ps.Sink.OnImeUpdate(ps.Surface.TextInputSessionToken, 0, 0, null, null, -1, -1);
+                }
+            }
+            seat.ClearLastDelivered();
+        }
+
+        protected override void PreeditString(ZwpTextInputV3 sender, string? text, int cursorBegin, int cursorEnd)
+        {
+            seat.PendingPreedit = text ?? string.Empty;
+            seat.PendingPreeditCursorBeginByte = cursorBegin;
+            seat.PendingPreeditCursorEndByte = cursorEnd;
+        }
+
+        protected override void CommitString(ZwpTextInputV3 sender, string? text)
+        {
+            seat.PendingCommit = text ?? string.Empty;
+        }
+
+        protected override void DeleteSurroundingText(ZwpTextInputV3 sender, uint beforeLength, uint afterLength)
+        {
+            seat.HasDelete = true;
+            seat.PendingDeleteBeforeBytes = beforeLength;
+            seat.PendingDeleteAfterBytes = afterLength;
+        }
+
+        protected override void Done(ZwpTextInputV3 sender, uint serial)
+        {
+            seat.LastDoneSerial = serial;
+
+            // Snapshot pending state, then clear immediately. The protocol's
+            // double-buffered model requires pending preedit/commit/delete
+            // to be consumed atomically on each done — so a subsequent done
+            // with no preedit_string event clears the preedit.
+            var pendingPreedit = seat.PendingPreedit;
+            var pendingPreeditBeginByte = seat.PendingPreeditCursorBeginByte;
+            var pendingPreeditEndByte = seat.PendingPreeditCursorEndByte;
+            var pendingCommit = seat.PendingCommit;
+            var hasDelete = seat.HasDelete;
+            var pendingDeleteBefore = seat.PendingDeleteBeforeBytes;
+            var pendingDeleteAfter = seat.PendingDeleteAfterBytes;
+            seat.ClearPending();
+
+            // Only the active seat for its focused surface surfaces IME state.
+            var surface = seat.FocusedSurface;
+            if (surface == null
+                || !owner._surfaces.TryGetValue(surface, out var ps)
+                || ps.EnteredSeats.Count == 0
+                || ps.EnteredSeats[ps.EnteredSeats.Count - 1] != seat)
+            {
+                if (Logger.TryGet(LogEventLevel.Verbose, "Wayland.TextInput") is { } log)
+                    log.Log(this, "Dropping IME 'done' from non-active seat {Seat}", seat.GlobalName);
+                return;
+            }
+
+            var sink = ps.Sink;
+            // Per spec (zwp_text_input_v3.done): "The serial number reflects
+            // the last state of zwp_text_input_v3.commit request. The client
+            // is expected to compare this serial with the most recent commit's
+            // serial it has sent. If they don't match the client must ignore
+            // the changes." Every enable/disable/state push we make ends in a
+            // commit() that bumps commit_count, so a stale serial means the
+            // batch was generated against state we've already superseded
+            // (e.g. a prior focus/client session). Drop the whole batch.
+            if (serial != seat.CommitSerial)
+            {
+                if (Logger.TryGet(LogEventLevel.Verbose, "Wayland.TextInput") is { } staleLog)
+                    staleLog.Log(this,
+                        "Dropping stale text-input-v3 done batch (done.serial={Serial}, commit_count={Commit})",
+                        serial, seat.CommitSerial);
+                return;
+            }
+
+            // Spec event order on the client side:
+            //   1. clear current preedit (implicit before commit/delete);
+            //   2. apply delete_surrounding_text;
+            //   3. insert commit text;
+            //   4. apply new preedit.
+            // We deliver all four operations to the UI thread as a SINGLE
+            // proxy call so they apply atomically (no other UI work can
+            // interleave between them).
+            var commitText = pendingCommit.Length > 0 ? pendingCommit : null;
+            var hasCommit = commitText != null;
+
+            int deleteBeforeChars = 0, deleteAfterChars = 0;
+            if (hasDelete && ps.SupportsSurroundingText)
+                (deleteBeforeChars, deleteAfterChars) = ConvertDeleteToChars(
+                    ps, pendingDeleteBefore, pendingDeleteAfter);
+
+            // Compute new preedit (null = clear).
+            int beginChar, endChar;
+            if (pendingPreeditBeginByte < 0 || pendingPreeditEndByte < 0)
+            {
+                beginChar = endChar = -1;
+            }
+            else
+            {
+                beginChar = WaylandTextUtils.CharIndexFromUtf8Offset(pendingPreedit, pendingPreeditBeginByte, 0);
+                endChar = WaylandTextUtils.CharIndexFromUtf8Offset(pendingPreedit, pendingPreeditEndByte, 0);
+            }
+            var newPreedit = pendingPreedit.Length == 0 ? null : pendingPreedit;
+
+            var preeditUnchanged = seat.LastDeliveredPreedit == newPreedit
+                && seat.LastDeliveredCursorBeginChar == beginChar
+                && seat.LastDeliveredCursorEndChar == endChar;
+
+            // Skip the entire batch only when nothing observable happens: no
+            // commit, no delete, and the preedit is byte-for-byte identical
+            // to what we last sent.
+            var hasObservableDelete = deleteBeforeChars > 0 || deleteAfterChars > 0;
+            if (!hasCommit && !hasObservableDelete && preeditUnchanged)
+                return;
+
+            sink.OnImeUpdate(
+                ps.Surface.TextInputSessionToken,
+                deleteBeforeChars, deleteAfterChars,
+                commitText,
+                newPreedit, beginChar, endChar);
+
+            seat.LastDeliveredPreedit = newPreedit;
+            seat.LastDeliveredCursorBeginChar = beginChar;
+            seat.LastDeliveredCursorEndChar = endChar;
+        }
+
+        private static (int beforeChars, int afterChars) ConvertDeleteToChars(PerSurface ps, uint beforeBytes, uint afterBytes)
+        {
+            // No surrounding-text snapshot means we can't safely convert the
+            // protocol's UTF-8 byte counts to UTF-16 char counts (passing the
+            // bytes through would be wrong for any non-ASCII text). The IME
+            // shouldn't issue delete_surrounding_text without us first sending
+            // set_surrounding_text, so just drop.
+            if (ps.SurroundingText is null)
+                return (0, 0);
+            var cursorChar = ps.SurroundingCursorChar;
+            var beforeStartChar = WaylandTextUtils.CharIndexFromUtf8Offset(ps.SurroundingText, -(int)beforeBytes, cursorChar);
+            var afterEndChar = WaylandTextUtils.CharIndexFromUtf8Offset(ps.SurroundingText, (int)afterBytes, cursorChar);
+            return (cursorChar - beforeStartChar, afterEndChar - cursorChar);
+        }
+
+        private static WSurface? ResolveSurface(WlSurface? wlSurface)
+        {
+            if (wlSurface == null)
+                return null;
+            if (wlSurface.Tags.TryGetValue(typeof(WXdgShellSurface), out var tag))
+                return (WSurface)tag;
+            return null;
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/XdgToplevelExport.cs b/src/Avalonia.Wayland/Server/Transient/XdgToplevelExport.cs
new file mode 100644
index 0000000000..2986b8c022
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/Transient/XdgToplevelExport.cs
@@ -0,0 +1,66 @@
+using System;
+using System.Threading.Tasks;
+using Avalonia.Wayland.Server.Persistent;
+using NWayland;
+using NWayland.Protocols.Wayland;
+using NWayland.Protocols.XdgForeignUnstableV2;
+
+namespace Avalonia.Wayland.Server.Transient;
+
+/// <summary>
+/// Worker-thread handle to a single <c>zxdg_exported_v2</c> export of a wayland
+/// toplevel. Implements the UI-facing <see cref="IWaylandXdgTopLevelExport"/>
+/// directly so it can be returned through the cross-thread proxy: <see cref="IWaylandXdgTopLevelExport.HandleTask"/>
+/// is just a TCS that the worker completes when the compositor delivers the handle event,
+/// and Dispose hops back to the worker thread for the actual destroy.
+/// </summary>
+internal sealed class XdgToplevelExport : IDisposable
+{
+    private readonly WXdgTopLevel _owner;
+    private readonly WaylandWorker _worker;
+    private readonly TaskCompletionSource<string?> _handleTcs =
+        new(TaskCreationOptions.RunContinuationsAsynchronously);
+    private ZxdgExportedV2? _exported;
+    private bool _alive = true;
+
+    internal XdgToplevelExport(WXdgTopLevel owner, WaylandWorker worker, ZxdgExporterV2 exporter,
+        WlSurface surface, WlEventQueue queue)
+    {
+        _owner = owner;
+        _worker = worker;
+        _exported = exporter.ExportToplevel(surface, new ExportListener(this), queue);
+    }
+
+    public IWaylandXdgTopLevelExport GetUiThreadHandle() => new UiThreadHandle(this);
+    
+    class UiThreadHandle(XdgToplevelExport parent) : IWaylandXdgTopLevelExport
+    {
+        public Task<string?> HandleTask => parent._handleTcs.Task;
+        
+        public void Dispose() => parent._worker.PostOob(parent.Dispose);
+    }
+
+    public void Dispose()
+    {
+        if (!_alive)
+            return;
+        _alive = false;
+        _exported?.Destroy();
+        _exported = null;
+        _owner.RemoveExport(this);
+        // Unblock any awaiter that's still waiting on a handle event we'll never get.
+        _handleTcs.TrySetResult(null);
+    }
+
+    private void OnHandle(string handle)
+    {
+        if (!_alive)
+            return;
+        _handleTcs.TrySetResult(handle);
+    }
+
+    private sealed class ExportListener(XdgToplevelExport self) : ZxdgExportedV2.Listener
+    {
+        protected override void Handle(ZxdgExportedV2 eventSender, string handle) => self.OnHandle(handle);
+    }
+}
diff --git a/src/Avalonia.Wayland/Server/WaylandDispatchPriority.cs b/src/Avalonia.Wayland/Server/WaylandDispatchPriority.cs
new file mode 100644
index 0000000000..79ae32e7b5
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/WaylandDispatchPriority.cs
@@ -0,0 +1,19 @@
+namespace Avalonia.Wayland.Server;
+
+/// <summary>
+/// Priority for cross-thread dispatch between UI and Wayland threads.
+/// </summary>
+internal enum WaylandDispatchPriority
+{
+    /// <summary>
+    /// UI→worker: batched with the next compositor commit.
+    /// Worker→UI: posted at default dispatcher priority.
+    /// </summary>
+    Normal,
+
+    /// <summary>
+    /// UI→worker: out-of-band, processed immediately by the worker.
+    /// Worker→UI: posted at Send dispatcher priority (highest).
+    /// </summary>
+    Oob
+}
diff --git a/src/Avalonia.Wayland/Server/WaylandMarshallers.cs b/src/Avalonia.Wayland/Server/WaylandMarshallers.cs
new file mode 100644
index 0000000000..58ef0d35ef
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/WaylandMarshallers.cs
@@ -0,0 +1,17 @@
+using System;
+using Avalonia.Threading;
+
+namespace Avalonia.Wayland.Server;
+
+/// <summary>
+/// Marshallers used by generated cross-thread proxies.
+/// </summary>
+/// <remarks>
+/// The UI-thread marshaller is stateless and exposed as a singleton. The
+/// worker-thread marshaller is per-worker and exposed via
+/// <see cref="WaylandWorkerClient.Marshaller"/> — there is no global worker.
+/// </remarks>
+internal static class WaylandMarshallers
+{
+    public static Action<Action, DispatcherPriority> UIThread { get; } = Dispatcher.UIThread.Post;
+}
diff --git a/src/Avalonia.Wayland/Server/WaylandPlatformGraphics.cs b/src/Avalonia.Wayland/Server/WaylandPlatformGraphics.cs
new file mode 100644
index 0000000000..3f0ae79ddf
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/WaylandPlatformGraphics.cs
@@ -0,0 +1,54 @@
+using System;
+using Avalonia.Platform;
+using Avalonia.Platform.Surfaces;
+using Avalonia.Wayland.Server.Persistent;
+
+namespace Avalonia.Wayland.Server;
+
+class WaylandPlatformGraphics : IPlatformGraphicsWithFeatures, IPlatformGraphicsReadyStateFeature
+{
+    private IWaylandGraphics? _inner;
+
+    public interface IWaylandGraphics : IDisposable
+    {
+        IPlatformGraphicsContext CreateContext();
+        IPlatformRenderSurface CreateRenderSurface(WSurface surface);
+    }
+
+    public bool UsesSharedContext => false;
+    public IPlatformGraphicsContext CreateContext() => (_inner ?? throw new InvalidOperationException()).CreateContext();
+
+    /// <summary>
+    /// Currently-bound backend, or <c>null</c> if none. Identity also
+    /// serves as a cache key for callers that need to invalidate
+    /// per-backend state across reconnects.
+    /// </summary>
+    public IWaylandGraphics? CurrentGraphics => _inner;
+
+    public IPlatformGraphicsContext GetSharedContext() => throw new NotSupportedException();
+
+    public object? TryGetFeature(Type featureType)
+    {
+        if (featureType == typeof(IPlatformGraphicsReadyStateFeature))
+            return this;
+        return null;
+    }
+
+    public bool IsReady { get; private set; }
+
+    public bool UsesContexts => _inner != null;
+
+    public void Reset()
+    {
+        IsReady = false;
+        _inner?.Dispose();
+        _inner = null;
+    }
+
+    public void Initialize(IWaylandGraphics? graphics)
+    {
+        _inner?.Dispose();
+        _inner = graphics;
+        IsReady = true;
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Server/WaylandWorker.RenderTimer.cs b/src/Avalonia.Wayland/Server/WaylandWorker.RenderTimer.cs
new file mode 100644
index 0000000000..dff5329a97
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/WaylandWorker.RenderTimer.cs
@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using System.Timers;
+using Avalonia.Logging;
+using Avalonia.Rendering;
+
+namespace Avalonia.Wayland.Server;
+
+partial class WaylandWorker
+{
+    private bool _renderLoopWakeupPending = false;
+    private ServerSignaler _renderLoopWakeupSignaler = null!;
+    private readonly Stopwatch _clock = Stopwatch.StartNew();
+    private TimeSpan? _renderLoopStarvedSince;
+    private readonly object _renderLoopStarvationLock = new object();
+    
+    
+    private readonly RenderLoopImpl _renderLoop = new RenderLoopImpl();
+    public IRenderLoop RenderLoop => _renderLoop;
+    
+    // The target FPS for UI thread animations when Wayland compositor doesn't think
+    // that we should be rendering yet
+    private const int ThrottledUiThreadFps = 20;
+    private static readonly TimeSpan s_RenderLoopStarvationInterval = TimeSpan.FromSeconds(1.0 / ThrottledUiThreadFps);
+
+    private readonly System.Timers.Timer _renderLoopStarvationTimer = new System.Timers.Timer(s_RenderLoopStarvationInterval);
+
+    class RenderLoopImpl : IRenderLoop
+    {
+        private readonly List<IRenderLoopTask> _tasks = new();
+        private readonly List<IRenderLoopTask> _tasksCopy = new();
+        private int _inTick;
+        internal Action? WakeupCallback;
+
+        public bool RunsInBackground => true;
+        
+        public void Add(IRenderLoopTask i)
+        {
+            lock (_tasks)
+                _tasks.Add(i);
+            Wakeup();
+        }
+
+        public void Remove(IRenderLoopTask i)
+        {
+            lock (_tasks)
+                _tasks.Remove(i);
+        }
+
+        public void Wakeup()
+        {
+            WakeupCallback?.Invoke();
+        }
+
+        public void DoTick()
+        {
+            if (Interlocked.CompareExchange(ref _inTick, 1, 0) != 0)
+                return;
+            try
+            {
+                lock (_tasks)
+                {
+                    _tasksCopy.Clear();
+                    _tasksCopy.AddRange(_tasks);
+                }
+
+                for (int i = 0; i < _tasksCopy.Count; i++)
+                    _tasksCopy[i].Render();
+
+                _tasksCopy.Clear();
+            }
+            finally
+            {
+                Interlocked.Exchange(ref _inTick, 0);
+            }
+        }
+    }
+    
+    public void WakeupRenderLoop() => _renderLoopWakeupPending = true;
+
+    public void AnyThreadWakeupRenderLoop() => _renderLoopWakeupSignaler.Signal();
+    
+    void InitRenderTimer()
+    {
+        _renderLoop.WakeupCallback = () =>
+        {
+            WakeupRenderLoop();
+            _wakeupFd.Set();
+        };
+        
+        Compositor.AfterCommit += delegate
+        {
+            if (_hasPendingServerJobs)
+            {
+                _hasPendingServerJobs = false;
+                AnyThreadWakeupRenderLoop();
+            }
+
+            lock (_renderLoopStarvationLock)
+            {
+                if (_renderLoopStarvedSince == null)
+                {
+                    _renderLoopStarvedSince = _clock.Elapsed;
+                    _renderLoopStarvationTimer.Enabled = true;
+                }
+            }
+            _wakeupFd.Set();
+        };
+        _renderLoopWakeupSignaler = new ServerSignaler(this, WakeupRenderLoop);
+        _renderLoopStarvationTimer.Elapsed += delegate { OnRenderLoopStarved(); };
+    }
+
+    private void OnRenderLoopStarved()
+    {
+        lock (_renderLoopStarvationLock)
+        {
+            if (_renderLoopStarvedSince.HasValue &&
+                _renderLoopStarvedSince.Value + s_RenderLoopStarvationInterval < _clock.Elapsed)
+                AnyThreadWakeupRenderLoop();
+        }
+    }
+
+    private void TickRenderLoopIfNeeded()
+    {
+        if (_renderLoopWakeupPending)
+        {
+            lock (_renderLoopStarvationLock)
+            {
+                _renderLoopStarvedSince = null;
+                _renderLoopStarvationTimer.Stop();
+            }
+
+            _renderLoopWakeupPending = false;
+            try
+            {
+                _renderLoop.DoTick();
+            }
+            catch (Exception ex)
+            {
+                AnyThreadWakeupRenderLoop();
+                Logger.TryGet(LogEventLevel.Error, LogArea.Visual)?.Log(this, "Exception in render loop: {Error}", ex);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Server/WaylandWorker.cs b/src/Avalonia.Wayland/Server/WaylandWorker.cs
new file mode 100644
index 0000000000..c6712efa34
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/WaylandWorker.cs
@@ -0,0 +1,316 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using Avalonia.Logging;
+using Avalonia.Rendering;
+using Avalonia.Rendering.Composition;
+using Avalonia.Wayland.Screens;
+using Avalonia.Wayland.Server.Interop;
+using Avalonia.Wayland.Server.Persistent;
+using Avalonia.Wayland.Server.Transient;
+using NWayland;
+using NWayland.Interop;
+using NWayland.Protocols.Wayland;
+
+namespace Avalonia.Wayland.Server;
+
+partial class WaylandWorker
+{
+    private Queue<Action> _queue = new();
+    private readonly WakeupFd _wakeupFd = new();
+    private volatile bool _hasPendingServerJobs;
+    private WaylandConnection? _connection;
+    private WaylandGlobals? _globals;
+    private WaylandOutputsSinkProxy? _outputsSink;
+    public WaylandGlobals? Globals => _globals;
+    public WaylandPlatformGraphics PlatformGraphics { get; } = new();
+    private Thread? _thread;
+    public IRawEventGrouperDispatchQueue InputDispatchQueue { get; }
+
+
+    public Compositor Compositor { get; }
+    public WaylandWorkerClient Client { get; }
+    private HashSet<IPersistentWaylandObject> _persistentObjects = new();
+    private HashSet<IPersistentWaylandObject> _connectedObjects = new();
+
+
+    public WaylandWorker(IRawEventGrouperDispatchQueue inputDispatchQueue)
+    {
+        InputDispatchQueue = inputDispatchQueue;
+        Compositor = new Compositor(_renderLoop, PlatformGraphics);
+        Client = new WaylandWorkerClient(this);
+        InitRenderTimer();
+    }
+
+    /// <summary>
+    /// Posts a callback to the wayland thread alongside with the current compositor batch.
+    /// The order of execution of such callbacks and callbacks submitted via different means is UNDEFINED.
+    /// </summary>
+    public void PostWithCommit(Action cb)
+    {
+        _hasPendingServerJobs = true;
+        Compositor.PostServerJob(cb);
+    }
+    
+    /// <summary>
+    /// Posts a callback to the wayland thread queue directly, bypassing the compositor batch.
+    /// Use for rare out-of-band messages that need immediate delivery.
+    /// </summary>
+    public void PostOob(Action cb)
+    {
+        lock (_queue)
+            _queue.Enqueue(cb);
+        _wakeupFd.Set();
+    }
+
+
+    /// <summary>
+    /// Posts a callback to the wayland thread queue out-of-band (bypassing the compositor batch)
+    /// and returns a task that indicates its completion.
+    /// </summary>
+    public Task<T> InvokeOobAsync<T>(Func<T> cb)
+    {
+        var tcs = new TaskCompletionSource<T>(TaskCreationOptions.RunContinuationsAsynchronously);
+        PostOob(() =>
+        {
+            try
+            {
+                var result = cb();
+                tcs.SetResult(result);
+            }
+            catch (Exception ex)
+            {
+                tcs.SetException(ex);
+            }
+        });
+        return tcs.Task;
+    }
+
+    /// <summary>
+    /// Posts a callback to the wayland thread queue out-of-band (bypassing the compositor batch)
+    /// and returns a task that completes when the callback finishes.
+    /// Unlike <see cref="InvokeOobAsync{T}(Func{T})"/>, this does not return a value.
+    /// </summary>
+    public Task InvokeOobAsync(Action cb)
+    {
+        var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+        PostOob(() =>
+        {
+            try
+            {
+                cb();
+                tcs.SetResult();
+            }
+            catch (Exception ex)
+            {
+                tcs.SetException(ex);
+            }
+        });
+        return tcs.Task;
+    }
+
+    void Run(WaylandPlatformOptions options, WaylandConnection connection)
+    {
+        var reconnectsDisabled = options.EnableReconnects == false || options.DisplayFd.HasValue;
+        while (true)
+        {
+            RunConnection(connection, options);
+            foreach (var obj in _persistentObjects.ToList())
+                obj.OnDisconnected();
+            Compositor.Server.ResetAllGpuResources();
+            _globals?.Dispose();
+            _globals = null;
+            
+            Logger.TryGet(LogEventLevel.Error, "Wayland")?.Log(null, "Wayland connection lost");
+            if (reconnectsDisabled)
+                throw new AvaloniaWaylandException("Connection lost");
+            connection.Dispose();
+
+            while (true)
+            {
+                var probe = Probe(options);
+                if (probe == null)
+                    Thread.Sleep(1000);
+                else
+                {
+                    connection = probe;
+                    break;
+                }
+            }
+
+        }
+    }
+    
+    void RunQueue()
+    {
+        while (true)
+        {
+            Action cb;
+            lock (_queue)
+            {
+                if (!_queue.TryDequeue(out cb!))
+                    return;
+            }
+
+            cb();
+        }
+    }
+    
+    void RunConnection(WaylandConnection connection, WaylandPlatformOptions options)
+    {
+        _thread = Thread.CurrentThread;
+        _connection = connection;
+        _globals = new WaylandGlobals(_connection, this, options, _outputsSink);
+
+        foreach (var obj in _persistentObjects)
+            ConnectPersistentObject(obj);
+        
+        WakeupRenderLoop();
+        Compositor.Server.InvalidateAllCompositionTargets();
+        
+        while (true)
+        {
+            var res = connection.DispatchQueueOrWakeup(connection.Queue, _wakeupFd.PollFd);
+            if (res == WaylandConnection.DispatchResult.ConnectionReset)
+                return;
+            if (res == WaylandConnection.DispatchResult.Wakeup) 
+                _wakeupFd.Clear();
+            RunQueue();
+            TickRenderLoopIfNeeded();
+        }
+    }
+
+    class Tracer : INWaylandTracer
+    {
+        // Dedicated log area so protocol tracing can be enabled independently of
+        // the platform's normal verbose ("Wayland") traffic.
+        public const string TraceArea = "WaylandProtocol";
+
+        string GetProxyString(WlProxy proxy)
+        {
+            // Handle throws once the proxy is disposed; tracing must stay best-effort.
+            var handle = proxy.IsDisposed ? IntPtr.Zero : proxy.Handle;
+            return $"{proxy.GetType().Name}({handle:x8}/{proxy.Id})";
+        }
+        
+        string PrintArg(WlMessageDescription method, WlTracedArgument arg, int index)
+        {
+            var code = method.Arguments[index].Code;
+            return code switch
+            {
+                WaylandArgumentCodes.Object when arg.Object is WlProxy proxy => GetProxyString(proxy),
+                WaylandArgumentCodes.String => arg.Object?.ToString() ?? "null",
+                WaylandArgumentCodes.Int32 or WaylandArgumentCodes.Fd => arg.Int32.ToString(),
+                WaylandArgumentCodes.UInt32 or WaylandArgumentCodes.NewId => arg.UInt32.ToString(),
+                WaylandArgumentCodes.Fixed => ((double)arg.Fixed).ToString(),
+                _ => arg.Object?.ToString() ?? "null"
+            };
+        }
+
+        public void Trace(WlProxy sender, bool isEvent, bool isDestructor, WlMessageDescription method, ReadOnlySpan<WlTracedArgument> args)
+        {
+            if (Logger.TryGet(LogEventLevel.Verbose, TraceArea) is not { } logger)
+                return;
+            var argStrings = new string[args.Length];
+            for (var i = 0; i < args.Length; i++)
+                argStrings[i] = PrintArg(method, args[i], i);
+            logger.Log(null, "{Message}",
+                $"{GetProxyString(sender)}-{(isEvent ? '<' : '>')}{(isDestructor ? " (D)" : "")}-{method.Name}({string.Join(", ", argStrings)})");
+        }
+
+        public void TraceDestroy(WlProxy proxy, bool isFromFinalizer, bool nativeCallSkipped)
+        {
+            if (isFromFinalizer)
+                Logger.TryGet(LogEventLevel.Verbose, TraceArea)?.Log(null, "{Message}", $"{GetProxyString(proxy)} IS FINALIZED");
+        }
+    }
+    
+    public static WaylandConnection? Probe(WaylandPlatformOptions options)
+    {
+        try
+        {
+            var conn = options.DisplayFd is { } fd
+                ? new WaylandConnection(fd)
+                : new WaylandConnection(options.WlDisplayName);
+            if (Logger.TryGet(LogEventLevel.Verbose, Tracer.TraceArea) != null)
+                conn.Display.Tracer = new Tracer();
+            return conn;
+        }
+        catch(Exception e)
+        {
+            Logger.TryGet(LogEventLevel.Error, "Wayland")?.Log(null, "Failed to connect to Wayland display: " + e);
+            return null;
+        }
+    }
+
+    public void Start(WaylandPlatformOptions options, WaylandConnection probedConnection,
+        WaylandOutputsSinkProxy? outputsSink = null)
+    {
+        _outputsSink = outputsSink;
+        StartCore(options, probedConnection, null);
+    }
+    
+    public void Start(WaylandPlatformOptions options, WlDisplay foreignDisplay,
+        WaylandOutputsSinkProxy? outputsSink = null)
+    {
+        _outputsSink = outputsSink;
+        StartCore(options, null, foreignDisplay);
+    }
+    
+    void StartCore(WaylandPlatformOptions options, WaylandConnection? probedConnection, WlDisplay? foreignDisplay)
+    {
+        new Thread(() =>
+        {
+            if(probedConnection!=null)
+                Run(options, probedConnection);
+            else if (foreignDisplay != null)
+            {
+                RunConnection(new WaylandConnection(foreignDisplay), options);
+                // This is fatal
+                throw new AvaloniaWaylandException("Connection lost");
+            }
+            else
+                throw new InvalidOperationException("Either probedConnection or foreignDisplay must be provided.");
+        })
+        {
+            Name = "AvaloniaWayland",
+            IsBackground = true
+        }.Start();
+    }
+
+    void VerifyAccess()
+    {
+        if(_thread != Thread.CurrentThread)
+            throw new AvaloniaWaylandException("Call from invalid thread");
+        
+    }
+
+    void ConnectPersistentObject(IPersistentWaylandObject waylandObject)
+    {
+        if (_connection == null || _globals == null)
+            throw new InvalidOperationException();
+        waylandObject.OnConnected(_connection, _globals);
+        _connectedObjects.Add(waylandObject);
+    }
+    
+    public void RegisterPersistentObject(IPersistentWaylandObject waylandObject)
+    {
+        VerifyAccess();
+        _persistentObjects.Add(waylandObject);
+        if (_connection?.IsConnected == true)
+            ConnectPersistentObject(waylandObject);
+
+    }
+
+    public void UnregisterPersistentObject(IPersistentWaylandObject waylandObject)
+    {
+        VerifyAccess();
+        if (_connectedObjects.Remove(waylandObject))
+            waylandObject.OnDisconnected();
+        _persistentObjects.Remove(waylandObject);
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Server/WaylandWorkerClient.cs b/src/Avalonia.Wayland/Server/WaylandWorkerClient.cs
new file mode 100644
index 0000000000..8be21f29b6
--- /dev/null
+++ b/src/Avalonia.Wayland/Server/WaylandWorkerClient.cs
@@ -0,0 +1,123 @@
+using System;
+using System.Threading.Tasks;
+using Avalonia;
+using Avalonia.Input.Raw;
+using Avalonia.Rendering.Composition;
+using Avalonia.Wayland.Server.Persistent;
+
+namespace Avalonia.Wayland.Server;
+
+/// <summary>
+/// UI-thread-safe interface to the wayland worker.
+/// UI thread code should use this instead of accessing WaylandWorker directly.
+/// </summary>
+class WaylandWorkerClient
+{
+    private readonly WaylandWorker _worker;
+
+    internal WaylandWorkerClient(WaylandWorker worker)
+    {
+        _worker = worker;
+        Compositor = worker.Compositor;
+        InputDispatchQueue = worker.InputDispatchQueue;
+        AnyThreadWakeupRenderLoop = worker.AnyThreadWakeupRenderLoop;
+        Marshaller = (action, priority) =>
+        {
+            if (priority == WaylandDispatchPriority.Oob)
+                worker.PostOob(action);
+            else
+                worker.PostWithCommit(action);
+        };
+    }
+
+    public Compositor Compositor { get; }
+
+    /// <summary>Shared platform-wide input-dispatch queue (any-thread safe).</summary>
+    public IRawEventGrouperDispatchQueue InputDispatchQueue { get; }
+
+    /// <summary>
+    /// Wakes the wayland worker's render loop. Documented as safe to call
+    /// from any thread (see <see cref="WaylandWorker.AnyThreadWakeupRenderLoop"/>).
+    /// </summary>
+    public Action AnyThreadWakeupRenderLoop { get; }
+
+    /// <summary>
+    /// Marshaller for UI→worker cross-thread proxies (see
+    /// <c>CrossThreadProxyGenerator</c>). Bound to this worker instance —
+    /// no global state.
+    /// </summary>
+    public Action<Action, WaylandDispatchPriority> Marshaller { get; }
+
+    /// <summary>
+    /// Posts a rare out-of-band callback directly to the wayland thread queue.
+    /// </summary>
+    public void PostOob(Action cb) => _worker.PostOob(cb);
+
+    /// <summary>
+    /// Posts a callback to the wayland thread batched with the current compositor commit.
+    /// </summary>
+    public void PostWithCommit(Action cb) => _worker.PostWithCommit(cb);
+
+    /// <summary>
+    /// Posts a callback to the wayland thread queue out-of-band (bypassing the compositor batch)
+    /// and returns a task that indicates its completion.
+    /// </summary>
+    public Task<T> InvokeOobAsync<T>(Func<T> cb) => _worker.InvokeOobAsync(cb);
+
+    /// <summary>
+    /// Creates a UI-thread wrapper for a standard themed cursor. The wrapper must be released via
+    /// <see cref="WaylandCursorProxy.Destroy()"/> (e.g. <see cref="WaylandCursorImpl.Dispose"/>).
+    /// </summary>
+    public WaylandCursorProxy CreateStandardCursor(Input.StandardCursorType cursorType)
+        => new WaylandCursorProxy(new WaylandStandardCursor(cursorType), Marshaller);
+
+    /// <summary>
+    /// Creates a persistent worker-side custom bitmap cursor and returns a UI-thread wrapper for it.
+    /// <paramref name="pixels"/> must be tightly-packed Bgra8888 premultiplied data
+    /// (stride == <c>size.Width * 4</c>). The returned wrapper must be released via
+    /// <see cref="WaylandCursorProxy.Destroy()"/> (e.g. <see cref="WaylandCursorImpl.Dispose"/>).
+    /// </summary>
+    public WaylandCursorProxy CreateBitmapCursor(byte[] pixels, PixelSize size, int hotspotX, int hotspotY)
+        => new WaylandCursorProxy(new WaylandBitmapCursor(_worker, pixels, size, hotspotX, hotspotY), Marshaller);
+
+    /// <summary>
+    /// Creates a new xdg_toplevel surface and returns the bundle of UI-thread
+    /// accessors needed to drive it. The underlying <see cref="WXdgTopLevel"/>
+    /// is worker-thread state and is intentionally not exposed.
+    /// </summary>
+    public WaylandSurfaceCreateResult<WXdgTopLevelProxy> CreateTopLevelHandle(WXdgTopLevelEventSinkProxy sink)
+    {
+        var topLevel = new WXdgTopLevel(_worker, sink);
+        var proxy = new WXdgTopLevelProxy(topLevel, Marshaller);
+        return new WaylandSurfaceCreateResult<WXdgTopLevelProxy>(
+            Proxy: proxy,
+            GetRenderSurfaces: () => topLevel.RenderSurfaces,
+            BasicInitCompleted: topLevel.BasicInitCompleted);
+    }
+
+    /// <summary>
+    /// Creates a new xdg_popup surface parented to <paramref name="parent"/>
+    /// (a <see cref="WXdgTopLevelProxy"/> / <see cref="WXdgPopupProxy"/> /
+    /// other <see cref="WXdgShellSurfaceProxy"/> belonging to this worker).
+    /// Throws if <paramref name="parent"/> doesn't unwrap to a known
+    /// worker-side parent surface. The popup isn't actually mapped until
+    /// the UI side calls <see cref="IWXdgPopup.UpdatePositioner"/> at least
+    /// once and a buffer is attached.
+    /// </summary>
+    public WaylandSurfaceCreateResult<WXdgPopupProxy> CreatePopupHandle(
+        WXdgPopupEventSinkProxy sink,
+        WXdgShellSurfaceProxy parent)
+    {
+        var popup = new WXdgPopup(_worker, sink, (WXdgShellSurface)parent.ProxyTarget);
+        var proxy = new WXdgPopupProxy(popup, Marshaller);
+        // Popups don't currently surface a "basic init" task to the UI
+        // side: the UI driver waits on the first OnPopupConfigure delivered
+        // through the event sink instead. We therefore complete the task
+        // immediately with an empty configure batch placeholder so the
+        // shared WaylandSurfaceCreateResult<T> shape is preserved.
+        return new WaylandSurfaceCreateResult<WXdgPopupProxy>(
+            Proxy: proxy,
+            GetRenderSurfaces: () => popup.RenderSurfaces,
+            BasicInitCompleted: Task.FromResult(new XdgConfigureBatch()));
+    }
+}
diff --git a/src/Avalonia.Wayland/TextInputOptionsConverter.cs b/src/Avalonia.Wayland/TextInputOptionsConverter.cs
new file mode 100644
index 0000000000..6df30161be
--- /dev/null
+++ b/src/Avalonia.Wayland/TextInputOptionsConverter.cs
@@ -0,0 +1,79 @@
+using Avalonia.Input.TextInput;
+using NWayland.Protocols.TextInputUnstableV3;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// Maps Avalonia <see cref="TextInputOptions"/> onto the
+/// <c>zwp_text_input_v3</c> <c>(content_hint, content_purpose)</c> pair.
+/// </summary>
+internal static class TextInputOptionsConverter
+{
+    public static (ZwpTextInputV3.ContentHintEnum hint, ZwpTextInputV3.ContentPurposeEnum purpose)
+        Convert(TextInputOptions options)
+    {
+        var hint = ZwpTextInputV3.ContentHintEnum.None;
+        var purpose = ZwpTextInputV3.ContentPurposeEnum.Normal;
+
+        switch (options.ContentType)
+        {
+            case TextInputContentType.Normal:
+                break;
+            case TextInputContentType.Alpha:
+                hint |= ZwpTextInputV3.ContentHintEnum.Latin;
+                break;
+            case TextInputContentType.Digits:
+                purpose = ZwpTextInputV3.ContentPurposeEnum.Digits;
+                break;
+            case TextInputContentType.Pin:
+                purpose = ZwpTextInputV3.ContentPurposeEnum.Pin;
+                break;
+            case TextInputContentType.Number:
+                purpose = ZwpTextInputV3.ContentPurposeEnum.Number;
+                break;
+            case TextInputContentType.Email:
+                purpose = ZwpTextInputV3.ContentPurposeEnum.Email;
+                break;
+            case TextInputContentType.Url:
+                purpose = ZwpTextInputV3.ContentPurposeEnum.Url;
+                break;
+            case TextInputContentType.Name:
+                purpose = ZwpTextInputV3.ContentPurposeEnum.Name;
+                break;
+            case TextInputContentType.Password:
+                purpose = ZwpTextInputV3.ContentPurposeEnum.Password;
+                hint |= ZwpTextInputV3.ContentHintEnum.HiddenText
+                      | ZwpTextInputV3.ContentHintEnum.SensitiveData;
+                break;
+            case TextInputContentType.Social:
+            case TextInputContentType.Search:
+                break;
+        }
+
+        if (options.Multiline)
+            hint |= ZwpTextInputV3.ContentHintEnum.Multiline;
+        if (options.IsSensitive)
+            hint |= ZwpTextInputV3.ContentHintEnum.SensitiveData;
+        if (options.Lowercase)
+            hint |= ZwpTextInputV3.ContentHintEnum.Lowercase;
+        if (options.Uppercase)
+            hint |= ZwpTextInputV3.ContentHintEnum.Uppercase;
+        if (options.AutoCapitalization)
+            hint |= ZwpTextInputV3.ContentHintEnum.AutoCapitalization;
+
+        if (options.ShowSuggestions == true)
+            hint |= ZwpTextInputV3.ContentHintEnum.Completion
+                  | ZwpTextInputV3.ContentHintEnum.Spellcheck;
+
+        // Password always overrides: even with ShowSuggestions=true, never reveal text.
+        if (options.ContentType == TextInputContentType.Password)
+        {
+            hint &= ~(ZwpTextInputV3.ContentHintEnum.Completion
+                    | ZwpTextInputV3.ContentHintEnum.Spellcheck);
+            hint |= ZwpTextInputV3.ContentHintEnum.HiddenText
+                  | ZwpTextInputV3.ContentHintEnum.SensitiveData;
+        }
+
+        return (hint, purpose);
+    }
+}
diff --git a/src/Avalonia.Wayland/WaylandConversionExtensions.cs b/src/Avalonia.Wayland/WaylandConversionExtensions.cs
new file mode 100644
index 0000000000..5e1733b70c
--- /dev/null
+++ b/src/Avalonia.Wayland/WaylandConversionExtensions.cs
@@ -0,0 +1,103 @@
+using System;
+using Avalonia.Controls.Primitives.PopupPositioning;
+using Avalonia.Wayland.Server.Persistent;
+using NWayland.Protocols.XdgShell;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// Conversions between Avalonia and Wayland-protocol types. Mirrors the
+/// per-platform <c>ToAvalonia</c>/<c>ToWayland</c>/<c>ToWin32</c>/etc.
+/// extension-method pattern used by the other backends.
+/// </summary>
+internal static class WaylandConversionExtensions
+{
+    /// <summary>
+    /// Translates Avalonia's <see cref="PopupPositionerParameters"/> (used
+    /// by <see cref="IPopupPositioner.Update"/>) into the worker-side
+    /// <see cref="XdgPopupPositionerParams"/>.
+    ///
+    /// Coordinate convention: <see cref="PopupPositionerParameters.AnchorRectangle"/>
+    /// arrives in the parent's client-area logical coordinates (consistent with
+    /// <see cref="ManagedPopupPositioner"/>'s usage of "parent client area"). On
+    /// Wayland CSD surfaces the entire buffer is the "client area" — including
+    /// the shadow margins — so the rect is passed through as buffer-relative
+    /// logical coords. The worker-side <see cref="WXdgPopup"/> performs the
+    /// buffer→geometry origin shift and clamps the rect into the parent's
+    /// window-geometry rectangle (see <see cref="XdgPopupPositionerParams"/>).
+    /// </summary>
+    public static XdgPopupPositionerParams ToWayland(this PopupPositionerParameters parameters) =>
+        new(
+            Size: parameters.Size,
+            AnchorRect: parameters.AnchorRectangle,
+            Anchor: parameters.Anchor.ToWayland(),
+            Gravity: parameters.Gravity.ToWayland(),
+            ConstraintAdjustment: parameters.ConstraintAdjustment.ToWayland(),
+            Offset: parameters.Offset);
+
+    /// <summary>
+    /// <see cref="PopupAnchor"/> is a bitfield (Top=1, Bottom=2, Left=4, Right=8,
+    /// corners are bit combinations); the protocol's <see cref="XdgPositioner.AnchorEnum"/>
+    /// is a dense enum (None=0..BottomRight=8). Translate explicitly per
+    /// combination rather than reinterpret-casting.
+    /// </summary>
+    public static XdgPositioner.AnchorEnum ToWayland(this PopupAnchor a) => a switch
+    {
+        PopupAnchor.None => XdgPositioner.AnchorEnum.None,
+        PopupAnchor.Top => XdgPositioner.AnchorEnum.Top,
+        PopupAnchor.Bottom => XdgPositioner.AnchorEnum.Bottom,
+        PopupAnchor.Left => XdgPositioner.AnchorEnum.Left,
+        PopupAnchor.Right => XdgPositioner.AnchorEnum.Right,
+        PopupAnchor.TopLeft => XdgPositioner.AnchorEnum.TopLeft,
+        PopupAnchor.TopRight => XdgPositioner.AnchorEnum.TopRight,
+        PopupAnchor.BottomLeft => XdgPositioner.AnchorEnum.BottomLeft,
+        PopupAnchor.BottomRight => XdgPositioner.AnchorEnum.BottomRight,
+        _ => throw new ArgumentOutOfRangeException(
+            nameof(a), a, $"Unsupported PopupAnchor combination: {a}"),
+    };
+
+    /// <summary>
+    /// Same shape concern as <see cref="ToWayland(PopupAnchor)"/>:
+    /// <see cref="PopupGravity"/> is a bitfield, <see cref="XdgPositioner.GravityEnum"/>
+    /// is dense.
+    /// </summary>
+    public static XdgPositioner.GravityEnum ToWayland(this PopupGravity g) => g switch
+    {
+        PopupGravity.None => XdgPositioner.GravityEnum.None,
+        PopupGravity.Top => XdgPositioner.GravityEnum.Top,
+        PopupGravity.Bottom => XdgPositioner.GravityEnum.Bottom,
+        PopupGravity.Left => XdgPositioner.GravityEnum.Left,
+        PopupGravity.Right => XdgPositioner.GravityEnum.Right,
+        PopupGravity.TopLeft => XdgPositioner.GravityEnum.TopLeft,
+        PopupGravity.TopRight => XdgPositioner.GravityEnum.TopRight,
+        PopupGravity.BottomLeft => XdgPositioner.GravityEnum.BottomLeft,
+        PopupGravity.BottomRight => XdgPositioner.GravityEnum.BottomRight,
+        _ => throw new ArgumentOutOfRangeException(
+            nameof(g), g, $"Unsupported PopupGravity combination: {g}"),
+    };
+
+    /// <summary>
+    /// <see cref="PopupPositionerConstraintAdjustment"/> currently has the
+    /// same numeric layout as <see cref="XdgPositioner.ConstraintAdjustmentEnum"/>,
+    /// but that's not a contractual guarantee — translate flag-by-flag
+    /// rather than reinterpret-casting.
+    /// </summary>
+    public static XdgPositioner.ConstraintAdjustmentEnum ToWayland(
+        this PopupPositionerConstraintAdjustment a)
+    {
+        var r = XdgPositioner.ConstraintAdjustmentEnum.None;
+        if ((a & PopupPositionerConstraintAdjustment.SlideX) != 0)
+            r |= XdgPositioner.ConstraintAdjustmentEnum.SlideX;
+        if ((a & PopupPositionerConstraintAdjustment.SlideY) != 0)
+            r |= XdgPositioner.ConstraintAdjustmentEnum.SlideY;
+        if ((a & PopupPositionerConstraintAdjustment.FlipX) != 0)
+            r |= XdgPositioner.ConstraintAdjustmentEnum.FlipX;
+        if ((a & PopupPositionerConstraintAdjustment.FlipY) != 0)
+            r |= XdgPositioner.ConstraintAdjustmentEnum.FlipY;
+        if ((a & PopupPositionerConstraintAdjustment.ResizeX) != 0)
+            r |= XdgPositioner.ConstraintAdjustmentEnum.ResizeX;
+        if ((a & PopupPositionerConstraintAdjustment.ResizeY) != 0)
+            r |= XdgPositioner.ConstraintAdjustmentEnum.ResizeY;
+        return r;
+    }
+}
diff --git a/src/Avalonia.Wayland/WaylandCursorFactory.cs b/src/Avalonia.Wayland/WaylandCursorFactory.cs
new file mode 100644
index 0000000000..4aa536a767
--- /dev/null
+++ b/src/Avalonia.Wayland/WaylandCursorFactory.cs
@@ -0,0 +1,52 @@
+using System;
+using Avalonia.Input;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using Avalonia.Wayland.Server;
+using Avalonia.Wayland.Server.Persistent;
+
+namespace Avalonia.Wayland;
+
+class WaylandCursorFactory : ICursorFactory
+{
+    private readonly WaylandWorkerClient _client;
+
+    public WaylandCursorFactory(WaylandWorkerClient client)
+    {
+        _client = client;
+    }
+
+    public ICursorImpl GetCursor(StandardCursorType cursorType)
+        => new WaylandCursorImpl(_client.CreateStandardCursor(cursorType));
+
+    public unsafe ICursorImpl CreateCursor(Bitmap cursor, PixelPoint hotSpot)
+    {
+        // Extract the cursor pixels into a tightly-packed Bgra8888 premultiplied buffer on the UI
+        // thread (CopyPixels transcodes format + alpha). The worker thread then uploads this raw
+        // buffer into a wl_buffer without touching the UI-owned Bitmap.
+        var size = cursor.PixelSize;
+        var stride = size.Width * 4;
+        var pixels = new byte[stride * size.Height];
+        fixed (byte* ptr = pixels)
+        {
+            using var locked = new LockedFramebuffer((IntPtr)ptr, size, stride,
+                new Vector(96, 96), PixelFormats.Bgra8888, AlphaFormat.Premul, null);
+            cursor.CopyPixels(locked);
+        }
+
+        return new WaylandCursorImpl(_client.CreateBitmapCursor(pixels, size, hotSpot.X, hotSpot.Y));
+    }
+}
+
+class WaylandCursorImpl : ICursorImpl
+{
+    /// <summary>UI-thread wrapper for the worker-side cursor (standard or custom bitmap).</summary>
+    public WaylandCursorProxy Cursor { get; }
+
+    public WaylandCursorImpl(WaylandCursorProxy cursor)
+    {
+        Cursor = cursor;
+    }
+
+    public void Dispose() => Cursor.Destroy();
+}
diff --git a/src/Avalonia.Wayland/WaylandPlatform.cs b/src/Avalonia.Wayland/WaylandPlatform.cs
new file mode 100644
index 0000000000..dc42c17b6a
--- /dev/null
+++ b/src/Avalonia.Wayland/WaylandPlatform.cs
@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+using Avalonia.Controls.Platform;
+using Avalonia.FreeDesktop;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using Avalonia.Platform;
+using Avalonia.Rendering;
+using Avalonia.Threading;
+using Avalonia.Wayland.Clipboard;
+using Avalonia.Wayland.Screens;
+using Avalonia.Wayland.Server;
+using Avalonia.X11;
+
+namespace Avalonia.Wayland;
+
+class WaylandPlatform
+{
+
+    public static void Initialize(WaylandPlatformOptions options)
+    {
+        var connection = WaylandWorker.Probe(options);
+        if (connection == null)
+            throw new AvaloniaWaylandException("Unable to connect to Wayland display");
+        // TODO: wait for globals to be ready on the wayland thread and perform sanity checks too.
+        // This is needed for UsePlatformDetect() in Avalonia.Desktop: if we detect a compositor we
+        // can't support we should fail here so the caller can fall back to X11. Later we'll also want
+        // feature-detection flags (e.g. xdg-toplevel-drag-v1 for docks) so apps can request features
+        // that force an X11 fallback when the compositor lacks them.
+
+        var inputDispatchQueue = new AutomaticRawEventGrouperDispatchQueue();
+        Dispatcher.InitializeUIThreadDispatcher(new ManagedDispatcherImpl(null));
+        
+        var worker = new WaylandWorker(inputDispatchQueue);
+
+        var screens = new SnapshotScreensImpl();
+        var screensProxy = new WaylandOutputsSinkProxy(screens, WaylandMarshallers.UIThread);
+
+        worker.Start(options, connection, screensProxy);
+
+
+
+        var clipboardImpl = new WaylandClipboardImpl(worker);
+        var clipboard = new Input.Platform.Clipboard(clipboardImpl);
+
+        AvaloniaLocator.CurrentMutable
+
+            .Bind<IWindowingPlatform>().ToConstant(new WaylandTopLevelFactory(worker.Client))
+            .Bind<IRenderLoop>().ToConstant(worker.RenderLoop)
+            .Bind<PlatformHotkeyConfiguration>().ToConstant(new PlatformHotkeyConfiguration(KeyModifiers.Control))
+            .Bind<KeyGestureFormatInfo>()
+            .ToConstant(new KeyGestureFormatInfo(new Dictionary<Key, string>() { }, meta: "Super"))
+            .Bind<IKeyboardDevice>().ToConstant(new KeyboardDevice())
+            .Bind<ICursorFactory>().ToConstant(new WaylandCursorFactory(worker.Client))
+            .Bind<IClipboardImpl>().ToConstant(clipboardImpl)
+            .Bind<IClipboard>().ToConstant(clipboard)
+            .Bind<IPlatformDragSource>().ToConstant(new WaylandDragSource())
+            .Bind<IPlatformSettings>().ToSingleton<DBusPlatformSettings>()
+            .Bind<IMountedVolumeInfoProvider>().ToConstant(new LinuxMountedVolumeInfoProvider())
+            .Bind<IPlatformIconLoader>().ToConstant(new X11IconLoader())
+            .Bind<IScreenImpl>().ToConstant(screens);
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/WaylandPlatformOptions.cs b/src/Avalonia.Wayland/WaylandPlatformOptions.cs
new file mode 100644
index 0000000000..313b79e9e8
--- /dev/null
+++ b/src/Avalonia.Wayland/WaylandPlatformOptions.cs
@@ -0,0 +1,75 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Avalonia.OpenGL;
+
+// XxxPlatformOptions are deliberately in global Avalonia namespace
+// ReSharper disable once CheckNamespace
+namespace Avalonia;
+
+/// <summary>
+/// Platform-specific options for the Wayland windowing backend, supplied via
+/// <see cref="AvaloniaWaylandPlatformExtensions.UseWayland"/>.
+/// </summary>
+public class WaylandPlatformOptions
+{
+    /// <summary>
+    /// The name of the Wayland display to connect to (e.g. <c>wayland-0</c>). When <c>null</c>,
+    /// the <c>WAYLAND_DISPLAY</c> environment variable is used. Ignored when <see cref="DisplayFd"/> is set.
+    /// </summary>
+    public string? WlDisplayName { get; set; }
+
+    /// <summary>
+    /// An already-opened file descriptor for the Wayland display socket.
+    /// When set, <see cref="WlDisplayName"/> is ignored and
+    /// <c>wl_display_connect_to_fd</c> is used instead of <c>wl_display_connect</c>.
+    /// Reconnects are automatically disabled in this mode because the fd
+    /// is consumed by <c>libwayland</c> and cannot be reused.
+    /// </summary>
+    public int? DisplayFd { get; set; }
+
+    /// <summary>
+    /// Whether to automatically attempt to reconnect to the compositor if the connection is lost.
+    /// Defaults to enabled. Reconnects are always disabled when <see cref="DisplayFd"/> is set, because
+    /// the file descriptor is consumed by <c>libwayland</c> and cannot be reused.
+    /// </summary>
+    public bool? EnableReconnects { get; set; }
+
+    /// <summary>
+    /// Suppresses server-side decoration negotiation
+    /// (<c>zxdg_decoration_manager_v1</c>): toplevels behave as if the
+    /// compositor never advertised SSD support. Used primarily for
+    /// testing the CSD path on compositors that would otherwise enforce
+    /// server-side decorations (KWin, etc.). Equivalent in intent to
+    /// <c>X11PlatformOptions.ForceDrawnDecorations</c>.
+    /// </summary>
+    [Experimental("AVALONIA_WAYLAND_FORCE_CSD"
+#if NET10_0_OR_GREATER
+        , Message = "Experimental, used mostly for testing"
+#endif
+    )]
+    public bool ForceDrawnDecorations { get; set; }
+
+#pragma warning disable AVALONIA_WAYLAND_FORCE_CSD
+    internal bool ForceDrawnDecorationsInternal => ForceDrawnDecorations;
+#pragma warning restore AVALONIA_WAYLAND_FORCE_CSD
+
+    /// <summary>
+    /// The OpenGL/OpenGL ES versions to try, in priority order, when creating the GL context.
+    /// The first profile the driver supports is used.
+    /// </summary>
+    public IList<GlVersion> GlProfiles { get; set; } = new List<GlVersion>
+    {
+        new GlVersion(GlProfileType.OpenGL, 4, 0),
+        new GlVersion(GlProfileType.OpenGL, 3, 2),
+        new GlVersion(GlProfileType.OpenGL, 3, 0),
+        new GlVersion(GlProfileType.OpenGLES, 3, 2),
+        new GlVersion(GlProfileType.OpenGLES, 3, 0),
+        new GlVersion(GlProfileType.OpenGLES, 2, 0)
+    };
+
+    /// <summary>
+    /// Whether to use a dmabuf-based swapchain for GPU rendering. When <c>null</c>, the backend
+    /// decides based on compositor and driver capabilities.
+    /// </summary>
+    public bool? UseDmabufSwapchain { get; set; }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/WaylandSurfaceCreateResult.cs b/src/Avalonia.Wayland/WaylandSurfaceCreateResult.cs
new file mode 100644
index 0000000000..e48284a1db
--- /dev/null
+++ b/src/Avalonia.Wayland/WaylandSurfaceCreateResult.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+using Avalonia.Input.Raw;
+using Avalonia.Platform;
+using Avalonia.Platform.Surfaces;
+using Avalonia.SourceGenerator;
+using Avalonia.Wayland.Server.Persistent;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// Result of creating a worker-side wayland surface from the UI thread.
+/// Bundles the UI→worker proxy together with whatever extra UI-thread
+/// accessors the caller needs to drive the surface.
+/// </summary>
+/// <typeparam name="T">
+/// The concrete proxy subtype (e.g. <see cref="WXdgTopLevelProxy"/>) — all
+/// such proxies derive from <see cref="WSurfaceProxy"/>.
+/// </typeparam>
+/// <remarks>
+/// <see cref="GetRenderSurfaces"/> is a callback rather than a snapshot
+/// because <c>ITopLevelImpl.Surfaces</c> is queried by the render thread,
+/// not the UI thread; routing it through a callback avoids any need for the
+/// UI side to cache (or even read) worker-thread state.
+/// </remarks>
+[DefinitelyNotARecord]
+internal sealed partial class WaylandSurfaceCreateResult<T>(
+    T Proxy,
+    Func<IPlatformRenderSurface[]> GetRenderSurfaces,
+    Task<XdgConfigureBatch> BasicInitCompleted)
+    where T : WSurfaceProxy;
diff --git a/src/Avalonia.Wayland/WaylandTextUtils.cs b/src/Avalonia.Wayland/WaylandTextUtils.cs
new file mode 100644
index 0000000000..0aa7668204
--- /dev/null
+++ b/src/Avalonia.Wayland/WaylandTextUtils.cs
@@ -0,0 +1,107 @@
+using System;
+using System.Text;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// Helpers for converting between UTF-8 byte offsets (used by Wayland text-input
+/// protocols) and UTF-16 char indices (used by .NET <see cref="string"/>).
+/// </summary>
+/// <remarks>
+/// The Wayland text-input protocols address text by byte offset into the UTF-8
+/// encoding of the string. Avalonia / .NET use UTF-16 internally. Conversion
+/// must respect multi-byte sequences and surrogate pairs (a single non-BMP
+/// codepoint is 4 bytes in UTF-8 and 2 chars in UTF-16) and must be robust to
+/// negative offsets, out-of-range indices and partially-truncated sequences.
+/// </remarks>
+internal static class WaylandTextUtils
+{
+    /// <summary>
+    /// Convert a wayland-side byte offset (relative to <paramref name="baseChar"/>)
+    /// into a UTF-16 char index in <paramref name="text"/>. A negative
+    /// <paramref name="byteLength"/> means "go backwards from baseChar".
+    /// Out-of-range offsets are clamped to <c>[0, text.Length]</c>.
+    /// </summary>
+    public static int CharIndexFromUtf8Offset(string text, int byteLength, int baseChar)
+    {
+        if (byteLength == 0)
+            return Math.Clamp(baseChar, 0, text.Length);
+
+        baseChar = Math.Clamp(baseChar, 0, text.Length);
+
+        if (byteLength < 0)
+        {
+            var prefix = text.AsSpan(0, baseChar);
+            var prefixBytes = System.Text.Encoding.UTF8.GetByteCount(prefix);
+            var targetBytes = Math.Max(prefixBytes + byteLength, 0);
+            return CountCharsForUtf8Bytes(prefix, targetBytes);
+        }
+        else
+        {
+            var suffix = text.AsSpan(baseChar);
+            var suffixBytes = System.Text.Encoding.UTF8.GetByteCount(suffix);
+            var targetBytes = Math.Min(byteLength, suffixBytes);
+            return baseChar + CountCharsForUtf8Bytes(suffix, targetBytes);
+        }
+    }
+
+    /// <summary>
+    /// Convert a UTF-16 char index <paramref name="charIndex"/> in
+    /// <paramref name="text"/> into a wayland-side byte offset, relative to
+    /// <paramref name="baseChar"/>. The returned value is the byte distance
+    /// between <paramref name="baseChar"/> and <paramref name="charIndex"/>;
+    /// it is negative when <paramref name="charIndex"/> &lt; <paramref name="baseChar"/>.
+    /// </summary>
+    public static int Utf8OffsetFromCharIndex(string text, int charIndex, int baseChar)
+    {
+        if (charIndex == baseChar)
+            return 0;
+
+        baseChar = Math.Clamp(baseChar, 0, text.Length);
+        charIndex = Math.Clamp(charIndex, 0, text.Length);
+
+        if (charIndex >= baseChar)
+            return System.Text.Encoding.UTF8.GetByteCount(text.AsSpan(baseChar, charIndex - baseChar));
+
+        return -System.Text.Encoding.UTF8.GetByteCount(text.AsSpan(charIndex, baseChar - charIndex));
+    }
+
+    /// <summary>
+    /// Convert an absolute char index to its absolute UTF-8 byte index in
+    /// <paramref name="text"/>. Equivalent to
+    /// <c>Utf8OffsetFromCharIndex(text, charIndex, 0)</c>.
+    /// </summary>
+    public static int Utf8ByteIndexFromCharIndex(string text, int charIndex)
+    {
+        charIndex = Math.Clamp(charIndex, 0, text.Length);
+        return System.Text.Encoding.UTF8.GetByteCount(text.AsSpan(0, charIndex));
+    }
+
+    /// <summary>
+    /// Walk the UTF-16 <paramref name="span"/> until either it is exhausted or
+    /// the cumulative UTF-8 byte count reaches <paramref name="targetBytes"/>.
+    /// Stops at a UTF-16 char boundary that lies on a UTF-8 codepoint boundary,
+    /// i.e. it never returns a position halfway through a surrogate pair.
+    /// </summary>
+    private static int CountCharsForUtf8Bytes(ReadOnlySpan<char> span, int targetBytes)
+    {
+        if (targetBytes <= 0)
+            return 0;
+
+        var bytes = 0;
+        var i = 0;
+        while (i < span.Length)
+        {
+            Rune.DecodeFromUtf16(span.Slice(i), out var rune, out var cpChars);
+            var cpBytes = rune.Utf8SequenceLength;
+
+            if (bytes + cpBytes > targetBytes)
+                break;
+
+            bytes += cpBytes;
+            i += cpChars;
+        }
+
+        return i;
+    }
+}
diff --git a/src/Avalonia.Wayland/WaylandTopLevelFactory.cs b/src/Avalonia.Wayland/WaylandTopLevelFactory.cs
new file mode 100644
index 0000000000..acc8176069
--- /dev/null
+++ b/src/Avalonia.Wayland/WaylandTopLevelFactory.cs
@@ -0,0 +1,53 @@
+using System;
+using System.Linq;
+using Avalonia.FreeDesktop;
+using Avalonia.Platform;
+using Avalonia.Wayland.Server;
+using Avalonia.Wayland.Server.Persistent;
+using Avalonia.X11;
+
+namespace Avalonia.Wayland;
+
+class WaylandTopLevelFactory : IWindowingPlatform
+{
+    private readonly WaylandWorkerClient _client;
+
+    public WaylandTopLevelFactory(WaylandWorkerClient client)
+    {
+        _client = client;
+    }
+
+    public IWindowImpl CreateWindow() => new WindowImpl(_client);
+
+    public ITopLevelImpl CreateEmbeddableTopLevel() => throw new System.NotSupportedException();
+
+    public IWindowImpl CreateEmbeddableWindow() => throw new System.NotSupportedException();
+
+    public ITrayIconImpl? CreateTrayIcon()
+    {
+        // org.kde.StatusNotifierItem (works on KDE; on GNOME via the
+        // AppIndicator extension). No XEmbed fallback — XEmbed is X11-only,
+        // and there is no Wayland-native systray protocol. If the watcher
+        // service is not on the bus we return null and the framework falls
+        // back to its own no-op handling.
+        var dbusTrayIcon = new DBusTrayIconImpl();
+        if (!dbusTrayIcon.IsActive)
+        {
+            dbusTrayIcon.Dispose();
+            return null;
+        }
+        // DBusTrayIconImpl wants an IWindowIconImpl-to-uint[] flattener
+        // (X11 NET_WM_ICON wire format: [w, h, ARGB32 pixels…]) which our
+        // X11IconLoader-produced X11IconData already stores in. Reuse it.
+        dbusTrayIcon.IconConverterDelegate = static icon =>
+            icon is X11IconData x ? x.Data.Select(p => p.ToUInt32()).ToArray() : Array.Empty<uint>();
+        return dbusTrayIcon;
+    }
+
+    public void GetWindowsZOrder(ReadOnlySpan<IWindowImpl> windows, Span<long> zOrder)
+    {
+        // Z-order querying isn't supported on Wayland; zero the output so callers
+        // get a deterministic result instead of whatever the span previously held.
+        zOrder.Clear();
+    }
+}
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/WindowImpl.Sink.cs b/src/Avalonia.Wayland/WindowImpl.Sink.cs
new file mode 100644
index 0000000000..cc852df01e
--- /dev/null
+++ b/src/Avalonia.Wayland/WindowImpl.Sink.cs
@@ -0,0 +1,164 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Wayland.Server;
+using Avalonia.Wayland.Server.Persistent;
+using NWayland.Protocols.XdgShell;
+
+namespace Avalonia.Wayland;
+
+partial class WindowImpl
+{
+    private new sealed class Sink : WindowBaseImpl.Sink, IWXdgTopLevelEventSink
+    {
+        private new WindowImpl Parent => (WindowImpl)base.Parent;
+        private XdgConfigureBatch? _initialBatch;
+        private WaylandSurfaceCreateResult<WXdgTopLevelProxy>? _handle;
+        private WXdgTopLevelProxy? _surfaceProxy;
+
+        public Sink(WindowImpl parent, bool secondShow) : base(parent)
+        {
+            _handle = Parent.Client.CreateTopLevelHandle(new WXdgTopLevelEventSinkProxy(this, WaylandMarshallers.UIThread));
+            _surfaceProxy = _handle.Proxy;
+            Parent._handle = _handle;
+            Parent._surfaceProxy = _surfaceProxy;
+
+            var initialBatch = _handle.BasicInitCompleted.GetAwaiter().GetResult();
+            _initialBatch = initialBatch;
+
+            Parent.ApplyConfigureBatch(initialBatch);
+
+            // If compositor didn't provide a size, auto-size
+            if (!secondShow && initialBatch.Size is not { Width: > 0, Height: > 0 })
+                Parent.ClientSize = new Size(Math.Min(640, Parent.MaxAutoSizeHint.Width),
+                    Math.Min(480, Parent.MaxAutoSizeHint.Height));
+
+            // Ack the initial configure
+            _surfaceProxy.SetPendingAckSerial(initialBatch.Serial);
+
+            if (initialBatch.InitialDecorationMode is { } im)
+                Parent.ApplyDecorationMode(im);
+
+            // Re-send stored shadow extents to the new surface
+            if (Parent._shadowExtents != default)
+                _surfaceProxy.SetShadowExtents(Parent._shadowExtents);
+
+            // Re-send cached title to the new surface
+            if (Parent._title != null)
+                _surfaceProxy.SetTitle(Parent._title);
+
+            // Re-apply cached min/max size constraints after a fresh worker
+            // surface is created. null on both sides means SetMinMaxSize was
+            // never called (or both bounds are unconstrained) — nothing to push.
+            if (Parent._minSize.HasValue || Parent._maxSize.HasValue)
+                _surfaceProxy.SetMinMaxSize(Parent._minSize, Parent._maxSize);
+
+            // Re-apply cursor (defaults to Arrow on a fresh worker WSurface).
+            if (Parent.CurrentCursor is not null)
+                Parent.ApplyCurrentCursor(_surfaceProxy);
+
+            // Re-register text-input sink on the freshly created worker
+            // surface and re-apply current state, if a client is attached.
+            Parent._textInputMethod?.OnSurfaceCreated();
+
+            // Refresh the storage provider's factory chain — the previous wayland
+            // connection (and its xdg-foreign exporter, if any) is gone, and the new
+            // compositor may expose different globals. Reset() drops any cached
+            // provider so portal availability is re-evaluated against the fresh
+            // connection on the next picker call.
+            Parent._storageProvider?.Reset(Parent.BuildStorageFactories());
+        }
+
+        protected override void DisconnectFromSurface()
+        {
+            var proxy = Parent._surfaceProxy;
+            Parent._handle = null;
+            Parent._surfaceProxy = null;
+            proxy?.Disconnect();
+        }
+
+        public void OnConfigure(XdgConfigureBatch batch)
+        {
+            // Marshalled to UI thread by WSurfaceEventSinkProxy.
+            if (IsDisposed)
+                return;
+
+            // Skip the initial batch — already processed synchronously in the constructor
+            if (ReferenceEquals(batch, _initialBatch))
+            {
+                _initialBatch = null;
+                return;
+            }
+
+            Parent.ApplyConfigureBatch(batch);
+
+            // Post the ack serial back to the wayland thread for next commit
+            _surfaceProxy?.SetPendingAckSerial(batch.Serial);
+        }
+
+        public void OnDecorationModeChanged(DecorationMode mode)
+        {
+            if (IsDisposed || Parent._csdSticky)
+                return;
+            Parent.ApplyDecorationMode(mode);
+        }
+
+        public void OnClose()
+        {
+            // Marshalled to UI thread by WSurfaceEventSinkProxy.
+            if (IsDisposed)
+                return;
+
+            if (Parent.Closing?.Invoke(WindowCloseReason.WindowClosing) != true)
+                Dispose();
+        }
+
+        protected override void OnInputWhileDisabled() => Parent.GotInputWhenDisabled?.Invoke();
+
+        // Title-bar move and edge-resize chrome dispatch is xdg_toplevel-specific.
+        protected override bool HandleSurfaceSpecificDispatch(RawInputEventArgs args)
+        {
+            // TODO: We need to properly check if touch contact is primary, but it's tracked in TouchDevice,
+            // so we might want to move that handling to x-plat part of the codebase
+            // another point is that we generally need to cancel implicit capture if pointer gesture started
+            // with right mouse button
+            if (InputRoot == null || !(args is RawPointerEventArgs
+                {
+                    Type: RawPointerEventType.LeftButtonDown or RawPointerEventType.TouchBegin
+                } mouse))
+                return false;
+
+            var chromeRole = InputRoot.HitTestChromeElement(mouse.Position);
+            if (chromeRole == WindowDecorationsElementRole.TitleBar)
+            {
+                _surfaceProxy?.Move(mouse.PlatformInputEventCookie, WaylandDispatchPriority.Oob);
+                return true;
+            }
+
+            if (Parent._canResize && chromeRole is { } role)
+            {
+                var resizeEdge = role switch
+                {
+                    WindowDecorationsElementRole.ResizeN => XdgToplevel.ResizeEdgeEnum.Top,
+                    WindowDecorationsElementRole.ResizeS => XdgToplevel.ResizeEdgeEnum.Bottom,
+                    WindowDecorationsElementRole.ResizeE => XdgToplevel.ResizeEdgeEnum.Right,
+                    WindowDecorationsElementRole.ResizeW => XdgToplevel.ResizeEdgeEnum.Left,
+                    WindowDecorationsElementRole.ResizeNE => XdgToplevel.ResizeEdgeEnum.TopRight,
+                    WindowDecorationsElementRole.ResizeNW => XdgToplevel.ResizeEdgeEnum.TopLeft,
+                    WindowDecorationsElementRole.ResizeSE => XdgToplevel.ResizeEdgeEnum.BottomRight,
+                    WindowDecorationsElementRole.ResizeSW => XdgToplevel.ResizeEdgeEnum.BottomLeft,
+                    _ => (XdgToplevel.ResizeEdgeEnum?)null
+                };
+
+                if (resizeEdge is { } edge)
+                {
+                    _surfaceProxy?.Resize(mouse.PlatformInputEventCookie, edge, WaylandDispatchPriority.Oob);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/WindowImpl.TextInput.cs b/src/Avalonia.Wayland/WindowImpl.TextInput.cs
new file mode 100644
index 0000000000..e381200e7c
--- /dev/null
+++ b/src/Avalonia.Wayland/WindowImpl.TextInput.cs
@@ -0,0 +1,233 @@
+using System;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Input.TextInput;
+using Avalonia.Wayland.Server;
+using Avalonia.Wayland.Server.Persistent;
+using Avalonia.Wayland.Server.Transient;
+
+namespace Avalonia.Wayland;
+
+partial class WindowImpl
+{
+    /// <summary>
+    /// UI-thread broker for text input. Combines two responsibilities so they
+    /// stay coherent on compositors with or without zwp_text_input_v3:
+    /// 1. Compose-key gating — flips <c>WSurface.HasTextInputClient</c> on the
+    ///    Wayland thread so XKB-compose key sequences are processed if a text
+    ///    input client is attached.
+    /// 2. zwp_text_input_v3 IME — when the compositor exposes the manager,
+    ///    drives the worker-side <see cref="WaylandTextInputV3"/> facade and
+    ///    surfaces its callbacks back to the active <see cref="TextInputMethodClient"/>.
+    /// </summary>
+    /// <remarks>
+    /// All worker→UI callbacks (<see cref="IWaylandTextInputV3Events"/>) are
+    /// marshalled by the generated <c>WaylandTextInputV3EventsProxy</c> the
+    /// broker registers with the surface, so the methods below run on the UI
+    /// thread despite being invoked by the worker.
+    /// </remarks>
+    private sealed class WaylandTextInputMethod
+        : ITextInputMethodImpl, IWaylandTextInputV3Events
+    {
+        private readonly WindowImpl _owner;
+        private TextInputMethodClient? _client;
+        private bool _hasPreedit;
+        private WaylandTextInputV3EventsProxy? _sinkProxy;
+
+        // Each callback the worker emits carries the session token most
+        // recently set via SetTextInputActive. SetClient bumps _clientEpoch
+        // and propagates it to the worker; worker→UI callbacks emitted under
+        // a previous client carry the old token and are dropped by the guard
+        // at the top of every IWaylandTextInputV3Events method.
+        private int _clientEpoch;
+
+        // Tracks the surface proxy we registered the sink against. After
+        // hide/show the surface is recreated; we need to re-register the
+        // sink and re-apply the current text-input state.
+        private WXdgTopLevelProxy? _registeredAgainstSurface;
+
+        public WaylandTextInputMethod(WindowImpl owner)
+        {
+            _owner = owner;
+        }
+
+        public void SetClient(TextInputMethodClient? client)
+        {
+            var oldClient = _client;
+            if (ReferenceEquals(oldClient, client))
+                return;
+
+            UnsubscribeClient();
+
+            // Bump epoch BEFORE swapping _client. The worker stamps every
+            // subsequent IME callback with the token we send below; older
+            // callbacks (for the previous client) carry the previous token
+            // and are dropped at the top of each OnImeXxx handler.
+            _clientEpoch++;
+
+            // Abort any in-flight composition on the old client (if any).
+            if (oldClient != null && _hasPreedit)
+            {
+                try { oldClient.SetPreeditText(null, null); } catch { }
+            }
+            _hasPreedit = false;
+
+            _client = client;
+            var hasClient = client != null;
+            var supportsPreedit = client?.SupportsPreedit ?? false;
+            var supportsSurrounding = client?.SupportsSurroundingText ?? false;
+
+            ApplyTextInputStateToSurface(hasClient, supportsPreedit, supportsSurrounding);
+
+            if (client != null)
+            {
+                client.SurroundingTextChanged += OnClientSurroundingTextChanged;
+                client.SelectionChanged += OnClientSelectionChanged;
+                PushSurrounding();
+            }
+        }
+
+        /// <summary>
+        /// Called by <see cref="WindowImpl.Sink"/> after a new worker surface
+        /// is created (Show following Hide). Re-registers the sink on the
+        /// freshly created worker <c>WSurface</c> and re-applies the current
+        /// text-input state so the IME keeps working across surface
+        /// recreation.
+        /// </summary>
+        public void OnSurfaceCreated()
+        {
+            if (_owner._surfaceProxy is null)
+                return;
+            // Force re-registration on the new surface even if we already
+            // have a sink proxy — the worker-side sink lives on WSurface and
+            // is reset when the surface is recreated.
+            _registeredAgainstSurface = null;
+
+            var hasClient = _client != null;
+            var supportsPreedit = _client?.SupportsPreedit ?? false;
+            var supportsSurrounding = _client?.SupportsSurroundingText ?? false;
+            ApplyTextInputStateToSurface(hasClient, supportsPreedit, supportsSurrounding);
+
+            if (hasClient)
+                PushSurrounding();
+        }
+
+        private void ApplyTextInputStateToSurface(bool hasClient, bool supportsPreedit, bool supportsSurrounding)
+        {
+            var proxy = _owner._surfaceProxy;
+            if (proxy is null)
+                return;
+
+            if (!ReferenceEquals(_registeredAgainstSurface, proxy))
+            {
+                _sinkProxy ??= new WaylandTextInputV3EventsProxy(this, WaylandMarshallers.UIThread);
+                proxy.RegisterTextInputSink(_sinkProxy);
+                _registeredAgainstSurface = proxy;
+            }
+
+            proxy.SetTextInputActive(hasClient, supportsPreedit, supportsSurrounding, _clientEpoch);
+        }
+
+        public void SetCursorRect(Rect rect) =>
+            _owner._surfaceProxy?.SetTextInputCursorRect(rect);
+
+        public void SetOptions(TextInputOptions options) =>
+            _owner._surfaceProxy?.SetTextInputOptions(options);
+
+        public void Reset() =>
+            _owner._surfaceProxy?.ResetTextInput();
+
+        void IWaylandTextInputV3Events.OnImeUpdate(
+            int sessionToken,
+            int deleteBeforeChars, int deleteAfterChars,
+            string? commitText,
+            string? preeditText, int preeditCursorBeginChar, int preeditCursorEndChar)
+        {
+            // The session token rejects in-flight callbacks queued on the UI
+            // dispatcher before SetClient (or surface recreation) bumped the
+            // epoch — those would otherwise apply to the wrong client.
+            if (sessionToken != _clientEpoch || _client is not { } client)
+                return;
+            if (_owner.InputRoot is not { } inputRoot)
+                return;
+
+            var input = _owner.Input;
+
+            // Per spec, in this exact order:
+            //   1. clear current preedit (implicit before commit/delete);
+            //   2. apply delete_surrounding_text;
+            //   3. insert commit text;
+            //   4. apply new preedit.
+            var hasDelete = (deleteBeforeChars > 0 || deleteAfterChars > 0)
+                            && client.SupportsSurroundingText;
+            var hasCommit = !string.IsNullOrEmpty(commitText);
+            var newPreeditEmpty = string.IsNullOrEmpty(preeditText);
+
+            // Clear the existing preedit before we mutate the document with
+            // delete or commit (it's about to be replaced anyway, and any
+            // ongoing composition needs to be torn down first).
+            if (_hasPreedit && (hasDelete || hasCommit))
+            {
+                client.SetPreeditText(null, null);
+                _hasPreedit = false;
+            }
+
+            if (hasDelete && input is not null)
+            {
+                // Select the to-be-deleted range, then synthesize a Backspace
+                // keypress. TextBox handles "Backspace with non-empty selection"
+                // by deleting the selection — same pattern iOS uses for
+                // IUIKeyInput.DeleteBackward (see TextInputResponder.cs).
+                var sel = client.Selection;
+                var anchor = Math.Min(sel.Start, sel.End);
+                var cursor = Math.Max(sel.Start, sel.End);
+                client.Selection = new TextSelection(
+                    Math.Max(0, anchor - deleteBeforeChars),
+                    cursor + deleteAfterChars);
+
+                input.Invoke(new RawKeyEventArgs(_owner.Keyboard, 0, inputRoot,
+                    RawKeyEventType.KeyDown, Key.Back, RawInputModifiers.None,
+                    PhysicalKey.Backspace, "\b"));
+                input.Invoke(new RawKeyEventArgs(_owner.Keyboard, 0, inputRoot,
+                    RawKeyEventType.KeyUp, Key.Back, RawInputModifiers.None,
+                    PhysicalKey.Backspace, "\b"));
+            }
+
+            if (hasCommit)
+                input?.Invoke(new RawTextInputEventArgs(_owner.Keyboard, 0, inputRoot, commitText!));
+
+            if (!newPreeditEmpty)
+            {
+                _hasPreedit = true;
+                client.SetPreeditText(preeditText,
+                    preeditCursorEndChar < 0 ? null : preeditCursorEndChar);
+            }
+            else if (_hasPreedit)
+            {
+                // No new preedit: clear any leftover composition.
+                client.SetPreeditText(null, null);
+                _hasPreedit = false;
+            }
+        }
+
+        private void OnClientSurroundingTextChanged(object? sender, EventArgs e) => PushSurrounding();
+        private void OnClientSelectionChanged(object? sender, EventArgs e) => PushSurrounding();
+
+        private void PushSurrounding()
+        {
+            if (_client is not { SupportsSurroundingText: true } client)
+                return;
+            var text = client.SurroundingText ?? string.Empty;
+            var selection = client.Selection;
+            _owner._surfaceProxy?.SetTextInputSurroundingText(text, selection.End, selection.Start);
+        }
+
+        private void UnsubscribeClient()
+        {
+            if (_client is null)
+                return;
+            _client.SurroundingTextChanged -= OnClientSurroundingTextChanged;
+            _client.SelectionChanged -= OnClientSelectionChanged;
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/WindowImpl.cs b/src/Avalonia.Wayland/WindowImpl.cs
new file mode 100644
index 0000000000..8dca42b77f
--- /dev/null
+++ b/src/Avalonia.Wayland/WindowImpl.cs
@@ -0,0 +1,396 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using Avalonia.Controls.Platform;
+using Avalonia.Dialogs;
+using Avalonia.FreeDesktop;
+using Avalonia.Input;
+using Avalonia.Input.TextInput;
+using Avalonia.Platform;
+using Avalonia.Platform.Storage;
+using Avalonia.Platform.Storage.FileIO;
+using Avalonia.Platform.Surfaces;
+using Avalonia.Wayland.Server;
+using Avalonia.Wayland.Server.Persistent;
+using NWayland.Protocols.XdgShell;
+
+namespace Avalonia.Wayland;
+
+internal partial class WindowImpl : WindowBaseImpl, IWindowImpl
+{
+    private WaylandSurfaceCreateResult<WXdgTopLevelProxy>? _handle;
+    private WXdgTopLevelProxy? _surfaceProxy;
+    private WaylandTextInputMethod? _textInputMethod;
+    private bool _isActivated;
+    private Size _maxAutoSizeHint;
+    private WindowState _windowState;
+    private bool _canResize = true;
+    private Size _restoreBounds;
+    private Thickness _shadowExtents;
+    private Size? _minSize;
+    private Size? _maxSize;
+    // Sticky-CSD latch on the UI side. Set true the first time the
+    // framework asks for partial / no decorations. Never resets,
+    // including across reconnects. 
+    // This is a limitation of V1 of the protocol that's supported in the wild
+    private bool _csdSticky;
+    private string? _title;
+    private FallbackStorageProvider? _storageProvider;
+
+    public WindowImpl(WaylandWorkerClient client) : base(client)
+    {
+        CurrentSink = new Sink(this, false);
+    }
+
+    private void ApplyConfigureBatch(XdgConfigureBatch batch)
+    {
+        _maxAutoSizeHint = batch.MaxSize;
+
+        // Map xdg_toplevel states to Avalonia WindowState
+        var newWindowState = WindowState.Normal;
+        if ((batch.States & XdgToplevelStates.Fullscreen) != 0)
+            newWindowState = WindowState.FullScreen;
+        else if ((batch.States & XdgToplevelStates.Maximized) != 0)
+            newWindowState = WindowState.Maximized;
+
+        var oldWindowState = _windowState;
+
+        // Save restore bounds when leaving Normal state
+        if (oldWindowState == WindowState.Normal && newWindowState != WindowState.Normal)
+            _restoreBounds = ClientSize;
+
+        if (oldWindowState != newWindowState)
+        {
+            _windowState = newWindowState;
+            WindowStateChanged?.Invoke(newWindowState);
+        }
+
+        // Activation
+        var isActivated = (batch.States & XdgToplevelStates.Activated) != 0;
+        var wasActivated = _isActivated;
+        _isActivated = isActivated;
+        if (isActivated && !wasActivated)
+            Activated?.Invoke();
+        else if (!isActivated && wasActivated)
+            Deactivated?.Invoke();
+
+        // Resize: configure size is window geometry (excluding shadows).
+        // Add shadow extents to get full surface size for the UI thread.
+        if (batch.Size is { Width: > 0, Height: > 0 })
+        {
+            var newClientSize = new Size(
+                batch.Size.Width + _shadowExtents.Left + _shadowExtents.Right,
+                batch.Size.Height + _shadowExtents.Top + _shadowExtents.Bottom);
+            if (newClientSize != ClientSize)
+            {
+                ClientSize = newClientSize;
+                Resized?.Invoke(newClientSize, WindowResizeReason.Layout);
+            }
+        }
+        else if (newWindowState == WindowState.Normal && oldWindowState != WindowState.Normal
+                 && _restoreBounds is { Width: > 0, Height: > 0 })
+        {
+            if (_restoreBounds != ClientSize)
+            {
+                ClientSize = _restoreBounds;
+                Resized?.Invoke(_restoreBounds, WindowResizeReason.Layout);
+            }
+        }
+    }
+
+    public override object? TryGetFeature(Type featureType)
+    {
+        if (featureType == typeof(ITextInputMethodImpl))
+            return _textInputMethod ??= new WaylandTextInputMethod(this);
+        if (featureType == typeof(IStorageProvider))
+            return _storageProvider ??= new FallbackStorageProvider(BuildStorageFactories());
+        return base.TryGetFeature(featureType);
+    }
+
+    private Func<Task<IStorageProvider?>>[] BuildStorageFactories() => new Func<Task<IStorageProvider?>>[]
+    {
+        // Probe xdg-foreign-v2 export at factory-eval time. The DBus portal is only
+        // useful with a real wayland: parent_window — exposing the dialog as a
+        // floating, unparented window is worse UX than a managed in-process picker.
+        // If the probe fails (no exporter global, surface not mapped, or compositor
+        // never delivers the handle), return null and let FallbackStorageProvider
+        // move on to ManagedStorageProvider. The factory is re-evaluated on every
+        // (re)connect via FallbackStorageProvider.Reset.
+        async () =>
+        {
+            var firstLease = await AcquirePortalParentLeaseAsync();
+            if (firstLease is null)
+                return null;
+            // We don't keep the probe lease around — each picker call exports fresh.
+            await firstLease.DisposeAsync();
+            return await DBusSystemDialog.TryCreateAsync(AcquirePortalParentLeaseAsync);
+        },
+        // HACK: relies on focus root being TopLevel which currently is true
+        () => Task.FromResult(((PresentationSource?)InputRoot)?.FocusRoot is TopLevel tl ? (IStorageProvider?)new ManagedStorageProvider(tl) : null)
+    };
+
+    private async Task<IPortalParentLease?> AcquirePortalParentLeaseAsync()
+    {
+        var proxy = _surfaceProxy;
+        if (proxy is null)
+            return null;
+        // Cross-thread proxy auto-wraps the worker call into Task<IWaylandXdgTopLevelExport?>.
+        var export = await proxy.ExportToplevel();
+        if (export is null)
+            return null;
+        var raw = await export.HandleTask;
+        if (raw is null)
+        {
+            export.Dispose();
+            return null;
+        }
+        return new XdgForeignPortalParentLease(export, "wayland:" + raw);
+    }
+
+    private sealed class XdgForeignPortalParentLease : IPortalParentLease
+    {
+        private readonly IWaylandXdgTopLevelExport _export;
+        public XdgForeignPortalParentLease(IWaylandXdgTopLevelExport export, string handle)
+        {
+            _export = export;
+            Handle = handle;
+        }
+        public string Handle { get; }
+        public ValueTask DisposeAsync()
+        {
+            _export.Dispose();
+            return default;
+        }
+    }
+
+    public override IPlatformRenderSurface[] Surfaces => _handle?.GetRenderSurfaces() ?? [];
+
+    internal override WXdgShellSurfaceProxy? SurfaceProxy => _surfaceProxy;
+
+    public override IPopupImpl? CreatePopup() => new PopupImpl(Client, this);
+
+    // TODO: Query client decorations
+    public override Size? FrameSize => null;
+
+    public override void Show(bool activate, bool isDialog)
+    {
+        if (IsDisposed)
+            throw new ObjectDisposedException(nameof(WindowImpl));
+
+        if (CurrentSink == null)
+        {
+            // TODO: Re-apply window state
+            CurrentSink = new Sink(this, true);
+        }
+
+        Client.AnyThreadWakeupRenderLoop();
+    }
+
+    public override Size MaxAutoSizeHint => _maxAutoSizeHint;
+
+    public WindowState WindowState
+    {
+        get => _windowState;
+        set
+        {
+            // Capture current state on the UI thread for the transition logic
+            var currentState = _windowState;
+            // Don't update the field — the compositor will confirm via configure
+            var proxy = _surfaceProxy;
+            if (proxy is null)
+                return;
+            switch (value)
+            {
+                case WindowState.Normal:
+                    if (currentState == WindowState.Maximized)
+                        proxy.UnsetMaximized();
+                    else if (currentState == WindowState.FullScreen)
+                        proxy.UnsetFullscreen();
+                    break;
+                case WindowState.Maximized:
+                    if (currentState == WindowState.FullScreen)
+                        proxy.UnsetFullscreen();
+                    proxy.SetMaximized();
+                    break;
+                case WindowState.FullScreen:
+                    if (currentState == WindowState.Maximized)
+                        proxy.UnsetMaximized();
+                    proxy.SetFullscreen();
+                    break;
+                case WindowState.Minimized:
+                    proxy.SetMinimized();
+                    break;
+            }
+        }
+    }
+    public bool WindowStateGetterIsUsable => true;
+    public Action<WindowState>? WindowStateChanged { get; set; }
+    public void SetTitle(string? title)
+    {
+        _title = title;
+        _surfaceProxy?.SetTitle(title);
+    }
+
+    public void SetParent(IWindowImpl? parent)
+    {
+        var parentProxy = (parent as WindowImpl)?._handle?.Proxy;
+        _surfaceProxy?.SetParent(parentProxy);
+    }
+
+    public void SetEnabled(bool enable) => IsEnabled = enable;
+
+    public Action? GotInputWhenDisabled { get; set; }
+
+    public void SetWindowDecorations(WindowDecorations enabled)
+    {
+        if (_csdSticky || enabled == WindowDecorations.Full)
+            return;
+        
+        // We disable SSD support completely once CSD was requested at least once. Protocol limitation
+        _csdSticky = true;
+        _surfaceProxy?.DestroyDecoration();
+        ApplyDecorationMode(DecorationMode.ClientSide);
+    }
+
+    /// <summary>
+    /// Apply a new effective decoration mode on the UI thread. Updates
+    /// the cached <see cref="NeedsManagedDecorations"/> flag and nudges the
+    /// framework to re-evaluate chrome layout. Idempotent.
+    /// </summary>
+    internal void ApplyDecorationMode(DecorationMode mode)
+    {
+        if(_serverReportedMode == mode)
+            return;
+        _serverReportedMode = mode;
+        RaiseDecorationChangeCallbacks();
+    }
+
+    private void RaiseDecorationChangeCallbacks()
+    {
+        DrawnDecorationsRequestChanged?.Invoke();
+        ExtendClientAreaToDecorationsChanged?.Invoke(IsClientAreaExtendedToDecorations);
+    }
+
+    public void SetIcon(IWindowIconImpl? icon) { }
+    public void ShowTaskbarIcon(bool value) { }
+    public void CanResize(bool value) => _canResize = value;
+    public void SetCanMinimize(bool value) { }
+    public void SetCanMaximize(bool value) { }
+
+    public Func<WindowCloseReason, bool>? Closing { get; set; }
+
+
+    public Action<bool>? ExtendClientAreaToDecorationsChanged
+    {
+        get => field;
+        set
+        {
+            field = value;
+            value?.Invoke(true);
+        }
+    }
+
+    private DecorationMode _serverReportedMode = DecorationMode.ClientSide;
+    private bool _appRequestedDecorationExtension;
+
+    public bool IsClientAreaExtendedToDecorations => NeedsManagedDecorations && _appRequestedDecorationExtension;
+    public bool NeedsManagedDecorations => _serverReportedMode == DecorationMode.ClientSide;
+    public PlatformRequestedDrawnDecoration RequestedDrawnDecorations =>
+        NeedsManagedDecorations
+            ? PlatformRequestedDrawnDecoration.TitleBar | PlatformRequestedDrawnDecoration.Border |
+              PlatformRequestedDrawnDecoration.ResizeGrips | PlatformRequestedDrawnDecoration.Shadow
+            : PlatformRequestedDrawnDecoration.None;
+
+    public Action? DrawnDecorationsRequestChanged { get; set; }
+
+    public Thickness ExtendedMargins => default;
+    public Thickness OffScreenMargin => default;
+
+    // Not supported by Wayland — surfaces have no screen position.
+    public void Move(PixelPoint point) { }
+
+    public void BeginMoveDrag(PointerPressedEventArgs e)
+    {
+        var cookie = e.PlatformInputEventCookie;
+        e.Pointer.Capture(null);
+        _surfaceProxy?.Move(cookie, WaylandDispatchPriority.Oob);
+    }
+
+    public void BeginResizeDrag(WindowEdge edge, PointerPressedEventArgs e)
+    {
+        var resizeEdge = edge switch
+        {
+            WindowEdge.NorthWest => XdgToplevel.ResizeEdgeEnum.TopLeft,
+            WindowEdge.North => XdgToplevel.ResizeEdgeEnum.Top,
+            WindowEdge.NorthEast => XdgToplevel.ResizeEdgeEnum.TopRight,
+            WindowEdge.West => XdgToplevel.ResizeEdgeEnum.Left,
+            WindowEdge.East => XdgToplevel.ResizeEdgeEnum.Right,
+            WindowEdge.SouthWest => XdgToplevel.ResizeEdgeEnum.BottomLeft,
+            WindowEdge.South => XdgToplevel.ResizeEdgeEnum.Bottom,
+            WindowEdge.SouthEast => XdgToplevel.ResizeEdgeEnum.BottomRight,
+            _ => XdgToplevel.ResizeEdgeEnum.None
+        };
+        var cookie = e.PlatformInputEventCookie;
+        e.Pointer.Capture(null);
+        _surfaceProxy?.Resize(cookie, resizeEdge, WaylandDispatchPriority.Oob);
+    }
+
+    private int _resizeStackDepth = 0;
+
+    private bool SizeNearlyEquals(double x, double y) => Math.Abs(x - y) < 0.01;
+
+    public void Resize(Size clientSize, WindowResizeReason reason = WindowResizeReason.Application)
+    {
+        // There is some bug on the x-plat side of things that increments the size by 0.000001 or smth and causes
+        // a stack overflow
+        // So we check for recursion depth and for nearly equal values here.
+        
+        if (_resizeStackDepth > 5) 
+            return;
+
+        if (SizeNearlyEquals(clientSize.Width, ClientSize.Width) &&
+            SizeNearlyEquals(clientSize.Height, ClientSize.Height))
+            return;
+        try
+        {
+            _resizeStackDepth++;
+            // Size is just a number, the actual resizing is done by the compositor when submitting a frame
+            ClientSize = clientSize;
+            Resized?.Invoke(clientSize, reason);
+        }
+        finally
+        {
+            _resizeStackDepth--;
+        }
+    }
+
+    public void SetMinMaxSize(Size minSize, Size maxSize)
+    {
+        // Avalonia uses (0,0) and PositiveInfinity to mean "unconstrained".
+        // Map both onto null at this boundary so the worker layer can
+        // express "no constraint" without sentinel-value plumbing.
+        static Size? Normalize(Size s) =>
+            s.Width > 0 && s.Height > 0 && !double.IsPositiveInfinity(s.Width)
+                && !double.IsPositiveInfinity(s.Height)
+                ? s
+                : (Size?)null;
+        _minSize = Normalize(minSize);
+        _maxSize = Normalize(maxSize);
+        _surfaceProxy?.SetMinMaxSize(_minSize, _maxSize);
+    }
+
+    public void SetExtendClientAreaToDecorationsHint(bool extendIntoClientAreaHint)
+    {
+        _appRequestedDecorationExtension = extendIntoClientAreaHint;
+        RaiseDecorationChangeCallbacks();
+    }
+
+    public void SetExtendClientAreaTitleBarHeightHint(double titleBarHeight) { }
+
+    void IWindowImpl.SetShadowExtents(Thickness extents)
+    {
+        _shadowExtents = extents;
+        _surfaceProxy?.SetShadowExtents(extents);
+    }
+}
diff --git a/src/Avalonia.Wayland/WindowImplBase.DragDrop.cs b/src/Avalonia.Wayland/WindowImplBase.DragDrop.cs
new file mode 100644
index 0000000000..0bf4657068
--- /dev/null
+++ b/src/Avalonia.Wayland/WindowImplBase.DragDrop.cs
@@ -0,0 +1,190 @@
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Wayland.Clipboard;
+using Avalonia.Wayland.Server.Persistent;
+using Avalonia.Wayland.Server.Transient.Clipboard;
+
+namespace Avalonia.Wayland;
+
+partial class WindowBaseImpl
+{
+    partial class Sink
+    {
+        // DnD session state (Wayland-thread only; carried to UI thread via event args)
+        private IDataTransfer? _currentDragDataTransfer;
+        private DragDropEffects _currentDragSourceEffects;
+        private WaylandDragMotionArgs? _pendingDragMotion;
+        private WaylandOfferCookie? _currentDndCookie;
+
+        /// <summary>
+        /// Handles DnD-related dispatch in <see cref="DispatchInput"/>.
+        /// Returns true if the event was DnD and was fully handled.
+        /// </summary>
+        protected bool HandleDragDropDispatch(RawInputEventArgs args)
+        {
+            // DnD motion debouncing: consume latest position under lock, create RawDragEvent
+            if (args is WaylandDragMotionArgs dragMotion)
+            {
+                Point pos;
+                RawInputModifiers mods;
+                lock (dragMotion.SyncRoot)
+                {
+                    pos = dragMotion.Position;
+                    mods = dragMotion.Modifiers;
+                    dragMotion.Consumed = true;
+                }
+
+                var overEvent = new RawDragEvent(DragDropDevice.Instance, RawDragEventType.DragOver,
+                    InputRoot!, pos, dragMotion.DataTransfer, dragMotion.SourceEffects, mods);
+                Parent.Input?.Invoke(overEvent);
+
+                var effects = overEvent.Effects;
+                dragMotion.OfferCookie?.PostUpdateFeedback(effects);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Post-dispatch feedback for DnD enter/drop events.
+        /// Called after <see cref="WindowBaseImpl.Input"/> has processed the event.
+        /// Returns true if the event was DnD and feedback was sent.
+        /// </summary>
+        protected bool HandleDragDropPostDispatch(RawInputEventArgs args)
+        {
+            if (args is not WaylandRawDragEvent dragEvent)
+                return false;
+
+            // Route DnD feedback through the session cookie, which resolves
+            // the correct data device on the Wayland thread.
+            if (dragEvent.Type is RawDragEventType.DragEnter)
+            {
+                var effects = dragEvent.Effects;
+                dragEvent.OfferCookie?.PostUpdateFeedback(effects);
+            }
+            else if (dragEvent.Type is RawDragEventType.Drop)
+            {
+                dragEvent.OfferCookie?.PostFinish();
+            }
+
+            return true;
+        }
+
+        void IWSurfaceEventSink.OnDragEnter(Point position, string[] mimeTypes, WaylandOfferCookie offerCookie,
+            DragDropEffects sourceEffects, RawInputModifiers modifiers)
+        {
+            if (InputRoot is null)
+                return;
+
+            _currentDndCookie = offerCookie;
+
+            // Check for in-process drag source to avoid deadlock: if the offer contains
+            // our sentinel MIME type, use the original IDataTransfer directly instead of
+            // creating a pipe-based WaylandDataTransfer (whose reads would deadlock because
+            // the source's send handler dispatches to the same UI thread).
+            _currentDragDataTransfer = WaylandOutgoingTransfer.TryGetInProcessTransfer(mimeTypes)
+                                       ?? new WaylandDataTransfer(mimeTypes, offerCookie);
+            _currentDragSourceEffects = sourceEffects;
+            _pendingDragMotion = null;
+
+            ScheduleInput(new WaylandRawDragEvent(DragDropDevice.Instance, RawDragEventType.DragEnter,
+                InputRoot, position, _currentDragDataTransfer, sourceEffects, modifiers, offerCookie));
+        }
+
+        void IWSurfaceEventSink.OnDragMotion(Point position, RawInputModifiers modifiers)
+        {
+            var pending = _pendingDragMotion;
+            if (pending != null)
+            {
+                lock (pending.SyncRoot)
+                {
+                    if (!pending.Consumed)
+                    {
+                        pending.Position = position;
+                        pending.Modifiers = modifiers;
+                        return;
+                    }
+                }
+            }
+
+            if (InputRoot is null || _currentDragDataTransfer is null)
+                return;
+
+            var args = new WaylandDragMotionArgs(DragDropDevice.Instance, InputRoot,
+                position, _currentDragDataTransfer, _currentDragSourceEffects, modifiers, _currentDndCookie);
+            _pendingDragMotion = args;
+            RawEventGrouper.HandleEvent(args);
+        }
+
+        void IWSurfaceEventSink.OnDragLeave()
+        {
+            if (InputRoot is null || _currentDragDataTransfer is null)
+                return;
+
+            _pendingDragMotion = null;
+
+            ScheduleInput(new RawDragEvent(DragDropDevice.Instance, RawDragEventType.DragLeave,
+                InputRoot, default, _currentDragDataTransfer, DragDropEffects.None, RawInputModifiers.None));
+
+            _currentDragDataTransfer = null;
+            _currentDndCookie = null;
+        }
+
+        void IWSurfaceEventSink.OnDrop(Point position, RawInputModifiers modifiers)
+        {
+            if (InputRoot is null || _currentDragDataTransfer is null)
+                return;
+
+            _pendingDragMotion = null;
+
+            ScheduleInput(new WaylandRawDragEvent(DragDropDevice.Instance, RawDragEventType.Drop,
+                InputRoot, position, _currentDragDataTransfer, _currentDragSourceEffects, modifiers, _currentDndCookie));
+
+            _currentDragDataTransfer = null;
+            _currentDndCookie = null;
+        }
+    }
+
+    /// <summary>
+    /// <see cref="RawDragEvent"/> subclass that carries the <see cref="WaylandOfferCookie"/>
+    /// through the event queue so the UI thread can route DnD feedback without cross-thread
+    /// field access.
+    /// </summary>
+    private class WaylandRawDragEvent(
+        IDragDropDevice device, RawDragEventType type, IInputRoot root,
+        Point location, IDataTransfer dataTransfer, DragDropEffects effects,
+        RawInputModifiers modifiers, WaylandOfferCookie? offerCookie)
+        : RawDragEvent(device, type, root, location, dataTransfer, effects, modifiers)
+    {
+        public WaylandOfferCookie? OfferCookie { get; } = offerCookie;
+    }
+
+    /// <summary>
+    /// Specialized event args for DnD motion debouncing.
+    /// <para>
+    /// Ownership semantics: while a <see cref="WaylandDragMotionArgs"/> instance is in the dispatch
+    /// queue, ownership belongs to the Wayland thread — it may update <see cref="Position"/> and
+    /// <see cref="Modifiers"/> under <see cref="SyncRoot"/>. When the UI thread processes the event,
+    /// it acquires the lock, reads the latest values, and sets <see cref="Consumed"/> to
+    /// <c>true</c>. This atomically transfers ownership to the UI thread: subsequent Wayland-thread
+    /// updates see <c>Consumed == true</c> and create a new args instance instead. Therefore the
+    /// state is never truly shared — at any point exactly one thread owns the mutable fields.
+    /// </para>
+    /// </summary>
+    private class WaylandDragMotionArgs(
+        IDragDropDevice device, IInputRoot root,
+        Point position, IDataTransfer dataTransfer,
+        DragDropEffects sourceEffects, RawInputModifiers modifiers,
+        WaylandOfferCookie? offerCookie)
+        : RawInputEventArgs(device, 0, root)
+    {
+        public readonly object SyncRoot = new();
+        public Point Position = position;
+        public RawInputModifiers Modifiers = modifiers;
+        public bool Consumed;
+        public readonly IDataTransfer DataTransfer = dataTransfer;
+        public readonly DragDropEffects SourceEffects = sourceEffects;
+        public readonly WaylandOfferCookie? OfferCookie = offerCookie;
+    }
+}
diff --git a/src/Avalonia.Wayland/WindowImplBase.Keyboard.cs b/src/Avalonia.Wayland/WindowImplBase.Keyboard.cs
new file mode 100644
index 0000000000..ad4250c594
--- /dev/null
+++ b/src/Avalonia.Wayland/WindowImplBase.Keyboard.cs
@@ -0,0 +1,144 @@
+using System;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Threading;
+using Avalonia.Wayland.Server.Persistent;
+
+namespace Avalonia.Wayland;
+
+partial class WindowBaseImpl
+{
+    partial class Sink
+    {
+        // Key repeat state (managed on UI thread via DispatcherTimer)
+        private DispatcherTimer? _keyRepeatTimer;
+        private Key _repeatKey;
+        private PhysicalKey _repeatPhysicalKey;
+        private RawInputModifiers _repeatModifiers;
+        private string? _repeatKeySymbol;
+        private int _keyRepeatDelay;
+        private int _keyRepeatRate;
+
+        void IWSurfaceEventSink.OnKeyDown(ulong timestamp, Key key, RawInputModifiers modifiers,
+            PhysicalKey physicalKey, string? keySymbol)
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawKeyEventArgs(Keyboard, timestamp, InputRoot,
+                RawKeyEventType.KeyDown, key, modifiers, physicalKey, keySymbol));
+        }
+
+        void IWSurfaceEventSink.OnKeyUp(ulong timestamp, Key key, RawInputModifiers modifiers, PhysicalKey physicalKey,
+            string? keySymbol)
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawKeyEventArgs(Keyboard, timestamp, InputRoot,
+                RawKeyEventType.KeyUp, key, modifiers, physicalKey, keySymbol));
+        }
+
+        void IWSurfaceEventSink.OnKeyboardLeave()
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawKeyboardLeaveEventArgs(Keyboard, 0, InputRoot));
+        }
+
+        void IWSurfaceEventSink.OnKeyRepeatInfo(int rate, int delay)
+        {
+            _keyRepeatRate = rate;
+            _keyRepeatDelay = delay;
+        }
+
+        /// <summary>
+        /// Called from DispatchInput on the UI thread to handle keyboard events for key repeat.
+        /// Returns true if the event is fully handled and should not be dispatched further.
+        /// </summary>
+        protected bool HandleKeyboardDispatch(RawInputEventArgs args)
+        {
+            if (args is RawKeyboardLeaveEventArgs)
+            {
+                StopKeyRepeat();
+                return true;
+            }
+
+            if (args is RawKeyEventArgs keyArgs)
+            {
+                if (keyArgs.Type == RawKeyEventType.KeyDown)
+                {
+                    StartKeyRepeat(keyArgs.Key, keyArgs.PhysicalKey, keyArgs.Modifiers, keyArgs.KeySymbol);
+                }
+                else if (keyArgs.Type == RawKeyEventType.KeyUp && _repeatKey == keyArgs.Key)
+                {
+                    StopKeyRepeat();
+                }
+            }
+
+            return false;
+        }
+
+        private void StartKeyRepeat(Key key, PhysicalKey physicalKey, RawInputModifiers modifiers, string? keySymbol)
+        {
+            StopKeyRepeat();
+            if (_keyRepeatRate <= 0)
+                return;
+
+            // Modifier keys don't repeat
+            if (key is Key.LeftShift or Key.RightShift or Key.LeftCtrl or Key.RightCtrl
+                or Key.LeftAlt or Key.RightAlt or Key.LWin or Key.RWin)
+                return;
+
+            _repeatKey = key;
+            _repeatPhysicalKey = physicalKey;
+            _repeatModifiers = modifiers;
+            _repeatKeySymbol = keySymbol;
+
+            var intervalMs = Math.Max(1, 1000 / _keyRepeatRate);
+            _keyRepeatTimer = new DispatcherTimer(
+                TimeSpan.FromMilliseconds(intervalMs),
+                // Ensure it doesn't block any actual input events that would stop the repeat
+                DispatcherPriority.Input - 1,
+                Dispatcher.UIThread);
+            _keyRepeatTimer.Tick += OnKeyRepeatTick;
+
+            // Start with the initial delay, then switch to repeat interval on first tick
+            _keyRepeatTimer.Interval = TimeSpan.FromMilliseconds(_keyRepeatDelay);
+            _keyRepeatTimer.Start();
+        }
+
+        protected void StopKeyRepeat()
+        {
+            if (_keyRepeatTimer != null)
+            {
+                _keyRepeatTimer.Stop();
+                _keyRepeatTimer.Tick -= OnKeyRepeatTick;
+                _keyRepeatTimer = null;
+            }
+        }
+
+        private void OnKeyRepeatTick(object? sender, EventArgs e)
+        {
+            if (InputRoot is null || _keyRepeatTimer == null)
+            {
+                StopKeyRepeat();
+                return;
+            }
+
+            // After first tick (initial delay), switch to repeat interval
+            var intervalMs = Math.Max(1, 1000 / _keyRepeatRate);
+            var repeatInterval = TimeSpan.FromMilliseconds(intervalMs);
+            if (_keyRepeatTimer.Interval != repeatInterval)
+                _keyRepeatTimer.Interval = repeatInterval;
+
+            Parent.Input?.Invoke(new RawKeyEventArgs(Keyboard, 0, InputRoot,
+                RawKeyEventType.KeyDown, _repeatKey, _repeatModifiers, _repeatPhysicalKey, _repeatKeySymbol));
+        }
+    }
+
+    /// <summary>
+    /// Internal event args for keyboard leave, routed through the event queue
+    /// to be serialized with other input events.
+    /// </summary>
+    private class RawKeyboardLeaveEventArgs(IInputDevice device, ulong timestamp, IInputRoot root)
+        : RawInputEventArgs(device, timestamp, root);
+}
diff --git a/src/Avalonia.Wayland/WindowImplBase.Pointer.cs b/src/Avalonia.Wayland/WindowImplBase.Pointer.cs
new file mode 100644
index 0000000000..12223f9c12
--- /dev/null
+++ b/src/Avalonia.Wayland/WindowImplBase.Pointer.cs
@@ -0,0 +1,86 @@
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Wayland.Server.Persistent;
+
+namespace Avalonia.Wayland;
+
+partial class WindowBaseImpl
+{
+    partial class Sink
+    {
+        void IWSurfaceEventSink.OnPointerEnter(ulong timestamp, uint serial, Point position)
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawPointerEventArgs(Mouse, timestamp, InputRoot,
+                RawPointerEventType.Move, position, RawInputModifiers.None));
+        }
+
+        void IWSurfaceEventSink.OnPointerLeave(uint serial)
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawPointerEventArgs(Mouse, 0, InputRoot,
+                RawPointerEventType.LeaveWindow, new Point(), RawInputModifiers.None));
+        }
+
+        void IWSurfaceEventSink.OnPointerMotion(ulong timestamp, Point position, RawInputModifiers modifiers)
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawPointerEventArgs(Mouse, timestamp, InputRoot,
+                RawPointerEventType.Move, position, modifiers));
+        }
+
+        void IWSurfaceEventSink.OnPointerButton(ulong timestamp, uint serial, RawPointerEventType type,
+            RawInputModifiers modifiers, Point position, object? platformCookie)
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawPointerEventArgs(Mouse, timestamp, InputRoot,
+                type, position, modifiers) { PlatformInputEventCookie = platformCookie });
+        }
+
+        void IWSurfaceEventSink.OnPointerAxis(ulong timestamp, Vector delta, RawInputModifiers modifiers,
+            Point position)
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawMouseWheelEventArgs(Mouse, timestamp, InputRoot,
+                position, delta, modifiers));
+        }
+
+        void IWSurfaceEventSink.OnTouchDown(ulong timestamp, int touchId, Point position, object? platformCookie)
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawTouchEventArgs(Touch, timestamp, InputRoot,
+                    RawPointerEventType.TouchBegin, position, RawInputModifiers.None, touchId)
+                { PlatformInputEventCookie = platformCookie });
+        }
+
+        void IWSurfaceEventSink.OnTouchMove(ulong timestamp, int touchId, Point position)
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawTouchEventArgs(Touch, timestamp, InputRoot,
+                RawPointerEventType.TouchUpdate, position, RawInputModifiers.None, touchId));
+        }
+
+        void IWSurfaceEventSink.OnTouchUp(ulong timestamp, int touchId, Point position)
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawTouchEventArgs(Touch, timestamp, InputRoot,
+                RawPointerEventType.TouchEnd, position, RawInputModifiers.None, touchId));
+        }
+
+        void IWSurfaceEventSink.OnTouchCancel(int touchId, Point position)
+        {
+            if (InputRoot is null)
+                return;
+            ScheduleInput(new RawTouchEventArgs(Touch, 0, InputRoot,
+                RawPointerEventType.TouchCancel, position, RawInputModifiers.None, touchId));
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/WindowImplBase.cs b/src/Avalonia.Wayland/WindowImplBase.cs
new file mode 100644
index 0000000000..3a95933d9c
--- /dev/null
+++ b/src/Avalonia.Wayland/WindowImplBase.cs
@@ -0,0 +1,262 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using Avalonia.Controls.Platform;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using Avalonia.Input.Raw;
+using Avalonia.Input.TextInput;
+using Avalonia.Platform;
+using Avalonia.Platform.Storage;
+using Avalonia.Platform.Storage.FileIO;
+using Avalonia.Platform.Surfaces;
+using Avalonia.Rendering.Composition;
+using Avalonia.Threading;
+using Avalonia.Wayland.Server;
+using Avalonia.Wayland.Server.Persistent;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// Shared base for Wayland top-level and popup window implementations.
+/// Holds the common DI/threading state, render-scale, cursor, event
+/// callbacks and no-op platform methods that Wayland doesn't support
+/// (Move, SetTopmost, Activate, PointToClient/Screen, etc.).
+/// </summary>
+internal abstract partial class WindowBaseImpl : IWindowBaseImpl
+{
+    protected WaylandWorkerClient Client { get; }
+    protected IInputRoot? InputRoot { get; private set; }
+    protected MouseDevice Mouse { get; }
+    protected TouchDevice Touch { get; }
+    protected KeyboardDevice Keyboard  { get; }
+    public double RenderScaling { get; set; } = 1;
+    protected WaylandCursorImpl? CurrentCursor { get; private set; }
+    protected bool IsEnabled  { get; set; } = true;
+    protected bool IsDisposed  { get; private set; }
+    
+    internal IReadOnlyList<object> CurrentOutputIds { get; set; } = Array.Empty<object>();
+
+    protected WindowBaseImpl(WaylandWorkerClient client)
+    {
+        Client = client;
+        Compositor = client.Compositor;
+        Mouse = MouseDevice.Primary;
+        Touch = new TouchDevice();
+        Keyboard = (KeyboardDevice)AvaloniaLocator.Current.GetRequiredService<IKeyboardDevice>();
+    }
+
+    public Compositor Compositor { get; }
+    public double DesktopScaling => RenderScaling;
+    public IPlatformHandle? Handle => null;
+
+    public Size ClientSize
+    {
+        get;
+        protected set
+        {
+            field = value;
+            Client.AnyThreadWakeupRenderLoop();
+        }
+    }
+
+    public abstract IPlatformRenderSurface[] Surfaces { get; }
+
+    // Not supported by Wayland.
+    public PixelPoint Position => default;
+    public Point PointToClient(PixelPoint point) => new(point.X, point.Y);
+    public PixelPoint PointToScreen(Point point) => new((int)point.X, (int)point.Y);
+    public void Activate() { }
+    public void SetTopmost(bool value) { }
+
+    public abstract Size MaxAutoSizeHint { get; }
+    public virtual Size? FrameSize => null;
+
+    public WindowTransparencyLevel TransparencyLevel { get; } = WindowTransparencyLevel.Transparent;
+    public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } = default;
+    public void SetTransparencyLevelHint(IReadOnlyList<WindowTransparencyLevel> transparencyLevels) { }
+    public void SetFrameThemeVariant(PlatformThemeVariant themeVariant) { }
+
+    public Action? Closed { get; set; }
+    public Action? LostFocus { get; set; }
+    public Action<PixelPoint>? PositionChanged { get; set; }
+    public Action? Activated { get; set; }
+    public Action? Deactivated { get; set; }
+    public Action<RawInputEventArgs>? Input { get; set; }
+    public Action<Rect>? Paint { get; set; }
+    public Action<Size, WindowResizeReason>? Resized { get; set; }
+    public Action<double>? ScalingChanged { get; set; }
+    public Action<WindowTransparencyLevel>? TransparencyLevelChanged { get; set; }
+
+    public void SetInputRoot(IInputRoot inputRoot) => InputRoot = inputRoot;
+
+    protected Sink? CurrentSink { get; set; }
+
+    public abstract void Show(bool activate, bool isDialog);
+
+    public virtual void Hide()
+    {
+        var current = CurrentSink;
+        CurrentSink = null;
+        current?.Dispose();
+    }
+
+    public abstract IPopupImpl? CreatePopup();
+
+
+    public virtual void Dispose()
+    {
+        if (IsDisposed)
+            return;
+        IsDisposed = true;
+        var current = CurrentSink;
+        CurrentSink = null;
+        current?.Dispose();
+        Closed?.Invoke();
+    }
+
+    public void SetCursor(ICursorImpl? cursor)
+    {
+        CurrentCursor = cursor as WaylandCursorImpl;
+        ApplyCurrentCursor(SurfaceProxy);
+    }
+
+    /// <summary>
+    /// Pushes <see cref="CurrentCursor"/> to the given surface proxy (<c>null</c> falls back to the
+    /// default arrow). Also used by the sinks to re-apply the cursor on a freshly created surface.
+    /// </summary>
+    internal void ApplyCurrentCursor(WXdgShellSurfaceProxy? proxy) => proxy?.SetCursor(CurrentCursor?.Cursor);
+
+    /// <summary>
+    /// Returns the worker-side <c>xdg_surface</c>-derived proxy backing
+    /// this top-level / popup, or <c>null</c> when no surface is
+    /// currently created. Used by base-class operations that need to
+    /// reach the surface uniformly across <see cref="WindowImpl"/> and
+    /// <see cref="PopupImpl"/> (e.g. cursor application, child-popup
+    /// parenting).
+    /// </summary>
+    internal abstract WXdgShellSurfaceProxy? SurfaceProxy { get; }
+
+    protected void UpdateScaling(double scale)
+    {
+        if (Math.Abs(scale - RenderScaling) < 1e-6)
+            return;
+        RenderScaling = scale;
+        ScalingChanged?.Invoke(scale);
+        Client.AnyThreadWakeupRenderLoop();
+    }
+
+    protected void PostToUiThread(Action action) =>
+        Dispatcher.UIThread.Post(action, DispatcherPriority.Input);
+
+    public virtual object? TryGetFeature(Type featureType)
+    {
+        if (featureType == typeof(IScreenImpl))
+            return AvaloniaLocator.Current.GetService<IScreenImpl>();
+        if (featureType == typeof(IClipboard))
+            return AvaloniaLocator.Current.GetRequiredService<IClipboard>();
+        if (featureType == typeof(ILauncher))
+            return new BclLauncher();
+        return null;
+    }
+
+    /// <summary>
+    /// UI-thread sink for surface events. Receives worker→UI calls (already
+    /// marshalled by <see cref="WSurfaceEventSinkProxy"/>) and converts them
+    /// into Avalonia raw input events. Subclasses add surface-role-specific
+    /// behaviour: top-levels handle xdg_toplevel configure/close (via
+    /// <see cref="IWXdgTopLevelEventSink"/>) and chrome-driven move/resize;
+    /// popups handle their own configure batch (via
+    /// <see cref="IWXdgPopupEventSink"/>).
+    /// </summary>
+    internal abstract partial class Sink : IWSurfaceEventSink, IDisposable
+    {
+        protected WindowBaseImpl Parent { get; }
+        protected bool IsDisposed { get; private set; }
+        protected RawEventGrouper RawEventGrouper { get; }
+
+        protected Sink(WindowBaseImpl parent)
+        {
+            Parent = parent;
+            RawEventGrouper = new RawEventGrouper(DispatchInput, Parent.Client.InputDispatchQueue);
+        }
+
+        public virtual void Dispose()
+        {
+            if (IsDisposed)
+                return;
+            IsDisposed = true;
+            StopKeyRepeat();
+            DisconnectFromSurface();
+        }
+
+        /// <summary>
+        /// Tear down the worker-side surface proxy. Subclasses null out their
+        /// typed handle/proxy fields (and the corresponding fields on
+        /// <see cref="Parent"/>) and post a disconnect to the worker.
+        /// </summary>
+        protected abstract void DisconnectFromSurface();
+
+        protected IInputRoot? InputRoot => Parent.InputRoot;
+        protected TouchDevice Touch => Parent.Touch;
+        protected MouseDevice Mouse => Parent.Mouse;
+        protected KeyboardDevice Keyboard => Parent.Keyboard;
+
+        protected void ScheduleInput(RawInputEventArgs args) => RawEventGrouper.HandleEvent(args);
+
+        protected virtual void DispatchInput(RawInputEventArgs args)
+        {
+            if (IsDisposed || InputRoot is null)
+                return;
+
+            if (!Parent.IsEnabled)
+            {
+                OnInputWhileDisabled();
+                return;
+            }
+
+            if (HandleKeyboardDispatch(args))
+                return;
+
+            if (HandleDragDropDispatch(args))
+                return;
+
+            if (HandleSurfaceSpecificDispatch(args))
+                return;
+
+            Parent.Input?.Invoke(args);
+
+            if (HandleDragDropPostDispatch(args))
+                return;
+
+            if (!args.Handled && args is RawKeyEventArgs { KeySymbol: { } text, Type: RawKeyEventType.KeyDown })
+                Parent.Input?.Invoke(new RawTextInputEventArgs(Keyboard, args.Timestamp, InputRoot, text));
+        }
+
+        /// <summary>
+        /// Lets a derived sink intercept input before it reaches the framework.
+        /// Used by <see cref="WindowImpl.Sink"/> for title-bar move and edge resize chrome.
+        /// </summary>
+        protected virtual bool HandleSurfaceSpecificDispatch(RawInputEventArgs args) => false;
+
+        protected virtual void OnInputWhileDisabled() { }
+
+        // Configure/close are surface-role-specific (xdg_toplevel vs xdg_popup
+        // carry different payloads). Subclasses implement the matching
+        // worker→UI interface (IWXdgTopLevelEventSink / IWXdgPopupEventSink).
+        public virtual void OnScaleChanged(double scale)
+        {
+            if (IsDisposed)
+                return;
+            Parent.UpdateScaling(scale);
+        }
+
+        public virtual void OnSurfaceOutputsChanged(IReadOnlyList<object> outputIds)
+        {
+            if (IsDisposed)
+                return;
+            Parent.CurrentOutputIds = outputIds;
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/XkbCommonKeymap.cs b/src/Avalonia.Wayland/XkbCommonKeymap.cs
new file mode 100644
index 0000000000..71c7577305
--- /dev/null
+++ b/src/Avalonia.Wayland/XkbCommonKeymap.cs
@@ -0,0 +1,126 @@
+using System;
+using System.Text;
+using Avalonia.Wayland.Server.Interop;
+using static Avalonia.Wayland.Server.Interop.XkbCommonNativeMethods;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// Wraps an xkbcommon keymap and state, providing safe .NET API for keyboard layout handling.
+/// Created from the keymap fd received in the wl_keyboard.keymap event.
+/// </summary>
+sealed unsafe class XkbCommonKeymap : IDisposable
+{
+    private IntPtr _keymap;
+    private IntPtr _state;
+
+    public XkbCommonKeymap(XkbContext context, int fd, uint size)
+    {
+        var mapped = UnsafeNativeMethods.mmap(
+            IntPtr.Zero, (IntPtr)size, PROT_READ, MAP_PRIVATE, fd, IntPtr.Zero);
+        UnsafeNativeMethods.close(fd);
+
+        if (mapped == IntPtr.Zero || mapped == new IntPtr(-1))
+            throw new InvalidOperationException("Failed to mmap keymap fd");
+
+        try
+        {
+            // size includes null terminator; xkb_keymap_new_from_buffer expects length without it
+            _keymap = xkb_keymap_new_from_buffer(
+                context.Handle, (byte*)mapped, (IntPtr)(size - 1),
+                XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
+
+            if (_keymap == IntPtr.Zero)
+                throw new InvalidOperationException("Failed to create xkb keymap from buffer");
+
+            _state = xkb_state_new(_keymap);
+            if (_state == IntPtr.Zero)
+                throw new InvalidOperationException("Failed to create xkb state");
+        }
+        catch
+        {
+            Dispose();
+            throw;
+        }
+        finally
+        {
+            UnsafeNativeMethods.munmap(mapped, (IntPtr)size);
+        }
+    }
+
+    /// <summary>
+    /// Number of keyboard layout groups in this keymap.
+    /// </summary>
+    public uint LayoutCount => _keymap != IntPtr.Zero ? xkb_keymap_num_layouts(_keymap) : 0;
+
+    /// <summary>
+    /// Updates the keyboard state with new modifier and group values from wl_keyboard.modifiers.
+    /// </summary>
+    public void UpdateModifiers(uint modsDepressed, uint modsLatched, uint modsLocked, uint group)
+    {
+        if (_state != IntPtr.Zero)
+            xkb_state_update_mask(_state, modsDepressed, modsLatched, modsLocked, 0, 0, group);
+    }
+
+    /// <summary>
+    /// Resolves an evdev keycode to a keysym and UTF-8 text using the current xkb state.
+    /// </summary>
+    /// <param name="evdevKeycode">The evdev keycode (NOT xkb keycode — offset +8 is applied internally).</param>
+    /// <returns>The keysym and the UTF-8 text produced by the key, or null if no text.</returns>
+    public (uint keysym, string? text) ResolveKey(uint evdevKeycode)
+    {
+        if (_state == IntPtr.Zero)
+            return (0, null);
+
+        var xkbKey = evdevKeycode + 8;
+        var keysym = xkb_state_key_get_one_sym(_state, xkbKey);
+
+        // Get UTF-8 text: first call with null to get required size
+        var needed = xkb_state_key_get_utf8(_state, xkbKey, null, IntPtr.Zero);
+        if (needed <= 0)
+            return (keysym, null);
+
+        // Allocate buffer (+1 for null terminator written by xkbcommon)
+        var bufSize = needed + 1;
+        var buf = stackalloc byte[bufSize];
+        xkb_state_key_get_utf8(_state, xkbKey, buf, (IntPtr)bufSize);
+
+        var text = Encoding.UTF8.GetString(buf, needed);
+        return (keysym, text);
+    }
+
+    /// <summary>
+    /// Gets the keysym for a key in a specific layout group at level 0 (base level).
+    /// Used for non-latin keyboard fallback — cycling through layouts to find a latin key.
+    /// </summary>
+    /// <param name="evdevKeycode">The evdev keycode.</param>
+    /// <param name="layout">The layout group index.</param>
+    /// <returns>The keysym, or 0 if not found.</returns>
+    public uint FindKeysymInLayout(uint evdevKeycode, uint layout)
+    {
+        if (_keymap == IntPtr.Zero)
+            return 0;
+
+        var xkbKey = evdevKeycode + 8;
+        var count = xkb_keymap_key_get_syms_by_level(_keymap, xkbKey, layout, 0, out var syms);
+        if (count > 0 && syms != null)
+            return syms[0];
+
+        return 0;
+    }
+
+    public void Dispose()
+    {
+        if (_state != IntPtr.Zero)
+        {
+            xkb_state_unref(_state);
+            _state = IntPtr.Zero;
+        }
+
+        if (_keymap != IntPtr.Zero)
+        {
+            xkb_keymap_unref(_keymap);
+            _keymap = IntPtr.Zero;
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/XkbComposeState.cs b/src/Avalonia.Wayland/XkbComposeState.cs
new file mode 100644
index 0000000000..7e79dfeb74
--- /dev/null
+++ b/src/Avalonia.Wayland/XkbComposeState.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Text;
+using static Avalonia.Wayland.Server.Interop.XkbCommonNativeMethods;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// Wraps an xkb_compose_state for tracking compose/dead key sequences.
+/// </summary>
+sealed unsafe class XkbComposeState : IDisposable
+{
+    private IntPtr _state;
+
+    public XkbComposeState(XkbComposeTable table)
+    {
+        _state = xkb_compose_state_new(table.Handle, XKB_COMPOSE_STATE_NO_FLAGS);
+        if (_state == IntPtr.Zero)
+            throw new InvalidOperationException("Failed to create xkb compose state");
+    }
+
+    /// <summary>
+    /// Feeds a keysym to the compose state machine.
+    /// Returns the compose status after feeding.
+    /// </summary>
+    public int Feed(uint keysym)
+    {
+        if (_state == IntPtr.Zero)
+            return XKB_COMPOSE_NOTHING;
+
+        xkb_compose_state_feed(_state, keysym);
+        return xkb_compose_state_get_status(_state);
+    }
+
+    /// <summary>
+    /// Gets the composed UTF-8 text. Only valid when status is XKB_COMPOSE_COMPOSED.
+    /// </summary>
+    public string? GetComposedText()
+    {
+        if (_state == IntPtr.Zero)
+            return null;
+
+        var needed = xkb_compose_state_get_utf8(_state, null, IntPtr.Zero);
+        if (needed <= 0)
+            return null;
+
+        var bufSize = needed + 1;
+        // Compose results are tiny in practice, but `needed` comes from native code and is
+        // technically unbounded, so fall back to the heap past a small stack threshold.
+        Span<byte> buf = bufSize <= 256 ? stackalloc byte[256] : new byte[bufSize];
+        fixed (byte* bufPtr = buf)
+            xkb_compose_state_get_utf8(_state, bufPtr, (IntPtr)bufSize);
+
+        return Encoding.UTF8.GetString(buf.Slice(0, needed));
+    }
+
+    /// <summary>
+    /// Gets the composed keysym. Only valid when status is XKB_COMPOSE_COMPOSED.
+    /// </summary>
+    public uint GetComposedKeysym()
+    {
+        if (_state == IntPtr.Zero)
+            return 0;
+
+        return xkb_compose_state_get_one_sym(_state);
+    }
+
+    public void Reset()
+    {
+        if (_state != IntPtr.Zero)
+            xkb_compose_state_reset(_state);
+    }
+
+    public void Dispose()
+    {
+        if (_state != IntPtr.Zero)
+        {
+            xkb_compose_state_unref(_state);
+            _state = IntPtr.Zero;
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/XkbComposeTable.cs b/src/Avalonia.Wayland/XkbComposeTable.cs
new file mode 100644
index 0000000000..52e24e1a58
--- /dev/null
+++ b/src/Avalonia.Wayland/XkbComposeTable.cs
@@ -0,0 +1,42 @@
+using System;
+using static Avalonia.Wayland.Server.Interop.XkbCommonNativeMethods;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// Wraps an xkb_compose_table loaded from the system locale.
+/// </summary>
+sealed class XkbComposeTable : IDisposable
+{
+    public IntPtr Handle { get; private set; }
+
+    private XkbComposeTable(IntPtr handle)
+    {
+        Handle = handle;
+    }
+
+    /// <summary>
+    /// Creates a compose table from the system locale, or returns null if unavailable.
+    /// </summary>
+    public static XkbComposeTable? TryCreate(XkbContext context)
+    {
+        var locale = Environment.GetEnvironmentVariable("LC_ALL")
+                     ?? Environment.GetEnvironmentVariable("LC_CTYPE")
+                     ?? Environment.GetEnvironmentVariable("LANG")
+                     ?? "C";
+
+        var handle = xkb_compose_table_new_from_locale(
+            context.Handle, locale, XKB_COMPOSE_COMPILE_NO_FLAGS);
+
+        return handle == IntPtr.Zero ? null : new XkbComposeTable(handle);
+    }
+
+    public void Dispose()
+    {
+        if (Handle != IntPtr.Zero)
+        {
+            xkb_compose_table_unref(Handle);
+            Handle = IntPtr.Zero;
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/XkbContext.cs b/src/Avalonia.Wayland/XkbContext.cs
new file mode 100644
index 0000000000..663cffb185
--- /dev/null
+++ b/src/Avalonia.Wayland/XkbContext.cs
@@ -0,0 +1,28 @@
+using System;
+using static Avalonia.Wayland.Server.Interop.XkbCommonNativeMethods;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// Wraps an xkb_context, shared by XkbCommonKeymap and XkbComposeTable.
+/// </summary>
+sealed class XkbContext : IDisposable
+{
+    public IntPtr Handle { get; private set; }
+
+    public XkbContext()
+    {
+        Handle = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+        if (Handle == IntPtr.Zero)
+            throw new InvalidOperationException("Failed to create xkb context");
+    }
+
+    public void Dispose()
+    {
+        if (Handle != IntPtr.Zero)
+        {
+            xkb_context_unref(Handle);
+            Handle = IntPtr.Zero;
+        }
+    }
+}
diff --git a/src/Avalonia.Wayland/XkbKeyTransform.cs b/src/Avalonia.Wayland/XkbKeyTransform.cs
new file mode 100644
index 0000000000..801c4be822
--- /dev/null
+++ b/src/Avalonia.Wayland/XkbKeyTransform.cs
@@ -0,0 +1,580 @@
+using System.Collections.Generic;
+using Avalonia.Input;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// Maps evdev keycodes and XKB keysyms to Avalonia Key and PhysicalKey values.
+/// </summary>
+internal static class XkbKeyTransform
+{
+    // evdev keycode → Avalonia Key
+    // Based on linux/input-event-codes.h
+    private static readonly Dictionary<uint, Key> s_keyFromEvdev = new(128)
+    {
+        { 1, Key.Escape },
+        { 2, Key.D1 },
+        { 3, Key.D2 },
+        { 4, Key.D3 },
+        { 5, Key.D4 },
+        { 6, Key.D5 },
+        { 7, Key.D6 },
+        { 8, Key.D7 },
+        { 9, Key.D8 },
+        { 10, Key.D9 },
+        { 11, Key.D0 },
+        { 12, Key.OemMinus },
+        { 13, Key.OemPlus },
+        { 14, Key.Back },
+        { 15, Key.Tab },
+        { 16, Key.Q },
+        { 17, Key.W },
+        { 18, Key.E },
+        { 19, Key.R },
+        { 20, Key.T },
+        { 21, Key.Y },
+        { 22, Key.U },
+        { 23, Key.I },
+        { 24, Key.O },
+        { 25, Key.P },
+        { 26, Key.OemOpenBrackets },
+        { 27, Key.OemCloseBrackets },
+        { 28, Key.Return },
+        { 29, Key.LeftCtrl },
+        { 30, Key.A },
+        { 31, Key.S },
+        { 32, Key.D },
+        { 33, Key.F },
+        { 34, Key.G },
+        { 35, Key.H },
+        { 36, Key.J },
+        { 37, Key.K },
+        { 38, Key.L },
+        { 39, Key.OemSemicolon },
+        { 40, Key.OemQuotes },
+        { 41, Key.OemTilde },
+        { 42, Key.LeftShift },
+        { 43, Key.OemPipe },
+        { 44, Key.Z },
+        { 45, Key.X },
+        { 46, Key.C },
+        { 47, Key.V },
+        { 48, Key.B },
+        { 49, Key.N },
+        { 50, Key.M },
+        { 51, Key.OemComma },
+        { 52, Key.OemPeriod },
+        { 53, Key.Oem2 },       // Slash
+        { 54, Key.RightShift },
+        { 55, Key.Multiply },   // KP_Multiply
+        { 56, Key.LeftAlt },
+        { 57, Key.Space },
+        { 58, Key.CapsLock },
+        { 59, Key.F1 },
+        { 60, Key.F2 },
+        { 61, Key.F3 },
+        { 62, Key.F4 },
+        { 63, Key.F5 },
+        { 64, Key.F6 },
+        { 65, Key.F7 },
+        { 66, Key.F8 },
+        { 67, Key.F9 },
+        { 68, Key.F10 },
+        { 69, Key.NumLock },
+        { 70, Key.Scroll },
+        { 71, Key.NumPad7 },
+        { 72, Key.NumPad8 },
+        { 73, Key.NumPad9 },
+        { 74, Key.Subtract },
+        { 75, Key.NumPad4 },
+        { 76, Key.NumPad5 },
+        { 77, Key.NumPad6 },
+        { 78, Key.Add },
+        { 79, Key.NumPad1 },
+        { 80, Key.NumPad2 },
+        { 81, Key.NumPad3 },
+        { 82, Key.NumPad0 },
+        { 83, Key.Decimal },
+        { 87, Key.F11 },
+        { 88, Key.F12 },
+        { 96, Key.Return },     // KP_Enter
+        { 97, Key.RightCtrl },
+        { 98, Key.Divide },     // KP_Divide
+        { 99, Key.Print },      // SysRq / PrintScreen
+        { 100, Key.RightAlt },
+        { 102, Key.Home },
+        { 103, Key.Up },
+        { 104, Key.Prior },     // PageUp
+        { 105, Key.Left },
+        { 106, Key.Right },
+        { 107, Key.End },
+        { 108, Key.Down },
+        { 109, Key.PageDown },
+        { 110, Key.Insert },
+        { 111, Key.Delete },
+        { 113, Key.None },      // Mute (media)
+        { 114, Key.None },      // VolumeDown
+        { 115, Key.None },      // VolumeUp
+        { 119, Key.Pause },
+        { 125, Key.LWin },
+        { 126, Key.RWin },
+        { 127, Key.Apps },      // Compose / Menu
+        { 183, Key.F13 },
+        { 184, Key.F14 },
+        { 185, Key.F15 },
+        { 186, Key.F16 },
+        { 187, Key.F17 },
+        { 188, Key.F18 },
+        { 189, Key.F19 },
+        { 190, Key.F20 },
+        { 191, Key.F21 },
+        { 192, Key.F22 },
+        { 193, Key.F23 },
+        { 194, Key.F24 },
+    };
+
+    // evdev keycode → PhysicalKey
+    // Adapted from X11KeyTransform.s_physicalKeyFromScanCode by subtracting 8 from X11 scancodes.
+    private static readonly Dictionary<uint, PhysicalKey> s_physicalKeyFromEvdev = new(162)
+    {
+        // Writing System Keys
+        { 41, PhysicalKey.Backquote },
+        { 43, PhysicalKey.Backslash },
+        { 26, PhysicalKey.BracketLeft },
+        { 27, PhysicalKey.BracketRight },
+        { 51, PhysicalKey.Comma },
+        { 11, PhysicalKey.Digit0 },
+        { 2, PhysicalKey.Digit1 },
+        { 3, PhysicalKey.Digit2 },
+        { 4, PhysicalKey.Digit3 },
+        { 5, PhysicalKey.Digit4 },
+        { 6, PhysicalKey.Digit5 },
+        { 7, PhysicalKey.Digit6 },
+        { 8, PhysicalKey.Digit7 },
+        { 9, PhysicalKey.Digit8 },
+        { 10, PhysicalKey.Digit9 },
+        { 13, PhysicalKey.Equal },
+        { 86, PhysicalKey.IntlBackslash },
+        { 89, PhysicalKey.IntlRo },
+        { 124, PhysicalKey.IntlYen },
+        { 30, PhysicalKey.A },
+        { 48, PhysicalKey.B },
+        { 46, PhysicalKey.C },
+        { 32, PhysicalKey.D },
+        { 18, PhysicalKey.E },
+        { 33, PhysicalKey.F },
+        { 34, PhysicalKey.G },
+        { 35, PhysicalKey.H },
+        { 23, PhysicalKey.I },
+        { 36, PhysicalKey.J },
+        { 37, PhysicalKey.K },
+        { 38, PhysicalKey.L },
+        { 50, PhysicalKey.M },
+        { 49, PhysicalKey.N },
+        { 24, PhysicalKey.O },
+        { 25, PhysicalKey.P },
+        { 16, PhysicalKey.Q },
+        { 19, PhysicalKey.R },
+        { 31, PhysicalKey.S },
+        { 20, PhysicalKey.T },
+        { 22, PhysicalKey.U },
+        { 47, PhysicalKey.V },
+        { 17, PhysicalKey.W },
+        { 45, PhysicalKey.X },
+        { 21, PhysicalKey.Y },
+        { 44, PhysicalKey.Z },
+        { 12, PhysicalKey.Minus },
+        { 52, PhysicalKey.Period },
+        { 40, PhysicalKey.Quote },
+        { 39, PhysicalKey.Semicolon },
+        { 53, PhysicalKey.Slash },
+
+        // Functional Keys
+        { 56, PhysicalKey.AltLeft },
+        { 100, PhysicalKey.AltRight },
+        { 14, PhysicalKey.Backspace },
+        { 58, PhysicalKey.CapsLock },
+        { 127, PhysicalKey.ContextMenu },
+        { 29, PhysicalKey.ControlLeft },
+        { 97, PhysicalKey.ControlRight },
+        { 28, PhysicalKey.Enter },
+        { 125, PhysicalKey.MetaLeft },
+        { 126, PhysicalKey.MetaRight },
+        { 42, PhysicalKey.ShiftLeft },
+        { 54, PhysicalKey.ShiftRight },
+        { 57, PhysicalKey.Space },
+        { 15, PhysicalKey.Tab },
+        { 92, PhysicalKey.Convert },
+        { 93, PhysicalKey.KanaMode },
+        { 122, PhysicalKey.Lang1 },
+        { 123, PhysicalKey.Lang2 },
+        { 90, PhysicalKey.Lang3 },
+        { 91, PhysicalKey.Lang4 },
+        { 85, PhysicalKey.Lang5 },
+        { 94, PhysicalKey.NonConvert },
+
+        // Control Pad Section
+        { 111, PhysicalKey.Delete },
+        { 107, PhysicalKey.End },
+        { 138, PhysicalKey.Help },
+        { 102, PhysicalKey.Home },
+        { 110, PhysicalKey.Insert },
+        { 109, PhysicalKey.PageDown },
+        { 104, PhysicalKey.PageUp },
+
+        // Arrow Pad Section
+        { 108, PhysicalKey.ArrowDown },
+        { 105, PhysicalKey.ArrowLeft },
+        { 106, PhysicalKey.ArrowRight },
+        { 103, PhysicalKey.ArrowUp },
+
+        // Numpad Section
+        { 69, PhysicalKey.NumLock },
+        { 82, PhysicalKey.NumPad0 },
+        { 79, PhysicalKey.NumPad1 },
+        { 80, PhysicalKey.NumPad2 },
+        { 81, PhysicalKey.NumPad3 },
+        { 75, PhysicalKey.NumPad4 },
+        { 76, PhysicalKey.NumPad5 },
+        { 77, PhysicalKey.NumPad6 },
+        { 71, PhysicalKey.NumPad7 },
+        { 72, PhysicalKey.NumPad8 },
+        { 73, PhysicalKey.NumPad9 },
+        { 78, PhysicalKey.NumPadAdd },
+        { 121, PhysicalKey.NumPadComma },
+        { 83, PhysicalKey.NumPadDecimal },
+        { 98, PhysicalKey.NumPadDivide },
+        { 96, PhysicalKey.NumPadEnter },
+        { 117, PhysicalKey.NumPadEqual },
+        { 55, PhysicalKey.NumPadMultiply },
+        { 179, PhysicalKey.NumPadParenLeft },
+        { 180, PhysicalKey.NumPadParenRight },
+        { 74, PhysicalKey.NumPadSubtract },
+
+        // Function Section
+        { 1, PhysicalKey.Escape },
+        { 59, PhysicalKey.F1 },
+        { 60, PhysicalKey.F2 },
+        { 61, PhysicalKey.F3 },
+        { 62, PhysicalKey.F4 },
+        { 63, PhysicalKey.F5 },
+        { 64, PhysicalKey.F6 },
+        { 65, PhysicalKey.F7 },
+        { 66, PhysicalKey.F8 },
+        { 67, PhysicalKey.F9 },
+        { 68, PhysicalKey.F10 },
+        { 87, PhysicalKey.F11 },
+        { 88, PhysicalKey.F12 },
+        { 183, PhysicalKey.F13 },
+        { 184, PhysicalKey.F14 },
+        { 185, PhysicalKey.F15 },
+        { 186, PhysicalKey.F16 },
+        { 187, PhysicalKey.F17 },
+        { 188, PhysicalKey.F18 },
+        { 189, PhysicalKey.F19 },
+        { 190, PhysicalKey.F20 },
+        { 191, PhysicalKey.F21 },
+        { 192, PhysicalKey.F22 },
+        { 193, PhysicalKey.F23 },
+        { 194, PhysicalKey.F24 },
+        { 99, PhysicalKey.PrintScreen },
+        { 70, PhysicalKey.ScrollLock },
+        { 119, PhysicalKey.Pause },
+
+        // Media Keys
+        { 158, PhysicalKey.BrowserBack },
+        { 156, PhysicalKey.BrowserFavorites },
+        { 159, PhysicalKey.BrowserForward },
+        { 172, PhysicalKey.BrowserHome },
+        { 173, PhysicalKey.BrowserRefresh },
+        { 217, PhysicalKey.BrowserSearch },
+        { 128, PhysicalKey.BrowserStop },
+        { 161, PhysicalKey.Eject },
+        { 144, PhysicalKey.LaunchApp1 },
+        { 140, PhysicalKey.LaunchApp2 },
+        { 155, PhysicalKey.LaunchMail },
+        { 164, PhysicalKey.MediaPlayPause },
+        { 171, PhysicalKey.MediaSelect },
+        { 166, PhysicalKey.MediaStop },
+        { 163, PhysicalKey.MediaTrackNext },
+        { 165, PhysicalKey.MediaTrackPrevious },
+        { 116, PhysicalKey.Power },
+        { 142, PhysicalKey.Sleep },
+        { 114, PhysicalKey.AudioVolumeDown },
+        { 113, PhysicalKey.AudioVolumeMute },
+        { 115, PhysicalKey.AudioVolumeUp },
+        { 143, PhysicalKey.WakeUp },
+
+        // Legacy Keys
+        { 129, PhysicalKey.Again },
+        { 133, PhysicalKey.Copy },
+        { 137, PhysicalKey.Cut },
+        { 136, PhysicalKey.Find },
+        { 134, PhysicalKey.Open },
+        { 135, PhysicalKey.Paste },
+        { 132, PhysicalKey.Select },
+        { 131, PhysicalKey.Undo }
+    };
+
+    public static Key KeyFromEvdev(uint evdevCode)
+        => s_keyFromEvdev.TryGetValue(evdevCode, out var result) ? result : Key.None;
+
+    public static PhysicalKey PhysicalKeyFromEvdev(uint evdevCode)
+        => s_physicalKeyFromEvdev.TryGetValue(evdevCode, out var result) ? result : PhysicalKey.None;
+
+    public static Key KeyFromKeysym(uint keysym)
+        => s_keyFromKeysym.TryGetValue(keysym, out var result) ? result : Key.None;
+
+    /// <summary>
+    /// Full key resolution with non-latin keyboard fallback.
+    /// Mirrors X11's LookupKey/LookUpKeyXkb behavior:
+    /// 1. Try current layout keysym → Key
+    /// 2. Digit keys always forced to QWERTY (matching Windows/macOS)
+    /// 3. If Key.None, cycle other layout groups to find a latin key
+    /// 4. Ultimate fallback to PhysicalKey.ToQwertyKey()
+    /// </summary>
+    public static (Key key, string? keySymbol) ResolveKeyWithFallback(
+        XkbCommonKeymap keymap, uint evdevKeycode, PhysicalKey physicalKey)
+    {
+        var (keysym, text) = keymap.ResolveKey(evdevKeycode);
+        var keySymbol = FilterKeySymbol(text);
+
+        // Always use digit keys from QWERTY, matching Windows/macOS
+        if (physicalKey is >= PhysicalKey.Digit0 and <= PhysicalKey.Digit9)
+            return (physicalKey.ToQwertyKey(), keySymbol);
+
+        var key = KeyFromKeysym(keysym);
+        if (key != Key.None)
+            return (key, keySymbol);
+
+        // Non-latin fallback: cycle through other layout groups
+        var layoutCount = keymap.LayoutCount;
+        for (uint layout = 0; layout < layoutCount; layout++)
+        {
+            var groupKeysym = keymap.FindKeysymInLayout(evdevKeycode, layout);
+            if (groupKeysym != 0)
+            {
+                key = KeyFromKeysym(groupKeysym);
+                if (key != Key.None)
+                    return (key, keySymbol);
+            }
+        }
+
+        // Ultimate fallback: QWERTY physical key mapping
+        if (keysym != 0)
+            return (physicalKey.ToQwertyKey(), keySymbol);
+
+        return (Key.None, keySymbol);
+    }
+
+    internal static string? FilterKeySymbol(string? text)
+    {
+        if (text is null || text.Length == 0)
+            return null;
+
+        if (text.Length == 1)
+        {
+            var c = text[0];
+            // Reject control characters and DEL
+            if (c < ' ' && c != '\b' && c != '\t' && c != '\r' && c != '\x1b')
+                return null;
+            if (c == '\x7f')
+                return null;
+        }
+
+        return text;
+    }
+
+    // XKB keysym → Avalonia Key
+    // Keysym values are identical to X11 keysym values (from xkbcommon-keysyms.h / keysymdef.h)
+    private static readonly Dictionary<uint, Key> s_keyFromKeysym = new(200)
+    {
+        // Function/control keys (0xff00+ range)
+        { 0xff69, Key.Cancel },       // XKB_KEY_Cancel
+        { 0xff08, Key.Back },         // XKB_KEY_BackSpace
+        { 0xff09, Key.Tab },          // XKB_KEY_Tab
+        { 0xff0a, Key.LineFeed },     // XKB_KEY_Linefeed
+        { 0xff0b, Key.Clear },        // XKB_KEY_Clear
+        { 0xff0d, Key.Return },       // XKB_KEY_Return
+        { 0xff8d, Key.Return },       // XKB_KEY_KP_Enter
+        { 0xff13, Key.Pause },        // XKB_KEY_Pause
+        { 0xffe5, Key.CapsLock },     // XKB_KEY_Caps_Lock
+        { 0xff1b, Key.Escape },       // XKB_KEY_Escape
+        { 0x0020, Key.Space },        // XKB_KEY_space
+        { 0xff55, Key.Prior },        // XKB_KEY_Prior / Page_Up
+        { 0xff9a, Key.Prior },        // XKB_KEY_KP_Prior
+        { 0xff56, Key.PageDown },     // XKB_KEY_Next / Page_Down
+        { 0xff9b, Key.PageDown },     // XKB_KEY_KP_Next
+        { 0xff57, Key.End },          // XKB_KEY_End
+        { 0xff9c, Key.End },          // XKB_KEY_KP_End
+        { 0xff50, Key.Home },         // XKB_KEY_Home
+        { 0xff95, Key.Home },         // XKB_KEY_KP_Home
+        { 0xff51, Key.Left },         // XKB_KEY_Left
+        { 0xff96, Key.Left },         // XKB_KEY_KP_Left
+        { 0xff52, Key.Up },           // XKB_KEY_Up
+        { 0xff97, Key.Up },           // XKB_KEY_KP_Up
+        { 0xff53, Key.Right },        // XKB_KEY_Right
+        { 0xff98, Key.Right },        // XKB_KEY_KP_Right
+        { 0xff54, Key.Down },         // XKB_KEY_Down
+        { 0xff99, Key.Down },         // XKB_KEY_KP_Down
+        { 0xff60, Key.Select },       // XKB_KEY_Select
+        { 0xff61, Key.Print },        // XKB_KEY_Print
+        { 0xff62, Key.Execute },      // XKB_KEY_Execute
+        { 0xff63, Key.Insert },       // XKB_KEY_Insert
+        { 0xff9e, Key.Insert },       // XKB_KEY_KP_Insert
+        { 0xffff, Key.Delete },       // XKB_KEY_Delete
+        { 0xff9f, Key.Delete },       // XKB_KEY_KP_Delete
+        { 0xff6a, Key.Help },         // XKB_KEY_Help
+
+        // Latin uppercase (A-Z, 0x41-0x5a)
+        { 0x0041, Key.A },
+        { 0x0042, Key.B },
+        { 0x0043, Key.C },
+        { 0x0044, Key.D },
+        { 0x0045, Key.E },
+        { 0x0046, Key.F },
+        { 0x0047, Key.G },
+        { 0x0048, Key.H },
+        { 0x0049, Key.I },
+        { 0x004a, Key.J },
+        { 0x004b, Key.K },
+        { 0x004c, Key.L },
+        { 0x004d, Key.M },
+        { 0x004e, Key.N },
+        { 0x004f, Key.O },
+        { 0x0050, Key.P },
+        { 0x0051, Key.Q },
+        { 0x0052, Key.R },
+        { 0x0053, Key.S },
+        { 0x0054, Key.T },
+        { 0x0055, Key.U },
+        { 0x0056, Key.V },
+        { 0x0057, Key.W },
+        { 0x0058, Key.X },
+        { 0x0059, Key.Y },
+        { 0x005a, Key.Z },
+
+        // Latin lowercase (a-z, 0x61-0x7a)
+        { 0x0061, Key.A },
+        { 0x0062, Key.B },
+        { 0x0063, Key.C },
+        { 0x0064, Key.D },
+        { 0x0065, Key.E },
+        { 0x0066, Key.F },
+        { 0x0067, Key.G },
+        { 0x0068, Key.H },
+        { 0x0069, Key.I },
+        { 0x006a, Key.J },
+        { 0x006b, Key.K },
+        { 0x006c, Key.L },
+        { 0x006d, Key.M },
+        { 0x006e, Key.N },
+        { 0x006f, Key.O },
+        { 0x0070, Key.P },
+        { 0x0071, Key.Q },
+        { 0x0072, Key.R },
+        { 0x0073, Key.S },
+        { 0x0074, Key.T },
+        { 0x0075, Key.U },
+        { 0x0076, Key.V },
+        { 0x0077, Key.W },
+        { 0x0078, Key.X },
+        { 0x0079, Key.Y },
+        { 0x007a, Key.Z },
+
+        // Super / Meta / Apps
+        { 0xffeb, Key.LWin },         // XKB_KEY_Super_L
+        { 0xffec, Key.RWin },         // XKB_KEY_Super_R
+        { 0xff67, Key.Apps },         // XKB_KEY_Menu
+
+        // Numpad
+        { 0xffb0, Key.NumPad0 },      // XKB_KEY_KP_0
+        { 0xffb1, Key.NumPad1 },
+        { 0xffb2, Key.NumPad2 },
+        { 0xffb3, Key.NumPad3 },
+        { 0xffb4, Key.NumPad4 },
+        { 0xffb5, Key.NumPad5 },
+        { 0xffb6, Key.NumPad6 },
+        { 0xffb7, Key.NumPad7 },
+        { 0xffb8, Key.NumPad8 },
+        { 0xffb9, Key.NumPad9 },      // XKB_KEY_KP_9
+        { 0x002a, Key.Multiply },     // asterisk
+        { 0xffaa, Key.Multiply },     // XKB_KEY_KP_Multiply
+        { 0xffab, Key.Add },          // XKB_KEY_KP_Add
+        { 0xffad, Key.Subtract },     // XKB_KEY_KP_Subtract
+        { 0xffae, Key.Decimal },      // XKB_KEY_KP_Decimal
+        { 0xffaf, Key.Divide },       // XKB_KEY_KP_Divide
+
+        // Function keys
+        { 0xffbe, Key.F1 },
+        { 0xffbf, Key.F2 },
+        { 0xffc0, Key.F3 },
+        { 0xffc1, Key.F4 },
+        { 0xffc2, Key.F5 },
+        { 0xffc3, Key.F6 },
+        { 0xffc4, Key.F7 },
+        { 0xffc5, Key.F8 },
+        { 0xffc6, Key.F9 },
+        { 0xffc7, Key.F10 },
+        { 0xffc8, Key.F11 },
+        { 0xffc9, Key.F12 },
+        { 0xffca, Key.F13 },
+        { 0xffcb, Key.F14 },
+        { 0xffcc, Key.F15 },
+        { 0xffcd, Key.F16 },
+        { 0xffce, Key.F17 },
+        { 0xffcf, Key.F18 },
+        { 0xffd0, Key.F19 },
+        { 0xffd1, Key.F20 },
+        { 0xffd2, Key.F21 },
+        { 0xffd3, Key.F22 },
+        { 0xffd4, Key.F23 },
+        { 0xffd5, Key.F24 },
+
+        // Lock / modifier keys
+        { 0xff7f, Key.NumLock },      // XKB_KEY_Num_Lock
+        { 0xff14, Key.Scroll },       // XKB_KEY_Scroll_Lock
+        { 0xffe1, Key.LeftShift },    // XKB_KEY_Shift_L
+        { 0xffe2, Key.RightShift },   // XKB_KEY_Shift_R
+        { 0xffe3, Key.LeftCtrl },     // XKB_KEY_Control_L
+        { 0xffe4, Key.RightCtrl },    // XKB_KEY_Control_R
+        { 0xffe9, Key.LeftAlt },      // XKB_KEY_Alt_L
+        { 0xffea, Key.RightAlt },     // XKB_KEY_Alt_R
+
+        // Punctuation / OEM keys
+        { 0x002d, Key.OemMinus },     // minus
+        { 0x005f, Key.OemMinus },     // underscore
+        { 0x002b, Key.OemPlus },      // plus
+        { 0x003d, Key.OemPlus },      // equal
+        { 0x005b, Key.OemOpenBrackets },  // bracketleft
+        { 0x007b, Key.OemOpenBrackets },  // braceleft
+        { 0x005d, Key.OemCloseBrackets }, // bracketright
+        { 0x007d, Key.OemCloseBrackets }, // braceright
+        { 0x005c, Key.OemPipe },      // backslash
+        { 0x007c, Key.OemPipe },      // bar
+        { 0x003b, Key.OemSemicolon }, // semicolon
+        { 0x003a, Key.OemSemicolon }, // colon
+        { 0x0027, Key.OemQuotes },    // apostrophe
+        { 0x0022, Key.OemQuotes },    // quotedbl
+        { 0x002c, Key.OemComma },     // comma
+        { 0x003c, Key.OemComma },     // less
+        { 0x002e, Key.OemPeriod },    // period
+        { 0x003e, Key.OemPeriod },    // greater
+        { 0x002f, Key.Oem2 },        // slash
+        { 0x003f, Key.Oem2 },        // question
+        { 0x0060, Key.OemTilde },     // grave
+        { 0x007e, Key.OemTilde },     // asciitilde
+
+        // Digits (0-9)
+        { 0x0031, Key.D1 },
+        { 0x0032, Key.D2 },
+        { 0x0033, Key.D3 },
+        { 0x0034, Key.D4 },
+        { 0x0035, Key.D5 },
+        { 0x0036, Key.D6 },
+        { 0x0037, Key.D7 },
+        { 0x0038, Key.D8 },
+        { 0x0039, Key.D9 },
+        { 0x0030, Key.D0 },
+    };
+}
diff --git a/src/Shared/SourceGeneratorAttributes.cs b/src/Shared/SourceGeneratorAttributes.cs
index 6bc7b2bd36..6b52312132 100644
--- a/src/Shared/SourceGeneratorAttributes.cs
+++ b/src/Shared/SourceGeneratorAttributes.cs
@@ -52,6 +52,19 @@ namespace Avalonia.SourceGenerator
     {
     }
 
+    /// <summary>
+    /// When applied to a partial class or struct that declares a primary constructor,
+    /// generates a partial part exposing a getter-only property for every primary
+    /// constructor parameter, each initialized from that parameter
+    /// (e.g. <c>[DefinitelyNotARecord] partial class C(int Foo)</c> generates
+    /// <c>public int Foo { get; } = Foo;</c>). Unlike a record, this produces no
+    /// equality, <c>ToString</c>, deconstruction or copy members, keeping IL small.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct)]
+    internal sealed class DefinitelyNotARecordAttribute : Attribute
+    {
+    }
+
     [AttributeUsage(AttributeTargets.Interface, Inherited = false, AllowMultiple = false)]
     internal sealed class GenerateCrossThreadProxyAttribute : Attribute
     {
diff --git a/src/tools/DevGenerators/CrossThreadProxyGenerator.cs b/src/tools/DevGenerators/CrossThreadProxyGenerator.cs
index 53c27121ae..5c070b46bc 100644
--- a/src/tools/DevGenerators/CrossThreadProxyGenerator.cs
+++ b/src/tools/DevGenerators/CrossThreadProxyGenerator.cs
@@ -23,6 +23,14 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
     private const string ProxyAttributeName = "Avalonia.SourceGenerator.GenerateCrossThreadProxyAttribute";
     private const string ReturnTaskAttributeName = "global::Avalonia.SourceGenerator.GenerateCrossThreadProxyReturnTaskAttribute";
 
+    private static readonly DiagnosticDescriptor MarshallerMismatchDescriptor = new(
+        id: "AVPROXY001",
+        title: "Cross-thread proxy marshaller type mismatch",
+        messageFormat: "Parameter '{0}' of method '{1}' has type '{2}' which uses marshaller type '{3}', but the containing interface uses '{4}'. Interfaces with different marshaller types belong to different threads and cannot be passed across proxy boundaries.",
+        category: "Avalonia.SourceGenerator",
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
+
     public void Initialize(IncrementalGeneratorInitializationContext context)
     {
         var proxies = context.SyntaxProvider
@@ -35,6 +43,17 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
 
         context.RegisterSourceOutput(proxies, static (spc, model) =>
         {
+            foreach (var diag in model.Diagnostics)
+            {
+                spc.ReportDiagnostic(Diagnostic.Create(
+                    MarshallerMismatchDescriptor,
+                    Location.None,
+                    diag.ParamName,
+                    diag.MethodName,
+                    diag.ParamTypeFqn,
+                    diag.ParamMarshallerFqn,
+                    diag.ExpectedMarshallerFqn));
+            }
             var source = Render(model);
             spc.AddSource(model.HintName, source);
         });
@@ -103,6 +122,7 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
         }
 
         var methodsBuilder = ImmutableArray.CreateBuilder<MethodModel>();
+        var diagnosticsBuilder = ImmutableArray.CreateBuilder<ProxyDiagnosticInfo>();
         foreach (var member in iface.GetMembers())
         {
             if (member is not IMethodSymbol m || m.MethodKind != MethodKind.Ordinary)
@@ -124,7 +144,47 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
                     skip = true;
                     break;
                 }
-                paramsBuilder.Add(new ParamModel(p.Name, p.Type.GetFullyQualifiedName()));
+                var typeFqn = p.Type.GetFullyQualifiedName();
+                string? proxyClassFqn = null;
+                var isNullable = typeFqn.EndsWith("?");
+
+                if (p.Type is INamedTypeSymbol namedParamType
+                    && namedParamType.TypeKind == TypeKind.Interface)
+                {
+                    var paramProxyAttr = namedParamType.GetAttributes().FirstOrDefault(a =>
+                        a.AttributeClass?.ToDisplayString() == ProxyAttributeName);
+                    if (paramProxyAttr is not null
+                        && paramProxyAttr.ConstructorArguments.Length >= 2
+                        && paramProxyAttr.ConstructorArguments[0].Value is INamedTypeSymbol paramPriorityType)
+                    {
+                        var paramPriorityFqn = paramPriorityType.GetFullyQualifiedName();
+                        if (paramPriorityFqn != priorityFqn)
+                        {
+                            diagnosticsBuilder.Add(new ProxyDiagnosticInfo(
+                                m.Name,
+                                p.Name,
+                                namedParamType.ToDisplayString(),
+                                paramPriorityFqn,
+                                priorityFqn));
+                        }
+                        else
+                        {
+                            string? paramGenClassName = null;
+                            foreach (var na in paramProxyAttr.NamedArguments)
+                            {
+                                if (na.Key == "GeneratedClassName" && na.Value.Value is string s2)
+                                    paramGenClassName = s2;
+                            }
+                            var paramClassName = paramGenClassName ?? DefaultProxyName(namedParamType.Name);
+                            var paramNs = namedParamType.ContainingNamespace.IsGlobalNamespace
+                                ? null
+                                : namedParamType.ContainingNamespace.ToDisplayString();
+                            proxyClassFqn = "global::" + (paramNs is null ? paramClassName : paramNs + "." + paramClassName);
+                        }
+                    }
+                }
+
+                paramsBuilder.Add(new ParamModel(p.Name, typeFqn, proxyClassFqn, isNullable));
             }
             if (skip)
                 continue;
@@ -146,7 +206,8 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
             PriorityFqn: priorityFqn,
             DefaultPriorityExpression: defaultExpr,
             BaseProxyFqn: baseProxyFqn,
-            Methods: methodsBuilder.ToImmutable());
+            Methods: methodsBuilder.ToImmutable(),
+            Diagnostics: diagnosticsBuilder.ToImmutable());
     }
 
     private static string MethodSignature(IMethodSymbol m)
@@ -182,16 +243,13 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
         }
 
         sb.Append("internal class ").Append(m.ClassName);
-        var canImplementInterface = m.Methods.All(mm => !mm.WrapInTask);
+        // The proxy intentionally does NOT implement the proxied interface.
+        // Implementing it makes it dangerously easy to confuse proxy objects
+        // (which live on the caller's thread) with real implementations
+        // (which live on the target thread), leading to cross-thread bugs.
         if (m.BaseProxyFqn is not null)
         {
             sb.Append(" : ").Append(m.BaseProxyFqn);
-            if (canImplementInterface)
-                sb.Append(", ").Append(m.InterfaceFqn);
-        }
-        else if (canImplementInterface)
-        {
-            sb.Append(" : ").Append(m.InterfaceFqn);
         }
         sb.AppendLine();
         sb.AppendLine("{");
@@ -233,16 +291,24 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
     private static void RenderMethod(StringBuilder sb, ProxyModel m, MethodModel method)
     {
         var paramListNoPriority = string.Join(", ",
-            method.Parameters.Select(p => p.TypeFqn + " " + p.Name));
+            method.Parameters.Select(p =>
+                (p.ProxyClassFqn is not null
+                    ? p.ProxyClassFqn + (p.IsNullable ? "?" : "")
+                    : p.TypeFqn) + " " + p.Name));
         var paramListWithPriority = paramListNoPriority.Length > 0
             ? paramListNoPriority + ", " + m.PriorityFqn + " priority"
             : m.PriorityFqn + " priority";
 
-        var argList = string.Join(", ", method.Parameters.Select(p => p.Name));
-        var argListPlusDefaultPriority = argList.Length > 0
-            ? argList + ", " + m.DefaultPriorityExpression
+        var paramNames = string.Join(", ", method.Parameters.Select(p => p.Name));
+        var paramNamesWithDefaultPriority = paramNames.Length > 0
+            ? paramNames + ", " + m.DefaultPriorityExpression
             : m.DefaultPriorityExpression;
 
+        var dispatchArgs = string.Join(", ", method.Parameters.Select(p =>
+            p.ProxyClassFqn is not null
+                ? p.Name + (p.IsNullable ? "?" : "") + ".ProxyTarget"
+                : p.Name));
+
         string returnType;
         if (!method.WrapInTask)
             returnType = "void";
@@ -254,7 +320,7 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
         // Convenience overload — uses the configured default priority.
         sb.Pad(1).Append("public ").Append(returnType).Append(' ').Append(method.Name)
             .Append('(').Append(paramListNoPriority).Append(") => ")
-            .Append(method.Name).Append('(').Append(argListPlusDefaultPriority).AppendLine(");");
+            .Append(method.Name).Append('(').Append(paramNamesWithDefaultPriority).AppendLine(");");
         sb.AppendLine();
 
         sb.Pad(1).Append("public ").Append(returnType).Append(' ').Append(method.Name)
@@ -265,7 +331,7 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
         {
             // Fire-and-forget void.
             sb.Pad(2).Append("_marshaller(() => _target.").Append(method.Name)
-                .Append('(').Append(argList).AppendLine("), priority);");
+                .Append('(').Append(dispatchArgs).AppendLine("), priority);");
         }
         else
         {
@@ -284,13 +350,13 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
             sb.Pad(3).AppendLine("{");
             if (method.ReturnTypeFqn is null)
             {
-                sb.Pad(4).Append("_target.").Append(method.Name).Append('(').Append(argList).AppendLine(");");
+                sb.Pad(4).Append("_target.").Append(method.Name).Append('(').Append(dispatchArgs).AppendLine(");");
                 sb.Pad(4).AppendLine("tcs.TrySetResult(true);");
             }
             else
             {
                 sb.Pad(4).Append("var __result = _target.").Append(method.Name)
-                    .Append('(').Append(argList).AppendLine(");");
+                    .Append('(').Append(dispatchArgs).AppendLine(");");
                 sb.Pad(4).AppendLine("tcs.TrySetResult(__result);");
             }
             sb.Pad(3).AppendLine("}");
@@ -315,7 +381,8 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
         string PriorityFqn,
         string DefaultPriorityExpression,
         string? BaseProxyFqn,
-        ImmutableArray<MethodModel> Methods)
+        ImmutableArray<MethodModel> Methods,
+        ImmutableArray<ProxyDiagnosticInfo> Diagnostics)
     {
         public bool Equals(ProxyModel? other)
         {
@@ -327,7 +394,8 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
                 && PriorityFqn == other.PriorityFqn
                 && DefaultPriorityExpression == other.DefaultPriorityExpression
                 && BaseProxyFqn == other.BaseProxyFqn
-                && Methods.SequenceEqual(other.Methods);
+                && Methods.SequenceEqual(other.Methods)
+                && Diagnostics.SequenceEqual(other.Diagnostics);
         }
 
         public override int GetHashCode()
@@ -343,6 +411,7 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
                 h = h * 31 + (DefaultPriorityExpression?.GetHashCode() ?? 0);
                 h = h * 31 + (BaseProxyFqn?.GetHashCode() ?? 0);
                 foreach (var m in Methods) h = h * 31 + m.GetHashCode();
+                foreach (var d in Diagnostics) h = h * 31 + d.GetHashCode();
                 return h;
             }
         }
@@ -377,5 +446,12 @@ public sealed class CrossThreadProxyGenerator : IIncrementalGenerator
         }
     }
 
-    private sealed record ParamModel(string Name, string TypeFqn);
+    private sealed record ParamModel(string Name, string TypeFqn, string? ProxyClassFqn, bool IsNullable);
+
+    private sealed record ProxyDiagnosticInfo(
+        string MethodName,
+        string ParamName,
+        string ParamTypeFqn,
+        string ParamMarshallerFqn,
+        string ExpectedMarshallerFqn);
 }
diff --git a/src/tools/DevGenerators/DefinitelyNotARecordGenerator.cs b/src/tools/DevGenerators/DefinitelyNotARecordGenerator.cs
new file mode 100644
index 0000000000..8effe927d2
--- /dev/null
+++ b/src/tools/DevGenerators/DefinitelyNotARecordGenerator.cs
@@ -0,0 +1,126 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Generator;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace DevGenerators;
+
+[Generator(LanguageNames.CSharp)]
+public class DefinitelyNotARecordGenerator : IIncrementalGenerator
+{
+    const string AttributeFullName = "global::Avalonia.SourceGenerator.DefinitelyNotARecordAttribute";
+
+    public void Initialize(IncrementalGeneratorInitializationContext context)
+    {
+        var candidates = context.SyntaxProvider
+            .CreateSyntaxProvider(
+                static (s, _) => s is (ClassDeclarationSyntax or StructDeclarationSyntax)
+                                 and TypeDeclarationSyntax
+                                 {
+                                     AttributeLists.Count: > 0,
+                                     ParameterList: not null, // has a primary constructor
+                                 } td
+                                 && td.Modifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword)),
+                static (ctx, _) =>
+                    (INamedTypeSymbol)ctx.SemanticModel.GetDeclaredSymbol(ctx.Node)!)
+            .Where(s => s.HasAttributeWithFullyQualifiedName(AttributeFullName))
+            .Collect();
+
+        context.RegisterSourceOutput(candidates, static (context, types) =>
+        {
+            // The same partial type can be discovered through more than one declaration.
+            foreach (var type in types.Distinct<INamedTypeSymbol>(SymbolEqualityComparer.Default).Cast<INamedTypeSymbol>())
+                Generate(context, type);
+        });
+    }
+
+    static void Generate(SourceProductionContext context, INamedTypeSymbol type)
+    {
+        var primaryCtor = type.InstanceConstructors.FirstOrDefault(c =>
+            c.DeclaringSyntaxReferences.Any(r => r.GetSyntax() is TypeDeclarationSyntax));
+
+        if (primaryCtor is null || primaryCtor.Parameters.Length == 0)
+            return;
+
+        var sb = new StringBuilder();
+        sb.AppendLine("// <auto-generated/>");
+        sb.AppendLine("#nullable enable");
+
+        var ns = type.ContainingNamespace;
+        if (ns is { IsGlobalNamespace: false })
+            sb.Append("namespace ").Append(ns.ToDisplayString()).AppendLine();
+        else
+            sb.AppendLine();
+
+        sb.AppendLine("{");
+
+        // Re-open every enclosing type so the generated members land in the right nesting.
+        var nesting = new Stack<INamedTypeSymbol>();
+        for (var outer = type.ContainingType; outer is not null; outer = outer.ContainingType)
+            nesting.Push(outer);
+
+        var indent = 1;
+        foreach (var outer in nesting)
+        {
+            sb.Pad(indent).Append(DeclarationKeywords(outer)).Append(' ')
+                .Append(outer.Name).Append(TypeParameters(outer)).AppendLine();
+            sb.Pad(indent).AppendLine("{");
+            indent++;
+        }
+
+        sb.Pad(indent).Append(DeclarationKeywords(type)).Append(' ')
+            .Append(type.Name).Append(TypeParameters(type)).AppendLine();
+        sb.Pad(indent).AppendLine("{");
+
+        foreach (var parameter in primaryCtor.Parameters)
+        {
+            // Don't fight a property/field the user already declared by hand.
+            if (type.GetMembers(parameter.Name).Any(m => m is IPropertySymbol or IFieldSymbol))
+                continue;
+
+            sb.Pad(indent + 1)
+                .Append("public ")
+                .Append(parameter.Type.GetFullyQualifiedName())
+                .Append(' ')
+                .Append(parameter.Name)
+                .Append(" { get; } = ")
+                .Append(parameter.Name)
+                .AppendLine(";");
+        }
+
+        sb.Pad(indent).AppendLine("}");
+
+        for (; indent > 1; indent--)
+            sb.Pad(indent - 1).AppendLine("}");
+
+        sb.AppendLine("}");
+
+        context.AddSource(
+            type.GetFullyQualifiedName().Replace(":", "").Replace("<", "_").Replace(">", "_").Replace(", ", "_") + ".g.cs",
+            sb.ToString());
+    }
+
+    // The contextual `partial` keyword must appear immediately before the type
+    // keyword, so any other modifiers (readonly/ref) come first.
+    static string DeclarationKeywords(INamedTypeSymbol type)
+    {
+        if (!type.IsValueType)
+            return "partial class";
+
+        var sb = new StringBuilder();
+        if (type.IsReadOnly)
+            sb.Append("readonly ");
+        if (type.IsRefLikeType)
+            sb.Append("ref ");
+        sb.Append("partial struct");
+        return sb.ToString();
+    }
+
+    static string TypeParameters(INamedTypeSymbol type) =>
+        type.TypeParameters.Length == 0
+            ? string.Empty
+            : "<" + string.Join(", ", type.TypeParameters.Select(p => p.Name)) + ">";
+}
diff --git a/tests/Avalonia.Base.UnitTests/SourceGenerators/CrossThreadProxyGeneratorTests.cs b/tests/Avalonia.Base.UnitTests/SourceGenerators/CrossThreadProxyGeneratorTests.cs
index 795e11275a..b5c8f529ef 100644
--- a/tests/Avalonia.Base.UnitTests/SourceGenerators/CrossThreadProxyGeneratorTests.cs
+++ b/tests/Avalonia.Base.UnitTests/SourceGenerators/CrossThreadProxyGeneratorTests.cs
@@ -26,6 +26,19 @@ public class CrossThreadProxyGeneratorTests
         void AsyncFireAndForget(string s);
     }
 
+    [GenerateCrossThreadProxy(typeof(TestPriority), "Avalonia.Base.UnitTests.SourceGenerators.CrossThreadProxyGeneratorTests.TestPriority.Normal")]
+    public interface IProxiedDependency
+    {
+        void Execute(int value);
+    }
+
+    [GenerateCrossThreadProxy(typeof(TestPriority), "Avalonia.Base.UnitTests.SourceGenerators.CrossThreadProxyGeneratorTests.TestPriority.Normal")]
+    public interface IAcceptsProxiedParam
+    {
+        void ProcessDependency(IProxiedDependency dep);
+        void ProcessOptionalDependency(IProxiedDependency? dep);
+    }
+
     private sealed class Target : IDerivedProxied
     {
         public List<int> BaseCalls { get; } = new();
@@ -39,6 +52,25 @@ public class CrossThreadProxyGeneratorTests
         public void AsyncFireAndForget(string s) => AsyncCalls.Add(s);
     }
 
+    private sealed class ProxiedDependencyTarget : IProxiedDependency
+    {
+        public int LastValue;
+        public void Execute(int value) => LastValue = value;
+    }
+
+    private sealed class AcceptsProxiedParamTarget : IAcceptsProxiedParam
+    {
+        public IProxiedDependency? ReceivedDep;
+        public IProxiedDependency? ReceivedOptionalDep;
+        public bool OptionalWasCalled;
+        public void ProcessDependency(IProxiedDependency dep) => ReceivedDep = dep;
+        public void ProcessOptionalDependency(IProxiedDependency? dep)
+        {
+            ReceivedOptionalDep = dep;
+            OptionalWasCalled = true;
+        }
+    }
+
     private sealed class QueueMarshaller
     {
         public readonly Queue<(Action action, TestPriority priority)> Queue = new();
@@ -157,4 +189,57 @@ public class CrossThreadProxyGeneratorTests
         Assert.Equal(0, t.Counter);
         Assert.Equal(3, m.Queue.Count);
     }
+
+    [Fact]
+    public void Proxy_does_not_implement_proxied_interface()
+    {
+        Assert.False(typeof(IBaseProxied).IsAssignableFrom(typeof(BaseProxiedProxy)));
+        Assert.False(typeof(IDerivedProxied).IsAssignableFrom(typeof(DerivedProxiedProxy)));
+    }
+
+    [Fact]
+    public void Proxied_parameter_is_unwrapped_when_dispatching()
+    {
+        var depTarget = new ProxiedDependencyTarget();
+        var m = new QueueMarshaller();
+        var depProxy = new ProxiedDependencyProxy(depTarget, m.Post);
+
+        var acceptsTarget = new AcceptsProxiedParamTarget();
+        var acceptsProxy = new AcceptsProxiedParamProxy(acceptsTarget, m.Post);
+
+        acceptsProxy.ProcessDependency(depProxy);
+        m.DrainAll();
+
+        Assert.Same(depTarget, acceptsTarget.ReceivedDep);
+    }
+
+    [Fact]
+    public void Nullable_proxied_parameter_null_is_passed_through()
+    {
+        var acceptsTarget = new AcceptsProxiedParamTarget();
+        var m = new QueueMarshaller();
+        var acceptsProxy = new AcceptsProxiedParamProxy(acceptsTarget, m.Post);
+
+        acceptsProxy.ProcessOptionalDependency(null);
+        m.DrainAll();
+
+        Assert.True(acceptsTarget.OptionalWasCalled);
+        Assert.Null(acceptsTarget.ReceivedOptionalDep);
+    }
+
+    [Fact]
+    public void Nullable_proxied_parameter_proxy_is_unwrapped()
+    {
+        var depTarget = new ProxiedDependencyTarget();
+        var m = new QueueMarshaller();
+        var depProxy = new ProxiedDependencyProxy(depTarget, m.Post);
+
+        var acceptsTarget = new AcceptsProxiedParamTarget();
+        var acceptsProxy = new AcceptsProxiedParamProxy(acceptsTarget, m.Post);
+
+        acceptsProxy.ProcessOptionalDependency(depProxy);
+        m.DrainAll();
+
+        Assert.Same(depTarget, acceptsTarget.ReceivedOptionalDep);
+    }
 }
diff --git a/tests/Avalonia.Wayland.UnitTests/Avalonia.Wayland.UnitTests.csproj b/tests/Avalonia.Wayland.UnitTests/Avalonia.Wayland.UnitTests.csproj
new file mode 100644
index 0000000000..ed789a89a2
--- /dev/null
+++ b/tests/Avalonia.Wayland.UnitTests/Avalonia.Wayland.UnitTests.csproj
@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
+  <PropertyGroup>
+    <TargetFramework>$(AvsCurrentTargetFramework)</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <IsTestProject>true</IsTestProject>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <Import Project="..\..\build\UnitTests.NetCore.targets" />
+  <Import Project="..\..\build\XUnit.props" />
+  <Import Project="..\..\build\SharedVersion.props" />
+  <Import Project="..\..\build\NullableEnable.props" />
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Avalonia.Wayland\Avalonia.Wayland.csproj" />
+    <ProjectReference Include="..\Avalonia.UnitTests\Avalonia.UnitTests.csproj" />
+  </ItemGroup>
+</Project>
diff --git a/tests/Avalonia.Wayland.UnitTests/TextInputOptionsConverterTests.cs b/tests/Avalonia.Wayland.UnitTests/TextInputOptionsConverterTests.cs
new file mode 100644
index 0000000000..9ce6406d88
--- /dev/null
+++ b/tests/Avalonia.Wayland.UnitTests/TextInputOptionsConverterTests.cs
@@ -0,0 +1,83 @@
+using Avalonia.Input.TextInput;
+using NWayland.Protocols.TextInputUnstableV3;
+using Xunit;
+
+namespace Avalonia.Wayland.UnitTests;
+
+using Hint = ZwpTextInputV3.ContentHintEnum;
+using Purpose = ZwpTextInputV3.ContentPurposeEnum;
+
+public class TextInputOptionsConverterTests
+{
+    [Fact]
+    public void Default_IsNoneNormal()
+    {
+        var (h, p) = TextInputOptionsConverter.Convert(new TextInputOptions());
+        Assert.Equal(Hint.None, h);
+        Assert.Equal(Purpose.Normal, p);
+    }
+
+    [Theory]
+    [InlineData(TextInputContentType.Digits, Purpose.Digits)]
+    [InlineData(TextInputContentType.Pin, Purpose.Pin)]
+    [InlineData(TextInputContentType.Number, Purpose.Number)]
+    [InlineData(TextInputContentType.Email, Purpose.Email)]
+    [InlineData(TextInputContentType.Url, Purpose.Url)]
+    [InlineData(TextInputContentType.Name, Purpose.Name)]
+    public void ContentType_MapsPurpose(TextInputContentType ct, Purpose expected)
+    {
+        var (_, p) = TextInputOptionsConverter.Convert(new TextInputOptions { ContentType = ct });
+        Assert.Equal(expected, p);
+    }
+
+    [Fact]
+    public void Alpha_AddsLatinHint()
+    {
+        var (h, _) = TextInputOptionsConverter.Convert(new TextInputOptions { ContentType = TextInputContentType.Alpha });
+        Assert.True((h & Hint.Latin) != 0);
+    }
+
+    [Fact]
+    public void Password_ForcesHiddenAndSensitive_EvenWithShowSuggestions()
+    {
+        var (h, p) = TextInputOptionsConverter.Convert(new TextInputOptions
+        {
+            ContentType = TextInputContentType.Password,
+            ShowSuggestions = true
+        });
+        Assert.Equal(Purpose.Password, p);
+        Assert.True((h & Hint.HiddenText) != 0);
+        Assert.True((h & Hint.SensitiveData) != 0);
+        Assert.False((h & Hint.Completion) != 0);
+        Assert.False((h & Hint.Spellcheck) != 0);
+    }
+
+    [Fact]
+    public void Flags_ComposeIntoHint()
+    {
+        var (h, _) = TextInputOptionsConverter.Convert(new TextInputOptions
+        {
+            Multiline = true,
+            IsSensitive = true,
+            Lowercase = true,
+            Uppercase = true,
+            AutoCapitalization = true,
+            ShowSuggestions = true,
+        });
+        Assert.True((h & Hint.Multiline) != 0);
+        Assert.True((h & Hint.SensitiveData) != 0);
+        Assert.True((h & Hint.Lowercase) != 0);
+        Assert.True((h & Hint.Uppercase) != 0);
+        Assert.True((h & Hint.AutoCapitalization) != 0);
+        Assert.True((h & Hint.Completion) != 0);
+        Assert.True((h & Hint.Spellcheck) != 0);
+    }
+
+    [Fact]
+    public void ShowSuggestionsFalse_OmitsCompletion()
+    {
+        var (h, _) = TextInputOptionsConverter.Convert(new TextInputOptions { ShowSuggestions = false });
+        Assert.False((h & Hint.Completion) != 0);
+        Assert.False((h & Hint.Spellcheck) != 0);
+    }
+}
diff --git a/tests/Avalonia.Wayland.UnitTests/WaylandTextUtilsTests.cs b/tests/Avalonia.Wayland.UnitTests/WaylandTextUtilsTests.cs
new file mode 100644
index 0000000000..09adbe12b5
--- /dev/null
+++ b/tests/Avalonia.Wayland.UnitTests/WaylandTextUtilsTests.cs
@@ -0,0 +1,98 @@
+using Xunit;
+
+namespace Avalonia.Wayland.UnitTests;
+
+public class WaylandTextUtilsTests
+{
+    // Cyrillic 'й' = U+0439 → 2 UTF-8 bytes, 1 char.
+    // CJK '日' = U+65E5 → 3 UTF-8 bytes, 1 char.
+    // Emoji '🌍' = U+1F30D → 4 UTF-8 bytes, 2 chars (surrogate pair).
+    private const string Mixed = "aй日🌍b";   // bytes: 1+2+3+4+1=11; chars: 1+1+1+2+1=6.
+
+    [Theory]
+    [InlineData("hello", 0, 0, 0)]
+    [InlineData("hello", 5, 0, 5)]                      // forward, ASCII
+    [InlineData("hello", -3, 5, 2)]                     // backward, ASCII
+    [InlineData("hello", 100, 0, 5)]                    // clamp forward
+    [InlineData("hello", -100, 5, 0)]                   // clamp backward
+    [InlineData("aй日🌍b", 0, 3, 3)]                     // zero distance from middle
+    [InlineData("aй日🌍b", 1, 0, 1)]                     // 'a' = 1 byte
+    [InlineData("aй日🌍b", 3, 0, 2)]                     // 'aй' = 3 bytes → 2 chars
+    [InlineData("aй日🌍b", 6, 0, 3)]                     // 'aй日' = 6 bytes → 3 chars
+    [InlineData("aй日🌍b", 10, 0, 5)]                    // 'aй日🌍' = 10 bytes → 5 chars (surrogate pair counts as 2)
+    [InlineData("aй日🌍b", 11, 0, 6)]                    // full
+    [InlineData("aй日🌍b", -1, 6, 5)]                    // 'b' = 1 byte
+    [InlineData("aй日🌍b", -5, 6, 3)]                    // 'b' + '🌍' = 5 bytes → drops 3 chars
+    [InlineData("aй日🌍b", -11, 6, 0)]                   // back to start
+    [InlineData("aй日🌍b", 1, 1, 1)]                     // partway: from char index 1, +1 byte cannot reach a clean boundary in "й" (2 bytes), so stays at 1
+    public void CharIndexFromUtf8Offset_Cases(string text, int byteLength, int baseChar, int expectedChar)
+    {
+        Assert.Equal(expectedChar, WaylandTextUtils.CharIndexFromUtf8Offset(text, byteLength, baseChar));
+    }
+
+    [Fact]
+    public void CharIndexFromUtf8Offset_DoesNotSplitMultiByte()
+    {
+        // From start, +1 byte into "й" (2 bytes) — only the 'a' (1 byte) fits cleanly,
+        // so we should land at char 1, not partway through 'й'.
+        Assert.Equal(1, WaylandTextUtils.CharIndexFromUtf8Offset(Mixed, 2, 0));
+        // +1 byte from char 1 should consume nothing since "й" alone is 2 bytes.
+        Assert.Equal(1, WaylandTextUtils.CharIndexFromUtf8Offset(Mixed, 1, 1));
+    }
+
+    [Fact]
+    public void CharIndexFromUtf8Offset_DoesNotSplitSurrogatePair()
+    {
+        // From start, +9 bytes = "aй日" (6) + 3 bytes into '🌍' (4) — should NOT
+        // return half a surrogate pair. Should clamp at "aй日" = 3 chars.
+        Assert.Equal(3, WaylandTextUtils.CharIndexFromUtf8Offset(Mixed, 9, 0));
+    }
+
+    [Theory]
+    [InlineData("hello", 0, 0, 0)]
+    [InlineData("hello", 5, 0, 5)]
+    [InlineData("hello", 2, 5, -3)]
+    [InlineData("aй日🌍b", 0, 0, 0)]
+    [InlineData("aй日🌍b", 1, 0, 1)]
+    [InlineData("aй日🌍b", 2, 0, 3)]
+    [InlineData("aй日🌍b", 3, 0, 6)]
+    [InlineData("aй日🌍b", 5, 0, 10)]                    // through the surrogate pair
+    [InlineData("aй日🌍b", 6, 0, 11)]
+    [InlineData("aй日🌍b", 5, 6, -1)]                    // backward
+    [InlineData("aй日🌍b", 3, 6, -5)]                    // backward through surrogate pair
+    public void Utf8OffsetFromCharIndex_Cases(string text, int charIndex, int baseChar, int expectedBytes)
+    {
+        Assert.Equal(expectedBytes, WaylandTextUtils.Utf8OffsetFromCharIndex(text, charIndex, baseChar));
+    }
+
+    [Fact]
+    public void Utf8OffsetFromCharIndex_ClampsOutOfRange()
+    {
+        Assert.Equal(11, WaylandTextUtils.Utf8OffsetFromCharIndex(Mixed, 100, 0));
+        Assert.Equal(-11, WaylandTextUtils.Utf8OffsetFromCharIndex(Mixed, -10, 6));
+    }
+
+    [Fact]
+    public void RoundTrip_AllCharBoundaries()
+    {
+        // For every char index, char→byte→char should be the identity (modulo
+        // surrogate-pair midpoints, which we deliberately avoid by stepping through
+        // char positions, not byte positions).
+        for (var i = 0; i <= Mixed.Length; i++)
+        {
+            // skip the low-surrogate position (mid-pair)
+            if (i > 0 && char.IsLowSurrogate(Mixed[i - 1]) == false &&
+                i < Mixed.Length && char.IsHighSurrogate(Mixed[i]) && char.IsLowSurrogate(Mixed[i + 1]))
+            {
+                // i points at a high surrogate — that's a valid boundary.
+            }
+
+            if (i > 0 && i < Mixed.Length && char.IsLowSurrogate(Mixed[i]))
+                continue;
+
+            var bytes = WaylandTextUtils.Utf8ByteIndexFromCharIndex(Mixed, i);
+            var roundTrip = WaylandTextUtils.CharIndexFromUtf8Offset(Mixed, bytes, 0);
+            Assert.Equal(i, roundTrip);
+        }
+    }
+}

From 59e7353a4596da1ccf405c637a729d4eaee41d7f Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Wed, 17 Jun 2026 13:29:18 +0800
Subject: [PATCH 026/196] macOS: fix accessibility read-only, selection, and
 expand/collapse actions (#21599)

* Gate macOS setAccessibilityValue on value read-only state

A read-only value provider must not advertise the setAccessibilityValue selector, so AX clients see the value as not settable.

* Gate macOS read-only range value mutations

Report a read-only IRangeValueProvider (ProgressBar, read-only NumericUpDown) as not settable, and stop advertising setAccessibilityValue/increment/decrement for it; keep min/max exposed.

* Support deselect and toggle expand/collapse in macOS AX

setAccessibilitySelected:NO now removes from selection, and AXPress toggles an expand/collapse provider instead of always expanding.

* Harden macOS AX select, value-set, and disabled-control actions

setAccessibilitySelected:YES now adds to the selection instead of replacing it, the value setter respects read-only, and mutating actions are gated on IsEnabled.
---
 native/Avalonia.Native/src/OSX/automation.mm | 41 +++++++++++++-------
 src/Avalonia.Native/AvnAutomationPeer.cs     |  3 ++
 src/Avalonia.Native/avn.idl                  |  5 ++-
 3 files changed, 35 insertions(+), 14 deletions(-)

diff --git a/native/Avalonia.Native/src/OSX/automation.mm b/native/Avalonia.Native/src/OSX/automation.mm
index f355634de4..8750e9986c 100644
--- a/native/Avalonia.Native/src/OSX/automation.mm
+++ b/native/Avalonia.Native/src/OSX/automation.mm
@@ -260,14 +260,16 @@
 
 - (void)setAccessibilityValue:(id)newValue
 {
-    if (_peer->IsValueProvider())
+    if (!_peer->IsEnabled())
+        return;
+    if (_peer->IsValueProvider() && !_peer->ValueProvider_IsReadOnly())
     {
         if (newValue == nil)
             _peer->ValueProvider_SetValue(nil);
         else if ([newValue isKindOfClass:[NSString class]])
             _peer->ValueProvider_SetValue([(NSString*)newValue UTF8String]);
     }
-    else if (_peer->IsRangeValueProvider())
+    else if (_peer->IsRangeValueProvider() && !_peer->RangeValueProvider_IsReadOnly())
     {
         if ([newValue isKindOfClass:[NSNumber class]])
             _peer->RangeValueProvider_SetValue([(NSNumber*)newValue doubleValue]);
@@ -281,7 +283,7 @@
         if (_peer->IsValueProvider())
             return !_peer->ValueProvider_IsReadOnly();
         if (_peer->IsRangeValueProvider())
-            return YES;
+            return !_peer->RangeValueProvider_IsReadOnly();
         return NO;
     }
 
@@ -395,7 +397,7 @@
 
 - (void)setAccessibilityExpanded:(BOOL)accessibilityExpanded
 {
-    if (!_peer->IsExpandCollapseProvider())
+    if (!_peer->IsExpandCollapseProvider() || !_peer->IsEnabled())
         return;
     if (accessibilityExpanded)
         _peer->ExpandCollapseProvider_Expand();
@@ -405,13 +407,18 @@
 
 - (BOOL)accessibilityPerformPress
 {
+    if (!_peer->IsEnabled())
+        return NO;
     if (_peer->IsInvokeProvider())
     {
         _peer->InvokeProvider_Invoke();
     }
     else if (_peer->IsExpandCollapseProvider())
     {
-        _peer->ExpandCollapseProvider_Expand();
+        if (_peer->ExpandCollapseProvider_GetIsExpanded())
+            _peer->ExpandCollapseProvider_Collapse();
+        else
+            _peer->ExpandCollapseProvider_Expand();
     }
     else if (_peer->IsToggleProvider())
     {
@@ -422,7 +429,7 @@
 
 - (BOOL)accessibilityPerformIncrement
 {
-    if (!_peer->IsRangeValueProvider())
+    if (!_peer->IsRangeValueProvider() || _peer->RangeValueProvider_IsReadOnly() || !_peer->IsEnabled())
         return NO;
     auto value = _peer->RangeValueProvider_GetValue();
     value += _peer->RangeValueProvider_GetSmallChange();
@@ -432,7 +439,7 @@
 
 - (BOOL)accessibilityPerformDecrement
 {
-    if (!_peer->IsRangeValueProvider())
+    if (!_peer->IsRangeValueProvider() || _peer->RangeValueProvider_IsReadOnly() || !_peer->IsEnabled())
         return NO;
     auto value = _peer->RangeValueProvider_GetValue();
     value -= _peer->RangeValueProvider_GetSmallChange();
@@ -442,7 +449,7 @@
 
 - (BOOL)accessibilityPerformShowMenu
 {
-    if (!_peer->IsExpandCollapseProvider())
+    if (!_peer->IsExpandCollapseProvider() || !_peer->IsEnabled())
         return NO;
     _peer->ExpandCollapseProvider_Expand();
     return YES;
@@ -476,15 +483,20 @@
 
 - (void)setAccessibilitySelected:(BOOL)accessibilitySelected
 {
-    if (accessibilitySelected && _peer->IsSelectionItemProvider())
-        _peer->SelectionItemProvider_Select();
+    if (!_peer->IsSelectionItemProvider() || !_peer->IsEnabled())
+        return;
+    if (accessibilitySelected)
+        _peer->SelectionItemProvider_AddToSelection();
+    else
+        _peer->SelectionItemProvider_RemoveFromSelection();
 }
 
 - (BOOL)isAccessibilitySelectorAllowed:(SEL)selector
 {
     if (selector == @selector(setAccessibilityValue:))
     {
-        return _peer->IsValueProvider() || _peer->IsRangeValueProvider();
+        return (_peer->IsValueProvider() && !_peer->ValueProvider_IsReadOnly()) ||
+               (_peer->IsRangeValueProvider() && !_peer->RangeValueProvider_IsReadOnly());
     }
     else if (selector == @selector(accessibilityPerformShowMenu))
     {
@@ -503,8 +515,11 @@
         return _peer->IsSelectionItemProvider();
     }
     else if (selector == @selector(accessibilityPerformIncrement) ||
-             selector == @selector(accessibilityPerformDecrement) ||
-             selector == @selector(accessibilityMinValue) ||
+             selector == @selector(accessibilityPerformDecrement))
+    {
+        return _peer->IsRangeValueProvider() && !_peer->RangeValueProvider_IsReadOnly();
+    }
+    else if (selector == @selector(accessibilityMinValue) ||
              selector == @selector(accessibilityMaxValue))
     {
         return _peer->IsRangeValueProvider();
diff --git a/src/Avalonia.Native/AvnAutomationPeer.cs b/src/Avalonia.Native/AvnAutomationPeer.cs
index b448d5cb1a..9b9f890c06 100644
--- a/src/Avalonia.Native/AvnAutomationPeer.cs
+++ b/src/Avalonia.Native/AvnAutomationPeer.cs
@@ -184,10 +184,13 @@ namespace Avalonia.Native
         public double RangeValueProvider_GetSmallChange() => RangeValueProvider.SmallChange;
         public double RangeValueProvider_GetLargeChange() => RangeValueProvider.LargeChange;
         public void RangeValueProvider_SetValue(double value) => RangeValueProvider.SetValue(value);
+        public int RangeValueProvider_IsReadOnly() => RangeValueProvider.IsReadOnly.AsComBool();
 
         public int IsSelectionItemProvider() => IsProvider<ISelectionItemProvider>();
         public int SelectionItemProvider_IsSelected() => SelectionItemProvider.IsSelected.AsComBool();
         public void SelectionItemProvider_Select() => SelectionItemProvider.Select();
+        public void SelectionItemProvider_AddToSelection() => SelectionItemProvider.AddToSelection();
+        public void SelectionItemProvider_RemoveFromSelection() => SelectionItemProvider.RemoveFromSelection();
 
         public IAvnAutomationPeer? ScrollProvider_GetHorizontalScrollBar()
             => _inner is ScrollViewerAutomationPeer scrollViewer ? Wrap(scrollViewer.GetHorizontalScrollBarPeer()) : null;
diff --git a/src/Avalonia.Native/avn.idl b/src/Avalonia.Native/avn.idl
index 5b1b97fa37..f01430a42a 100644
--- a/src/Avalonia.Native/avn.idl
+++ b/src/Avalonia.Native/avn.idl
@@ -1315,10 +1315,13 @@ interface IAvnAutomationPeer : IUnknown
      double RangeValueProvider_GetSmallChange();
      double RangeValueProvider_GetLargeChange();
      void RangeValueProvider_SetValue(double value);
-     
+     bool RangeValueProvider_IsReadOnly();
+
      bool IsSelectionItemProvider();
      bool SelectionItemProvider_IsSelected();
      void SelectionItemProvider_Select();
+     void SelectionItemProvider_AddToSelection();
+     void SelectionItemProvider_RemoveFromSelection();
 
      IAvnAutomationPeer* ScrollProvider_GetHorizontalScrollBar();
      IAvnAutomationPeer* ScrollProvider_GetVerticalScrollBar();

From 8268d7dc1a3db7bbaba65f422d8979f1b4f299ed Mon Sep 17 00:00:00 2001
From: Rudy Paningal <149013690+ruddypp@users.noreply.github.com>
Date: Wed, 17 Jun 2026 15:15:41 +0700
Subject: [PATCH 027/196] Fix X11 BorderOnly window resizing (#21579)

Co-authored-by: Tim Miller <drasticactions@users.noreply.github.com>
---
 src/Avalonia.Controls/Window.cs | 1 +
 src/Avalonia.X11/X11Window.cs   | 7 ++++---
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.Controls/Window.cs b/src/Avalonia.Controls/Window.cs
index 901431d835..c344ef4b1b 100644
--- a/src/Avalonia.Controls/Window.cs
+++ b/src/Avalonia.Controls/Window.cs
@@ -1519,6 +1519,7 @@ namespace Avalonia.Controls
                 var (_, typedNewValue) = change.GetOldAndNewValue<WindowDecorations>();
 
                 PlatformImpl?.SetWindowDecorations(typedNewValue);
+                UpdateDrawnDecorations();
             }
 
             else if (change.Property == WindowDecorationsThemeProperty)
diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index 67b97979cc..6926758fe3 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -970,7 +970,7 @@ namespace Avalonia.X11
                 mouse.Position = mouse.Position / RenderScaling;
                 
                 // Chrome hit-test for drawn decorations
-                if (UseManagedDecorations
+                if (NeedsDrawnDecorations
                     && mouse.Type == RawPointerEventType.LeftButtonDown
                     && _inputRoot is { } inputRoot)
                 {
@@ -1556,6 +1556,7 @@ namespace Avalonia.X11
 
         private bool _extendingClientAreaToDecorations;
         private bool UseManagedDecorations => _extendingClientAreaToDecorations || _platform.Options.ForceDrawnDecorationsInternal;
+        private bool NeedsDrawnDecorations => UseManagedDecorations || _requestedWindowDecorations == WindowDecorations.BorderOnly;
 
         public void SetExtendClientAreaToDecorationsHint(bool extendIntoClientAreaHint)
         {
@@ -1652,10 +1653,10 @@ namespace Avalonia.X11
 
         public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } = new AcrylicPlatformCompensationLevels(1, 0.8, 0.8);
 
-        public bool NeedsManagedDecorations => UseManagedDecorations;
+        public bool NeedsManagedDecorations => NeedsDrawnDecorations;
 
         public PlatformRequestedDrawnDecoration RequestedDrawnDecorations =>
-            UseManagedDecorations
+            NeedsDrawnDecorations
                 ? PlatformRequestedDrawnDecoration.Border
                   | PlatformRequestedDrawnDecoration.ResizeGrips
                   | PlatformRequestedDrawnDecoration.TitleBar

From 7fa021e5625ca91aa22e0f2108327f08e090fb3c Mon Sep 17 00:00:00 2001
From: Tim Miller <drasticactions@users.noreply.github.com>
Date: Wed, 17 Jun 2026 17:40:23 +0900
Subject: [PATCH 028/196] [macOS] Synchronize Metal drawable presentation
 (#21588)

* Add demo app

* [macOS] Present Metal drawable synchronously on main-thread resize frames

* write through the out-parameter

* Add ResizePattern to RenderDemo

* Remove MetalResizeDemo
---
 native/Avalonia.Native/src/OSX/metal.mm       | 33 +++++++--
 samples/RenderDemo/Controls/ResizePattern.cs  | 73 +++++++++++++++++++
 samples/RenderDemo/MainWindow.xaml            |  3 +
 .../RenderDemo/Pages/ResizePatternPage.xaml   |  7 ++
 .../Pages/ResizePatternPage.xaml.cs           | 18 +++++
 5 files changed, 127 insertions(+), 7 deletions(-)
 create mode 100644 samples/RenderDemo/Controls/ResizePattern.cs
 create mode 100644 samples/RenderDemo/Pages/ResizePatternPage.xaml
 create mode 100644 samples/RenderDemo/Pages/ResizePatternPage.xaml.cs

diff --git a/native/Avalonia.Native/src/OSX/metal.mm b/native/Avalonia.Native/src/OSX/metal.mm
index 3da1282306..05f9fe0e34 100644
--- a/native/Avalonia.Native/src/OSX/metal.mm
+++ b/native/Avalonia.Native/src/OSX/metal.mm
@@ -181,12 +181,13 @@ class AvnMetalRenderSession : public ComSingleObject<IAvnMetalRenderingSession,
     CAMetalLayer* _layer;
     AvnPixelSize _size;
     double _scaling;
+    bool _presentWithTransaction;
 public:
     FORWARD_IUNKNOWN()
 
-    AvnMetalRenderSession(AvnMetalDevice* device, CAMetalLayer* layer, id <CAMetalDrawable> drawable, const AvnPixelSize &size, double scaling)
+    AvnMetalRenderSession(AvnMetalDevice* device, CAMetalLayer* layer, id <CAMetalDrawable> drawable, const AvnPixelSize &size, double scaling, bool presentWithTransaction)
             : _drawable(drawable), _size(size), _scaling(scaling), _queue(device->queue),
-            _texture([drawable texture]) {
+            _texture([drawable texture]), _presentWithTransaction(presentWithTransaction) {
         _layer = layer;
     }
 
@@ -207,8 +208,19 @@ public:
     {
         START_ARP_CALL;
         auto buffer = [_queue commandBuffer];
-        [buffer presentDrawable: _drawable];
-        [buffer commit];
+        if(_presentWithTransaction)
+        {
+            [buffer commit];
+            [buffer waitUntilScheduled];
+            [_drawable present];
+            // Restore the default asynchronous presentation for the off-thread render loop.
+            _layer.presentsWithTransaction = NO;
+        }
+        else
+        {
+            [buffer presentDrawable: _drawable];
+            [buffer commit];
+        }
     }
 };
 
@@ -230,7 +242,8 @@ public:
 
     HRESULT BeginDrawing(IAvnMetalRenderingSession **ret) override {
         START_COM_ARP_CALL;
-        if([NSThread isMainThread])
+        bool onMainThread = [NSThread isMainThread];
+        if(onMainThread)
         {
             // Flush all existing rendering
             auto buffer = [_device->queue commandBuffer];
@@ -240,15 +253,21 @@ public:
             _scaling= PendingScaling;
             CGSize layerSize = {(CGFloat)_size.Width, (CGFloat)_size.Height};
 
+            [CATransaction begin];
+            [CATransaction setDisableActions:YES];
             [_layer setDrawableSize: layerSize];
+            _layer.presentsWithTransaction = YES;
+            [CATransaction commit];
         }
         auto drawable = [_layer nextDrawable];
         if(drawable == nil)
         {
-            ret = nil;
+            if(onMainThread)
+                _layer.presentsWithTransaction = NO;
+            *ret = nullptr;
             return E_FAIL;
         }
-        *ret = new AvnMetalRenderSession(_device, _layer, drawable, _size, _scaling);
+        *ret = new AvnMetalRenderSession(_device, _layer, drawable, _size, _scaling, onMainThread);
         return 0;
     }
 };
diff --git a/samples/RenderDemo/Controls/ResizePattern.cs b/samples/RenderDemo/Controls/ResizePattern.cs
new file mode 100644
index 0000000000..23a269c09d
--- /dev/null
+++ b/samples/RenderDemo/Controls/ResizePattern.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Globalization;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Media;
+
+namespace RenderDemo.Controls
+{
+    public sealed class ResizePattern : Control
+    {
+        private static readonly IPen GridPen = new Pen(new SolidColorBrush(Color.FromRgb(60, 90, 130)), 1);
+        private static readonly IPen DiagonalPen = new Pen(new SolidColorBrush(Color.FromRgb(90, 90, 90)), 1);
+        private static readonly IPen CirclePen = new Pen(Brushes.OrangeRed, 4);
+        private static readonly IPen EdgePen = new Pen(Brushes.Lime, 6);
+        private static readonly IBrush Background = new SolidColorBrush(Color.FromRgb(16, 16, 24));
+        private static readonly IBrush TextBrush = Brushes.White;
+
+        private const double GridStep = 40;
+
+        static ResizePattern()
+        {
+            AffectsRender<ResizePattern>(BoundsProperty);
+        }
+
+        public override void Render(DrawingContext context)
+        {
+            var w = Bounds.Width;
+            var h = Bounds.Height;
+            if (w <= 0 || h <= 0)
+                return;
+
+            var rect = new Rect(0, 0, w, h);
+            context.FillRectangle(Background, rect);
+
+            // Grid -- uneven spacing on the far edges is the tell-tale of stretching.
+            for (double x = 0; x <= w; x += GridStep)
+                context.DrawLine(GridPen, new Point(x, 0), new Point(x, h));
+            for (double y = 0; y <= h; y += GridStep)
+                context.DrawLine(GridPen, new Point(0, y), new Point(w, y));
+
+            // Corner-to-corner diagonals -- they only meet exactly at the centre
+            // when the aspect ratio is correct.
+            context.DrawLine(DiagonalPen, new Point(0, 0), new Point(w, h));
+            context.DrawLine(DiagonalPen, new Point(w, 0), new Point(0, h));
+
+            // Edge frame -- a stretched drawable makes this peel away from the window edge.
+            context.DrawRectangle(null, EdgePen, rect.Deflate(3));
+
+            // Concentric perfect circles centred in the window.
+            var center = new Point(w / 2, h / 2);
+            var maxRadius = Math.Max(10, Math.Min(w, h) / 2 - 16);
+            for (var i = 1; i <= 3; i++)
+            {
+                var r = maxRadius * i / 3;
+                context.DrawEllipse(null, CirclePen, center, r, r);
+            }
+
+            // Centre crosshair.
+            context.DrawLine(CirclePen, new Point(center.X - 20, center.Y), new Point(center.X + 20, center.Y));
+            context.DrawLine(CirclePen, new Point(center.X, center.Y - 20), new Point(center.X, center.Y + 20));
+
+            // Live size read-out.
+            var text = new FormattedText(
+                string.Create(CultureInfo.InvariantCulture, $"{w:0} x {h:0} DIP"),
+                CultureInfo.InvariantCulture,
+                FlowDirection.LeftToRight,
+                Typeface.Default,
+                22,
+                TextBrush);
+            context.DrawText(text, new Point(12, 8));
+        }
+    }
+}
diff --git a/samples/RenderDemo/MainWindow.xaml b/samples/RenderDemo/MainWindow.xaml
index e3afd0c241..c3e68ab735 100644
--- a/samples/RenderDemo/MainWindow.xaml
+++ b/samples/RenderDemo/MainWindow.xaml
@@ -97,5 +97,8 @@
     <TabItem Header="3D Transformation">
       <pages:Transform3DPage />
     </TabItem>
+    <TabItem Header="Resize Pattern">
+      <pages:ResizePatternPage />
+    </TabItem>
   </controls:HamburgerMenu>
 </Window>
diff --git a/samples/RenderDemo/Pages/ResizePatternPage.xaml b/samples/RenderDemo/Pages/ResizePatternPage.xaml
new file mode 100644
index 0000000000..8e03879b84
--- /dev/null
+++ b/samples/RenderDemo/Pages/ResizePatternPage.xaml
@@ -0,0 +1,7 @@
+<UserControl
+  xmlns="https://github.com/avaloniaui"
+  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+  xmlns:controls="using:RenderDemo.Controls"
+  x:Class="RenderDemo.Pages.ResizePatternPage">
+  <controls:ResizePattern />
+</UserControl>
diff --git a/samples/RenderDemo/Pages/ResizePatternPage.xaml.cs b/samples/RenderDemo/Pages/ResizePatternPage.xaml.cs
new file mode 100644
index 0000000000..5c7f2b7916
--- /dev/null
+++ b/samples/RenderDemo/Pages/ResizePatternPage.xaml.cs
@@ -0,0 +1,18 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace RenderDemo.Pages
+{
+    public class ResizePatternPage : UserControl
+    {
+        public ResizePatternPage()
+        {
+            InitializeComponent();
+        }
+
+        private void InitializeComponent()
+        {
+            AvaloniaXamlLoader.Load(this);
+        }
+    }
+}

From b164b257b5a7ca4cc41b05a7ea2cd86ece4418a5 Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Wed, 17 Jun 2026 18:34:11 +0800
Subject: [PATCH 029/196] AT-SPI: add to the selection in Selection.SelectChild
 instead of replacing it (#21602)

---
 .../Handlers/AtSpiSelectionHandler.cs                           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiSelectionHandler.cs b/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiSelectionHandler.cs
index 7d38d051d4..95bd6e032d 100644
--- a/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiSelectionHandler.cs
+++ b/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiSelectionHandler.cs
@@ -54,7 +54,7 @@ namespace Avalonia.FreeDesktop.AtSpi.Handlers
             if (childPeer.GetProvider<ISelectionItemProvider>() is not { } selectionItem)
                 return ValueTask.FromResult(false);
 
-            selectionItem.Select();
+            selectionItem.AddToSelection();
             return ValueTask.FromResult(true);
         }
 

From f655d6ffa7b6566aa19c3c9e4406e2a86913ae1e Mon Sep 17 00:00:00 2001
From: lindexi <lindexi@users.noreply.github.com>
Date: Thu, 18 Jun 2026 18:21:02 +0800
Subject: [PATCH 030/196] Optimize rendering performance by reduce
 Premultiplied AlphaMode (#20757)

* Adding TransparencyLevel property to CompositionTarget

* Try to pass the WindowTransparencyLevel to surface

* Enable change the AlphaMode in WinUI window.

* Support disable transparency explicitly;

* Adding the test demo code.

* Fix ICompositionDrawingSurfaceInterop.BeginDraw fail. Because the surface do not set size.

* Merge the same code

* Fix compile

* Add test demo code

* Put the re create surface to trycatch block.

Solve the `transaction` do not be disposed when CreateSurface exception.

* Add the dynamic Transparency alpha mode support to DirectComposited

* Revert "Adding TransparencyLevel property to CompositionTarget"

This reverts commit da0af790b15c62bb8d5f2e94ca6b3c904a79b4a2.

* Adding TransparencyLevel property to CompositionTarget

* Adding TransparencyLevel to RenderTargetSceneInfo

* Try remove the pass level

* Finish pass RenderTargetSceneInfo to create surface.

* Remove the unuse argument

* Remove the unuse code

* Bring the comments closer to the code

* Revert sort using

* Remove the unuse using

* Try fix compile error

* Remove the unuse namespace using.

* Try fix API changed

* Try fix compile

* Update api
---
 api/Avalonia.nupkg.xml                        | 40 ++++++++-
 samples/RenderDemo/MainWindow.xaml            |  2 +
 samples/RenderDemo/MainWindow.xaml.cs         | 11 +++
 src/Avalonia.Base/Platform/IRenderTarget.cs   |  5 +-
 .../CompositionTransparencyLevel.cs           | 10 +++
 .../Server/ServerCompositionTarget.cs         |  2 +-
 src/Avalonia.Base/composition-schema.xml      |  1 +
 src/Avalonia.Controls/TopLevel.cs             | 18 +++-
 .../Server/Persistent/WaylandBitmapCursor.cs  |  3 +-
 .../Output/DrmOutput.cs                       |  3 +-
 .../Avalonia.Skia/RenderTargetBitmapImpl.cs   |  3 +-
 .../DComposition/DirectCompositedWindow.cs    |  1 -
 .../DirectCompositedWindowSurface.cs          | 72 ++++++++++++----
 .../IDirect3D11TexturePlatformSurface.cs      | 13 +++
 .../OpenGl/Angle/AngleD3DTextureFeature.cs    | 10 +--
 .../WinUiCompositedWindowSurface.cs           | 83 ++++++++++++++-----
 src/Windows/Avalonia.Win32/WindowImpl.cs      |  7 ++
 .../Avalonia.RenderTests/Media/BitmapTests.cs |  3 +-
 18 files changed, 234 insertions(+), 53 deletions(-)
 create mode 100644 src/Avalonia.Base/Rendering/Composition/CompositionTransparencyLevel.cs

diff --git a/api/Avalonia.nupkg.xml b/api/Avalonia.nupkg.xml
index aaf84068f5..590fbdc538 100644
--- a/api/Avalonia.nupkg.xml
+++ b/api/Avalonia.nupkg.xml
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <!-- https://learn.microsoft.com/dotnet/fundamentals/package-validation/diagnostic-ids -->
 <Suppressions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
   <Suppression>
@@ -19,6 +19,24 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.IRenderTarget.RenderTargetSceneInfo.#ctor(Avalonia.PixelSize,System.Double,Avalonia.Size)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.IRenderTarget.RenderTargetSceneInfo.#ctor(Avalonia.PixelSize,System.Double)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.IRenderTarget.RenderTargetSceneInfo.Deconstruct(Avalonia.PixelSize@,System.Double@,Avalonia.Size@)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:Avalonia.Platform.IRenderTarget.RenderTargetSceneInfo.Deconstruct(Avalonia.PixelSize@,System.Double@)</Target>
@@ -49,6 +67,24 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.IRenderTarget.RenderTargetSceneInfo.#ctor(Avalonia.PixelSize,System.Double,Avalonia.Size)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.IRenderTarget.RenderTargetSceneInfo.#ctor(Avalonia.PixelSize,System.Double)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.IRenderTarget.RenderTargetSceneInfo.Deconstruct(Avalonia.PixelSize@,System.Double@,Avalonia.Size@)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:Avalonia.Platform.IRenderTarget.RenderTargetSceneInfo.Deconstruct(Avalonia.PixelSize@,System.Double@)</Target>
@@ -61,4 +97,4 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Right>
   </Suppression>
-</Suppressions>
\ No newline at end of file
+</Suppressions>
diff --git a/samples/RenderDemo/MainWindow.xaml b/samples/RenderDemo/MainWindow.xaml
index c3e68ab735..058cc14278 100644
--- a/samples/RenderDemo/MainWindow.xaml
+++ b/samples/RenderDemo/MainWindow.xaml
@@ -43,6 +43,8 @@
         </MenuItem>
         <MenuItem Header="Tests">
           <MenuItem Command="{Binding ResizeWindow}" Header="Resize window" />
+          <MenuItem x:Name="SetNotTransparencyMenuItem" Header="Set window not Transparency" Click="SetNotTransparencyMenuItem_OnClick"/>
+          <MenuItem x:Name="SetTransparencyMenuItem" Header="Set window Transparency" Click="SetTransparencyMenuItem_OnClick"/>
         </MenuItem>
       </MenuFlyout>
     </FlyoutBase.AttachedFlyout>
diff --git a/samples/RenderDemo/MainWindow.xaml.cs b/samples/RenderDemo/MainWindow.xaml.cs
index a2f3f0eac8..96e21f0d2f 100644
--- a/samples/RenderDemo/MainWindow.xaml.cs
+++ b/samples/RenderDemo/MainWindow.xaml.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Linq.Expressions;
 using Avalonia.Controls;
+using Avalonia.Interactivity;
 using Avalonia.Markup.Xaml;
 using Avalonia.Rendering;
 using RenderDemo.ViewModels;
@@ -37,5 +38,15 @@ namespace RenderDemo
         {
             AvaloniaXamlLoader.Load(this);
         }
+
+        private void SetNotTransparencyMenuItem_OnClick(object? sender, RoutedEventArgs e)
+        {
+            TransparencyLevelHint = [WindowTransparencyLevel.None];
+        }
+
+        private void SetTransparencyMenuItem_OnClick(object? sender, RoutedEventArgs e)
+        {
+            TransparencyLevelHint = [WindowTransparencyLevel.Transparent];
+        }
     }
 }
diff --git a/src/Avalonia.Base/Platform/IRenderTarget.cs b/src/Avalonia.Base/Platform/IRenderTarget.cs
index b9da6a35b6..0bc84c7a14 100644
--- a/src/Avalonia.Base/Platform/IRenderTarget.cs
+++ b/src/Avalonia.Base/Platform/IRenderTarget.cs
@@ -1,5 +1,6 @@
 using System;
 using Avalonia.Metadata;
+using Avalonia.Rendering.Composition;
 
 namespace Avalonia.Platform
 {
@@ -32,9 +33,9 @@ namespace Avalonia.Platform
         /// </summary>
         PlatformRenderTargetState PlatformRenderTargetState => PlatformRenderTargetState.Ready;
         
-        public record struct RenderTargetSceneInfo(PixelSize Size, double Scaling, Size LogicalSize)
+        public record struct RenderTargetSceneInfo(PixelSize Size, double Scaling, Size LogicalSize, CompositionTransparencyLevel TransparencyLevel)
         {
-            public RenderTargetSceneInfo(PixelSize size, double scaling) : this(size, scaling, size.ToSize(scaling))
+            public RenderTargetSceneInfo(PixelSize size, double scaling, CompositionTransparencyLevel transparencyLevel) : this(size, scaling, size.ToSize(scaling), transparencyLevel)
             {
             }
         }
diff --git a/src/Avalonia.Base/Rendering/Composition/CompositionTransparencyLevel.cs b/src/Avalonia.Base/Rendering/Composition/CompositionTransparencyLevel.cs
new file mode 100644
index 0000000000..fd2abd75ee
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/CompositionTransparencyLevel.cs
@@ -0,0 +1,10 @@
+namespace Avalonia.Rendering.Composition;
+
+public enum CompositionTransparencyLevel : byte
+{
+    None = 0,
+    Transparent = 1,
+    Blur = 2,
+    AcrylicBlur = 3,
+    Mica = 4
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionTarget.cs b/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionTarget.cs
index 3ce37aec28..72d1eac278 100644
--- a/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionTarget.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionTarget.cs
@@ -205,7 +205,7 @@ namespace Avalonia.Rendering.Composition.Server
             try
             {
                 renderTargetContext =
-                    _renderTarget.CreateDrawingContext(new(PixelSize, Scaling, Size), out properties);
+                    _renderTarget.CreateDrawingContext(new(PixelSize, Scaling, Size, TransparencyLevel), out properties);
             }
             catch (RenderTargetNotReadyException)
             {
diff --git a/src/Avalonia.Base/composition-schema.xml b/src/Avalonia.Base/composition-schema.xml
index 207f80647b..442d0c9197 100644
--- a/src/Avalonia.Base/composition-schema.xml
+++ b/src/Avalonia.Base/composition-schema.xml
@@ -59,6 +59,7 @@
         <Property Name="LastLayoutPassTiming" Type="LayoutPassTiming" Internal="true"/>
         <Property Name="Scaling" Type="double"/>
         <Property Name="Size" Type="Size" />
+        <Property Name="TransparencyLevel" Type="CompositionTransparencyLevel" />
     </Object>
     <KeyFrameAnimation Name="Scalar" Type="float"/>
     <KeyFrameAnimation Name="Double" Type="double"/>
diff --git a/src/Avalonia.Controls/TopLevel.cs b/src/Avalonia.Controls/TopLevel.cs
index 7a9cfa4abb..c30047fe7a 100644
--- a/src/Avalonia.Controls/TopLevel.cs
+++ b/src/Avalonia.Controls/TopLevel.cs
@@ -218,7 +218,8 @@ namespace Avalonia.Controls
             _scaling = LayoutHelper.ValidateScaling(impl.RenderScaling);
             _actualTransparencyLevel = PlatformImpl.TransparencyLevel;
 
-
+            _source.Renderer.CompositionTarget.TransparencyLevel =
+                ToCompositionTransparencyLevel(_actualTransparencyLevel);
 
 
             _accessKeyHandler = TryGetService<IAccessKeyHandler>(dependencyResolver);
@@ -731,6 +732,8 @@ namespace Avalonia.Controls
             }
 
             ActualTransparencyLevel = transparencyLevel;
+            Renderer.CompositionTarget.TransparencyLevel =
+                ToCompositionTransparencyLevel(transparencyLevel);
         }
 
         protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
@@ -833,5 +836,18 @@ namespace Avalonia.Controls
         {
             // Do nothing becuase TopLevel should't apply MirrorTransform on himself.
         }
+
+        private static CompositionTransparencyLevel ToCompositionTransparencyLevel(WindowTransparencyLevel level)
+        {
+            if (level == WindowTransparencyLevel.Transparent)
+                return CompositionTransparencyLevel.Transparent;
+            if (level == WindowTransparencyLevel.Blur)
+                return CompositionTransparencyLevel.Blur;
+            if (level == WindowTransparencyLevel.AcrylicBlur)
+                return CompositionTransparencyLevel.AcrylicBlur;
+            if (level == WindowTransparencyLevel.Mica)
+                return CompositionTransparencyLevel.Mica;
+            return CompositionTransparencyLevel.None;
+        }
     }
 }
diff --git a/src/Avalonia.Wayland/Server/Persistent/WaylandBitmapCursor.cs b/src/Avalonia.Wayland/Server/Persistent/WaylandBitmapCursor.cs
index 716dd6ae99..e46d9d0d15 100644
--- a/src/Avalonia.Wayland/Server/Persistent/WaylandBitmapCursor.cs
+++ b/src/Avalonia.Wayland/Server/Persistent/WaylandBitmapCursor.cs
@@ -4,6 +4,7 @@ using System.Linq;
 using System.Runtime.InteropServices;
 using Avalonia;
 using Avalonia.Platform;
+using Avalonia.Rendering.Composition;
 using Avalonia.Wayland.Server.Interop;
 using Avalonia.Wayland.Server.Transient;
 using Avalonia.Wayland.Server.Transient.Rendering;
@@ -75,7 +76,7 @@ sealed class WaylandBitmapCursor : WaylandCursor, IPersistentWaylandObject, IWay
 
         var framebuffer = new WaylandFramebuffer(this);
         using var renderTarget = framebuffer.CreateFramebufferRenderTarget();
-        using var locked = renderTarget.Lock(new IRenderTarget.RenderTargetSceneInfo(_size, 1), out _);
+        using var locked = renderTarget.Lock(new IRenderTarget.RenderTargetSceneInfo(_size, 1, CompositionTransparencyLevel.None), out _);
         // The locked framebuffer is Bgra8888 premultiplied with stride == Width * 4, matching the
         // packed pixel data we captured on the UI thread. Disposing the lock attaches + commits.
         Marshal.Copy(_pixels, 0, locked.Address, _pixels.Length);
diff --git a/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmOutput.cs b/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmOutput.cs
index dabf1b6bfd..e0292c44e6 100644
--- a/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmOutput.cs
+++ b/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmOutput.cs
@@ -8,6 +8,7 @@ using Avalonia.OpenGL;
 using Avalonia.OpenGL.Egl;
 using Avalonia.OpenGL.Surfaces;
 using Avalonia.Platform;
+using Avalonia.Rendering.Composition;
 using static Avalonia.LinuxFramebuffer.NativeUnsafeMethods;
 using static Avalonia.LinuxFramebuffer.Output.LibDrm;
 
@@ -377,7 +378,7 @@ namespace Avalonia.LinuxFramebuffer.Output
             {
                 //Go through two cycles of buffer swapping (there are render artifacts otherwise)
                 for (var c = 0; c < 2; c++)
-                    using (CreateGlRenderTarget().BeginDraw(new IRenderTarget.RenderTargetSceneInfo(PixelSize, 1)))
+                    using (CreateGlRenderTarget().BeginDraw(new IRenderTarget.RenderTargetSceneInfo(PixelSize, 1, CompositionTransparencyLevel.None)))
                     {
                         _deferredContext.GlInterface.ClearColor(initialBufferSwappingColorR, initialBufferSwappingColorG,
                             initialBufferSwappingColorB, initialBufferSwappingColorA);
diff --git a/src/Skia/Avalonia.Skia/RenderTargetBitmapImpl.cs b/src/Skia/Avalonia.Skia/RenderTargetBitmapImpl.cs
index c5002510f9..8712cfc2b5 100644
--- a/src/Skia/Avalonia.Skia/RenderTargetBitmapImpl.cs
+++ b/src/Skia/Avalonia.Skia/RenderTargetBitmapImpl.cs
@@ -1,5 +1,6 @@
 using Avalonia.Platform.Surfaces;
 using Avalonia.Platform;
+using Avalonia.Rendering.Composition;
 using SkiaSharp;
 
 namespace Avalonia.Skia;
@@ -20,7 +21,7 @@ internal class RenderTargetBitmapImpl : WriteableBitmapImpl,
     public IDrawingContextImpl CreateDrawingContext()
     {
         return _renderTarget.CreateDrawingContext(new IRenderTarget.RenderTargetSceneInfo(
-            PixelSize, Dpi.X / 96.0), out _);
+            PixelSize, Dpi.X / 96.0, CompositionTransparencyLevel.None), out _);
     }
 
 
diff --git a/src/Windows/Avalonia.Win32/DComposition/DirectCompositedWindow.cs b/src/Windows/Avalonia.Win32/DComposition/DirectCompositedWindow.cs
index 8935e8bcbf..4689ad9bc4 100644
--- a/src/Windows/Avalonia.Win32/DComposition/DirectCompositedWindow.cs
+++ b/src/Windows/Avalonia.Win32/DComposition/DirectCompositedWindow.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Numerics;
 using System.Threading;
 using Avalonia.OpenGL.Egl;
 using Avalonia.Reactive;
diff --git a/src/Windows/Avalonia.Win32/DComposition/DirectCompositedWindowSurface.cs b/src/Windows/Avalonia.Win32/DComposition/DirectCompositedWindowSurface.cs
index 9c6f5707bf..e91ca786f7 100644
--- a/src/Windows/Avalonia.Win32/DComposition/DirectCompositedWindowSurface.cs
+++ b/src/Windows/Avalonia.Win32/DComposition/DirectCompositedWindowSurface.cs
@@ -1,14 +1,17 @@
 using System;
-using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+
 using Avalonia.OpenGL.Egl;
 using Avalonia.Platform;
+using Avalonia.Rendering.Composition;
 using Avalonia.Win32.DirectX;
 using Avalonia.Win32.Interop;
+
 using MicroCom.Runtime;
 
 namespace Avalonia.Win32.DComposition;
 
-internal class DirectCompositedWindowSurface : IDirect3D11TexturePlatformSurface, IDisposable, ICompositionEffectsSurface
+internal class DirectCompositedWindowSurface : IDirect3D11TexturePlatformSurface, IDirect3D11TexturePlatformSurface2, IDisposable, ICompositionEffectsSurface
 {
     private readonly EglGlPlatformSurface.IEglWindowGlPlatformSurfaceInfo _info;
     private readonly DirectCompositionShared _shared;
@@ -21,7 +24,12 @@ internal class DirectCompositedWindowSurface : IDirect3D11TexturePlatformSurface
         _info = info;
     }
 
-    public IDirect3D11TextureRenderTarget CreateRenderTarget(IPlatformGraphicsContext context, IntPtr d3dDevice)
+    IDirect3D11TextureRenderTarget IDirect3D11TexturePlatformSurface.CreateRenderTarget(IPlatformGraphicsContext context, IntPtr d3dDevice)
+    {
+        return (IDirect3D11TextureRenderTarget) CreateRenderTarget(context, d3dDevice);
+    }
+
+    public IDirect3D11TextureRenderTarget2 CreateRenderTarget(IPlatformGraphicsContext context, IntPtr d3dDevice)
     {
         _window ??= new DirectCompositedWindow(_info, _shared);
         SetBlur(_blurEffect);
@@ -45,16 +53,18 @@ internal class DirectCompositedWindowSurface : IDirect3D11TexturePlatformSurface
     }
 }
 
-internal class DirectCompositedWindowRenderTarget : IDirect3D11TextureRenderTarget
+internal class DirectCompositedWindowRenderTarget : IDirect3D11TextureRenderTarget, IDirect3D11TextureRenderTarget2
 {
     private static readonly Guid IID_ID3D11Texture2D = Guid.Parse("6f15aaf2-d208-4e89-9ab4-489535d34f9c");
 
     private readonly IPlatformGraphicsContext _context;
+    private readonly DirectCompositionShared _shared;
     private readonly DirectCompositedWindow _window;
-    private readonly IDCompositionVirtualSurface _surface;
+    private IDCompositionVirtualSurface? _surface;
     private bool _lost;
     private PixelSize _size;
     private readonly IUnknown _d3dDevice;
+    private bool _isSurfaceSupportTransparency;
 
     public DirectCompositedWindowRenderTarget(
         IPlatformGraphicsContext context, IntPtr d3dDevice,
@@ -63,24 +73,44 @@ internal class DirectCompositedWindowRenderTarget : IDirect3D11TextureRenderTarg
         _d3dDevice = MicroComRuntime.CreateProxyFor<IUnknown>(d3dDevice, false).CloneReference();
 
         _context = context;
+        _shared = shared;
         _window = window;
+    }
 
-        using (var surfaceFactory = shared.Device.CreateSurfaceFactory(_d3dDevice))
-        {
-            _surface = surfaceFactory.CreateVirtualSurface(1, 1, DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_UNORM,
-                DXGI_ALPHA_MODE.DXGI_ALPHA_MODE_PREMULTIPLIED);
-        }
+    [MemberNotNull(nameof(_surface))]
+    private void CreateSurface(in IRenderTarget.RenderTargetSceneInfo sceneInfo)
+    {
+        using var surfaceFactory = _shared.Device.CreateSurfaceFactory(_d3dDevice);
+
+        bool isTransparency = sceneInfo.TransparencyLevel != CompositionTransparencyLevel.None;
+        var surfaceSize = sceneInfo.Size;
+
+        var alphaMode = isTransparency ?
+            DXGI_ALPHA_MODE.DXGI_ALPHA_MODE_PREMULTIPLIED :
+            DXGI_ALPHA_MODE.DXGI_ALPHA_MODE_IGNORE;
+
+        _surface = surfaceFactory.CreateVirtualSurface((uint)surfaceSize.Width, (uint)surfaceSize.Height, DXGI_FORMAT.DXGI_FORMAT_B8G8R8A8_UNORM, alphaMode);
+
+        _isSurfaceSupportTransparency = isTransparency;
+        _size = surfaceSize;
     }
 
     public void Dispose()
     {
-        _surface.Dispose();
+        _surface?.Dispose();
         _d3dDevice.Dispose();
     }
 
     public PlatformRenderTargetState State => _context.IsLost || _lost ? PlatformRenderTargetState.Corrupted : PlatformRenderTargetState.Ready;
-    
-    public unsafe IDirect3D11TextureRenderTargetRenderSession BeginDraw()
+
+    IDirect3D11TextureRenderTargetRenderSession IDirect3D11TextureRenderTarget.BeginDraw()
+    {
+        var fallbackSceneInfo = new IRenderTarget.RenderTargetSceneInfo(_window.WindowInfo.Size,
+            _window.WindowInfo.Scaling, CompositionTransparencyLevel.None);
+        return BeginDraw(fallbackSceneInfo);
+    }
+
+    public unsafe IDirect3D11TextureRenderTargetRenderSession BeginDraw(IRenderTarget.RenderTargetSceneInfo sceneInfo)
     {
         if (State.IsCorrupted)
             throw new RenderTargetCorruptedException();
@@ -88,11 +118,19 @@ internal class DirectCompositedWindowRenderTarget : IDirect3D11TextureRenderTarg
         bool needsEndDraw = false;
         try
         {
-            var size = _window.WindowInfo.Size;
-            var scale = _window.WindowInfo.Scaling;
+            bool isTransparency = sceneInfo.TransparencyLevel != CompositionTransparencyLevel.None;
+            if (_surface is null || isTransparency != _isSurfaceSupportTransparency)
+            {
+                _surface?.Dispose();
+
+                CreateSurface(in sceneInfo);
+            }
+
+            var size = sceneInfo.Size;
+            var scale = sceneInfo.Scaling;
             if (_size != size)
             {
-                _surface.Resize((ushort)size.Width, (ushort)size.Height);
+                _surface.Resize((uint)size.Width, (uint)size.Height);
                 _size = size;
             }
 
@@ -125,7 +163,7 @@ internal class DirectCompositedWindowRenderTarget : IDirect3D11TextureRenderTarg
             if (transaction != null)
             {
                 if (needsEndDraw)
-                    _surface.EndDraw();
+                    _surface?.EndDraw();
                 transaction.Dispose();
             }
         }
diff --git a/src/Windows/Avalonia.Win32/DirectX/IDirect3D11TexturePlatformSurface.cs b/src/Windows/Avalonia.Win32/DirectX/IDirect3D11TexturePlatformSurface.cs
index ce077d6ce0..c0dda8592b 100644
--- a/src/Windows/Avalonia.Win32/DirectX/IDirect3D11TexturePlatformSurface.cs
+++ b/src/Windows/Avalonia.Win32/DirectX/IDirect3D11TexturePlatformSurface.cs
@@ -1,4 +1,6 @@
 using System;
+
+using Avalonia.Metadata;
 using Avalonia.OpenGL;
 using Avalonia.OpenGL.Surfaces;
 using Avalonia.Platform;
@@ -11,6 +13,11 @@ public interface IDirect3D11TexturePlatformSurface : IPlatformRenderSurface
     public IDirect3D11TextureRenderTarget CreateRenderTarget(IPlatformGraphicsContext graphicsContext, IntPtr d3dDevice);
 }
 
+[PrivateApi]
+public interface IDirect3D11TexturePlatformSurface2 : IPlatformRenderSurface
+{
+    IDirect3D11TextureRenderTarget2 CreateRenderTarget(IPlatformGraphicsContext graphicsContext, IntPtr d3dDevice);
+}
 
 
 public interface IDirect3D11TextureRenderTarget : IPlatformRenderSurfaceRenderTarget, IDisposable
@@ -18,6 +25,12 @@ public interface IDirect3D11TextureRenderTarget : IPlatformRenderSurfaceRenderTa
     IDirect3D11TextureRenderTargetRenderSession BeginDraw();
 }
 
+[PrivateApi]
+public interface IDirect3D11TextureRenderTarget2 : IPlatformRenderSurfaceRenderTarget, IDisposable
+{
+    IDirect3D11TextureRenderTargetRenderSession BeginDraw(IRenderTarget.RenderTargetSceneInfo sceneInfo);
+}
+
 public interface IDirect3D11TextureRenderTargetRenderSession : IDisposable
 {
     public IntPtr D3D11Texture2D { get; }
diff --git a/src/Windows/Avalonia.Win32/OpenGl/Angle/AngleD3DTextureFeature.cs b/src/Windows/Avalonia.Win32/OpenGl/Angle/AngleD3DTextureFeature.cs
index 60882fb62e..f2e2f270a4 100644
--- a/src/Windows/Avalonia.Win32/OpenGl/Angle/AngleD3DTextureFeature.cs
+++ b/src/Windows/Avalonia.Win32/OpenGl/Angle/AngleD3DTextureFeature.cs
@@ -14,16 +14,16 @@ internal class AngleD3DTextureFeature  : IGlPlatformSurfaceRenderTargetFactory
         context is EglContext
         {
             Display: AngleWin32EglDisplay { PlatformApi: AngleOptions.PlatformApi.DirectX11 }
-        } && surface is IDirect3D11TexturePlatformSurface;
+        } && surface is IDirect3D11TexturePlatformSurface2;
 
     private class RenderTargetWrapper : EglPlatformSurfaceRenderTargetBase
     {
         private readonly AngleWin32EglDisplay _angle;
-        private readonly IDirect3D11TextureRenderTarget _target;
+        private readonly IDirect3D11TextureRenderTarget2 _target;
 
         public RenderTargetWrapper(EglContext context,
             AngleWin32EglDisplay angle,
-            IDirect3D11TextureRenderTarget target) : base(context)
+            IDirect3D11TextureRenderTarget2 target) : base(context)
         {
             _angle = angle;
             _target = target;
@@ -40,7 +40,7 @@ internal class AngleD3DTextureFeature  : IGlPlatformSurfaceRenderTargetFactory
             {
                 try
                 {
-                    session = _target.BeginDraw();
+                    session = _target.BeginDraw(sceneInfo);
                 }
                 catch (RenderTargetCorruptedException e)
                 {
@@ -91,7 +91,7 @@ internal class AngleD3DTextureFeature  : IGlPlatformSurfaceRenderTargetFactory
     {
         var ctx = (EglContext)context;
         var angle = (AngleWin32EglDisplay)ctx.Display;
-        var textureSurface = (IDirect3D11TexturePlatformSurface)surface;
+        var textureSurface = (IDirect3D11TexturePlatformSurface2)surface;
         try
         {
             var target = textureSurface.CreateRenderTarget(context, angle.GetDirect3DDevice());
diff --git a/src/Windows/Avalonia.Win32/WinRT/Composition/WinUiCompositedWindowSurface.cs b/src/Windows/Avalonia.Win32/WinRT/Composition/WinUiCompositedWindowSurface.cs
index 96e5fae00b..179d0c2060 100644
--- a/src/Windows/Avalonia.Win32/WinRT/Composition/WinUiCompositedWindowSurface.cs
+++ b/src/Windows/Avalonia.Win32/WinRT/Composition/WinUiCompositedWindowSurface.cs
@@ -1,13 +1,15 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using Avalonia.OpenGL.Egl;
 using Avalonia.Platform;
+using Avalonia.Rendering.Composition;
 using Avalonia.Win32.DirectX;
 using Avalonia.Win32.Interop;
 using MicroCom.Runtime;
 
 namespace Avalonia.Win32.WinRT.Composition
 {
-    internal class WinUiCompositedWindowSurface : IDirect3D11TexturePlatformSurface, IDisposable, ICompositionEffectsSurface
+    internal class WinUiCompositedWindowSurface : IDirect3D11TexturePlatformSurface, IDirect3D11TexturePlatformSurface2, IDisposable, ICompositionEffectsSurface
     {
         private readonly WinUiCompositionShared _shared;
         private readonly EglGlPlatformSurface.IEglWindowGlPlatformSurfaceInfo _info;
@@ -20,7 +22,12 @@ namespace Avalonia.Win32.WinRT.Composition
             _info = info;
         }
 
-        public IDirect3D11TextureRenderTarget CreateRenderTarget(IPlatformGraphicsContext context, IntPtr d3dDevice)
+        IDirect3D11TextureRenderTarget IDirect3D11TexturePlatformSurface.CreateRenderTarget(IPlatformGraphicsContext context, IntPtr d3dDevice)
+        {
+           return (IDirect3D11TextureRenderTarget) CreateRenderTarget(context, d3dDevice);
+        }
+
+        public IDirect3D11TextureRenderTarget2 CreateRenderTarget(IPlatformGraphicsContext context, IntPtr d3dDevice)
         {
             var cornerRadius = AvaloniaLocator.Current.GetService<Win32PlatformOptions>()
                 ?.WinUICompositionBackdropCornerRadius;
@@ -52,7 +59,7 @@ namespace Avalonia.Win32.WinRT.Composition
         }
     }
 
-    internal class WinUiCompositedWindowRenderTarget : IDirect3D11TextureRenderTarget
+    internal class WinUiCompositedWindowRenderTarget : IDirect3D11TextureRenderTarget, IDirect3D11TextureRenderTarget2
     {
         private static readonly Guid IID_ID3D11Texture2D = Guid.Parse("6f15aaf2-d208-4e89-9ab4-489535d34f9c");
 
@@ -63,11 +70,12 @@ namespace Avalonia.Win32.WinRT.Composition
         private readonly ICompositorInterop _interop;
         private readonly ICompositionGraphicsDevice _compositionDevice;
         private readonly ICompositionGraphicsDevice2 _compositionDevice2;
-        private readonly ICompositionSurface _surface;
+        private ICompositionSurface? _surface;
         private PixelSize _size;
         private bool _lost;
-        private readonly ICompositionDrawingSurfaceInterop _surfaceInterop;
-        private readonly ICompositionDrawingSurface _drawingSurface;
+        private bool _isSurfaceSupportTransparency;
+        private ICompositionDrawingSurfaceInterop? _surfaceInterop;
+        private ICompositionDrawingSurface? _drawingSurface;
 
         public WinUiCompositedWindowRenderTarget(IPlatformGraphicsContext context,
             WinUiCompositedWindow window, IntPtr device,
@@ -83,16 +91,9 @@ namespace Avalonia.Win32.WinRT.Composition
                 _interop = compositor.QueryInterface<ICompositorInterop>();
                 _compositionDevice = _interop.CreateGraphicsDevice(_d3dDevice);
                 _compositionDevice2 = _compositionDevice.QueryInterface<ICompositionGraphicsDevice2>();
-                _drawingSurface = _compositionDevice2.CreateDrawingSurface2(new UnmanagedMethods.SIZE(),
-                    DirectXPixelFormat.B8G8R8A8UIntNormalized, DirectXAlphaMode.Premultiplied);
-                _surface = _drawingSurface.QueryInterface<ICompositionSurface>();
-                _surfaceInterop = _drawingSurface.QueryInterface<ICompositionDrawingSurfaceInterop>();
             }
             catch
             {
-                _surface?.Dispose();
-                _surfaceInterop?.Dispose();
-                _drawingSurface?.Dispose();
                 _compositionDevice2?.Dispose();
                 _compositionDevice?.Dispose();
                 _interop?.Dispose();
@@ -104,9 +105,9 @@ namespace Avalonia.Win32.WinRT.Composition
 
         public void Dispose()
         {
-            _surface.Dispose();
-            _surfaceInterop.Dispose();
-            _drawingSurface.Dispose();
+            _surface?.Dispose();
+            _surfaceInterop?.Dispose();
+            _drawingSurface?.Dispose();
             _compositionDevice2.Dispose();
             _compositionDevice.Dispose();
             _interop.Dispose();
@@ -114,19 +115,61 @@ namespace Avalonia.Win32.WinRT.Composition
             _d3dDevice.Dispose();
         }
 
+        [MemberNotNull(nameof(_drawingSurface), nameof(_surface), nameof(_surfaceInterop))]
+        private void CreateSurface(in IRenderTarget.RenderTargetSceneInfo sceneInfo)
+        {
+            bool isTransparency = sceneInfo.TransparencyLevel != CompositionTransparencyLevel.None;
+            var surfaceSize = sceneInfo.Size;
+
+            // Do not use Premultiplied when the window is not Transparency. Because the Premultiplied AlphaMode will increase the performance loss of DWM. See https://github.com/AvaloniaUI/Avalonia/issues/20643
+            var alphaMode = isTransparency ? DirectXAlphaMode.Premultiplied : DirectXAlphaMode.Ignore;
+            _drawingSurface = _compositionDevice2.CreateDrawingSurface2(new UnmanagedMethods.SIZE()
+                {
+                    X = surfaceSize.Width, 
+                    Y = surfaceSize.Height,
+                },
+                DirectXPixelFormat.B8G8R8A8UIntNormalized, alphaMode);
+            _surface = _drawingSurface.QueryInterface<ICompositionSurface>();
+            _surfaceInterop = _drawingSurface.QueryInterface<ICompositionDrawingSurfaceInterop>();
+
+            _isSurfaceSupportTransparency = isTransparency;
+            _size = surfaceSize;
+        }
+
         public PlatformRenderTargetState State =>
             _context.IsLost || _lost ? PlatformRenderTargetState.Corrupted : PlatformRenderTargetState.Ready;
 
-        public unsafe IDirect3D11TextureRenderTargetRenderSession BeginDraw()
+        IDirect3D11TextureRenderTargetRenderSession IDirect3D11TextureRenderTarget.BeginDraw()
+        {
+            var fallbackSceneInfo = new IRenderTarget.RenderTargetSceneInfo(_window.WindowInfo.Size,
+                _window.WindowInfo.Scaling, CompositionTransparencyLevel.None);
+            return BeginDraw(fallbackSceneInfo);
+        }
+
+        public unsafe IDirect3D11TextureRenderTargetRenderSession BeginDraw(
+            IRenderTarget.RenderTargetSceneInfo sceneInfo)
         {
             if (State.IsCorrupted)
                 throw new RenderTargetCorruptedException();
             var transaction = _window.BeginTransaction();
+
             bool needsEndDraw = false;
             try
             {
-                var size = _window.WindowInfo.Size;
-                var scale = _window.WindowInfo.Scaling;
+                bool isTransparency = sceneInfo.TransparencyLevel != CompositionTransparencyLevel.None;
+               
+                if (_surface is null || _surfaceInterop is null || _drawingSurface is null || _isSurfaceSupportTransparency != isTransparency)
+                {
+                    // Re-create the surface with correct alpha mode if the transparency support is not correct. This can happen when the transparency level is changed.
+                    _surface?.Dispose();
+                    _surfaceInterop?.Dispose();
+                    _drawingSurface?.Dispose();
+
+                    CreateSurface(in sceneInfo);
+                }
+
+                var size = sceneInfo.Size;
+                var scale = sceneInfo.Scaling;
                 _window.ResizeIfNeeded(size);
                 _window.SetSurface(_surface);
                 
@@ -165,7 +208,7 @@ namespace Avalonia.Win32.WinRT.Composition
                 if (transaction != null)
                 {
                     if (needsEndDraw)
-                        _surfaceInterop.EndDraw();
+                        _surfaceInterop?.EndDraw();
                     transaction.Dispose();
                 }
             }
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs
index 2c778c86c8..a858761a64 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -373,6 +373,13 @@ namespace Avalonia.Win32
 
         public void SetTransparencyLevelHint(IReadOnlyList<WindowTransparencyLevel> transparencyLevels)
         {
+            if (transparencyLevels.Count == 1 && transparencyLevels[0] == WindowTransparencyLevel.None)
+            {
+                // Explicitly disable transparency. Ignore the UseRedirectionBitmap property.
+                TransparencyLevel = WindowTransparencyLevel.None;
+                return;
+            }
+
             foreach (var level in transparencyLevels)
             {
                 if (!IsSupported(level))
diff --git a/tests/Avalonia.RenderTests/Media/BitmapTests.cs b/tests/Avalonia.RenderTests/Media/BitmapTests.cs
index cd5713b9a2..1db7556b46 100644
--- a/tests/Avalonia.RenderTests/Media/BitmapTests.cs
+++ b/tests/Avalonia.RenderTests/Media/BitmapTests.cs
@@ -8,6 +8,7 @@ using Avalonia.Media;
 using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 using Avalonia.Platform.Surfaces;
+using Avalonia.Rendering.Composition;
 using Xunit;
 using Path = System.IO.Path;
 
@@ -71,7 +72,7 @@ namespace Avalonia.Skia.RenderTests
             var r = AvaloniaLocator.Current.GetRequiredService<IPlatformRenderInterface>();
             using(var cpuContext = r.CreateBackendContext(null))
             using (var target = cpuContext.CreateRenderTarget(new IPlatformRenderSurface[] { fb }))
-            using (var ctx = target.CreateDrawingContext(new IRenderTarget.RenderTargetSceneInfo(fb.Size, 1), out _))
+            using (var ctx = target.CreateDrawingContext(new IRenderTarget.RenderTargetSceneInfo(fb.Size, 1, CompositionTransparencyLevel.None), out _))
             {
                 ctx.Clear(Colors.Transparent);
                 ctx.PushOpacity(0.8, new Rect(0, 0, 80, 80));

From b2c8170f955e2a1ef03283be262a55f2dccc98d0 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Fri, 19 Jun 2026 07:40:58 +0100
Subject: [PATCH 031/196] Implement Win32Properties.WindowCornerPreference
 (#21615)

* Implement Win32Properties.WindowCornerPreference

* Add corner preference to ControlCatalog

* Update API suppressions
---
 api/Avalonia.nupkg.xml                        | 12 +++
 samples/ControlCatalog/MainWindow.xaml        |  1 +
 .../Pages/WindowCustomizationsPage.xaml       | 13 +++
 .../ViewModels/MainWindowViewModel.cs         | 10 +-
 .../Platform/IWin32OptionsTopLevelImpl.cs     | 13 +--
 .../Platform/Win32Properties.cs               | 95 +++++++++++++++++--
 src/Windows/Avalonia.Win32/WindowImpl.cs      | 35 +++----
 7 files changed, 148 insertions(+), 31 deletions(-)

diff --git a/api/Avalonia.nupkg.xml b/api/Avalonia.nupkg.xml
index 590fbdc538..d66ef8f68d 100644
--- a/api/Avalonia.nupkg.xml
+++ b/api/Avalonia.nupkg.xml
@@ -97,4 +97,16 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Controls.Platform.IWin32OptionsTopLevelImpl.SetWindowCornerPreference(Avalonia.Controls.Win32Properties.WindowCornerPreference)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Controls.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Controls.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Controls.Platform.IWin32OptionsTopLevelImpl.SetWindowCornerPreference(Avalonia.Controls.Win32Properties.WindowCornerPreference)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Controls.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Controls.dll</Right>
+  </Suppression>
 </Suppressions>
diff --git a/samples/ControlCatalog/MainWindow.xaml b/samples/ControlCatalog/MainWindow.xaml
index 4c0118872b..d839689db7 100644
--- a/samples/ControlCatalog/MainWindow.xaml
+++ b/samples/ControlCatalog/MainWindow.xaml
@@ -12,6 +12,7 @@
         CanResize="{Binding CanResize}"
         CanMinimize="{Binding CanMinimize}"
         CanMaximize="{Binding CanMaximize}"
+        Win32Properties.WindowCornerPreference="{Binding Win32WindowCornerPreference}"
         x:Class="ControlCatalog.MainWindow" WindowState="{Binding WindowState, Mode=TwoWay}"
         x:DataType="vm:MainWindowViewModel">
   <NativeMenu.Menu>
diff --git a/samples/ControlCatalog/Pages/WindowCustomizationsPage.xaml b/samples/ControlCatalog/Pages/WindowCustomizationsPage.xaml
index a782dbec23..5114dd16e9 100644
--- a/samples/ControlCatalog/Pages/WindowCustomizationsPage.xaml
+++ b/samples/ControlCatalog/Pages/WindowCustomizationsPage.xaml
@@ -42,6 +42,19 @@
                 IsChecked="{Binding CanMaximize}"
                 IsEnabled="{Binding CanResize}" />
 
+      <DockPanel>
+
+        <Label Content="Corner Preference (Windows 11+): "
+               Margin="4"
+               DockPanel.Dock="Left" />
+
+        <ComboBox ItemsSource="{Binding Win32WindowCornerPreferences}"
+                  SelectedItem="{Binding Win32WindowCornerPreference, Mode=TwoWay}"
+                  HorizontalAlignment="Left"
+                  MinWidth="220" />
+
+      </DockPanel>
+
     </StackPanel>
 
     <StackPanel Spacing="10" Margin="25" IsEnabled="{OnFormFactor false, Mobile=true}">
diff --git a/samples/ControlCatalog/ViewModels/MainWindowViewModel.cs b/samples/ControlCatalog/ViewModels/MainWindowViewModel.cs
index 0d877b253f..5d14cca1ee 100644
--- a/samples/ControlCatalog/ViewModels/MainWindowViewModel.cs
+++ b/samples/ControlCatalog/ViewModels/MainWindowViewModel.cs
@@ -122,7 +122,6 @@ namespace ControlCatalog.ViewModels
             set { RaiseAndSetIfChanged(ref _selectedDecorationIndex, value); }
         }
 
-
         public MiniCommand AboutCommand { get; }
 
         public MiniCommand ExitCommand { get; }
@@ -138,5 +137,14 @@ namespace ControlCatalog.ViewModels
             get => _validatedDateExample;
             set => RaiseAndSetIfChanged(ref _validatedDateExample, value);
         }
+
+        public Win32Properties.WindowCornerPreference[] Win32WindowCornerPreferences { get; } =
+            Enum.GetValues<Win32Properties.WindowCornerPreference>();
+
+        public Win32Properties.WindowCornerPreference Win32WindowCornerPreference
+        {
+            get;
+            set { RaiseAndSetIfChanged(ref field, value); }
+        }
     }
 }
diff --git a/src/Avalonia.Controls/Platform/IWin32OptionsTopLevelImpl.cs b/src/Avalonia.Controls/Platform/IWin32OptionsTopLevelImpl.cs
index 2e363e647d..5346dee942 100644
--- a/src/Avalonia.Controls/Platform/IWin32OptionsTopLevelImpl.cs
+++ b/src/Avalonia.Controls/Platform/IWin32OptionsTopLevelImpl.cs
@@ -1,9 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Avalonia.Metadata;
+using Avalonia.Metadata;
 using Avalonia.Platform;
 using static Avalonia.Controls.Win32Properties;
 
@@ -21,5 +16,11 @@ namespace Avalonia.Controls.Platform
         /// Gets or sets a custom callback for the window's WndProc
         /// </summary>
         public CustomWndProcHookCallback? WndProcHookCallback { get; set; }
+
+        /// <summary>
+        /// Sets a window corner preference for the window.
+        /// </summary>
+        /// <param name="preference">The value to set.</param>
+        public void SetWindowCornerPreference(WindowCornerPreference preference);
     }
 }
diff --git a/src/Avalonia.Controls/Platform/Win32Properties.cs b/src/Avalonia.Controls/Platform/Win32Properties.cs
index b81a0c9771..9cf6d07aec 100644
--- a/src/Avalonia.Controls/Platform/Win32Properties.cs
+++ b/src/Avalonia.Controls/Platform/Win32Properties.cs
@@ -17,9 +17,38 @@ namespace Avalonia.Controls
     /// </summary>
     public static class Win32Properties
     {
+        /// <summary>
+        /// Defines the <c>NonClientHitTestResult</c> attached property.
+        /// </summary>
+        public static readonly AttachedProperty<Win32HitTestValue> NonClientHitTestResultProperty =
+            AvaloniaProperty.RegisterAttached<Visual, Win32HitTestValue>(
+                "NonClientHitTestResult",
+                typeof(Win32Properties),
+                inherits: true,
+                defaultValue: Win32HitTestValue.Client);
+
+        /// <summary>
+        /// Defines the <c>WindowCornerPreferenceProperty</c> attached property.
+        /// </summary>
+        public static readonly AttachedProperty<WindowCornerPreference> WindowCornerPreferenceProperty =
+            AvaloniaProperty.RegisterAttached<Window, WindowCornerPreference>(
+                "WindowCornerPreference",
+                typeof(Win32Properties),
+                defaultValue: WindowCornerPreference.Default,
+                validate: ValidateWindowCornerPreference);
+
         public delegate (uint style, uint exStyle) CustomWindowStylesCallback(uint style, uint exStyle);
         public delegate IntPtr CustomWndProcHookCallback(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam, ref bool handled);
 
+        static Win32Properties()
+        {
+            WindowCornerPreferenceProperty.Changed.AddClassHandler<Window>((window, e) =>
+            {
+                if (window.PlatformImpl is IWin32OptionsTopLevelImpl toplevelImpl)
+                    toplevelImpl.SetWindowCornerPreference(e.GetNewValue<WindowCornerPreference>());
+            });
+        }
+
         /// <summary>
         /// Adds a callback to set the window's style.
         /// </summary>
@@ -72,16 +101,48 @@ namespace Avalonia.Controls
             }
         }
 
-        public static readonly AttachedProperty<Win32HitTestValue> NonClientHitTestResultProperty =
-            AvaloniaProperty.RegisterAttached<Visual, Win32HitTestValue>(
-                "NonClientHitTestResult",
-                typeof(Win32Properties),
-                inherits: true,
-                defaultValue: Win32HitTestValue.Client);
+        /// <summary>
+        /// Sets the value of the <c>NonClientHitTestResult</c> attached property on the specified visual.
+        /// </summary>
+        /// <param name="obj">The visual.</param>
+        /// <param name="value">The value to set.</param>
+        public static void SetNonClientHitTestResult(Visual obj, Win32HitTestValue value)
+            => obj.SetValue(NonClientHitTestResultProperty, value);
+
+        /// <summary>
+        /// Gets the value of the <c>NonClientHitTestResult</c> attached property on the specified visual.
+        /// </summary>
+        /// <param name="obj">The visual.</param>
+        /// <returns>The hit test value for <paramref name="obj"/>.</returns>
+        public static Win32HitTestValue GetNonClientHitTestResult(Visual obj)
+            => obj.GetValue(NonClientHitTestResultProperty);
+
+        /// <summary>
+        /// Sets the value of the <c>WindowCornerPreference</c> attached property on the specified window.
+        /// </summary>
+        /// <param name="window">The window.</param>
+        /// <param name="value">The value to set.</param>
+        /// <remarks>
+        /// This value is supported starting with Windows 11 Build 22000.
+        /// It is ignored on earlier Windows versions.
+        /// </remarks>
+        public static void SetWindowCornerPreference(Window window, WindowCornerPreference value)
+            => window.SetValue(WindowCornerPreferenceProperty, value);
+
+        /// <summary>
+        /// Gets the value of the <c>WindowCornerPreference</c> attached property on the specified window.
+        /// </summary>
+        /// <param name="window">The window.</param>
+        /// <returns>The window corner preference for <paramref name="window"/>.</returns>
+        public static WindowCornerPreference GetWindowCornerPreference(Window window)
+            => window.GetValue(WindowCornerPreferenceProperty);
 
-        public static void SetNonClientHitTestResult(Visual obj, Win32HitTestValue value) => obj.SetValue(NonClientHitTestResultProperty, value);
-        public static Win32HitTestValue GetNonClientHitTestResult(Visual obj) => obj.GetValue(NonClientHitTestResultProperty);
+        private static bool ValidateWindowCornerPreference(WindowCornerPreference preference)
+            => preference is >= WindowCornerPreference.Default and <= WindowCornerPreference.RoundSmall;
 
+        /// <summary>
+        /// Represents a hit test value for a visual.
+        /// </summary>
         public enum Win32HitTestValue
         {
             Nowhere = 0,
@@ -99,5 +160,23 @@ namespace Avalonia.Controls
             BottomRight = 17,
             Close = 20,
         }
+
+        /// <summary>
+        /// Represents the rounded corner preference for a window.
+        /// </summary>
+        public enum WindowCornerPreference
+        {
+            /// <summary>Let the system decide when to round window corners.</summary>
+            Default = 0,
+
+            /// <summary>Never round window corners.</summary>
+            DoNotRound = 1,
+
+            /// <summary>Round the corners, if appropriate.</summary>
+            Round = 2,
+
+            /// <summary>Round the corners if appropriate, with a small radius.</summary>
+            RoundSmall = 3
+        }
     }
 }
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs
index a858761a64..a39fa9c1cb 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -108,6 +108,7 @@ namespace Avalonia.Win32
         internal bool _ignoreWmChar;
         private WindowTransparencyLevel _transparencyLevel;
         private readonly WindowTransparencyLevel _defaultTransparencyLevel;
+        private WindowCornerPreference _cornerPreference;
 
         private const int MaxPointerHistorySize = 512;
         private static readonly PooledList<RawPointerPoint> s_intermediatePointsPooledList = new();
@@ -1197,6 +1198,18 @@ namespace Avalonia.Win32
             return margins;
         }
 
+        private void UpdateWindowCornerPreference()
+        {
+            if (!OperatingSystem.IsWindowsVersionAtLeast(10, 0, 22000))
+                return;
+
+            unsafe
+            {
+                var preference = (int)_cornerPreference;
+                DwmSetWindowAttribute(_hwnd, (int)DwmWindowAttribute.DWMWA_WINDOW_CORNER_PREFERENCE, &preference, sizeof(int));
+            }
+        }
+
         private void ExtendClientArea()
         {
             if (!_shown)
@@ -1219,10 +1232,6 @@ namespace Avalonia.Win32
 
                 // Make sure that Windows still paints the non-client area so we get native borders and shadows.
                 SetNCRenderingPolicy(DwmNCRenderingPolicy.DWMNCRP_ENABLED);
-
-                // On Windows 11 21H2 and later, corners are configurable.
-                if (OperatingSystem.IsWindowsVersionAtLeast(10, 0, 22000))
-                    SetWindowCornerPreference(DwmWindowCornerPreference.DWMWCP_ROUND);
             }
             else
             {
@@ -1231,16 +1240,7 @@ namespace Avalonia.Win32
 
                 _extendedMargins = new Thickness();
 
-                if (OperatingSystem.IsWindowsVersionAtLeast(10, 0, 22000))
-                    SetWindowCornerPreference(DwmWindowCornerPreference.DWMWCP_DEFAULT);
-
                 SetNCRenderingPolicy(DwmNCRenderingPolicy.DWMNCRP_USEWINDOWSTYLE);
-
-                unsafe
-                {
-                    int cornerPreference = (int)DwmWindowCornerPreference.DWMWCP_DEFAULT;
-                    DwmSetWindowAttribute(_hwnd, (int)DwmWindowAttribute.DWMWA_WINDOW_CORNER_PREFERENCE, &cornerPreference, sizeof(int));
-                }
             }
 
             if (!_isClientAreaExtended)
@@ -1262,9 +1262,6 @@ namespace Avalonia.Win32
             ExtendClientAreaToDecorationsChanged?.Invoke(_isClientAreaExtended);
         }
 
-        private unsafe void SetWindowCornerPreference(DwmWindowCornerPreference value)
-            => DwmSetWindowAttribute(_hwnd, (int)DwmWindowAttribute.DWMWA_WINDOW_CORNER_PREFERENCE, &value, sizeof(int));
-
         private unsafe void SetNCRenderingPolicy(DwmNCRenderingPolicy value)
             => DwmSetWindowAttribute(_hwnd, (int)DwmWindowAttribute.DWMWA_NCRENDERING_POLICY, &value, sizeof(int));
 
@@ -1615,6 +1612,12 @@ namespace Avalonia.Win32
             ExtendClientArea();
         }
 
+        public void SetWindowCornerPreference(WindowCornerPreference preference)
+        {
+            _cornerPreference = preference;
+            UpdateWindowCornerPreference();
+        }
+
         /// <inheritdoc/>
         public bool IsClientAreaExtendedToDecorations => _isClientAreaExtended;
 

From 3fd2da5701a802b9a7301898599f516ab530bdf3 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Fri, 19 Jun 2026 07:53:16 +0100
Subject: [PATCH 032/196] X11: fix invisible window when un-minimizing (#21614)

---
 src/Avalonia.X11/X11Window.cs                 | 21 +++++++++++++++----
 .../X11WindowModes/DefaultWindowMode.cs       |  5 +++--
 src/Avalonia.X11/X11WindowModes/WindowMode.cs |  3 ++-
 3 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index 6926758fe3..ef644e2c72 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -62,6 +62,7 @@ namespace Avalonia.X11
         private XSyncState _xSyncState = 0;
         private bool _mapped;
         private bool _wasMappedAtLeastOnce = false;
+        private bool _shown;
         private double? _scalingOverride;
         private bool _disabled;
         private TransparencyHelper? _transparencyHelper;
@@ -797,13 +798,21 @@ namespace Avalonia.X11
             get => _lastWindowState;
             set
             {
-                if(_lastWindowState == value)
+                var previousState = _lastWindowState;
+                if (previousState == value)
                     return;
+
                 if (value == WindowState.Minimized)
                 {
                     XIconifyWindow(_x11.Display, _handle, _x11.DefaultScreen);
+                    return;
                 }
-                else if (value == WindowState.Maximized)
+
+                // When going from Minimized to any other state programatically, we might need to re-map the window.
+                // Not doing that will leave the window invisible.
+                var needsRemap = _shown && previousState == WindowState.Minimized && !_mapped;
+
+                if (value == WindowState.Maximized)
                 {
                     ChangeWMAtoms(false, _x11.Atoms._NET_WM_STATE_HIDDEN);
                     ChangeWMAtoms(false, _x11.Atoms._NET_WM_STATE_FULLSCREEN);
@@ -823,9 +832,13 @@ namespace Avalonia.X11
                     ChangeWMAtoms(false, _x11.Atoms._NET_WM_STATE_FULLSCREEN);
                     ChangeWMAtoms(false, _x11.Atoms._NET_WM_STATE_MAXIMIZED_VERT,
                         _x11.Atoms._NET_WM_STATE_MAXIMIZED_HORZ);
-                    SendNetWMMessage(_x11.Atoms._NET_ACTIVE_WINDOW, (IntPtr)1, _x11.LastActivityTimestamp,
-                        IntPtr.Zero);
                 }
+
+                if (needsRemap)
+                    XMapWindow(_x11.Display, _handle);
+
+                if (_shown)
+                    SendNetWMMessage(_x11.Atoms._NET_ACTIVE_WINDOW, 1, _x11.LastActivityTimestamp, 0);
             }
         }
 
diff --git a/src/Avalonia.X11/X11WindowModes/DefaultWindowMode.cs b/src/Avalonia.X11/X11WindowModes/DefaultWindowMode.cs
index af7b56788d..b2a8910d76 100644
--- a/src/Avalonia.X11/X11WindowModes/DefaultWindowMode.cs
+++ b/src/Avalonia.X11/X11WindowModes/DefaultWindowMode.cs
@@ -30,7 +30,9 @@ partial class X11Window
         }
 
         public override void Show(bool activate, bool isDialog)
-        {            
+        {
+            base.Show(activate, isDialog);
+
             Window._wasMappedAtLeastOnce = true;
 
             if (!activate)
@@ -42,7 +44,6 @@ partial class X11Window
 
             XMapWindow(X11.Display, Handle);
             XFlush(X11.Display);
-            base.Show(activate, isDialog);
         }
 
         public override void Hide()
diff --git a/src/Avalonia.X11/X11WindowModes/WindowMode.cs b/src/Avalonia.X11/X11WindowModes/WindowMode.cs
index 20df7d93e9..868592cf45 100644
--- a/src/Avalonia.X11/X11WindowModes/WindowMode.cs
+++ b/src/Avalonia.X11/X11WindowModes/WindowMode.cs
@@ -47,7 +47,7 @@ partial class X11Window
 
         public virtual void Show(bool activate, bool isDialog)
         {
-
+            Window._shown = true;
         }
 
         public abstract PixelPoint PointToScreen(Point pt);
@@ -55,6 +55,7 @@ partial class X11Window
 
         public virtual void Hide()
         {
+            Window._shown = false;
         }
     }
 }

From 6d950d8e15fe8624acc717e5fdeec6bde1edab03 Mon Sep 17 00:00:00 2001
From: Max Katz <maxkatz6@outlook.com>
Date: Thu, 18 Jun 2026 23:55:34 -0700
Subject: [PATCH 033/196] Compiled Bindings: Fix unpredictable binding to
 method selection (#21617)

* Fix unpredictable binding to method selection (compiled bindings)

* Adjust tests

* Add more test cases
---
 .../XamlIlBindingPathHelper.cs                | 21 ++++++++++--
 .../XamlIlTrampolineBuilder.cs                | 21 ++----------
 .../CompiledBindingExtensionTests.cs          | 34 ++++++++++---------
 3 files changed, 40 insertions(+), 36 deletions(-)

diff --git a/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlBindingPathHelper.cs b/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlBindingPathHelper.cs
index e83807ea93..84af961431 100644
--- a/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlBindingPathHelper.cs
+++ b/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlBindingPathHelper.cs
@@ -210,9 +210,26 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                             {
                                 nodes.Add(new XamlIlClrPropertyPathElementNode(clrProperty, propName.AcceptsNull));
                             }
-                            else if (GetAllDefinedMethods(targetType).FirstOrDefault(m => m.Name == propName.PropertyName) is IXamlMethod method)
+                            else if (GetAllDefinedMethods(targetType)
+                                         .Where(p => p.Name == propName.PropertyName)
+                                         .OrderByDescending(m => m.Parameters.Count)
+                                         .ToArray()
+                                     is { Length: > 0 } methodCandidates)
                             {
-                                nodes.Add(new XamlIlClrMethodPathElementNode(method, context.Configuration.WellKnownTypes.Delegate, propName.AcceptsNull));
+                                var objType = context.Configuration.WellKnownTypes.Object;
+                                var candidate = methodCandidates
+                                    .FirstOrDefault(m => m.Parameters.Count == 0
+                                                         || (m.Parameters.Count == 1 &&
+                                                             m.Parameters[0].Equals(objType)));
+                                if (candidate is null)
+                                {
+                                    throw new XamlX.XamlTransformException(
+                                        $"Unable to resolve method of name '{propName.PropertyName}' on type '{targetType}'." +
+                                        $"Expected method with no parameters or a single object overload.",
+                                        lineInfo);
+                                }
+            
+                                nodes.Add(new XamlIlClrMethodPathElementNode(candidate, context.Configuration.WellKnownTypes.Delegate, propName.AcceptsNull));
                             }
                             else
                             {
diff --git a/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlTrampolineBuilder.cs b/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlTrampolineBuilder.cs
index ae26aec993..5245fa7d3c 100644
--- a/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlTrampolineBuilder.cs
+++ b/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlTrampolineBuilder.cs
@@ -48,24 +48,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             }
             if (executeMethod.Parameters.Count != 0)
             {
-                Debug.Assert(executeMethod.Parameters.Count == 1);
-                if (executeMethod.Parameters[0] != context.Configuration.WellKnownTypes.Object)
-                {
-                    var convertedValue = gen.DefineLocal(context.Configuration.WellKnownTypes.Object);
-                    gen.Ldtype(executeMethod.Parameters[0])
-                        .Ldarg(1)
-                        .EmitCall(context.Configuration.WellKnownTypes.CultureInfo.GetMethod(m => m.Name == "get_CurrentCulture"))
-                        .Ldloca(convertedValue)
-                        .EmitCall(
-                            context.GetAvaloniaTypes().TypeUtilities.GetMethod(m => m.Name == "TryConvert"),
-                            swallowResult: true)
-                        .Ldloc(convertedValue)
-                        .Unbox_Any(executeMethod.Parameters[0]);
-                }
-                else
-                {
-                    gen.Ldarg(1);
-                }
+                Debug.Assert(executeMethod.Parameters.Count == 1
+                             && executeMethod.Parameters[0] == context.Configuration.WellKnownTypes.Object);
+                gen.Ldarg(1);
             }
             gen.EmitCall(executeMethod, swallowResult: true);
             gen.Ret();
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs
index 99a79ded75..d3374ce8ad 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs
@@ -1863,8 +1863,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions
     <StackPanel>
         <ContentControl Content='{CompiledBinding Action}' Name='action' />
         <ContentControl Content='{CompiledBinding Func}' Name='func' />
-        <ContentControl Content='{CompiledBinding Action16}' Name='action16' />
-        <ContentControl Content='{CompiledBinding Func16}' Name='func16' />
+        <ContentControl Content='{CompiledBinding Func2}' Name='func2' />
         <ContentControl Content='{CompiledBinding CustomDelegateTypeVoid}' Name='customvoid' />
         <ContentControl Content='{CompiledBinding CustomDelegateTypeInt}' Name='customint' />
     </StackPanel>
@@ -1873,9 +1872,8 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions
                 window.DataContext = new MethodDataContext();
 
                 Assert.IsAssignableFrom(typeof(Action), window.GetControl<ContentControl>("action").Content);
-                Assert.IsAssignableFrom(typeof(Func<int>), window.GetControl<ContentControl>("func").Content);
-                Assert.IsAssignableFrom(typeof(Action<int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int>), window.GetControl<ContentControl>("action16").Content);
-                Assert.IsAssignableFrom(typeof(Func<int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int>), window.GetControl<ContentControl>("func16").Content);
+                Assert.IsAssignableFrom(typeof(Func<object>), window.GetControl<ContentControl>("func").Content);
+                Assert.IsAssignableFrom(typeof(Func<object, object>), window.GetControl<ContentControl>("func2").Content);
                 Assert.True(typeof(Delegate).IsAssignableFrom(window.GetControl<ContentControl>("customvoid").Content!.GetType()));
                 Assert.True(typeof(Delegate).IsAssignableFrom(window.GetControl<ContentControl>("customint").Content!.GetType()));
             }
@@ -1906,17 +1904,20 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions
             }
         }
 
-        [Fact]
-        public void Binding_Method_With_Parameter_To_Command_Works()
+        [Theory]
+        [InlineData("5")]
+        [InlineData("hello")]
+        [InlineData(null)]
+        public void Binding_Method_With_Parameter_To_Command_Works(string? parameter)
         {
             using (UnitTestApplication.Start(TestServices.StyledWindow))
             {
-                var xaml = @"
+                var xaml = $@"
 <Window xmlns='https://github.com/avaloniaui'
         xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
         xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.MarkupExtensions;assembly=Avalonia.Markup.Xaml.UnitTests'
         x:DataType='local:MethodAsCommandDataContext'>
-    <Button Name='button' Command='{CompiledBinding Method1}' CommandParameter='5'/>
+    <Button Name='button' Command='{{CompiledBinding Method1}}' CommandParameter='{ parameter ?? "{x:Null}" }'/>
 </Window>";
                 var window = (Window)AvaloniaRuntimeXamlLoader.Load(xaml);
                 var button = window.GetControl<Button>("button");
@@ -1927,7 +1928,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions
 
                 Assert.NotNull(button.Command);
                 PerformClick(button);
-                Assert.Equal("Called 5", vm.Value);
+                Assert.Equal("Called " + parameter, vm.Value);
             }
         }
 
@@ -2533,12 +2534,11 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions
     {
         public void Action() { }
 
-        public int Func() => 1;
+        public object Func() => 1;
+        public object Func2(object i) => i;
 
-        public void Action16(int i, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9, int i10, int i11, int i12, int i13, int i14, int i15, int i16) { }
-        public int Func16(int i, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9, int i10, int i11, int i12, int i13, int i14, int i15, int i16) => i;
-        public void CustomDelegateTypeVoid(int i, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9, int i10, int i11, int i12, int i13, int i14, int i15, int i16, int i17) { }
-        public int CustomDelegateTypeInt(int i, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9, int i10, int i11, int i12, int i13, int i14, int i15, int i16, int i17) => i;
+        public void CustomDelegateTypeVoid(object i) { }
+        public object CustomDelegateTypeInt(object i) => i;
     }
 
     public class MethodAsCommandDataContext : INotifyPropertyChanged
@@ -2546,7 +2546,9 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions
         public event PropertyChangedEventHandler? PropertyChanged;
 
         public string Method() => Value = "Called";
-        public string Method1(int i) => Value = $"Called {i}";
+        public string Method1() => Value = "Called";
+        public string Method1(int i) => throw new InvalidOperationException("Binding to method with typed parameters is not supported");
+        public string Method1(object i) => Value = $"Called {i}";
         public string Method2(int i, int j) => Value = $"Called {i},{j}";
         public string Value { get; private set; } = "Not called";
 

From 573849844abc338de12f416550eeaec4ac6a439a Mon Sep 17 00:00:00 2001
From: Max Katz <maxkatz6@outlook.com>
Date: Fri, 19 Jun 2026 00:50:31 -0700
Subject: [PATCH 034/196] New pass of AOT warning fixes (#21616)

* Use CompiledBinding.Create where possible in sample code

* Avoid "FullyQualifiedName" hacks, use AppContext.BaseDirectory

* Avoid ambigious binding to methods in the sample code

* Use ProcessPath, there are no "dll" in aot

* Disable devtools in release

* Remove "DefineDynamicAssembly" used for persistent assemblies output, we don't target net framework anymore

* Add RequiresDynamicCode to the runtime XAML loader

* Bump XAML

* Bump XAML
---
 Directory.Packages.props                      |  2 +-
 build/SampleApp.props                         |  2 +-
 external/XamlX                                |  2 +-
 samples/AppWithoutLifetime/Program.cs         |  2 +
 samples/BindingDemo/App.xaml.cs               |  2 +
 .../NativeControls/Gtk/EmbedSample.Gtk.cs     |  7 +-
 samples/ControlCatalog.Desktop/Program.cs     |  2 +
 .../Pages/AutoCompleteBoxPage.xaml.cs         |  4 +-
 .../CarouselPage/CareCompanionAppPage.xaml.cs |  3 +-
 .../Pages/DragAndDropPage.xaml.cs             |  7 +-
 .../Pages/NotificationsPage.xaml              |  6 +-
 .../Pages/NotificationsPage.xaml.cs           | 10 ++-
 samples/GpuInterop/Program.cs                 |  2 +
 samples/IntegrationTestApp/Program.cs         |  2 +
 samples/RenderDemo/App.xaml.cs                |  4 +-
 samples/SafeAreaDemo.Desktop/Program.cs       |  2 +
 samples/Sandbox/Program.cs                    |  2 +
 samples/TextTestApp/Program.cs                |  2 +
 samples/VirtualizationDemo/Program.cs         |  2 +
 .../AvaloniaRuntimeXamlLoader.cs              | 18 ++--
 .../AvaloniaXamlIlRuntimeCompiler.cs          | 85 +++----------------
 21 files changed, 68 insertions(+), 100 deletions(-)

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 176c4b731c..da5809c36d 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -7,7 +7,7 @@
     <PackageVersion Include="Appium.WebDriver" Version="5.2.0" />
     <PackageVersion Include="Avalonia.Angle.Windows.Natives" Version="2.1.27548.20260419" />
     <PackageVersion Include="Avalonia.BuildServices" Version="11.3.2" />
-    <PackageVersion Include="AvaloniaUI.DiagnosticsSupport" Version="2.2.1" />
+    <PackageVersion Include="AvaloniaUI.DiagnosticsSupport" Version="2.2.2" />
     <PackageVersion Include="BenchmarkDotNet" Version="0.15.6" />
     <PackageVersion Include="CommunityToolkit.Mvvm" Version="8.4.0" />
     <PackageVersion Include="Dotnet.Bundle" Version="0.9.13" />
diff --git a/build/SampleApp.props b/build/SampleApp.props
index 6816a38cbe..e8a9b9166e 100644
--- a/build/SampleApp.props
+++ b/build/SampleApp.props
@@ -14,7 +14,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="AvaloniaUI.DiagnosticsSupport" />
+    <PackageReference Include="AvaloniaUI.DiagnosticsSupport" Condition="'$(Configuration)' == 'Debug'" />
   </ItemGroup>
 
   <Target Name="GatherReferences" AfterTargets="CoreCompile">
diff --git a/external/XamlX b/external/XamlX
index 86f5a26fad..d7e37ca63d 160000
--- a/external/XamlX
+++ b/external/XamlX
@@ -1 +1 @@
-Subproject commit 86f5a26fadb745e95169c3c805ebd9fd7c9b44d2
+Subproject commit d7e37ca63dc9b13cdc95ca165938d4904fa0eddf
diff --git a/samples/AppWithoutLifetime/Program.cs b/samples/AppWithoutLifetime/Program.cs
index 60ab32824e..80be3f76bd 100644
--- a/samples/AppWithoutLifetime/Program.cs
+++ b/samples/AppWithoutLifetime/Program.cs
@@ -24,6 +24,8 @@ class Program
     public static AppBuilder BuildAvaloniaApp()
         => AppBuilder.Configure<App>()
             .UsePlatformDetect()
+#if DEBUG
             .WithDeveloperTools()
+#endif
             .LogToTrace();
 }
diff --git a/samples/BindingDemo/App.xaml.cs b/samples/BindingDemo/App.xaml.cs
index e76f61ac63..d6ba950382 100644
--- a/samples/BindingDemo/App.xaml.cs
+++ b/samples/BindingDemo/App.xaml.cs
@@ -24,7 +24,9 @@ namespace BindingDemo
         public static AppBuilder BuildAvaloniaApp()
           => AppBuilder.Configure<App>()
                 .UsePlatformDetect()
+#if DEBUG
                 .WithDeveloperTools()
+#endif
                 .LogToTrace();
     }
 }
diff --git a/samples/ControlCatalog.Desktop/NativeControls/Gtk/EmbedSample.Gtk.cs b/samples/ControlCatalog.Desktop/NativeControls/Gtk/EmbedSample.Gtk.cs
index 523503cc38..e02b1b7428 100644
--- a/samples/ControlCatalog.Desktop/NativeControls/Gtk/EmbedSample.Gtk.cs
+++ b/samples/ControlCatalog.Desktop/NativeControls/Gtk/EmbedSample.Gtk.cs
@@ -21,10 +21,11 @@ public class EmbedSampleGtk : INativeDemoControl
         }
 
         var control = createDefault();
-        var nodes = Path.GetFullPath(Path.Combine(typeof(EmbedSample).Assembly.GetModules()[0].FullyQualifiedName,
-            "..", "NativeControls", "Gtk", "nodes.mp4"));
+        var nodesFile = Path.Combine(AppContext.BaseDirectory, "NativeControls", "Gtk", "nodes.mp4");
+        nodesFile = Path.GetFullPath(nodesFile);
+
         _mplayer = Process.Start(new ProcessStartInfo("mplayer",
-            $"-vo x11 -zoom -loop 0 -wid {control.Handle.ToInt64()} \"{nodes}\"")
+            $"-vo x11 -zoom -loop 0 -wid {control.Handle.ToInt64()} \"{nodesFile}\"")
         {
             UseShellExecute = false,
 
diff --git a/samples/ControlCatalog.Desktop/Program.cs b/samples/ControlCatalog.Desktop/Program.cs
index 819072db18..1f553d116e 100644
--- a/samples/ControlCatalog.Desktop/Program.cs
+++ b/samples/ControlCatalog.Desktop/Program.cs
@@ -162,7 +162,9 @@ namespace ControlCatalog.Desktop
                 })
                 .UseSkia()
                 .WithInterFont()
+#if DEBUG
                 .WithDeveloperTools()
+#endif
                 .AfterSetup(builder =>
                 {
                     EmbedSample.Implementation = OperatingSystem.IsWindows() ? new EmbedSampleWin()
diff --git a/samples/ControlCatalog/Pages/AutoCompleteBoxPage.xaml.cs b/samples/ControlCatalog/Pages/AutoCompleteBoxPage.xaml.cs
index 295aa9d139..1624fc563f 100644
--- a/samples/ControlCatalog/Pages/AutoCompleteBoxPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/AutoCompleteBoxPage.xaml.cs
@@ -102,8 +102,8 @@ namespace ControlCatalog.Pages
                 return String.Format("{0} ({1})", parts.ToArray());
             });
             var binding = new MultiBinding { Converter = converter };
-            binding.Bindings.Add(new Binding("Name"));
-            binding.Bindings.Add(new Binding("Abbreviation"));
+            binding.Bindings.Add(CompiledBinding.Create<StateData, string>(s => s.Name));
+            binding.Bindings.Add(CompiledBinding.Create<StateData, string>(s => s.Abbreviation));
 
             MultiBindingBox.ValueMemberBinding = binding;
 
diff --git a/samples/ControlCatalog/Pages/CarouselPage/CareCompanionAppPage.xaml.cs b/samples/ControlCatalog/Pages/CarouselPage/CareCompanionAppPage.xaml.cs
index bc8be3ea87..16f1ba0ddc 100644
--- a/samples/ControlCatalog/Pages/CarouselPage/CareCompanionAppPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/CarouselPage/CareCompanionAppPage.xaml.cs
@@ -5,6 +5,7 @@ using Avalonia.Animation;
 using Avalonia.Controls;
 using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Primitives;
+using Avalonia.Data;
 using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
@@ -130,7 +131,7 @@ public partial class CareCompanionAppPage : UserControl
         };
 
         pager.Bind(PipsPager.SelectedPageIndexProperty,
-            new Avalonia.Data.Binding("SelectedIndex") { Source = carousel, Mode = Avalonia.Data.BindingMode.TwoWay });
+            CompiledBinding.Create<AvaCarouselPage, int>(c => c.SelectedIndex, carousel, mode: BindingMode.TwoWay));
 
         return pager;
     }
diff --git a/samples/ControlCatalog/Pages/DragAndDropPage.xaml.cs b/samples/ControlCatalog/Pages/DragAndDropPage.xaml.cs
index b2a91da381..dcffeb611e 100644
--- a/samples/ControlCatalog/Pages/DragAndDropPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/DragAndDropPage.xaml.cs
@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
@@ -38,9 +39,11 @@ namespace ControlCatalog.Pages
                 "Files",
                 async d =>
                 {
-                    if (Assembly.GetEntryAssembly()?.GetModules().FirstOrDefault()?.FullyQualifiedName is { } name &&
+                    var currentFile = Environment.ProcessPath;
+
+                    if (File.Exists(currentFile) &&
                         TopLevel.GetTopLevel(this) is { } topLevel &&
-                        await topLevel.StorageProvider.TryGetFileFromPathAsync(name) is { } storageFile)
+                        await topLevel.StorageProvider.TryGetFileFromPathAsync(currentFile) is { } storageFile)
                     {
                         d.Add(DataTransferItem.Create(DataFormat.File, storageFile));
                     }
diff --git a/samples/ControlCatalog/Pages/NotificationsPage.xaml b/samples/ControlCatalog/Pages/NotificationsPage.xaml
index 2ae1db7d43..61d8afdea4 100644
--- a/samples/ControlCatalog/Pages/NotificationsPage.xaml
+++ b/samples/ControlCatalog/Pages/NotificationsPage.xaml
@@ -17,11 +17,7 @@
     <TextBlock DockPanel.Dock="Top"
                Margin="2" Classes="h2" TextWrapping="Wrap">XAML only notification manager.</TextBlock>
     <Button DockPanel.Dock="Top"
-            Content="Show XAML only Notification" Command="{Binding #ControlNotifications.Show}">
-      <Button.CommandParameter>
-        <Notification Title="Title" Message="Message" OnClick="NotificationOnClick" />
-      </Button.CommandParameter>
-    </Button>
+            Content="Show XAML only Notification" Click="ShowNotification" />
     <Border Padding="10" BorderBrush="{DynamicResource SystemAccentColor}">
       <WindowNotificationManager x:Name="ControlNotifications" />
     </Border>
diff --git a/samples/ControlCatalog/Pages/NotificationsPage.xaml.cs b/samples/ControlCatalog/Pages/NotificationsPage.xaml.cs
index 5ff67e10dc..cc1ad3481c 100644
--- a/samples/ControlCatalog/Pages/NotificationsPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/NotificationsPage.xaml.cs
@@ -1,6 +1,7 @@
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.Notifications;
+using Avalonia.Interactivity;
 using ControlCatalog.ViewModels;
 
 namespace ControlCatalog.Pages
@@ -25,9 +26,14 @@ namespace ControlCatalog.Pages
             _viewModel.NotificationManager = new WindowNotificationManager(TopLevel.GetTopLevel(this)!);
         }
 
-        public void NotificationOnClick()
+        private void ShowNotification(object? sender, RoutedEventArgs e)
         {
-            ControlNotifications.Show("Notification clicked");
+            ControlNotifications.Show(new Notification
+            {
+                OnClick = () => ControlNotifications.Show("Notification clicked"),
+                Title = "Title",
+                Message = "Message"
+            });
         }
     }
 }
diff --git a/samples/GpuInterop/Program.cs b/samples/GpuInterop/Program.cs
index 46cf738304..8bfddfdf5e 100644
--- a/samples/GpuInterop/Program.cs
+++ b/samples/GpuInterop/Program.cs
@@ -34,7 +34,9 @@ namespace GpuInterop
                         UseDebug = true
                     }
                 })
+#if DEBUG
                 .WithDeveloperTools()
+#endif
                 .LogToTrace(LogEventLevel.Debug, "Vulkan");
     }
 }
diff --git a/samples/IntegrationTestApp/Program.cs b/samples/IntegrationTestApp/Program.cs
index 29b7557f6a..c2655178cd 100644
--- a/samples/IntegrationTestApp/Program.cs
+++ b/samples/IntegrationTestApp/Program.cs
@@ -31,7 +31,9 @@ namespace IntegrationTestApp
         public static AppBuilder BuildAvaloniaApp()
             => AppBuilder.Configure<App>()
                 .UsePlatformDetect()
+#if DEBUG
                 .WithDeveloperTools()
+#endif
                 .AfterSetup(builder =>
                 {
                     NativeTextBox.Factory = 
diff --git a/samples/RenderDemo/App.xaml.cs b/samples/RenderDemo/App.xaml.cs
index e08c48475b..b1e44a2e96 100644
--- a/samples/RenderDemo/App.xaml.cs
+++ b/samples/RenderDemo/App.xaml.cs
@@ -31,7 +31,9 @@ namespace RenderDemo
                    OverlayPopups = true,
                })
                 .UsePlatformDetect()
-                .WithDeveloperTools()
+#if DEBUG
+               .WithDeveloperTools()
+#endif
                 .LogToTrace();
     }
 }
diff --git a/samples/SafeAreaDemo.Desktop/Program.cs b/samples/SafeAreaDemo.Desktop/Program.cs
index 05593b3313..f8d86a8c00 100644
--- a/samples/SafeAreaDemo.Desktop/Program.cs
+++ b/samples/SafeAreaDemo.Desktop/Program.cs
@@ -16,7 +16,9 @@ namespace SafeAreaDemo.Desktop
         public static AppBuilder BuildAvaloniaApp()
             => AppBuilder.Configure<App>()
                 .UsePlatformDetect()
+#if DEBUG
                 .WithDeveloperTools()
+#endif
                 .LogToTrace();
     }
 }
diff --git a/samples/Sandbox/Program.cs b/samples/Sandbox/Program.cs
index b676992111..551d6deb23 100644
--- a/samples/Sandbox/Program.cs
+++ b/samples/Sandbox/Program.cs
@@ -10,7 +10,9 @@ namespace Sandbox
         public static AppBuilder BuildAvaloniaApp() =>
             AppBuilder.Configure<App>()
                 .UsePlatformDetect()
+#if DEBUG
                 .WithDeveloperTools()
+#endif
                 .LogToTrace();
     }
 }
diff --git a/samples/TextTestApp/Program.cs b/samples/TextTestApp/Program.cs
index e3931f97d8..3fc3ee2bcd 100644
--- a/samples/TextTestApp/Program.cs
+++ b/samples/TextTestApp/Program.cs
@@ -23,7 +23,9 @@ namespace TextTestApp
         {
             return AppBuilder.Configure<App>()
                 .UsePlatformDetect()
+#if DEBUG
                 .WithDeveloperTools()
+#endif
                 .LogToTrace();
         }
     }
diff --git a/samples/VirtualizationDemo/Program.cs b/samples/VirtualizationDemo/Program.cs
index dd289b3b25..2bed2ba006 100644
--- a/samples/VirtualizationDemo/Program.cs
+++ b/samples/VirtualizationDemo/Program.cs
@@ -7,7 +7,9 @@ class Program
     public static AppBuilder BuildAvaloniaApp()
         => AppBuilder.Configure<App>()
             .UsePlatformDetect()
+#if DEBUG
             .WithDeveloperTools()
+#endif
             .LogToTrace();
 
     public static int Main(string[] args)
diff --git a/src/Markup/Avalonia.Markup.Xaml.Loader/AvaloniaRuntimeXamlLoader.cs b/src/Markup/Avalonia.Markup.Xaml.Loader/AvaloniaRuntimeXamlLoader.cs
index eb153f7d0c..b4d26b7134 100644
--- a/src/Markup/Avalonia.Markup.Xaml.Loader/AvaloniaRuntimeXamlLoader.cs
+++ b/src/Markup/Avalonia.Markup.Xaml.Loader/AvaloniaRuntimeXamlLoader.cs
@@ -21,7 +21,8 @@ namespace Avalonia.Markup.Xaml
         /// <param name="uri">The URI of the XAML being loaded.</param>
         /// <param name="designMode">Indicates whether the XAML is being loaded in design mode.</param>
         /// <returns>The loaded object.</returns>
-        [RequiresUnreferencedCode(XamlX.TrimmingMessages.DynamicXamlReference)]
+        [RequiresUnreferencedCode(XamlX.TrimmingMessages.Sre)]
+        [RequiresDynamicCode(XamlX.TrimmingMessages.Sre)]
         public static object Load([StringSyntax(StringSyntaxAttribute.Xml)] string xaml, Assembly? localAssembly = null, object? rootInstance = null, Uri? uri = null, bool designMode = false)
         {
             xaml = xaml ?? throw new ArgumentNullException(nameof(xaml));
@@ -41,7 +42,8 @@ namespace Avalonia.Markup.Xaml
         /// <param name="uri">The URI of the XAML being loaded.</param>
         /// <param name="designMode">Indicates whether the XAML is being loaded in design mode.</param>
         /// <returns>The loaded object.</returns>
-        [RequiresUnreferencedCode(XamlX.TrimmingMessages.DynamicXamlReference)]
+        [RequiresUnreferencedCode(XamlX.TrimmingMessages.Sre)]
+        [RequiresDynamicCode(XamlX.TrimmingMessages.Sre)]
         public static object Load(Stream stream, Assembly? localAssembly = null, object? rootInstance = null, Uri? uri = null,
             bool designMode = false)
             => AvaloniaXamlIlRuntimeCompiler.Load(new RuntimeXamlLoaderDocument(uri, rootInstance, stream),
@@ -53,7 +55,8 @@ namespace Avalonia.Markup.Xaml
         /// <param name="document">The stream containing the XAML.</param>
         /// <param name="configuration">Xaml loader configuration.</param>
         /// <returns>The loaded object.</returns>
-        [RequiresUnreferencedCode(XamlX.TrimmingMessages.DynamicXamlReference)]
+        [RequiresUnreferencedCode(XamlX.TrimmingMessages.Sre)]
+        [RequiresDynamicCode(XamlX.TrimmingMessages.Sre)]
         public static object Load(RuntimeXamlLoaderDocument document, RuntimeXamlLoaderConfiguration? configuration = null)
             => AvaloniaXamlIlRuntimeCompiler.Load(document, configuration ?? new RuntimeXamlLoaderConfiguration());
 
@@ -63,7 +66,8 @@ namespace Avalonia.Markup.Xaml
         /// <param name="documents">Collection of documents.</param>
         /// <param name="configuration">Xaml loader configuration.</param>
         /// <returns>The loaded objects per each input document. If document was removed, the element by index is null.</returns>
-        [RequiresUnreferencedCode(XamlX.TrimmingMessages.DynamicXamlReference)]
+        [RequiresUnreferencedCode(XamlX.TrimmingMessages.Sre)]
+        [RequiresDynamicCode(XamlX.TrimmingMessages.Sre)]
         public static IReadOnlyList<object?> LoadGroup(IReadOnlyCollection<RuntimeXamlLoaderDocument> documents, RuntimeXamlLoaderConfiguration? configuration = null)
             => AvaloniaXamlIlRuntimeCompiler.LoadGroup(documents, configuration ?? new RuntimeXamlLoaderConfiguration());
 
@@ -73,7 +77,8 @@ namespace Avalonia.Markup.Xaml
         /// <param name="xaml">The string containing the XAML.</param>
         /// <param name="localAssembly">Default assembly for clr-namespace:.</param>
         /// <returns>The loaded object.</returns>
-        [RequiresUnreferencedCode(XamlX.TrimmingMessages.DynamicXamlReference)]
+        [RequiresUnreferencedCode(XamlX.TrimmingMessages.Sre)]
+        [RequiresDynamicCode(XamlX.TrimmingMessages.Sre)]
         public static object Parse([StringSyntax(StringSyntaxAttribute.Xml)] string xaml, Assembly? localAssembly = null)
             => Load(xaml, localAssembly);
 
@@ -84,7 +89,8 @@ namespace Avalonia.Markup.Xaml
         /// <param name="xaml">>The string containing the XAML.</param>
         /// <param name="localAssembly">>Default assembly for clr-namespace:.</param>
         /// <returns>The loaded object.</returns>
-        [RequiresUnreferencedCode(XamlX.TrimmingMessages.DynamicXamlReference)]
+        [RequiresUnreferencedCode(XamlX.TrimmingMessages.Sre)]
+        [RequiresDynamicCode(XamlX.TrimmingMessages.Sre)]
         public static T Parse<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] T>([StringSyntax(StringSyntaxAttribute.Xml)] string xaml, Assembly? localAssembly = null)
             => (T)Parse(xaml, localAssembly);
     }
diff --git a/src/Markup/Avalonia.Markup.Xaml.Loader/AvaloniaXamlIlRuntimeCompiler.cs b/src/Markup/Avalonia.Markup.Xaml.Loader/AvaloniaXamlIlRuntimeCompiler.cs
index 728fdb397a..d631cdccd1 100644
--- a/src/Markup/Avalonia.Markup.Xaml.Loader/AvaloniaXamlIlRuntimeCompiler.cs
+++ b/src/Markup/Avalonia.Markup.Xaml.Loader/AvaloniaXamlIlRuntimeCompiler.cs
@@ -28,7 +28,8 @@ using XamlX.IL.Cecil;
 namespace Avalonia.Markup.Xaml.XamlIl
 {
 #if !RUNTIME_XAML_CECIL
-    [RequiresUnreferencedCode(XamlX.TrimmingMessages.DynamicXamlReference)]
+    [RequiresUnreferencedCode(XamlX.TrimmingMessages.Sre)]
+    [RequiresDynamicCode(XamlX.TrimmingMessages.Sre)]
 #endif
     internal static class AvaloniaXamlIlRuntimeCompiler
     {
@@ -41,30 +42,8 @@ namespace Avalonia.Markup.Xaml.XamlIl
         private static XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult>? _sreEmitMappings;
         private static XamlXmlnsMappings? _sreXmlns;
         private static AssemblyBuilder? _sreAsm;
-        private static bool _sreCanSave;
-
-        [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = XamlX.TrimmingMessages.CanBeSafelyTrimmed)]
-        public static void DumpRuntimeCompilationResults()
-        {
-            if (_sreBuilder == null)
-                return;
-            var saveMethod = _sreAsm!.GetType().GetMethods()
-                .FirstOrDefault(m => m.Name == "Save" && m.GetParameters().Length == 1);
-            if (saveMethod == null)
-                return;
-            try
-            {
-                _sreBuilder.CreateGlobalFunctions();
-                saveMethod.Invoke(_sreAsm, new Object[] {"XamlIlLoader.ildump"});
-            }
-            catch
-            {
-                //Ignore
-            }
-        }
 
         [CompilerDynamicDependencies]
-        [UnconditionalSuppressMessage("Trimming", "IL2072", Justification = XamlX.TrimmingMessages.GeneratedTypes)]
         [MemberNotNull(nameof(_sreTypeSystem))]
         [MemberNotNull(nameof(_sreBuilder))]
         [MemberNotNull(nameof(_sreMappings))]
@@ -74,7 +53,7 @@ namespace Avalonia.Markup.Xaml.XamlIl
         [MemberNotNull(nameof(_ignoresAccessChecksFromAttribute))]
         static void InitializeSre()
         {
-            // SRE backend doesn't load assemblies, unless they are already in the memory.
+            // SRE backend doesn't load assemblies unless they are already in the memory.
             // At the very least, we should make sure that assemblies necessary for `AvaloniaXamlIlWellKnownTypes` are loaded.
             // Root `Avalonia.Controls`.
             GC.KeepAlive(typeof(Avalonia.Controls.Control));
@@ -87,26 +66,10 @@ namespace Avalonia.Markup.Xaml.XamlIl
                 _sreTypeSystem = new SreTypeSystem();
             if (_sreBuilder == null)
             {
-                _sreCanSave = !(RuntimeInformation.FrameworkDescription.StartsWith(".NET Core"));
                 var name = new AssemblyName(Guid.NewGuid().ToString("N"));
-                if (_sreCanSave)
-                {
-                    var define = GetDefineDynamicAssembly();
-                    if (define != null)
-                        _sreAsm = (AssemblyBuilder)define.Invoke(AppDomain.CurrentDomain, new object[]
-                        {
-                            name, (AssemblyBuilderAccess)3,
-                            Path.GetDirectoryName(typeof(AvaloniaXamlIlRuntimeCompiler).Assembly.GetModules()[0]
-                                .FullyQualifiedName)!
-                        })!;
-                    else
-                        _sreCanSave = false;
-                }
-                
-                if(_sreAsm == null)
-                    _sreAsm = AssemblyBuilder.DefineDynamicAssembly(name,
-                        AssemblyBuilderAccess.RunAndCollect);
-                
+
+                _sreAsm ??= AssemblyBuilder.DefineDynamicAssembly(name, AssemblyBuilderAccess.RunAndCollect);
+
                 _sreBuilder = _sreAsm.DefineDynamicModule("XamlIlLoader.ildump");
             }
 
@@ -123,12 +86,6 @@ namespace Avalonia.Markup.Xaml.XamlIl
                 _ignoresAccessChecksFromAttribute = EmitIgnoresAccessCheckAttributeDefinition(_sreBuilder);
         }
 
-        [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = XamlX.TrimmingMessages.CanBeSafelyTrimmed)]
-        static MethodInfo? GetDefineDynamicAssembly() => AppDomain.CurrentDomain.GetType().GetMethods()
-            .FirstOrDefault(m => m.Name == "DefineDynamicAssembly"
-                                 && m.GetParameters().Length == 3 &&
-                                 m.GetParameters()[2].ParameterType == typeof(string));
-
         static Type EmitIgnoresAccessCheckAttributeDefinition(ModuleBuilder builder)
         {
             var tb = builder.DefineType("System.Runtime.CompilerServices.IgnoresAccessChecksToAttribute",
@@ -237,37 +194,15 @@ namespace Avalonia.Markup.Xaml.XamlIl
             return result;
         }
 
-        static object LoadSre(RuntimeXamlLoaderDocument document, RuntimeXamlLoaderConfiguration configuration)
+        public static object LoadSre(RuntimeXamlLoaderDocument document, RuntimeXamlLoaderConfiguration configuration)
         {
-            var success = false;
-            try
-            {
-                var rv = LoadSreCore(document, configuration);
-                success = true;
-                return rv;
-            }
-            finally
-            {
-                if(!success && _sreCanSave)
-                    DumpRuntimeCompilationResults();
-            }
+            return LoadSreCore(document, configuration);
         }
 
-        static IReadOnlyList<object> LoadGroupSre(IReadOnlyCollection<RuntimeXamlLoaderDocument> documents,
+        public static IReadOnlyList<object> LoadGroupSre(IReadOnlyCollection<RuntimeXamlLoaderDocument> documents,
             RuntimeXamlLoaderConfiguration configuration)
         {
-            var success = false;
-            try
-            {
-                var rv = LoadGroupSreCore(documents, configuration);
-                success = true;
-                return rv;
-            }
-            finally
-            {
-                if(!success &&  _sreCanSave)
-                    DumpRuntimeCompilationResults();
-            }
+            return LoadGroupSreCore(documents, configuration);
         }
 
         [UnconditionalSuppressMessage("Trimming", "IL2072", Justification = XamlX.TrimmingMessages.GeneratedTypes)]

From b3014ccf2740a02b6dc5af4571a9d7e6ee8a72cc Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Sun, 21 Jun 2026 11:07:21 +0200
Subject: [PATCH 035/196] Handle replacementRange in AvnView (#21608)

* macOS: ensure native selectedRange is up-to-date

* macOS: handle replacementRange in setMarkedText and insertText

* macOS: handle unexpected ranges in attributedSubstringForProposedRange
---
 .../src/OSX/AvnTextInputMethod.h              |  4 ++-
 .../src/OSX/AvnTextInputMethod.mm             |  8 +++--
 native/Avalonia.Native/src/OSX/AvnView.mm     | 35 ++++++++++++++++---
 .../AvaloniaNativeTextInputMethod.cs          | 22 +++++++++---
 src/Avalonia.Native/avn.idl                   |  5 +--
 5 files changed, 60 insertions(+), 14 deletions(-)

diff --git a/native/Avalonia.Native/src/OSX/AvnTextInputMethod.h b/native/Avalonia.Native/src/OSX/AvnTextInputMethod.h
index 4e5116ee71..dd10ae28b4 100644
--- a/native/Avalonia.Native/src/OSX/AvnTextInputMethod.h
+++ b/native/Avalonia.Native/src/OSX/AvnTextInputMethod.h
@@ -38,7 +38,9 @@ public:
     
     virtual void SetCursorRect (AvnRect rect) override;
     
-    virtual void SetSurroundingText (char* text, int anchorOffset, int cursorOffset) override;
+    virtual void SetSurroundingText (char* text, int start, int end) override;
+    
+    virtual void SetSelectionInSurroundingText (int start, int end) override;
     
 public:
     ComPtr<IAvnTextInputMethodClient> Client;
diff --git a/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm b/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm
index 8c3ae080fa..d99fef7833 100644
--- a/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm
+++ b/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm
@@ -31,11 +31,15 @@ HRESULT AvnTextInputMethod::SetClient(IAvnTextInputMethodClient *client) {
 void AvnTextInputMethod::Reset() {
 }
 
-void AvnTextInputMethod::SetSurroundingText(char* text, int anchorOffset, int cursorOffset) {
+void AvnTextInputMethod::SetSurroundingText(char* text, int start, int end) {
     [_inputMethodDelegate setText:[NSString stringWithUTF8String:text]];
-    [_inputMethodDelegate setSelection: anchorOffset : cursorOffset];
+    [_inputMethodDelegate setSelection: start:end];
 }
 
 void AvnTextInputMethod::SetCursorRect(AvnRect rect) {
     [_inputMethodDelegate setCursorRect: rect];
 }
+
+void AvnTextInputMethod::SetSelectionInSurroundingText(int start, int end) {
+    [_inputMethodDelegate setSelection: start:end];
+}
diff --git a/native/Avalonia.Native/src/OSX/AvnView.mm b/native/Avalonia.Native/src/OSX/AvnView.mm
index 600dca865f..35c636819e 100644
--- a/native/Avalonia.Native/src/OSX/AvnView.mm
+++ b/native/Avalonia.Native/src/OSX/AvnView.mm
@@ -775,10 +775,21 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
         markedText = (NSString*) string;
     }
     
-    _markedRange = NSMakeRange(_selectedRange.location, [markedText length]);
     auto parent = _parent.tryGet();
 
-    if(parent->InputMethod->IsActive()){
+    // Delete any replaced range
+    if (replacementRange.location != NSNotFound && parent != nullptr && parent->InputMethod->IsActive())
+    {
+        parent->InputMethod->Client->SelectInSurroundingText((int)replacementRange.location, (int)(replacementRange.location + replacementRange.length));
+        uint64_t timestamp = static_cast<uint64_t>([NSDate timeIntervalSinceReferenceDate] * 1000);
+        parent->TopLevelEvents->RawKeyEvent(KeyDown, timestamp, AvnInputModifiersNone, AvnKeyBack, AvnPhysicalKeyNone, "\b");
+        parent->TopLevelEvents->RawKeyEvent(KeyUp, timestamp, AvnInputModifiersNone, AvnKeyBack, AvnPhysicalKeyNone, "\b");
+    }
+    
+    _markedRange = NSMakeRange(_selectedRange.location, [markedText length]);
+
+    if (parent != nullptr && parent->InputMethod->IsActive())
+    {
         parent->InputMethod->Client->SetPreeditText((char*)[markedText UTF8String]);
     }
 }
@@ -807,9 +818,16 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
     if(actualRange){
         range = *actualRange;
     }
+
+    // From the docs: an implementation of this method should be prepared for aRange to be out of bounds.
+    // In this case, you should return the intersection of the document's range and aRange.
+    // If the location of aRange is completely outside of the document's range, return nil.
+    auto finalRange = NSIntersectionRange(range, NSMakeRange(0, _text.length));
     
-    NSAttributedString* subString = [_text attributedSubstringFromRange:range];
+    if (finalRange.length == 0)
+        return nil;
     
+    NSAttributedString* subString = [_text attributedSubstringFromRange:finalRange];
     return subString;
 }
 
@@ -819,9 +837,9 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
     if(parent == nullptr){
         return;
     }
-    
+
     NSString* text;
-        
+
     if([string isKindOfClass:[NSAttributedString class]])
     {
         text = [string string];
@@ -831,6 +849,13 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
         text = (NSString*) string;
     }
     
+    if (replacementRange.location != NSNotFound &&
+        ![self hasMarkedText] &&
+        parent->InputMethod->IsActive())
+    {
+        parent->InputMethod->Client->SelectInSurroundingText((int)replacementRange.location, (int)(replacementRange.location + replacementRange.length));
+    }
+    
     [self unmarkText];
         
     uint64_t timestamp = static_cast<uint64_t>([NSDate timeIntervalSinceReferenceDate] * 1000);
diff --git a/src/Avalonia.Native/AvaloniaNativeTextInputMethod.cs b/src/Avalonia.Native/AvaloniaNativeTextInputMethod.cs
index 3df0a0ef4a..5889313ceb 100644
--- a/src/Avalonia.Native/AvaloniaNativeTextInputMethod.cs
+++ b/src/Avalonia.Native/AvaloniaNativeTextInputMethod.cs
@@ -32,22 +32,25 @@ namespace Avalonia.Native
             {
                 _client.SurroundingTextChanged -= OnSurroundingTextChanged;
                 _client.CursorRectangleChanged -= OnCursorRectangleChanged;
-                
+                _client.SelectionChanged -= OnSelectionChanged;
+
                 _nativeClient?.Dispose();
             }
-            
+
             _nativeClient = null;
             _client = client;
-            
+
             if (_client != null)
             {
                 _nativeClient = new AvnTextInputMethodClient(_client);
 
                 OnSurroundingTextChanged(this, EventArgs.Empty);
                 OnCursorRectangleChanged(this, EventArgs.Empty);
+                // Note: OnSelectionChanged isn't called, it's already up-to-date thanks to OnSurroundingTextChanged
 
                 _client.SurroundingTextChanged += OnSurroundingTextChanged;
                 _client.CursorRectangleChanged += OnCursorRectangleChanged;
+                _client.SelectionChanged += OnSelectionChanged;
             }
 
             _inputMethod.SetClient(_nativeClient);
@@ -92,7 +95,7 @@ namespace Avalonia.Native
             {
                 return;
             }
-            
+
             var surroundingText = _client.SurroundingText;
             var selection = _client.Selection;
 
@@ -103,6 +106,17 @@ namespace Avalonia.Native
             );
         }
 
+        private void OnSelectionChanged(object? sender, EventArgs e)
+        {
+            if (_client is null)
+            {
+                return;
+            }
+
+            var selection = _client.Selection;
+            _inputMethod.SetSelectionInSurroundingText(selection.Start, selection.End);
+        }
+
         public void SetCursorRect(Rect rect)
         {
             _inputMethod.SetCursorRect(rect.ToAvnRect());
diff --git a/src/Avalonia.Native/avn.idl b/src/Avalonia.Native/avn.idl
index f01430a42a..32d3f4286e 100644
--- a/src/Avalonia.Native/avn.idl
+++ b/src/Avalonia.Native/avn.idl
@@ -872,7 +872,7 @@ interface IAvnWindowEvents : IAvnWindowBaseEvents
 interface IAvnTextInputMethodClient : IUnknown
 {
     void SetPreeditText(char* preeditText);
-    void SelectInSurroundingText(int start, int length);
+    void SelectInSurroundingText(int start, int end);
 }
 
 [uuid(1382a29f-e260-4c7a-b83f-c99fc72e27c2)]
@@ -881,7 +881,8 @@ interface IAvnTextInputMethod : IUnknown
     HRESULT SetClient(IAvnTextInputMethodClient* client);
     void Reset();
     void SetCursorRect(AvnRect rect);
-    void SetSurroundingText(char* text, int anchorOffset, int cursorOffset);
+    void SetSurroundingText(char* text, int start, int end);
+    void SetSelectionInSurroundingText(int start, int end);
 }
 
 [uuid(e34ae0f8-18b4-48a3-b09d-2e6b19a3cf5e)]

From 61769ec1b2b7e019f1760c2f1aa6d4916ad4c100 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Mon, 22 Jun 2026 11:03:32 +0300
Subject: [PATCH 036/196] Add .tokensave to .gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 22077f6402..558b91f822 100644
--- a/.gitignore
+++ b/.gitignore
@@ -227,3 +227,4 @@ src/Browser/Avalonia.Browser/staticwebassets
 /.claude/settings.local.json
 /planning
 BenchmarkDotNet.Artifacts.*
+.tokensave

From ed703a1a3230425deaa45dd337ad16053d110c9b Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Mon, 22 Jun 2026 11:59:17 +0200
Subject: [PATCH 037/196] Fix RequestedThemeVariant default value (#21624)

---
 src/Avalonia.Base/Styling/ThemeVariant.cs | 32 +++++++++++------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/Avalonia.Base/Styling/ThemeVariant.cs b/src/Avalonia.Base/Styling/ThemeVariant.cs
index ac44fddb99..5414d340bf 100644
--- a/src/Avalonia.Base/Styling/ThemeVariant.cs
+++ b/src/Avalonia.Base/Styling/ThemeVariant.cs
@@ -15,6 +15,22 @@ namespace Avalonia.Styling;
     "Ideally we woould introduce readonly styled properties.")]
 public sealed record ThemeVariant
 {
+    /// <summary>
+    /// Inherit theme variant from the parent. If set on Application, system theme is inherited.
+    /// Using Default as the ResourceDictionary.Key marks this dictionary as a fallback in case the theme variant or resource key is not found in other theme dictionaries.
+    /// </summary>
+    public static ThemeVariant Default { get; } = new(nameof(Default));
+
+    /// <summary>
+    /// Use the Light theme variant.
+    /// </summary>
+    public static ThemeVariant Light { get; } = new(nameof(Light));
+
+    /// <summary>
+    /// Use the Dark theme variant.
+    /// </summary>
+    public static ThemeVariant Dark { get; } = new(nameof(Dark));
+
     /// <summary>
     /// Defines the ActualThemeVariant property.
     /// </summary>
@@ -63,22 +79,6 @@ public sealed record ThemeVariant
     /// </summary>
     public ThemeVariant? InheritVariant { get; }
 
-    /// <summary>
-    /// Inherit theme variant from the parent. If set on Application, system theme is inherited.
-    /// Using Default as the ResourceDictionary.Key marks this dictionary as a fallback in case the theme variant or resource key is not found in other theme dictionaries.
-    /// </summary>
-    public static ThemeVariant Default { get; } = new(nameof(Default));
-
-    /// <summary>
-    /// Use the Light theme variant.
-    /// </summary>
-    public static ThemeVariant Light { get; } = new(nameof(Light));
-
-    /// <summary>
-    /// Use the Dark theme variant.
-    /// </summary>
-    public static ThemeVariant Dark { get; } = new(nameof(Dark));
-
     public override string ToString()
     {
         return Key.ToString() ?? $"ThemeVariant {{ Key = {Key} }}";

From ff4210e809c303332385ab4a985c999b77d3f4e6 Mon Sep 17 00:00:00 2001
From: StefanKoell <stefan.koell@code4ward.net>
Date: Mon, 22 Jun 2026 14:46:41 +0200
Subject: [PATCH 038/196] Fix TopMost handling for Popups on Windows (#17841)

* Fix TopMost handling for Popups on Windows

* Properly handle TopMost property changes

* Call SetTopMost in PopupRoot constructor (similar to SetWindowManagerAddShadowHint)

* Make sure the parent is focused when the popup is clicked directly to activate the app.

* Move PopupsPage to IntegrationTestApp

* Move Popup code to the XAML, making visual/logical management implicit

* Add popup integration tests

* Fix MenuTests+Default.Click_Grandchild by delaying popup activation

* Kill input focus when input element on popup is focused element

* try to fix tests

* try to fix test v2

* Integration tests: ensure menus get closed after testing

* run popup tests only on windows

* WIP: Removing the hack to see if anything changes.

* WIP: Removing the second hack.

I'm guessing this will fix it.

* fix to make transparent window integration app work on macOS

* fix menu tests

* Fix warning in MenuTests

* Add a background to integration test popup

---------

Co-authored-by: Maxwell Katz <maxkatz6@outlook.com>
Co-authored-by: Steven Kirk <grokys@users.noreply.github.com>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../IntegrationTestApp/MainWindow.axaml.cs    |   1 +
 .../IntegrationTestApp/Pages/PopupsPage.axaml |  70 ++++++
 .../Pages/PopupsPage.axaml.cs                 |  48 +++++
 src/Avalonia.Controls/Primitives/PopupRoot.cs |   4 +
 src/Windows/Avalonia.Win32/PopupImpl.cs       |   6 +-
 .../MenuTests.cs                              |  65 ++++--
 .../PopupsTests.cs                            | 199 ++++++++++++++++++
 7 files changed, 371 insertions(+), 22 deletions(-)
 create mode 100644 samples/IntegrationTestApp/Pages/PopupsPage.axaml
 create mode 100644 samples/IntegrationTestApp/Pages/PopupsPage.axaml.cs
 create mode 100644 tests/Avalonia.IntegrationTests.Appium/PopupsTests.cs

diff --git a/samples/IntegrationTestApp/MainWindow.axaml.cs b/samples/IntegrationTestApp/MainWindow.axaml.cs
index 7d6a2c2c3e..f306ce84af 100644
--- a/samples/IntegrationTestApp/MainWindow.axaml.cs
+++ b/samples/IntegrationTestApp/MainWindow.axaml.cs
@@ -89,6 +89,7 @@ namespace IntegrationTestApp
                 new("ListBox", () => new ListBoxPage()),
                 new("Menu", () => new MenuPage()),
                 new("Pointer", () => new PointerPage()),
+                new("Popups", () => new PopupsPage()),
                 new("RadioButton", () => new RadioButtonPage()),
                 new("Screens", () => new ScreensPage()),
                 new("ScrollBar", () => new ScrollBarPage()),
diff --git a/samples/IntegrationTestApp/Pages/PopupsPage.axaml b/samples/IntegrationTestApp/Pages/PopupsPage.axaml
new file mode 100644
index 0000000000..e5c4e7636f
--- /dev/null
+++ b/samples/IntegrationTestApp/Pages/PopupsPage.axaml
@@ -0,0 +1,70 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             x:Class="IntegrationTestApp.Pages.PopupsPage">
+
+  <StackPanel Orientation="Vertical" Spacing="10">
+
+    <Button x:Name="DismissButton"
+            Content="Dismiss Button" />
+
+    <TextBlock Text="'Light Dismiss' Popup" />
+
+    <Button x:Name="ShowLightDismissPopup"
+            Content="Show Popup" Click="ButtonLightDismiss_OnClick" />
+    <Popup x:Name="LightDismissPopup"
+           PlacementTarget="ShowLightDismissPopup"
+           Placement="Bottom"
+           IsLightDismissEnabled="True">
+      <Panel Background="Gray"
+             Margin="10"
+             MinWidth="100"
+             MinHeight="30">
+        <TextBox Text="Popup Content"
+                 Name="LightDismissPopupContent" />
+      </Panel>
+    </Popup>
+
+    <TextBlock Text="Popup that stays open" />
+    <Button x:Name="ShowStaysOpenPopup"
+            Content="Show Popup" Click="ButtonPopupStaysOpen_OnClick" />
+    <Popup x:Name="StaysOpenPopup"
+           PlacementTarget="ShowStaysOpenPopup"
+           Placement="Bottom"
+           IsLightDismissEnabled="False">
+      <StackPanel Background="Gray"
+                  MinWidth="100"
+                  MinHeight="30"
+                  Spacing="20"
+                  Orientation="Vertical">
+        <TextBox Name="StaysOpenTextBox"
+                 Width="100"
+                 Text="Some text" />
+        <Button Name="StaysOpenPopupCloseButton"
+                Click="StaysOpenPopupCloseButton_OnClick"
+                Content="Click to Close" />
+      </StackPanel>
+    </Popup>
+
+    <TextBlock Text="TopMost popup that stays open" />
+    <Button x:Name="ShowTopMostPopup"
+            Content="Show Popup" Click="ButtonTopMostPopupStaysOpen" />
+    <Popup x:Name="TopMostPopup"
+           Placement="Top"
+           PlacementTarget="ShowTopMostPopup"
+           IsLightDismissEnabled="False"
+           Topmost="True">
+      <Panel MinWidth="100"
+             MinHeight="30"
+             Background="Gray">
+        <Button Name="TopMostPopupCloseButton"
+                Click="TopMostPopupCloseButton_OnClick"
+                Content="Click to Close" />
+      </Panel>
+    </Popup>
+
+    <Button x:Name="OpenNewWindowButton"
+            Content="Open Regular New Window"
+            Click="OpenRegularNewWindow_Click" />
+  </StackPanel>
+
+</UserControl>
diff --git a/samples/IntegrationTestApp/Pages/PopupsPage.axaml.cs b/samples/IntegrationTestApp/Pages/PopupsPage.axaml.cs
new file mode 100644
index 0000000000..feca539d90
--- /dev/null
+++ b/samples/IntegrationTestApp/Pages/PopupsPage.axaml.cs
@@ -0,0 +1,48 @@
+using Avalonia;
+using Avalonia.Automation;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.Primitives.PopupPositioning;
+using Avalonia.Interactivity;
+using Avalonia.Layout;
+using Avalonia.Markup.Xaml;
+using Avalonia.Media;
+
+namespace IntegrationTestApp.Pages;
+
+public partial class PopupsPage : UserControl
+{
+    public PopupsPage()
+    {
+        InitializeComponent();
+    }
+
+    private void ButtonLightDismiss_OnClick(object sender, RoutedEventArgs e)
+    {
+        LightDismissPopup.Open();
+    }
+
+    private void ButtonPopupStaysOpen_OnClick(object sender, RoutedEventArgs e)
+    {
+        StaysOpenPopup.Open();
+    }
+    private void StaysOpenPopupCloseButton_OnClick(object? sender, RoutedEventArgs e)
+    {
+        StaysOpenPopup.Close();
+    }
+
+    private void ButtonTopMostPopupStaysOpen(object sender, RoutedEventArgs e)
+    {
+        TopMostPopup.Open();
+    }
+    private void TopMostPopupCloseButton_OnClick(object? sender, RoutedEventArgs e)
+    {
+        TopMostPopup.Close();
+    }
+
+    private void OpenRegularNewWindow_Click(object? sender, RoutedEventArgs e)
+    {
+        var newWindow = new ShowWindowTest();
+        newWindow.Show((Window)TopLevel.GetTopLevel(this)!);
+    }
+}
diff --git a/src/Avalonia.Controls/Primitives/PopupRoot.cs b/src/Avalonia.Controls/Primitives/PopupRoot.cs
index 07ac06f15d..d1fd1317f8 100644
--- a/src/Avalonia.Controls/Primitives/PopupRoot.cs
+++ b/src/Avalonia.Controls/Primitives/PopupRoot.cs
@@ -215,6 +215,10 @@ namespace Avalonia.Controls.Primitives
             {
                 PlatformImpl?.SetWindowManagerAddShadowHint(change.GetNewValue<bool>());
             }
+            else if (change.Property == TopmostProperty)
+            {
+                PlatformImpl?.SetTopmost(change.GetNewValue<bool>());
+            }
         }
     }
 }
diff --git a/src/Windows/Avalonia.Win32/PopupImpl.cs b/src/Windows/Avalonia.Win32/PopupImpl.cs
index fd7b0982c4..ee2feedffc 100644
--- a/src/Windows/Avalonia.Win32/PopupImpl.cs
+++ b/src/Windows/Avalonia.Win32/PopupImpl.cs
@@ -1,7 +1,10 @@
 using System;
 using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Primitives.PopupPositioning;
+using Avalonia.Input;
 using Avalonia.Platform;
+using Avalonia.Threading;
 using Avalonia.Win32.Interop;
 
 namespace Avalonia.Win32
@@ -53,8 +56,7 @@ namespace Avalonia.Win32
                 UnmanagedMethods.WindowStyles.WS_CLIPCHILDREN;
 
             UnmanagedMethods.WindowStyles exStyle =
-                UnmanagedMethods.WindowStyles.WS_EX_TOOLWINDOW |
-                UnmanagedMethods.WindowStyles.WS_EX_TOPMOST;
+                UnmanagedMethods.WindowStyles.WS_EX_TOOLWINDOW;
 
             var result = UnmanagedMethods.CreateWindowEx(
                 (int)exStyle,
diff --git a/tests/Avalonia.IntegrationTests.Appium/MenuTests.cs b/tests/Avalonia.IntegrationTests.Appium/MenuTests.cs
index 6fd9505583..709f8d41de 100644
--- a/tests/Avalonia.IntegrationTests.Appium/MenuTests.cs
+++ b/tests/Avalonia.IntegrationTests.Appium/MenuTests.cs
@@ -1,11 +1,13 @@
-using OpenQA.Selenium;
+using System;
+using System.Threading;
+using OpenQA.Selenium;
 using OpenQA.Selenium.Interactions;
 using Xunit;
 
 namespace Avalonia.IntegrationTests.Appium
 {
     [Collection("Default")]
-    public abstract class MenuTests : TestBase
+    public abstract class MenuTests : TestBase, IDisposable
     {
         public MenuTests(DefaultAppFixture fixture)
             : base(fixture, "Menu")
@@ -17,11 +19,20 @@ namespace Avalonia.IntegrationTests.Appium
             Assert.Equal("None", clickedMenuItem.Text);
         }
 
+        public override void Dispose()
+        {
+            // Click the reset button so that any menu still open gets closed
+            var reset = Session.FindElementByAccessibilityId("MenuClickedMenuItemReset");
+            reset?.Click();
+
+            base.Dispose();
+        }
+
         [Fact]
         public void Click_Child()
         {
             var rootMenuItem = Session.FindElementByAccessibilityId("RootMenuItem");
-            
+
             rootMenuItem.SendClick();
 
             var childMenuItem = Session.FindElementByAccessibilityId("Child1MenuItem");
@@ -35,7 +46,7 @@ namespace Avalonia.IntegrationTests.Appium
         public void Click_Grandchild()
         {
             var rootMenuItem = Session.FindElementByAccessibilityId("RootMenuItem");
-            
+
             rootMenuItem.SendClick();
 
             var childMenuItem = Session.FindElementByAccessibilityId("Child2MenuItem");
@@ -53,10 +64,12 @@ namespace Avalonia.IntegrationTests.Appium
         {
             MovePointerOutOfTheWay();
 
-            new Actions(Session)
-                .KeyDown(Keys.Alt).KeyUp(Keys.Alt)
-                .SendKeys(Keys.Down + Keys.Enter)
-                .Perform();
+            var window = Session.FindElementByAccessibilityId("MainWindow");
+            window.Click();
+
+            window.SendKeys(Keys.LeftAlt);
+            Thread.Sleep(150);
+            window.SendKeys(Keys.Down + Keys.Enter);
 
             var clickedMenuItem = Session.FindElementByAccessibilityId("ClickedMenuItem");
             Assert.Equal("_Child 1", clickedMenuItem.Text);
@@ -67,10 +80,12 @@ namespace Avalonia.IntegrationTests.Appium
         {
             MovePointerOutOfTheWay();
 
-            new Actions(Session)
-                .KeyDown(Keys.Alt).KeyUp(Keys.Alt)
-                .SendKeys(Keys.Down + Keys.Down + Keys.Right + Keys.Enter)
-                .Perform();
+            var window = Session.FindElementByAccessibilityId("MainWindow");
+            window.Click();
+
+            window.SendKeys(Keys.LeftAlt);
+            Thread.Sleep(150);
+            window.SendKeys(Keys.Down + Keys.Down + Keys.Right + Keys.Enter);
 
             var clickedMenuItem = Session.FindElementByAccessibilityId("ClickedMenuItem");
             Assert.Equal("_Grandchild", clickedMenuItem.Text);
@@ -81,10 +96,14 @@ namespace Avalonia.IntegrationTests.Appium
         {
             MovePointerOutOfTheWay();
 
-            new Actions(Session)
-                .KeyDown(Keys.Alt).KeyUp(Keys.Alt)
-                .SendKeys("rc")
-                .Perform();
+            var window = Session.FindElementByAccessibilityId("MainWindow");
+            window.Click();
+
+            window.SendKeys(Keys.LeftAlt);
+            Thread.Sleep(150);
+            window.SendKeys("r");
+            Thread.Sleep(75);
+            window.SendKeys("c");
 
             var clickedMenuItem = Session.FindElementByAccessibilityId("ClickedMenuItem");
             Assert.Equal("_Child 1", clickedMenuItem.Text);
@@ -95,10 +114,16 @@ namespace Avalonia.IntegrationTests.Appium
         {
             MovePointerOutOfTheWay();
 
-            new Actions(Session)
-                .KeyDown(Keys.Alt).KeyUp(Keys.Alt)
-                .SendKeys("rhg")
-                .Perform();
+            var window = Session.FindElementByAccessibilityId("MainWindow");
+            window.Click();
+
+            window.SendKeys(Keys.LeftAlt);
+            Thread.Sleep(150);
+            window.SendKeys("r");
+            Thread.Sleep(75);
+            window.SendKeys("h");
+            Thread.Sleep(75);
+            window.SendKeys("g");
 
             var clickedMenuItem = Session.FindElementByAccessibilityId("ClickedMenuItem");
             Assert.Equal("_Grandchild", clickedMenuItem.Text);
diff --git a/tests/Avalonia.IntegrationTests.Appium/PopupsTests.cs b/tests/Avalonia.IntegrationTests.Appium/PopupsTests.cs
new file mode 100644
index 0000000000..98f6bc804d
--- /dev/null
+++ b/tests/Avalonia.IntegrationTests.Appium/PopupsTests.cs
@@ -0,0 +1,199 @@
+using System.Threading;
+using OpenQA.Selenium;
+using OpenQA.Selenium.Interactions;
+using Xunit;
+
+namespace Avalonia.IntegrationTests.Appium;
+
+[Collection("Default")]
+public abstract class PopupsTests : TestBase
+{
+    private readonly bool _isOverlayPopups;
+
+    protected PopupsTests(bool isOverlayPopups, DefaultAppFixture fixture) : base(fixture, "Popups")
+    {
+        _isOverlayPopups = isOverlayPopups;
+    }
+
+    [PlatformFact(TestPlatforms.Windows)]
+    public void LightDismiss_Popup_Should_Open_And_Close()
+    {
+        // Open popup
+        var button = Session.FindElementByAccessibilityId("ShowLightDismissPopup");
+        button.Click();
+        Thread.Sleep(500);
+
+        // Assert - Popup is visible
+        Assert.NotNull(Session.FindElementByAccessibilityId("LightDismissPopupContent"));
+        
+        // Act - Click outside to dismiss
+        var dismissBorder = Session.FindElementByAccessibilityId("DismissButton");
+        dismissBorder.Click();
+
+        Thread.Sleep(500);
+
+        // Assert - Popup is closed
+        Assert.Throws<WebDriverException>(() =>
+            Session.FindElementByAccessibilityId("LightDismissPopupContent"));
+    }
+
+    [PlatformFact(TestPlatforms.Windows)]
+    public void StaysOpen_Popup_Should_Stay_Open()
+    {
+        // Open popup
+        var button = Session.FindElementByAccessibilityId("ShowStaysOpenPopup");
+        button.Click();
+        Thread.Sleep(500);
+
+        try
+        {
+            // Assert - Popup is visible
+            Assert.NotNull(Session.FindElementByAccessibilityId("StaysOpenPopupCloseButton"));
+
+            // Act - Click outside
+            var dismissBorder = Session.FindElementByAccessibilityId("DismissButton");
+            dismissBorder.Click();
+
+            Thread.Sleep(500);
+
+            // Assert - Popup is still visible
+            Assert.NotNull(Session.FindElementByAccessibilityId("StaysOpenPopupCloseButton"));
+
+        }
+        finally
+        {
+            // Act - Close popup with button
+            Session.FindElementByAccessibilityId("StaysOpenPopupCloseButton").Click();
+
+            Thread.Sleep(400);
+
+            // Assert - Popup is closed
+            Assert.Throws<WebDriverException>(() =>
+                Session.FindElementByAccessibilityId("StaysOpenPopupCloseButton"));
+        }
+    }
+
+    [PlatformFact(TestPlatforms.Windows)]
+    public void StaysOpen_Popup_TextBox_Should_Be_Editable()
+    {
+        // Open popup
+        var button = Session.FindElementByAccessibilityId("ShowStaysOpenPopup");
+        button.Click();
+        Thread.Sleep(500);
+
+        try
+        {
+            // Find and edit the TextBox
+            var textBox = Session.FindElementByAccessibilityId("StaysOpenTextBox");
+            textBox.Clear();
+            textBox.SendKeys("New text value");
+            Thread.Sleep(500);
+
+            // Verify text was changed
+            Assert.Equal("New text value", textBox.Text);
+        }
+        finally
+        {
+            // Cleanup - close popup
+            Session.FindElementByAccessibilityId("StaysOpenPopupCloseButton").Click();
+        }
+    }
+
+    [PlatformFact(TestPlatforms.Windows)]
+    public void TopMost_Popup_Should_Stay_Above_Other_Windows()
+    {
+        // It's not possible to test overlay topmost with other windows.
+        if (_isOverlayPopups)
+        {
+            return;
+        }
+
+        var staysOpenPopup = Session.FindElementByAccessibilityId("ShowTopMostPopup");
+        var mainWindowHandle = Session.CurrentWindowHandle;
+
+        // Show topmost popup.
+        staysOpenPopup.Click();
+        Assert.NotNull(Session.FindElementByAccessibilityId("TopMostPopupCloseButton"));
+
+        var hasClosedPopup = false;
+
+        try
+        {
+            // Open a child window.
+            using var _ = Session.FindElementByAccessibilityId("OpenNewWindowButton").OpenWindowWithClick();
+            Thread.Sleep(500);
+
+            // Force window to front by maximizing child window.
+            Session.FindElementByAccessibilityId("CurrentWindowState").SendClick();
+            Session.FindElementByAccessibilityId("WindowStateMaximized").SendClick();
+
+            // Switch back to the mainwindow context and verify tooltip is still accessible.
+            Session.SwitchTo().Window(mainWindowHandle);
+            Assert.NotNull(Session.FindElementByAccessibilityId("TopMostPopupCloseButton"));
+
+            // Verify we can still interact with the popup by closing it via button.
+            Session.FindElementByAccessibilityId("TopMostPopupCloseButton").Click();
+
+            // Verify popup closed
+            Assert.Throws<WebDriverException>(() =>
+                Session.FindElementByAccessibilityId("TopMostPopupCloseButton"));
+            hasClosedPopup = true;
+        }
+        finally
+        {
+            if (!hasClosedPopup)
+            {
+                Session.FindElementByAccessibilityId("TopMostPopupCloseButton").Click();
+            }
+        }
+    }
+
+    [PlatformFact(TestPlatforms.Windows)]
+    public void Non_TopMost_Popup_Does_Not_Stay_Above_Other_Windows()
+    {
+        var topmostButton = Session.FindElementByAccessibilityId("ShowStaysOpenPopup");
+        var mainWindowHandle = Session.CurrentWindowHandle;
+
+        // Show topmost popup.
+        topmostButton.Click();
+        Assert.NotNull(Session.FindElementByAccessibilityId("StaysOpenPopupCloseButton"));
+
+        try
+        {
+            // Open a child window.
+            var newWindowButton = Session.FindElementByAccessibilityId("OpenNewWindowButton");
+            using var _ = newWindowButton.OpenWindowWithClick();
+
+            // Force window to front by maximizing child window.
+            Session.FindElementByAccessibilityId("CurrentWindowState").SendClick();
+            Session.FindElementByAccessibilityId("WindowStateMaximized").SendClick();
+
+            // Switch back to the mainwindow context and verify tooltip is still accessible.
+            Session.SwitchTo().Window(mainWindowHandle);
+            Assert.NotNull(Session.FindElementByAccessibilityId("StaysOpenPopupCloseButton"));
+
+            // Verify we cannot interact with the popup by attempting closing it via button.
+            Session.FindElementByAccessibilityId("StaysOpenPopupCloseButton").Click();
+
+            // Verify popup is still accessible.
+            Assert.NotNull(Session.FindElementByAccessibilityId("StaysOpenPopupCloseButton"));
+        }
+        finally
+        {
+            // At this point secondary window should be already closed. And safe to close the popup.
+            Session.FindElementByAccessibilityId("StaysOpenPopupCloseButton").Click();
+        }
+    }
+
+    [Collection("Default")]
+    public class Default : PopupsTests
+    {
+        public Default(DefaultAppFixture fixture) : base(false, fixture) { }
+    }
+
+    [Collection("OverlayPopups")]
+    public class OverlayPopups : PopupsTests
+    {
+        public OverlayPopups(OverlayPopupsAppFixture fixture) : base(true, fixture) { }
+    }
+}

From 129d9594978e8813cbdf557aa74e25094d52f190 Mon Sep 17 00:00:00 2001
From: Alexander Marek <gentledepp@gmail.com>
Date: Mon, 22 Jun 2026 15:25:03 +0200
Subject: [PATCH 039/196] Improve pull-to-refresh usability in RefreshContainer
 (#18617)

* Added improved refresh-capabilities to ScrollViewer in simple theme
Added gesture-recognizer for scroll-viewer to improve usability
Added possibility to enable pulltorefresh on desktop too

* Fix naming

* Adjust tests to avoid reflection

---------

Co-authored-by: nickodei <nickdeibus@outlook.de>
Co-authored-by: Emmanuel Hansen <emmausssss@gmail.com>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 samples/ControlCatalog/App.xaml               |   3 +
 .../Pages/RefreshContainerPage.axaml          |  20 ++-
 .../ScrollGestureRecognizer.cs                |  86 +++++++++-
 .../PullToRefresh/RefreshContainer.cs         |  68 ++++++--
 .../PullToRefresh/RefreshInfoProvider.cs      |  37 +++-
 .../PullToRefresh/RefreshVisualizer.cs        | 130 +++++++-------
 ...ScrollViewerIRefreshInfoProviderAdapter.cs |  56 ++++++-
 .../ScrollablePullGestureRecognizer.cs        | 158 ++++++++++++++++++
 .../Controls/ScrollViewer.xaml                |   5 +-
 .../Controls/ScrollViewer.xaml                |   5 +-
 .../PullToRefresh/RefreshInfoProviderTests.cs |  95 +++++++++++
 ...lViewerIRefreshInfoProviderAdapterTests.cs |  50 ++++++
 .../ScrollablePullGestureRecognizerTests.cs   |  65 +++++++
 13 files changed, 692 insertions(+), 86 deletions(-)
 create mode 100644 src/Avalonia.Controls/PullToRefresh/ScrollablePullGestureRecognizer.cs
 create mode 100644 tests/Avalonia.Controls.UnitTests/PullToRefresh/RefreshInfoProviderTests.cs
 create mode 100644 tests/Avalonia.Controls.UnitTests/PullToRefresh/ScrollViewerIRefreshInfoProviderAdapterTests.cs
 create mode 100644 tests/Avalonia.Controls.UnitTests/PullToRefresh/ScrollablePullGestureRecognizerTests.cs

diff --git a/samples/ControlCatalog/App.xaml b/samples/ControlCatalog/App.xaml
index 6ab30cc180..42f35c7205 100644
--- a/samples/ControlCatalog/App.xaml
+++ b/samples/ControlCatalog/App.xaml
@@ -59,6 +59,9 @@
     <Style Selector="Label.h3">
       <Setter Property="FontSize" Value="12" />
     </Style>
+    <Style Selector="RefreshContainer">
+      <Setter Property="IsMouseEnabled" Value="true" />
+    </Style>
   </Application.Styles>
   <NativeDock.Menu>
     <NativeMenu>
diff --git a/samples/ControlCatalog/Pages/RefreshContainerPage.axaml b/samples/ControlCatalog/Pages/RefreshContainerPage.axaml
index 06f54dd28a..a905e4efdf 100644
--- a/samples/ControlCatalog/Pages/RefreshContainerPage.axaml
+++ b/samples/ControlCatalog/Pages/RefreshContainerPage.axaml
@@ -3,6 +3,7 @@
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:viewModels="using:ControlCatalog.ViewModels"
+             xmlns:generic="clr-namespace:System.Collections.Generic;assembly=netstandard"
              mc:Ignorable="d"
              d:DesignWidth="800"
              d:DesignHeight="450"
@@ -12,12 +13,27 @@
   <DockPanel HorizontalAlignment="Stretch"
              Height="600"
              VerticalAlignment="Top">
-    <Label DockPanel.Dock="Top">A control that supports pull to refresh</Label>
+    <StackPanel DockPanel.Dock="Top">
+      <Label>A control that supports pull to refresh on touch inputs</Label>
+      <StackPanel Orientation="Horizontal" Margin="3" Spacing="5">
+        <TextBlock VerticalAlignment="Center">Used pull direction:</TextBlock>
+        <ComboBox x:Name="PullDirections" SelectedIndex="0">
+          <ComboBox.ItemsSource>
+            <generic:List x:TypeArguments="PullDirection">
+              <PullDirection>TopToBottom</PullDirection>
+              <PullDirection>LeftToRight</PullDirection>
+              <PullDirection>RightToLeft</PullDirection>
+              <PullDirection>BottomToTop</PullDirection>
+            </generic:List>
+          </ComboBox.ItemsSource>
+        </ComboBox>
+      </StackPanel>
+    </StackPanel>
     <RefreshContainer Name="Refresh"
                       DockPanel.Dock="Bottom"
                       HorizontalAlignment="Stretch"
                       VerticalAlignment="Stretch"
-                      PullDirection="TopToBottom"
+                      PullDirection="{Binding #PullDirections.SelectedItem}"
                       RefreshRequested="RefreshContainerPage_RefreshRequested"
                       Margin="5">
       <ListBox HorizontalAlignment="Stretch"
diff --git a/src/Avalonia.Base/Input/GestureRecognizers/ScrollGestureRecognizer.cs b/src/Avalonia.Base/Input/GestureRecognizers/ScrollGestureRecognizer.cs
index 5ac1be7152..00d578ecbf 100644
--- a/src/Avalonia.Base/Input/GestureRecognizers/ScrollGestureRecognizer.cs
+++ b/src/Avalonia.Base/Input/GestureRecognizers/ScrollGestureRecognizer.cs
@@ -16,6 +16,9 @@ namespace Avalonia.Input.GestureRecognizers
         private bool _canHorizontallyScroll;
         private bool _canVerticallyScroll;
         private bool _isScrollInertiaEnabled;
+        private Vector? _offset;
+        private Size? _viewport;
+        private Size? _extent;
         private readonly static int s_defaultScrollStartDistance = (int)((AvaloniaLocator.Current?.GetService<IPlatformSettings>()?.GetTapSize(PointerType.Touch).Height ?? 10) / 2);
         private int _scrollStartDistance = s_defaultScrollStartDistance;
 
@@ -64,6 +67,30 @@ namespace Avalonia.Input.GestureRecognizers
                 o => o.ScrollStartDistance, (o, v) => o.ScrollStartDistance = v,
                 unsetValue: s_defaultScrollStartDistance);
 
+        /// <summary>
+        /// Defines the <see cref="Offset"/> property.
+        /// </summary>
+        public static readonly DirectProperty<ScrollGestureRecognizer, Vector?> OffsetProperty =
+            AvaloniaProperty.RegisterDirect<ScrollGestureRecognizer, Vector?>(nameof(Offset),
+                o => o.Offset, (o, v) => o.Offset = v,
+                unsetValue: null);
+
+        /// <summary>
+        /// Defines the <see cref="Extent"/> property.
+        /// </summary>
+        public static readonly DirectProperty<ScrollGestureRecognizer, Size?> ExtentProperty =
+            AvaloniaProperty.RegisterDirect<ScrollGestureRecognizer, Size?>(nameof(Extent),
+                o => o.Extent, (o, v) => o.Extent = v,
+                unsetValue: null);
+
+        /// <summary>
+        /// Defines the <see cref="Viewport"/> property.
+        /// </summary>
+        public static readonly DirectProperty<ScrollGestureRecognizer, Size?> ViewportProperty =
+            AvaloniaProperty.RegisterDirect<ScrollGestureRecognizer, Size?>(nameof(Viewport),
+                o => o.Viewport, (o, v) => o.Viewport = v,
+                unsetValue: null);
+
         /// <summary>
         /// Gets or sets a value indicating whether the content can be scrolled horizontally.
         /// </summary>
@@ -100,6 +127,33 @@ namespace Avalonia.Input.GestureRecognizers
             set => SetAndRaise(ScrollStartDistanceProperty, ref _scrollStartDistance, value);
         }
 
+        /// <summary>
+        /// Gets the extent of the scrollable content.
+        /// </summary>
+        public Size? Extent
+        {
+            get => _extent;
+            private set => SetAndRaise(ExtentProperty, ref _extent, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the current scroll offset.
+        /// </summary>
+        public Vector? Offset
+        {
+            get => _offset;
+            private set => SetAndRaise(OffsetProperty, ref _offset, value);
+        }
+
+        /// <summary>
+        /// Gets the size of the viewport on the scrollable content.
+        /// </summary>
+        public Size? Viewport
+        {
+            get => _viewport;
+            private set => SetAndRaise(ViewportProperty, ref _viewport, value);
+        }
+
         protected override void PointerPressed(PointerPressedEventArgs e)
         {
             var point = e.GetCurrentPoint(null);
@@ -124,10 +178,34 @@ namespace Avalonia.Input.GestureRecognizers
                 var rootPoint = e.GetPosition(null);
                 if (!_scrolling)
                 {
-                    if (CanHorizontallyScroll && Math.Abs(_trackedRootPoint.X - rootPoint.X) > ScrollStartDistance)
-                        _scrolling = true;
-                    if (CanVerticallyScroll && Math.Abs(_trackedRootPoint.Y - rootPoint.Y) > ScrollStartDistance)
-                        _scrolling = true;
+                    if (CanVerticallyScroll)
+                    {
+                        double delta = _trackedRootPoint.Y - rootPoint.Y;
+
+                        if (Offset?.Y == 0 && delta < 0)
+                            return;
+
+                        if (Offset?.Y + Viewport?.Height - Extent?.Height == 0 && delta > 0)
+                            return;
+
+                        if (Math.Abs(delta) > ScrollStartDistance)
+                            _scrolling = true;
+                    }
+
+                    if (CanHorizontallyScroll)
+                    {
+                        double delta = _trackedRootPoint.X - rootPoint.X;
+
+                        if (Offset?.X == 0 && delta < 0)
+                            return;
+
+                        if (Offset?.X + Viewport?.Width - Extent?.Width == 0 && delta > 0)
+                            return;
+
+                        if (Math.Abs(delta) > ScrollStartDistance)
+                            _scrolling = true;
+                    }
+
                     if (_scrolling)
                     {
                         // Correct _trackedRootPoint with ScrollStartDistance, so scrolling does not start with a skip of ScrollStartDistance
diff --git a/src/Avalonia.Controls/PullToRefresh/RefreshContainer.cs b/src/Avalonia.Controls/PullToRefresh/RefreshContainer.cs
index 2c29b19d48..07bbfd53f3 100644
--- a/src/Avalonia.Controls/PullToRefresh/RefreshContainer.cs
+++ b/src/Avalonia.Controls/PullToRefresh/RefreshContainer.cs
@@ -41,7 +41,7 @@ namespace Avalonia.Controls
                 s => s.Visualizer, (s, o) => s.Visualizer = o);
 
         /// <summary>
-        /// Defines the <see cref="PullDirection"/> event.
+        /// Defines the <see cref="PullDirection"/> property.
         /// </summary>
         public static readonly StyledProperty<PullDirection> PullDirectionProperty =
             AvaloniaProperty.Register<RefreshContainer, PullDirection>(nameof(PullDirection), PullDirection.TopToBottom);
@@ -54,6 +54,25 @@ namespace Avalonia.Controls
                 SetAndRaise(RefreshInfoProviderAdapterProperty, ref _refreshInfoProviderAdapter, value);
             }
         }
+        
+        /// <summary>
+        /// Defines the <see cref="IsMouseEnabled"/> property.
+        /// </summary>
+        /// <remarks>
+        /// Allows to enable the pull 2 refresh gesture for devices using a mouse. Disabled by default 
+        /// </remarks>
+        public static readonly StyledProperty<bool> IsMouseEnabledProperty =
+            AvaloniaProperty.Register<RefreshContainer, bool>(nameof(IsMouseEnabled), false);
+        
+        /// <summary>
+        /// Gets or sets a value that indicates whether the pull-to-refresh gesture is enabled for desktop devices.
+        /// Allows to enable the pull 2 refresh gesture for devices using a mouse. Disabled by default
+        /// </summary>
+        public bool IsMouseEnabled
+        {
+            get => GetValue(IsMouseEnabledProperty);
+            set => SetValue(IsMouseEnabledProperty, value);
+        }
 
         /// <summary>
         /// Gets or sets the <see cref="RefreshVisualizer"/> for this container.
@@ -93,7 +112,7 @@ namespace Avalonia.Controls
         public RefreshContainer()
         {
             _hasDefaultRefreshInfoProviderAdapter = true;
-            _refreshInfoProviderAdapter = new ScrollViewerIRefreshInfoProviderAdapter(PullDirection);
+            _refreshInfoProviderAdapter = new ScrollViewerIRefreshInfoProviderAdapter(PullDirection, IsMouseEnabled);
             RaisePropertyChanged(RefreshInfoProviderAdapterProperty, null, _refreshInfoProviderAdapter);
         }
 
@@ -119,18 +138,29 @@ namespace Avalonia.Controls
 
         private void OnVisualizerSizeChanged(Rect obj)
         {
-            if (_hasDefaultRefreshInfoProviderAdapter)
-            {
-                _refreshInfoProviderAdapter = new ScrollViewerIRefreshInfoProviderAdapter(PullDirection);
+            if (_hasDefaultRefreshInfoProviderAdapter && _refreshInfoProviderAdapter != null)
+            {                
+                _refreshInfoProviderAdapter.UpdateVisualizerSize(obj.Size);
                 RaisePropertyChanged(RefreshInfoProviderAdapterProperty, null, _refreshInfoProviderAdapter);
             }
         }
 
         private void Visualizer_RefreshRequested(object? sender, RefreshRequestedEventArgs e)
         {
+            // Guarantee the inner deferral is balanced even if a downstream handler
+            // of RefreshRequestedEvent throws synchronously from RaiseEvent.
+            // Without this, a synchronously-throwing consumer leaves the visualizer's
+            // deferral count above zero forever, so RefreshCompleted never fires and
+            // the spinner stays stuck in Refreshing.
             var ev = new RefreshRequestedEventArgs(e.GetDeferral(), RefreshRequestedEvent);
-            RaiseEvent(ev);
-            ev.DecrementCount();
+            try
+            {
+                RaiseEvent(ev);
+            }
+            finally
+            {
+                ev.DecrementCount();
+            }
         }
 
         protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
@@ -181,6 +211,10 @@ namespace Avalonia.Controls
             {
                 OnPullDirectionChanged();
             }
+            else if (change.Property == IsMouseEnabledProperty)
+            {
+                OnIsMouseEnabledChanged();
+            }
         }
 
         private void OnPullDirectionChanged()
@@ -231,17 +265,25 @@ namespace Avalonia.Controls
                         break;
                 }
 
-                if (_hasDefaultRefreshInfoProviderAdapter &&
-                    _hasDefaultRefreshVisualizer &&
-                    _refreshVisualizer.Bounds.Height == DefaultPullDimensionSize &&
-                    _refreshVisualizer.Bounds.Width == DefaultPullDimensionSize)
-                {
-                    _refreshInfoProviderAdapter = new ScrollViewerIRefreshInfoProviderAdapter(PullDirection);
+                if (_hasDefaultRefreshInfoProviderAdapter)
+                {                
+                    if (_hasDefaultRefreshVisualizer)
+                    {                   
+                        var size = new Size(_refreshVisualizer.Width, _refreshVisualizer.Height);
+                        _refreshInfoProviderAdapter?.UpdateVisualizerSize(size);
+                    }
+
+                    _refreshInfoProviderAdapter?.UpdatePullDirection(PullDirection);
                     RaisePropertyChanged(RefreshInfoProviderAdapterProperty, null, _refreshInfoProviderAdapter);
                 }
             }
         }
 
+        private void OnIsMouseEnabledChanged()
+        {
+            _refreshInfoProviderAdapter?.UpdateIsMouseEnabled(IsMouseEnabled);
+        }
+        
         /// <summary>
         /// Initiates an update of the content.
         /// </summary>
diff --git a/src/Avalonia.Controls/PullToRefresh/RefreshInfoProvider.cs b/src/Avalonia.Controls/PullToRefresh/RefreshInfoProvider.cs
index db7b493fb7..8a57f68abc 100644
--- a/src/Avalonia.Controls/PullToRefresh/RefreshInfoProvider.cs
+++ b/src/Avalonia.Controls/PullToRefresh/RefreshInfoProvider.cs
@@ -9,8 +9,8 @@ namespace Avalonia.Controls.PullToRefresh
     {
         internal const double DefaultExecutionRatio = 0.8;
 
-        private readonly PullDirection _refreshPullDirection;
-        private readonly Size _refreshVisualizerSize;
+        private PullDirection _refreshPullDirection;
+        private Size _refreshVisualizerSize;
 
         private readonly CompositionVisual? _visual;
         private bool _isInteractingForRefresh;
@@ -30,6 +30,14 @@ namespace Avalonia.Controls.PullToRefresh
             AvaloniaProperty.RegisterDirect<RefreshInfoProvider, double>(nameof(InteractionRatio),
                 s => s.InteractionRatio, (s, o) => s.InteractionRatio = o);
 
+        public static readonly DirectProperty<RefreshInfoProvider, PullDirection> PullDirectionProperty =
+            AvaloniaProperty.RegisterDirect<RefreshInfoProvider, PullDirection>(nameof(PullDirection),
+                s => s.PullDirection, (s, o) => s.PullDirection = o);
+
+        public static readonly DirectProperty<RefreshInfoProvider, Size> RefreshVisualizerSizeProperty =
+            AvaloniaProperty.RegisterDirect<RefreshInfoProvider, Size>(nameof(RefreshVisualizerSize),
+                s => s.RefreshVisualizerSize, (s, o) => s.RefreshVisualizerSize = o);
+
         /// <summary>
         /// Defines the <see cref="RefreshStarted"/> event.
         /// </summary>
@@ -54,6 +62,17 @@ namespace Avalonia.Controls.PullToRefresh
                 if (isInteractingForRefresh != _isInteractingForRefresh)
                 {
                     SetAndRaise(IsInteractingForRefreshProperty, ref _isInteractingForRefresh, isInteractingForRefresh);
+
+                    // Keep _entered in sync with IsInteractingForRefresh.
+                    // The flag can be cleared by paths other than PullGestureEnded
+                    // (ScrollViewer_ScrollChanged / ScrollViewer_PointerReleased on the adapter).
+                    // Without this, InteractingStateEntered would short-circuit and never
+                    // re-assert the flag for the rest of the gesture, leaving the visualizer
+                    // stuck in Idle and the spinner invisible until the next gesture.
+                    if (!isInteractingForRefresh)
+                    {
+                        _entered = false;
+                    }
                 }
             }
         }
@@ -64,6 +83,18 @@ namespace Avalonia.Controls.PullToRefresh
             set => SetAndRaise(InteractionRatioProperty, ref _interactionRatio, value);
         }
 
+        public Size RefreshVisualizerSize
+        {
+            get => _refreshVisualizerSize;
+            set => SetAndRaise(RefreshVisualizerSizeProperty, ref _refreshVisualizerSize, value);
+        }
+
+        public PullDirection PullDirection
+        {
+            get => _refreshPullDirection;
+            set => SetAndRaise(PullDirectionProperty, ref _refreshPullDirection, value);
+        }
+
         public double ExecutionRatio
         {
             get => DefaultExecutionRatio;
@@ -130,7 +161,7 @@ namespace Avalonia.Controls.PullToRefresh
                     break;
                 case PullDirection.LeftToRight:
                 case PullDirection.RightToLeft:
-                    InteractionRatio = _refreshVisualizerSize.Height == 0 ? 1 : Math.Min(1, value.X / _refreshVisualizerSize.Width);
+                    InteractionRatio = _refreshVisualizerSize.Width == 0 ? 1 : Math.Min(1, value.X / _refreshVisualizerSize.Width);
                     break;
             }
         }
diff --git a/src/Avalonia.Controls/PullToRefresh/RefreshVisualizer.cs b/src/Avalonia.Controls/PullToRefresh/RefreshVisualizer.cs
index f92151e02a..d323965c13 100644
--- a/src/Avalonia.Controls/PullToRefresh/RefreshVisualizer.cs
+++ b/src/Avalonia.Controls/PullToRefresh/RefreshVisualizer.cs
@@ -18,6 +18,8 @@ namespace Avalonia.Controls
         private const float ParallaxPositionRatio = 0.5f;
         private double _executingRatio = 0.8;
 
+        private Vector3D _initialVisualOffset = default;
+
         private RefreshVisualizerState _refreshVisualizerState;
         private RefreshInfoProvider? _refreshInfoProvider;
         private IDisposable? _isInteractingSubscription;
@@ -211,47 +213,32 @@ namespace Avalonia.Controls
                                 _rotateAnimation.IterationBehavior = AnimationIterationBehavior.Count;
                                 _rotateAnimation = null;
                             }
+
                             contentVisual.Opacity = MinimumIndicatorOpacity;
                             contentVisual.RotationAngle = _startingRotationAngle;
-                            visualizerVisual.Offset = IsPullDirectionVertical ?
-                                new Vector3D(visualizerVisual.Offset.X, 0, 0) :
-                                new Vector3D(0, visualizerVisual.Offset.Y, 0);
-                            visual.Offset = visualizerVisual.Offset;
+
+                            if (visualizerVisual.Offset.X != 0 || visualizerVisual.Offset.Y != 0)
+                            {
+                                visual.Offset = _initialVisualOffset;
+                                visualizerVisual.Offset = new Vector3D(0, 0, 0);
+                            }
+
                             _content.InvalidateMeasure();
+
                             break;
                         case RefreshVisualizerState.Interacting:
                             _played = false;
                             contentVisual.Opacity = MinimumIndicatorOpacity;
                             contentVisual.RotationAngle = (float)(_startingRotationAngle + _interactionRatio * 2 * Math.PI);
-                            Vector3D offset = default;
-                            if (IsPullDirectionVertical)
-                            {
-                                offset = new Vector3D(0, (_interactionRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Height), 0);
-                            }
-                            else
-                            {
-                                offset = new Vector3D((_interactionRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Width), 0, 0);
-                            }
-                            visual.Offset = offset;
-                            visualizerVisual.Offset = IsPullDirectionVertical ? 
-                                new Vector3D(visualizerVisual.Offset.X, offset.Y, 0) :
-                                new Vector3D(offset.X, visualizerVisual.Offset.Y, 0);
+                            
+                            CalculateAndSetOffsets(root, visual, visualizerVisual);
+
                             break;
                         case RefreshVisualizerState.Pending:
                             contentVisual.Opacity = 1;
                             contentVisual.RotationAngle = _startingRotationAngle + (float)(2 * Math.PI);
-                            if (IsPullDirectionVertical)
-                            {
-                                offset = new Vector3D(0, (_interactionRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Height), 0);
-                            }
-                            else
-                            {
-                                offset = new Vector3D((_interactionRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Width), 0, 0);
-                            }
-                            visual.Offset = offset;
-                            visualizerVisual.Offset = IsPullDirectionVertical ? 
-                                new Vector3D(visualizerVisual.Offset.X, offset.Y, 0) : 
-                                new Vector3D(offset.X, visualizerVisual.Offset.Y, 0);
+
+                            CalculateAndSetOffsets(root, visual, visualizerVisual);
 
                             if (!_played)
                             {
@@ -278,20 +265,8 @@ namespace Avalonia.Controls
                             contentVisual.Opacity = 1;
                             float translationRatio = (float)(_refreshInfoProvider != null ?  (1.0f - _refreshInfoProvider.ExecutionRatio) * ParallaxPositionRatio : 1.0f) 
                                 * (IsPullDirectionFar ? -1f : 1f);
-                            if (IsPullDirectionVertical)
-                            {
-                                offset = new Vector3D(0, (_executingRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Height), 0);
-                            }
-                            else
-                            {
-                                offset = new Vector3D((_executingRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Width), 0, 0);
-                            }
-                            visual.Offset = offset;
-                            contentVisual.Offset += IsPullDirectionVertical ? new Vector3D(0, (translationRatio * root.Bounds.Height), 0) :
-                                new Vector3D((translationRatio * root.Bounds.Width), 0, 0);
-                            visualizerVisual.Offset = IsPullDirectionVertical ?
-                                new Vector3D(visualizerVisual.Offset.X, offset.Y, 0) :
-                                new Vector3D(offset.X, visualizerVisual.Offset.Y, 0);
+
+                            CalculateAndSetOffsets(root, visual, visualizerVisual);
                             break;
                         case RefreshVisualizerState.Peeking:
                             contentVisual.Opacity = 1;
@@ -302,6 +277,36 @@ namespace Avalonia.Controls
             }
         }
 
+        private void CalculateAndSetOffsets(Grid root, CompositionVisual visual, CompositionVisual indicatorVisualizer)
+        {
+            if (IsPullDirectionVertical)
+            {
+                // As long as the indicator-container isn't visible,
+                // the initial offset is the current offset
+                if (indicatorVisualizer.Offset.Y == 0)
+                {
+                    _initialVisualOffset = visual.Offset;
+                }
+
+                var offset = _interactionRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Height;
+                indicatorVisualizer.Offset = indicatorVisualizer.Offset with { Y = offset };
+
+                visual.Offset = _initialVisualOffset with { Y = _initialVisualOffset.Y + offset };         
+            }
+            else
+            {
+                if (indicatorVisualizer.Offset.X == 0)
+                {
+                    _initialVisualOffset = visual.Offset;
+                }
+
+                var offset = _interactionRatio * (IsPullDirectionFar ? -1 : 1) * root.Bounds.Width;
+                indicatorVisualizer.Offset = indicatorVisualizer.Offset with { X = offset };
+
+                visual.Offset = _initialVisualOffset with { X = _initialVisualOffset.X + offset }; 
+            }
+        }
+
         /// <summary>
         /// Initiates an update of the content.
         /// </summary>
@@ -371,32 +376,39 @@ namespace Avalonia.Controls
             }
             else if (change.Property == BoundsProperty)
             {
-                switch (PullDirection)
-                {
-                    case PullDirection.TopToBottom:
-                        RenderTransform = new TranslateTransform(0, -Bounds.Height);
-                        break;
-                    case PullDirection.BottomToTop:
-                        RenderTransform = new TranslateTransform(0, Bounds.Height);
-                        break;
-                    case PullDirection.LeftToRight:
-                        RenderTransform = new TranslateTransform(-Bounds.Width, 0);
-                        break;
-                    case PullDirection.RightToLeft:
-                        RenderTransform = new TranslateTransform(Bounds.Width, 0);
-                        break;
-                }
+                OnBoundsChanged();
 
                 UpdateContent();
             }
-            else if(change.Property == PullDirectionProperty)
+            else if (change.Property == PullDirectionProperty)
             {
                 OnOrientationChanged();
 
+                OnBoundsChanged();
+
                 UpdateContent();
             }
         }
 
+        private void OnBoundsChanged()
+        {
+            switch (PullDirection)
+            {
+                case PullDirection.TopToBottom:
+                    RenderTransform = new TranslateTransform(0, -Bounds.Height);
+                    break;
+                case PullDirection.BottomToTop:
+                    RenderTransform = new TranslateTransform(0, Bounds.Height);
+                    break;
+                case PullDirection.LeftToRight:
+                    RenderTransform = new TranslateTransform(-Bounds.Width, 0);
+                    break;
+                case PullDirection.RightToLeft:
+                    RenderTransform = new TranslateTransform(Bounds.Width, 0);
+                    break;
+            }
+        }
+
         private void OnOrientationChanged()
         {
             switch (_orientation)
diff --git a/src/Avalonia.Controls/PullToRefresh/ScrollViewerIRefreshInfoProviderAdapter.cs b/src/Avalonia.Controls/PullToRefresh/ScrollViewerIRefreshInfoProviderAdapter.cs
index 48063d90f8..875f5a5963 100644
--- a/src/Avalonia.Controls/PullToRefresh/ScrollViewerIRefreshInfoProviderAdapter.cs
+++ b/src/Avalonia.Controls/PullToRefresh/ScrollViewerIRefreshInfoProviderAdapter.cs
@@ -12,15 +12,20 @@ namespace Avalonia.Controls.PullToRefresh
         private const int InitialOffsetThreshold = 1;
 
         private PullDirection _refreshPullDirection;
+        private bool _isMouseEnabled;
         private ScrollViewer? _scrollViewer;
         private RefreshInfoProvider? _refreshInfoProvider;
-        private PullGestureRecognizer? _pullGestureRecognizer;
+        private ScrollablePullGestureRecognizer? _pullGestureRecognizer;
         private InputElement? _interactionSource;
         private bool _isVisualizerInteractionSourceAttached;
 
-        public ScrollViewerIRefreshInfoProviderAdapter(PullDirection pullDirection)
+        internal InputElement? InteractionSource
+            => _interactionSource;
+
+        public ScrollViewerIRefreshInfoProviderAdapter(PullDirection pullDirection, bool isMouseEnabled)
         {
             _refreshPullDirection = pullDirection;
+            _isMouseEnabled = isMouseEnabled;
         }
 
         public RefreshInfoProvider? AdaptFromTree(Visual root, Size? refreshVIsualizerSize)
@@ -93,6 +98,18 @@ namespace Avalonia.Controls.PullToRefresh
                 _interactionSource.RemoveHandler(InputElement.PullGestureEndedEvent, _refreshInfoProvider.InteractingStateExited);
             }
 
+            // Remove the previous pull gesture recognizer from the previous interaction source,
+            // otherwise repeated Adapt() calls (e.g. when the visual tree gets re-templated)
+            // accumulate recognizers, leading to duplicate PullGesture/PullGestureEnded events.
+            if (_pullGestureRecognizer != null && _interactionSource != null)
+            {
+                _interactionSource.GestureRecognizers.Remove(_pullGestureRecognizer);
+            }
+
+            _pullGestureRecognizer = null;
+            _interactionSource = null;
+            _isVisualizerInteractionSourceAttached = false;
+
             _refreshInfoProvider = null;
             _scrollViewer = adaptee;
 
@@ -124,7 +141,7 @@ namespace Avalonia.Controls.PullToRefresh
 
             _refreshInfoProvider = new RefreshInfoProvider(_refreshPullDirection, refreshVIsualizerSize, ElementComposition.GetElementVisual(content));
 
-            _pullGestureRecognizer = new PullGestureRecognizer(_refreshPullDirection);
+            _pullGestureRecognizer = new ScrollablePullGestureRecognizer(_refreshPullDirection, _isMouseEnabled);
 
             if (_interactionSource != null)
             {
@@ -261,6 +278,39 @@ namespace Avalonia.Controls.PullToRefresh
             return false;
         }
 
+        public void UpdatePullDirection(PullDirection pullDirection)
+        {
+            _refreshPullDirection = pullDirection;
+
+            if (_refreshInfoProvider != null)
+            {
+                _refreshInfoProvider.PullDirection = pullDirection;
+            }
+
+            if (_pullGestureRecognizer != null)
+            {
+                _pullGestureRecognizer.PullDirection = pullDirection;
+            }
+        }
+
+        public void UpdateIsMouseEnabled(bool IsMouseEnabled)
+        {
+            _isMouseEnabled = IsMouseEnabled;
+            
+            if (_pullGestureRecognizer != null)
+            {
+                _pullGestureRecognizer.IsMouseEnabled = IsMouseEnabled;
+            }
+        }
+
+        public void UpdateVisualizerSize(Size? refreshVisualizerSize)
+        {
+            if (_refreshInfoProvider != null)
+            {
+                _refreshInfoProvider.RefreshVisualizerSize = refreshVisualizerSize ?? default;
+            }
+        }
+
         private void CleanUpScrollViewer()
         {
             if (_scrollViewer != null)
diff --git a/src/Avalonia.Controls/PullToRefresh/ScrollablePullGestureRecognizer.cs b/src/Avalonia.Controls/PullToRefresh/ScrollablePullGestureRecognizer.cs
new file mode 100644
index 0000000000..3c8adf4c47
--- /dev/null
+++ b/src/Avalonia.Controls/PullToRefresh/ScrollablePullGestureRecognizer.cs
@@ -0,0 +1,158 @@
+using System;
+using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+using Avalonia.Input.GestureRecognizers;
+
+namespace Avalonia.Controls.PullToRefresh
+{
+    internal class ScrollablePullGestureRecognizer : GestureRecognizer
+    {
+        private int _gestureId;
+        private bool _pullInProgress;
+
+        private double _delta = 1;
+
+        private Point _initialPosition;
+        private IPointer? _tracking;
+
+        /// <summary>
+        /// Defines the <see cref="PullDirection"/> property.
+        /// </summary>
+        public static readonly StyledProperty<PullDirection> PullDirectionProperty =
+            AvaloniaProperty.Register<ScrollablePullGestureRecognizer, PullDirection>(nameof(PullDirection));
+
+        public PullDirection PullDirection
+        {
+            get => GetValue(PullDirectionProperty);
+            set => SetValue(PullDirectionProperty, value);
+        }
+
+        public bool IsMouseEnabled { get; set; }
+
+        public ScrollablePullGestureRecognizer(PullDirection pullDirection, bool isMouseEnabled)
+        {
+            PullDirection = pullDirection;
+            IsMouseEnabled = isMouseEnabled;
+        }
+
+        public ScrollablePullGestureRecognizer() { }
+
+        protected override void PointerCaptureLost(IPointer pointer)
+        {
+            if (_tracking == pointer)
+            {
+                EndPull();
+            }
+
+            // PointerReleased clears these fields; PointerCaptureLost must do the same,
+            // otherwise the next gesture re-enters PointerMoved with _pullInProgress=true
+            // and reuses the just-ended _gestureId for a new PullGestureEvent.
+            _tracking = null;
+            _initialPosition = default;
+            _pullInProgress = false;
+        }
+
+        protected override void PointerPressed(PointerPressedEventArgs e)
+        {
+            var isEnabledOnPlatform = (e.Pointer.Type == PointerType.Touch || e.Pointer.Type == PointerType.Pen) // either it is a touch device
+                                      || IsMouseEnabled; // or desktop is enabled
+            
+            if (Target != null && Target is Visual visual && isEnabledOnPlatform)
+            {
+                _tracking = e.Pointer;
+                _initialPosition = e.GetPosition(visual);
+            }
+        }
+
+        protected override void PointerMoved(PointerEventArgs e)
+        {
+            if (_tracking != e.Pointer)
+                return;
+
+            if (Target is Visual visual && visual is IScrollable scrollable && CanPull(scrollable))
+            {
+                var currentPosition = e.GetPosition(visual);
+
+                var delta = CalculateDelta(currentPosition);
+
+                bool pulling = delta.Y > 0 || delta.X > 0;
+                _pullInProgress = (_pullInProgress, pulling) switch
+                {
+                    (false, false) => false,
+                    (false, true) => BeginPull(e, delta),
+                    (true, true) => HandlePull(e, delta),
+                    (true, false) => EndPull(),
+                };
+            }
+        }
+
+        protected override void PointerReleased(PointerReleasedEventArgs e)
+        {
+            try
+            {
+                if (_pullInProgress == true)
+                {
+                    EndPull();
+                }
+            }
+            finally
+            {
+                // HandlePull captures the pointer on every PointerMoved with positive delta.
+                // The (true, false) -> EndPull transition in PointerMoved clears
+                // _pullInProgress without releasing capture, so by the time we get here
+                // the gesture is no longer in progress but the pointer can still be
+                // captured by this recognizer. Always release capture so the next
+                // gesture starts from a clean state.
+                if (_tracking != null)
+                {
+                    e.Pointer.Capture(null);
+                }
+
+                _tracking = null;
+                _initialPosition = default;
+                _pullInProgress = false;
+            }
+        }
+
+        private bool BeginPull(PointerEventArgs e, Vector delta)
+        {
+            _gestureId = PullGestureEventArgs.GetNextFreeId();
+            return HandlePull(e, delta);
+        }
+
+        private bool HandlePull(PointerEventArgs e, Vector delta)
+        {
+            Capture(e.Pointer);
+
+            var pullEventArgs = new PullGestureEventArgs(_gestureId, delta, PullDirection);
+            Target?.RaiseEvent(pullEventArgs);
+
+            e.Handled = pullEventArgs.Handled;
+            return true;
+        }
+
+        private bool EndPull()
+        {
+            Target?.RaiseEvent(new PullGestureEndedEventArgs(_gestureId, PullDirection));
+            return false;
+        }
+
+        private Vector CalculateDelta(Point currentPosition) => PullDirection switch
+        {
+            PullDirection.TopToBottom => new Vector(0, currentPosition.Y - _initialPosition.Y),
+            PullDirection.BottomToTop => new Vector(0, _initialPosition.Y - currentPosition.Y),
+            PullDirection.LeftToRight => new Vector(currentPosition.X - _initialPosition.X, 0),
+            PullDirection.RightToLeft => new Vector(_initialPosition.X - currentPosition.X, 0),
+            _ => default,
+        };
+
+        private bool CanPull(IScrollable scrollable) => PullDirection switch
+        {
+            PullDirection.TopToBottom => scrollable.Offset.Y < _delta,
+            PullDirection.BottomToTop => Math.Abs(scrollable.Offset.Y + scrollable.Viewport.Height - scrollable.Extent.Height) <= _delta,
+            PullDirection.LeftToRight => scrollable.Offset.X < _delta,
+            PullDirection.RightToLeft => Math.Abs(scrollable.Offset.X + scrollable.Viewport.Width - scrollable.Extent.Width) <= _delta,
+            _ => false,
+        };
+    }
+}
diff --git a/src/Avalonia.Themes.Fluent/Controls/ScrollViewer.xaml b/src/Avalonia.Themes.Fluent/Controls/ScrollViewer.xaml
index 611c7dc49b..ef861532ae 100644
--- a/src/Avalonia.Themes.Fluent/Controls/ScrollViewer.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/ScrollViewer.xaml
@@ -37,7 +37,10 @@
             <ScrollContentPresenter.GestureRecognizers>
               <ScrollGestureRecognizer CanHorizontallyScroll="{Binding CanHorizontallyScroll, ElementName=PART_ContentPresenter}"
                                        CanVerticallyScroll="{Binding CanVerticallyScroll, ElementName=PART_ContentPresenter}"
-                                       IsScrollInertiaEnabled="{Binding (ScrollViewer.IsScrollInertiaEnabled), ElementName=PART_ContentPresenter}"/>
+                                       IsScrollInertiaEnabled="{Binding (ScrollViewer.IsScrollInertiaEnabled), ElementName=PART_ContentPresenter}"
+                                       Offset="{Binding Offset, ElementName=PART_ContentPresenter}"
+                                       Viewport="{Binding Viewport, ElementName=PART_ContentPresenter}"
+                                       Extent="{Binding Extent, ElementName=PART_ContentPresenter}"/>
             </ScrollContentPresenter.GestureRecognizers>
           </ScrollContentPresenter>
           <ScrollBar Name="PART_HorizontalScrollBar"
diff --git a/src/Avalonia.Themes.Simple/Controls/ScrollViewer.xaml b/src/Avalonia.Themes.Simple/Controls/ScrollViewer.xaml
index f691ff6651..7cb45407c5 100644
--- a/src/Avalonia.Themes.Simple/Controls/ScrollViewer.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/ScrollViewer.xaml
@@ -20,7 +20,10 @@
             <ScrollContentPresenter.GestureRecognizers>
               <ScrollGestureRecognizer CanHorizontallyScroll="{Binding CanHorizontallyScroll, ElementName=PART_ContentPresenter}"
                                        CanVerticallyScroll="{Binding CanVerticallyScroll, ElementName=PART_ContentPresenter}"
-                                       IsScrollInertiaEnabled="{Binding (ScrollViewer.IsScrollInertiaEnabled), ElementName=PART_ContentPresenter}"/>
+                                       IsScrollInertiaEnabled="{Binding (ScrollViewer.IsScrollInertiaEnabled), ElementName=PART_ContentPresenter}"
+                                       Offset="{Binding Offset, ElementName=PART_ContentPresenter}"
+                                       Viewport="{Binding Viewport, ElementName=PART_ContentPresenter}"
+                                       Extent="{Binding Extent, ElementName=PART_ContentPresenter}"/>
             </ScrollContentPresenter.GestureRecognizers>
           </ScrollContentPresenter>
           <ScrollBar Name="PART_HorizontalScrollBar"
diff --git a/tests/Avalonia.Controls.UnitTests/PullToRefresh/RefreshInfoProviderTests.cs b/tests/Avalonia.Controls.UnitTests/PullToRefresh/RefreshInfoProviderTests.cs
new file mode 100644
index 0000000000..bc4126886a
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/PullToRefresh/RefreshInfoProviderTests.cs
@@ -0,0 +1,95 @@
+using Avalonia.Controls.PullToRefresh;
+using Avalonia.Input;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests.PullToRefresh
+{
+    public class RefreshInfoProviderTests : ScopedTestBase
+    {
+        // Repro for the "_entered desync" bug.
+        //
+        // Real-world flow that triggers it:
+        //   1. User starts pulling.   ScrollablePullGestureRecognizer raises PullGestureEvent
+        //                             -> InteractingStateEntered sets IsInteractingForRefresh = true
+        //                                and _entered = true.
+        //   2. The pull motion produces a small ScrollChanged that pushes the scroll offset
+        //      past the threshold. ScrollViewerIRefreshInfoProviderAdapter.ScrollViewer_ScrollChanged
+        //      writes IsInteractingForRefresh = false directly, bypassing PullGestureEnded.
+        //      (ScrollViewer_PointerReleased does the same.)
+        //   3. _entered stays true.
+        //   4. The user is still pulling, more PullGestureEvents arrive.
+        //      InteractingStateEntered short-circuits because _entered is already true,
+        //      so IsInteractingForRefresh is NOT reasserted.
+        //   5. RefreshVisualizer never re-enters the Interacting state -> spinner does not appear.
+        [Fact]
+        public void IsInteractingForRefresh_Is_Reasserted_After_Being_Cleared_Externally()
+        {
+            var provider = new RefreshInfoProvider(
+                PullDirection.TopToBottom,
+                new Size(100, 100),
+                visual: null);
+
+            var pullArgs = new PullGestureEventArgs(0, new Vector(0, 50), PullDirection.TopToBottom);
+
+            // 1. First PullGestureEvent of a gesture
+            provider.InteractingStateEntered(this, pullArgs);
+            Assert.True(provider.IsInteractingForRefresh,
+                "IsInteractingForRefresh should be true after the first PullGestureEvent");
+
+            // 2. Adapter clears the flag directly (simulating ScrollViewer_ScrollChanged
+            //    or ScrollViewer_PointerReleased)
+            provider.IsInteractingForRefresh = false;
+            Assert.False(provider.IsInteractingForRefresh);
+
+            // 3. Pull is still in progress, the next PullGestureEvent arrives
+            provider.InteractingStateEntered(this, pullArgs);
+
+            // BUG: stays false because _entered short-circuits the assignment.
+            // After the fix this assertion must pass.
+            Assert.True(provider.IsInteractingForRefresh,
+                "PullGestureEvent must re-assert IsInteractingForRefresh after it was cleared by something other than PullGestureEnded");
+        }
+
+        // Repro for the typo where horizontal pulls checked Height==0 instead of Width==0.
+        // With Width==0, value.X / Width produces +Infinity / NaN, which then breaks every
+        // downstream consumer of InteractionRatio (Math.Min(1, NaN) returns NaN).
+        [Fact]
+        public void Horizontal_Pull_With_Zero_Width_Produces_Safe_InteractionRatio()
+        {
+            var provider = new RefreshInfoProvider(
+                PullDirection.LeftToRight,
+                new Size(0, 100),
+                visual: null);
+
+            provider.ValuesChanged(new Vector(50, 0));
+
+            Assert.False(double.IsNaN(provider.InteractionRatio));
+            Assert.False(double.IsInfinity(provider.InteractionRatio));
+        }
+
+        // Sanity check for the existing happy-path: a complete gesture lifecycle
+        // (Entered -> Exited -> Entered) must toggle IsInteractingForRefresh correctly.
+        [Fact]
+        public void Normal_Gesture_Lifecycle_Toggles_IsInteractingForRefresh_Correctly()
+        {
+            var provider = new RefreshInfoProvider(
+                PullDirection.TopToBottom,
+                new Size(100, 100),
+                visual: null);
+
+            var pullArgs = new PullGestureEventArgs(0, new Vector(0, 50), PullDirection.TopToBottom);
+            var endArgs = new PullGestureEndedEventArgs(0, PullDirection.TopToBottom);
+
+            provider.InteractingStateEntered(this, pullArgs);
+            Assert.True(provider.IsInteractingForRefresh);
+
+            provider.InteractingStateExited(this, endArgs);
+            Assert.False(provider.IsInteractingForRefresh);
+
+            // Next gesture should work
+            provider.InteractingStateEntered(this, pullArgs);
+            Assert.True(provider.IsInteractingForRefresh);
+        }
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/PullToRefresh/ScrollViewerIRefreshInfoProviderAdapterTests.cs b/tests/Avalonia.Controls.UnitTests/PullToRefresh/ScrollViewerIRefreshInfoProviderAdapterTests.cs
new file mode 100644
index 0000000000..0af36c3f39
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/PullToRefresh/ScrollViewerIRefreshInfoProviderAdapterTests.cs
@@ -0,0 +1,50 @@
+using System.Linq;
+using Avalonia.Controls.PullToRefresh;
+using Avalonia.Controls.Templates;
+using Avalonia.Input;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests.PullToRefresh;
+
+public class ScrollViewerIRefreshInfoProviderAdapterTests : ScopedTestBase
+{
+    // Repro for the "gesture recognizer leaked across Adapt() calls" bug.
+    //
+    // Adapt() cleans up the previous ScrollViewer's pointer handlers and the previous
+    // RefreshInfoProvider's pull-event handlers, but never removes the previously-created
+    // ScrollablePullGestureRecognizer from _interactionSource.GestureRecognizers.
+    // Each subsequent Adapt() instantiates and adds a new recognizer, so the input element
+    // ends up holding N recognizers after N calls. They all listen for the same pointer
+    // events and raise duplicate PullGesture/PullGestureEnded pairs, which (combined with
+    // the _entered desync fix in RefreshInfoProvider) corrupts the visualizer state.
+    [Fact]
+    public void Adapt_Called_Twice_Does_Not_Leak_Pull_Gesture_Recognizer()
+    {
+        var sv = new ScrollViewer
+        {
+            Template = new FuncControlTemplate<ScrollViewer>(ScrollViewerTests.CreateTemplate),
+            Content = new Border(),
+        };
+
+        // Wrap in a TestRoot and execute the layout pass so Loaded fires and the
+        // visual tree under the ScrollContentPresenter is fully wired up
+        // (otherwise the adapter never reaches MakeInteractionSource).
+        var root = new TestRoot(sv);
+        root.LayoutManager.ExecuteInitialLayoutPass();
+
+        var adapter = new ScrollViewerIRefreshInfoProviderAdapter(PullDirection.TopToBottom, isMouseEnabled: false);
+
+        adapter.Adapt(sv, new Size(100, 100));
+        var interactionSource = adapter.InteractionSource;
+        Assert.NotNull(interactionSource);
+        var afterFirst = interactionSource.GestureRecognizers.OfType<ScrollablePullGestureRecognizer>().Count();
+        Assert.Equal(1, afterFirst);
+
+        adapter.Adapt(sv, new Size(100, 100));
+        var interactionSourceAfter = adapter.InteractionSource;
+        Assert.NotNull(interactionSourceAfter);
+        var afterSecond = interactionSourceAfter.GestureRecognizers.OfType<ScrollablePullGestureRecognizer>().Count();
+        Assert.Equal(1, afterSecond);
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/PullToRefresh/ScrollablePullGestureRecognizerTests.cs b/tests/Avalonia.Controls.UnitTests/PullToRefresh/ScrollablePullGestureRecognizerTests.cs
new file mode 100644
index 0000000000..284cf2f853
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/PullToRefresh/ScrollablePullGestureRecognizerTests.cs
@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.PullToRefresh;
+using Avalonia.Input;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests.PullToRefresh;
+
+public class ScrollablePullGestureRecognizerTests : ScopedTestBase
+{
+    // Repro for the "PointerCaptureLost doesn't clean up state" bug.
+    //
+    // PointerReleased clears _pullInProgress, _tracking, _initialPosition.
+    // PointerCaptureLost only raises EndPull (so the PullGestureEnded event fires)
+    // but leaves _pullInProgress == true and _tracking pointing at the lost pointer.
+    // The next gesture re-enters PointerMoved with (_pullInProgress=true, pulling=true)
+    // and goes straight to HandlePull, skipping BeginPull. This reuses the OLD _gestureId
+    // for the next PullGestureEvent - the same id that was just used in the
+    // PullGestureEndedEvent for the previous gesture.
+    [Fact]
+    public void Gesture_After_PointerCaptureLost_Uses_A_New_Id()
+    {
+        var scrollable = new TestScrollable();
+        var recognizer = new ScrollablePullGestureRecognizer(PullDirection.TopToBottom, isMouseEnabled: true);
+        scrollable.GestureRecognizers.Add(recognizer);
+
+        var root = new TestRoot(scrollable);
+
+        var pullIds = new List<int>();
+        var endedIds = new List<int>();
+        root.AddHandler(InputElement.PullGestureEvent, (_, e) => pullIds.Add(e.Id));
+        root.AddHandler(InputElement.PullGestureEndedEvent, (_, e) => endedIds.Add(e.Id));
+
+        var touch = new TouchTestHelper();
+
+        // First gesture: start pulling downwards so the recognizer begins a pull and captures the pointer.
+        touch.Down(scrollable, new Point(10, 20));
+        touch.Move(scrollable, new Point(10, 70));
+
+        Assert.Single(pullIds);
+        var firstGestureId = pullIds[0];
+
+        // Capture is lost (e.g. another control steals it, or the visual is detached mid-gesture)
+        touch.Cancel();
+
+        Assert.Equal([firstGestureId], endedIds);
+
+        // Second gesture must begin cleanly (BeginPull, not HandlePull) and therefore get a fresh id.
+        touch.Down(scrollable, new Point(10, 20));
+        touch.Move(scrollable, new Point(10, 70));
+
+        Assert.Equal(2, pullIds.Count);
+        Assert.NotEqual(firstGestureId, pullIds[1]);
+    }
+
+    private sealed class TestScrollable : Decorator, IScrollable
+    {
+        public Size Extent => new(100, 1000);
+        public Vector Offset { get; set; }
+        public Size Viewport => new(100, 100);
+        public bool CanHorizontallyScroll { get => false; }
+        public bool CanVerticallyScroll { get => true; }
+    }
+}

From b25f2d98c2ccc02170038023f71a53cd368e9d76 Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Tue, 23 Jun 2026 03:18:38 +0800
Subject: [PATCH 040/196] AT-SPI: Expose list item containers as accessible
 children (#21605)

* AT-SPI: add to the selection in Selection.SelectChild instead of replacing it

* AT-SPI: expose list item containers as accessible children

Index selectable items directly under the selection container so the
Selection interface's SelectChild/DeselectChild address them by index.

* Expose ListBox selection to accessibility via a selection peer

ListBox used ItemsControlAutomationPeer, which is not an ISelectionProvider,
so it never exposed the Selection interface (AT-SPI) for multi-select.

* Address review: expose item containers from the base ItemsControl peer

Move the GetChildrenCore container override down to ItemsControlAutomationPeer so every ItemsControl returns its containers, and return null directly when there are no items instead of calling the base algorithm.

* Use file-scoped namespace in ListBoxAutomationPeer

* Fix cross-platform regression: move child flattening from the peer to the AT-SPI selection handler

* Trigger rebuild

* AT-SPI: flatten selection container item children in the node layer, not the shared peer

Present a SelectingItemsControl's realized item containers as its direct AT-SPI children inside AtSpiNode so SelectChild-by-index and a selectable item's parent lookup resolve to the Selection container. Doing this in the FreeDesktop AT-SPI layer keeps the macOS AX and Windows UIA peer trees intact, avoiding the item-frame and tree-collapse regressions the shared ItemsControlAutomationPeer override caused.
---
 .../Peers/ItemsControlAutomationPeer.cs       |  3 +-
 .../Automation/Peers/ListBoxAutomationPeer.cs | 11 ++++
 src/Avalonia.Controls/ListBox.cs              |  6 ++
 src/Avalonia.FreeDesktop.AtSpi/AtSpiNode.cs   | 28 +++++++-
 .../Handlers/AtSpiSelectionHandler.cs         | 65 ++++++++++---------
 5 files changed, 78 insertions(+), 35 deletions(-)
 create mode 100644 src/Avalonia.Controls/Automation/Peers/ListBoxAutomationPeer.cs

diff --git a/src/Avalonia.Controls/Automation/Peers/ItemsControlAutomationPeer.cs b/src/Avalonia.Controls/Automation/Peers/ItemsControlAutomationPeer.cs
index 64727c43c5..278e6cdfce 100644
--- a/src/Avalonia.Controls/Automation/Peers/ItemsControlAutomationPeer.cs
+++ b/src/Avalonia.Controls/Automation/Peers/ItemsControlAutomationPeer.cs
@@ -1,4 +1,5 @@
-using Avalonia.Automation.Provider;
+using System.Collections.Generic;
+using Avalonia.Automation.Provider;
 using Avalonia.Controls;
 
 namespace Avalonia.Automation.Peers
diff --git a/src/Avalonia.Controls/Automation/Peers/ListBoxAutomationPeer.cs b/src/Avalonia.Controls/Automation/Peers/ListBoxAutomationPeer.cs
new file mode 100644
index 0000000000..d8aae6f82c
--- /dev/null
+++ b/src/Avalonia.Controls/Automation/Peers/ListBoxAutomationPeer.cs
@@ -0,0 +1,11 @@
+using Avalonia.Controls;
+
+namespace Avalonia.Automation.Peers;
+
+public class ListBoxAutomationPeer : SelectingItemsControlAutomationPeer
+{
+    public ListBoxAutomationPeer(ListBox owner)
+        : base(owner)
+    {
+    }
+}
diff --git a/src/Avalonia.Controls/ListBox.cs b/src/Avalonia.Controls/ListBox.cs
index 3ef75f4990..9307bf9b44 100644
--- a/src/Avalonia.Controls/ListBox.cs
+++ b/src/Avalonia.Controls/ListBox.cs
@@ -3,6 +3,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Drawing;
 using System.Linq;
+using Avalonia.Automation.Peers;
 using Avalonia.Controls.Metadata;
 using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Selection;
@@ -126,6 +127,11 @@ namespace Avalonia.Controls
             return NeedsContainer<ListBoxItem>(item, out recycleKey);
         }
 
+        protected override AutomationPeer OnCreateAutomationPeer()
+        {
+            return new ListBoxAutomationPeer(this);
+        }
+
         protected override void OnKeyDown(KeyEventArgs e)
         {
             var hotkeys = this.GetPlatformSettings()?.HotkeyConfiguration;
diff --git a/src/Avalonia.FreeDesktop.AtSpi/AtSpiNode.cs b/src/Avalonia.FreeDesktop.AtSpi/AtSpiNode.cs
index dc099464a6..09fec39c0f 100644
--- a/src/Avalonia.FreeDesktop.AtSpi/AtSpiNode.cs
+++ b/src/Avalonia.FreeDesktop.AtSpi/AtSpiNode.cs
@@ -164,6 +164,30 @@ namespace Avalonia.FreeDesktop.AtSpi
 
         internal bool RemoveAttachedChild(AtSpiNode child) => _attachedChildren.Remove(child);
 
+        // Present a selection container's realized item containers as its direct
+        // AT-SPI children so SelectChild-by-index and parent lookups work.
+        private IReadOnlyList<AutomationPeer> GetChildPeers()
+        {
+            if (Peer.GetProvider<ISelectionProvider>() is null)
+                return Peer.GetChildren();
+
+            var items = new List<AutomationPeer>();
+            CollectSelectionItemPeers(Peer.GetChildren(), items);
+            return items.Count > 0 ? items : Peer.GetChildren();
+        }
+
+        private static void CollectSelectionItemPeers(
+            IReadOnlyList<AutomationPeer> peers, List<AutomationPeer> result)
+        {
+            foreach (var peer in peers)
+            {
+                if (peer.GetProvider<ISelectionItemProvider>() is not null)
+                    result.Add(peer);
+                else
+                    CollectSelectionItemPeers(peer.GetChildren(), result);
+            }
+        }
+
         internal IReadOnlyList<AtSpiNode> EnsureChildren()
         {
             if (!IsAttached)
@@ -172,7 +196,7 @@ namespace Avalonia.FreeDesktop.AtSpi
             if (!_childrenDirty)
                 return _attachedChildren;
 
-            var childPeers = Peer.GetChildren();
+            var childPeers = GetChildPeers();
             var nextChildren = new List<AtSpiNode>(childPeers.Count);
             var nextChildrenSet = new HashSet<AtSpiNode>();
             foreach (var childPeer in childPeers)
@@ -275,7 +299,7 @@ namespace Avalonia.FreeDesktop.AtSpi
 
             _childrenDirty = true;
 
-            var childPeers = Peer.GetChildren();
+            var childPeers = GetChildPeers();
             if (_attachedChildren.Count > 0)
             {
                 var currentPeers = new HashSet<AutomationPeer>(childPeers);
diff --git a/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiSelectionHandler.cs b/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiSelectionHandler.cs
index 95bd6e032d..85d76374c5 100644
--- a/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiSelectionHandler.cs
+++ b/src/Avalonia.FreeDesktop.AtSpi/Handlers/AtSpiSelectionHandler.cs
@@ -1,6 +1,6 @@
-using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using Avalonia.Automation.Peers;
 using Avalonia.Automation.Provider;
 using Avalonia.DBus;
 using Avalonia.FreeDesktop.AtSpi.DBusXml;
@@ -8,9 +8,6 @@ using static Avalonia.FreeDesktop.AtSpi.AtSpiConstants;
 
 namespace Avalonia.FreeDesktop.AtSpi.Handlers
 {
-    /// <summary>
-    /// Implements the AT-SPI Selection interface for list-like containers.
-    /// </summary>
     internal sealed class AtSpiSelectionHandler(AtSpiServer server, AtSpiNode node) : IOrgA11yAtspiSelection
     {
         public uint Version => SelectionVersion;
@@ -38,7 +35,7 @@ namespace Avalonia.FreeDesktop.AtSpi.Handlers
 
             var selectedPeer = selection[selectedChildIndex];
             var childNode = server.TryGetAttachedNode(selectedPeer);
-            if (childNode is null || !ReferenceEquals(childNode.Parent, node))
+            if (childNode is null)
                 return ValueTask.FromResult(server.GetNullReference());
 
             return ValueTask.FromResult(server.GetReference(childNode));
@@ -46,15 +43,11 @@ namespace Avalonia.FreeDesktop.AtSpi.Handlers
 
         public ValueTask<bool> SelectChildAsync(int childIndex)
         {
-            var children = node.Peer.GetChildren();
-            if (childIndex < 0 || childIndex >= children.Count)
+            var items = CollectSelectableItems(node.Peer);
+            if (childIndex < 0 || childIndex >= items.Count)
                 return ValueTask.FromResult(false);
 
-            var childPeer = children[childIndex];
-            if (childPeer.GetProvider<ISelectionItemProvider>() is not { } selectionItem)
-                return ValueTask.FromResult(false);
-
-            selectionItem.AddToSelection();
+            items[childIndex].AddToSelection();
             return ValueTask.FromResult(true);
         }
 
@@ -78,15 +71,11 @@ namespace Avalonia.FreeDesktop.AtSpi.Handlers
 
         public ValueTask<bool> IsChildSelectedAsync(int childIndex)
         {
-            var children = node.Peer.GetChildren();
-            if (childIndex < 0 || childIndex >= children.Count)
+            var items = CollectSelectableItems(node.Peer);
+            if (childIndex < 0 || childIndex >= items.Count)
                 return ValueTask.FromResult(false);
 
-            var childPeer = children[childIndex];
-            if (childPeer.GetProvider<ISelectionItemProvider>() is not { } selectionItem)
-                return ValueTask.FromResult(false);
-
-            return ValueTask.FromResult(selectionItem.IsSelected);
+            return ValueTask.FromResult(items[childIndex].IsSelected);
         }
 
         public ValueTask<bool> SelectAllAsync()
@@ -95,12 +84,8 @@ namespace Avalonia.FreeDesktop.AtSpi.Handlers
             if (provider is null || !provider.CanSelectMultiple)
                 return ValueTask.FromResult(false);
 
-            var children = node.Peer.GetChildren();
-            foreach (var child in children)
-            {
-                if (child.GetProvider<ISelectionItemProvider>() is { } selectionItem)
-                    selectionItem.AddToSelection();
-            }
+            foreach (var item in CollectSelectableItems(node.Peer))
+                item.AddToSelection();
 
             return ValueTask.FromResult(true);
         }
@@ -123,16 +108,32 @@ namespace Avalonia.FreeDesktop.AtSpi.Handlers
 
         public ValueTask<bool> DeselectChildAsync(int childIndex)
         {
-            var children = node.Peer.GetChildren();
-            if (childIndex < 0 || childIndex >= children.Count)
+            var items = CollectSelectableItems(node.Peer);
+            if (childIndex < 0 || childIndex >= items.Count)
                 return ValueTask.FromResult(false);
 
-            var childPeer = children[childIndex];
-            if (childPeer.GetProvider<ISelectionItemProvider>() is not { } selectionItem)
-                return ValueTask.FromResult(false);
-
-            selectionItem.RemoveFromSelection();
+            items[childIndex].RemoveFromSelection();
             return ValueTask.FromResult(true);
         }
+
+        private static List<ISelectionItemProvider> CollectSelectableItems(AutomationPeer peer)
+        {
+            var result = new List<ISelectionItemProvider>();
+            CollectSelectableItemsCore(peer.GetChildren(), result);
+            return result;
+        }
+
+        private static void CollectSelectableItemsCore(
+            IReadOnlyList<AutomationPeer> children,
+            List<ISelectionItemProvider> result)
+        {
+            foreach (var child in children)
+            {
+                if (child.GetProvider<ISelectionItemProvider>() is { } item)
+                    result.Add(item);
+                else
+                    CollectSelectableItemsCore(child.GetChildren(), result);
+            }
+        }
     }
 }

From 7467c0cf0f0121a2987ef74566495b26e3b7ebb2 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Mon, 22 Jun 2026 21:19:11 +0200
Subject: [PATCH 041/196] Remove useless Android external permission check
 (#21628)

---
 .../Platform/Storage/AndroidStorageItem.cs    |  3 +-
 .../Storage/AndroidStorageProvider.cs         | 43 +++++--------------
 2 files changed, 12 insertions(+), 34 deletions(-)

diff --git a/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageItem.cs b/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageItem.cs
index a5ceb02312..fa26e0cac7 100644
--- a/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageItem.cs
+++ b/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageItem.cs
@@ -118,7 +118,8 @@ internal abstract class AndroidStorageItem : IStorageBookmarkItem
 
     protected async Task<bool> EnsureExternalFilesPermission(bool write)
     {
-        if (!_needsExternalFilesPermission)
+        // Starting in API level 33, this permission has no effect.
+        if (!_needsExternalFilesPermission || OperatingSystem.IsAndroidVersionAtLeast(33))
         {
             return true;
         }
diff --git a/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs b/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
index b42d0f7aaa..b1fc61684f 100644
--- a/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
+++ b/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
@@ -55,15 +55,20 @@ internal class AndroidStorageProvider : IStorageProvider
             return null;
         }
 
-        await EnsureUriReadPermission(androidUri);
+        // About the READ_EXTERNAL_STORAGE permission:
+        // https://developer.android.com/reference/android/Manifest.permission#READ_EXTERNAL_STORAGE
+        //  - "Starting in API level 33, this permission has no effect."
+        //  - "Also starting in API level 19, this permission is not required
+        //     to read or write files in your application-specific directories [...]"
+        // Consequently, we don't try to check for that permission here anymore.
 
         var javaFile = new JavaFile(androidUriPath);
         if (javaFile.Exists() && javaFile.IsFile)
         {
-            return null;
+            return new AndroidStorageFile(_activity, androidUri);
         }
 
-        return new AndroidStorageFile(_activity, androidUri);
+        return null;
     }
 
     public async Task<IStorageFolder?> TryGetFolderFromPathAsync(Uri folderPath)
@@ -84,15 +89,13 @@ internal class AndroidStorageProvider : IStorageProvider
             return null;
         }
 
-        await EnsureUriReadPermission(androidUri);
-
         var javaFile = new JavaFile(androidUriPath);
         if (javaFile.Exists() && javaFile.IsDirectory)
         {
-            return null;
+            return new AndroidStorageFolder(_activity, androidUri, false);
         }
 
-        return new AndroidStorageFolder(_activity, androidUri, false);
+        return null;
     }
 
     public Task<IStorageFolder?> TryGetWellKnownFolderAsync(WellKnownFolder wellKnownFolder)
@@ -284,30 +287,4 @@ internal class AndroidStorageProvider : IStorageProvider
 
         return intent;
     }
-
-    private async Task EnsureUriReadPermission(AndroidUri androidUri)
-    {
-        bool hasPerms = false;
-        Exception? innerEx = null;
-        try
-        {
-            hasPerms = _activity.CheckUriPermission(androidUri,
-                global::Android.OS.Process.MyPid(),
-                global::Android.OS.Process.MyUid(),
-                ActivityFlags.GrantReadUriPermission)
-                == global::Android.Content.PM.Permission.Granted;
-
-            // TODO: call RequestPermission or add proper permissions API, something like in Browser File API.
-            hasPerms = hasPerms || await _activity.CheckPermission(Manifest.Permission.ReadExternalStorage);
-        }
-        catch (Exception ex)
-        {
-            innerEx = ex;
-        }
-
-        if (!hasPerms)
-        {
-            throw new InvalidOperationException("Application doesn't have READ_EXTERNAL_STORAGE permission. Make sure android manifest has this permission defined and user allowed it.", innerEx);
-        }
-    }
 }

From 893bce4e027a5d47798fb464bfa43527a1d056a6 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Tue, 23 Jun 2026 12:57:51 +0400
Subject: [PATCH 042/196] Suppress culture flowing with ExecutionContext
 captured by DispatcherOperation (#21627)

* Fix for #21451

* Move another test to cross tests
---
 nukebuild/Build.cs                            |   7 +
 .../CulturePreservingExecutionContext.cs      | 133 ++++++++++++
 .../Threading/DispatcherOperation.cs          |  10 +-
 .../DispatcherExecutionContextTests.cs        | 193 ++++++++++++++++++
 .../DispatcherTests.cs                        | 164 ---------------
 .../WpfCompare.Support.cs                     |  36 ++++
 .../Avalonia.UnitTests.WpfCompare.csproj      |  19 ++
 .../WpfCompare.Support.cs                     |  38 ++++
 8 files changed, 430 insertions(+), 170 deletions(-)
 create mode 100644 src/Avalonia.Base/Threading/CulturePreservingExecutionContext.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/DispatcherExecutionContextTests.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/WpfCompare.Support.cs
 create mode 100644 tests/Avalonia.UnitTests.WpfCompare/Avalonia.UnitTests.WpfCompare.csproj
 create mode 100644 tests/Avalonia.UnitTests.WpfCompare/WpfCompare.Support.cs

diff --git a/nukebuild/Build.cs b/nukebuild/Build.cs
index ad9917f84c..7f479a883a 100644
--- a/nukebuild/Build.cs
+++ b/nukebuild/Build.cs
@@ -227,6 +227,10 @@ partial class Build : NukeBuild
             {
                 tfm = "net8.0";
             }
+            if (tfm == "$(AvsCurrentWindowsTargetFramework)")
+            {
+                tfm = "net10.0-windows";
+            }
             
             if (tfm.StartsWith("net4")
                 && (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
@@ -279,6 +283,9 @@ partial class Build : NukeBuild
             RunCoreTest("Avalonia.Headless.NUnit.PerTest.UnitTests");
             RunCoreTest("Avalonia.Headless.XUnit.PerAssembly.UnitTests");
             RunCoreTest("Avalonia.Headless.XUnit.PerTest.UnitTests");
+
+            if (Parameters.IsRunningOnWindows)
+                RunCoreTest("Avalonia.UnitTests.WpfCompare");
         });
 
     Target RunRenderTests => _ => _
diff --git a/src/Avalonia.Base/Threading/CulturePreservingExecutionContext.cs b/src/Avalonia.Base/Threading/CulturePreservingExecutionContext.cs
new file mode 100644
index 0000000000..d25855679d
--- /dev/null
+++ b/src/Avalonia.Base/Threading/CulturePreservingExecutionContext.cs
@@ -0,0 +1,133 @@
+using System;
+using System.Globalization;
+using System.Threading;
+
+namespace Avalonia.Threading;
+
+/// <summary>
+/// A wrapper around <see cref="ExecutionContext"/> for running dispatcher operations that deliberately
+/// opts OUT of the runtime flowing <see cref="CultureInfo.CurrentCulture"/> /
+/// <see cref="CultureInfo.CurrentUICulture"/> through the execution context.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Since .NET Framework 4.6 the current culture and UI culture flow with the <see cref="ExecutionContext"/>,
+/// like any <see cref="AsyncLocal{T}"/>. For a UI toolkit this is the wrong model, and we explicitly do NOT
+/// want it. The culture is a property of the UI thread: the application sets it once (e.g. for localization)
+/// and every dispatcher operation - layout, rendering, input, user callbacks - must observe that single,
+/// live thread culture. With the built-in flow an operation instead runs under whatever culture happened to
+/// be current when it was <em>queued</em> (captured into its execution context), and any culture change the
+/// operation makes is silently discarded when the context is restored afterwards. The net effect is that a
+/// culture the user sets on the UI thread gets reverted by the next queued operation - see
+/// https://github.com/AvaloniaUI/Avalonia/issues/21451.
+/// </para>
+/// <para>
+/// This type restores the pre-4.6 semantics, which are the only ones that make sense for a UI application:
+/// culture is plain ambient state on the UI thread. It still runs the callback under the captured execution
+/// context, so impersonation and every other <see cref="AsyncLocal{T}"/> continue to flow normally; only the
+/// culture is special-cased. It:
+/// </para>
+/// <list type="number">
+///   <item>snapshots the executing (UI) thread's live culture immediately before running;</item>
+///   <item>re-applies that live culture <em>inside</em> the context, overriding whatever culture the captured
+///   context flows in, so the callback always runs under the current UI-thread culture; and</item>
+///   <item>reads the culture back after the callback and writes it onto the thread once the context has been
+///   restored, so any culture change the callback made persists instead of being thrown away.</item>
+/// </list>
+/// <para>
+/// This is a port of WPF's <c>CulturePreservingExecutionContext</c>, which exists for exactly the same reason.
+/// </para>
+/// </remarks>
+internal sealed class CulturePreservingExecutionContext
+{
+    private readonly ExecutionContext _context;
+    private CultureAndContext? _cultureAndContext;
+
+    private static readonly ContextCallback s_callbackWrapperDelegate = CallbackWrapper;
+
+    private CulturePreservingExecutionContext(ExecutionContext context)
+    {
+        _context = context;
+    }
+
+    public static CulturePreservingExecutionContext? Capture()
+    {
+        // Match ExecutionContext.Capture(): when the flow is suppressed it returns null and there is
+        // nothing to restore later, so we behave the same way.
+        if (ExecutionContext.IsFlowSuppressed())
+            return null;
+
+        var context = ExecutionContext.Capture();
+        if (context is null)
+            return null;
+
+        return new CulturePreservingExecutionContext(context);
+    }
+
+    public static void Run(CulturePreservingExecutionContext executionContext, ContextCallback callback, object? state)
+    {
+        if (executionContext is null)
+            throw new InvalidOperationException("Cannot run on a null CulturePreservingExecutionContext.");
+
+        // Snapshot the live culture of the thread that is about to run the callback (the dispatcher thread).
+        // We need it to override the culture that ExecutionContext.Run flows in from the captured context.
+        executionContext._cultureAndContext = CultureAndContext.Initialize(callback, state);
+
+        try
+        {
+            ExecutionContext.Run(
+                executionContext._context,
+                s_callbackWrapperDelegate,
+                executionContext._cultureAndContext);
+        }
+        finally
+        {
+            // ExecutionContext.Run has reverted the context, discarding any culture change made inside it.
+            // Re-apply the culture we read back after the callback so the change persists on the thread.
+            executionContext._cultureAndContext.WriteCultureInfosToCurrentThread();
+        }
+    }
+
+    private static void CallbackWrapper(object? obj)
+    {
+        var cultureAndContext = (CultureAndContext)obj!;
+
+        // Override the culture flowed in by the captured context with the live UI-thread culture, run the
+        // callback, then capture whatever culture the callback leaves behind.
+        cultureAndContext.WriteCultureInfosToCurrentThread();
+        cultureAndContext.Callback(cultureAndContext.State);
+        cultureAndContext.ReadCultureInfosFromCurrentThread();
+    }
+
+    private sealed class CultureAndContext
+    {
+        private CultureInfo _culture;
+        private CultureInfo _uiCulture;
+
+        public ContextCallback Callback { get; }
+        public object? State { get; }
+
+        private CultureAndContext(ContextCallback callback, object? state)
+        {
+            Callback = callback;
+            State = state;
+            _culture = Thread.CurrentThread.CurrentCulture;
+            _uiCulture = Thread.CurrentThread.CurrentUICulture;
+        }
+
+        public static CultureAndContext Initialize(ContextCallback callback, object? state)
+            => new(callback, state);
+
+        public void ReadCultureInfosFromCurrentThread()
+        {
+            _culture = Thread.CurrentThread.CurrentCulture;
+            _uiCulture = Thread.CurrentThread.CurrentUICulture;
+        }
+
+        public void WriteCultureInfosToCurrentThread()
+        {
+            Thread.CurrentThread.CurrentCulture = _culture;
+            Thread.CurrentThread.CurrentUICulture = _uiCulture;
+        }
+    }
+}
diff --git a/src/Avalonia.Base/Threading/DispatcherOperation.cs b/src/Avalonia.Base/Threading/DispatcherOperation.cs
index 1e19ccd196..0cf891cc85 100644
--- a/src/Avalonia.Base/Threading/DispatcherOperation.cs
+++ b/src/Avalonia.Base/Threading/DispatcherOperation.cs
@@ -5,8 +5,6 @@ using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 
-using ExecutionContext = System.Threading.ExecutionContext;
-
 namespace Avalonia.Threading;
 
 [DebuggerDisplay("{DebugDisplay}")]
@@ -42,7 +40,7 @@ public class DispatcherOperation
     private EventHandler? _aborted;
     private EventHandler? _completed;
     private DispatcherPriority _priority;
-    private readonly ExecutionContext? _executionContext;
+    private readonly CulturePreservingExecutionContext? _executionContext;
 
     internal DispatcherOperation(Dispatcher dispatcher, DispatcherPriority priority, Action callback, bool throwOnUiThread,
         bool captureExecutionContext = true) :
@@ -57,7 +55,7 @@ public class DispatcherOperation
         ThrowOnUiThread = throwOnUiThread;
         Priority = priority;
         Dispatcher = dispatcher;
-        _executionContext = captureExecutionContext ? ExecutionContext.Capture() : null;
+        _executionContext = captureExecutionContext ? CulturePreservingExecutionContext.Capture() : null;
     }
 
     internal string DebugDisplay
@@ -275,8 +273,8 @@ public class DispatcherOperation
             {
                 if (_executionContext is { } executionContext)
                 {
-                    ExecutionContext.Restore(executionContext);
-                    InvokeCore();
+                    CulturePreservingExecutionContext.Run(
+                        executionContext, static s => ((DispatcherOperation)s!).InvokeCore(), this);
                 }
                 else
                 {
diff --git a/tests/Avalonia.Base.UnitTests/DispatcherExecutionContextTests.cs b/tests/Avalonia.Base.UnitTests/DispatcherExecutionContextTests.cs
new file mode 100644
index 0000000000..dcbefab4d3
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/DispatcherExecutionContextTests.cs
@@ -0,0 +1,193 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+// This file is compiled into BOTH:
+//   * Avalonia.Base.UnitTests        - against Avalonia.Threading
+//   * Avalonia.UnitTests.WpfCompare  - against System.Windows.Threading (no Avalonia reference)
+// so that the exact same test bodies run against Avalonia's dispatcher and WPF's dispatcher,
+// proving that Avalonia's culture / ExecutionContext behaviour matches WPF. See issue #21451.
+//
+// The only per-framework differences are hidden behind two small helpers that each project
+// provides in its own namespace:
+//   * CrossFactAttribute     - [Fact] on Avalonia, [StaFact] on WPF (WPF dispatcher needs STA).
+//   * DispatcherTestServices - DrainQueue(), which differs only in static vs instance PushFrame.
+// Everything else (Dispatcher.CurrentDispatcher, InvokeAsync, DispatcherPriority, DispatcherFrame,
+// CultureInfo, Thread, AsyncLocal) is API-identical between the two frameworks.
+
+#if WPFCOMPARE
+using System.Windows.Threading;
+
+namespace Avalonia.UnitTests.WpfCompare;
+
+public class DispatcherExecutionContextTests
+#else
+using Avalonia.Threading;
+
+namespace Avalonia.Base.UnitTests;
+
+public class DispatcherExecutionContextTests : global::Avalonia.UnitTests.ScopedTestBase
+#endif
+{
+    // Sumerian: extremely unlikely to be the machine default, so these tests don't depend on the environment.
+    private const string CustomCultureName = "sux-Shaw-UM";
+
+    // A second, distinct culture used as the "calling thread" culture in the cross-thread test.
+    private const string CallSiteCultureName = "kk-KZ";
+
+    // Regression test for https://github.com/AvaloniaUI/Avalonia/issues/21451. A dispatcher operation must
+    // run under the UI thread's live culture - even one queued *before* the culture was set, whose execution
+    // context captured the old culture - and running operations must not reset the UI-thread culture.
+    [CrossFact]
+    public void Dispatcher_Operation_Runs_Under_Live_UI_Thread_Culture_And_Does_Not_Reset_It()
+    {
+        var dispatcher = Dispatcher.CurrentDispatcher;
+        var custom = CultureInfo.GetCultureInfo(CustomCultureName);
+        var oldCulture = Thread.CurrentThread.CurrentUICulture;
+        try
+        {
+            string? earlyOpSaw = null;
+            string? lateOpSaw = null;
+
+            // Queued BEFORE the culture is set: its execution context captures the current (default) culture.
+            dispatcher.InvokeAsync(() => earlyOpSaw = Thread.CurrentThread.CurrentUICulture.Name, DispatcherPriority.Normal);
+
+            // The application sets a custom UI culture on the UI thread.
+            Thread.CurrentThread.CurrentUICulture = custom;
+
+            dispatcher.InvokeAsync(() => lateOpSaw = Thread.CurrentThread.CurrentUICulture.Name, DispatcherPriority.Normal);
+
+            DispatcherTestServices.DrainQueue(dispatcher, DispatcherPriority.Background);
+
+            // The early operation runs under the LIVE UI-thread culture, not the default it captured...
+            Assert.Equal(CustomCultureName, earlyOpSaw);
+            Assert.Equal(CustomCultureName, lateOpSaw);
+            // ...and running operations must not have reset the UI-thread culture.
+            Assert.Equal(CustomCultureName, Thread.CurrentThread.CurrentUICulture.Name);
+        }
+        finally
+        {
+            Thread.CurrentThread.CurrentUICulture = oldCulture;
+            Assert.NotEqual(CustomCultureName, oldCulture.Name);
+        }
+    }
+
+    // A culture change made *inside* an operation persists on the UI thread (the outbound half of the
+    // pre-4.6 semantics). With the runtime's default ExecutionContext flow the change would be discarded.
+    [CrossFact]
+    public void Culture_Set_Inside_Dispatcher_Operation_Persists_To_UI_Thread()
+    {
+        var dispatcher = Dispatcher.CurrentDispatcher;
+        var custom = CultureInfo.GetCultureInfo(CustomCultureName);
+        var oldCulture = Thread.CurrentThread.CurrentUICulture;
+        try
+        {
+            string? nextOpSaw = null;
+
+            dispatcher.InvokeAsync(() => Thread.CurrentThread.CurrentUICulture = custom, DispatcherPriority.Normal);
+            dispatcher.InvokeAsync(() => nextOpSaw = Thread.CurrentThread.CurrentUICulture.Name, DispatcherPriority.Normal);
+
+            DispatcherTestServices.DrainQueue(dispatcher, DispatcherPriority.Background);
+
+            // The change made by the first operation is visible to the next one and stays on the thread.
+            Assert.Equal(CustomCultureName, nextOpSaw);
+            Assert.Equal(CustomCultureName, Thread.CurrentThread.CurrentUICulture.Name);
+        }
+        finally
+        {
+            Thread.CurrentThread.CurrentUICulture = oldCulture;
+            Assert.NotEqual(CustomCultureName, oldCulture.Name);
+        }
+    }
+
+    // Non-culture ExecutionContext state (an AsyncLocal) DOES flow into an operation from the context that
+    // was captured when it was queued - this is preserved, unlike culture which is special-cased.
+    [CrossFact]
+    public void ExecutionContext_Flows_Into_Dispatcher_Operation()
+    {
+        var dispatcher = Dispatcher.CurrentDispatcher;
+        var asyncLocal = new AsyncLocal<string?>();
+        string? seen = null;
+
+        asyncLocal.Value = "captured";
+        dispatcher.InvokeAsync(() => seen = asyncLocal.Value, DispatcherPriority.Normal);
+        // Change the ambient value AFTER the operation captured its context.
+        asyncLocal.Value = "ambient";
+
+        DispatcherTestServices.DrainQueue(dispatcher, DispatcherPriority.Background);
+
+        // The operation observes the value captured at post time, not the later ambient value.
+        Assert.Equal("captured", seen);
+    }
+
+    // An AsyncLocal set inside one operation must not leak into the next one (each operation restores its
+    // own captured context).
+    [CrossFact]
+    public void ExecutionContext_Does_Not_Flow_Between_Dispatcher_Operations()
+    {
+        var dispatcher = Dispatcher.CurrentDispatcher;
+        var asyncLocal = new AsyncLocal<string?>();
+        string? seen = "unset";
+
+        dispatcher.InvokeAsync(() => asyncLocal.Value = "set-by-first-op", DispatcherPriority.Normal);
+        dispatcher.InvokeAsync(() => seen = asyncLocal.Value, DispatcherPriority.Normal);
+
+        DispatcherTestServices.DrainQueue(dispatcher, DispatcherPriority.Background);
+
+        Assert.Null(seen);
+    }
+
+    // A dispatcher operation runs under the UI thread's live culture, NOT under the culture of the thread
+    // that happened to queue it - even though that other thread's culture would flow into a plain Task.Run
+    // continuation. This is the cross-thread counterpart of the same-thread test above.
+    [CrossFact]
+    [SuppressMessage("Usage", "xUnit1031:Do not use blocking task operations in test method", Justification = "Tests the dispatcher itself")]
+    public void Dispatcher_Operations_Use_Live_UI_Thread_Culture_Not_Calling_Thread_Culture()
+    {
+        var dispatcher = Dispatcher.CurrentDispatcher;
+        var uiThreadCulture = CultureInfo.GetCultureInfo(CustomCultureName);
+        var callSiteCulture = CultureInfo.GetCultureInfo(CallSiteCultureName);
+        var oldCulture = Thread.CurrentThread.CurrentCulture;
+
+        // This (test) thread pumps the frame below, i.e. it is the UI thread. Give it a known culture.
+        Thread.CurrentThread.CurrentCulture = uiThreadCulture;
+        try
+        {
+            var frame = new DispatcherFrame();
+            string? taskRunSaw = null;
+            string? invokeSaw = null;
+            string? invokeAsyncSaw = null;
+
+            var callingThread = new Thread(() =>
+            {
+                // A DIFFERENT culture on this non-UI (calling) thread.
+                Thread.CurrentThread.CurrentCulture = callSiteCulture;
+
+                // Baseline: a plain Task.Run continuation DOES flow the calling-thread culture through the EC.
+                taskRunSaw = Task.Run(() => Thread.CurrentThread.CurrentCulture.Name).GetAwaiter().GetResult();
+
+                // Queue work onto the dispatcher from this non-UI thread, then stop the frame.
+                dispatcher.Invoke(() => invokeSaw = Thread.CurrentThread.CurrentCulture.Name);
+                dispatcher.InvokeAsync(() => invokeAsyncSaw = Thread.CurrentThread.CurrentCulture.Name, DispatcherPriority.Normal);
+                dispatcher.InvokeAsync(() => frame.Continue = false, DispatcherPriority.Normal);
+            });
+            callingThread.Start();
+
+            DispatcherTestServices.PushFrame(dispatcher, frame);
+            callingThread.Join();
+
+            // Baseline: Task.Run flows the calling-thread culture (guaranteed by the runtime).
+            Assert.Equal(CallSiteCultureName, taskRunSaw);
+            // Dispatcher operations run under the UI thread's live culture, not the calling thread's culture.
+            Assert.Equal(CustomCultureName, invokeSaw);
+            Assert.Equal(CustomCultureName, invokeAsyncSaw);
+        }
+        finally
+        {
+            Thread.CurrentThread.CurrentCulture = oldCulture;
+            Assert.NotEqual(CustomCultureName, oldCulture.Name);
+        }
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/DispatcherTests.cs b/tests/Avalonia.Base.UnitTests/DispatcherTests.cs
index f7e251eb50..03c8133b74 100644
--- a/tests/Avalonia.Base.UnitTests/DispatcherTests.cs
+++ b/tests/Avalonia.Base.UnitTests/DispatcherTests.cs
@@ -615,103 +615,6 @@ public partial class DispatcherTests
         }
     }
 
-    [Fact]
-    public async Task ExecutionContextIsPreservedInDispatcherInvokeAsync()
-    {
-        using var services = new DispatcherServices(new SimpleControlledDispatcherImpl());
-        var tokenSource = new CancellationTokenSource();
-        string? test1 = null;
-        string? test2 = null;
-        string? test3 = null;
-
-        // All test code must run inside Task.Run to avoid interfering with the test:
-        //  1. Prevent the execution context from being captured by MainLoop.
-        //  2. Prevent the execution context from remaining effective when set on the same thread.
-        var task = Task.Run(() =>
-        {
-            var testObject = new AsyncLocalTestClass();
-
-            // Test 1: Verify Task.Run preserves the execution context.
-            // First, test Task.Run to ensure that the preceding validation always passes, serving as a baseline for the subsequent Invoke/InvokeAsync tests.
-            // This way, if a later test fails, we have the .NET framework's baseline behavior for reference.
-            testObject.AsyncLocalField.Value = "Initial Value";
-            var task1 = Task.Run(() =>
-            {
-                test1 = testObject.AsyncLocalField.Value;
-            });
-
-            // Test 2: Verify Invoke preserves the execution context.
-            testObject.AsyncLocalField.Value = "Initial Value";
-            Dispatcher.UIThread.Invoke(() =>
-            {
-                test2 = testObject.AsyncLocalField.Value;
-            });
-
-            // Test 3: Verify InvokeAsync preserves the execution context.
-            testObject.AsyncLocalField.Value = "Initial Value";
-            _ = Dispatcher.UIThread.InvokeAsync(() =>
-            {
-                test3 = testObject.AsyncLocalField.Value;
-            });
-
-            _ = Dispatcher.UIThread.InvokeAsync(async () =>
-            {
-                await Task.WhenAll(task1);
-                tokenSource.Cancel();
-            });
-
-        }, TestContext.Current.CancellationToken);
-
-        Dispatcher.UIThread.MainLoop(tokenSource.Token);
-        await Task.WhenAll(task);
-
-        // Assertions
-        // Task.Run: Always passes (guaranteed by the .NET runtime).
-        Assert.Equal("Initial Value", test1);
-        // Invoke: Always passes because the context is not changed.
-        Assert.Equal("Initial Value", test2);
-        // InvokeAsync: See https://github.com/AvaloniaUI/Avalonia/pull/19163
-        Assert.Equal("Initial Value", test3);
-    }
-
-    [Fact]
-    public async Task ExecutionContextIsNotPreservedAmongDispatcherInvokeAsync()
-    {
-        using var services = new DispatcherServices(new SimpleControlledDispatcherImpl());
-        var tokenSource = new CancellationTokenSource();
-        string? test = null;
-
-        // All test code must run inside Task.Run to avoid interfering with the test:
-        //  1. Prevent the execution context from being captured by MainLoop.
-        //  2. Prevent the execution context from remaining effective when set on the same thread.
-        var task = Task.Run(() =>
-        {
-            var testObject = new AsyncLocalTestClass();
-
-            // Test: Verify that InvokeAsync calls do not share execution context between each other.
-            _ = Dispatcher.UIThread.InvokeAsync(() =>
-            {
-                testObject.AsyncLocalField.Value = "Initial Value";
-            });
-            _ = Dispatcher.UIThread.InvokeAsync(() =>
-            {
-                test = testObject.AsyncLocalField.Value;
-            });
-
-            _ = Dispatcher.UIThread.InvokeAsync(() =>
-            {
-                tokenSource.Cancel();
-            });
-        }, TestContext.Current.CancellationToken);
-
-        Dispatcher.UIThread.MainLoop(tokenSource.Token);
-        await Task.WhenAll(task);
-
-        // Assertions
-        // The value should NOT flow between different InvokeAsync execution contexts.
-        Assert.Null(test);
-    }
-
     [Fact]
     public void MediaContextRenderSchedulingDoesNotCaptureAmbientExecutionContext()
     {
@@ -782,73 +685,6 @@ public partial class DispatcherTests
         Assert.Null(test);
     }
 
-    [Fact]
-    public async Task ExecutionContextCultureInfoIsPreservedInDispatcherInvokeAsync()
-    {
-        using var services = new DispatcherServices(new SimpleControlledDispatcherImpl());
-        var tokenSource = new CancellationTokenSource();
-        string? test1 = null;
-        string? test2 = null;
-        string? test3 = null;
-        var oldCulture = Thread.CurrentThread.CurrentCulture;
-
-        // All test code must run inside Task.Run to avoid interfering with the test:
-        //  1. Prevent the execution context from being captured by MainLoop.
-        //  2. Prevent the execution context from remaining effective when set on the same thread.
-        var task = Task.Run(() =>
-        {
-            // This culture tag is Sumerian and is extremely unlikely to be set as the default on any device,
-            // ensuring that this test will not be affected by the user's environment.
-            Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("sux-Shaw-UM");
-
-            // Test 1: Verify Task.Run preserves the culture in the execution context.
-            // First, test Task.Run to ensure that the preceding validation always passes, serving as a baseline for the subsequent Invoke/InvokeAsync tests.
-            // This way, if a later test fails, we have the .NET framework's baseline behavior for reference.
-            var task1 = Task.Run(() =>
-            {
-                test1 = Thread.CurrentThread.CurrentCulture.Name;
-            });
-
-            // Test 2: Verify Invoke preserves the execution context.
-            Dispatcher.UIThread.Invoke(() =>
-            {
-                test2 = Thread.CurrentThread.CurrentCulture.Name;
-            });
-
-            // Test 3: Verify InvokeAsync preserves the culture in the execution context.
-            _ = Dispatcher.UIThread.InvokeAsync(() =>
-            {
-                test3 = Thread.CurrentThread.CurrentCulture.Name;
-            });
-
-            _ = Dispatcher.UIThread.InvokeAsync(async () =>
-            {
-                await Task.WhenAll(task1);
-                tokenSource.Cancel();
-            });
-        }, TestContext.Current.CancellationToken);
-
-        try
-        {
-            Dispatcher.UIThread.MainLoop(tokenSource.Token);
-            await Task.WhenAll(task);
-
-            // Assertions
-            // Task.Run: Always passes (guaranteed by the .NET runtime).
-            Assert.Equal("sux-Shaw-UM", test1);
-            // Invoke: Always passes because the context is not changed.
-            Assert.Equal("sux-Shaw-UM", test2);
-            // InvokeAsync: See https://github.com/AvaloniaUI/Avalonia/pull/19163
-            Assert.Equal("sux-Shaw-UM", test3);
-        }
-        finally
-        {
-            Thread.CurrentThread.CurrentCulture = oldCulture;
-            // Ensure that this test does not have a negative impact on other tests.
-            Assert.NotEqual("sux-Shaw-UM", oldCulture.Name);
-        }
-    }
-
     [Fact]
     public async Task Dispatcher_Can_Act_As_TaskScheduler()
     {
diff --git a/tests/Avalonia.Base.UnitTests/WpfCompare.Support.cs b/tests/Avalonia.Base.UnitTests/WpfCompare.Support.cs
new file mode 100644
index 0000000000..f3bb9aa4a9
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/WpfCompare.Support.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Runtime.CompilerServices;
+using Avalonia.Threading;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests;
+
+// Avalonia backend for the shared DispatcherExecutionContextTests. The WPF project
+// (Avalonia.UnitTests.WpfCompare) provides its own version of these two types in its own namespace.
+
+public sealed class CrossFactAttribute : FactAttribute
+{
+    public CrossFactAttribute(
+        [CallerFilePath] string? sourceFilePath = null,
+        [CallerLineNumber] int sourceLineNumber = -1)
+        : base(sourceFilePath, sourceLineNumber)
+    {
+    }
+}
+
+internal static class DispatcherTestServices
+{
+    // Drains every dispatcher operation queued at or above <paramref name="priority"/> by pumping a frame
+    // until a sentinel posted at that priority runs. Replaces the Avalonia-only impl.ExecuteSignal() so the
+    // same body works against WPF too.
+    public static void DrainQueue(Dispatcher dispatcher, DispatcherPriority priority)
+    {
+        var frame = new DispatcherFrame();
+        dispatcher.InvokeAsync(() => frame.Continue = false, priority);
+        PushFrame(dispatcher, frame);
+    }
+
+    // Pumps the dispatcher until the frame is stopped. Avalonia's PushFrame is an instance method
+    // (WPF's is static) - that is the only difference from the WPF backend.
+    public static void PushFrame(Dispatcher dispatcher, DispatcherFrame frame) => dispatcher.PushFrame(frame);
+}
diff --git a/tests/Avalonia.UnitTests.WpfCompare/Avalonia.UnitTests.WpfCompare.csproj b/tests/Avalonia.UnitTests.WpfCompare/Avalonia.UnitTests.WpfCompare.csproj
new file mode 100644
index 0000000000..848bffc9bc
--- /dev/null
+++ b/tests/Avalonia.UnitTests.WpfCompare/Avalonia.UnitTests.WpfCompare.csproj
@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>$(AvsCurrentWindowsTargetFramework)</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <EnableWindowsTargeting>true</EnableWindowsTargeting>
+    <Nullable>enable</Nullable>
+    <UseWpf>true</UseWpf>
+    <!-- WPFCOMPARE switches the shared test file to compile against System.Windows.Threading. -->
+    <DefineConstants>$(DefineConstants);WPFCOMPARE</DefineConstants>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="..\Avalonia.Base.UnitTests\DispatcherExecutionContextTests.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Xunit.StaFact" />
+  </ItemGroup>
+  <Import Project="..\..\build\XUnit.props" />
+  <Import Project="..\..\build\SharedVersion.props" />
+</Project>
diff --git a/tests/Avalonia.UnitTests.WpfCompare/WpfCompare.Support.cs b/tests/Avalonia.UnitTests.WpfCompare/WpfCompare.Support.cs
new file mode 100644
index 0000000000..b6038a3ced
--- /dev/null
+++ b/tests/Avalonia.UnitTests.WpfCompare/WpfCompare.Support.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Windows.Threading;
+using Xunit;
+
+namespace Avalonia.UnitTests.WpfCompare;
+
+// WPF backend for the shared DispatcherExecutionContextTests (compiled from
+// ..\Avalonia.Base.UnitTests\DispatcherExecutionContextTests.cs with WPFCOMPARE defined).
+// The Avalonia project provides equivalent types in the Avalonia.Base.UnitTests namespace.
+
+// The WPF dispatcher requires an STA thread, so the cross-framework [CrossFact] maps to [StaFact] here.
+public sealed class CrossFactAttribute : StaFactAttribute
+{
+    public CrossFactAttribute(
+        [CallerFilePath] string? sourceFilePath = null,
+        [CallerLineNumber] int sourceLineNumber = -1)
+        : base(sourceFilePath, sourceLineNumber)
+    {
+    }
+}
+
+internal static class DispatcherTestServices
+{
+    // Drains every dispatcher operation queued at or above <paramref name="priority"/> by pumping a frame
+    // until a sentinel posted at that priority runs. WPF's PushFrame is static (Avalonia's is an instance
+    // method) - that is the only difference from the Avalonia backend.
+    public static void DrainQueue(Dispatcher dispatcher, DispatcherPriority priority)
+    {
+        var frame = new DispatcherFrame();
+        dispatcher.InvokeAsync(() => frame.Continue = false, priority);
+        PushFrame(dispatcher, frame);
+    }
+
+    // Pumps the dispatcher until the frame is stopped. WPF's PushFrame is static (Avalonia's is an
+    // instance method) - that is the only difference from the Avalonia backend.
+    public static void PushFrame(Dispatcher dispatcher, DispatcherFrame frame) => Dispatcher.PushFrame(frame);
+}

From 8d80010cb39bee4f6108d095ddf0ec2deee52880 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Tue, 23 Jun 2026 11:33:09 +0200
Subject: [PATCH 043/196] Fix WinUiCompositorConnection deadlock (#21591)

* Fix WinUiCompositorConnection deadlock

* Revert watchdog to 1s
---
 .../Composition/WinUiCompositorConnection.cs  | 106 ++++++++++++------
 1 file changed, 69 insertions(+), 37 deletions(-)

diff --git a/src/Windows/Avalonia.Win32/WinRT/Composition/WinUiCompositorConnection.cs b/src/Windows/Avalonia.Win32/WinRT/Composition/WinUiCompositorConnection.cs
index e98caae88c..2e5c0a7b14 100644
--- a/src/Windows/Avalonia.Win32/WinRT/Composition/WinUiCompositorConnection.cs
+++ b/src/Windows/Avalonia.Win32/WinRT/Composition/WinUiCompositorConnection.cs
@@ -3,7 +3,6 @@ using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
-using Avalonia.Platform;
 using Avalonia.Platform.Surfaces;
 using Avalonia.Logging;
 using Avalonia.MicroCom;
@@ -20,6 +19,7 @@ internal class WinUiCompositorConnection : IRenderTimer, Win32.IWindowsSurfaceFa
     private readonly AutoResetEvent _wakeEvent = new(false);
     private volatile bool _stopped = true;
     private volatile Action<TimeSpan>? _tick;
+
     public bool RunsInBackground => true;
 
     public Action<TimeSpan>? Tick
@@ -40,7 +40,7 @@ internal class WinUiCompositorConnection : IRenderTimer, Win32.IWindowsSurfaceFa
             }
         }
     }
-    
+
     public WinUiCompositorConnection()
     {
         using var compositor = NativeWinRTMethods.CreateInstance<ICompositor>("Windows.UI.Composition.Compositor");
@@ -59,7 +59,7 @@ internal class WinUiCompositorConnection : IRenderTimer, Win32.IWindowsSurfaceFa
         void* texture = null;
         surfInterop.BeginDraw(null, &IID_ID3D11Texture2D, &texture);
         */
-        
+
         _shared = new WinUiCompositionShared(compositor);
     }
 
@@ -106,26 +106,45 @@ internal class WinUiCompositorConnection : IRenderTimer, Win32.IWindowsSurfaceFa
         private readonly Stopwatch _st = Stopwatch.StartNew();
         private TimeSpan? _commitDueAt;
         private IAsyncAction? _currentCommit;
+        private bool _commitCompleted;
+
         public RunLoopHandler(WinUiCompositorConnection parent)
         {
             _parent = parent;
         }
 
         public void Invoke(IAsyncAction? asyncInfo, AsyncStatus asyncStatus)
-        { 
-            if (_currentCommit == null ||
-              _currentCommit.GetNativeIntPtr() != asyncInfo.GetNativeIntPtr())
-                return;
-            OnCommitCompleted();
+        {
+            lock (_parent._shared.SyncRoot)
+            {
+                if (_currentCommit == null || _currentCommit.GetNativeIntPtr() != asyncInfo.GetNativeIntPtr())
+                    return;
+                OnCommitCompleted();
+            }
         }
-        
+
         private void OnCommitCompleted()
         {
+            Debug.Assert(Monitor.IsEntered(_parent._shared.SyncRoot), "Lock should be held");
+
             _currentCommit?.Dispose();
             _currentCommit = null;
             _parent._tick?.Invoke(_st.Elapsed);
             // Always schedule a commit so the current frame's work reaches DWM.
             ScheduleNextCommit();
+            _commitCompleted = true;
+        }
+
+        // This method should be called outside the shared lock, as it might wait for a long time.
+        public void OnAfterMessageWithoutLock()
+        {
+            Debug.Assert(!Monitor.IsEntered(_parent._shared.SyncRoot), "Lock should NOT be held");
+
+            if (!_commitCompleted)
+                return;
+
+            _commitCompleted = false;
+
             if (_parent._stopped)
             {
                 _parent._wakeEvent.WaitOne();
@@ -137,40 +156,47 @@ internal class WinUiCompositorConnection : IRenderTimer, Win32.IWindowsSurfaceFa
 
         private void ScheduleNextCommit()
         {
-            lock (_parent._shared.SyncRoot)
-            {
-                _commitDueAt = _st.Elapsed + TimeSpan.FromSeconds(1);
-                _currentCommit = _parent._shared.Compositor5.RequestCommitAsync();
-                _currentCommit.SetCompleted(this);
-            }
+            Debug.Assert(Monitor.IsEntered(_parent._shared.SyncRoot), "Lock should be held");
+
+            _commitDueAt = _st.Elapsed + TimeSpan.FromSeconds(1);
+            _currentCommit = _parent._shared.Compositor5.RequestCommitAsync();
+            _currentCommit.SetCompleted(this);
         }
 
         public void WatchDog()
         {
-            // This is a workaround for a nasty WinUI composition API bug that prevents
-            // RequestCommitAsync to ever complete after D3D device loss event with some systems
-            // (A notable example is after pause/resume in Parallels Desktop)
-            // We check if we haven't got a commit completion callback for a second
-            // And forcefully trigger the next one, which makes the entire thing to unstuck
-            
-            if (_st.Elapsed > _commitDueAt && _currentCommit != null)
+            lock (_parent._shared.SyncRoot)
             {
-                Logger.TryGet(LogEventLevel.Error, LogArea.Visual)?.Log(this,
-                    "windows::UI::Composition::ICompositor5.RequestCommitAsync timed out, force-triggering next tick");
-                try
-                {
-                    _currentCommit?.GetResults();
-                }
-                catch (Exception e)
+                // This is a workaround for a nasty WinUI composition API bug that prevents
+                // RequestCommitAsync to ever complete after D3D device loss event with some systems
+                // (A notable example is after pause/resume in Parallels Desktop)
+                // We check if we haven't got a commit completion callback for a second
+                // And forcefully trigger the next one, which makes the entire thing to unstuck
+
+                if (_st.Elapsed > _commitDueAt && _currentCommit != null)
                 {
                     Logger.TryGet(LogEventLevel.Error, LogArea.Visual)?.Log(this,
-                        "ICompositor5::RequestCommitAsync failed: {HR}, {ERR}", e.HResult, e.ToString());
+                        "windows::UI::Composition::ICompositor5.RequestCommitAsync timed out, force-triggering next tick");
+                    try
+                    {
+                        _currentCommit?.GetResults();
+                    }
+                    catch (Exception e)
+                    {
+                        Logger.TryGet(LogEventLevel.Error, LogArea.Visual)?.Log(this,
+                            "ICompositor5::RequestCommitAsync failed: {HR}, {ERR}", e.HResult, e.ToString());
+                    }
+
+                    OnCommitCompleted();
                 }
-                OnCommitCompleted();
             }
         }
 
-        public void Start() => ScheduleNextCommit();
+        public void Start()
+        {
+            lock (_parent._shared.SyncRoot)
+                ScheduleNextCommit();
+        }
     }
 
     private void RunLoop()
@@ -182,23 +208,29 @@ internal class WinUiCompositorConnection : IRenderTimer, Win32.IWindowsSurfaceFa
         var handler = new RunLoopHandler(this);
         handler.Start();
 
+        const int watchDogIntervalInMs = 1000;
+
         using var dw = new SimpleWindow((hwnd, msg, w, l) =>
         {
             if (msg == (uint)UnmanagedMethods.WindowsMessage.WM_TIMER)
             {
                 handler.WatchDog();
-                UnmanagedMethods.SetTimer(hwnd, IntPtr.Zero, 1000, null);
+                UnmanagedMethods.SetTimer(hwnd, IntPtr.Zero, watchDogIntervalInMs, null);
             }
             return UnmanagedMethods.DefWindowProc(hwnd, msg, w, l);
         });
-        UnmanagedMethods.SetTimer(dw.Handle, IntPtr.Zero, 1000, null);
+        UnmanagedMethods.SetTimer(dw.Handle, IntPtr.Zero, watchDogIntervalInMs, null);
+
+        // Warning: the completion callback (RunLoopHandler.Invoke) from ICompositor5.RequestCommitAsync()
+        // is called in DispatchMessage() on Windows 10, but in GetMessage() on Windows 11!
+        // Be careful when changing the scope of the shared lock.
 
         var result = 0;
         while (!cts.IsCancellationRequested
                && (result = UnmanagedMethods.GetMessage(out var msg, IntPtr.Zero, 0, 0)) > 0)
         {
-            lock (_shared.SyncRoot)
-                UnmanagedMethods.DispatchMessage(ref msg);
+            UnmanagedMethods.DispatchMessage(ref msg);
+            handler.OnAfterMessageWithoutLock();
         }
 
         if (result < 0)
@@ -212,7 +244,7 @@ internal class WinUiCompositorConnection : IRenderTimer, Win32.IWindowsSurfaceFa
     {
         return Win32Platform.WindowsVersion >= WinUiCompositionShared.MinWinCompositionVersion;
     }
-    
+
     public static bool TryCreateAndRegister()
     {
         if (IsSupported())

From 41b8a8df1bac9c5db9f5ffab5a46ff72ceeb4e74 Mon Sep 17 00:00:00 2001
From: shine <106159554+shine1258@users.noreply.github.com>
Date: Tue, 23 Jun 2026 18:26:47 +0800
Subject: [PATCH 044/196] Fix TimePicker selection style (#21626)

---
 src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml | 5 +++++
 src/Avalonia.Themes.Simple/Controls/TimePicker.xaml | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml b/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
index 27e52fa152..28544638d1 100644
--- a/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
@@ -203,6 +203,11 @@
                 MaxHeight="398">
           <Grid Name="ContentPanel" RowDefinitions="*,Auto">
             <Grid Name="PART_PickerContainer">
+              <Grid.Styles>
+                <Style Selector="DateTimePickerPanel > ListBoxItem">
+                  <Setter Property="Theme" Value="{StaticResource FluentDateTimePickerItem}" />
+                </Style>
+              </Grid.Styles>
               <!--Ignore col defs here, set in code-->
               <Panel Name="PART_HourHost" Grid.Column="0">
                 <ScrollViewer HorizontalScrollBarVisibility="Disabled"
diff --git a/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml b/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml
index 3a5e9ec1b1..aed297fba2 100644
--- a/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml
@@ -219,6 +219,11 @@
           <Grid Name="ContentPanel"
                 RowDefinitions="*,Auto">
             <Grid Name="PART_PickerContainer">
+              <Grid.Styles>
+                <Style Selector="DateTimePickerPanel > ListBoxItem">
+                  <Setter Property="Theme" Value="{StaticResource SimpleDateTimePickerItem}" />
+                </Style>
+              </Grid.Styles>
               <!--  Ignore col defs here, set in code  -->
               <Panel Name="PART_HourHost"
                      Grid.Column="0">

From b84f5db167bdf9a3d0c1f7d729238926de46193a Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Tue, 23 Jun 2026 10:51:17 +0000
Subject: [PATCH 045/196] WASM - Check permissions before reading or writing to
 clipboard (#21573)

* check permissions before reading or writing to clipboard

* throw UnauthorizedAccessException when permission is not granted for clipboard

* handle unauthorized access exceptions for clipboard in textbox

* check only for denied errors on clipboard

* addressed review

* wasm - use marshal methods instead when reading clipboard

* log unauthorized read clipboard  error

* Improve logging

* Also log in MaskedTextBox

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 src/Avalonia.Controls/MaskedTextBox.cs        |  6 +-
 src/Avalonia.Controls/TextBox.cs              | 16 +++-
 src/Browser/Avalonia.Browser/ClipboardImpl.cs | 27 +++++-
 .../Avalonia.Browser/Interop/InputHelper.cs   |  7 +-
 .../webapp/modules/avalonia/input.ts          | 92 ++++++++++++-------
 5 files changed, 104 insertions(+), 44 deletions(-)

diff --git a/src/Avalonia.Controls/MaskedTextBox.cs b/src/Avalonia.Controls/MaskedTextBox.cs
index cfbd072a88..22c05e7159 100644
--- a/src/Avalonia.Controls/MaskedTextBox.cs
+++ b/src/Avalonia.Controls/MaskedTextBox.cs
@@ -5,7 +5,7 @@ using System.Globalization;
 using System.Linq;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
-using Avalonia.Interactivity;
+using Avalonia.Logging;
 using Avalonia.VisualTree;
 
 namespace Avalonia.Controls
@@ -224,6 +224,10 @@ namespace Avalonia.Controls
                 {
                     // Silently ignore.
                 }
+                catch (UnauthorizedAccessException uex)
+                {
+                    Logger.TryGet(LogEventLevel.Warning, LogArea.Control)?.Log(this, "Failed to read text from clipboard: {Error}", uex);
+                }
 
                 if (text == null)
                     return;
diff --git a/src/Avalonia.Controls/TextBox.cs b/src/Avalonia.Controls/TextBox.cs
index dac2dd98c7..eb72638744 100644
--- a/src/Avalonia.Controls/TextBox.cs
+++ b/src/Avalonia.Controls/TextBox.cs
@@ -13,6 +13,7 @@ using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
+using Avalonia.Logging;
 using Avalonia.Media;
 using Avalonia.Media.TextFormatting;
 using Avalonia.Media.TextFormatting.Unicode;
@@ -1302,8 +1303,15 @@ namespace Avalonia.Controls
             {
                 var clipboard = TopLevel.GetTopLevel(this)?.Clipboard;
 
-                if (clipboard != null)
-                    await clipboard.SetTextAsync(text);
+                try
+                {
+                    if (clipboard != null)
+                        await clipboard.SetTextAsync(text);
+                }
+                catch (UnauthorizedAccessException uex)
+                {
+                    Logger.TryGet(LogEventLevel.Warning, LogArea.Control)?.Log(this, "Failed to write text to clipboard: {Error}", uex);
+                }
             }
         }
 
@@ -1333,6 +1341,10 @@ namespace Avalonia.Controls
                 {
                     // Silently ignore.
                 }
+                catch (UnauthorizedAccessException uex)
+                {
+                    Logger.TryGet(LogEventLevel.Warning, LogArea.Control)?.Log(this, "Failed to read text from clipboard: {Error}", uex);
+                }
             }
 
             if (string.IsNullOrEmpty(text))
diff --git a/src/Browser/Avalonia.Browser/ClipboardImpl.cs b/src/Browser/Avalonia.Browser/ClipboardImpl.cs
index 3a4d44c278..50cec8721c 100644
--- a/src/Browser/Avalonia.Browser/ClipboardImpl.cs
+++ b/src/Browser/Avalonia.Browser/ClipboardImpl.cs
@@ -2,6 +2,7 @@
 using System.IO;
 using System.Runtime.InteropServices.JavaScript;
 using System.Threading.Tasks;
+using Avalonia.Browser.Interop;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Logging;
@@ -14,8 +15,13 @@ internal sealed class ClipboardImpl : IClipboardImpl
 {
     public async Task<IAsyncDataTransfer?> TryGetDataAsync()
     {
-        var jsItems = await ReadClipboardAsync(BrowserWindowingPlatform.GlobalThis).ConfigureAwait(false);
-        return jsItems.GetPropertyAsInt32("length") == 0 ? null : new BrowserClipboardDataTransfer(jsItems);
+        var result = await ReadClipboardAsync(BrowserWindowingPlatform.GlobalThis).ConfigureAwait(false);
+        if (result.GetPropertyAsString("error") == "denied")
+        {
+            throw new UnauthorizedAccessException("Read permission is not granted for clipboard");
+        }
+        var items = result.GetPropertyAsJSObject("result");
+        return items == null ? null : items.GetPropertyAsInt32("length") == 0 ? null : new BrowserClipboardDataTransfer(items);
     }
 
     public async Task SetDataAsync(IAsyncDataTransfer dataTransfer)
@@ -29,7 +35,18 @@ internal sealed class ClipboardImpl : IClipboardImpl
         }
 
         // However, ConfigureAwait(false) is fine here: we're not doing anything after.
-        await WriteClipboardAsync(BrowserWindowingPlatform.GlobalThis, source).ConfigureAwait(false);
+        await WriteClipboardAsync(source).ConfigureAwait(false);
+    }
+
+    private async Task WriteClipboardAsync(JSObject? source)
+    {
+        // However, ConfigureAwait(false) is fine here: we're not doing anything after.
+        var error = await InputHelper.WriteClipboardAsync(BrowserWindowingPlatform.GlobalThis, source).ConfigureAwait(false);
+
+        if (error == "denied")
+        {
+            throw new UnauthorizedAccessException("Write permission is not granted for clipboard");
+        }
     }
 
     private async Task TryAddItemAsync(IAsyncDataTransferItem dataTransferItem, JSObject source)
@@ -55,7 +72,7 @@ internal sealed class ClipboardImpl : IClipboardImpl
                     continue;
                 }
 
-                if(DataFormat.Bitmap.Equals(format))
+                if (DataFormat.Bitmap.Equals(format))
                 {
                     var bitmap = await dataTransferItem.TryGetValueAsync(DataFormat.Bitmap);
                     if (bitmap != null)
@@ -106,5 +123,5 @@ internal sealed class ClipboardImpl : IClipboardImpl
     }
 
     public Task ClearAsync()
-        => WriteClipboardAsync(BrowserWindowingPlatform.GlobalThis, null);
+        => WriteClipboardAsync(null);
 }
diff --git a/src/Browser/Avalonia.Browser/Interop/InputHelper.cs b/src/Browser/Avalonia.Browser/Interop/InputHelper.cs
index bb2884b064..4e104b0968 100644
--- a/src/Browser/Avalonia.Browser/Interop/InputHelper.cs
+++ b/src/Browser/Avalonia.Browser/Interop/InputHelper.cs
@@ -8,11 +8,12 @@ internal static partial class InputHelper
 {
     public static Task RedirectInputAsync(int topLevelId, Action<BrowserTopLevelImpl> handler)
     {
-        if (BrowserTopLevelImpl.TryGetTopLevel(topLevelId) is { } topLevelImpl) handler(topLevelImpl);
+        if (BrowserTopLevelImpl.TryGetTopLevel(topLevelId) is { } topLevelImpl)
+            handler(topLevelImpl);
         return Task.CompletedTask;
     }
 
-    public static Task<T> RedirectInputRetunAsync<T>(int topLevelId, Func<BrowserTopLevelImpl,T> handler, T @default)
+    public static Task<T> RedirectInputRetunAsync<T>(int topLevelId, Func<BrowserTopLevelImpl, T> handler, T @default)
     {
         if (BrowserTopLevelImpl.TryGetTopLevel(topLevelId) is { } topLevelImpl)
             return Task.FromResult(handler(topLevelImpl));
@@ -132,7 +133,7 @@ internal static partial class InputHelper
     public static partial Task<JSObject> ReadClipboardAsync(JSObject window);
 
     [JSImport("InputHelper.writeClipboard", AvaloniaModule.MainModuleName)]
-    public static partial Task WriteClipboardAsync(JSObject globalThis, JSObject? source);
+    public static partial Task<string> WriteClipboardAsync(JSObject globalThis, JSObject? source);
 
     [JSImport("InputHelper.getReadableDataItemFormats", AvaloniaModule.MainModuleName)]
     public static partial string[] GetReadableDataItemFormats(JSObject item);
diff --git a/src/Browser/Avalonia.Browser/webapp/modules/avalonia/input.ts b/src/Browser/Avalonia.Browser/webapp/modules/avalonia/input.ts
index e70c43ebed..3c2ef49048 100644
--- a/src/Browser/Avalonia.Browser/webapp/modules/avalonia/input.ts
+++ b/src/Browser/Avalonia.Browser/webapp/modules/avalonia/input.ts
@@ -47,6 +47,11 @@ interface WriteableClipboardSource {
     items: WriteableClipboardItem[];
 }
 
+interface ClipboardResult {
+    error: string;
+    result: ReadableDataItem[]
+}
+
 type ReadableDataItem = {
     type: "clipboardItem";
     value: ClipboardItem;
@@ -71,7 +76,7 @@ type ReadableDataValue = {
 
 export class InputHelper {
     static clipboardState: ClipboardState = ClipboardState.None;
-    static resolveClipboard?: (value: readonly ReadableDataItem[]) => void;
+    static resolveClipboard?: (value: ClipboardResult) => void;
     static rejectClipboard?: (reason?: any) => void;
 
     public static initializeBackgroundHandlers() {
@@ -85,7 +90,7 @@ export class InputHelper {
             }
 
             const items = this.getDataTransferItems(args.clipboardData);
-            this.resolveClipboard(items.map((item) => ({ type: "dataTransferItem", value: item })));
+            this.resolveClipboard({ result: items.map((item) => ({ type: "dataTransferItem", value: item }))} as ClipboardResult);
         });
         this.clipboardState = ClipboardState.Ready;
     }
@@ -122,43 +127,64 @@ export class InputHelper {
         item.data[format] = new Blob([bytes], { type: format });
     }
 
-    public static async readClipboard(window: Window): Promise<readonly ReadableDataItem[]> {
+    public static async readClipboard(window: Window): Promise<ClipboardResult> {
         const clipboard = window.navigator.clipboard;
 
-        if (clipboard.read) {
-            const clipboardItems = await clipboard.read();
-            return clipboardItems.map((item) => ({ type: "clipboardItem", value: item }));
-        } else if (clipboard.readText) {
-            const item: ReadableDataItem = {
-                type: "string",
-                value: await clipboard.readText()
-            };
-            return [item];
-        } else {
-            try {
-                return await new Promise<readonly ReadableDataItem[]>((resolve, reject) => {
-                    this.clipboardState = ClipboardState.Pending;
-                    this.resolveClipboard = resolve;
-                    this.rejectClipboard = reject;
-                });
-            } finally {
-                this.clipboardState = ClipboardState.Ready;
-                this.resolveClipboard = undefined;
-                this.rejectClipboard = undefined;
+        try {
+            if (clipboard.read) {
+                const clipboardItems = await clipboard.read();
+                return { result: clipboardItems.map((item) => ({ type: "clipboardItem", value: item })) } as ClipboardResult;
+            } else if (clipboard.readText) {
+                const item: ReadableDataItem = {
+                    type: "string",
+                    value: await clipboard.readText()
+                };
+                return { result: [item] } as ClipboardResult;
+            } else {
+                try {
+                    return await new Promise<ClipboardResult>((resolve, reject) => {
+                        this.clipboardState = ClipboardState.Pending;
+                        this.resolveClipboard = resolve;
+                        this.rejectClipboard = reject;
+                    });
+                } finally {
+                    this.clipboardState = ClipboardState.Ready;
+                    this.resolveClipboard = undefined;
+                    this.rejectClipboard = undefined;
+                }
+            }
+        }
+        catch (ex: unknown) {
+            if (ex instanceof Error && ex.name == "NotAllowedError") {
+                return { error: "denied" } as ClipboardResult;
             }
+            throw ex;
         }
     }
 
-    public static async writeClipboard(window: Window, source?: WriteableClipboardSource | null): Promise<void> {
-        const items = source?.items ?? [];
-        if (items.length === 0) {
-            await window.navigator.clipboard.writeText("");
-            return;
-        }
+    public static async writeClipboard(window: Window, source?: WriteableClipboardSource | null): Promise<string> {
+        try {
+            const items = source?.items ?? [];
+            if (items.length === 0) {
+                await window.navigator.clipboard.writeText("");
+                return "";
+            }
+
+            if (window.navigator.clipboard.write) {
+                await window.navigator.clipboard.write(items.map(item => new ClipboardItem(item.data)))
+            }
+            else {
+                await this.writeFirstText(window, items)
+            }
 
-        return window.navigator.clipboard.write
-            ? await window.navigator.clipboard.write(items.map(item => new ClipboardItem(item.data)))
-            : await this.writeFirstText(window, items);
+            return "";
+        }
+        catch (error: unknown) {
+            if (error instanceof Error && error.name == "NotAllowedError") {
+                return "denied";
+            }
+            throw error;
+        }
     }
 
     private static async writeFirstText(window: Window, items: WriteableClipboardItem[]): Promise<void> {
@@ -505,7 +531,7 @@ export class InputHelper {
             };
         }
 
-        return () => {};
+        return () => { };
     }
 
     public static clearInput(inputElement: HTMLInputElement) {

From 39f0ffdf616580e51662d1092d32c68012d7bb39 Mon Sep 17 00:00:00 2001
From: Valentino Saitz <valentino.saitz@optris.de>
Date: Wed, 24 Jun 2026 09:27:15 +0200
Subject: [PATCH 046/196] Add decimal support to automation ComVariant
 marshalling (#21634)

NumericUpDown.Value is a decimal?, so changing it while a UI Automation
client is attached raised an automation property-changed event whose boxed
decimal hit no case in ComVariant.Create and threw an unhandled
ArgumentException that crashed the process. The event only fires when a UIA
client is listening, so it reproduced only on "some machines".

Mirror the BCL System.Runtime.InteropServices.Marshalling.ComVariant (which
this type is based on): overlay a decimal field on the variant, write it
before setting the VT_DECIMAL discriminator in Create (the discriminator
overlaps the decimal's unused leading bytes), and clear that discriminator on
a copy before reading the value back in AsObject.

Fixes #21491
---
 .../Marshalling/ComVariant.cs                 | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/src/Windows/Avalonia.Win32.Automation/Marshalling/ComVariant.cs b/src/Windows/Avalonia.Win32.Automation/Marshalling/ComVariant.cs
index 0fa78f300e..5c851c6e7d 100644
--- a/src/Windows/Avalonia.Win32.Automation/Marshalling/ComVariant.cs
+++ b/src/Windows/Avalonia.Win32.Automation/Marshalling/ComVariant.cs
@@ -39,9 +39,17 @@ internal struct ComVariant : IDisposable
     // Most of the data types in the Variant are carried in _typeUnion
     [FieldOffset(0)] private TypeUnion _typeUnion;
 
+    // Decimal is the largest data type and it needs to use the space that is normally unused in
+    // TypeUnion._wReserved1, etc. Hence, it is declared to completely overlap with TypeUnion. A
+    // Decimal does not use the first two bytes, and so TypeUnion._vt can still be used to encode the
+    // type. (Win32 automation is Windows-only, i.e. always little-endian, so TypeUnion's field order
+    // already lines up with Decimal._flags and no big-endian special-casing is required.)
+    [FieldOffset(0)] private decimal _decimal;
+
     [StructLayout(LayoutKind.Sequential)]
     private struct TypeUnion
     {
+        // The layout of _wReserved1 and _vt fields needs to match Decimal._flags.
         public ushort _vt;
         public ushort _wReserved1;
         public ushort _wReserved2;
@@ -161,6 +169,15 @@ internal struct ComVariant : IDisposable
             variant.VarType = VarEnum.VT_R8;
             variant._typeUnion._unionTypes._r8 = (double)value;
         }
+        else if (value is decimal)
+        {
+            // Set the value first and then the type, as the decimal storage overlaps the whole
+            // variant (including the type discriminator, which lands in decimal's unused first two
+            // bytes). NumericUpDown.Value is a decimal?, so its automation property-changed events
+            // arrive here; without this branch they throw and crash the app (#21491).
+            variant._decimal = (decimal)value;
+            variant.VarType = VarEnum.VT_DECIMAL;
+        }
         else if (value is DateTime)
         {
             variant.VarType = VarEnum.VT_DATE;
@@ -260,6 +277,8 @@ internal struct ComVariant : IDisposable
             // floating
             VarEnum.VT_R4 => _typeUnion._unionTypes._r4,
             VarEnum.VT_R8 => _typeUnion._unionTypes._r8,
+            // decimal
+            VarEnum.VT_DECIMAL => GetDecimal(),
             // date
             VarEnum.VT_DATE => DateTime.FromOADate(_typeUnion._unionTypes._date),
             // string
@@ -296,6 +315,19 @@ internal struct ComVariant : IDisposable
         };
     }
 
+    /// <summary>
+    /// Read the <see cref="decimal"/> stored in a <see cref="VarEnum.VT_DECIMAL"/> variant. The
+    /// decimal storage overlaps the entire variant, so the type discriminator currently sits in the
+    /// decimal's otherwise-unused first two bytes; clear it on a copy (by setting the type to
+    /// <see cref="VarEnum.VT_EMPTY"/>) so the VT_DECIMAL flag doesn't leak into the returned value.
+    /// </summary>
+    private readonly decimal GetDecimal()
+    {
+        var copy = this;
+        copy.VarType = VarEnum.VT_EMPTY;
+        return copy._decimal;
+    }
+
     /// <summary>
     /// The type of the data stored in this <see cref="ComVariant"/>.
     /// </summary>

From bdc8314235a73ef8b6079efdef00bdfdd39c13ca Mon Sep 17 00:00:00 2001
From: Shun-ichi Goto <shunichi.goto@gmail.com>
Date: Wed, 24 Jun 2026 19:30:36 +0900
Subject: [PATCH 047/196] Respect IME preedit cursor position on Win32 (#21632)

---
 .../Avalonia.Win32/Input/Imm32InputMethod.cs  | 80 +++++++++++++++----
 1 file changed, 63 insertions(+), 17 deletions(-)

diff --git a/src/Windows/Avalonia.Win32/Input/Imm32InputMethod.cs b/src/Windows/Avalonia.Win32/Input/Imm32InputMethod.cs
index 65827607c1..588e7a134b 100644
--- a/src/Windows/Avalonia.Win32/Input/Imm32InputMethod.cs
+++ b/src/Windows/Avalonia.Win32/Input/Imm32InputMethod.cs
@@ -25,6 +25,7 @@ namespace Avalonia.Win32.Input
         private const int CaretMargin = 1;
 
         private bool _ignoreComposition;
+        private int? _compositionCursorPosition;
 
         public TextInputMethodClient? Client { get; private set; }
 
@@ -110,6 +111,7 @@ namespace Avalonia.Win32.Input
             _langId = 0;
 
             IsComposing = false;
+            _compositionCursorPosition = null;
         }
 
         //Dependant on CurrentThread. When Avalonia will support Multiple Dispatchers -
@@ -118,6 +120,8 @@ namespace Avalonia.Win32.Input
 
         public void Reset()
         {
+            _compositionCursorPosition = null;
+
             Dispatcher.UIThread.Post(() =>
             {
                 var himc = ImmGetContext(Hwnd);
@@ -141,6 +145,7 @@ namespace Avalonia.Win32.Input
                     IsComposing = false;
 
                     Composition = null;
+                    _compositionCursorPosition = null;
                 }
             });
         }
@@ -150,8 +155,9 @@ namespace Avalonia.Win32.Input
             if(Client != null)
             {
                 Composition = null;
+                _compositionCursorPosition = null;
 
-                Client.SetPreeditText(null);
+                Client.SetPreeditText(null, null);
             }
 
             Client = client;
@@ -266,16 +272,17 @@ namespace Avalonia.Win32.Input
             // we're skipping this. not usable on windows
         }
 
-        public void CompositionChanged(string? composition)
+        public void CompositionChanged(string? composition, int? cursorPosition)
         {
             Composition = composition;
+            _compositionCursorPosition = cursorPosition;
 
             if (!IsActive || !Client.SupportsPreedit)
             {
                 return;
             }
 
-            Client.SetPreeditText(composition);
+            Client.SetPreeditText(composition, cursorPosition);
         }
         
         public string? GetCompositionString(GCS flag)
@@ -290,13 +297,40 @@ namespace Avalonia.Win32.Input
             return ImmGetCompositionString(himc, flag);
         }
 
+        private int? GetCompositionCursorPosition()
+        {
+            if (!IsComposing)
+            {
+                return null;
+            }
+
+            var himc = ImmGetContext(Hwnd);
+
+            if (himc == IntPtr.Zero)
+            {
+                return null;
+            }
+
+            try
+            {
+                var cursorPosition = ImmGetCompositionString(himc, GCS.GCS_CURSORPOS, IntPtr.Zero, 0);
+
+                return cursorPosition >= 0 ? cursorPosition : null;
+            }
+            finally
+            {
+                ImmReleaseContext(Hwnd, himc);
+            }
+        }
+
         public void HandleCompositionStart()
         {
             Composition = null;
+            _compositionCursorPosition = null;
 
             if (IsActive)
             {
-                Client.SetPreeditText(null);
+                Client.SetPreeditText(null, null);
 
                 if (Client.SupportsSurroundingText && Client.Selection.Start != Client.Selection.End)
                 {
@@ -325,10 +359,11 @@ namespace Avalonia.Win32.Input
             }
 
             Composition = null;
+            _compositionCursorPosition = null;
 
             if (IsActive)
             {
-                Client.SetPreeditText(null);
+                Client.SetPreeditText(null, null);
             }
         }
 
@@ -342,25 +377,27 @@ namespace Avalonia.Win32.Input
             }
 
             var flags = (GCS)ToInt32(lParam);
+            var resultChanged = (flags & GCS.GCS_RESULTSTR) != 0;
             
             if (flags == 0)
             {
-                CompositionChanged("");
+                CompositionChanged("", null);
             }
 
-            if ((flags & GCS.GCS_RESULTSTR) != 0)
+            if (resultChanged)
             {
                 var resultString = GetCompositionString(GCS.GCS_RESULTSTR);
 
-                if (_parent != null && !string.IsNullOrEmpty(resultString))
-                {
-                    Composition = null;
+                Composition = null;
+                _compositionCursorPosition = null;
 
-                    if (IsActive)
-                    {
-                        Client.SetPreeditText(null);
-                    }
+                if (IsActive)
+                {
+                    Client.SetPreeditText(null, null);
+                }
 
+                if (_parent != null && !string.IsNullOrEmpty(resultString))
+                {
                     var e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp, _parent.Owner, resultString);
 
                     if (_parent.Input != null)
@@ -372,11 +409,20 @@ namespace Avalonia.Win32.Input
                 }
             }
 
-            if ((flags & GCS.GCS_COMPSTR) != 0)
+            var compositionChanged = (flags & GCS.GCS_COMPSTR) != 0;
+            var cursorPositionChanged = (flags & GCS.GCS_CURSORPOS) != 0;
+
+            if (compositionChanged || (cursorPositionChanged && !resultChanged))
             {
-                var compositionString = GetCompositionString(GCS.GCS_COMPSTR);
+                var compositionString = compositionChanged
+                    ? GetCompositionString(GCS.GCS_COMPSTR)
+                    : Composition;
+
+                var cursorPosition = cursorPositionChanged
+                    ? GetCompositionCursorPosition()
+                    : _compositionCursorPosition;
 
-                CompositionChanged(compositionString);
+                CompositionChanged(compositionString, cursorPosition);
             }
         }
 

From 7846c5cbab8bc72fc9124ad065dce2007c8015fc Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Wed, 24 Jun 2026 12:15:17 +0000
Subject: [PATCH 048/196] Allow setting ThemeVariant to Default to reset theme
 to system on android (#16340)

* allow setting ThemeVariant to Default to reset theme to system on android

* update api diff

* Fix theme variant not being applied when switching from Light/Dark to Default

* Use IPlatformSettings as a fallback in macOS SetFrameThemeVariant

* fix nullable check in android avaloniaview

* fix SetFrameThemeVariant api suppression

* fix accessibility helper crash

* fix reseting actual theme variant

* rebased

* update apidiff

* update apidiff

* fix default theme selection on desktop

* add missing changes

* fix wayland default theme detection

* fix browser theme detection

* removed redundant overrides

* Fix macOS default theme detection

* Fix iOS default theme detection

* Avoid async void

---------

Co-authored-by: Max Katz <maxkatz6@outlook.com>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 api/Avalonia.nupkg.xml                        | 36 ++++++++++
 samples/SafeAreaDemo/App.xaml                 |  2 +-
 .../SafeAreaDemo/ViewModels/MainViewModel.cs  | 31 ++++++++-
 samples/SafeAreaDemo/Views/MainView.xaml      |  9 ++-
 .../Avalonia.Android/AvaloniaView.Input.cs    |  6 +-
 src/Android/Avalonia.Android/AvaloniaView.cs  | 66 +++++++++++++++----
 .../Platform/AndroidInsetsManager.cs          |  5 ++
 .../Platform/AndroidPlatformSettings.cs       |  8 +--
 .../Platform/SkiaPlatform/TopLevelImpl.cs     | 23 ++++++-
 src/Avalonia.Base/Styling/ThemeVariant.cs     |  6 +-
 src/Avalonia.Controls/Application.cs          | 30 +++++----
 .../Offscreen/OffscreenTopLevelImpl.cs        |  2 +-
 .../Platform/ITopLevelImpl.cs                 |  2 +-
 src/Avalonia.Controls/TopLevel.cs             | 15 +++--
 src/Avalonia.DesignerSupport/Remote/Stubs.cs  |  2 +-
 .../DBusPlatformSettings.cs                   |  5 ++
 src/Avalonia.Native/NativePlatformSettings.cs | 15 +----
 src/Avalonia.Native/TopLevelImpl.cs           |  2 +-
 src/Avalonia.Native/WindowImplBase.cs         | 10 ++-
 src/Avalonia.Wayland/WindowImplBase.cs        | 10 ++-
 src/Avalonia.X11/X11Window.cs                 |  8 ++-
 .../BrowserPlatformSettings.cs                |  5 ++
 .../Avalonia.Browser/BrowserTopLevelImpl.cs   |  6 +-
 .../Avalonia.Headless/HeadlessWindowImpl.cs   |  2 +-
 .../FramebufferToplevelImpl.cs                |  2 +-
 .../Avalonia.Win32/SwapChainTopLevelImpl.cs   |  2 +-
 .../Avalonia.Win32/Win32PlatformSettings.cs   | 16 ++---
 src/Windows/Avalonia.Win32/WindowImpl.cs      |  8 ++-
 src/iOS/Avalonia.iOS/AvaloniaView.cs          |  7 +-
 src/iOS/Avalonia.iOS/PlatformSettings.cs      |  5 ++
 .../CompositorTestServices.cs                 |  2 +-
 31 files changed, 260 insertions(+), 88 deletions(-)

diff --git a/api/Avalonia.nupkg.xml b/api/Avalonia.nupkg.xml
index d66ef8f68d..4b2aa63ef1 100644
--- a/api/Avalonia.nupkg.xml
+++ b/api/Avalonia.nupkg.xml
@@ -43,6 +43,18 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Controls.Embedding.Offscreen.OffscreenTopLevelImplBase.SetFrameThemeVariant(Avalonia.Platform.PlatformThemeVariant)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Controls.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Controls.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.ITopLevelImpl.SetFrameThemeVariant(Avalonia.Platform.PlatformThemeVariant)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Controls.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Controls.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:Avalonia.OpenGL.Egl.EglPlatformSurfaceRenderTargetBase.BeginDraw(Avalonia.OpenGL.Egl.EglSurface,Avalonia.PixelSize,System.Double,System.Action,System.Boolean)</Target>
@@ -91,6 +103,18 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Controls.Embedding.Offscreen.OffscreenTopLevelImplBase.SetFrameThemeVariant(Avalonia.Platform.PlatformThemeVariant)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Controls.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Controls.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.ITopLevelImpl.SetFrameThemeVariant(Avalonia.Platform.PlatformThemeVariant)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Controls.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Controls.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:Avalonia.OpenGL.Egl.EglPlatformSurfaceRenderTargetBase.BeginDraw(Avalonia.OpenGL.Egl.EglSurface,Avalonia.PixelSize,System.Double,System.Action,System.Boolean)</Target>
@@ -103,10 +127,22 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Controls.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Controls.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.ITopLevelImpl.SetFrameThemeVariant(System.Nullable{Avalonia.Platform.PlatformThemeVariant})</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Controls.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Controls.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Controls.Platform.IWin32OptionsTopLevelImpl.SetWindowCornerPreference(Avalonia.Controls.Win32Properties.WindowCornerPreference)</Target>
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.Controls.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.Controls.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.ITopLevelImpl.SetFrameThemeVariant(System.Nullable{Avalonia.Platform.PlatformThemeVariant})</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Controls.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Controls.dll</Right>
+  </Suppression>
 </Suppressions>
diff --git a/samples/SafeAreaDemo/App.xaml b/samples/SafeAreaDemo/App.xaml
index f406bfe710..70fd759dad 100644
--- a/samples/SafeAreaDemo/App.xaml
+++ b/samples/SafeAreaDemo/App.xaml
@@ -2,7 +2,7 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:local="using:SafeAreaDemo"
              x:Class="SafeAreaDemo.App"
-             RequestedThemeVariant="Light">
+             RequestedThemeVariant="Default">
     <Application.DataTemplates>
         <local:ViewLocator/>
     </Application.DataTemplates>
diff --git a/samples/SafeAreaDemo/ViewModels/MainViewModel.cs b/samples/SafeAreaDemo/ViewModels/MainViewModel.cs
index 4679948a6a..ef7fd35651 100644
--- a/samples/SafeAreaDemo/ViewModels/MainViewModel.cs
+++ b/samples/SafeAreaDemo/ViewModels/MainViewModel.cs
@@ -3,6 +3,7 @@ using Avalonia;
 using Avalonia.Animation.Easings;
 using Avalonia.Controls;
 using Avalonia.Controls.Platform;
+using Avalonia.Styling;
 using MiniMvvm;
 
 namespace SafeAreaDemo.ViewModels
@@ -33,7 +34,7 @@ namespace SafeAreaDemo.ViewModels
         public Rect InputPaneRect => _inputPane?.OccludedRect ?? default;
 
         public Rect CanvasSize { get; set; }
-        
+
         public Thickness SafeAreaPadding
         {
             get
@@ -105,7 +106,7 @@ namespace SafeAreaDemo.ViewModels
             set
             {
                 _autoSafeAreaPadding = value;
-                
+
                 RaisePropertyChanged();
                 RaiseSafeAreaChanged();
             }
@@ -159,7 +160,7 @@ namespace SafeAreaDemo.ViewModels
             this.RaisePropertyChanged(nameof(ViewPadding));
             this.RaisePropertyChanged(nameof(InputPaneMarkerMargin));
         }
-        
+
         private void RaiseKeyboardChanged()
         {
             this.RaisePropertyChanged(nameof(InputPaneState));
@@ -168,5 +169,29 @@ namespace SafeAreaDemo.ViewModels
             this.RaisePropertyChanged(nameof(InputPaneDuration));
             this.RaisePropertyChanged(nameof(InputPaneMarkerMargin));
         }
+
+        public void SetLight()
+        {
+            if (Application.Current is { } application)
+            {
+                application.RequestedThemeVariant = ThemeVariant.Light;
+            }
+        }
+
+        public void SetDark()
+        {
+            if (Application.Current is { } application)
+            {
+                application.RequestedThemeVariant = ThemeVariant.Dark;
+            }
+        }
+
+        public void SetDefault()
+        {
+            if (Application.Current is { } application)
+            {
+                application.RequestedThemeVariant = ThemeVariant.Default;
+            }
+        }
     }
 }
diff --git a/samples/SafeAreaDemo/Views/MainView.xaml b/samples/SafeAreaDemo/Views/MainView.xaml
index c03ffc1f39..c62410aa83 100644
--- a/samples/SafeAreaDemo/Views/MainView.xaml
+++ b/samples/SafeAreaDemo/Views/MainView.xaml
@@ -8,7 +8,6 @@
              d:DesignHeight="450"
              x:Class="SafeAreaDemo.Views.MainView"
              x:DataType="vm:MainViewModel"
-             Background="#ccc"
              TopLevel.AutoSafeAreaPadding="{Binding AutoSafeAreaPadding, Mode=TwoWay}">
     <Grid HorizontalAlignment="Stretch"
           VerticalAlignment="Stretch"
@@ -40,6 +39,7 @@
                       HorizontalAlignment="Stretch"
                       VerticalAlignment="Stretch">
                     <StackPanel Orientation="Vertical"
+                                Spacing="5"
                                 HorizontalAlignment="Center"
                                 VerticalAlignment="Center">
                         <Label HorizontalAlignment="Left">Options:</Label>
@@ -47,7 +47,12 @@
                         <CheckBox IsChecked="{Binding UseSafeArea}" IsEnabled="{Binding !AutoSafeAreaPadding}">Use Safe Area</CheckBox>
                         <CheckBox IsChecked="{Binding AutoSafeAreaPadding}">Automatic Paddings</CheckBox>
                         <CheckBox IsChecked="{Binding HideSystemBars}">Hide System Bars</CheckBox>
-                         <TextBox Width="200" PlaceholderText="Tap to Show Keyboard"/>
+                        <TextBox Width="200" PlaceholderText="Tap to Show Keyboard"/>
+                        <StackPanel Orientation="Horizontal" Spacing="10">
+                          <Button Command="{Binding SetLight}">Light</Button>
+                          <Button Command="{Binding SetDark}">Dark</Button>
+                          <Button Command="{Binding SetDefault}">Default</Button>
+                        </StackPanel>
                     </StackPanel>
                 </Grid>
             </DockPanel>
diff --git a/src/Android/Avalonia.Android/AvaloniaView.Input.cs b/src/Android/Avalonia.Android/AvaloniaView.Input.cs
index 4862daaf0b..413a21ba9c 100644
--- a/src/Android/Avalonia.Android/AvaloniaView.Input.cs
+++ b/src/Android/Avalonia.Android/AvaloniaView.Input.cs
@@ -22,14 +22,14 @@ namespace Avalonia.Android
         protected override void OnFocusChanged(bool gainFocus, FocusSearchDirection direction, global::Android.Graphics.Rect? previouslyFocusedRect)
         {
             base.OnFocusChanged(gainFocus, direction, previouslyFocusedRect);
-            _accessHelper.OnFocusChanged(gainFocus, (int)direction, previouslyFocusedRect);
+            _accessHelper?.OnFocusChanged(gainFocus, (int)direction, previouslyFocusedRect);
         }
 
         protected override bool DispatchHoverEvent(MotionEvent? e)
         {
             var res = _view.PointerHelper.DispatchMotionEvent(e, out var callBase);
             if (res == false)
-                callBase = !_accessHelper.DispatchHoverEvent(e!) && callBase;
+                callBase = (_accessHelper?.DispatchHoverEvent(e!) == true) && callBase;
 
             var baseResult = callBase && base.DispatchHoverEvent(e);
 
@@ -63,7 +63,7 @@ namespace Avalonia.Android
         {
             var res = _view.KeyboardHelper.DispatchKeyEvent(e, out var callBase);
             if (res == false)
-                callBase = !_accessHelper.DispatchKeyEvent(e!) && callBase;
+                callBase = _accessHelper?.DispatchKeyEvent(e!) == false && callBase;
 
             var baseResult = callBase && base.DispatchKeyEvent(e);
 
diff --git a/src/Android/Avalonia.Android/AvaloniaView.cs b/src/Android/Avalonia.Android/AvaloniaView.cs
index f1c3b95aa1..cec520acb7 100644
--- a/src/Android/Avalonia.Android/AvaloniaView.cs
+++ b/src/Android/Avalonia.Android/AvaloniaView.cs
@@ -19,11 +19,13 @@ namespace Avalonia.Android
 {
     public partial class AvaloniaView : FrameLayout
     {
-        private EmbeddableControlRoot _root;
+        private EmbeddableControlRoot? _root;
+        private ExploreByTouchHelper? _accessHelper;
+
         private readonly ViewImpl _view;
-        private readonly ExploreByTouchHelper _accessHelper;
 
         private IDisposable? _timerSubscription;
+        private object? _content;
         private bool _surfaceCreated;
 
         public AvaloniaView(Context context) : base(context)
@@ -32,11 +34,13 @@ namespace Avalonia.Android
 
             AddView(_view.View);
 
+            this.SetBackgroundColor(global::Android.Graphics.Color.Transparent);
+
             _root = new EmbeddableControlRoot(_view);
             _root.Prepare();
 
             SetBackgroundColor(global::Android.Graphics.Color.Transparent);
-            OnConfigurationChanged();
+            OnConfigurationChanged(null);
 
             _view.InternalView!.SurfaceWindowCreated += InternalView_SurfaceWindowCreated;
             _view.InternalView.SurfaceWindowDestroyed += InternalView_SurfaceWindowDestroyed;
@@ -69,16 +73,50 @@ namespace Avalonia.Android
 
         public object? Content
         {
-            get { return _root.Content; }
-            set { _root.Content = value; }
+            get { return _root?.Content; }
+            set
+            {
+                _content = value;
+                if (_root != null)
+                    _root.Content = value;
+            }
         }
 
         internal new void Dispose()
         {
+            _root?.Dispose();
+            _root = null;
+            _content = null;
+        }
+
+        protected override void OnDetachedFromWindow()
+        {
+            base.OnDetachedFromWindow();
             OnVisibilityChanged(false);
             _surfaceCreated = false;
-            _root?.Dispose();
-            _root = null!;
+
+            if (_accessHelper is { } accessHelper)
+            {
+                ViewCompat.SetAccessibilityDelegate(this, null);
+                _accessHelper = null;
+            }
+        }
+
+        protected override void OnAttachedToWindow()
+        {
+            _root?.Content = null;
+            _root = new EmbeddableControlRoot(_view);
+            _root.Prepare();
+            if (_content != null)
+            {
+                _root.Content = _content;
+            }
+
+            _accessHelper = new AvaloniaAccessHelper(this);
+            ViewCompat.SetAccessibilityDelegate(this, _accessHelper);
+            SendConfigurationChanged(Context?.Resources?.Configuration);
+
+            base.OnAttachedToWindow();
         }
 
         [SupportedOSPlatform("android24.0")]
@@ -98,6 +136,7 @@ namespace Avalonia.Android
         {
             if (_root == null || !_surfaceCreated)
                 return;
+
             if (isVisible && _timerSubscription == null)
             {
                 if (AndroidPlatform.Timer is { } timer)
@@ -119,20 +158,21 @@ namespace Avalonia.Android
                 _timerSubscription = null;
             }
         }
-        
+
         protected override void OnConfigurationChanged(Configuration? newConfig)
         {
             base.OnConfigurationChanged(newConfig);
-            OnConfigurationChanged();
+            SendConfigurationChanged(newConfig ?? Context?.Resources?.Configuration);
         }
 
-        private void OnConfigurationChanged()
+        private void SendConfigurationChanged(Configuration? newConfig)
         {
-            if (Context is { } context)
+            _view.InsetsManager?.SetDefaultSystemLightMode(!(newConfig?.UiMode.HasFlag(UiMode.NightYes) ?? false));
+            if (Context is { } context && newConfig is { } config)
             {
                 var settings =
                     AvaloniaLocator.Current.GetRequiredService<IPlatformSettings>() as AndroidPlatformSettings;
-                settings?.OnViewConfigurationChanged(context);
+                settings?.OnViewConfigurationChanged(context, config);
                 ((AndroidScreens)_view.TryGetFeature<IScreenImpl>()!).OnChanged();
             }
         }
@@ -146,7 +186,7 @@ namespace Avalonia.Android
 
             private void ViewImpl_FocusChange(object? sender, FocusChangeEventArgs e)
             {
-                if(!e.HasFocus)
+                if (!e.HasFocus)
                     LostFocus?.Invoke();
             }
         }
diff --git a/src/Android/Avalonia.Android/Platform/AndroidInsetsManager.cs b/src/Android/Avalonia.Android/Platform/AndroidInsetsManager.cs
index a8ab825808..2cf2896c7b 100644
--- a/src/Android/Avalonia.Android/Platform/AndroidInsetsManager.cs
+++ b/src/Android/Avalonia.Android/Platform/AndroidInsetsManager.cs
@@ -187,6 +187,11 @@ namespace Avalonia.Android.Platform
             return insets;
         }
 
+        internal void SetDefaultSystemLightMode(bool islightMode)
+        {
+            _isDefaultSystemBarLightTheme = islightMode;
+        }
+
         private void NotifySafeAreaChanged(Thickness safeAreaPadding)
         {
             Dispatcher.UIThread.Send(_ => SafeAreaChanged?.Invoke(this, new SafeAreaChangedArgs(safeAreaPadding)));
diff --git a/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs b/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs
index 1e77b7d880..5da78439e2 100644
--- a/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs
+++ b/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs
@@ -49,14 +49,14 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
 
     public override TimeSpan HoldWaitDuration => _holdWaitDuration;
 
-    internal void OnViewConfigurationChanged(Context context)
+    internal void OnViewConfigurationChanged(Context context, Configuration configuration)
     {
-        if (context.Resources?.Configuration is null)
+        if (context.Resources is null)
         {
             return;
         }
 
-        var systemTheme = (context.Resources.Configuration.UiMode & UiMode.NightMask) switch
+        PlatformThemeVariant systemTheme = (configuration.UiMode & UiMode.NightMask) switch
         {
             UiMode.NightYes => PlatformThemeVariant.Dark,
             UiMode.NightNo => PlatformThemeVariant.Light,
@@ -98,7 +98,7 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
                 }
                 finally
                 {
-                    array.Recycle();   
+                    array.Recycle();
                 }
             }
         }
diff --git a/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs b/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs
index a7bf5f626d..a732e90689 100644
--- a/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs
+++ b/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs
@@ -8,6 +8,7 @@ using Android.OS;
 using Android.Runtime;
 using Android.Views;
 using AndroidX.AppCompat.App;
+using AndroidX.Core.View;
 using Avalonia.Android.Platform.Input;
 using Avalonia.Android.Platform.Specific.Helpers;
 using Avalonia.Android.Platform.Storage;
@@ -232,7 +233,7 @@ namespace Avalonia.Android.Platform.SkiaPlatform
             }
         }
 
-        public void SetFrameThemeVariant(PlatformThemeVariant themeVariant)
+        public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
         {
             if (_insetsManager != null)
             {
@@ -244,7 +245,23 @@ namespace Avalonia.Android.Platform.SkiaPlatform
                 };
             }
 
-            AppCompatDelegate.DefaultNightMode = themeVariant == PlatformThemeVariant.Light ? AppCompatDelegate.ModeNightNo : AppCompatDelegate.ModeNightYes;
+            // Sets the default app NightMode to AppCompatDelegate.ModeNightFollowSystem when themeVariant is null. This
+            // allows app to follow the current OS night mode. Using either ModeNightNo or ModeNightYes will force the app
+            // to use one night mode, ignoring the system's configuration and preventing us from detecting system theme changes
+            // in View.OnConfigurationChanged. In this case, only Activity.OnConfigurationChanged is called when system theme is
+            // changed, but we don't have access to that method if the toplevel view is embedded in a custom activity
+            var nightMode = themeVariant == null ? AppCompatDelegate.ModeNightFollowSystem :
+                themeVariant == PlatformThemeVariant.Light ? AppCompatDelegate.ModeNightNo : AppCompatDelegate.ModeNightYes;
+
+            AppCompatDelegate.DefaultNightMode = nightMode;
+
+            if (nightMode == AppCompatDelegate.ModeNightFollowSystem && _view?.Context is { } context
+                && context.Resources?.Configuration is { } config)
+            {
+                var settings =
+                    AvaloniaLocator.Current.GetRequiredService<IPlatformSettings>() as AndroidPlatformSettings;
+                settings?.OnViewConfigurationChanged(context, config);
+            }
         }
 
         public AcrylicPlatformCompensationLevels AcrylicCompensationLevels => new(1, 1, 1);
@@ -254,8 +271,8 @@ namespace Avalonia.Android.Platform.SkiaPlatform
         PixelSize EglGlPlatformSurface.IEglWindowGlPlatformSurfaceInfo.Size => _view?.Size ?? default;
         double EglGlPlatformSurface.IEglWindowGlPlatformSurfaceInfo.Scaling => _view?.Scaling ?? default;
 
+        internal AndroidInsetsManager? InsetsManager => _insetsManager;
         internal AndroidKeyboardEventsHelper<TopLevelImpl> KeyboardHelper => _keyboardHelper;
-
         internal AndroidMotionEventsHelper PointerHelper => _pointerHelper;
 
         public void SetTransparencyLevelHint(IReadOnlyList<WindowTransparencyLevel> transparencyLevels)
diff --git a/src/Avalonia.Base/Styling/ThemeVariant.cs b/src/Avalonia.Base/Styling/ThemeVariant.cs
index 5414d340bf..b469ea5b28 100644
--- a/src/Avalonia.Base/Styling/ThemeVariant.cs
+++ b/src/Avalonia.Base/Styling/ThemeVariant.cs
@@ -100,11 +100,11 @@ public sealed record ThemeVariant
         {
             PlatformThemeVariant.Light => Light,
             PlatformThemeVariant.Dark => Dark,
-            _ => throw new ArgumentOutOfRangeException(nameof(themeVariant), themeVariant, null)
+            _ => throw new ArgumentOutOfRangeException(nameof(themeVariant), themeVariant, null),
         };
     }
 
-    public static explicit operator PlatformThemeVariant?(ThemeVariant themeVariant)
+    public static explicit operator PlatformThemeVariant?(ThemeVariant? themeVariant)
     {
         if (themeVariant == Light)
         {
@@ -114,7 +114,7 @@ public sealed record ThemeVariant
         {
             return PlatformThemeVariant.Dark;
         }
-        else if (themeVariant.InheritVariant is { } inheritVariant)
+        else if (themeVariant?.InheritVariant is { } inheritVariant)
         {
             return (PlatformThemeVariant?)inheritVariant;
         }
diff --git a/src/Avalonia.Controls/Application.cs b/src/Avalonia.Controls/Application.cs
index 90e272c7bd..0b1e20c395 100644
--- a/src/Avalonia.Controls/Application.cs
+++ b/src/Avalonia.Controls/Application.cs
@@ -53,7 +53,7 @@ namespace Avalonia
         /// <inheritdoc cref="ThemeVariantScope.ActualThemeVariantProperty" />
         public static readonly StyledProperty<ThemeVariant> ActualThemeVariantProperty =
             ThemeVariantScope.ActualThemeVariantProperty.AddOwner<Application>();
-        
+
         /// <inheritdoc cref="ThemeVariantScope.RequestedThemeVariantProperty" />
         public static readonly StyledProperty<ThemeVariant?> RequestedThemeVariantProperty =
             ThemeVariantScope.RequestedThemeVariantProperty.AddOwner<Application>();
@@ -91,7 +91,7 @@ namespace Avalonia
             get => GetValue(RequestedThemeVariantProperty);
             set => SetValue(RequestedThemeVariantProperty, value);
         }
-        
+
         /// <inheritdoc />
         [System.Diagnostics.CodeAnalysis.SuppressMessage("AvaloniaProperty", "AVP1031", Justification = "This property is supposed to be a styled readonly property.")]
         [System.Diagnostics.CodeAnalysis.SuppressMessage("AvaloniaProperty", "AVP1030", Justification = "False positive.")]
@@ -201,7 +201,7 @@ namespace Avalonia
         /// as specific top levels might have different settings set-up. 
         /// </remarks>
         public IPlatformSettings? PlatformSettings => this.TryGetFeature<IPlatformSettings>();
-        
+
         event Action<IReadOnlyList<IStyle>>? IGlobalStyles.GlobalStylesAdded
         {
             add => _stylesAdded += value;
@@ -218,7 +218,7 @@ namespace Avalonia
         /// Initializes the application by loading XAML etc.
         /// </summary>
         public virtual void Initialize() { }
-        
+
         /// <inheritdoc/>
         public bool TryGetResource(object key, ThemeVariant? theme, out object? value)
         {
@@ -262,7 +262,7 @@ namespace Avalonia
                 .Bind<IGlobalStyles>().ToConstant(this)
                 .Bind<IThemeVariantHost>().ToConstant(this)
                 .Bind<IInputManager>().ToConstant(InputManager)
-                .Bind< IToolTipService>().ToConstant(new ToolTipService(InputManager))
+                .Bind<IToolTipService>().ToConstant(new ToolTipService(InputManager))
                 .Bind<IKeyboardNavigationHandler>().ToTransient<KeyboardNavigationHandler>()
                 .Bind<IDragDropDevice>().ToConstant(DragDropDevice.Instance);
 
@@ -330,20 +330,28 @@ namespace Avalonia
 
             if (change.Property == RequestedThemeVariantProperty)
             {
-                if (change.GetNewValue<ThemeVariant>() is {} themeVariant && themeVariant != ThemeVariant.Default)
-                    SetValue(ActualThemeVariantProperty, themeVariant);
-                else
-                    ClearValue(ActualThemeVariantProperty);
+                if (change.GetNewValue<ThemeVariant>() is { } themeVariant)
+                {
+                    if (themeVariant == ThemeVariant.Default)
+                    {
+                        ClearValue(ActualThemeVariantProperty);
+                    }
+                    else
+                    {
+                        SetValue(ActualThemeVariantProperty, themeVariant);
+                    }
+                }
             }
             else if (change.Property == ActualThemeVariantProperty)
             {
                 ActualThemeVariantChanged?.Invoke(this, EventArgs.Empty);
             }
         }
-        
+
         private void OnColorValuesChanged(object? sender, PlatformColorValues e)
         {
-            SetValue(ActualThemeVariantProperty, (ThemeVariant)e.ThemeVariant, BindingPriority.Template);
+            if ((RequestedThemeVariant ?? ThemeVariant.Default) == ThemeVariant.Default)
+                SetValue(ActualThemeVariantProperty, (ThemeVariant)e.ThemeVariant);
         }
     }
 }
diff --git a/src/Avalonia.Controls/Embedding/Offscreen/OffscreenTopLevelImpl.cs b/src/Avalonia.Controls/Embedding/Offscreen/OffscreenTopLevelImpl.cs
index 27f927a3c4..32df6bafd9 100644
--- a/src/Avalonia.Controls/Embedding/Offscreen/OffscreenTopLevelImpl.cs
+++ b/src/Avalonia.Controls/Embedding/Offscreen/OffscreenTopLevelImpl.cs
@@ -63,7 +63,7 @@ namespace Avalonia.Controls.Embedding.Offscreen
 
         public Action<WindowTransparencyLevel>? TransparencyLevelChanged { get; set; }
 
-        public void SetFrameThemeVariant(PlatformThemeVariant themeVariant) { }
+        public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant) { }
 
         public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } = new AcrylicPlatformCompensationLevels(1, 1, 1);
 
diff --git a/src/Avalonia.Controls/Platform/ITopLevelImpl.cs b/src/Avalonia.Controls/Platform/ITopLevelImpl.cs
index bab5e4ffe9..548d4989b6 100644
--- a/src/Avalonia.Controls/Platform/ITopLevelImpl.cs
+++ b/src/Avalonia.Controls/Platform/ITopLevelImpl.cs
@@ -137,6 +137,6 @@ namespace Avalonia.Platform
         /// Sets the <see cref="PlatformThemeVariant"/> on the frame if it should be dark or light.
         /// Also applies for the mobile status bar.
         /// </summary>
-        void SetFrameThemeVariant(PlatformThemeVariant themeVariant);
+        void SetFrameThemeVariant(PlatformThemeVariant? themeVariant);
     }
 }
diff --git a/src/Avalonia.Controls/TopLevel.cs b/src/Avalonia.Controls/TopLevel.cs
index c30047fe7a..eeb6ae3488 100644
--- a/src/Avalonia.Controls/TopLevel.cs
+++ b/src/Avalonia.Controls/TopLevel.cs
@@ -239,11 +239,6 @@ namespace Avalonia.Controls
             impl.TransparencyLevelChanged = HandleTransparencyLevelChanged;
 
             CreatePlatformImplBinding(TransparencyLevelHintProperty, hint => PlatformImpl.SetTransparencyLevelHint(hint ?? Array.Empty<WindowTransparencyLevel>()));
-            CreatePlatformImplBinding(ActualThemeVariantProperty, variant =>
-            {
-                variant ??= ThemeVariant.Default;
-                PlatformImpl?.SetFrameThemeVariant((PlatformThemeVariant?)variant ?? PlatformThemeVariant.Light);
-            });
 
             _keyboardNavigationHandler?.SetOwner(this);
             _accessKeyHandler?.SetOwner(this);
@@ -258,6 +253,16 @@ namespace Avalonia.Controls
                 SetValue(ActualThemeVariantProperty, _applicationThemeHost.ActualThemeVariant, BindingPriority.Template);
                 _applicationThemeHost.ActualThemeVariantChanged += GlobalActualThemeVariantChanged;
             }
+            CreatePlatformImplBinding(ActualThemeVariantProperty, variant =>
+            {
+                if(_applicationThemeHost is AvaloniaObject element)
+                {
+                    if (element.GetValue(ThemeVariantScope.RequestedThemeVariantProperty) is { } requestedThemeVariant)
+                        variant = requestedThemeVariant == ThemeVariant.Default ? ThemeVariant.Default : variant;
+                }
+                variant ??= ThemeVariant.Default;
+                PlatformImpl?.SetFrameThemeVariant((PlatformThemeVariant?)variant);
+            });
 
             ClientSize = impl.ClientSize;
 
diff --git a/src/Avalonia.DesignerSupport/Remote/Stubs.cs b/src/Avalonia.DesignerSupport/Remote/Stubs.cs
index 8149e5ad71..b53645c67b 100644
--- a/src/Avalonia.DesignerSupport/Remote/Stubs.cs
+++ b/src/Avalonia.DesignerSupport/Remote/Stubs.cs
@@ -196,7 +196,7 @@ namespace Avalonia.DesignerSupport.Remote
 
         public bool NeedsManagedDecorations => false;
 
-        public void SetFrameThemeVariant(PlatformThemeVariant themeVariant) { }
+        public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant) { }
 
         public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } = new AcrylicPlatformCompensationLevels(1, 1, 1);
 
diff --git a/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs b/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs
index 882219f9a1..bf17b5522e 100644
--- a/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs
+++ b/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs
@@ -37,6 +37,11 @@ namespace Avalonia.FreeDesktop
                 Dispatcher.UIThread.Post(() => OnColorValuesChanged(_lastColorValues));
         }
 
+        internal void OnRequestDefaultThemeVariant()
+        {
+            _ = TryGetInitialValuesAsync();
+        }
+
         private async Task<PlatformThemeVariant?> TryGetThemeVariantAsync()
         {
             try
diff --git a/src/Avalonia.Native/NativePlatformSettings.cs b/src/Avalonia.Native/NativePlatformSettings.cs
index 5e3ee0cfc2..b95d9a9439 100644
--- a/src/Avalonia.Native/NativePlatformSettings.cs
+++ b/src/Avalonia.Native/NativePlatformSettings.cs
@@ -8,7 +8,6 @@ namespace Avalonia.Native;
 internal class NativePlatformSettings : DefaultPlatformSettings
 {
     private readonly IAvnPlatformSettings _platformSettings;
-    private PlatformColorValues? _lastColorValues;
 
     public NativePlatformSettings(IAvnPlatformSettings platformSettings)
     {
@@ -30,7 +29,7 @@ internal class NativePlatformSettings : DefaultPlatformSettings
 
         if (color > 0)
         {
-            _lastColorValues = new PlatformColorValues
+            return new PlatformColorValues
             {
                 ThemeVariant = theme,
                 ContrastPreference = contrast,
@@ -39,25 +38,17 @@ internal class NativePlatformSettings : DefaultPlatformSettings
         }
         else
         {
-            _lastColorValues = new PlatformColorValues
+            return new PlatformColorValues
             {
                 ThemeVariant = theme,
                 ContrastPreference = contrast
             };
         }
-
-        return _lastColorValues;
     }
 
     public void OnColorValuesChanged()
     {
-        var oldColorValues = _lastColorValues;
-        var colorValues = GetColorValues();
-
-        if (oldColorValues != colorValues)
-        {
-            OnColorValuesChanged(colorValues);
-        }
+        OnColorValuesChanged(GetColorValues());
     }
 
     private class ColorsChangeCallback : NativeCallbackBase, IAvnActionCallback
diff --git a/src/Avalonia.Native/TopLevelImpl.cs b/src/Avalonia.Native/TopLevelImpl.cs
index 04e1318da8..4bd6e94f7d 100644
--- a/src/Avalonia.Native/TopLevelImpl.cs
+++ b/src/Avalonia.Native/TopLevelImpl.cs
@@ -158,7 +158,7 @@ internal class TopLevelImpl : ITopLevelImpl, IFramebufferPlatformSurface
     }
 
     public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } = new AcrylicPlatformCompensationLevels(1, 0, 0);
-    public virtual void SetFrameThemeVariant(PlatformThemeVariant themeVariant)
+    public virtual void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
     {
         //noop
     }
diff --git a/src/Avalonia.Native/WindowImplBase.cs b/src/Avalonia.Native/WindowImplBase.cs
index 852317a793..4c5652c03e 100644
--- a/src/Avalonia.Native/WindowImplBase.cs
+++ b/src/Avalonia.Native/WindowImplBase.cs
@@ -68,8 +68,16 @@ namespace Avalonia.Native
             Native?.Resize(clientSize.Width, clientSize.Height, (AvnPlatformResizeReason)reason);
         }
         
-        public override void SetFrameThemeVariant(PlatformThemeVariant themeVariant)
+        public override void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
         {
+            var settings = AvaloniaLocator.Current.GetService<IPlatformSettings>();
+
+            if (themeVariant is null && settings is NativePlatformSettings typedSettings)
+            {
+                typedSettings.OnColorValuesChanged();
+            }
+
+            themeVariant ??= settings?.GetColorValues().ThemeVariant ?? PlatformThemeVariant.Light;
             Native?.SetFrameThemeVariant((AvnPlatformThemeVariant)themeVariant);
         }
 
diff --git a/src/Avalonia.Wayland/WindowImplBase.cs b/src/Avalonia.Wayland/WindowImplBase.cs
index 3a95933d9c..8fe854feb5 100644
--- a/src/Avalonia.Wayland/WindowImplBase.cs
+++ b/src/Avalonia.Wayland/WindowImplBase.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Controls.Platform;
+using Avalonia.FreeDesktop;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Input.Raw;
@@ -76,7 +77,14 @@ internal abstract partial class WindowBaseImpl : IWindowBaseImpl
     public WindowTransparencyLevel TransparencyLevel { get; } = WindowTransparencyLevel.Transparent;
     public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } = default;
     public void SetTransparencyLevelHint(IReadOnlyList<WindowTransparencyLevel> transparencyLevels) { }
-    public void SetFrameThemeVariant(PlatformThemeVariant themeVariant) { }
+
+    public async void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
+    {
+        if (themeVariant == null && AvaloniaLocator.Current.GetService<IPlatformSettings>() is DBusPlatformSettings platformSettings)
+        {
+            platformSettings.OnRequestDefaultThemeVariant();
+        }
+    }
 
     public Action? Closed { get; set; }
     public Action? LostFocus { get; set; }
diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index ef644e2c72..12c3453d75 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -1662,7 +1662,13 @@ namespace Avalonia.X11
         public WindowTransparencyLevel TransparencyLevel =>
             _transparencyHelper?.CurrentLevel ?? WindowTransparencyLevel.None;
 
-        public void SetFrameThemeVariant(PlatformThemeVariant themeVariant) { }
+        public async void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
+        {
+            if (themeVariant == null && AvaloniaLocator.Current.GetService<IPlatformSettings>() is DBusPlatformSettings platformSettings)
+            {
+                platformSettings.OnRequestDefaultThemeVariant();
+            }
+        }
 
         public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } = new AcrylicPlatformCompensationLevels(1, 0.8, 0.8);
 
diff --git a/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs b/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs
index 2a3cef4334..5d9f18d993 100644
--- a/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs
+++ b/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs
@@ -37,6 +37,11 @@ internal class BrowserPlatformSettings : DefaultPlatformSettings
         _isHighContrast = isHighContrast;
         OnColorValuesChanged(GetColorValues());
     }
+
+    public void OnValuesChanged()
+    {
+        OnColorValuesChanged(GetColorValues());
+    }
     
     private void EnsureBackend()
     {
diff --git a/src/Browser/Avalonia.Browser/BrowserTopLevelImpl.cs b/src/Browser/Avalonia.Browser/BrowserTopLevelImpl.cs
index 6b712391e4..67773a6d5c 100644
--- a/src/Browser/Avalonia.Browser/BrowserTopLevelImpl.cs
+++ b/src/Browser/Avalonia.Browser/BrowserTopLevelImpl.cs
@@ -144,9 +144,13 @@ namespace Avalonia.Browser
         public Action? LostFocus { get; set; }
         public WindowTransparencyLevel TransparencyLevel => WindowTransparencyLevel.None;
 
-        public void SetFrameThemeVariant(PlatformThemeVariant themeVariant)
+        public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
         {
             // not in the standard, but we potentially can use "apple-mobile-web-app-status-bar-style" for iOS and "theme-color" for android.
+            if (themeVariant == null && AvaloniaLocator.Current.GetService<IPlatformSettings>() is BrowserPlatformSettings platformSettings)
+            {
+                platformSettings.OnValuesChanged();
+            }
         }
 
         public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; }
diff --git a/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs b/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
index f2a7bf3575..0036288ac0 100644
--- a/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
+++ b/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
@@ -438,7 +438,7 @@ namespace Avalonia.Headless
             
         }
         
-        public void SetFrameThemeVariant(PlatformThemeVariant themeVariant)
+        public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
         {
             
         }
diff --git a/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs b/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs
index 22965c05fe..0ef7d08677 100644
--- a/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs
+++ b/src/Linux/Avalonia.LinuxFramebuffer/FramebufferToplevelImpl.cs
@@ -78,7 +78,7 @@ using Avalonia.Rendering.Composition;
 
         public WindowTransparencyLevel TransparencyLevel => WindowTransparencyLevel.None;
 
-        public void SetFrameThemeVariant(PlatformThemeVariant themeVariant) { }
+        public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant) { }
 
         public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } = new AcrylicPlatformCompensationLevels(1, 1, 1);
         public object? TryGetFeature(Type featureType) => null;
diff --git a/src/Windows/Avalonia.Win32/SwapChainTopLevelImpl.cs b/src/Windows/Avalonia.Win32/SwapChainTopLevelImpl.cs
index 15ea304709..f59d39a75d 100644
--- a/src/Windows/Avalonia.Win32/SwapChainTopLevelImpl.cs
+++ b/src/Windows/Avalonia.Win32/SwapChainTopLevelImpl.cs
@@ -99,7 +99,7 @@ internal class SwapChainTopLevelImpl : ITopLevelImpl
 
     public void SetTransparencyLevelHint(IReadOnlyList<WindowTransparencyLevel> transparencyLevels) { }
 
-    public void SetFrameThemeVariant(PlatformThemeVariant themeVariant) { }
+    public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant) { }
 
     /// <summary>
     /// Optional IME implementation provided by the host.
diff --git a/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs b/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
index c4b016c1b9..efcdb32458 100644
--- a/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
+++ b/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
@@ -10,9 +10,7 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
 {
     private static readonly Lazy<bool> s_uiSettingsSupported = new(() =>
         WinRTApiInformation.IsTypePresent("Windows.UI.ViewManagement.UISettings")
-        && WinRTApiInformation.IsTypePresent("Windows.UI.ViewManagement.AccessibilitySettings")); 
-
-    private PlatformColorValues? _lastColorValues;
+        && WinRTApiInformation.IsTypePresent("Windows.UI.ViewManagement.AccessibilitySettings"));
 
     public override Size GetTapSize(PointerType type)
     {
@@ -54,7 +52,7 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
             // - Night sky - High Contrast #2
             // Only "Desert" one can be considered a "light" preference. 
             using var highContrastScheme = new HStringInterop(accessibilitySettings.HighContrastScheme);
-            return _lastColorValues = new PlatformColorValues
+            return new PlatformColorValues
             {
                 ThemeVariant = highContrastScheme.Value?.Contains("White") == true ?
                     PlatformThemeVariant.Light :
@@ -67,7 +65,7 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
         else
         {
             var background = uiSettings.GetColorValue(UIColorType.Background).ToAvalonia();
-            return _lastColorValues = new PlatformColorValues
+            return new PlatformColorValues
             {
                 ThemeVariant = background.R + background.G + background.B < (255 * 3 - background.R - background.G - background.B) ?
                     PlatformThemeVariant.Dark :
@@ -80,12 +78,6 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
     
     internal void OnColorValuesChanged()
     {
-        var oldColorValues = _lastColorValues;
-        var colorValues = GetColorValues();
-
-        if (oldColorValues != colorValues)
-        {
-            OnColorValuesChanged(colorValues);
-        }
+        OnColorValuesChanged(GetColorValues());
     }
 }
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs
index a39fa9c1cb..e07454a8ee 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -948,12 +948,12 @@ namespace Avalonia.Win32
             }
         }
 
-        public unsafe void SetFrameThemeVariant(PlatformThemeVariant themeVariant)
+        public unsafe void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
         {
-            _currentThemeVariant = themeVariant;
+            _currentThemeVariant = themeVariant ?? Win32Platform.Instance.PlatformSettings.GetColorValues().ThemeVariant;
             if (Win32Platform.WindowsVersion.Build >= 22000)
             {
-                var pvUseBackdropBrush = themeVariant == PlatformThemeVariant.Dark ? 1 : 0;
+                var pvUseBackdropBrush = _currentThemeVariant == PlatformThemeVariant.Dark ? 1 : 0;
                 DwmSetWindowAttribute(
                     _hwnd,
                     (int)DwmWindowAttribute.DWMWA_USE_IMMERSIVE_DARK_MODE,
@@ -964,6 +964,8 @@ namespace Avalonia.Win32
                     SetTransparencyMica();
                 }
             }
+
+            (Win32Platform.Instance.PlatformSettings as Win32PlatformSettings)?.OnColorValuesChanged();
         }
 
         protected virtual IntPtr CreateWindowOverride(ushort atom)
diff --git a/src/iOS/Avalonia.iOS/AvaloniaView.cs b/src/iOS/Avalonia.iOS/AvaloniaView.cs
index 29f848925d..566f210529 100644
--- a/src/iOS/Avalonia.iOS/AvaloniaView.cs
+++ b/src/iOS/Avalonia.iOS/AvaloniaView.cs
@@ -254,8 +254,13 @@ namespace Avalonia.iOS
 
             public WindowTransparencyLevel TransparencyLevel => WindowTransparencyLevel.None;
 
-            public void SetFrameThemeVariant(PlatformThemeVariant themeVariant)
+            public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
             {
+                if (themeVariant is null && AvaloniaLocator.Current.GetService<IPlatformSettings>() is PlatformSettings settings)
+                {
+                    settings.OnColorValuesChanged();
+                }
+
 #if !TVOS
                 // TODO adjust status bar depending on full screen mode.
                 if ((OperatingSystem.IsIOSVersionAtLeast(13)
diff --git a/src/iOS/Avalonia.iOS/PlatformSettings.cs b/src/iOS/Avalonia.iOS/PlatformSettings.cs
index 43cd731701..bf371d82c1 100644
--- a/src/iOS/Avalonia.iOS/PlatformSettings.cs
+++ b/src/iOS/Avalonia.iOS/PlatformSettings.cs
@@ -61,4 +61,9 @@ internal class PlatformSettings : DefaultPlatformSettings
             OnColorValuesChanged(colorValues);
         }
     }
+
+    internal void OnColorValuesChanged()
+    {
+        OnColorValuesChanged(GetColorValues());
+    }
 }
diff --git a/tests/Avalonia.UnitTests/CompositorTestServices.cs b/tests/Avalonia.UnitTests/CompositorTestServices.cs
index 14320ee4da..1ba03f5974 100644
--- a/tests/Avalonia.UnitTests/CompositorTestServices.cs
+++ b/tests/Avalonia.UnitTests/CompositorTestServices.cs
@@ -205,7 +205,7 @@ public class CompositorTestServices : IDisposable
 
         public WindowTransparencyLevel TransparencyLevel => WindowTransparencyLevel.None;
 
-        public void SetFrameThemeVariant(PlatformThemeVariant themeVariant)
+        public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
         {
         }
 

From fe01ba32485e03476a81781166387e11e6f17be6 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Wed, 24 Jun 2026 17:42:41 +0400
Subject: [PATCH 049/196] [X11] Implemented automatic fps detection (#18558)

* [X11] Detect FPS from XRANDR

* Fix timer detection

* Remove AllowHighRefreshRate

* Add constant for default FPS

* Use proper message/value in argument exception

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../Rendering/SleepLoopRenderTimer.cs         |  17 +-
 .../Screens/X11Screen.Providers.cs            | 216 +++++++++++++-----
 src/Avalonia.X11/Screens/X11Screens.cs        |   4 +
 src/Avalonia.X11/X11Platform.cs               |  13 +-
 src/Avalonia.X11/X11Structs.cs                |  87 ++++++-
 src/Avalonia.X11/XLib.Helpers.cs              |  10 +
 src/Avalonia.X11/XLib.cs                      |  21 ++
 7 files changed, 307 insertions(+), 61 deletions(-)

diff --git a/src/Avalonia.Base/Rendering/SleepLoopRenderTimer.cs b/src/Avalonia.Base/Rendering/SleepLoopRenderTimer.cs
index 570dc4cb30..3bcad0e87d 100644
--- a/src/Avalonia.Base/Rendering/SleepLoopRenderTimer.cs
+++ b/src/Avalonia.Base/Rendering/SleepLoopRenderTimer.cs
@@ -13,11 +13,21 @@ namespace Avalonia.Rendering
         private bool _threadStarted;
         private readonly AutoResetEvent _wakeEvent = new(false);
         private readonly Stopwatch _st = Stopwatch.StartNew();
-        private readonly TimeSpan _timeBetweenTicks;
+        private volatile int _desiredFps;
 
         public SleepLoopRenderTimer(int fps)
         {
-            _timeBetweenTicks = TimeSpan.FromSeconds(1d / fps);
+            DesiredFps = fps;
+        }
+
+        public int DesiredFps
+        {
+            get => _desiredFps;
+            set
+            {
+                ArgumentOutOfRangeException.ThrowIfLessThan(value, 1);
+                _desiredFps = value;
+            }
         }
 
         public Action<TimeSpan>? Tick
@@ -58,7 +68,8 @@ namespace Avalonia.Rendering
                     _wakeEvent.WaitOne();
 
                 var now = _st.Elapsed;
-                var timeTillNextTick = lastTick + _timeBetweenTicks - now;
+                var tickInterval = TimeSpan.FromSeconds(1d / _desiredFps);
+                var timeTillNextTick = lastTick + tickInterval - now;
                 if (timeTillNextTick.TotalMilliseconds > 1)
                     _wakeEvent.WaitOne(timeTillNextTick);
                 lastTick = now = _st.Elapsed;
diff --git a/src/Avalonia.X11/Screens/X11Screen.Providers.cs b/src/Avalonia.X11/Screens/X11Screen.Providers.cs
index 1a12a279a1..af0e47cfd5 100644
--- a/src/Avalonia.X11/Screens/X11Screen.Providers.cs
+++ b/src/Avalonia.X11/Screens/X11Screen.Providers.cs
@@ -3,6 +3,7 @@ using System.Diagnostics;
 using System.Linq;
 using System.Runtime.InteropServices;
 using Avalonia.Platform;
+using Avalonia.Threading;
 using static Avalonia.X11.XLib;
 
 namespace Avalonia.X11.Screens;
@@ -12,8 +13,6 @@ internal partial class X11Screens
     internal unsafe class X11Screen(MonitorInfo info, X11Info x11, IScalingProvider? scalingProvider, int id) : PlatformScreen(new PlatformHandle(info.Name, "XRandRMonitorName"))
     {
         public Size? PhysicalSize { get; set; }
-        // Length of a EDID-Block-Length(128 bytes), XRRGetOutputProperty multiplies offset and length by 4
-        private const int EDIDStructureLength = 32;
 
         public virtual void Refresh(MonitorInfo newInfo)
         {
@@ -26,55 +25,11 @@ internal partial class X11Screens
             DisplayName = name;
             IsPrimary = newInfo.IsPrimary;
             Bounds = new PixelRect(newInfo.X, newInfo.Y, newInfo.Width, newInfo.Height);
-            Size? pSize = null;
-            for (int o = 0; o < newInfo.Outputs.Length; o++)
-            {
-                var outputSize = GetPhysicalMonitorSizeFromEDID(newInfo.Outputs[o]);
-                if (outputSize != null)
-                {
-                    pSize = outputSize;
-                    break;
-                }
-            }
-            PhysicalSize = pSize;
+            PhysicalSize = newInfo.PhysicalSize;
             UpdateWorkArea();
             Scaling = scalingProvider.GetScaling(this, id);
         }
 
-        private unsafe Size? GetPhysicalMonitorSizeFromEDID(IntPtr rrOutput)
-        {
-            if (rrOutput == IntPtr.Zero)
-                return null;
-            var properties = XRRListOutputProperties(x11.Display, rrOutput, out int propertyCount);
-            var hasEDID = false;
-            for (var pc = 0; pc < propertyCount; pc++)
-            {
-                if (properties[pc] == x11.Atoms.EDID)
-                    hasEDID = true;
-            }
-
-            if (!hasEDID)
-                return null;
-            XRRGetOutputProperty(x11.Display, rrOutput, x11.Atoms.EDID, 0, EDIDStructureLength, false, false,
-                AnyPropertyType, out IntPtr actualType, out int actualFormat, out int bytesAfter, out _,
-                out IntPtr prop);
-            if (actualType != x11.Atoms.INTEGER)
-                return null;
-            if (actualFormat != 8) // Expecting an byte array
-                return null;
-
-            var edid = new byte[bytesAfter];
-            Marshal.Copy(prop, edid, 0, bytesAfter);
-            XFree(prop);
-            XFree(new IntPtr(properties));
-            if (edid.Length < 22)
-                return null;
-            var width = edid[21]; // 0x15 1 Max. Horizontal Image Size cm. 
-            var height = edid[22]; // 0x16 1 Max. Vertical Image Size cm. 
-            if (width == 0 && height == 0)
-                return null;
-            return new Size(width * 10, height * 10);
-        }
 
         protected unsafe void UpdateWorkArea()
         {
@@ -132,6 +87,11 @@ internal partial class X11Screens
         X11Screen CreateScreenFromKey(nint key);
         MonitorInfo GetMonitorInfoByKey(nint key);
     }
+    
+    internal interface IX11RawScreenInfoProviderWithRefreshRate : IX11RawScreenInfoProvider
+    {
+        int MaxRefreshRate { get; }
+    }
 
     internal unsafe struct MonitorInfo
     {
@@ -141,10 +101,12 @@ internal partial class X11Screens
         public int Y;
         public int Width;
         public int Height;
-        public IntPtr[] Outputs;
+        public int RefreshRate;
+        public Size? PhysicalSize;
+        public int SharedRefreshRate;
     }
 
-    private class Randr15ScreensImpl : IX11RawScreenInfoProvider
+    private class Randr15ScreensImpl : IX11RawScreenInfoProviderWithRefreshRate
     {
         private MonitorInfo[]? _cache;
         private readonly X11Info _x11;
@@ -160,17 +122,23 @@ internal partial class X11Screens
             _x11 = platform.Info;
             _window = CreateEventWindow(platform, OnEvent);
             _scalingProvider = GetScalingProvider(platform);
-            XRRSelectInput(_x11.Display, _window, RandrEventMask.RRScreenChangeNotify);
+            XRRSelectInput(_x11.Display, _window,
+                RandrEventMask.RRScreenChangeNotify
+                | RandrEventMask.RROutputChangeNotifyMask
+                | RandrEventMask.RROutputPropertyNotifyMask
+                | RandrEventMask.RRCrtcChangeNotifyMask);
+            
             if (_scalingProvider is IScalingProviderWithChanges scalingWithChanges)
                 scalingWithChanges.SettingsChanged += () => Changed?.Invoke();
         }
 
         private void OnEvent(ref XEvent ev)
         {
-            if ((int)ev.type == _x11.RandrEventBase + (int)RandrEvent.RRScreenChangeNotify)
+            if (((int)ev.type - _x11.RandrEventBase) is  (int)RandrEvent.RRScreenChangeNotify or (int)RandrEvent.RRNotify)
             {
                 _cache = null;
-                Changed?.Invoke();
+                // Delay triggering the update event
+                Dispatcher.UIThread.Post(() => Changed?.Invoke(), DispatcherPriority.Normal);
             }
         }
 
@@ -181,6 +149,7 @@ internal partial class X11Screens
                 if (_cache != null)
                     return _cache;
                 var monitors = XRRGetMonitors(_x11.Display, _window, true, out var count);
+                var resources = XRRGetScreenResources(_x11.Display, _window);
 
                 var screens = new MonitorInfo[count];
                 for (var c = 0; c < count; c++)
@@ -201,13 +170,150 @@ internal partial class X11Screens
                         Y = mon.Y,
                         Width = mon.Width,
                         Height = mon.Height,
-                        Outputs = outputs
+                        PhysicalSize = GetPhysicalMonitorSizeFromFirstEligibleOutput(outputs),
+                        SharedRefreshRate = GetSharedRefreshRateForOutputs(resources, outputs)
                     };
                 }
 
-                XFree(new IntPtr(monitors));
+                XRRFreeScreenResources(resources);
+                XRRFreeMonitors(monitors);
+
+                return _cache = screens;
+            }
+        }
+
+        private unsafe int GetSharedRefreshRateForOutputs(XRRScreenResources* resources, IntPtr[] outputs)
+        {
+            int? minRate = null;
+            foreach (var output in outputs)
+            {
+                var rate = GetRefreshRateForOutput(resources, output);
+                if (rate.HasValue)
+                    minRate = minRate.HasValue ? Math.Min(minRate.Value, rate.Value) : rate;
+            }
+
+            return minRate ?? AvaloniaX11Platform.DefaultFps;
+        }
+
+        private unsafe int? GetRefreshRateForOutput(XRRScreenResources* resources, IntPtr output)
+        {
+            // Check if output exists in resources
+            var foundOutput = false;
+            for (var c = 0; c < resources->noutput; c++)
+            {
+                if (resources->outputs[c] == output)
+                {
+                    foundOutput = true;
+                    break;
+                }
+            }
+
+            if (!foundOutput)
+                return null;
+
+            var outputInfo = XRRGetOutputInfo(_x11.Display, resources, output);
+            if (outputInfo == null)
+                return null;
+            try
+            {
+                if (outputInfo->crtc == IntPtr.Zero)
+                    return null;
+                var crtc = XRRGetCrtcInfo(_x11.Display, resources, outputInfo->crtc);
+                if (crtc == null)
+                    return null;
+                try
+                {
+                    if (crtc->mode == IntPtr.Zero)
+                        return null;
+                    for (var c = 0; c < resources->nmode; c++)
+                    {
+                        var mode = resources->modes[c];
+                        if (mode.id == crtc->mode)
+                        {
+                            var multiplier = 1d;
+                            if (mode.modeFlags.HasAnyFlag(RRModeFlags.RR_Interlace))
+                                multiplier *= 2;
+                            if (mode.modeFlags.HasAnyFlag(RRModeFlags.RR_DoubleScan))
+                                multiplier /= 2;
+                            if (mode.hTotal == 0 || mode.vTotal == 0 || mode.dotClock == 0)
+                                return null;
+                            var hz = mode.dotClock / ((double)mode.hTotal * mode.vTotal) * multiplier;
+                            return (int)Math.Round(hz, MidpointRounding.ToEven);
+                        }
+                    }
+                }
+                finally
+                {
+                    XRRFreeCrtcInfo(crtc);
+                }
+            }
+            finally
+            {
+                XRRFreeOutputInfo(outputInfo);
+            }
+
+            return null;
+        }
+        
+        private Size? GetPhysicalMonitorSizeFromFirstEligibleOutput(IntPtr[] outputs)
+        {
+            Size? pSize = null;
+            for (int o = 0; o < outputs.Length; o++)
+            {
+                var outputSize = GetPhysicalMonitorSizeFromEDID(outputs[o]);
+                if (outputSize != null)
+                {
+                    pSize = outputSize;
+                    break;
+                }
+            }
+
+            return pSize;
+        }
+        
+        private unsafe Size? GetPhysicalMonitorSizeFromEDID(IntPtr rrOutput)
+        {
+            if (rrOutput == IntPtr.Zero)
+                return null;
+            var properties = XRRListOutputPropertiesAsArray(_x11.Display, rrOutput);
+            var hasEDID = false;
+            for (var pc = 0; pc < properties.Length; pc++)
+            {
+                if (properties[pc] == _x11.Atoms.EDID)
+                    hasEDID = true;
+            }
+
+            if (!hasEDID)
+                return null;
+            
+            // Length of a EDID-Block-Length(128 bytes), XRRGetOutputProperty multiplies offset and length by 4
+            const int EDIDStructureLength = 32;
+            XRRGetOutputProperty(_x11.Display, rrOutput, _x11.Atoms.EDID, 0, EDIDStructureLength, false, false,
+                AnyPropertyType, out IntPtr actualType, out int actualFormat, out int bytesAfter, out _,
+                out IntPtr prop);
+            if (actualType != _x11.Atoms.INTEGER)
+                return null;
+            if (actualFormat != 8) // Expecting an byte array
+                return null;
+
+            var edid = new byte[bytesAfter];
+            Marshal.Copy(prop, edid, 0, bytesAfter);
+            XFree(prop);
+            if (edid.Length < 22)
+                return null;
+            var width = edid[21]; // 0x15 1 Max. Horizontal Image Size cm. 
+            var height = edid[22]; // 0x16 1 Max. Vertical Image Size cm. 
+            if (width == 0 && height == 0)
+                return null;
+            return new Size(width * 10, height * 10);
+        }
 
-                return screens;
+        public int MaxRefreshRate
+        {
+            get
+            {
+                var monitors = MonitorInfos;
+                return monitors.Length == 0 ? AvaloniaX11Platform.DefaultFps : monitors.Max(x => x.SharedRefreshRate);
             }
         }
 
diff --git a/src/Avalonia.X11/Screens/X11Screens.cs b/src/Avalonia.X11/Screens/X11Screens.cs
index cd6232b6f2..cde6337cfc 100644
--- a/src/Avalonia.X11/Screens/X11Screens.cs
+++ b/src/Avalonia.X11/Screens/X11Screens.cs
@@ -18,6 +18,10 @@ namespace Avalonia.X11.Screens
             _impl.Changed += OnChanged;
         }
 
+        internal int MaxRefreshRate => _impl is IX11RawScreenInfoProviderWithRefreshRate refreshProvider
+            ? Math.Max(AvaloniaX11Platform.DefaultFps, refreshProvider.MaxRefreshRate)
+            : AvaloniaX11Platform.DefaultFps;
+
         protected override int GetScreenCount() => _impl.ScreenKeys.Length;
 
         protected override IReadOnlyList<nint> GetAllScreenKeys() => _impl.ScreenKeys;
diff --git a/src/Avalonia.X11/X11Platform.cs b/src/Avalonia.X11/X11Platform.cs
index c043bf9bbf..85f3c63577 100644
--- a/src/Avalonia.X11/X11Platform.cs
+++ b/src/Avalonia.X11/X11Platform.cs
@@ -29,6 +29,8 @@ namespace Avalonia.X11
 {
     internal class AvaloniaX11Platform : IWindowingPlatform
     {
+        public const int DefaultFps = 60;
+
         private Lazy<KeyboardDevice> _keyboardDevice = new Lazy<KeyboardDevice>(() => new KeyboardDevice());
         private X11AtSpiAccessibility? _accessibility;
         internal AtSpiServer? AtSpiServer => _accessibility?.Server;
@@ -75,8 +77,8 @@ namespace Avalonia.X11
             Resources = new XResources(this);
 
             IRenderTimer timer = options.ShouldRenderOnUIThread
-               ? new UiThreadRenderTimer(60)
-               : new SleepLoopRenderTimer(60);
+               ? new UiThreadRenderTimer(DefaultFps)
+               : new SleepLoopRenderTimer(DefaultFps);
 
             var clipboardImpl = new X11ClipboardImpl(this);
             var clipboard = new Input.Platform.Clipboard(clipboardImpl);
@@ -101,6 +103,13 @@ namespace Avalonia.X11
                 .Bind<IPlatformLifetimeEventsImpl>().ToConstant(new X11PlatformLifetimeEvents(this));
             
             Screens = X11Screens = new X11Screens(this);
+
+            if (timer is SleepLoopRenderTimer loopTimer)
+            {
+                X11Screens.Changed += () => { loopTimer.DesiredFps = X11Screens.MaxRefreshRate; };
+                loopTimer.DesiredFps = X11Screens.MaxRefreshRate;
+            }
+            
             if (Info.XInputVersion != null)
             {
                 XI2 = XI2Manager.TryCreate(this);
diff --git a/src/Avalonia.X11/X11Structs.cs b/src/Avalonia.X11/X11Structs.cs
index 1682ad4bb5..e15dcc5499 100644
--- a/src/Avalonia.X11/X11Structs.cs
+++ b/src/Avalonia.X11/X11Structs.cs
@@ -1907,5 +1907,90 @@ namespace Avalonia.X11 {
         public int MWidth;
         public int MHeight;
         public IntPtr* Outputs;
-    } 
+    }
+
+    internal unsafe struct XRRScreenResources
+    {
+	    public long timestamp;
+	    public long configTimestamp;
+	    public int ncrtc;
+	    public IntPtr crtcs;
+	    public int noutput;
+	    public  IntPtr* outputs;
+	    public int nmode;
+	    public XRRModeInfo* modes;
+    }
+
+    [Flags]
+    enum RRModeFlags : ulong
+    {
+	    RR_HSyncPositive = 0x00000001,
+	    RR_HSyncNegative = 0x00000002,
+	    RR_VSyncPositive = 0x00000004,
+	    RR_VSyncNegative = 0x00000008,
+	    RR_Interlace = 0x00000010,
+	    RR_DoubleScan = 0x00000020,
+	    RR_CSync = 0x00000040,
+	    RR_CSyncPositive = 0x00000080,
+	    RR_CSyncNegative = 0x00000100,
+	    RR_HSkewPresent = 0x00000200,
+	    RR_BCast = 0x00000400,
+	    RR_PixelMultiplex = 0x00000800,
+	    RR_DoubleClock = 0x00001000,
+	    RR_ClockDivideBy2 = 0x00002000,
+    }
+
+    internal unsafe struct XRRModeInfo
+    {
+	    public IntPtr id;
+	    public uint width;
+	    public uint height;
+	    public ulong dotClock;
+	    public uint hSyncStart;
+	    public uint hSyncEnd;
+	    public uint hTotal;
+	    public uint hSkew;
+	    public uint vSyncStart;
+	    public uint vSyncEnd;
+	    public uint vTotal;
+	    public byte* name;
+	    public uint nameLength;
+	    public RRModeFlags modeFlags;
+    }
+
+    internal unsafe struct XRROutputInfo
+    {
+	    public long timestamp;
+	    public IntPtr crtc;
+	    public char* name;
+	    public int nameLen;
+	    public long mm_width;
+	    public long mm_height;
+	    public ushort connection;
+	    public ushort subpixel_order;
+	    public int ncrtc;
+	    public IntPtr* crtcs;
+	    public int nclone;
+	    public IntPtr* clones;
+	    public int nmode;
+	    public int npreferred;
+	    public IntPtr* modes;
+    }
+
+    internal unsafe struct XRRCrtcInfo
+    {
+	    public ulong timestamp;
+	    public int x, y;
+	    public uint width, height;
+	    public IntPtr mode;
+	    public ushort rotation;
+	    public int noutput;
+	    public IntPtr* outputs;
+	    public ushort rotations;
+	    public int npossible;
+	    public IntPtr* possible;
+    }
+
+
+
 }
diff --git a/src/Avalonia.X11/XLib.Helpers.cs b/src/Avalonia.X11/XLib.Helpers.cs
index b32d5e3b26..7fb90e4595 100644
--- a/src/Avalonia.X11/XLib.Helpers.cs
+++ b/src/Avalonia.X11/XLib.Helpers.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace Avalonia.X11;
@@ -26,4 +27,13 @@ internal static partial class XLib
             XFree(prop);
         }
     }
+
+    public static unsafe IntPtr[] XRRListOutputPropertiesAsArray(IntPtr display, IntPtr output)
+    {
+        var pList = XRRListOutputProperties(display, output, out int propertyCount);
+        var rv = new IntPtr[propertyCount];
+        new Span<IntPtr>(pList, propertyCount).CopyTo(rv);
+        XFree(pList);
+        return rv;
+    }
 }
\ No newline at end of file
diff --git a/src/Avalonia.X11/XLib.cs b/src/Avalonia.X11/XLib.cs
index 0b663d7a1b..cdede39624 100644
--- a/src/Avalonia.X11/XLib.cs
+++ b/src/Avalonia.X11/XLib.cs
@@ -612,6 +612,27 @@ namespace Avalonia.X11
         [DllImport(libX11Randr)]
         public static extern XRRMonitorInfo*
             XRRGetMonitors(IntPtr dpy, IntPtr window, bool get_active, out int nmonitors);
+        
+        [DllImport(libX11Randr)]
+        public static extern void XRRFreeMonitors(XRRMonitorInfo* monitors);
+        
+        [DllImport(libX11Randr)]
+        public static extern XRRScreenResources * XRRGetScreenResources (IntPtr dpy, IntPtr window);
+
+        [DllImport(libX11Randr)]
+        public static extern void XRRFreeScreenResources(XRRScreenResources* resources);
+        
+        [DllImport(libX11Randr)]
+        public static extern XRROutputInfo * XRRGetOutputInfo (IntPtr dpy, XRRScreenResources *resources, IntPtr output);
+
+        [DllImport(libX11Randr)]
+        public static extern void XRRFreeOutputInfo(XRROutputInfo* outputInfo);
+
+        [DllImport(libX11Randr)]
+        public static extern XRRCrtcInfo* XRRGetCrtcInfo(IntPtr dpy, XRRScreenResources* resources, IntPtr crtc);
+
+        [DllImport(libX11Randr)]
+        public static extern void XRRFreeCrtcInfo(XRRCrtcInfo* crtcInfo);
 
         [DllImport(libX11Randr)]
         public static extern IntPtr* XRRListOutputProperties(IntPtr dpy, IntPtr output, out int count);

From 9691b4e386c756f95de55bd99bdbb99eb32997b6 Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Wed, 24 Jun 2026 15:29:40 +0000
Subject: [PATCH 050/196] android - use BCL storage api for TryGet api (#21641)

---
 .../Platform/Storage/AndroidStorageProvider.cs  | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs b/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
index b1fc61684f..c64431a034 100644
--- a/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
+++ b/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
@@ -65,7 +65,7 @@ internal class AndroidStorageProvider : IStorageProvider
         var javaFile = new JavaFile(androidUriPath);
         if (javaFile.Exists() && javaFile.IsFile)
         {
-            return new AndroidStorageFile(_activity, androidUri);
+            return new BclStorageFile(new System.IO.FileInfo(javaFile.AbsolutePath));
         }
 
         return null;
@@ -92,7 +92,7 @@ internal class AndroidStorageProvider : IStorageProvider
         var javaFile = new JavaFile(androidUriPath);
         if (javaFile.Exists() && javaFile.IsDirectory)
         {
-            return new AndroidStorageFolder(_activity, androidUri, false);
+            return new BclStorageFolder(new System.IO.DirectoryInfo(javaFile.AbsolutePath));
         }
 
         return null;
@@ -121,16 +121,9 @@ internal class AndroidStorageProvider : IStorageProvider
             return Task.FromResult<IStorageFolder?>(null);
         }
 
-        var uri = AndroidUri.FromFile(dir);
-        if (uri is null)
-        {
-            return Task.FromResult<IStorageFolder?>(null);
-        }
-
-        // To make TryGetWellKnownFolder API easier to use, we don't check for the permissions.
-        // It will work with file picker activities, but it will fail on any direct access to the folder, like getting list of children.
-        // We pass "needsExternalFilesPermission" parameter here, so folder itself can check for permissions on any FS access. 
-        return Task.FromResult<IStorageFolder?>(new WellKnownAndroidStorageFolder(_activity, dirCode, uri, true));
+        // From Android 10(API 29), WellKnownFolders points to the app's external files directories, rather than the system's.
+        // These paths can be access directly using File apis without need to go though the ContextResolver or requesting permissions.
+        return Task.FromResult<IStorageFolder?>(new BclStorageFolder(new System.IO.DirectoryInfo(dir.AbsolutePath)));
     }
 
     public Task<IStorageBookmarkFile?> OpenFileBookmarkAsync(string bookmark)

From 9547beef87930d4219497f4c668a996f3023a933 Mon Sep 17 00:00:00 2001
From: Tim Miller <drasticactions@users.noreply.github.com>
Date: Thu, 25 Jun 2026 17:12:31 +0900
Subject: [PATCH 051/196] Add Scrollbar Context Menu (#19413)

* Scroll Bar Context Menu V1

* Add resource files

* Use InvariantResources file

* Add Unit Tests

* Refactor to XAML

* Add pointer type

* Add tests
---
 .../Input/ContextRequestedEventArgs.cs        |   2 +
 src/Avalonia.Controls/Primitives/ScrollBar.cs | 111 +++++++++
 .../Controls/ScrollBar.xaml                   |  28 +++
 .../Strings/InvariantResources.xaml           |  13 +
 .../Controls/ScrollBar.xaml                   |  28 +++
 .../Primitives/ScrollBarTests.cs              | 222 ++++++++++++++++++
 6 files changed, 404 insertions(+)

diff --git a/src/Avalonia.Base/Input/ContextRequestedEventArgs.cs b/src/Avalonia.Base/Input/ContextRequestedEventArgs.cs
index e9e23d817c..6550b3fa62 100644
--- a/src/Avalonia.Base/Input/ContextRequestedEventArgs.cs
+++ b/src/Avalonia.Base/Input/ContextRequestedEventArgs.cs
@@ -67,5 +67,7 @@ namespace Avalonia.Input
         }
 
         internal bool IsHolding => _holdRoutedEventArgs != null;
+
+        internal PointerType? PointerType => _pointerEventArgs?.Pointer.Type;
     }
 }
diff --git a/src/Avalonia.Controls/Primitives/ScrollBar.cs b/src/Avalonia.Controls/Primitives/ScrollBar.cs
index 89dcb9a8d4..6044777a40 100644
--- a/src/Avalonia.Controls/Primitives/ScrollBar.cs
+++ b/src/Avalonia.Controls/Primitives/ScrollBar.cs
@@ -5,6 +5,7 @@ using Avalonia.Input;
 using Avalonia.Layout;
 using Avalonia.Threading;
 using Avalonia.Controls.Metadata;
+using Avalonia.Controls.Templates;
 using Avalonia.Automation.Peers;
 using Avalonia.VisualTree;
 using Avalonia.Reactive;
@@ -86,6 +87,7 @@ namespace Avalonia.Controls.Primitives
         private CompositeDisposable? _ownerSubscriptions;
         private ScrollViewer? _owner;
         private bool _isDragging;
+        private Point _lastRightClickPosition;
 
         /// <summary>
         /// Initializes static members of the <see cref="ScrollBar"/> class. 
@@ -105,6 +107,7 @@ namespace Avalonia.Controls.Primitives
         public ScrollBar()
         {
             UpdatePseudoClasses(Orientation);
+            ContextRequested += OnContextRequested;
         }
 
         /// <summary>
@@ -521,5 +524,113 @@ namespace Avalonia.Controls.Primitives
             PseudoClasses.Set(":vertical", o == Orientation.Vertical);
             PseudoClasses.Set(":horizontal", o == Orientation.Horizontal);
         }
+
+        protected override void OnPointerPressed(PointerPressedEventArgs e)
+        {
+            base.OnPointerPressed(e);
+
+            if (e.GetCurrentPoint(this).Properties.IsRightButtonPressed)
+            {
+                _lastRightClickPosition = e.GetPosition(this);
+            }
+        }
+
+        private void OnContextRequested(object? sender, ContextRequestedEventArgs e)
+        {
+            if (e.PointerType is PointerType.Touch or PointerType.Pen)
+            {
+                e.Handled = true;
+                return;
+            }
+
+            if (e.TryGetPosition(this, out var position))
+            {
+                _lastRightClickPosition = position;
+            }
+        }
+
+        /// <summary>
+        /// Scrolls to the location at which the context menu was most recently requested.
+        /// </summary>
+        public void ScrollHere()
+        {
+            if (Track is not { } track)
+            {
+                return;
+            }
+
+            var trackLength = Orientation == Orientation.Vertical ? track.Bounds.Height : track.Bounds.Width;
+            var thumbLength = Orientation == Orientation.Vertical ? track.Thumb?.Bounds.Height ?? 0 : track.Thumb?.Bounds.Width ?? 0;
+            var clickPosition = Orientation == Orientation.Vertical ? _lastRightClickPosition.Y : _lastRightClickPosition.X;
+
+            if (trackLength > thumbLength)
+            {
+                var ratio = clickPosition / trackLength;
+                var range = Maximum - Minimum;
+                var value = Minimum + (ratio * range);
+                SetCurrentValue(ValueProperty, Math.Max(Minimum, Math.Min(Maximum, value)));
+                OnScroll(ScrollEventType.ThumbTrack);
+            }
+        }
+
+        /// <summary>
+        /// Scrolls to the top (or left edge) of the scrollbar by setting <see cref="RangeBase.Value"/> to <see cref="RangeBase.Minimum"/>.
+        /// </summary>
+        public void ScrollToHome()
+        {
+            SetCurrentValue(ValueProperty, Minimum);
+            OnScroll(ScrollEventType.SmallDecrement);
+        }
+
+        /// <summary>
+        /// Scrolls to the bottom (or right edge) of the scrollbar by setting <see cref="RangeBase.Value"/> to <see cref="RangeBase.Maximum"/>.
+        /// </summary>
+        public void ScrollToEnd()
+        {
+            SetCurrentValue(ValueProperty, Maximum);
+            OnScroll(ScrollEventType.SmallIncrement);
+        }
+
+        /// <summary>
+        /// Scrolls up by one <see cref="RangeBase.LargeChange"/> (a page) on a vertical scrollbar.
+        /// </summary>
+        public void PageUp() => LargeDecrement();
+
+        /// <summary>
+        /// Scrolls down by one <see cref="RangeBase.LargeChange"/> (a page) on a vertical scrollbar.
+        /// </summary>
+        public void PageDown() => LargeIncrement();
+
+        /// <summary>
+        /// Scrolls left by one <see cref="RangeBase.LargeChange"/> (a page) on a horizontal scrollbar.
+        /// </summary>
+        public void PageLeft() => LargeDecrement();
+
+        /// <summary>
+        /// Scrolls right by one <see cref="RangeBase.LargeChange"/> (a page) on a horizontal scrollbar.
+        /// </summary>
+        public void PageRight() => LargeIncrement();
+
+        /// <summary>
+        /// Scrolls up by one <see cref="RangeBase.SmallChange"/> on a vertical scrollbar.
+        /// </summary>
+        public void LineUp() => SmallDecrement();
+
+        /// <summary>
+        /// Scrolls down by one <see cref="RangeBase.SmallChange"/> on a vertical scrollbar.
+        /// </summary>
+        public void LineDown() => SmallIncrement();
+
+        /// <summary>
+        /// Scrolls left by one <see cref="RangeBase.SmallChange"/> on a horizontal scrollbar.
+        /// </summary>
+        public void LineLeft() => SmallDecrement();
+
+        /// <summary>
+        /// Scrolls right by one <see cref="RangeBase.SmallChange"/> on a horizontal scrollbar.
+        /// </summary>
+        public void LineRight() => SmallIncrement();
+
+        private Track? Track => this.GetTemplateDescendants().OfType<Track>().FirstOrDefault();
     }
 }
diff --git a/src/Avalonia.Themes.Fluent/Controls/ScrollBar.xaml b/src/Avalonia.Themes.Fluent/Controls/ScrollBar.xaml
index 8af22dd0b9..69a632ddb5 100644
--- a/src/Avalonia.Themes.Fluent/Controls/ScrollBar.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/ScrollBar.xaml
@@ -18,6 +18,32 @@
     </Border>
   </Design.PreviewWith>
 
+  <MenuFlyout x:Key="VerticalScrollBarContextFlyout">
+    <MenuItem Header="{DynamicResource StringScrollBarScrollHere}" Command="{Binding $parent[ScrollBar].ScrollHere}" AutomationProperties.AutomationId="ScrollHere" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarTop}" Command="{Binding $parent[ScrollBar].ScrollToHome}" AutomationProperties.AutomationId="Top" />
+    <MenuItem Header="{DynamicResource StringScrollBarBottom}" Command="{Binding $parent[ScrollBar].ScrollToEnd}" AutomationProperties.AutomationId="Bottom" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarPageUp}" Command="{Binding $parent[ScrollBar].PageUp}" AutomationProperties.AutomationId="PageUp" />
+    <MenuItem Header="{DynamicResource StringScrollBarPageDown}" Command="{Binding $parent[ScrollBar].PageDown}" AutomationProperties.AutomationId="PageDown" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarScrollUp}" Command="{Binding $parent[ScrollBar].LineUp}" AutomationProperties.AutomationId="ScrollUp" />
+    <MenuItem Header="{DynamicResource StringScrollBarScrollDown}" Command="{Binding $parent[ScrollBar].LineDown}" AutomationProperties.AutomationId="ScrollDown" />
+  </MenuFlyout>
+
+  <MenuFlyout x:Key="HorizontalScrollBarContextFlyout">
+    <MenuItem Header="{DynamicResource StringScrollBarScrollHere}" Command="{Binding $parent[ScrollBar].ScrollHere}" AutomationProperties.AutomationId="ScrollHere" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarLeftEdge}" Command="{Binding $parent[ScrollBar].ScrollToHome}" AutomationProperties.AutomationId="LeftEdge" />
+    <MenuItem Header="{DynamicResource StringScrollBarRightEdge}" Command="{Binding $parent[ScrollBar].ScrollToEnd}" AutomationProperties.AutomationId="RightEdge" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarPageLeft}" Command="{Binding $parent[ScrollBar].PageLeft}" AutomationProperties.AutomationId="PageLeft" />
+    <MenuItem Header="{DynamicResource StringScrollBarPageRight}" Command="{Binding $parent[ScrollBar].PageRight}" AutomationProperties.AutomationId="PageRight" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarScrollLeft}" Command="{Binding $parent[ScrollBar].LineLeft}" AutomationProperties.AutomationId="ScrollLeft" />
+    <MenuItem Header="{DynamicResource StringScrollBarScrollRight}" Command="{Binding $parent[ScrollBar].LineRight}" AutomationProperties.AutomationId="ScrollRight" />
+  </MenuFlyout>
+
   <ControlTheme x:Key="FluentScrollBarThumb" TargetType="Thumb">
     <Setter Property="Background" Value="{DynamicResource ScrollBarPanningThumbBackground}"/>
     <Setter Property="Template">
@@ -111,6 +137,7 @@
     <Setter Property="BorderBrush" Value="{DynamicResource ScrollBarBorderBrush}" />
 
     <Style Selector="^:vertical">
+      <Setter Property="ContextFlyout" Value="{StaticResource VerticalScrollBarContextFlyout}" />
       <Setter Property="Template">
         <ControlTemplate>
           <Grid x:Name="Root">
@@ -194,6 +221,7 @@
     </Style>
 
     <Style Selector="^:horizontal">
+      <Setter Property="ContextFlyout" Value="{StaticResource HorizontalScrollBarContextFlyout}" />
       <Setter Property="Template">
         <ControlTemplate>
           <Grid x:Name="Root">
diff --git a/src/Avalonia.Themes.Fluent/Strings/InvariantResources.xaml b/src/Avalonia.Themes.Fluent/Strings/InvariantResources.xaml
index 2e7c1687e9..a540e8c119 100644
--- a/src/Avalonia.Themes.Fluent/Strings/InvariantResources.xaml
+++ b/src/Avalonia.Themes.Fluent/Strings/InvariantResources.xaml
@@ -25,5 +25,18 @@
   <x:String x:Key="StringManagedFileChooserOverwritePromptFileAlreadyExistsText">{0} already exists. Do you want to replace it?</x:String>
   <x:String x:Key="StringManagedFileChooserOverwritePromptConfirmText">Yes</x:String>
   <x:String x:Key="StringManagedFileChooserOverwritePromptCancelText">No</x:String>
+  <x:String x:Key="StringScrollBarScrollHere">Scroll Here</x:String>
+  <x:String x:Key="StringScrollBarTop">Top</x:String>
+  <x:String x:Key="StringScrollBarBottom">Bottom</x:String>
+  <x:String x:Key="StringScrollBarPageUp">Page Up</x:String>
+  <x:String x:Key="StringScrollBarPageDown">Page Down</x:String>
+  <x:String x:Key="StringScrollBarScrollUp">Scroll Up</x:String>
+  <x:String x:Key="StringScrollBarScrollDown">Scroll Down</x:String>
+  <x:String x:Key="StringScrollBarLeftEdge">Left Edge</x:String>
+  <x:String x:Key="StringScrollBarRightEdge">Right Edge</x:String>
+  <x:String x:Key="StringScrollBarPageLeft">Page Left</x:String>
+  <x:String x:Key="StringScrollBarPageRight">Page Right</x:String>
+  <x:String x:Key="StringScrollBarScrollLeft">Scroll Left</x:String>
+  <x:String x:Key="StringScrollBarScrollRight">Scroll Right</x:String>
 </ResourceDictionary>
 
diff --git a/src/Avalonia.Themes.Simple/Controls/ScrollBar.xaml b/src/Avalonia.Themes.Simple/Controls/ScrollBar.xaml
index a7f11ec24c..733c845488 100644
--- a/src/Avalonia.Themes.Simple/Controls/ScrollBar.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/ScrollBar.xaml
@@ -1,11 +1,38 @@
 <ResourceDictionary xmlns="https://github.com/avaloniaui"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                     x:ClassModifier="internal">
+  <MenuFlyout x:Key="SimpleVerticalScrollBarContextFlyout">
+    <MenuItem Header="{DynamicResource StringScrollBarScrollHere}" Command="{Binding $parent[ScrollBar].ScrollHere}" AutomationProperties.AutomationId="ScrollHere" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarTop}" Command="{Binding $parent[ScrollBar].ScrollToHome}" AutomationProperties.AutomationId="Top" />
+    <MenuItem Header="{DynamicResource StringScrollBarBottom}" Command="{Binding $parent[ScrollBar].ScrollToEnd}" AutomationProperties.AutomationId="Bottom" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarPageUp}" Command="{Binding $parent[ScrollBar].PageUp}" AutomationProperties.AutomationId="PageUp" />
+    <MenuItem Header="{DynamicResource StringScrollBarPageDown}" Command="{Binding $parent[ScrollBar].PageDown}" AutomationProperties.AutomationId="PageDown" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarScrollUp}" Command="{Binding $parent[ScrollBar].LineUp}" AutomationProperties.AutomationId="ScrollUp" />
+    <MenuItem Header="{DynamicResource StringScrollBarScrollDown}" Command="{Binding $parent[ScrollBar].LineDown}" AutomationProperties.AutomationId="ScrollDown" />
+  </MenuFlyout>
+
+  <MenuFlyout x:Key="SimpleHorizontalScrollBarContextFlyout">
+    <MenuItem Header="{DynamicResource StringScrollBarScrollHere}" Command="{Binding $parent[ScrollBar].ScrollHere}" AutomationProperties.AutomationId="ScrollHere" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarLeftEdge}" Command="{Binding $parent[ScrollBar].ScrollToHome}" AutomationProperties.AutomationId="LeftEdge" />
+    <MenuItem Header="{DynamicResource StringScrollBarRightEdge}" Command="{Binding $parent[ScrollBar].ScrollToEnd}" AutomationProperties.AutomationId="RightEdge" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarPageLeft}" Command="{Binding $parent[ScrollBar].PageLeft}" AutomationProperties.AutomationId="PageLeft" />
+    <MenuItem Header="{DynamicResource StringScrollBarPageRight}" Command="{Binding $parent[ScrollBar].PageRight}" AutomationProperties.AutomationId="PageRight" />
+    <Separator />
+    <MenuItem Header="{DynamicResource StringScrollBarScrollLeft}" Command="{Binding $parent[ScrollBar].LineLeft}" AutomationProperties.AutomationId="ScrollLeft" />
+    <MenuItem Header="{DynamicResource StringScrollBarScrollRight}" Command="{Binding $parent[ScrollBar].LineRight}" AutomationProperties.AutomationId="ScrollRight" />
+  </MenuFlyout>
+
   <ControlTheme x:Key="{x:Type ScrollBar}"
                 TargetType="ScrollBar">
     <Setter Property="Cursor" Value="Arrow" />
 
     <Style Selector="^:horizontal">
+      <Setter Property="ContextFlyout" Value="{StaticResource SimpleHorizontalScrollBarContextFlyout}" />
       <Setter Property="Height" Value="{DynamicResource ScrollBarThickness}" />
       <Setter Property="Template">
         <ControlTemplate>
@@ -62,6 +89,7 @@
       </Setter>
     </Style>
     <Style Selector="^:vertical">
+      <Setter Property="ContextFlyout" Value="{StaticResource SimpleVerticalScrollBarContextFlyout}" />
       <Setter Property="Width" Value="{DynamicResource ScrollBarThickness}" />
       <Setter Property="Template">
         <ControlTemplate>
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs
index b6bfab09cc..81b03d7863 100644
--- a/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs
@@ -1,8 +1,10 @@
 using System;
 using System.Linq;
+using Avalonia.Automation;
 using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Templates;
 using Avalonia.Input;
+using Avalonia.Layout;
 using Avalonia.Media;
 using Avalonia.UnitTests;
 using Xunit;
@@ -194,5 +196,225 @@ namespace Avalonia.Controls.UnitTests.Primitives
                 Background = Brushes.Gray,
             };
         }
+
+        [Theory]
+        [InlineData(Orientation.Vertical)]
+        [InlineData(Orientation.Horizontal)]
+        public void Orientation_Should_Set_Matching_PseudoClass(Orientation orientation)
+        {
+            var target = new ScrollBar { Orientation = orientation };
+
+            Assert.Equal(orientation == Orientation.Vertical, target.Classes.Contains(":vertical"));
+            Assert.Equal(orientation == Orientation.Horizontal, target.Classes.Contains(":horizontal"));
+        }
+
+        [Fact]
+        public void ScrollToHome_Should_Set_Value_To_Minimum()
+        {
+            var target = CreateScrollBar(minimum: 10, maximum: 100, value: 50);
+
+            target.ScrollToHome();
+
+            Assert.Equal(10, target.Value);
+        }
+
+        [Fact]
+        public void ScrollToEnd_Should_Set_Value_To_Maximum()
+        {
+            var target = CreateScrollBar(minimum: 0, maximum: 90, value: 50);
+
+            target.ScrollToEnd();
+
+            Assert.Equal(90, target.Value);
+        }
+
+        [Fact]
+        public void PageUp_Should_Decrease_Value_By_LargeChange()
+        {
+            var target = CreateScrollBar(value: 50, largeChange: 10);
+
+            target.PageUp();
+
+            Assert.Equal(40, target.Value);
+        }
+
+        [Fact]
+        public void PageDown_Should_Increase_Value_By_LargeChange()
+        {
+            var target = CreateScrollBar(value: 50, largeChange: 10);
+
+            target.PageDown();
+
+            Assert.Equal(60, target.Value);
+        }
+
+        [Fact]
+        public void PageLeft_Should_Decrease_Value_By_LargeChange()
+        {
+            var target = CreateScrollBar(orientation: Orientation.Horizontal, value: 50, largeChange: 10);
+
+            target.PageLeft();
+
+            Assert.Equal(40, target.Value);
+        }
+
+        [Fact]
+        public void PageRight_Should_Increase_Value_By_LargeChange()
+        {
+            var target = CreateScrollBar(orientation: Orientation.Horizontal, value: 50, largeChange: 10);
+
+            target.PageRight();
+
+            Assert.Equal(60, target.Value);
+        }
+
+        [Fact]
+        public void LineUp_Should_Decrease_Value_By_SmallChange()
+        {
+            var target = CreateScrollBar(value: 50, smallChange: 5);
+
+            target.LineUp();
+
+            Assert.Equal(45, target.Value);
+        }
+
+        [Fact]
+        public void LineDown_Should_Increase_Value_By_SmallChange()
+        {
+            var target = CreateScrollBar(value: 50, smallChange: 5);
+
+            target.LineDown();
+
+            Assert.Equal(55, target.Value);
+        }
+
+        [Fact]
+        public void LineLeft_Should_Decrease_Value_By_SmallChange()
+        {
+            var target = CreateScrollBar(orientation: Orientation.Horizontal, value: 50, smallChange: 5);
+
+            target.LineLeft();
+
+            Assert.Equal(45, target.Value);
+        }
+
+        [Fact]
+        public void LineRight_Should_Increase_Value_By_SmallChange()
+        {
+            var target = CreateScrollBar(orientation: Orientation.Horizontal, value: 50, smallChange: 5);
+
+            target.LineRight();
+
+            Assert.Equal(55, target.Value);
+        }
+
+        [Fact]
+        public void Scroll_Methods_Should_Respect_Value_Bounds()
+        {
+            var target = CreateScrollBar(minimum: 20, maximum: 80, value: 25, smallChange: 10);
+
+            target.LineUp();
+            Assert.Equal(20, target.Value); // Should not go below Minimum
+
+            target.Value = 75;
+            target.LineDown();
+            Assert.Equal(80, target.Value); // Should not go above Maximum
+        }
+
+        [Fact]
+        public void Scroll_Methods_Should_Raise_Scroll_Event()
+        {
+            var target = CreateScrollBar(value: 50, smallChange: 5, largeChange: 10);
+            var events = new System.Collections.Generic.List<ScrollEventType>();
+            target.Scroll += (_, e) => events.Add(e.ScrollEventType);
+
+            target.LineDown();
+            target.PageDown();
+            target.ScrollToHome();
+            target.ScrollToEnd();
+
+            Assert.Equal(
+                new[]
+                {
+                    ScrollEventType.SmallIncrement,
+                    ScrollEventType.LargeIncrement,
+                    ScrollEventType.SmallDecrement,
+                    ScrollEventType.SmallIncrement,
+                },
+                events);
+        }
+
+        [Fact]
+        public void ScrollHere_Should_Set_Value_Within_Bounds()
+        {
+            var target = CreateScrollBar(minimum: 0, maximum: 100, value: 0);
+
+            // No exception even though no pointer position was recorded yet.
+            target.ScrollHere();
+
+            Assert.InRange(target.Value, target.Minimum, target.Maximum);
+        }
+
+        [Theory]
+        [InlineData(PointerType.Touch)]
+        [InlineData(PointerType.Pen)]
+        public void ContextRequested_Should_Be_Handled_For_Touch_Or_Pen_Input(PointerType pointerType)
+        {
+            var target = CreateScrollBar();
+
+            var args = CreateContextRequested(target, pointerType);
+            target.RaiseEvent(args);
+
+            Assert.True(args.Handled);
+        }
+
+        [Fact]
+        public void ContextRequested_Should_Not_Be_Handled_For_Mouse_Input()
+        {
+            var target = CreateScrollBar();
+
+            var args = CreateContextRequested(target, PointerType.Mouse);
+            target.RaiseEvent(args);
+
+            Assert.False(args.Handled);
+        }
+
+        private static ContextRequestedEventArgs CreateContextRequested(ScrollBar target, PointerType pointerType)
+        {
+            var pointer = new Pointer(Pointer.GetNextFreeId(), pointerType, true);
+            var pointerArgs = new PointerPressedEventArgs(
+                target,
+                pointer,
+                target,
+                default,
+                timestamp: 1,
+                new PointerPointProperties(RawInputModifiers.None, PointerUpdateKind.Other),
+                KeyModifiers.None);
+
+            return new ContextRequestedEventArgs(pointerArgs);
+        }
+
+        private static ScrollBar CreateScrollBar(
+            Orientation orientation = Orientation.Vertical,
+            double minimum = 0,
+            double maximum = 100,
+            double value = 0,
+            double smallChange = 1,
+            double largeChange = 10)
+        {
+            var target = new ScrollBar
+            {
+                Orientation = orientation,
+                Template = new FuncControlTemplate<ScrollBar>(Template),
+                Minimum = minimum,
+                Maximum = maximum,
+                Value = value,
+                SmallChange = smallChange,
+                LargeChange = largeChange,
+            };
+
+            target.ApplyTemplate();
+            return target;
+        }
     }
 }

From dab62c09d29f18772b82b3933f54d1216db4ed18 Mon Sep 17 00:00:00 2001
From: Isabelle Santin <isabelle@chosenfewsoftware.com>
Date: Thu, 25 Jun 2026 04:36:36 -0500
Subject: [PATCH 052/196] Fix: Android TalkBack should still respond to all
 hover events (#21644)

---
 src/Android/Avalonia.Android/AvaloniaView.Input.cs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/Android/Avalonia.Android/AvaloniaView.Input.cs b/src/Android/Avalonia.Android/AvaloniaView.Input.cs
index 413a21ba9c..dcf368c19f 100644
--- a/src/Android/Avalonia.Android/AvaloniaView.Input.cs
+++ b/src/Android/Avalonia.Android/AvaloniaView.Input.cs
@@ -28,8 +28,7 @@ namespace Avalonia.Android
         protected override bool DispatchHoverEvent(MotionEvent? e)
         {
             var res = _view.PointerHelper.DispatchMotionEvent(e, out var callBase);
-            if (res == false)
-                callBase = (_accessHelper?.DispatchHoverEvent(e!) == true) && callBase;
+            callBase = (_accessHelper?.DispatchHoverEvent(e!) == true) && callBase;
 
             var baseResult = callBase && base.DispatchHoverEvent(e);
 
@@ -50,7 +49,7 @@ namespace Avalonia.Android
             var result = _view.PointerHelper.DispatchMotionEvent(e, out var callBase);
             var baseResult = callBase && base.DispatchTouchEvent(e);
 
-            if(result == true)
+            if (result == true)
             {
                 // Request focus for this view
                 RequestFocus();

From 4bd9909d0fb91e9e6b11896c018d466ed7695fb1 Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Tue, 30 Jun 2026 07:23:39 +0000
Subject: [PATCH 053/196] Win32 - Support rendering at max refresh rate of
 current displays (#21643)

* win32 - support rendering at max refresh rate for current displays

* win32 - set max framerate floor to 60
---
 src/Avalonia.Base/Rendering/RenderLoop.cs      |  2 ++
 src/Windows/Avalonia.Win32/Win32Platform.cs    | 18 +++++++++++++++---
 .../Avalonia.Win32/WindowImpl.AppWndProc.cs    |  5 +++++
 3 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.Base/Rendering/RenderLoop.cs b/src/Avalonia.Base/Rendering/RenderLoop.cs
index 9af9c54443..ae46a16471 100644
--- a/src/Avalonia.Base/Rendering/RenderLoop.cs
+++ b/src/Avalonia.Base/Rendering/RenderLoop.cs
@@ -101,6 +101,8 @@ namespace Avalonia.Rendering
         /// <inheritdoc />
         public bool RunsInBackground => _timer.RunsInBackground;
 
+        internal IRenderTimer Timer => _timer;
+
         /// <inheritdoc />
         public void Wakeup()
         {
diff --git a/src/Windows/Avalonia.Win32/Win32Platform.cs b/src/Windows/Avalonia.Win32/Win32Platform.cs
index 7903a62d8f..6be81dd2d9 100644
--- a/src/Windows/Avalonia.Win32/Win32Platform.cs
+++ b/src/Windows/Avalonia.Win32/Win32Platform.cs
@@ -44,7 +44,7 @@ namespace Avalonia.Win32
         private static Win32PlatformOptions? s_options;
         private static Compositor? s_compositor;
         internal const int TIMERID_DISPATCHER = 1;
-
+        private const int DefaultFramesPerSecond = 60;
         private WndProc? _wndProcDelegate;
         private IntPtr _hwnd;
         private Win32DispatcherImpl _dispatcher;
@@ -87,7 +87,7 @@ namespace Avalonia.Win32
 
             Dispatcher.InitializeUIThreadDispatcher(s_instance._dispatcher);
             
-            var renderTimer = options.ShouldRenderOnUIThread ? new UiThreadRenderTimer(60) : new DefaultRenderTimer(60);
+            IRenderTimer renderTimer = options.ShouldRenderOnUIThread ? new UiThreadRenderTimer(DefaultFramesPerSecond) : new SleepLoopRenderTimer(DefaultFramesPerSecond);
             var clipboardImpl = new ClipboardImpl();
             var clipboard = new Clipboard(clipboardImpl);
 
@@ -133,7 +133,9 @@ namespace Avalonia.Win32
             
             if (OleContext.Current != null)
                 AvaloniaLocator.CurrentMutable.Bind<IPlatformDragSource>().ToSingleton<DragSource>();
-            
+
+            UpdateTimerFps();
+
             s_compositor = new Compositor( platformGraphics);
             AvaloniaLocator.CurrentMutable.Bind<Compositor>().ToConstant(s_compositor);
         }
@@ -196,6 +198,16 @@ namespace Avalonia.Win32
             return DefWindowProc(hWnd, msg, wParam, lParam);
         }
 
+        internal static void UpdateTimerFps()
+        {
+            var maxDisplayFrequency = Math.Max(60, Instance.Screen?.AllScreens?.Max(s => (s as WinScreen)?.Frequency) ?? 0);
+            if (AvaloniaLocator.Current.GetService<IRenderLoop>() is DefaultRenderLoop defaultRenderLoop &&
+                defaultRenderLoop.Timer is SleepLoopRenderTimer sleepLoopRenderTimer)
+            {
+                sleepLoopRenderTimer.DesiredFps = maxDisplayFrequency;
+            }
+        }
+
         private void CreateMessageWindow()
         {
             // Ensure that the delegate doesn't get garbage collected by storing it as a field.
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.AppWndProc.cs b/src/Windows/Avalonia.Win32/WindowImpl.AppWndProc.cs
index 42938620d9..f0140204a4 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.AppWndProc.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.AppWndProc.cs
@@ -1,11 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Runtime.InteropServices;
 using Avalonia.Automation.Peers;
 using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Input.Raw;
+using Avalonia.Rendering;
 using Avalonia.Threading;
 using Avalonia.Win32.Automation;
 using Avalonia.Win32.Automation.Interop;
@@ -873,6 +875,9 @@ namespace Avalonia.Win32
                 case WindowsMessage.WM_DISPLAYCHANGE:
                     {
                         Screen?.OnChanged();
+
+                        Win32Platform.UpdateTimerFps();
+
                         return IntPtr.Zero;
                     }
 

From 59b473f31ec5ee023d89261b7338b23d867b2632 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Tue, 30 Jun 2026 19:32:35 +0400
Subject: [PATCH 054/196] Added GLib event loop support to wayland backend
 (#21669)

---
 src/Avalonia.Wayland/Avalonia.Wayland.csproj  |   2 +
 src/Avalonia.Wayland/WaylandGlibDispatcher.cs |  19 ++
 src/Avalonia.Wayland/WaylandPlatform.cs       |   5 +-
 .../WaylandPlatformOptions.cs                 |  18 ++
 .../Dispatching/GLibDispatcherImpl.cs         | 264 +---------------
 .../Dispatching/GlibDispatcherImplBase.cs     | 289 ++++++++++++++++++
 6 files changed, 337 insertions(+), 260 deletions(-)
 create mode 100644 src/Avalonia.Wayland/WaylandGlibDispatcher.cs
 create mode 100644 src/Avalonia.X11/Dispatching/GlibDispatcherImplBase.cs

diff --git a/src/Avalonia.Wayland/Avalonia.Wayland.csproj b/src/Avalonia.Wayland/Avalonia.Wayland.csproj
index 2c9e941cac..4b4ebfece8 100644
--- a/src/Avalonia.Wayland/Avalonia.Wayland.csproj
+++ b/src/Avalonia.Wayland/Avalonia.Wayland.csproj
@@ -17,6 +17,8 @@
     <Compile Include="..\Shared\RawEventGrouping.cs" />
     <Compile Include="..\Avalonia.X11\X11IconLoader.cs" />
     <Compile Include="..\Avalonia.X11\Clipboard\ClipboardUriListHelper.cs" />
+    <Compile Include="..\Avalonia.X11\Interop\Glib.cs" Link="Dispatching\Glib.cs" />
+    <Compile Include="..\Avalonia.X11\Dispatching\GlibDispatcherImplBase.cs" Link="Dispatching\GlibDispatcherImplBase.cs" />
   </ItemGroup>
   <Import Project="..\..\build\SourceGenerators.props" />
   <Import Project="..\..\build\TrimmingEnable.props" />
diff --git a/src/Avalonia.Wayland/WaylandGlibDispatcher.cs b/src/Avalonia.Wayland/WaylandGlibDispatcher.cs
new file mode 100644
index 0000000000..a1d513d5c6
--- /dev/null
+++ b/src/Avalonia.Wayland/WaylandGlibDispatcher.cs
@@ -0,0 +1,19 @@
+using System;
+using Avalonia.X11.Dispatching;
+
+namespace Avalonia.Wayland;
+
+/// <summary>
+/// GLib (GMainLoop) based UI-thread dispatcher for the Wayland backend, enabled via
+/// <see cref="WaylandPlatformOptions.UseGLibMainLoop"/>. It lets Avalonia share a GLib main loop with GLib/GTK
+/// based libraries on the UI thread. Unlike X11 it attaches no platform event source of its own: the Wayland
+/// connection is owned and pumped by the worker thread, which posts input/events back via the dispatcher, so the
+/// base class' signaling/timer/background machinery is all the UI thread needs.
+/// </summary>
+internal sealed class WaylandGlibDispatcher : GlibDispatcherImplBase
+{
+    public WaylandGlibDispatcher(Action<Exception>? externalExceptionLogger)
+        : base(externalExceptionLogger)
+    {
+    }
+}
diff --git a/src/Avalonia.Wayland/WaylandPlatform.cs b/src/Avalonia.Wayland/WaylandPlatform.cs
index dc42c17b6a..01e608ef92 100644
--- a/src/Avalonia.Wayland/WaylandPlatform.cs
+++ b/src/Avalonia.Wayland/WaylandPlatform.cs
@@ -28,7 +28,10 @@ class WaylandPlatform
         // that force an X11 fallback when the compositor lacks them.
 
         var inputDispatchQueue = new AutomaticRawEventGrouperDispatchQueue();
-        Dispatcher.InitializeUIThreadDispatcher(new ManagedDispatcherImpl(null));
+        IDispatcherImpl dispatcherImpl = options.UseGLibMainLoop
+            ? new WaylandGlibDispatcher(options.ExternalGLibMainLoopExceptionLogger)
+            : new ManagedDispatcherImpl(null);
+        Dispatcher.InitializeUIThreadDispatcher(dispatcherImpl);
         
         var worker = new WaylandWorker(inputDispatchQueue);
 
diff --git a/src/Avalonia.Wayland/WaylandPlatformOptions.cs b/src/Avalonia.Wayland/WaylandPlatformOptions.cs
index 313b79e9e8..3c50426239 100644
--- a/src/Avalonia.Wayland/WaylandPlatformOptions.cs
+++ b/src/Avalonia.Wayland/WaylandPlatformOptions.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Avalonia.OpenGL;
@@ -72,4 +73,21 @@ public class WaylandPlatformOptions
     /// decides based on compositor and driver capabilities.
     /// </summary>
     public bool? UseDmabufSwapchain { get; set; }
+
+    /// <summary>
+    /// If this option is set to true, a GMainLoop and GSource based dispatcher implementation will be used for the
+    /// UI thread instead of the default managed one.
+    /// Use this if you need to use GLib-based libraries on the main thread.
+    /// </summary>
+    public bool UseGLibMainLoop { get; set; }
+
+    /// <summary>
+    /// If Avalonia is in control of a run loop, we propagate exceptions by stopping the run loop frame
+    /// and rethrowing an exception. However, if there is no Avalonia-controlled run loop frame,
+    /// there is no way to report such exceptions, since allowing those to escape native->managed call boundary
+    /// will likely brick GLib machinery since it's not aware of managed Exceptions.
+    /// This property allows to inspect such exceptions before they will be ignored.
+    /// Only used when <see cref="UseGLibMainLoop"/> is enabled.
+    /// </summary>
+    public Action<Exception>? ExternalGLibMainLoopExceptionLogger { get; set; }
 }
\ No newline at end of file
diff --git a/src/Avalonia.X11/Dispatching/GLibDispatcherImpl.cs b/src/Avalonia.X11/Dispatching/GLibDispatcherImpl.cs
index f3a73940fe..c39170c9ae 100644
--- a/src/Avalonia.X11/Dispatching/GLibDispatcherImpl.cs
+++ b/src/Avalonia.X11/Dispatching/GLibDispatcherImpl.cs
@@ -1,87 +1,15 @@
 using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Runtime.ExceptionServices;
 using System.Threading;
-using Avalonia.Logging;
-using Avalonia.Threading;
 using static Avalonia.X11.Interop.Glib;
 namespace Avalonia.X11.Dispatching;
 
-internal class GlibDispatcherImpl : 
-    IDispatcherImplWithExplicitBackgroundProcessing,
-    IControlledDispatcherImpl,
-    IX11PlatformDispatcher
+internal class GlibDispatcherImpl : GlibDispatcherImplBase, IX11PlatformDispatcher
 {
-    /*
-        GLib priorities and Avalonia priorities are a bit different. Avalonia follows the WPF model when there
-            are "background" and "foreground" priority groups. Foreground jobs are executed before any user input processing,
-            background jobs are executed strictly after user input processing.
-        
-        GLib has numeric priorities that are used in the following way:
-        -100    G_PRIORITY_HIGH - "high" priority sources, not really used by GLib/GTK
-        0       G_PRIORITY_DEFAULT - polling X11 events (GTK) and default value for g_timeout_add
-        100     G_PRIORITY_HIGH_IDLE without a clear definition, used as an anchor value of sorts
-        110     Resize/layout operations (GTK)
-        120     Render operations (GTK)
-        200     G_PRIORITY_DEFAULT_IDLE - "idle" priority sources
-        
-        So, unlike Avalonia, GTK puts way higher priority on input processing, then does resize/layout/render
-        
-        So, to map our model to GLib we do the following:
-        - foreground jobs (including grouped user events) are executed with (-1) priority (_before_ any normal GLib jobs)
-        - X11 socket is polled with G_PRIORITY_DEFAULT, all X11 events are read until socket is empty,
-            we also group input events at that stage (this matches our epoll-based dispatcher)
-        - background jobs are executed with G_PRIORITY_DEFAULT_IDLE, so they would have lower priority than GTK
-            foreground jobs
-        
-        Unfortunately we can't detect if there are pending _non-idle_ GLib jobs using g_main_context_pending, since
-        - g_main_context_pending doesn't accept max_priority argument
-        - even if it did, that would still involve a syscall to the kernel to poll for fds anyway
-        
-        So we just report that we don't support pending input query and let the dispatcher to 
-        call RequestBackgroundProcessing every time, which results in g_idle_add call for every background job.
-        Background jobs are expected to be relatively expensive to execute since on Windows 
-        MsgWaitForMultipleObjectsEx results isn't really free too.
-
-        For signaling (aka waking up dispatcher for processing _high_ priority jobs we are using
-        g_idle_add_full with (-1) priority. While the naming suggests that it would enqueue an idle job,
-        it actually adds an always-triggered source that would be called before other sources with lower priority.
-
-        For timers we are using a simple g_timeout_add_full and discard the previous one when dispatcher requests
-        an update
-        
-        Since GLib dispatches event sources in batches, we force-check for "signaled" flag to run high-prio jobs
-        whenever we get control back from GLib. We can still occasionally get GTK code to run before high-prio
-        Avalonia-jobs, but that should be fine since the point is to keep Avalonia-based jobs ordered properly
-        and to not have our low-priority jobs to prevent GLib-based code from running its own "foreground" jobs 
-
-        Another implementation note here is that GLib (just as any other C library) is NOT aware of C# exceptions,
-        so we are NOT allowed to have exceptions to escape native->managed call boundary. So we have exception handlers
-        that try to propagate those to the nearest run loop frame that was initiated by Avalonia.
-        
-        If there is no such frame, we have no choice but to log/swallow those
-     */
-    
     private readonly AvaloniaX11Platform _platform;
-    
-    // Note that we can't use g_main_context_is_owner outside a run loop, since context doesn't really have an
-    // inherent owner when run loop is not running and the context isn't explicitly "locked", so we just assume that
-    // the app author is initializing Avalonia on the intended UI thread and won't migrate the default run loop
-    // to a different thread
-    private readonly Thread _mainThread = Thread.CurrentThread;
-    
     private readonly X11EventDispatcher _x11Events;
-    private bool _signaled;
-    private bool _signaledSourceAdded;
-    private readonly object _signalLock = new();
-    private readonly Stack<ManagedLoopFrame> _runLoopStack = new();
-    
-    private readonly Stopwatch _stopwatch = Stopwatch.StartNew();
-    private uint? _glibTimerSourceTag;
 
     public GlibDispatcherImpl(AvaloniaX11Platform platform)
+        : base(platform.Options.ExternalGLibMainLoopExceptionLogger)
     {
         _platform = platform;
         _x11Events = new X11EventDispatcher(platform);
@@ -92,96 +20,14 @@ internal class GlibDispatcherImpl :
         g_source_set_can_recurse(unixFdSource, 1);
     }
 
-    public bool CurrentThreadIsLoopThread => _mainThread == Thread.CurrentThread;
-    
-    public event Action? Signaled;
-    public void Signal()
-    {
-        lock (_signalLock)
-        {
-            if(_signaled)
-                return;
-            _signaled = true;
-            if(_signaledSourceAdded)
-                return;
-            _signaledSourceAdded = true;
-        }
-        g_idle_add_full(G_PRIORITY_DEFAULT - 1, SignalSourceCallback);
-    }
+    protected override void Flush() => _x11Events.Flush();
 
-    private void CheckSignaled()
-    {
-        lock (_signalLock)
-        {
-            if (!_signaled)
-                return;
-            _signaled = false;
-        }
+    public override bool HasPendingInput => _platform.EventGrouperDispatchQueue.HasJobs || _x11Events.IsPending;
 
-        try
-        {
-            Signaled?.Invoke();
-        }
-        catch (Exception e)
-        {
-            HandleException(e);
-        }
-        _x11Events.Flush();
-    }
-    
-    private bool SignalSourceCallback()
-    {
-        lock (_signalLock)
-        {
-            _signaledSourceAdded = false;
-        }
-        CheckSignaled();
-        return false;
-    }
-    
-    public event Action? Timer;
-    public long Now => _stopwatch.ElapsedMilliseconds;
-    
-    public void UpdateTimer(long? dueTimeInMs)
-    {
-        if (_glibTimerSourceTag.HasValue)
-        {
-            g_source_remove(_glibTimerSourceTag.Value);
-            _glibTimerSourceTag = null;
-        }
-
-        if (dueTimeInMs == null)
-            return;
-
-        var interval = (uint)Math.Max(0, (int)Math.Min(int.MaxValue, dueTimeInMs.Value - Now));
-        _glibTimerSourceTag = g_timeout_add_once(interval, TimerCallback);
-    }
-    
-    private void TimerCallback()
-    {
-        try
-        {
-            Timer?.Invoke();
-        }
-        catch (Exception e)
-        {
-            HandleException(e);
-        }
-        _x11Events.Flush();
-    }
-    
-    public event Action? ReadyForBackgroundProcessing;
-
-    public void RequestBackgroundProcessing() =>
-        g_idle_add_once(() => ReadyForBackgroundProcessing?.Invoke());
-    
-    public bool CanQueryPendingInput => false;
-    public bool HasPendingInput => _platform.EventGrouperDispatchQueue.HasJobs || _x11Events.IsPending;
-    
     private bool X11SourceCallback(int i, GIOCondition gioCondition)
     {
         CheckSignaled();
-        var token = _runLoopStack.Count > 0 ? _runLoopStack.Peek().Cancelled : CancellationToken.None;
+        var token = CurrentLoopCancellation;
         try
         {
             // Completely drain X11 socket while we are at it
@@ -209,106 +55,6 @@ internal class GlibDispatcherImpl :
 
         return true;
     }
-    
-    public void RunLoop(CancellationToken token)
-    {
-        if(token.IsCancellationRequested)
-            return;
-
-        using var loop = new ManagedLoopFrame(token);
-        _runLoopStack.Push(loop);
-        loop.Run();
-        _runLoopStack.Pop();
-        
-        // Propagate any managed exceptions that we've captured from this frame
-        if(loop.Exceptions.Count == 1)
-            loop.Exceptions[0].Throw();
-        else if (loop.Exceptions.Count > 1)
-            throw new AggregateException(loop.Exceptions.Select(x => x.SourceException));
-    }
-
-    void HandleException(Exception e)
-    {
-        if (_runLoopStack.Count > 0)
-        {
-            var frame = _runLoopStack.Peek();
-            frame.Exceptions.Add(ExceptionDispatchInfo.Capture(e));
-            frame.Stop();
-        }
-        else
-        {
-            var externalLogger = _platform.Options.ExternalGLibMainLoopExceptionLogger;
-            if (externalLogger != null)
-                externalLogger.Invoke(e);
-            else
-                Logger.TryGet(LogEventLevel.Error, LogArea.Control)
-                    ?.Log("Dispatcher", "Unhandled exception: {exception}", e);
-        }
-    }
-    
-    private class ManagedLoopFrame : IDisposable
-    {
-        private readonly CancellationToken _externalToken;
-        private CancellationTokenSource? _internalTokenSource;
-        public CancellationToken Cancelled { get; private set; }
-        
-        private readonly IntPtr _loop = g_main_loop_new(IntPtr.Zero, 1);
-        public List<ExceptionDispatchInfo> Exceptions { get; } = new();
-        private readonly object _destroyLock = new();
-        private bool _disposed;
-
-        public ManagedLoopFrame(CancellationToken token)
-        {
-            _externalToken = token;
-        }
-
-        public void Stop()
-        {
-            try
-            {
-                _internalTokenSource?.Cancel();
-            }
-            catch
-            {
-                // Ignore
-            }
-        }
-
-        public void Run()
-        {
-            if (_externalToken.IsCancellationRequested)
-                return;
-            using (_internalTokenSource = new())
-            using (var composite =
-                   CancellationTokenSource.CreateLinkedTokenSource(_externalToken, _internalTokenSource.Token))
-            {
-                Cancelled = composite.Token;
-                using (Cancelled.Register(() =>
-                       {
-                           lock (_destroyLock)
-                           {
-                               if (_disposed)
-                                   return;
-                               g_main_loop_quit(_loop);
-                           }
-                       }))
-                {
-                    g_main_loop_run(_loop);
-                }
-            }
-        }
-
-        public void Dispose()
-        {
-            lock (_destroyLock)
-            {
-                if(_disposed)
-                    return;
-                _disposed = true;
-                g_main_loop_unref(_loop);
-            }
-        }
-    }
 
     public X11EventDispatcher EventDispatcher => _x11Events;
 }
diff --git a/src/Avalonia.X11/Dispatching/GlibDispatcherImplBase.cs b/src/Avalonia.X11/Dispatching/GlibDispatcherImplBase.cs
new file mode 100644
index 0000000000..241bbc67f9
--- /dev/null
+++ b/src/Avalonia.X11/Dispatching/GlibDispatcherImplBase.cs
@@ -0,0 +1,289 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.ExceptionServices;
+using System.Threading;
+using Avalonia.Logging;
+using Avalonia.Threading;
+using static Avalonia.X11.Interop.Glib;
+namespace Avalonia.X11.Dispatching;
+
+/// <summary>
+/// Platform-agnostic GLib (GMainLoop/GSource) based dispatcher implementation. It maps Avalonia's dispatcher model
+/// onto GLib so Avalonia code can share a GLib main loop with GLib/GTK based libraries on the UI thread.
+/// It owns no platform event source by itself; backends derive from it to attach their own (e.g. the X11 socket).
+/// </summary>
+internal abstract class GlibDispatcherImplBase :
+    IDispatcherImplWithExplicitBackgroundProcessing,
+    IControlledDispatcherImpl
+{
+    /*
+        GLib priorities and Avalonia priorities are a bit different. Avalonia follows the WPF model when there
+            are "background" and "foreground" priority groups. Foreground jobs are executed before any user input processing,
+            background jobs are executed strictly after user input processing.
+
+        GLib has numeric priorities that are used in the following way:
+        -100    G_PRIORITY_HIGH - "high" priority sources, not really used by GLib/GTK
+        0       G_PRIORITY_DEFAULT - polling X11 events (GTK) and default value for g_timeout_add
+        100     G_PRIORITY_HIGH_IDLE without a clear definition, used as an anchor value of sorts
+        110     Resize/layout operations (GTK)
+        120     Render operations (GTK)
+        200     G_PRIORITY_DEFAULT_IDLE - "idle" priority sources
+
+        So, unlike Avalonia, GTK puts way higher priority on input processing, then does resize/layout/render
+
+        So, to map our model to GLib we do the following:
+        - foreground jobs (including grouped user events) are executed with (-1) priority (_before_ any normal GLib jobs)
+        - the platform event source is polled with G_PRIORITY_DEFAULT, all events are read until the socket is empty,
+            we also group input events at that stage (this matches our epoll-based dispatcher)
+        - background jobs are executed with G_PRIORITY_DEFAULT_IDLE, so they would have lower priority than GTK
+            foreground jobs
+
+        Unfortunately we can't detect if there are pending _non-idle_ GLib jobs using g_main_context_pending, since
+        - g_main_context_pending doesn't accept max_priority argument
+        - even if it did, that would still involve a syscall to the kernel to poll for fds anyway
+
+        So we just report that we don't support pending input query and let the dispatcher to
+        call RequestBackgroundProcessing every time, which results in g_idle_add call for every background job.
+        Background jobs are expected to be relatively expensive to execute since on Windows
+        MsgWaitForMultipleObjectsEx results isn't really free too.
+
+        For signaling (aka waking up dispatcher for processing _high_ priority jobs we are using
+        g_idle_add_full with (-1) priority. While the naming suggests that it would enqueue an idle job,
+        it actually adds an always-triggered source that would be called before other sources with lower priority.
+
+        For timers we are using a simple g_timeout_add_full and discard the previous one when dispatcher requests
+        an update
+
+        Since GLib dispatches event sources in batches, we force-check for "signaled" flag to run high-prio jobs
+        whenever we get control back from GLib. We can still occasionally get GTK code to run before high-prio
+        Avalonia-jobs, but that should be fine since the point is to keep Avalonia-based jobs ordered properly
+        and to not have our low-priority jobs to prevent GLib-based code from running its own "foreground" jobs
+
+        Another implementation note here is that GLib (just as any other C library) is NOT aware of C# exceptions,
+        so we are NOT allowed to have exceptions to escape native->managed call boundary. So we have exception handlers
+        that try to propagate those to the nearest run loop frame that was initiated by Avalonia.
+
+        If there is no such frame, we have no choice but to log/swallow those
+     */
+
+    // Note that we can't use g_main_context_is_owner outside a run loop, since context doesn't really have an
+    // inherent owner when run loop is not running and the context isn't explicitly "locked", so we just assume that
+    // the app author is initializing Avalonia on the intended UI thread and won't migrate the default run loop
+    // to a different thread
+    private readonly Thread _mainThread = Thread.CurrentThread;
+
+    private readonly Action<Exception>? _externalExceptionLogger;
+    private bool _signaled;
+    private bool _signaledSourceAdded;
+    private readonly object _signalLock = new();
+    private readonly Stack<ManagedLoopFrame> _runLoopStack = new();
+
+    private readonly Stopwatch _stopwatch = Stopwatch.StartNew();
+    private uint? _glibTimerSourceTag;
+
+    protected GlibDispatcherImplBase(Action<Exception>? externalExceptionLogger)
+    {
+        _externalExceptionLogger = externalExceptionLogger;
+    }
+
+    public bool CurrentThreadIsLoopThread => _mainThread == Thread.CurrentThread;
+
+    public event Action? Signaled;
+    public void Signal()
+    {
+        lock (_signalLock)
+        {
+            if(_signaled)
+                return;
+            _signaled = true;
+            if(_signaledSourceAdded)
+                return;
+            _signaledSourceAdded = true;
+        }
+        g_idle_add_full(G_PRIORITY_DEFAULT - 1, SignalSourceCallback);
+    }
+
+    protected void CheckSignaled()
+    {
+        lock (_signalLock)
+        {
+            if (!_signaled)
+                return;
+            _signaled = false;
+        }
+
+        try
+        {
+            Signaled?.Invoke();
+        }
+        catch (Exception e)
+        {
+            HandleException(e);
+        }
+        Flush();
+    }
+
+    private bool SignalSourceCallback()
+    {
+        lock (_signalLock)
+        {
+            _signaledSourceAdded = false;
+        }
+        CheckSignaled();
+        return false;
+    }
+
+    public event Action? Timer;
+    public long Now => _stopwatch.ElapsedMilliseconds;
+
+    public void UpdateTimer(long? dueTimeInMs)
+    {
+        if (_glibTimerSourceTag.HasValue)
+        {
+            g_source_remove(_glibTimerSourceTag.Value);
+            _glibTimerSourceTag = null;
+        }
+
+        if (dueTimeInMs == null)
+            return;
+
+        var interval = (uint)Math.Max(0, (int)Math.Min(int.MaxValue, dueTimeInMs.Value - Now));
+        _glibTimerSourceTag = g_timeout_add_once(interval, TimerCallback);
+    }
+
+    private void TimerCallback()
+    {
+        try
+        {
+            Timer?.Invoke();
+        }
+        catch (Exception e)
+        {
+            HandleException(e);
+        }
+        Flush();
+    }
+
+    public event Action? ReadyForBackgroundProcessing;
+
+    public void RequestBackgroundProcessing() =>
+        g_idle_add_once(() => ReadyForBackgroundProcessing?.Invoke());
+
+    public virtual bool CanQueryPendingInput => false;
+    public virtual bool HasPendingInput => false;
+
+    /// <summary>
+    /// Flush any pending output to the platform event source after Avalonia jobs ran. Called whenever control
+    /// returns to GLib from a signaled/timer callback. The base implementation does nothing; backends that own a
+    /// socket (e.g. X11) override it to flush their connection.
+    /// </summary>
+    protected virtual void Flush()
+    {
+    }
+
+    /// <summary>The cancellation token of the innermost Avalonia-controlled run loop frame, or None when no frame
+    /// is running. Backends use it to stop draining their event source once a loop frame asked to quit.</summary>
+    protected CancellationToken CurrentLoopCancellation =>
+        _runLoopStack.Count > 0 ? _runLoopStack.Peek().Cancelled : CancellationToken.None;
+
+    public void RunLoop(CancellationToken token)
+    {
+        if(token.IsCancellationRequested)
+            return;
+
+        using var loop = new ManagedLoopFrame(token);
+        _runLoopStack.Push(loop);
+        loop.Run();
+        _runLoopStack.Pop();
+
+        // Propagate any managed exceptions that we've captured from this frame
+        if(loop.Exceptions.Count == 1)
+            loop.Exceptions[0].Throw();
+        else if (loop.Exceptions.Count > 1)
+            throw new AggregateException(loop.Exceptions.Select(x => x.SourceException));
+    }
+
+    protected void HandleException(Exception e)
+    {
+        if (_runLoopStack.Count > 0)
+        {
+            var frame = _runLoopStack.Peek();
+            frame.Exceptions.Add(ExceptionDispatchInfo.Capture(e));
+            frame.Stop();
+        }
+        else
+        {
+            if (_externalExceptionLogger != null)
+                _externalExceptionLogger.Invoke(e);
+            else
+                Logger.TryGet(LogEventLevel.Error, LogArea.Control)
+                    ?.Log("Dispatcher", "Unhandled exception: {exception}", e);
+        }
+    }
+
+    private class ManagedLoopFrame : IDisposable
+    {
+        private readonly CancellationToken _externalToken;
+        private CancellationTokenSource? _internalTokenSource;
+        public CancellationToken Cancelled { get; private set; }
+
+        private readonly IntPtr _loop = g_main_loop_new(IntPtr.Zero, 1);
+        public List<ExceptionDispatchInfo> Exceptions { get; } = new();
+        private readonly object _destroyLock = new();
+        private bool _disposed;
+
+        public ManagedLoopFrame(CancellationToken token)
+        {
+            _externalToken = token;
+        }
+
+        public void Stop()
+        {
+            try
+            {
+                _internalTokenSource?.Cancel();
+            }
+            catch
+            {
+                // Ignore
+            }
+        }
+
+        public void Run()
+        {
+            if (_externalToken.IsCancellationRequested)
+                return;
+            using (_internalTokenSource = new())
+            using (var composite =
+                   CancellationTokenSource.CreateLinkedTokenSource(_externalToken, _internalTokenSource.Token))
+            {
+                Cancelled = composite.Token;
+                using (Cancelled.Register(() =>
+                       {
+                           lock (_destroyLock)
+                           {
+                               if (_disposed)
+                                   return;
+                               g_main_loop_quit(_loop);
+                           }
+                       }))
+                {
+                    g_main_loop_run(_loop);
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            lock (_destroyLock)
+            {
+                if(_disposed)
+                    return;
+                _disposed = true;
+                g_main_loop_unref(_loop);
+            }
+        }
+    }
+}

From f8eb57adf1b5fd8ec13cbbcc35450dba289a0723 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Wed, 1 Jul 2026 15:20:02 +0500
Subject: [PATCH 055/196] Fixed XEmbed client (#21677)

---
 samples/XEmbedSample/Program.cs                           | 1 +
 samples/XEmbedSample/XEmbedSample.csproj                  | 2 ++
 src/Avalonia.X11/X11WindowModes/XEmbedClientWindowMode.cs | 2 +-
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/samples/XEmbedSample/Program.cs b/samples/XEmbedSample/Program.cs
index b8f00bd86d..81035dcf9d 100644
--- a/samples/XEmbedSample/Program.cs
+++ b/samples/XEmbedSample/Program.cs
@@ -17,6 +17,7 @@ class Program
         HarfbuzzWorkaround.Apply();
         AppBuilder.Configure<App>()
             .UseSkia()
+            .UseHarfBuzz()
             .With(new X11PlatformOptions()
             {
                 UseGLibMainLoop = true,
diff --git a/samples/XEmbedSample/XEmbedSample.csproj b/samples/XEmbedSample/XEmbedSample.csproj
index 1b51999ada..46388eea83 100644
--- a/samples/XEmbedSample/XEmbedSample.csproj
+++ b/samples/XEmbedSample/XEmbedSample.csproj
@@ -13,6 +13,8 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\Avalonia.X11\Avalonia.X11.csproj"/>
+    <ProjectReference Include="../../src/HarfBuzz/Avalonia.HarfBuzz/Avalonia.HarfBuzz.csproj"/>
+
     <ProjectReference Include="..\ControlCatalog\ControlCatalog.csproj"/>
   </ItemGroup>
 
diff --git a/src/Avalonia.X11/X11WindowModes/XEmbedClientWindowMode.cs b/src/Avalonia.X11/X11WindowModes/XEmbedClientWindowMode.cs
index 824a26d10f..73b967a780 100644
--- a/src/Avalonia.X11/X11WindowModes/XEmbedClientWindowMode.cs
+++ b/src/Avalonia.X11/X11WindowModes/XEmbedClientWindowMode.cs
@@ -9,7 +9,7 @@ partial class X11Window
 {
     public class XEmbedClientWindowMode : X11WindowMode
     {
-        EmbeddableControlRoot? Root => Window._inputRoot?.RootElement as EmbeddableControlRoot;
+        EmbeddableControlRoot? Root => Window._inputRoot?.FocusRoot as EmbeddableControlRoot;
         private bool _focusedInEmbedder;
         private bool _embedderActivated;
         private bool _disabled;

From 9448ef8a91cacf9cabd003ab09ce63b2b9ee72a8 Mon Sep 17 00:00:00 2001
From: Thad House <ThadHouse@users.noreply.github.com>
Date: Wed, 1 Jul 2026 23:12:28 -0700
Subject: [PATCH 056/196] Fix hang if exception is thrown during headless
 session app construction (#21688)

---
 .../HeadlessUnitTestSession.cs                | 25 +++++++++++++------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/src/Headless/Avalonia.Headless/HeadlessUnitTestSession.cs b/src/Headless/Avalonia.Headless/HeadlessUnitTestSession.cs
index 645812cefb..5613244461 100644
--- a/src/Headless/Avalonia.Headless/HeadlessUnitTestSession.cs
+++ b/src/Headless/Avalonia.Headless/HeadlessUnitTestSession.cs
@@ -16,7 +16,7 @@ namespace Avalonia.Headless;
 /// <summary>
 /// Headless unit test session that needs to be used by the actual testing framework.
 /// All UI tests are supposed to be executed from one of the <see cref="Dispatch"/> methods to keep execution flow on the UI thread.
-/// Disposing unit test session stops internal dispatcher loop. 
+/// Disposing unit test session stops internal dispatcher loop.
 /// </summary>
 public sealed class HeadlessUnitTestSession : IDisposable, IAsyncDisposable
 {
@@ -96,9 +96,18 @@ public sealed class HeadlessUnitTestSession : IDisposable, IAsyncDisposable
             using var globalCts = token.Register(s => ((CancellationTokenSource)s!).Cancel(), cts, true);
             using var localCts = cancellationToken.Register(s => ((CancellationTokenSource)s!).Cancel(), cts, true);
 
-            var application = _isolated
-                ? EnsureIsolatedApplication()
-                : EnsureSharedApplication();
+            IDisposable application = null!;
+            try
+            {
+                application = _isolated
+                    ? EnsureIsolatedApplication()
+                    : EnsureSharedApplication();
+            }
+            catch (Exception ex)
+            {
+                tcs.TrySetException(ex);
+                return; // Exit the dispatcher action if application initialization fails
+            }
 
             bool shouldCancel = false;
             Exception? caught = null;
@@ -212,7 +221,7 @@ public sealed class HeadlessUnitTestSession : IDisposable, IAsyncDisposable
     }
 
     /// <summary>
-    /// Creates instance of <see cref="HeadlessUnitTestSession"/>. 
+    /// Creates instance of <see cref="HeadlessUnitTestSession"/>.
     /// </summary>
     /// <param name="entryPointType">
     /// Parameter from which <see cref="AppBuilder"/> should be created.
@@ -228,7 +237,7 @@ public sealed class HeadlessUnitTestSession : IDisposable, IAsyncDisposable
     }
 
     /// <summary>
-    /// Creates instance of <see cref="HeadlessUnitTestSession"/>. 
+    /// Creates instance of <see cref="HeadlessUnitTestSession"/>.
     /// </summary>
     /// <param name="entryPointType">
     /// Parameter from which <see cref="AppBuilder"/> should be created.
@@ -283,7 +292,7 @@ public sealed class HeadlessUnitTestSession : IDisposable, IAsyncDisposable
                     }
                     else
                     {
-                        action();   
+                        action();
                     }
                 }
                 catch (OperationCanceledException)
@@ -297,7 +306,7 @@ public sealed class HeadlessUnitTestSession : IDisposable, IAsyncDisposable
 
     /// <summary>
     /// Creates a session from AvaloniaTestApplicationAttribute attribute or reuses any existing.
-    /// If AvaloniaTestApplicationAttribute doesn't exist, empty application is used. 
+    /// If AvaloniaTestApplicationAttribute doesn't exist, empty application is used.
     /// </summary>
     [UnconditionalSuppressMessage("Trimming", "IL2072",
         Justification = "AvaloniaTestApplicationAttribute attribute should preserve type information.")]

From 883a2477a51f681c28531f336524a2d0b8d3cc1a Mon Sep 17 00:00:00 2001
From: Benedikt Stebner <Gillibald@users.noreply.github.com>
Date: Thu, 2 Jul 2026 09:59:08 +0200
Subject: [PATCH 057/196] [Text] Rework text fallback itemization (#21631)

* Add GlyphTypeface.CanShapeScript(Script), backed by a lazy read of the GSUB/GPOS ScriptList via the new ScriptListTable parser.
Add FontFallbackScriptHints.TryGetComplexShapingTags, which maps 17 complex scripts to the OpenType script tag(s) a font must declare to shape them.
Thread a Script shapingScript constraint through FontManager.TryMatchCharacter and FontCollectionBase.TryMatchCharacter as internal overloads, leaving the public signatures untouched.
Rework TextCharacters.CreateShapeableRun into a capability preference: a complex script tries shaping-capable fonts first (tier 0), then cmap-only coverage (tier 1); simple scripts keep the single historical tier.
Replace the NUL placeholder U+200B (ZERO WIDTH SPACE) with U+2060 (WORD JOINER) so the substitution introduces no line-break opportunity.
Suppress previous-run font reuse across a culture change for locale-sensitive scripts, so a zh run's font no longer pins following ja text.
Add 3 subset test fonts and 3 new test files (7 new tests) and fix 2 stale doc-comment crefs.

* Fix comments

* Fix font fallback reusing the wrong cached face from the script bucket

FontCollectionBase.TryMatchCharacter caches a resolved fallback family per
(script, culture) bucket. Two bugs let that bucket hand back a face that does
not match the request:

- A positive bucket entry suppressed the Tier D platform lookup for any later
  codepoint, even one the bucket family cannot cover. A CJK run left the
  Simplified-only U+534E unmatched (tofu) because the bucket resolved to a
  Japanese font that lacks it, while another installed font could place it.
  Tier D now treats only a negative (null) entry as "platform already
  attempted"; a positive entry no longer blocks the platform, since that
  family may not cover this codepoint.

- A cached covering match of a neighbouring FontCollectionKey was reused for a
  different requested key. After a Bold run cached a face, a following Normal
  run reused it and rendered bold (and the symmetric style and stretch cases).
  Tier A, B and C now keep the exact key: when the cached covering match is a
  neighbouring key, the exact-key face of the same family is resolved from the
  platform via TryMatchCharacterFromPlatform, falling back to the neighbour
  only when the platform has no exact face. Collections without a platform are
  unchanged.

Add regression tests for both: a bucket whose font lacks a later same-script
codepoint, and weight and style leaks resolved through Tier B (script cache)
and Tier C (the sweep, exercised via a non-locale-sensitive script with no
culture).
---
 src/Avalonia.Base/Media/FontManager.cs        |  38 ++-
 .../Media/Fonts/FontCollectionBase.cs         | 143 ++++++--
 .../Media/Fonts/FontFallbackScriptHints.cs    |  70 +++-
 .../Media/Fonts/Tables/ScriptListTable.cs     |  73 +++++
 src/Avalonia.Base/Media/GlyphTypeface.cs      |  60 ++++
 .../Media/TextFormatting/TextCharacters.cs    | 243 +++++++++++---
 .../Fonts/NotoSansArabic-NoLayout.ttf         | Bin 0 -> 2740 bytes
 .../Fonts/NotoSansJP-Subset.ttf               | Bin 0 -> 3756 bytes
 .../Fonts/NotoSansSC-Subset.ttf               | Bin 0 -> 3020 bytes
 .../Media/FontCollectionDeterminismTests.cs   |   3 +-
 .../FontCollectionTryMatchCharacterTests.cs   | 245 +++++++++++++-
 .../Media/GlyphTypefaceShapingTests.cs        |  91 ++++++
 .../ShapingCapabilityFallbackTests.cs         | 110 +++++++
 .../TextFormatting/TextCharactersTests.cs     | 308 ++++++++++++++++++
 14 files changed, 1314 insertions(+), 70 deletions(-)
 create mode 100644 src/Avalonia.Base/Media/Fonts/Tables/ScriptListTable.cs
 create mode 100644 tests/Avalonia.Skia.UnitTests/Fonts/NotoSansArabic-NoLayout.ttf
 create mode 100644 tests/Avalonia.Skia.UnitTests/Fonts/NotoSansJP-Subset.ttf
 create mode 100644 tests/Avalonia.Skia.UnitTests/Fonts/NotoSansSC-Subset.ttf
 create mode 100644 tests/Avalonia.Skia.UnitTests/Media/GlyphTypefaceShapingTests.cs
 create mode 100644 tests/Avalonia.Skia.UnitTests/Media/TextFormatting/ShapingCapabilityFallbackTests.cs
 create mode 100644 tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextCharactersTests.cs

diff --git a/src/Avalonia.Base/Media/FontManager.cs b/src/Avalonia.Base/Media/FontManager.cs
index 60200dea85..481a69eaf7 100644
--- a/src/Avalonia.Base/Media/FontManager.cs
+++ b/src/Avalonia.Base/Media/FontManager.cs
@@ -6,6 +6,7 @@ using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using Avalonia.Logging;
 using Avalonia.Media.Fonts;
+using Avalonia.Media.TextFormatting.Unicode;
 using Avalonia.Platform;
 using Avalonia.Utilities;
 
@@ -262,6 +263,17 @@ namespace Avalonia.Media
         /// </returns>
         public bool TryMatchCharacter(int codepoint, FontStyle fontStyle, FontWeight fontWeight,
             FontStretch fontStretch, FontFamily? fontFamily, CultureInfo? culture, out Typeface typeface)
+            => TryMatchCharacter(codepoint, fontStyle, fontWeight, fontStretch, fontFamily, culture,
+                Script.Unknown, out typeface);
+
+        /// <summary>
+        /// Character-to-typeface match with an optional shaping-capability constraint: when
+        /// <paramref name="shapingScript"/> is a complex script, only fonts that can shape it are
+        /// considered. <see cref="Script.Unknown"/> imposes no constraint and is identical to the
+        /// public overload.
+        /// </summary>
+        internal bool TryMatchCharacter(int codepoint, FontStyle fontStyle, FontWeight fontWeight,
+            FontStretch fontStretch, FontFamily? fontFamily, CultureInfo? culture, Script shapingScript, out Typeface typeface)
         {
             if (_fontFallbacks != null)
             {
@@ -271,7 +283,9 @@ namespace Avalonia.Media
                     {
                         typeface = new Typeface(fallback.FontFamily, fontStyle, fontWeight, fontStretch);
 
-                        if (TryGetGlyphTypeface(typeface, out var glyphTypeface) && glyphTypeface.CharacterToGlyphMap.TryGetGlyph(codepoint, out _))
+                        if (TryGetGlyphTypeface(typeface, out var glyphTypeface) &&
+                            glyphTypeface.CharacterToGlyphMap.TryGetGlyph(codepoint, out _) &&
+                            (shapingScript == Script.Unknown || glyphTypeface.CanShapeScript(shapingScript)))
                         {
                             return true;
                         }
@@ -298,7 +312,7 @@ namespace Avalonia.Media
                         if (TryGetFontCollection(source, out var fontCollection) &&
                             // With composite fonts we need to first check if the font collection contains the family if not we skip it
                             fontCollection.TryGetGlyphTypeface(familyName, fontStyle, fontWeight, fontStretch, out _) &&
-                            fontCollection.TryMatchCharacter(codepoint, fontStyle, fontWeight, fontStretch, familyName, culture, out typeface))
+                            TryMatchCharacterInCollection(fontCollection, codepoint, fontStyle, fontWeight, fontStretch, familyName, culture, shapingScript, out typeface))
                         {
                             if (typeface.FontFamily.Name == DefaultFontFamily.Name && i + 1 < compositeKey.Keys.Count)
                             {
@@ -315,7 +329,7 @@ namespace Avalonia.Media
                 if (fontUri.IsFontCollection())
                 {
                     if (TryGetFontCollection(fontUri, out var fontCollection) &&
-                            fontCollection.TryMatchCharacter(codepoint, fontStyle, fontWeight, fontStretch, fontFamily.Name, culture, out typeface))
+                            TryMatchCharacterInCollection(fontCollection, codepoint, fontStyle, fontWeight, fontStretch, fontFamily.Name, culture, shapingScript, out typeface))
                     {
                         return true;
                     }
@@ -323,7 +337,23 @@ namespace Avalonia.Media
             }
 
             //Try to find a match with the system font collection
-            return SystemFonts.TryMatchCharacter(codepoint, fontStyle, fontWeight, fontStretch, fontFamily?.Name,
+            return TryMatchCharacterInCollection(SystemFonts, codepoint, fontStyle, fontWeight, fontStretch,
+                fontFamily?.Name, culture, shapingScript, out typeface);
+        }
+
+        // Routes through the shaping-aware overload when the collection is a FontCollectionBase (all
+        // built-in collections are); a foreign IFontCollection gets the unconstrained match.
+        private static bool TryMatchCharacterInCollection(IFontCollection fontCollection, int codepoint,
+            FontStyle fontStyle, FontWeight fontWeight, FontStretch fontStretch, string? familyName,
+            CultureInfo? culture, Script shapingScript, out Typeface typeface)
+        {
+            if (fontCollection is FontCollectionBase fontCollectionBase)
+            {
+                return fontCollectionBase.TryMatchCharacter(codepoint, fontStyle, fontWeight, fontStretch,
+                    familyName, culture, shapingScript, out typeface);
+            }
+
+            return fontCollection.TryMatchCharacter(codepoint, fontStyle, fontWeight, fontStretch, familyName,
                 culture, out typeface);
         }
 
diff --git a/src/Avalonia.Base/Media/Fonts/FontCollectionBase.cs b/src/Avalonia.Base/Media/Fonts/FontCollectionBase.cs
index 649c47f730..778a326e72 100644
--- a/src/Avalonia.Base/Media/Fonts/FontCollectionBase.cs
+++ b/src/Avalonia.Base/Media/Fonts/FontCollectionBase.cs
@@ -20,8 +20,10 @@ namespace Avalonia.Media.Fonts
         // Make this internal for testing purposes
         internal readonly ConcurrentDictionary<string, ConcurrentDictionary<FontCollectionKey, GlyphTypeface?>> _glyphTypefaceCache = new();
 
-        // Cache of resolved script/culture fallback family names. A null value is a *negative* cache
-        // entry which prevents repeated platform-fallback calls for the same script bucket.
+        // Cache of resolved script/culture fallback family names. A non-null value is the preferred
+        // fallback family for that script bucket: a Tier B hint that is still re-checked for coverage
+        // per codepoint, and which does NOT by itself suppress a platform call. A null value is a
+        // *negative* entry that prevents repeated platform-fallback calls for the same script bucket.
         private readonly ConcurrentDictionary<ScriptFallbackKey, string?> _scriptFallbackCache = new();
 
         private readonly object _fontFamiliesLock = new();
@@ -45,6 +47,16 @@ namespace Avalonia.Media.Fonts
 
         public virtual bool TryMatchCharacter(int codepoint, FontStyle style, FontWeight weight, FontStretch stretch,
             string? familyName, CultureInfo? culture, out Typeface match)
+            => TryMatchCharacter(codepoint, style, weight, stretch, familyName, culture, Script.Unknown, out match);
+
+        /// <summary>
+        /// Character-to-typeface match with an optional shaping-capability constraint. When
+        /// <paramref name="shapingScript"/> is a complex script, only candidates that can shape it
+        /// (<see cref="GlyphTypeface.CanShapeScript"/>) are considered; <see cref="Script.Unknown"/>
+        /// imposes no constraint and is identical to the public overload.
+        /// </summary>
+        internal bool TryMatchCharacter(int codepoint, FontStyle style, FontWeight weight, FontStretch stretch,
+            string? familyName, CultureInfo? culture, Script shapingScript, out Typeface match)
         {
             match = default;
 
@@ -57,7 +69,7 @@ namespace Avalonia.Media.Fonts
             // --- Tier A: requested family, coverage-checked, culture-compatible ---
             if (familyName != null &&
                 _glyphTypefaceCache.TryGetValue(familyName, out var requestedFamily) &&
-                TryGetCoveringMatch(requestedFamily, key, codepoint, isLastResort: false, out var requestedGlyphTypeface) &&
+                TryGetCoveringMatchForFamily(requestedFamily, key, codepoint, culture, shapingScript, out var requestedGlyphTypeface) &&
                 IsCultureCompatible(requestedGlyphTypeface, culture, script))
             {
                 match = BuildTypefaceWithSynthesis(requestedGlyphTypeface, key);
@@ -71,7 +83,7 @@ namespace Avalonia.Media.Fonts
                     cachedFamily != null &&
                     !string.Equals(cachedFamily, familyName, StringComparison.OrdinalIgnoreCase) &&
                     _glyphTypefaceCache.TryGetValue(cachedFamily, out var cachedTypefaces) &&
-                    TryGetCoveringMatch(cachedTypefaces, key, codepoint, isLastResort: false, out var cachedGlyphTypeface))
+                    TryGetCoveringMatchForFamily(cachedTypefaces, key, codepoint, culture, shapingScript, out var cachedGlyphTypeface))
                 {
                     match = BuildTypefaceWithSynthesis(cachedGlyphTypeface, key);
                     return true;
@@ -79,8 +91,14 @@ namespace Avalonia.Media.Fonts
             }
 
             // --- Tier C: deterministic cache sweep (non last-resort), culture-scored ---
-            if (TryMatchInCache(codepoint, key, familyName, culture, script, refinedScript, isLastResort: false, out var bestGt, out var bestFamilyName))
-            {               
+            if (TryMatchInCache(codepoint, key, familyName, culture, script, refinedScript, shapingScript, isLastResort: false, out var bestGt, out var bestFamilyName))
+            {
+                // The sweep returns the nearest cached key for the winning family. A codepoint the
+                // bucket family can't cover (e.g. the Simplified-only 华 when the bucket is a JP font)
+                // lands here, so the exact-key upgrade is needed here too: otherwise a Bold face cached
+                // for an earlier run is rendered for a Normal request.
+                bestGt = PreferExactKey(bestGt, key, codepoint, culture, shapingScript);
+
                 if (FontFallbackScriptHints.IsLocaleSensitive(refinedScript) || culture != null)
                 {
                     _scriptFallbackCache.TryAdd(scriptKey, bestFamilyName);
@@ -90,25 +108,41 @@ namespace Avalonia.Media.Fonts
                 return true;
             }
 
-            // --- Tier D: platform fallback (at most once per (script, culture)) ---
-            var platformAlreadyAttempted = _scriptFallbackCache.ContainsKey(scriptKey);
-
-            if (!platformAlreadyAttempted &&
-                TryMatchCharacterFromPlatform(codepoint, key, familyName, culture, out var platformGt))
+            // --- Tier D: platform fallback ---
+            // Only a *negative* cache entry (the platform had no font for this script bucket)
+            // suppresses a retry. A *positive* entry must not: it records a preferred family for the
+            // bucket, but that family may not cover THIS codepoint - e.g. 中 (U+4E2D) resolves to a CJK
+            // font that lacks the Simplified-only 华 (U+534E) - and the platform resolves per codepoint,
+            // so it may still place a codepoint the bucket's font cannot. Reaching Tier D already means
+            // no cached family covered this codepoint.
+            // Skipped for shaping-constrained queries: the platform match is not capability-checked,
+            // and the caller's unconstrained pass already covers the platform path (so the negative
+            // cache stays consistent with unconstrained lookups).
+            if (shapingScript == Script.Unknown)
             {
-                _scriptFallbackCache.TryAdd(scriptKey, platformGt.FamilyName);
-                match = BuildTypefaceWithSynthesis(platformGt, key);
-                return true;
-            }
+                var hasCacheEntry = _scriptFallbackCache.TryGetValue(scriptKey, out var cachedFamily);
+                var platformAlreadyAttempted = hasCacheEntry && cachedFamily is null;
 
-            if (!platformAlreadyAttempted)
-            {
-                // Remember the negative answer so we don't ask the platform again.
-                _scriptFallbackCache.TryAdd(scriptKey, null);
+                if (!platformAlreadyAttempted &&
+                    TryMatchCharacterFromPlatform(codepoint, key, familyName, culture, out var platformGt))
+                {
+                    // Keep any existing positive hint (TryAdd won't overwrite); registering the match
+                    // lets later lookups for this codepoint be served by Tier C without the platform.
+                    _scriptFallbackCache.TryAdd(scriptKey, platformGt.FamilyName);
+                    match = BuildTypefaceWithSynthesis(platformGt, key);
+                    return true;
+                }
+
+                // Record a negative only when nothing was cached for the bucket yet, so a positive hint
+                // for one codepoint isn't downgraded to a negative by another the platform can't place.
+                if (!hasCacheEntry)
+                {
+                    _scriptFallbackCache.TryAdd(scriptKey, null);
+                }
             }
 
             // --- Tier E: last-resort cache sweep ---
-            if (TryMatchInCache(codepoint, key, familyName, culture, script, refinedScript, isLastResort: true, out var lrGt, out _))
+            if (TryMatchInCache(codepoint, key, familyName, culture, script, refinedScript, shapingScript, isLastResort: true, out var lrGt, out _))
             {
                 match = BuildTypefaceWithSynthesis(lrGt, key);
                 return true;
@@ -124,6 +158,7 @@ namespace Avalonia.Media.Fonts
             CultureInfo? culture,
             Script script,
             Script refinedScript,
+            Script shapingScript,
             bool isLastResort,
             [NotNullWhen(true)] out GlyphTypeface? bestGlyphTypeface,
             [NotNullWhen(true)] out string? bestFamilyName)
@@ -149,7 +184,7 @@ namespace Avalonia.Media.Fonts
                     continue;
                 }
 
-                if (!TryGetCoveringMatch(glyphTypefaces, key, codepoint, isLastResort, out var candidate))
+                if (!TryGetCoveringMatch(glyphTypefaces, key, codepoint, isLastResort, shapingScript, out var candidate))
                 {
                     continue;
                 }
@@ -280,7 +315,7 @@ namespace Avalonia.Media.Fonts
         /// <summary>
         /// Hook for platform-backed collections (e.g. <see cref="SystemFontCollection"/>) to consult
         /// the underlying font manager for a fallback typeface. Invoked at most once per
-        /// (script-bucket, culture) pair from <see cref="TryMatchCharacter"/>.
+        /// (script-bucket, culture) pair from <see cref="FontCollectionBase.TryMatchCharacter(int, FontStyle, FontWeight, FontStretch, string?, CultureInfo?, out Typeface)"/>.
         /// </summary>
         protected virtual bool TryMatchCharacterFromPlatform(
             int codepoint,
@@ -293,23 +328,82 @@ namespace Avalonia.Media.Fonts
             return false;
         }
 
+        /// <summary>
+        /// Resolves a covering face for a single family at the requested key. Takes the cheap cached
+        /// covering match first (an exact-key hit needs nothing more) and only escalates to the exact
+        /// key when that match differs in any axis, so a Bold (or Italic, or Condensed) face cached for
+        /// one run is not reused for a differently-keyed request of the same family.
+        /// </summary>
+        private bool TryGetCoveringMatchForFamily(
+            ConcurrentDictionary<FontCollectionKey, GlyphTypeface?> glyphTypefaces,
+            FontCollectionKey key,
+            int codepoint,
+            CultureInfo? culture,
+            Script shapingScript,
+            [NotNullWhen(true)] out GlyphTypeface? glyphTypeface)
+        {
+            if (!TryGetCoveringMatch(glyphTypefaces, key, codepoint, isLastResort: false, shapingScript, out glyphTypeface))
+            {
+                return false;
+            }
+
+            glyphTypeface = PreferExactKey(glyphTypeface, key, codepoint, culture, shapingScript);
+            return true;
+        }
+
+        /// <summary>
+        /// When <paramref name="glyphTypeface"/> differs from the requested <paramref name="key"/> in
+        /// any axis (style, weight or stretch), asks the platform for the exact-key face of the same
+        /// family - the only source of a key the cache lacks - via <see cref="TryMatchCharacterFromPlatform"/>,
+        /// and returns it when it is an exact, shapeable match; otherwise returns the input unchanged.
+        /// The platform is consulted only on a mismatch, and a collection without one keeps the
+        /// neighbouring match. This guards every key axis, not just weight.
+        /// </summary>
+        private GlyphTypeface PreferExactKey(
+            GlyphTypeface glyphTypeface,
+            FontCollectionKey key,
+            int codepoint,
+            CultureInfo? culture,
+            Script shapingScript)
+        {
+            // The platform's character match, biased by the family already resolved, yields that family
+            // at the requested key when it has that face (MatchCharacter covers the codepoint, so no
+            // extra coverage check is needed). Accept it only when it is the exact key and can shape.
+            if (glyphTypeface.ToFontCollectionKey() != key &&
+                TryMatchCharacterFromPlatform(codepoint, key, glyphTypeface.FamilyName, culture, out var exact) &&
+                exact.ToFontCollectionKey() == key &&
+                CanShape(exact, shapingScript))
+            {
+                return exact;
+            }
+
+            return glyphTypeface;
+        }
+
         /// <summary>
         /// Picks a variant of the family that both is close to the requested key and actually maps
         /// the requested codepoint. Falls back through the existing weight/stretch search but
         /// filters every candidate through the font's character-to-glyph map.
         /// </summary>
+        // A candidate satisfies a shaping-capability constraint when it can shape the requested
+        // script; Script.Unknown means no constraint (the historical, unconstrained behaviour).
+        private static bool CanShape(GlyphTypeface glyphTypeface, Script shapingScript)
+            => shapingScript == Script.Unknown || glyphTypeface.CanShapeScript(shapingScript);
+
         private static bool TryGetCoveringMatch(
             ConcurrentDictionary<FontCollectionKey, GlyphTypeface?> glyphTypefaces,
             FontCollectionKey key,
             int codepoint,
             bool isLastResort,
+            Script shapingScript,
             [NotNullWhen(true)] out GlyphTypeface? glyphTypeface)
         {
             // Exact key first.
             if (glyphTypefaces.TryGetValue(key, out glyphTypeface) &&
                 glyphTypeface != null &&
                 glyphTypeface.IsLastResort == isLastResort &&
-                glyphTypeface.CharacterToGlyphMap.TryGetGlyph(codepoint, out _))
+                glyphTypeface.CharacterToGlyphMap.TryGetGlyph(codepoint, out _) &&
+                CanShape(glyphTypeface, shapingScript))
             {
                 return true;
             }
@@ -330,7 +424,8 @@ namespace Avalonia.Media.Fonts
                     continue;
                 }
 
-                if (!candidate.CharacterToGlyphMap.TryGetGlyph(codepoint, out _))
+                if (!candidate.CharacterToGlyphMap.TryGetGlyph(codepoint, out _) ||
+                    !CanShape(candidate, shapingScript))
                 {
                     continue;
                 }
diff --git a/src/Avalonia.Base/Media/Fonts/FontFallbackScriptHints.cs b/src/Avalonia.Base/Media/Fonts/FontFallbackScriptHints.cs
index c1912f62e9..ed05886f35 100644
--- a/src/Avalonia.Base/Media/Fonts/FontFallbackScriptHints.cs
+++ b/src/Avalonia.Base/Media/Fonts/FontFallbackScriptHints.cs
@@ -5,7 +5,7 @@ using Avalonia.Media.TextFormatting.Unicode;
 namespace Avalonia.Media.Fonts
 {
     /// <summary>
-    /// Script-aware hints used by <see cref="FontCollectionBase.TryMatchCharacter"/> to
+    /// Script-aware hints used by <see cref="FontCollectionBase.TryMatchCharacter(int, FontStyle, FontWeight, FontStretch, string?, CultureInfo?, out Typeface)"/> to
     /// disambiguate locale-sensitive scripts (e.g. CJK), to provide deterministic probe
     /// codepoints for scoring candidate fonts, and to decide whether a candidate font is
     /// compatible with the caller's culture.
@@ -177,5 +177,73 @@ namespace Avalonia.Media.Fonts
 
             return bit >= 0;
         }
+
+        // OpenType GSUB/GPOS script tags a font must declare to shape each complex script. Indic
+        // and Myanmar expose a modern ("dev2") and a legacy ("deva") tag; either is accepted.
+        private static readonly OpenTypeTag Arab = OpenTypeTag.Parse("arab");
+        private static readonly OpenTypeTag Syrc = OpenTypeTag.Parse("syrc");
+        private static readonly OpenTypeTag Mong = OpenTypeTag.Parse("mong");
+        private static readonly OpenTypeTag Thaa = OpenTypeTag.Parse("thaa");
+        private static readonly OpenTypeTag Khmr = OpenTypeTag.Parse("khmr");
+        private static readonly OpenTypeTag Tibt = OpenTypeTag.Parse("tibt");
+        private static readonly OpenTypeTag Sinh = OpenTypeTag.Parse("sinh");
+        private static readonly OpenTypeTag Dev2 = OpenTypeTag.Parse("dev2");
+        private static readonly OpenTypeTag Deva = OpenTypeTag.Parse("deva");
+        private static readonly OpenTypeTag Bng2 = OpenTypeTag.Parse("bng2");
+        private static readonly OpenTypeTag Beng = OpenTypeTag.Parse("beng");
+        private static readonly OpenTypeTag Gur2 = OpenTypeTag.Parse("gur2");
+        private static readonly OpenTypeTag Guru = OpenTypeTag.Parse("guru");
+        private static readonly OpenTypeTag Gjr2 = OpenTypeTag.Parse("gjr2");
+        private static readonly OpenTypeTag Gujr = OpenTypeTag.Parse("gujr");
+        private static readonly OpenTypeTag Ory2 = OpenTypeTag.Parse("ory2");
+        private static readonly OpenTypeTag Orya = OpenTypeTag.Parse("orya");
+        private static readonly OpenTypeTag Tml2 = OpenTypeTag.Parse("tml2");
+        private static readonly OpenTypeTag Taml = OpenTypeTag.Parse("taml");
+        private static readonly OpenTypeTag Tel2 = OpenTypeTag.Parse("tel2");
+        private static readonly OpenTypeTag Telu = OpenTypeTag.Parse("telu");
+        private static readonly OpenTypeTag Knd2 = OpenTypeTag.Parse("knd2");
+        private static readonly OpenTypeTag Knda = OpenTypeTag.Parse("knda");
+        private static readonly OpenTypeTag Mlm2 = OpenTypeTag.Parse("mlm2");
+        private static readonly OpenTypeTag Mlym = OpenTypeTag.Parse("mlym");
+        private static readonly OpenTypeTag Mym2 = OpenTypeTag.Parse("mym2");
+        private static readonly OpenTypeTag Mymr = OpenTypeTag.Parse("mymr");
+
+        /// <summary>
+        /// For scripts that require OpenType complex shaping (cursive joining, reordering, conjunct
+        /// formation, dependent-vowel positioning, …), returns the GSUB/GPOS script tag(s) a font
+        /// must declare in order to shape them. A font that maps the codepoints through cmap but
+        /// declares none of these tags cannot shape the script and should be skipped during fallback.
+        /// </summary>
+        /// <returns>
+        /// <c>true</c> with one or two acceptable script tags (Indic and Myanmar expose both a modern
+        /// "dev2"-style tag and a legacy "deva"-style tag; for single-tag scripts
+        /// <paramref name="secondary"/> equals <paramref name="primary"/>). <c>false</c> for scripts
+        /// that render acceptably from cmap alone (Latin, CJK, Hangul, Hebrew, Thai, …), for which no
+        /// layout-table gate should apply.
+        /// </returns>
+        public static bool TryGetComplexShapingTags(Script script, out OpenTypeTag primary, out OpenTypeTag secondary)
+        {
+            switch (script)
+            {
+                case Script.Arabic: primary = secondary = Arab; return true;
+                case Script.Syriac: primary = secondary = Syrc; return true;
+                case Script.Mongolian: primary = secondary = Mong; return true;
+                case Script.Thaana: primary = secondary = Thaa; return true;
+                case Script.Khmer: primary = secondary = Khmr; return true;
+                case Script.Tibetan: primary = secondary = Tibt; return true;
+                case Script.Sinhala: primary = secondary = Sinh; return true;
+                case Script.Devanagari: primary = Dev2; secondary = Deva; return true;
+                case Script.Bengali: primary = Bng2; secondary = Beng; return true;
+                case Script.Gurmukhi: primary = Gur2; secondary = Guru; return true;
+                case Script.Gujarati: primary = Gjr2; secondary = Gujr; return true;
+                case Script.Oriya: primary = Ory2; secondary = Orya; return true;
+                case Script.Tamil: primary = Tml2; secondary = Taml; return true;
+                case Script.Telugu: primary = Tel2; secondary = Telu; return true;
+                case Script.Kannada: primary = Knd2; secondary = Knda; return true;
+                case Script.Malayalam: primary = Mlm2; secondary = Mlym; return true;
+                case Script.Myanmar: primary = Mym2; secondary = Mymr; return true;
+                default: primary = default; secondary = default; return false;
+            }
+        }
     }
 }
diff --git a/src/Avalonia.Base/Media/Fonts/Tables/ScriptListTable.cs b/src/Avalonia.Base/Media/Fonts/Tables/ScriptListTable.cs
new file mode 100644
index 0000000000..adae14c335
--- /dev/null
+++ b/src/Avalonia.Base/Media/Fonts/Tables/ScriptListTable.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+
+namespace Avalonia.Media.Fonts.Tables
+{
+    /// <summary>
+    /// Reads the script tags declared in a font's OpenType Layout (<c>GSUB</c>/<c>GPOS</c>)
+    /// ScriptList. A declared script tag signals that the font carries shaping rules for that
+    /// script — the signal used to decide whether a font can actually <em>shape</em> a complex
+    /// script rather than merely map its codepoints through cmap.
+    /// <see href="https://learn.microsoft.com/typography/opentype/spec/chapter2#script-list-table-and-script-record"/>
+    /// </summary>
+    internal static class ScriptListTable
+    {
+        private static readonly OpenTypeTag s_gsub = OpenTypeTag.Parse("GSUB");
+        private static readonly OpenTypeTag s_gpos = OpenTypeTag.Parse("GPOS");
+
+        /// <summary>
+        /// Adds the GSUB and GPOS script tags declared by <paramref name="glyphTypeface"/> to
+        /// <paramref name="scriptTags"/>.
+        /// </summary>
+        /// <returns>
+        /// <c>false</c> if a layout table is present but could not be parsed — the caller should
+        /// then treat shaping capability as unknown rather than unsupported (don't reject the font
+        /// on the strength of an empty set). An absent table is not a failure.
+        /// </returns>
+        public static bool TryReadScriptTags(GlyphTypeface glyphTypeface, HashSet<OpenTypeTag> scriptTags)
+        {
+            // Non-short-circuiting '&' so both tables are always attempted.
+            return TryReadScriptList(glyphTypeface, s_gsub, scriptTags)
+                 & TryReadScriptList(glyphTypeface, s_gpos, scriptTags);
+        }
+
+        private static bool TryReadScriptList(GlyphTypeface glyphTypeface, OpenTypeTag tableTag,
+            HashSet<OpenTypeTag> scriptTags)
+        {
+            if (!glyphTypeface.PlatformTypeface.TryGetTable(tableTag, out var table))
+            {
+                // An absent table simply contributes no scripts
+                return true;
+            }
+
+            try
+            {
+                var reader = new BigEndianBinaryReader(table.Span);
+
+                // GSUB/GPOS header: majorVersion, minorVersion, scriptListOffset, featureListOffset,
+                // lookupListOffset.
+                reader.ReadUInt16();
+                reader.ReadUInt16();
+                var scriptListOffset = reader.ReadOffset16();
+
+                // ScriptList: scriptCount, then scriptCount ScriptRecords of (Tag, Offset16).
+                reader.Seek(scriptListOffset);
+
+                var scriptCount = reader.ReadUInt16();
+
+                for (var i = 0; i < scriptCount; i++)
+                {
+                    scriptTags.Add(new OpenTypeTag(reader.ReadUInt32()));
+                    reader.ReadOffset16(); // scriptOffset — not needed
+                }
+
+                return true;
+            }
+            catch (Exception)
+            {
+                // Malformed layout table — capability unknown.
+                return false;
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Base/Media/GlyphTypeface.cs b/src/Avalonia.Base/Media/GlyphTypeface.cs
index 22aaf1c1c3..9edee48991 100644
--- a/src/Avalonia.Base/Media/GlyphTypeface.cs
+++ b/src/Avalonia.Base/Media/GlyphTypeface.cs
@@ -44,6 +44,13 @@ namespace Avalonia.Media
         private ITextShaperTypeface? _textShaperTypeface;
         private UnicodeRange? _supportedUnicodeRange;
 
+        // Lazily-built set of OpenType script tags the font declares in GSUB/GPOS, used by
+        // CanShapeScript. Parsing copies the layout tables, so it is deferred until a complex script
+        // is actually queried (most text never triggers it). Published via the volatile field.
+        private volatile HashSet<OpenTypeTag>? _shapingScriptTags;
+        private bool _shapingScriptTagsUnknown;
+        private readonly object _shapingScriptTagsLock = new();
+
         /// <summary>
         /// Initializes a new instance of the <see cref="GlyphTypeface"/> class with the specified platform typeface and
         /// font simulations.
@@ -543,6 +550,59 @@ namespace Avalonia.Media
             return false;
         }
 
+        /// <summary>
+        /// Determines whether this font can <em>shape</em> the specified script, not merely map its
+        /// codepoints. Scripts that need OpenType complex shaping (e.g. Arabic joining, Indic
+        /// conjuncts) require the font to declare the script in its GSUB/GPOS tables; scripts that
+        /// render acceptably from cmap alone always return <c>true</c>. Used by the fallback itemizer
+        /// to avoid selecting a font that has the glyphs but cannot form them correctly.
+        /// </summary>
+        public bool CanShapeScript(Script script)
+        {
+            if (!FontFallbackScriptHints.TryGetComplexShapingTags(script, out var primary, out var secondary))
+            {
+                // Simple script: cmap coverage (checked by the caller) is sufficient.
+                return true;
+            }
+
+            var tags = EnsureShapingScriptTags();
+
+            // A present-but-unparseable GSUB/GPOS leaves capability unknown — don't reject on that
+            // basis; cmap remains the authority as it was before.
+            if (_shapingScriptTagsUnknown)
+            {
+                return true;
+            }
+
+            return tags.Contains(primary) || tags.Contains(secondary);
+        }
+
+        private HashSet<OpenTypeTag> EnsureShapingScriptTags()
+        {
+            var tags = _shapingScriptTags;
+
+            if (tags is not null)
+            {
+                return tags;
+            }
+
+            lock (_shapingScriptTagsLock)
+            {
+                if (_shapingScriptTags is not null)
+                {
+                    return _shapingScriptTags;
+                }
+
+                var set = new HashSet<OpenTypeTag>();
+
+                // Set the "unknown" flag before publishing the set so a lock-free reader that sees the
+                // volatile set also sees the flag.
+                _shapingScriptTagsUnknown = !ScriptListTable.TryReadScriptTags(this, set);
+
+                return _shapingScriptTags = set;
+            }
+        }
+
         private UnicodeRange BuildSupportedUnicodeRange()
         {
             var segments = new List<UnicodeRangeSegment>();
diff --git a/src/Avalonia.Base/Media/TextFormatting/TextCharacters.cs b/src/Avalonia.Base/Media/TextFormatting/TextCharacters.cs
index cc48ed47c6..b52b992746 100644
--- a/src/Avalonia.Base/Media/TextFormatting/TextCharacters.cs
+++ b/src/Avalonia.Base/Media/TextFormatting/TextCharacters.cs
@@ -1,4 +1,6 @@
 using System;
+using Avalonia.Logging;
+using Avalonia.Media.Fonts;
 using Avalonia.Media.TextFormatting.Unicode;
 using static Avalonia.Media.TextFormatting.FormattingObjectPool;
 
@@ -9,7 +11,11 @@ namespace Avalonia.Media.TextFormatting
     /// </summary>
     public class TextCharacters : TextRun
     {
-        private static char ZeroWidthSpace = '\u200b';
+        // NUL characters render nothing but must keep their position in the run. WORD JOINER (U+2060)
+        // is a zero-width, default-ignorable, non-breaking filler; unlike ZERO WIDTH SPACE (U+200B)
+        // it introduces no line-break opportunity, matching NUL's lack of break semantics.
+        private const char WordJoiner = '\u2060';
+        private static readonly string s_wordJoinerRun = new string(WordJoiner, 8);
 
         /// <summary>
         /// Constructs a run for text content from a string.
@@ -95,60 +101,141 @@ namespace Avalonia.Media.TextFormatting
             //Detect null terminator
             if (count > 0)
             {
-                return new UnshapedTextRun(new string(ZeroWidthSpace, count).AsMemory(), defaultProperties, biDiLevel);
+                // Reuse a cached run of WORD JOINERs for the common short case to avoid an allocation.
+                var nullReplacement = count <= s_wordJoinerRun.Length
+                    ? s_wordJoinerRun.AsMemory(0, count)
+                    : new string(WordJoiner, count).AsMemory();
+
+                return new UnshapedTextRun(nullReplacement, defaultProperties, biDiLevel);
             }
 
-            if (TryGetShapeableLength(textSpan, defaultGlyphTypeface, null, out count))
+            // The first scalar's script drives both the locale-sensitivity check and the complex-script
+            // capability preference below.
+            var firstScript = Codepoint.ReadAt(textSpan, 0, out _).Script;
+
+            // The previous run's font is reused as a cheap anti-thrashing bias, but it bypasses the
+            // culture-aware fallback scorer. For locale-sensitive scripts (CJK Han unification) skip
+            // the reuse when the culture changed between runs so the culture-scored fallback runs
+            // instead - otherwise e.g. a zh run's font would pin ja text. Same-culture runs keep the
+            // reuse, so the common case pays only a culture comparison.
+            var allowPreviousTypeface = true;
+
+            if (previousGlyphTypeface is not null &&
+                !Equals(previousProperties!.CultureInfo, defaultProperties.CultureInfo) &&
+                FontFallbackScriptHints.IsLocaleSensitive(firstScript))
             {
-                return new UnshapedTextRun(text.Slice(0, count), defaultProperties.WithTypeface(defaultTypeface),
-                    biDiLevel);
+                allowPreviousTypeface = false;
             }
 
-            if (previousGlyphTypeface is not null)
+            // Capability preference (Strategy A): for a complex script, first try fonts that declare
+            // the script in GSUB/GPOS (so they can actually shape it), then fall back to cmap-only
+            // coverage. Simple scripts use a single cmap tier, so the common path is unchanged.
+            var capabilityTiers =
+                FontFallbackScriptHints.TryGetComplexShapingTags(firstScript, out _, out _) ? 2 : 1;
+
+            for (var capabilityTier = 0; capabilityTier < capabilityTiers; capabilityTier++)
             {
-                if (TryGetShapeableLength(textSpan, previousGlyphTypeface, defaultGlyphTypeface, out count))
+                // Tier 0 (only present when there are two tiers) requires the font to declare shaping
+                // support for the script; tier 1 accepts cmap coverage alone (the historical gate).
+                var requireShapingCapability = capabilityTiers == 2 && capabilityTier == 0;
+
+                // When this tier requires shaping capability, constrain the fallback search to fonts
+                // that can shape the script (Script.Unknown = the historical, unconstrained search).
+                var shapingConstraint = requireShapingCapability ? firstScript : Script.Unknown;
+
+                // Coverage tiers (full cluster, then base-only) run inside each capability tier. The
+                // fallback is resolved once per capability tier because the search constraint differs.
+                Typeface fallbackTypeface = default;
+                GlyphTypeface? fallbackGlyphTypeface = null;
+                var fallbackResolved = false;
+
+                // A primary that cannot shape this tier's script is not a valid "return target": pass
+                // null so the return-to-primary check doesn't hand clusters back to it, which would
+                // otherwise block a shaping-capable fallback that merely shares the primary's cmap.
+                var defaultCanShape = !requireShapingCapability || defaultGlyphTypeface.CanShapeScript(firstScript);
+                var primaryForReturn = defaultCanShape ? defaultGlyphTypeface : null;
+
+                for (var pass = 0; pass < 2; pass++)
                 {
-                    return new UnshapedTextRun(text.Slice(0, count),
-                        defaultProperties.WithTypeface(previousTypeface!.Value), biDiLevel);
-                }
-            }
+                    var requireFullCluster = pass == 0;
 
-            var codepoint = Codepoint.ReplacementCodepoint;
+                    if (defaultCanShape &&
+                        TryGetShapeableLength(textSpan, defaultGlyphTypeface, null, requireFullCluster, out count))
+                    {
+                        // Primary font: the properties already carry this typeface, so reuse them
+                        // directly. This avoids a needless copy and preserves a custom
+                        // TextRunProperties subclass that WithTypeface would otherwise flatten.
+                        return new UnshapedTextRun(text.Slice(0, count), defaultProperties, biDiLevel);
+                    }
 
-            var graphemeEnumerator = new GraphemeEnumerator(text.Slice(count).Span);
+                    if (allowPreviousTypeface && previousGlyphTypeface is not null &&
+                        (!requireShapingCapability || previousGlyphTypeface.CanShapeScript(firstScript)) &&
+                        TryGetShapeableLength(textSpan, previousGlyphTypeface, primaryForReturn, requireFullCluster, out count))
+                    {
+                        return new UnshapedTextRun(text.Slice(0, count),
+                            defaultProperties.WithTypeface(previousTypeface!.Value), biDiLevel);
+                    }
 
-            if (graphemeEnumerator.MoveNext(out var grapheme))
-            {
-                codepoint = grapheme.FirstCodepoint;
-            }
+                    // Resolve the fallback once, after the primary/previous probes fail. It is keyed on
+                    // the first scalar the primary font cannot render - the base for an unsupported
+                    // script, or the combining mark for an otherwise-supported cluster - so the search
+                    // can find a font for the mark, not just the base. Reused by every pass.
+                    if (!fallbackResolved)
+                    {
+                        fallbackResolved = true;
 
-            var matchFound =
-                fontManager.TryMatchCharacter(codepoint, defaultTypeface.Style, defaultTypeface.Weight,
-                    defaultTypeface.Stretch, defaultTypeface.FontFamily, defaultProperties.CultureInfo,
-                    out var fallbackTypeface);
-                        
-            if (matchFound)
-            {
-                // Fallback found
-                if(fontManager.TryGetGlyphTypeface(fallbackTypeface, out var fallbackGlyphTypeface))
-                {
-                    if (TryGetShapeableLength(textSpan, fallbackGlyphTypeface, defaultGlyphTypeface, out count))
+                        var fallbackCodepoint = GetFallbackCodepoint(textSpan, defaultGlyphTypeface);
+
+                        if (fontManager.TryMatchCharacter(fallbackCodepoint, defaultTypeface.Style, defaultTypeface.Weight,
+                                defaultTypeface.Stretch, defaultTypeface.FontFamily, defaultProperties.CultureInfo,
+                                shapingConstraint, out fallbackTypeface)
+                            && !fontManager.TryGetGlyphTypeface(fallbackTypeface, out fallbackGlyphTypeface))
+                        {
+                            // The platform matched a fallback family but its glyph typeface could not
+                            // be loaded; the cluster degrades to .notdef. Surface it for diagnosis.
+                            Logger.TryGet(LogEventLevel.Warning, LogArea.Fonts)?.Log(null,
+                                "Matched fallback typeface {FamilyName} for codepoint U+{Codepoint} but could not load its glyph typeface.",
+                                fallbackTypeface.FontFamily.Name, ((uint)fallbackCodepoint).ToString("X4"));
+                        }
+                    }
+
+                    if (fallbackGlyphTypeface is not null &&
+                        TryGetShapeableLength(textSpan, fallbackGlyphTypeface, primaryForReturn, requireFullCluster, out count))
                     {
-                        return new UnshapedTextRun(text.Slice(0, count), defaultProperties.WithTypeface(fallbackTypeface),
-                            biDiLevel);
+                        return new UnshapedTextRun(text.Slice(0, count),
+                            defaultProperties.WithTypeface(fallbackTypeface), biDiLevel);
                     }
-                }          
+                }
             }
 
-            // no fallback found
+            // No font (not even a last-resort match) covers the first cluster. Coalesce the
+            // following clusters that likewise have no home into a single .notdef ("tofu") run,
+            // then hand control back so the next run can be selected normally. We must stop as
+            // soon as a cluster the primary font - or any fallback - can render is reached;
+            // otherwise a renderable cluster following an unmatchable one would be swallowed as
+            // tofu too (e.g. a private-use codepoint immediately followed by CJK text).
             var enumerator = new GraphemeEnumerator(textSpan);
 
-            //Move forward until we reach the next base character
-            while (enumerator.MoveNext(out grapheme))
+            while (enumerator.MoveNext(out var grapheme))
             {
-                if (!grapheme.FirstCodepoint.IsWhiteSpace && defaultGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(grapheme.FirstCodepoint, out _))
+                var firstCodepoint = grapheme.FirstCodepoint;
+
+                if (!firstCodepoint.IsWhiteSpace)
                 {
-                    break;
+                    // Primary font regained coverage - return to it.
+                    if (defaultGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(firstCodepoint, out _))
+                    {
+                        break;
+                    }
+
+                    // A fallback exists for this cluster - stop so the next run can use it. The
+                    // first cluster is skipped (count == 0): we already know it has no match.
+                    if (count > 0 &&
+                        fontManager.TryMatchCharacter(firstCodepoint, defaultTypeface.Style, defaultTypeface.Weight,
+                            defaultTypeface.Stretch, defaultTypeface.FontFamily, defaultProperties.CultureInfo, out _))
+                    {
+                        break;
+                    }
                 }
 
                 count += grapheme.Length;
@@ -163,12 +250,18 @@ namespace Avalonia.Media.TextFormatting
         /// <param name="text">The characters to shape.</param>
         /// <param name="glyphTypeface">The typeface that is used to find matching characters.</param>
         /// <param name="defaultGlyphTypeface">The default typeface.</param>
+        /// <param name="requireFullCluster">
+        /// When <c>true</c>, a grapheme cluster only counts as supported when the typeface has a glyph
+        /// for every scalar it contains (base plus combining marks); when <c>false</c>, only the base
+        /// scalar is tested.
+        /// </param>
         /// <param name="length">The shapeable length.</param>
         /// <returns></returns>
         internal static bool TryGetShapeableLength(
             ReadOnlySpan<char> text,
             GlyphTypeface glyphTypeface,
             GlyphTypeface? defaultGlyphTypeface,
+            bool requireFullCluster,
             out int length)
         {
             length = 0;
@@ -192,17 +285,19 @@ namespace Avalonia.Media.TextFormatting
                     break;
                 }
 
+                var clusterText = text.Slice(currentGrapheme.Offset, currentGrapheme.Length);
+
                 if (!currentCodepoint.IsWhiteSpace
                     && defaultGlyphTypeface != null
-                    && defaultGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(currentCodepoint, out _))
+                    && ClusterIsCovered(clusterText, currentCodepoint, defaultGlyphTypeface, requireFullCluster))
                 {
                     break;
                 }
 
-                //Stop at the first missing glyph
+                //Stop at the first cluster this typeface can't render
                 if (!currentCodepoint.IsBreakChar &&
                     currentCodepoint.GeneralCategory != GeneralCategory.Control &&
-                    !glyphTypeface.CharacterToGlyphMap.TryGetGlyph(currentCodepoint, out _))
+                    !ClusterIsCovered(clusterText, currentCodepoint, glyphTypeface, requireFullCluster))
                 {
                     break;
                 }
@@ -228,5 +323,75 @@ namespace Avalonia.Media.TextFormatting
 
             return length > 0;
         }
+
+        /// <summary>
+        /// Determines whether <paramref name="glyphTypeface"/> can render the first grapheme cluster in
+        /// <paramref name="clusterText"/>. For a single-scalar cluster, or when
+        /// <paramref name="requireFullCluster"/> is <c>false</c>, only the base scalar is tested.
+        /// Otherwise every scalar that needs a glyph (excluding break chars and control/format
+        /// codepoints) must be present, so a base+mark cluster is only covered by a font that has the
+        /// marks too.
+        /// </summary>
+        private static bool ClusterIsCovered(ReadOnlySpan<char> clusterText, Codepoint firstCodepoint,
+            GlyphTypeface glyphTypeface, bool requireFullCluster)
+        {
+            var baseLength = firstCodepoint.Value > 0xFFFF ? 2 : 1;
+
+            if (!requireFullCluster || clusterText.Length <= baseLength)
+            {
+                return glyphTypeface.CharacterToGlyphMap.TryGetGlyph(firstCodepoint, out _);
+            }
+
+            var codepoints = new CodepointEnumerator(clusterText);
+
+            while (codepoints.MoveNext(out var codepoint))
+            {
+                if (codepoint.IsBreakChar || codepoint.GeneralCategory is GeneralCategory.Control or GeneralCategory.Format)
+                {
+                    continue;
+                }
+
+                if (!glyphTypeface.CharacterToGlyphMap.TryGetGlyph(codepoint, out _))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns the first scalar of the run's first grapheme cluster that
+        /// <paramref name="defaultGlyphTypeface"/> cannot render - the base for an unsupported script,
+        /// or a combining mark for an otherwise-supported cluster. Keying the fallback search on this
+        /// lets it find a font for the mark, not just the base. Falls back to the cluster's first
+        /// scalar when every scalar is already covered.
+        /// </summary>
+        private static Codepoint GetFallbackCodepoint(ReadOnlySpan<char> text, GlyphTypeface defaultGlyphTypeface)
+        {
+            var graphemeEnumerator = new GraphemeEnumerator(text);
+
+            if (!graphemeEnumerator.MoveNext(out var grapheme))
+            {
+                return Codepoint.ReplacementCodepoint;
+            }
+
+            var codepoints = new CodepointEnumerator(text.Slice(grapheme.Offset, grapheme.Length));
+
+            while (codepoints.MoveNext(out var codepoint))
+            {
+                if (codepoint.IsBreakChar || codepoint.GeneralCategory is GeneralCategory.Control or GeneralCategory.Format)
+                {
+                    continue;
+                }
+
+                if (!defaultGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(codepoint, out _))
+                {
+                    return codepoint;
+                }
+            }
+
+            return grapheme.FirstCodepoint;
+        }
     }
 }
diff --git a/tests/Avalonia.Skia.UnitTests/Fonts/NotoSansArabic-NoLayout.ttf b/tests/Avalonia.Skia.UnitTests/Fonts/NotoSansArabic-NoLayout.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..40962448c9f4624025e57386fdcc993f16ef4d64
GIT binary patch
literal 2740
zcmcguO>7%g5T3VduM?+n2wCT^wPoCrmMU=^$8kd1rsS_l$dA=H5W<hCV>@<QCys2V
zNh(1rsA$zwB_yb-9(sdHKsmszCk`Ac#Gz6p{tmza6{vs%AS%(AZ{Ds+npQ|~U{`P7
z%)FU-GvCa6HVGoCpi`uhKOAWdoIUW|43X%9^hji?cj}j$U;R#GKM#Iad?B`^^=q$U
z{eAHJQ<=57BMpD-0{<t*>2xxdcvPuUv33n3l!l<ZL3lv_im@xbP*`=ig$CUV;OjHl
zc#PJG{oMxdSct7Ik%J20>%n^#V++YEKYx0TNIgZQeXx|x7j6%{vyOOzSf3$|T@l*t
z?1xP+R_*_dRP`1l^yLj#gy-*~@0}t0`f>HDaviKj3QO_8&KkYzhTm_<PL1kS>B(3#
zzM7P1bPzV}z=n6)cogs!byA!sD*`yDJcFfCV-`^g(AOKPOnL5Mhr;0@@r1TpYc^uA
zMwM@&Aa@YQ#bwYQs)Elb{Y1lv&`ob5M$F1dM2ihE7-QXxOD7BM0k2^eq-cAz=3)^n
zb|@C_d~xS<!#6besiX#KrK9u_XhFmHz6*5VFR!-OJg*<tmFssyuy+?*)T`oktqER<
zY@~{d#qVL!SRA02if^H3XxiJ<5e&5lYMr_^=5)E7y32LVrR#3DuDdu+ckxH|K@U?C
z(O_qwN9hPQ?e26dPTisG^!mVtLY;LE@U^w=b>g+g<tqyvJ8H)(>mCZdeDm_mnP+`v
zm9|lf-PUn>MR!ha+urJJN<6;ZGcx4f7YWwa`NumOIzkOKRgdkh4jyy`cvn<hnFfv(
z)Pr3&#i+_1d(=*wPu=O&Y`a4U-mTWP*LfWlr|wqT1Bgb`MAS^ie&}SZ%i9}W9ja&y
zb@w&7TXaWb?<2n9-r<=8<%&OZY<9G{c|6(GmTKG4eIi%Nef^fFe{QgQ{)LGH&dRcy
zYP;R~WJP6leM7aFtlislINlu`_18LU26k)*w$*flD`_bQoyIU|fj&x`w1QJ{(WF)C
zqqj}kvPs8Ejr4;l*Qi-oOxi|$!f(=Lv{&Rzx}1)ROD1inR}{^pftqsGq_@$2<zths
zRNhb(lXg(hdcmO4w%e?qn6x0f^)u?HEG^L*<!GK#$f1CK4v?SPsDoN0#hizRpqGV4
zhLYgM@b;4rR4*hM%#(lH=Ove<JT!B39Nz>qCtzK`@KA(ew1`!<&4HeUWgHx9jDcUn
zybRq*Sf)T_Aj=^VAL8&+koF;#Fy0|hC9fr)n?1H{@$j^aCy(8-*q^g3dHg3YTcaxJ
zdf<n1h+!0D9trqgkg*<vEK76vJ_xmOxj&<^2ILvd5owo#$3<k!{2~zX(fyhO(B}+N
zGJ`2_G1xZ4W&%_~dSH+JsALR-Ju=UTC#2RqodA~ueb|(;-e$jCFAu7+hVTCu0e4;j
zcy!~wYo!(W`jF>F*ZF`+7TLB!nuKmEax!|VRrc-u)(cyZ-tdrz{j$U>OH&djuH_-A
z&nF-PY7ROp5-Uc~sCEW(9J_P>8aORWWVzG157H9t2r4)RJ}m3Yy|&?b>>dwXxvhQK
zhRXBs{Hw^g_M8=;<5_urjQEUR=lXldixU^YJc6$mbD!jy<2a@vpTciUn4ZGSd@oMW
zB)${iM`%#mh9Tkp3PU;|Ek-2Ge#6L<PxS<T?L9P#Rn}qONknC!!#E{r70Bc;=kfAc
zVd*?-yM)s|4>{i$T!kdw|AMOr)ib=7YLb_=h{O9FMjT%GUg7h$jF~%%<K*+0LmZ4{
z>89WaOXr89<JAHr1<Z^tuXCUBO_u{-I>p94#+fZchx0J*1dhn)rj4%H+Hbxs9i2zS
zT-hb;ng=!<TLv@dn8Hb5<i}7k#@V>Vr$Hqo=H~yX;w9X84|@0?o+4CX5muqumKW#!
wp+KiOci9u!!fY~=U5VukQE1Ry>Std9Z<+j$qnoakl~lSQz^o(+X@T{>0BM@XIRF3v

literal 0
HcmV?d00001

diff --git a/tests/Avalonia.Skia.UnitTests/Fonts/NotoSansJP-Subset.ttf b/tests/Avalonia.Skia.UnitTests/Fonts/NotoSansJP-Subset.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..8d53a5bb358284fdf9db634f760bd19b2d1a4e0b
GIT binary patch
literal 3756
zcmb_fYit}>6+U-nch<YM*IvhVoYar;YyF6yYw!9IC-u5c;>33BcpaR!sok}`-d%gw
zyV>3PMcTALi3tYrBLz{aib^d4sXqdZ6eNloB4{f_8&Ro$P>_%a5b-A<@%Ynv`OeI2
zVv`6J#EkCTbM8I&JidF*of#5DRDg$x)B&&W$d+<_h$tscBy7jV$9y0D=H^+V-1CrH
zIOaP&Fm-pp4*oXy#W7#2>q~7vutE0w;GgzQdMDRj3;mVIJ`TQdF6xg*8VjxxNrmA1
zg8n4*Qa<#D&}RiB>kA*eRM~*}d9;^90sp+ymIHgD3G<#12C|}ZH+albO(>dLGu@>R
zAe#l=7KzRI#cjF<{tWX`|5}`~XbJM0;MHY+H1N^PpY9Tw!CH>SW64zd%jAOnA)b#X
z0`ZWt^&-}@zm^r)Gv6wJKX#6{W`*rtqjvD$1#ct9N)pOH27f&~lh^lmlI1%Xp<7p~
zD!BjS^c#;;IQ_P~AwLRMA&EzEF}$1GzaxTtn3m-YO_MfdJcKr4qD7Lm5w^7ZGRYs)
zJO?6O(xM&KdofKeaRj5;8DqRGYX{>U92leiwt<t)ay$)OOq)W@cqUayzlFF;3Ot*q
z3-AsSxOhE#Qivz}Qi%MhN3Wn4B(b)1nn>?&zVpM6H7N-ESfpRPV)_~=T;HN=Vidhh
z7t*)n6*-4W=m2bxS5Yi>si?5Hc(0{Ja(5n<x;!4Y#pUsI?X}C*RZeGJUAbhoOOUcC
z3J(}U9j@ZyqC$+;9mYDRv%1RA)Zy|#M;AuLJCa$l<k|A~+sp0y@+{d_S%{@mS6)9X
zdOrW$Mpu4!cY$#9^@vv`*(6m=2720p4P~wSn}%mPU9pCzUl^!AwK1`0^6OK5=O%iW
z>K|S5)>hO#)iHL_DI{6WHtn_6e&IXAu0*uS)_iWw?MX%+FU{FwzLZm#TWQV9RwP+e
z%Zhx)WVI^OuRhn}JW$eF<?>G*LBIn`hdnc+ZhNWKdv3gIy0^@+e<s;mTT|OO@bfLR
zH5(f&-^(EjWm6uJuhLQNK<lb3suUfL>agr6`?R6VA^r1Hs|b~sOBc6~i<h_kvt?52
zC(mO2X8QMXOg8@~v^)QAXx{*c=KSp3eU8e!y}63bDoerfH(xs>y4TOIdh)xv9HOYl
zEnZ@<%SUGqwFVkWoA)&yf2zY3sh_^!ts7fARp9&TWN&=Dd$I0NxWBr>Iqe#Kp_aim
zSqigip1pj+9Syr|u1LJgeQt5;k?cL@i`j*_sx{BXU{?X`DN~kJIs5I6_Syp_EtTyv
zrym2@-q0cU^spzl%-SD2={eh7>e&Beyr;(LZ17&cWVYG>HZBK!#93~#f_?=}rv=b^
z#h@j!(^Z3(sh@5bv}uQonHGg)j4Pyyh(TNEn_|nLv&be@8MIYgmYNLOCT#L`gU+T-
z(=QD=S5%p{4cbnfifYjNs8E^IX(1>_32C$gHOM~K(;PLRrd`yAv#XPuHOd8AB`>Nx
zMza(ET~8rO;f_-;wc=jY?iTXjlWBpb7)3GHKuuV&irP(Kl}Z!PkVH$+3ZC;AISR>T
z%&K$}8lswoI`U!k8A#26ucH>s#UK-dln+wN(4o=^8rSp%AsNAF0{*tZ_cr)`5FQWG
z0F8mltj(<Cb<H#he{iN6l4FoPLZ8z-OJbaTVk9#9nrR5!L9AgvIJ#v-paL6~XhGjj
z-I$NUk0oefsRi_FXu2LZq&(zCYom^b`s70#vl=?7UGb~%hvW65r4S|K9MCK!U`vIq
z1w41|5XZ%`A<g<}aE!l>w-1zG<8+<N(AEka2~Cr}hG~xR8LVWBVXRHU|NAy3XdUxQ
zXuNO7;qMThPta)^hLrl13um5)zWwAlX6qrvJLcCiVHPXmXi>BUZM73JVJ)H<1-0nn
z@H>gjIf$8YtmEBPv70S;4jDeN-VrShj+Jxl7}f@GGa{_>F?h(HM{tJ`jjm760nTL}
zXDRk2s%d2@Mn>O#pmY7oTfh47_D^2_(fc>)z0}XnXm&U=W5^$lpYaJo%L&AM5+11U
zy>X-DU14}|;+`bu1Mdi9qshHl^!_Km_zOn3mKYs9hgJ9=LE|c5<dd339^rc9s^LB3
z=#sF{5%`fYJkNLyVxBP?)>f;)hyCMRVLNfm#_*jGK$Ki<TrYF5u4e|1F^WNGTZb&y
zD%UAXvW5l7=~<Mi4fZ0YRWWCzj;3y79(GxuE~(=_3YjDt=N{(+@1z$sIEf0KK<22y
z+;7}jn%laHnT)Ty_2_Xwm?;lp)&TE6>-m(@q79$|^z(r6y?-L{UN1n`Dm>=w%2cAB
zQM^Zt5uaiiq`7i3b>~A|BjCq?C(G{CJOXt1Y|}L`^8bGJ@X5kW-Qn48yBTl%*abiI
z-Oq-dCoW@s6j+}^&-nME&)}0ZPVgjr;aZ7fp6i@XzzBLi6@tKK3>rr6t<q2Z&$i}a
zXYUl^4nr?{!Ea6NN`DdO>%%U5;o^%i5AP_vv5>z+e@4!mNEtjjGD*(4^+bfagNeWr
zb%*@RVRA0{m;L07_*2U`krhp)1o?8Rp+@?iF(P9mhYIlCyG(NWr$A7a57K$q+QdvT
znZk1mvuLUCd?1#HMVJ2vdyP2jdw1C@fe-bF*sYH~kLcyMG+KZb@KxZA!F`VQEXEUD
zKW^>I8uT9?(WLmVq7UcJP86IP3eE>ma3UgHKvA=>68A^&x0A8Q-{nkaq1kZPrQZc5
zw0+?j8y!Z4{&#lxF92WrD}h9c>??_s3*SKxv&VlrY)kh*_ksTzm@g%1H5f_>rdf(F
j2WpKkkx$}p+c|*m4r-)R#-E}gp-nS~8G>{>P8<3cP3(8T

literal 0
HcmV?d00001

diff --git a/tests/Avalonia.Skia.UnitTests/Fonts/NotoSansSC-Subset.ttf b/tests/Avalonia.Skia.UnitTests/Fonts/NotoSansSC-Subset.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..26e9f744dcbbb6532370bf5af58d8cb2c64a8a40
GIT binary patch
literal 3020
zcmbVOTWnNS6y4|EVcJg1qfH?Y9$ug+Ez))<1siI#Eo~_<cA!%fF+p#q^P=<0%+LqX
zNMg`xYGNYs!}y^_6cayC_%IO@Bq+ofO^E(M;)fby{Ln=42Rg2G?wvk>58}N!=j?s<
zKKrrGKIdLhB2t6SBUX1;sCU|Xv0udJ5mCO~`-7pLvA{8r%4N{9c83mjr`n!w2JZ*o
z9SpU!zQ6k88t9$@|6FLOYiQ!V_+OA0z;6zx?5tD`oDea%zAa|wvlu~F+{RcQOHM}L
zyqx+8@*(h@@rXTA?^|*M_O^iE5ywP%%4`Qe0=_PuDol6|2xy}myf>K%+hTzdBS1c7
zPh`a_)zF^;Z>8;2<l4i3cp*O}Qr4Hv<O{`@r4|0KQ=ZL5vT^V9NyvM^myN;SqU$w{
zi2q&ibz}6m3Y1h{M&}h`Whn2hTW3a}UHa%hVwyK8y?(atBaXivIXx(e;sx`#`8Zgw
z7@WmJc&BE57J+_3(&lk(NsHW0Iktg~sb}bE;o~uHAoE2C;5FkAMEjgk9g$Ymi`mMO
zGcF@MrKhW>J1Ct4O#@A4wg_B2Q_8|_>&JM=0NTLNi^xV08y^~C6t(CXM=fguqX#ee
zfu>^7=|BBZ%jI)bJbBjhI#lpjXyz;mWl||iMMCSVH&&xPvVQq`wXJ$%!mM6<r*Uny
z@$a1q6<@c`cx7gfdV9tmUTd`6egPJ$<r=+vDnP%ZEs|EU5}Y${$Pzj4(x!CEC71Th
z(^(`(mEq2N#ZpO^E|a&^v`d$Z&)DG773!3+#if19XI^yaN@??a>(YzW2G5L3FOfE{
z<<hI9);r|TN=cPBPP&|kG3EvdOCzvp6~AniHfhpSD`-o)fP6-VB?7uZ;!?nym7UUp
zcU-^CV$bR{!%{|4kTuE{tQg0x6|l;ZL0HJ6<zx)~2xj`AnTFJo0a!?B51S-}*<;WO
zgWn|0kY%8gfmR4wY1kmOOWTV<Gl|(8;%!Fke#G8^h<l`4f}l!kODnmqNrn&)>fF@~
zLbq3*)RE;e&zOir$zGH6gX_Q=#=-2;$iM<N)M&=IRoWp>A&ya4p;i>*1e#-KJG6Gl
zb~L|iyKhV(<T0$#DJ;m}LOjfu_ecR*66c8al!Gq|zM|;o?-28%Zd`jm2#)wWc!xmQ
znsaQXVXXx=a@vx!hBR|LhL!Y~z}h_GpYt&&laP<1ao_eJ-hT9l<)G|?mi6k3hYqJM
zJhLCt2551|Y+VV%Sdm3bp+)uTdgvr{Mj46e?6QbEkILzQWIxt%cP;E@Gx~lvCfW_?
zJeVtMY&X_M@DdT)+=U1kc@l2|**Nx`8elDRo?470rL9tn$T+(XbS|Df_ucoueDT3&
zSAUQzg|7~2Kdj6Q>WBFgpBSv{Ma~0=z`An!(#mg?8^PXLP1XZ<gxF}kPnKW3{q>)i
z;aMU&P7Pa#KZ(XuK;-k<BWHNtcxt$3%q|cA%)my)P)@vhASXuq^lA(EFh14_{bV7{
z$Wd@%*kU#Dbny((GUte54Av&0%d^UJN=;gbLeHt9(%E1X8GVXbkq(-Uj}iE#Jx9~Q
z{R!yg(O7$|2kvAS&fpME=pZV`iY<QQ=4g2OJS3%97us?1zPD2D#jFw0Kj{5b(Ah?C
z0-XDR_|Dx(-0LW8jU!@KSLq}=6~#RwM!dyJNb}^B&Rqz31;7V^Cw1pr4gekAZH@&Z
zfA`(Pn}yAq7uiC;rD$yIf(?6f)iD3YCDwhw`T$1azY}8#pS*j6=Mf9fN)~dSbKZbS
zjJy?Mz$OR_f!S5gt^Z(a?sxY-g}f86%P5?$IELa&xL@!0;I9MU@}>Aj;fsa(75N=C
z?-6fLUtmb;!;`tBw8wIhQE89c>4eme+G$(rlXfAE8yWvqcns*TlRDWfAG$LpW~!tH
z-@Q{}7QY07rr9CS!`BofE5wrsM~Bf0iIGSqmr14nhri9Z>vt~jw-PZl;G4VMnLUB*
z&2ySopcNuj_+oIZ()|kb;5zZ@KOWG(uGU)k{gpMyNof?y5i=hC^XP{beDWBU%}2?v
zQSxh){2C>{M#+EI>XHqGUo={()%_YV#$)k<;*6nZ_y;timDMs)f6r7QotvoHHuF4Y
NsW<m1{TI4b<UbLO@fiRB

literal 0
HcmV?d00001

diff --git a/tests/Avalonia.Skia.UnitTests/Media/FontCollectionDeterminismTests.cs b/tests/Avalonia.Skia.UnitTests/Media/FontCollectionDeterminismTests.cs
index a630a63615..87d7ba876b 100644
--- a/tests/Avalonia.Skia.UnitTests/Media/FontCollectionDeterminismTests.cs
+++ b/tests/Avalonia.Skia.UnitTests/Media/FontCollectionDeterminismTests.cs
@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using Avalonia.Media;
 using Avalonia.Media.Fonts;
@@ -12,7 +13,7 @@ using Xunit;
 namespace Avalonia.Skia.UnitTests.Media
 {
     /// <summary>
-    /// Verifies that <see cref="FontCollectionBase.TryMatchCharacter"/> resolves the same family
+    /// Verifies that <see cref="FontCollectionBase.TryMatchCharacter(int, FontStyle, FontWeight, FontStretch, string?, CultureInfo?, out Typeface)"/> resolves the same family
     /// regardless of the order in which fonts were added to the collection, and is stable
     /// across repeated invocations.
     /// </summary>
diff --git a/tests/Avalonia.Skia.UnitTests/Media/FontCollectionTryMatchCharacterTests.cs b/tests/Avalonia.Skia.UnitTests/Media/FontCollectionTryMatchCharacterTests.cs
index c8f91393dd..ad10048298 100644
--- a/tests/Avalonia.Skia.UnitTests/Media/FontCollectionTryMatchCharacterTests.cs
+++ b/tests/Avalonia.Skia.UnitTests/Media/FontCollectionTryMatchCharacterTests.cs
@@ -14,7 +14,7 @@ using Xunit;
 namespace Avalonia.Skia.UnitTests.Media
 {
     /// <summary>
-    /// Exercises the tiered <see cref="FontCollectionBase.TryMatchCharacter"/> algorithm
+    /// Exercises the tiered <see cref="FontCollectionBase.TryMatchCharacter(int, FontStyle, FontWeight, FontStretch, string?, CultureInfo?, out Typeface)"/> algorithm
     /// (Tier A → Tier E) using a small set of embedded test fonts and a stub subclass
     /// that intercepts the platform-fallback hook.
     /// </summary>
@@ -220,6 +220,59 @@ namespace Avalonia.Skia.UnitTests.Media
                 null, null, out _));
         }
 
+        // Regression for the "中华人民共和国 second codepoint is tofu" report. A positive (script,
+        // culture) bucket entry records a preferred family, but it must not suppress the Tier D
+        // platform lookup for another same-script codepoint that family cannot cover. Here 中 (U+4E2D)
+        // resolves to the Noto Sans SC subset, which lacks the Simplified-only 华 (U+534E); 华 must then
+        // reach the platform (which can place it) rather than be denied and rendered as tofu.
+        [Fact]
+        public void TierD_Positive_Script_Cache_Does_Not_Block_Platform_For_A_Codepoint_The_Bucket_Font_Lacks()
+        {
+            using var app = StartApp();
+
+            const int zhong = 0x4E2D; // 中 — covered by the Noto Sans SC subset
+            const int hua = 0x534E;   // 华 — Simplified-only; absent from the SC subset
+
+            var collection = new RecordingFontCollection(new Uri("fonts:bucket-coverage", UriKind.Absolute));
+
+            // Latin primary (covers neither ideograph) plus the SC subset that covers 中 but not 华.
+            LoadFonts(collection, "NotoMono-Regular.ttf");
+            LoadFontsFromFontsNamespace(collection, "NotoSansSC-Subset.ttf");
+
+            // The SC subset is Thin (weight 100). Resolve at that weight so the Tier C exact-key upgrade
+            // (covered by the dedicated weight test) does not fire here, leaving this test to isolate the
+            // Tier D positive-bucket behaviour and its platform-call count.
+            const FontWeight weight = FontWeight.Thin;
+
+            Assert.True(collection.TryGetGlyphTypeface(
+                "Noto Sans SC", FontStyle.Normal, weight, FontStretch.Normal, out var scGt));
+            Assert.True(scGt.CharacterToGlyphMap.TryGetGlyph(zhong, out _));
+            Assert.False(scGt.CharacterToGlyphMap.TryGetGlyph(hua, out _));
+
+            // The platform can place 华 (MiSans covers it). It is deliberately NOT in the collection,
+            // so only Tier D can supply it.
+            var miSans = LoadStandaloneGlyphTypeface("Avalonia.Skia.UnitTests.Assets.MiSans-Normal.ttf");
+            Assert.True(miSans.CharacterToGlyphMap.TryGetGlyph(hua, out _));
+            collection.PlatformFallbackResult = miSans;
+
+            var zh = CultureInfo.GetCultureInfo("zh-CN");
+
+            // 中 resolves from the loaded cache (Tier C) and writes the (Han, zh-CN) bucket. The platform
+            // is not consulted for it.
+            Assert.True(collection.TryMatchCharacter(
+                zhong, FontStyle.Normal, weight, FontStretch.Normal, null, zh, out var zhongMatch));
+            Assert.Equal("Noto Sans SC", FamilyOf(zhongMatch));
+            Assert.Equal(0, collection.PlatformCallCount);
+
+            // 华 shares the bucket but the bucket font lacks it. Before the fix the positive entry made
+            // Tier D treat the bucket as "platform already attempted", so 华 returned no match. It must
+            // now reach the platform and resolve to a font that covers it.
+            Assert.True(collection.TryMatchCharacter(
+                hua, FontStyle.Normal, weight, FontStretch.Normal, null, zh, out var huaMatch));
+            Assert.Equal("MiSans Normal", FamilyOf(huaMatch));
+            Assert.Equal(1, collection.PlatformCallCount);
+        }
+
         [Fact]
         public void Match_Typeface_Carries_The_Requested_Style_Weight_And_Stretch()
         {
@@ -238,6 +291,109 @@ namespace Avalonia.Skia.UnitTests.Media
             Assert.Equal(FontStretch.Condensed, match.Stretch);
         }
 
+        // Regression for the "Normal CJK fallback renders bold" report, generalized across the whole
+        // FontCollectionKey. The (script, culture) bucket is key-agnostic, so once one face of a fallback
+        // family is resolved, a later request that differs in ANY axis (weight via Bold, style via
+        // Oblique) must still resolve its own face, not reuse the cached neighbour. Stretch travels the
+        // same path. The leak is order-dependent, so both orders are checked.
+        [Theory]
+        [InlineData(FontSimulations.Bold, FontSimulations.None)]    // weight: Bold then upright Normal (Sandbox order)
+        [InlineData(FontSimulations.None, FontSimulations.Bold)]    // weight: reverse
+        [InlineData(FontSimulations.Oblique, FontSimulations.None)] // style: Italic then upright
+        [InlineData(FontSimulations.None, FontSimulations.Oblique)] // style: reverse
+        public void Fallback_Resolves_The_Requested_Typeface_Not_A_Cached_Neighbour(
+            FontSimulations first, FontSimulations second)
+        {
+            using var app = StartApp();
+
+            const int aleph = 0x05D0; // Hebrew — absent from any Latin primary, so it needs fallback.
+
+            // One family ("Noto Sans Hebrew") exposed by the platform as several faces (Regular plus a
+            // synthetic Bold and Oblique), modelling a .ttc whose styles/weights are separate faces. All
+            // cover aleph (same underlying font).
+            var faces = new Dictionary<FontSimulations, GlyphTypeface>
+            {
+                [FontSimulations.None] = CreateGlyphTypeface(FontSimulations.None),
+                [FontSimulations.Bold] = CreateGlyphTypeface(FontSimulations.Bold),
+                [FontSimulations.Oblique] = CreateGlyphTypeface(FontSimulations.Oblique),
+            };
+
+            var collection = new KeyedFallbackCollection(new Uri("fonts:key", UriKind.Absolute), aleph);
+
+            foreach (var face in faces.Values)
+            {
+                collection.AddPlatformFace(face);
+            }
+
+            var firstFace = faces[first];
+            var secondFace = faces[second];
+            var culture = CultureInfo.GetCultureInfo("he-IL");
+
+            // First face: resolved via the platform (Tier D) and pins the bucket to the family.
+            Assert.True(collection.TryMatchCharacter(
+                aleph, firstFace.Style, firstFace.Weight, FontStretch.Normal, null, culture, out _));
+
+            // Second face: same family, same bucket, different key. It must come back as its own key.
+            Assert.True(collection.TryMatchCharacter(
+                aleph, secondFace.Style, secondFace.Weight, FontStretch.Normal, null, culture, out _));
+
+            Assert.True(collection.TryGetGlyphTypeface(
+                secondFace.FamilyName, secondFace.Style, secondFace.Weight, FontStretch.Normal, out var secondResult));
+            Assert.Equal(secondFace.ToFontCollectionKey(), secondResult.ToFontCollectionKey());
+
+            // The first face stays correct too.
+            Assert.True(collection.TryGetGlyphTypeface(
+                firstFace.FamilyName, firstFace.Style, firstFace.Weight, FontStretch.Normal, out var firstResult));
+            Assert.Equal(firstFace.ToFontCollectionKey(), firstResult.ToFontCollectionKey());
+        }
+
+        // Regression for "中华人民共和国: the first glyph is Normal but 华人民共和国 stay bold". A codepoint
+        // the bucket family cannot cover (the Simplified-only 华 when the bucket is a JP font) skips Tier B
+        // and lands in the Tier C sweep, where only a neighbouring-key face cached by an earlier run is
+        // available. The exact-key upgrade must run in Tier C too. Modelled with Tamil, which is not
+        // locale-sensitive, so resolving with no culture skips Tier B and drives the request into Tier C.
+        [Theory]
+        [InlineData(FontSimulations.Bold, FontSimulations.None)] // Sandbox order: Bold block above Normal one
+        [InlineData(FontSimulations.None, FontSimulations.Bold)] // reverse
+        public void TierC_Sweep_Resolves_The_Requested_Weight_Not_A_Cached_Neighbour(
+            FontSimulations first, FontSimulations second)
+        {
+            using var app = StartApp();
+
+            const int tamilKa = 0x0B95; // க — Tamil; not locale-sensitive, so culture=null skips Tier B.
+            const string tamil = "Avalonia.Skia.UnitTests.Assets.NotoSansTamil-Regular.ttf";
+
+            var faces = new Dictionary<FontSimulations, GlyphTypeface>
+            {
+                [FontSimulations.None] = CreateGlyphTypeface(tamil, FontSimulations.None),
+                [FontSimulations.Bold] = CreateGlyphTypeface(tamil, FontSimulations.Bold),
+            };
+
+            Assert.Equal(FontWeight.Normal, faces[FontSimulations.None].Weight);
+            Assert.Equal(FontWeight.Bold, faces[FontSimulations.Bold].Weight);
+
+            var collection = new KeyedFallbackCollection(new Uri("fonts:tierc", UriKind.Absolute), tamilKa);
+
+            foreach (var face in faces.Values)
+            {
+                collection.AddPlatformFace(face);
+            }
+
+            var firstFace = faces[first];
+            var secondFace = faces[second];
+
+            // culture=null on a non-locale-sensitive script skips Tier B, so the second request lands in
+            // the Tier C sweep, where only the first (neighbouring-key) face is cached.
+            Assert.True(collection.TryMatchCharacter(
+                tamilKa, firstFace.Style, firstFace.Weight, FontStretch.Normal, null, null, out _));
+            Assert.True(collection.TryMatchCharacter(
+                tamilKa, secondFace.Style, secondFace.Weight, FontStretch.Normal, null, null, out _));
+
+            Assert.True(collection.TryGetGlyphTypeface(
+                secondFace.FamilyName, secondFace.Style, secondFace.Weight, FontStretch.Normal, out var secondResult));
+            Assert.Equal(secondFace.ToFontCollectionKey(), secondResult.ToFontCollectionKey());
+        }
+
         private static IDisposable StartApp() =>
             UnitTestApplication.Start(TestServices.MockPlatformRenderInterface.With(fontManagerImpl: new FontManagerImpl()));
 
@@ -260,6 +416,53 @@ namespace Avalonia.Skia.UnitTests.Media
             }
         }
 
+        // The subset test fonts live in the Fonts resource namespace rather than Assets.
+        private static void LoadFontsFromFontsNamespace(FontCollectionBase collection, params string[] fileNames)
+        {
+            var loader = AvaloniaLocator.Current.GetRequiredService<IAssetLoader>();
+
+            foreach (var fileName in fileNames)
+            {
+                var uri = new Uri($"resm:Avalonia.Skia.UnitTests.Fonts.{fileName}?assembly=Avalonia.Skia.UnitTests", UriKind.Absolute);
+                using var stream = loader.Open(uri);
+                Assert.True(collection.TryAddGlyphTypeface(stream, out _));
+            }
+        }
+
+        // Loads a font into a throwaway collection and returns its glyph typeface, so the platform
+        // stub can return it without the font being present in the collection under test.
+        private static GlyphTypeface LoadStandaloneGlyphTypeface(string resourceName)
+        {
+            var loader = AvaloniaLocator.Current.GetRequiredService<IAssetLoader>();
+            var sink = new TestFontCollection(new Uri("fonts:sink", UriKind.Absolute));
+
+            using var stream = loader.Open(new Uri($"resm:{resourceName}?assembly=Avalonia.Skia.UnitTests", UriKind.Absolute));
+            Assert.True(sink.TryAddGlyphTypeface(stream, out var glyphTypeface));
+
+            return glyphTypeface!;
+        }
+
+        // Builds a Noto Sans Hebrew glyph typeface at the requested simulations. None is the Regular
+        // face; Bold and Oblique report weight Bold / style Italic respectively while keeping the same
+        // family name and cmap, so the faces model one family at several keys.
+        private static GlyphTypeface CreateGlyphTypeface(FontSimulations simulations)
+            => CreateGlyphTypeface($"{AssetsNamespace}.NotoSansHebrew-Regular.ttf", simulations);
+
+        private static GlyphTypeface CreateGlyphTypeface(string resourceName, FontSimulations simulations)
+        {
+            var loader = AvaloniaLocator.Current.GetRequiredService<IAssetLoader>();
+            var fontManagerImpl = AvaloniaLocator.Current.GetRequiredService<IFontManagerImpl>();
+
+            using var stream = loader.Open(new Uri($"resm:{resourceName}?assembly=Avalonia.Skia.UnitTests", UriKind.Absolute));
+
+            Assert.True(fontManagerImpl.TryCreateGlyphTypeface(stream, simulations, out var platformTypeface));
+
+            var glyphTypeface = GlyphTypeface.TryCreate(platformTypeface, simulations);
+            Assert.NotNull(glyphTypeface);
+
+            return glyphTypeface!;
+        }
+
         private static string FamilyOf(Typeface typeface)
         {
             // Fallback typefaces are returned with FontFamily.Name == "<collectionKey>#<familyName>".
@@ -296,5 +499,45 @@ namespace Avalonia.Skia.UnitTests.Media
                 return glyphTypeface is not null;
             }
         }
+
+        // A platform-backed collection holding one fallback family at several keys (style/weight). Its
+        // single platform hook serves a face for an EXACT requested key only, modelling SystemFontCollection
+        // over a .ttc, so the key-honouring fallback path (including the exact-key upgrade, which reuses
+        // TryMatchCharacterFromPlatform) is exercised deterministically.
+        private sealed class KeyedFallbackCollection : FontCollectionBase
+        {
+            private readonly Dictionary<FontCollectionKey, GlyphTypeface> _platformFaces = new();
+            private readonly int _coveredCodepoint;
+
+            public KeyedFallbackCollection(Uri key, int coveredCodepoint)
+            {
+                Key = key;
+                _coveredCodepoint = coveredCodepoint;
+            }
+
+            public override Uri Key { get; }
+
+            public void AddPlatformFace(GlyphTypeface face) => _platformFaces[face.ToFontCollectionKey()] = face;
+
+            protected override bool TryMatchCharacterFromPlatform(
+                int codepoint,
+                FontCollectionKey key,
+                string? familyName,
+                CultureInfo? culture,
+                [NotNullWhen(true)] out GlyphTypeface? glyphTypeface)
+            {
+                glyphTypeface = null;
+
+                if (codepoint != _coveredCodepoint || !_platformFaces.TryGetValue(key, out var face))
+                {
+                    return false;
+                }
+
+                // Register the matched face, as SystemFontCollection does, so later tiers can find it.
+                TryAddGlyphTypeface(face.FamilyName, key, face);
+                glyphTypeface = face;
+                return true;
+            }
+        }
     }
 }
diff --git a/tests/Avalonia.Skia.UnitTests/Media/GlyphTypefaceShapingTests.cs b/tests/Avalonia.Skia.UnitTests/Media/GlyphTypefaceShapingTests.cs
new file mode 100644
index 0000000000..06b4d03684
--- /dev/null
+++ b/tests/Avalonia.Skia.UnitTests/Media/GlyphTypefaceShapingTests.cs
@@ -0,0 +1,91 @@
+#nullable enable
+
+using System;
+using Avalonia.Media;
+using Avalonia.Media.Fonts;
+using Avalonia.Media.TextFormatting.Unicode;
+using Avalonia.Platform;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Skia.UnitTests.Media
+{
+    public class GlyphTypefaceShapingTests
+    {
+        private const string MonoFont = "Avalonia.Skia.UnitTests.Assets.NotoMono-Regular.ttf";
+        private const string ArabicFont = "Avalonia.Skia.UnitTests.Assets.NotoSansArabic-Regular.ttf";
+
+        // A tiny Noto Sans Arabic subset with the GSUB/GPOS layout tables stripped: it keeps Arabic
+        // cmap glyphs but cannot shape Arabic. Renamed so it doesn't collide with the full font.
+        private const string ArabicNoLayoutFont = "Avalonia.Skia.UnitTests.Fonts.NotoSansArabic-NoLayout.ttf";
+
+        // P0 — CanShapeScript gates complex scripts on GSUB/GPOS script coverage, not cmap. This is
+        // the primitive the F3 capability fallback (Strategy A) builds on.
+        [Fact]
+        public void CanShapeScript_Gates_Complex_Scripts_On_Layout_Coverage_Not_Cmap()
+        {
+            using (Start(MonoFont, ArabicFont, ArabicNoLayoutFont))
+            {
+                var fontManager = FontManager.Current;
+
+                Assert.True(fontManager.TryGetGlyphTypeface(
+                    new Typeface("fonts:SystemFonts#Noto Mono"), out var mono));
+                Assert.True(fontManager.TryGetGlyphTypeface(
+                    new Typeface("fonts:SystemFonts#Noto Sans Arabic"), out var arabic));
+                Assert.True(fontManager.TryGetGlyphTypeface(
+                    new Typeface("fonts:SystemFonts#Noto Sans Arabic NoLayout"), out var arabicNoLayout));
+
+                // Simple scripts never require layout tables — always true, regardless of the font.
+                Assert.True(mono.CanShapeScript(Script.Latin));
+                Assert.True(arabic.CanShapeScript(Script.Latin));
+
+                // The real Arabic font declares the 'arab' GSUB script, so it can shape Arabic.
+                Assert.True(arabic.CanShapeScript(Script.Arabic));
+
+                // A Latin-only font has no Arabic layout coverage.
+                Assert.False(mono.CanShapeScript(Script.Arabic));
+
+                // The crux: the stripped font HAS Arabic cmap glyphs but no GSUB/GPOS, so it cannot
+                // shape Arabic even though TryGetGlyph succeeds. cmap coverage is not shaping capability.
+                Assert.True(arabicNoLayout.CharacterToGlyphMap.TryGetGlyph(0x0627, out _)); // ا is mapped
+                Assert.False(arabicNoLayout.CanShapeScript(Script.Arabic));
+
+                // A complex script the Arabic font does not declare is rejected too.
+                Assert.False(arabic.CanShapeScript(Script.Devanagari));
+            }
+        }
+
+        private static IDisposable Start(params string[] fontResourceNames)
+        {
+            var disposable = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface
+                .With(renderInterface: new PlatformRenderInterface()));
+
+            var fontManagerImpl = new CustomFontManagerImpl();
+
+            AvaloniaLocator.CurrentMutable
+                .Bind<IFontManagerImpl>().ToConstant(fontManagerImpl);
+
+            var fontManager = new FontManager(fontManagerImpl);
+
+            AvaloniaLocator.CurrentMutable
+                .Bind<FontManager>().ToConstant(fontManager);
+
+            fontManager.AddFontCollection(new CuratedSystemFontCollection(fontResourceNames));
+
+            return disposable;
+        }
+
+        private sealed class CuratedSystemFontCollection : FontCollectionBase
+        {
+            public CuratedSystemFontCollection(string[] fontResourceNames)
+            {
+                foreach (var name in fontResourceNames)
+                {
+                    TryAddFontSource(new Uri($"resm:{name}?assembly=Avalonia.Skia.UnitTests"));
+                }
+            }
+
+            public override Uri Key => FontManager.SystemFontsKey;
+        }
+    }
+}
diff --git a/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/ShapingCapabilityFallbackTests.cs b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/ShapingCapabilityFallbackTests.cs
new file mode 100644
index 0000000000..310e820613
--- /dev/null
+++ b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/ShapingCapabilityFallbackTests.cs
@@ -0,0 +1,110 @@
+#nullable enable
+
+using System;
+using Avalonia.Media;
+using Avalonia.Media.Fonts;
+using Avalonia.Media.TextFormatting;
+using Avalonia.Platform;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Skia.UnitTests.Media.TextFormatting
+{
+    public class ShapingCapabilityFallbackTests
+    {
+        private const string MonoFont = "Avalonia.Skia.UnitTests.Assets.NotoMono-Regular.ttf";
+        private const string ArabicFont = "Avalonia.Skia.UnitTests.Assets.NotoSansArabic-Regular.ttf";
+
+        // Tiny Noto Sans Arabic subset with the layout tables stripped: it has the Arabic cmap glyphs
+        // but no GSUB/GPOS, so it cannot actually shape Arabic. Renamed so it doesn't collide with the
+        // full font.
+        private const string ArabicNoLayoutFont = "Avalonia.Skia.UnitTests.Fonts.NotoSansArabic-NoLayout.ttf";
+
+        // For a complex script, a primary that has the cmap glyphs but can't shape it (no GSUB/GPOS) is
+        // upgraded to a shaping-capable font. This is unconditional — there is no longer a mode toggle.
+        [Fact]
+        public void CmapOnly_Complex_Script_Primary_Is_Upgraded_To_A_Shaping_Capable_Font()
+        {
+            // A shaping-capable Arabic font is present, so the cmap-only primary is replaced by it.
+            Assert.Equal("Noto Sans Arabic",
+                ResolveArabicRunFamily(MonoFont, ArabicFont, ArabicNoLayoutFont));
+        }
+
+        // When no shaping-capable font for the script exists, the cmap-only font is kept (the capability
+        // tier finds nothing, the cmap tier then accepts it) — we never reject more than before.
+        [Fact]
+        public void CmapOnly_Complex_Script_Primary_Is_Kept_When_No_Capable_Font_Exists()
+        {
+            Assert.Equal("Noto Sans Arabic NoLayout",
+                ResolveArabicRunFamily(MonoFont, ArabicNoLayoutFont));
+        }
+
+        private static string ResolveArabicRunFamily(params string[] fontResourceNames)
+        {
+            using (Start(fontResourceNames))
+            {
+                var fontManager = FontManager.Current;
+
+                // Primary run typeface: the cmap-only (no-layout) Arabic font.
+                var defaultProperties = new GenericTextRunProperties(
+                    new Typeface("fonts:SystemFonts#Noto Sans Arabic NoLayout"));
+
+                var text = char.ConvertFromUtf32(0x0627).AsMemory(); // U+0627 ARABIC LETTER ALEF
+
+                var textCharacters = new TextCharacters(text, defaultProperties);
+
+                var results = FormattingObjectPool.Instance.TextRunLists.Rent();
+
+                try
+                {
+                    TextRunProperties? previousProperties = null;
+
+                    textCharacters.GetShapeableCharacters(text, 0, fontManager, ref previousProperties, results);
+
+                    Assert.Single(results);
+                    Assert.True(fontManager.TryGetGlyphTypeface(results[0].Properties!.Typeface, out var runGlyphTypeface));
+
+                    return runGlyphTypeface.FamilyName;
+                }
+                finally
+                {
+                    FormattingObjectPool.RentedList<TextRun>? toReturn = results;
+                    FormattingObjectPool.Instance.TextRunLists.Return(ref toReturn);
+                }
+            }
+        }
+
+        private static IDisposable Start(string[] fontResourceNames)
+        {
+            var disposable = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface
+                .With(renderInterface: new PlatformRenderInterface()));
+
+            var fontManagerImpl = new CustomFontManagerImpl();
+
+            AvaloniaLocator.CurrentMutable
+                .Bind<IFontManagerImpl>().ToConstant(fontManagerImpl);
+
+            var fontManager = new FontManager(fontManagerImpl);
+
+            AvaloniaLocator.CurrentMutable
+                .Bind<FontManager>().ToConstant(fontManager);
+
+            fontManager.AddFontCollection(new CuratedSystemFontCollection(fontResourceNames));
+
+            return disposable;
+        }
+
+        private sealed class CuratedSystemFontCollection : FontCollectionBase
+        {
+            public CuratedSystemFontCollection(string[] fontResourceNames)
+            {
+                foreach (var name in fontResourceNames)
+                {
+                    TryAddFontSource(new Uri($"resm:{name}?assembly=Avalonia.Skia.UnitTests"));
+                }
+            }
+
+            public override Uri Key => FontManager.SystemFontsKey;
+        }
+    }
+}
diff --git a/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextCharactersTests.cs b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextCharactersTests.cs
new file mode 100644
index 0000000000..f58ee3b7de
--- /dev/null
+++ b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextCharactersTests.cs
@@ -0,0 +1,308 @@
+#nullable enable
+
+using System;
+using System.Globalization;
+using Avalonia.Media;
+using Avalonia.Media.Fonts;
+using Avalonia.Media.TextFormatting;
+using Avalonia.Platform;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Skia.UnitTests.Media.TextFormatting
+{
+    public class TextCharactersTests
+    {
+        // Curated system fonts (see Start): "Noto Mono" is the primary; "DejaVu Sans" is a broad
+        // fallback that covers Hebrew and a wide range of combining marks. The broad-coverage faces
+        // bundled for other tests (AdobeBlank2VF, MiSans/NISC CJK) are excluded so that a CJK
+        // codepoint genuinely has no fallback.
+        private const string PrimaryFont = "Avalonia.Skia.UnitTests.Assets.NotoMono-Regular.ttf";
+        private const string FallbackFont = "Avalonia.Skia.UnitTests.Fonts.DejaVuSans.ttf";
+
+        // Tiny zh/ja regional subsets (a few glyphs each) of the Google Fonts Noto Sans SC / JP, with
+        // distinct OS/2 codepage bits and localized family names so the culture-aware fallback scorer
+        // can tell them apart. Both cover U+4E2D (中); only the JP subset covers U+3042 (あ).
+        private const string NotoSansScFont = "Avalonia.Skia.UnitTests.Fonts.NotoSansSC-Subset.ttf";
+        private const string NotoSansJpFont = "Avalonia.Skia.UnitTests.Fonts.NotoSansJP-Subset.ttf";
+
+        // U+4E2D 中 — a CJK ideograph covered by neither curated font, and with no platform fallback,
+        // so it has no match at all.
+        private const int NoMatchCodepoint = 0x4E2D;
+
+        // U+05D0 Hebrew aleph — covered by DejaVu Sans but not Noto Mono, so it resolves to a fallback.
+        private const int FallbackCodepoint = 0x05D0;
+
+        // F2 — a cluster that has no home (NoMatchCodepoint) immediately followed by one that does
+        // (FallbackCodepoint). This used to make the .notdef recovery loop swallow the renderable
+        // cluster into the tofu run.
+        [Fact]
+        public void GetShapeableCharacters_Does_Not_Swallow_Fallbackable_Cluster_After_Unmatchable_One()
+        {
+            using (Start(PrimaryFont, FallbackFont))
+            {
+                var fontManager = FontManager.Current;
+
+                var defaultProperties = new GenericTextRunProperties(Typeface.Default);
+                var defaultGlyphTypeface = defaultProperties.CachedGlyphTypeface;
+                var defaultFontFamily = defaultProperties.Typeface.FontFamily;
+
+                // Preconditions: the primary covers neither codepoint, the first has no fallback, the
+                // second does.
+                Assert.False(defaultGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(NoMatchCodepoint, out _));
+                Assert.False(defaultGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(FallbackCodepoint, out _));
+
+                Assert.False(fontManager.TryMatchCharacter(NoMatchCodepoint, FontStyle.Normal, FontWeight.Normal,
+                    FontStretch.Normal, defaultFontFamily, null, out _));
+                Assert.True(fontManager.TryMatchCharacter(FallbackCodepoint, FontStyle.Normal, FontWeight.Normal,
+                    FontStretch.Normal, defaultFontFamily, null, out _));
+
+                var text = string.Concat(
+                    char.ConvertFromUtf32(NoMatchCodepoint),
+                    char.ConvertFromUtf32(FallbackCodepoint)).AsMemory();
+
+                var textCharacters = new TextCharacters(text, defaultProperties);
+
+                var results = FormattingObjectPool.Instance.TextRunLists.Rent();
+
+                try
+                {
+                    TextRunProperties? previousProperties = null;
+
+                    textCharacters.GetShapeableCharacters(text, 0, fontManager, ref previousProperties, results);
+
+                    // Before the fix this was a SINGLE coalesced .notdef run spanning both codepoints
+                    // with the primary typeface — the Hebrew cluster was rendered as tofu even though a
+                    // fallback exists. The recovery loop now stops at the fallbackable cluster.
+                    Assert.Equal(2, results.Count);
+
+                    // First run: the genuinely unmatchable cluster, left with the primary (tofu) typeface.
+                    Assert.Equal(1, results[0].Length);
+                    Assert.Equal(defaultProperties.Typeface, results[0].Properties!.Typeface);
+
+                    // Second run: the Hebrew cluster, handed to a fallback that actually covers it.
+                    Assert.Equal(1, results[1].Length);
+                    Assert.NotEqual(defaultProperties.Typeface, results[1].Properties!.Typeface);
+                    Assert.True(results[1].Properties!.CachedGlyphTypeface.CharacterToGlyphMap
+                        .TryGetGlyph(FallbackCodepoint, out _));
+                }
+                finally
+                {
+                    FormattingObjectPool.RentedList<TextRun>? toReturn = results;
+                    FormattingObjectPool.Instance.TextRunLists.Return(ref toReturn);
+                }
+            }
+        }
+
+        // F1 — a base+combining-mark cluster where the primary font has the base but not the mark, and
+        // a fallback covers the whole cluster. The whole cluster must be handed to that fallback rather
+        // than left on the primary (which would drop the mark).
+        [Fact]
+        public void GetShapeableCharacters_Prefers_A_Fallback_That_Covers_The_Whole_Cluster_Including_Marks()
+        {
+            using (Start(PrimaryFont, FallbackFont))
+            {
+                var fontManager = FontManager.Current;
+
+                var defaultProperties = new GenericTextRunProperties(Typeface.Default);
+                var defaultGlyphTypeface = defaultProperties.CachedGlyphTypeface;
+                var defaultFontFamily = defaultProperties.Typeface.FontFamily;
+
+                const int baseCodepoint = 'a';
+                Assert.True(defaultGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(baseCodepoint, out _));
+
+                // Probe for a combining mark the primary lacks but a fallback covers together with the
+                // base. Probing keeps the test robust to the exact coverage of the embedded fonts.
+                var mark = 0;
+
+                foreach (var candidate in CombiningMarkCandidates)
+                {
+                    if (defaultGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(candidate, out _))
+                    {
+                        continue; // primary already covers it - not a useful probe
+                    }
+
+                    if (fontManager.TryMatchCharacter(candidate, FontStyle.Normal, FontWeight.Normal,
+                            FontStretch.Normal, defaultFontFamily, null, out var markTypeface)
+                        && fontManager.TryGetGlyphTypeface(markTypeface, out var markGlyphTypeface)
+                        && markGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(baseCodepoint, out _))
+                    {
+                        mark = candidate;
+                        break;
+                    }
+                }
+
+                Assert.True(mark != 0,
+                    "No combining mark found that the primary font lacks but a fallback covers together with the base.");
+
+                var text = ("a" + char.ConvertFromUtf32(mark)).AsMemory();
+
+                var textCharacters = new TextCharacters(text, defaultProperties);
+
+                var results = FormattingObjectPool.Instance.TextRunLists.Rent();
+
+                try
+                {
+                    TextRunProperties? previousProperties = null;
+
+                    textCharacters.GetShapeableCharacters(text, 0, fontManager, ref previousProperties, results);
+
+                    // The base+mark cluster stays whole, on a font that covers the mark. Before the fix
+                    // it was left on the primary (which has the base but not the mark), dropping the mark.
+                    Assert.NotEmpty(results);
+
+                    var firstRun = results[0];
+
+                    Assert.Equal(text.Length, firstRun.Length);
+                    Assert.NotEqual(defaultProperties.Typeface, firstRun.Properties!.Typeface);
+                    Assert.True(firstRun.Properties!.CachedGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(mark, out _),
+                        "The cluster's run uses a font that does not cover the combining mark.");
+                }
+                finally
+                {
+                    FormattingObjectPool.RentedList<TextRun>? toReturn = results;
+                    FormattingObjectPool.Instance.TextRunLists.Return(ref toReturn);
+                }
+            }
+        }
+
+        // F5 — NUL characters are replaced with non-breaking WORD JOINER (U+2060), not ZERO WIDTH
+        // SPACE (U+200B), which would introduce a line-break opportunity NUL never had.
+        [Fact]
+        public void GetShapeableCharacters_Replaces_Null_Characters_With_Non_Breaking_Word_Joiners()
+        {
+            using (Start(PrimaryFont, FallbackFont))
+            {
+                var fontManager = FontManager.Current;
+                var defaultProperties = new GenericTextRunProperties(Typeface.Default);
+
+                var text = "\0\0".AsMemory();
+
+                var textCharacters = new TextCharacters(text, defaultProperties);
+
+                var results = FormattingObjectPool.Instance.TextRunLists.Rent();
+
+                try
+                {
+                    TextRunProperties? previousProperties = null;
+
+                    textCharacters.GetShapeableCharacters(text, 0, fontManager, ref previousProperties, results);
+
+                    Assert.Single(results);
+                    Assert.Equal(text.Length, results[0].Length);
+
+                    foreach (var c in results[0].Text.Span)
+                    {
+                        Assert.Equal((char)0x2060, c);
+                    }
+                }
+                finally
+                {
+                    FormattingObjectPool.RentedList<TextRun>? toReturn = results;
+                    FormattingObjectPool.Instance.TextRunLists.Return(ref toReturn);
+                }
+            }
+        }
+
+        // F4 — the previous run's font is reused as an anti-thrashing bias, but for a locale-sensitive
+        // script (CJK Han unification) it must not be pinned across a culture change. A zh run's
+        // Simplified-Chinese font must not carry into a following ja run; the ja run resolves to the
+        // culture-appropriate Japanese font instead.
+        [Fact]
+        public void GetShapeableCharacters_Does_Not_Pin_Previous_Region_Font_Across_A_Culture_Change()
+        {
+            using (Start(PrimaryFont, NotoSansScFont, NotoSansJpFont))
+            {
+                var fontManager = FontManager.Current;
+                var ja = CultureInfo.GetCultureInfo("ja-JP");
+                var zh = CultureInfo.GetCultureInfo("zh-CN");
+
+                // Previous run: the Simplified-Chinese font, resolved for a zh culture.
+                var scTypeface = new Typeface(new FontFamily("fonts:SystemFonts#Noto Sans SC"));
+                Assert.True(fontManager.TryGetGlyphTypeface(scTypeface, out var scGlyphTypeface));
+
+                // Current run: a Latin primary that lacks the ideograph, under a ja culture.
+                var defaultProperties = new GenericTextRunProperties(Typeface.Default, cultureInfo: ja);
+
+                const int han = 0x4E2D; // 中 (a Han codepoint both regional fonts cover)
+
+                // Preconditions: primary lacks 中; the zh font covers it; and the culture-aware fallback
+                // for ja prefers the JP font over the SC font (distinct OS/2 codepage + localized names).
+                Assert.False(defaultProperties.CachedGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(han, out _));
+                Assert.True(scGlyphTypeface.CharacterToGlyphMap.TryGetGlyph(han, out _));
+                Assert.True(fontManager.TryMatchCharacter(han, FontStyle.Normal, FontWeight.Normal,
+                    FontStretch.Normal, defaultProperties.Typeface.FontFamily, ja, out var jaMatch));
+                Assert.True(fontManager.TryGetGlyphTypeface(jaMatch, out var jaMatchGlyphTypeface));
+                Assert.Equal("Noto Sans JP", jaMatchGlyphTypeface.FamilyName);
+
+                var text = char.ConvertFromUtf32(han).AsMemory();
+                var textCharacters = new TextCharacters(text, defaultProperties);
+
+                TextRunProperties? previousProperties = new GenericTextRunProperties(scTypeface, cultureInfo: zh);
+
+                var results = FormattingObjectPool.Instance.TextRunLists.Rent();
+
+                try
+                {
+                    textCharacters.GetShapeableCharacters(text, 0, fontManager, ref previousProperties, results);
+
+                    Assert.Single(results);
+                    Assert.True(fontManager.TryGetGlyphTypeface(results[0].Properties!.Typeface, out var runGlyphTypeface));
+
+                    // With the fix, the zh→ja culture change on a locale-sensitive script skips reuse of
+                    // the previous (SC) font, so the run resolves to the ja-appropriate JP font. Before
+                    // the fix the SC font was pinned and this was "Noto Sans SC".
+                    Assert.Equal("Noto Sans JP", runGlyphTypeface.FamilyName);
+                }
+                finally
+                {
+                    FormattingObjectPool.RentedList<TextRun>? toReturn = results;
+                    FormattingObjectPool.Instance.TextRunLists.Return(ref toReturn);
+                }
+            }
+        }
+
+        // A spread of combining marks (all grapheme-cluster Extend) likely present in a broad fallback
+        // font but absent from a minimal monospace primary. The F1 test picks the first workable one.
+        private static readonly int[] CombiningMarkCandidates =
+        {
+            0x0316, 0x0317, 0x031C, 0x0323, 0x032E, 0x0333, 0x0359, 0x035C, 0x0360, 0x0361, 0x0362,
+            0x0363, 0x036F, 0x0488, 0x0489, 0x1DC0, 0x1DC1, 0x20DD, 0x20E0,
+        };
+
+        private static IDisposable Start(params string[] fontResourceNames)
+        {
+            var disposable = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface
+                .With(renderInterface: new PlatformRenderInterface()));
+
+            var fontManagerImpl = new CustomFontManagerImpl();
+
+            AvaloniaLocator.CurrentMutable
+                .Bind<IFontManagerImpl>().ToConstant(fontManagerImpl);
+
+            var fontManager = new FontManager(fontManagerImpl);
+
+            AvaloniaLocator.CurrentMutable
+                .Bind<FontManager>().ToConstant(fontManager);
+
+            // Register a curated system collection holding only the fonts each test needs. This excludes
+            // the broad-coverage fonts bundled for other tests, so coverage is exactly the requested set.
+            fontManager.AddFontCollection(new CuratedSystemFontCollection(fontResourceNames));
+
+            return disposable;
+        }
+
+        private sealed class CuratedSystemFontCollection : FontCollectionBase
+        {
+            public CuratedSystemFontCollection(string[] fontResourceNames)
+            {
+                foreach (var name in fontResourceNames)
+                {
+                    TryAddFontSource(new Uri($"resm:{name}?assembly=Avalonia.Skia.UnitTests"));
+                }
+            }
+
+            public override Uri Key => FontManager.SystemFontsKey;
+        }
+    }
+}

From 842937ddad8378a92d48bb15d63bd9b75e17fe2c Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Thu, 2 Jul 2026 18:40:24 +0500
Subject: [PATCH 058/196] Skia: avoid SKBitmap.Copy when creating
 ImmutableBitmap from pixels (#21675)

* Skia: avoid SKBitmap.Copy when creating ImmutableBitmap from pixels

The pixel-data ImmutableBitmap constructor used by LoadBitmap(IntPtr) wrapped
the caller's buffer with InstallPixels and then called SKBitmap.Copy() to get
an owned copy. SKBitmap.Copy() internally spins up an SKCanvas and draws the
source via an SKPaint shader, which is far more expensive than a memory blit.

Instead, allocate the destination with Marshal.AllocHGlobal, blit the pixels
span-to-span, and hand ownership to Skia via InstallPixels with a release proc
that frees the buffer. This is dramatically faster (~6x at 4096x4096, 50-80x at
small/medium sizes) and allocates less managed memory.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Skia: back ImmutableBitmap-from-pixels with BitmapMemory + shared per-row copy

Follow-up to the previous change. Two corrections/improvements:

* Use BitmapMemory as the backing storage instead of a bare Marshal.AllocHGlobal
  buffer, so allocation/lifetime (incl. GC memory pressure) is managed in one
  place. Ownership is handed to Skia via InstallPixels with a release proc that
  disposes the BitmapMemory.

* The previous single contiguous blit was incorrect: the source stride is allowed
  to be negative (bottom-up layouts). Copy row by row instead, which also handles
  the backing store's row alignment differing from the source stride.

To avoid duplicating the row-copy logic, Bitmap.CopyPixelsCore is now an
internal static helper taking the source as raw (address, rowBytes, format),
reused by both Bitmap/WriteableBitmap.CopyPixels and ImmutableBitmap. Source-rect
validation moves to the (instance) call sites.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Skia: keep a self-contained instance CopyPixelsCore for inheritors

Re-add the instance CopyPixelsCore(..., ILockedFramebuffer fb) overload that
validates the source rect and delegates to the static raw-buffer core. Inheritors
(WriteableBitmap) and the framebuffer-based CopyPixels paths use this self-contained
overload again, while ImmutableBitmap keeps using the static raw overload directly.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Bitmap: add contiguous fast-path to CopyPixelsCore

When the source and destination layouts are identical, tightly-packed and forward
(no row padding, no X offset, positive stride == minStride), the whole region is
contiguous in both buffers, so copy it with a single blit instead of the per-row
loop. Measured up to ~5x faster for small images and ~30% for large ones; requiring
stride == minStride also guarantees we never read past the source's last row.
Negative strides, sub-rect copies and padded layouts still take the per-row path.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Address code-review findings on the ImmutableBitmap pixel path

* BitmapMemory: make ReleaseUnmanagedResources idempotent (zero Address after
  FreeHGlobal). SKBitmap.InstallPixels invokes the release proc even when it
  returns false, so the failure branch in ImmutableBitmap could dispose the same
  BitmapMemory twice -> double free / heap corruption. Idempotency also guards any
  other native-handoff consumer that double-disposes.

* Bitmap.CopyPixelsCore: compute minBufferSize in 64-bit so a very large
  stride*height can't overflow the buffer-size guard and let the new contiguous
  blit (or the per-row loop) run past the buffers.

* ImmutableBitmap: dispose the SKBitmap if SKImage.FromBitmap returns null so the
  backing memory is freed promptly via the release proc instead of waiting for the
  finalizer.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* BitmapMemory: free the buffer atomically with Interlocked.Exchange

Back Address with a field and claim it via Interlocked.Exchange in
ReleaseUnmanagedResources, so the buffer is freed exactly once even if an
explicit Dispose() races with the finalizer or a native release callback running
on another thread.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* BitmapMemory: drop redundant Interlocked comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Skia: let SKBitmap own its pixels in ImmutableBitmap, drop BitmapMemory

Since CopyPixelsCore copies into the destination, ImmutableBitmap can simply
TryAllocPixels a Skia-owned SKBitmap and blit into it, instead of allocating a
separate BitmapMemory and handing it to InstallPixels with a release proc. This
removes the manual unmanaged-memory lifetime management (and the
release-proc/double-dispose hazard along with it). SKBitmap frees its own pixels
on Dispose.

Reverts the now-unneeded BitmapMemory idempotency/Interlocked change too, since
that code path no longer exists.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* comments

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 src/Avalonia.Base/Media/Imaging/Bitmap.cs     | 55 +++++++++++----
 src/Skia/Avalonia.Skia/ImmutableBitmap.cs     | 18 +++--
 .../Avalonia.Skia.UnitTests.csproj            |  1 +
 .../Media/ImmutableBitmapTests.cs             | 68 +++++++++++++++++++
 4 files changed, 125 insertions(+), 17 deletions(-)
 create mode 100644 tests/Avalonia.Skia.UnitTests/Media/ImmutableBitmapTests.cs

diff --git a/src/Avalonia.Base/Media/Imaging/Bitmap.cs b/src/Avalonia.Base/Media/Imaging/Bitmap.cs
index dc1541414b..87ef0a234f 100644
--- a/src/Avalonia.Base/Media/Imaging/Bitmap.cs
+++ b/src/Avalonia.Base/Media/Imaging/Bitmap.cs
@@ -196,32 +196,63 @@ namespace Avalonia.Media.Imaging
             return sourceRect;
         }
         
-        private protected unsafe void CopyPixelsCore(PixelRect sourceRect, IntPtr buffer, int bufferSize, int stride,
-            ILockedFramebuffer fb)
+        /// <summary>
+        /// Performs a row-by-row copy of pixels from a source buffer into a destination buffer.
+        /// </summary>
+        /// <remarks>
+        /// <paramref name="sourceRowBytes"/> is signed and may be negative: a negative value means the
+        /// source rows are laid out bottom-up, with <paramref name="sourceAddress"/> pointing at the
+        /// first (top) row. The destination <paramref name="stride"/> must be positive and at least the
+        /// tightly-packed row size. The caller is responsible for validating <paramref name="sourceRect"/>
+        /// against the source bounds (e.g. via <see cref="ValidateSourceRect"/>).
+        /// </remarks>
+        internal static unsafe void CopyPixelsCore(PixelRect sourceRect, IntPtr sourceAddress, int sourceRowBytes,
+            PixelFormat sourceFormat, IntPtr buffer, int bufferSize, int stride)
         {
-            if (Format == null)
-                throw new NotSupportedException("CopyPixels is not supported for this bitmap type");
-
-            sourceRect = ValidateSourceRect(sourceRect);
-
-            int minStride = checked(((sourceRect.Width * fb.Format.BitsPerPixel) + 7) / 8);
+            int minStride = checked(((sourceRect.Width * sourceFormat.BitsPerPixel) + 7) / 8);
             if (stride < minStride)
                 throw new ArgumentOutOfRangeException(nameof(stride));
 
-            var minBufferSize = stride * sourceRect.Height;
+            // 64-bit to avoid overflowing the guard for very large strides/heights, which would
+            // otherwise let an oversized contiguous blit/loop run past the buffers.
+            var minBufferSize = (long)stride * sourceRect.Height;
             if (minBufferSize > bufferSize)
                 throw new ArgumentOutOfRangeException(nameof(bufferSize));
 
-            var offsetX = checked(((sourceRect.X * Format.Value.BitsPerPixel) + 7) / 8);
+            var offsetX = checked(((sourceRect.X * sourceFormat.BitsPerPixel) + 7) / 8);
+
+            // Fast-path: when the source and destination layouts are identical, tightly-packed and
+            // forward (no row padding, no X offset, positive stride), the whole region is contiguous in
+            // both buffers and can be copied with a single blit. This is meaningfully faster than the
+            // per-row loop (up to ~5x for small images, ~30% for large ones). Requiring stride == minStride
+            // also guarantees we don't read past the source's last row.
+            if (offsetX == 0 && sourceRowBytes == stride && stride == minStride)
+            {
+                Unsafe.CopyBlock(buffer.ToPointer(),
+                    (sourceAddress + sourceRowBytes * sourceRect.Y).ToPointer(), (uint)minBufferSize);
+                return;
+            }
 
             for (var y = 0; y < sourceRect.Height; y++)
             {
-                var srcAddress = fb.Address + fb.RowBytes * (sourceRect.Y + y) + offsetX;
+                var srcAddress = sourceAddress + sourceRowBytes * (sourceRect.Y + y) + offsetX;
                 var dstAddress = buffer + stride * y;
                 Unsafe.CopyBlock(dstAddress.ToPointer(), srcAddress.ToPointer(), (uint)minStride);
             }
         }
 
+        /// <summary>
+        /// Validates <paramref name="sourceRect"/> against this bitmap and copies pixels out of the
+        /// given framebuffer. Self-contained convenience wrapper around the static
+        /// <see cref="CopyPixelsCore(PixelRect,IntPtr,int,PixelFormat,IntPtr,int,int)"/> for inheritors.
+        /// </summary>
+        private protected void CopyPixelsCore(PixelRect sourceRect, IntPtr buffer, int bufferSize, int stride,
+            ILockedFramebuffer fb)
+        {
+            sourceRect = ValidateSourceRect(sourceRect);
+            CopyPixelsCore(sourceRect, fb.Address, fb.RowBytes, fb.Format, buffer, bufferSize, stride);
+        }
+
         public virtual void CopyPixels(PixelRect sourceRect, IntPtr buffer, int bufferSize, int stride)
         {
             if (
@@ -235,7 +266,7 @@ namespace Avalonia.Media.Imaging
 
             if (_isTranscoded)
                 throw new NotSupportedException("CopyPixels is not supported for transcoded bitmaps");
-            
+
             using (var fb = readable.Lock())
                 CopyPixelsCore(sourceRect, buffer, bufferSize, stride, fb);
         }
diff --git a/src/Skia/Avalonia.Skia/ImmutableBitmap.cs b/src/Skia/Avalonia.Skia/ImmutableBitmap.cs
index 44408a5333..c168394768 100644
--- a/src/Skia/Avalonia.Skia/ImmutableBitmap.cs
+++ b/src/Skia/Avalonia.Skia/ImmutableBitmap.cs
@@ -131,18 +131,26 @@ namespace Avalonia.Skia
         /// <param name="data">Data pixels.</param>
         public ImmutableBitmap(PixelSize size, Vector dpi, int stride, PixelFormat format, AlphaFormat alphaFormat, IntPtr data)
         {
-            using (var tmp = new SKBitmap())
+            var info = new SKImageInfo(size.Width, size.Height, format.ToSkColorType(), alphaFormat.ToSkAlphaType());
+
+            _bitmap = new SKBitmap();
+            if (!_bitmap.TryAllocPixels(info))
             {
-                tmp.InstallPixels(
-                    new SKImageInfo(size.Width, size.Height, format.ToSkColorType(), alphaFormat.ToSkAlphaType()),
-                    data, stride);
-                _bitmap = tmp.Copy();
+                _bitmap.Dispose();
+                throw new ArgumentException("Unable to create bitmap from provided data");
             }
+
+            // Our CopyPixels is 6-15x  faster than SKBitmap.Copy(), which internally spins up an
+            // SKCanvas and draws the source bitmap by assigning it as a shader on an SKPaint
+            Bitmap.CopyPixelsCore(new PixelRect(size), data, stride, format, _bitmap.GetPixels(),
+                _bitmap.RowBytes * size.Height, _bitmap.RowBytes);
+
             _bitmap.SetImmutable();
             _image = SKImage.FromBitmap(_bitmap);
 
             if (_image == null)
             {
+                _bitmap.Dispose();
                 throw new ArgumentException("Unable to create bitmap from provided data");
             }
 
diff --git a/tests/Avalonia.Skia.UnitTests/Avalonia.Skia.UnitTests.csproj b/tests/Avalonia.Skia.UnitTests/Avalonia.Skia.UnitTests.csproj
index 1edcbfa5aa..5ee6d2b787 100644
--- a/tests/Avalonia.Skia.UnitTests/Avalonia.Skia.UnitTests.csproj
+++ b/tests/Avalonia.Skia.UnitTests/Avalonia.Skia.UnitTests.csproj
@@ -2,6 +2,7 @@
   <PropertyGroup>
     <TargetFramework>$(AvsCurrentTargetFramework)</TargetFramework>
     <OutputType>Exe</OutputType>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <Import Project="..\..\build\UnitTests.NetCore.targets" />
   <Import Project="..\..\build\XUnit.props" />
diff --git a/tests/Avalonia.Skia.UnitTests/Media/ImmutableBitmapTests.cs b/tests/Avalonia.Skia.UnitTests/Media/ImmutableBitmapTests.cs
new file mode 100644
index 0000000000..34fc7dadd5
--- /dev/null
+++ b/tests/Avalonia.Skia.UnitTests/Media/ImmutableBitmapTests.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Runtime.InteropServices;
+using Avalonia.Platform;
+using Xunit;
+
+namespace Avalonia.Skia.UnitTests.Media
+{
+    public class ImmutableBitmapTests
+    {
+        [Theory]
+        [InlineData(1, 1, false)]
+        [InlineData(3, 5, false)]
+        [InlineData(64, 64, false)]
+        [InlineData(1, 1, true)]
+        [InlineData(3, 5, true)]
+        [InlineData(64, 64, true)]
+        public unsafe void Constructor_From_Pixels_Copies_Source_Data(int width, int height, bool negativeStride)
+        {
+            var size = new PixelSize(width, height);
+            var rowBytes = width * 4;
+            var absStride = rowBytes;
+            var byteSize = absStride * height;
+
+            // Logical pixel byte: deterministic function of (row, byteIndexWithinRow).
+            byte Expected(int row, int x) => (byte)((row * rowBytes + x) * 7 + 1);
+
+            var source = Marshal.AllocHGlobal(byteSize);
+            try
+            {
+                // Lay the logical rows out in physical memory. For a negative stride the rows are stored
+                // bottom-up and the data pointer addresses the first (top) logical row, which sits at the
+                // highest address.
+                var buffer = new Span<byte>((void*)source, byteSize);
+                for (var row = 0; row < height; row++)
+                {
+                    var physicalRow = negativeStride ? height - 1 - row : row;
+                    for (var x = 0; x < rowBytes; x++)
+                        buffer[physicalRow * absStride + x] = Expected(row, x);
+                }
+
+                var stride = negativeStride ? -absStride : absStride;
+                var data = negativeStride ? source + absStride * (height - 1) : source;
+
+                using var bitmap = new ImmutableBitmap(
+                    size, new Vector(96, 96), stride,
+                    PixelFormat.Bgra8888, AlphaFormat.Premul, data);
+
+                // The constructor must take its own copy: corrupting (and freeing) the source
+                // afterwards must not affect the bitmap's pixels.
+                buffer.Fill(0xCD);
+
+                Assert.Equal(size, bitmap.PixelSize);
+
+                using var locked = bitmap.Lock();
+                Assert.Equal(size, locked.Size);
+
+                var dst = new ReadOnlySpan<byte>((void*)locked.Address, locked.RowBytes * height);
+                for (var row = 0; row < height; row++)
+                    for (var x = 0; x < rowBytes; x++)
+                        Assert.Equal(Expected(row, x), dst[row * locked.RowBytes + x]);
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(source);
+            }
+        }
+    }
+}

From fd26b29594d4299baae537bedf62a7f8a9eb2026 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Thu, 2 Jul 2026 18:20:57 +0200
Subject: [PATCH 059/196] Implement XDND: drag-and-drop support for Linux
 (#20926)

* Xdnd: handle events

* Xdnd: implement synchronous event waiter

* Xdnd: share common DataReader/ReadSession with clipboard

* Xdnd: rename XdndHandler to X11DropTarget

* Xdnd: find Xdnd target

* Xdnd: move text formats atoms to X11Atoms

* Xdnd: introduce SelectionDataProvider

* Xdnd: send messages

* Xdnd: handle drop properly

* Fix UriListHelper

* Dispose data transfer in InProcessDragSource

* Xdnd: cleanup

* Store X11Window instances inside X11Platform

* Xdnd: handle in process DnD

* Xdnd: set cursor

* Xdnd: fix in process completion

* Improve DragAndDropPage

* Xdnd: fix XML doc

* Xdnd: send XdndFinished with correct args

* Fix DnD page when dropping on textblocks

* Xdnd: add timeout waiting for XdndFinished

* Xdnd: handle key modifiers

* Xdnd: update allowed effects from modifiers

* Xdnd: cancel drop if target doesn't accept format

* Xdnd: handle text/plain format

* Xdnd: handle rejected drop in process

* Xdnd: wait for XdndStatus before sending nez XdndPosition

* Xdnd: add trace logging

* Xdnd: more logging

* Xdnd: update target on key press/release

* Xdnd: add global event hook instead of grabbing pointer

* Xdnd: remove window-specific event hook

* Xdnd: complete correctly if the pointer didn't move
---
 .../ControlCatalog/Pages/DragAndDropPage.xaml |   4 +-
 .../Pages/DragAndDropPage.xaml.cs             |  38 +-
 .../Input/AsyncDataTransferExtensions.cs      |   3 +
 .../Input/SyncToAsyncDataTransfer.cs          |  43 +
 .../Input/SyncToAsyncDataTransferItem.cs      |  21 +
 .../Platform/InProcessDragSource.cs           |   1 +
 src/Avalonia.Wayland/Avalonia.Wayland.csproj  |   2 +-
 .../Clipboard/WaylandClipboardImpl.cs         |   4 +-
 .../Clipboard/WaylandDataTransfer.cs          |   4 +-
 .../Clipboard/ClipboardDataFormatHelper.cs    | 119 ---
 .../Clipboard/ClipboardDataReader.cs          |  82 --
 src/Avalonia.X11/Clipboard/X11Clipboard.cs    | 417 ----------
 .../Dispatching/X11EventDispatcher.cs         |  20 +-
 .../Clipboard/ClipboardDataReader.cs          |  39 +
 .../Clipboard/ClipboardDataTransfer.cs        |  12 +-
 .../Clipboard/ClipboardDataTransferItem.cs    |   9 +-
 .../Clipboard/ClipboardReadSessionFactory.cs  |  20 +
 .../Clipboard/EventStreamWindow.cs            |  19 +-
 .../Selections/Clipboard/X11ClipboardImpl.cs  | 140 ++++
 .../Selections/DataFormatHelper.cs            | 177 ++++
 .../DragDrop/DragDropDataProvider.cs          |  30 +
 .../Selections/DragDrop/DragDropDataReader.cs |  49 ++
 .../DragDrop/DragDropDataTransfer.cs          |  40 +
 .../DragDrop/DragDropDataTransferItem.cs      |  31 +
 .../DragDrop/DragDropTimeoutManager.cs        |  41 +
 .../Selections/DragDrop/IXdndWindow.cs        |  13 +
 .../DragDrop/SynchronousXEventWaiter.cs       | 124 +++
 .../Selections/DragDrop/X11DragSource.cs      | 766 ++++++++++++++++++
 .../Selections/DragDrop/X11DropTarget.cs      | 204 +++++
 .../Selections/DragDrop/XdndActionHelper.cs   |  29 +
 .../Selections/DragDrop/XdndConstants.cs      |   8 +
 src/Avalonia.X11/Selections/IXEventWaiter.cs  |   9 +
 .../Selections/SelectionDataProvider.cs       | 260 ++++++
 .../Selections/SelectionDataReader.cs         | 108 +++
 .../Selections/SelectionHelper.cs             |   8 +
 .../SelectionReadSession.cs}                  |  74 +-
 .../UriListHelper.cs}                         |   4 +-
 src/Avalonia.X11/X11Atoms.cs                  |  36 +-
 src/Avalonia.X11/X11CursorFactory.cs          |  36 +-
 src/Avalonia.X11/X11EnumExtensions.cs         |  30 +
 src/Avalonia.X11/X11FocusProxy.cs             |   2 +-
 src/Avalonia.X11/X11Globals.cs                |   4 +-
 src/Avalonia.X11/X11Platform.cs               |   8 +-
 src/Avalonia.X11/X11Window.Ime.cs             |   2 +-
 src/Avalonia.X11/X11Window.cs                 |  75 +-
 src/Avalonia.X11/X11WindowInfo.cs             |   7 +
 src/Avalonia.X11/XLib.Helpers.cs              |  31 +-
 src/Avalonia.X11/XLib.cs                      |  31 +-
 48 files changed, 2448 insertions(+), 786 deletions(-)
 create mode 100644 src/Avalonia.Base/Input/SyncToAsyncDataTransfer.cs
 create mode 100644 src/Avalonia.Base/Input/SyncToAsyncDataTransferItem.cs
 delete mode 100644 src/Avalonia.X11/Clipboard/ClipboardDataFormatHelper.cs
 delete mode 100644 src/Avalonia.X11/Clipboard/ClipboardDataReader.cs
 delete mode 100644 src/Avalonia.X11/Clipboard/X11Clipboard.cs
 create mode 100644 src/Avalonia.X11/Selections/Clipboard/ClipboardDataReader.cs
 rename src/Avalonia.X11/{ => Selections}/Clipboard/ClipboardDataTransfer.cs (75%)
 rename src/Avalonia.X11/{ => Selections}/Clipboard/ClipboardDataTransferItem.cs (73%)
 create mode 100644 src/Avalonia.X11/Selections/Clipboard/ClipboardReadSessionFactory.cs
 rename src/Avalonia.X11/{ => Selections}/Clipboard/EventStreamWindow.cs (87%)
 create mode 100644 src/Avalonia.X11/Selections/Clipboard/X11ClipboardImpl.cs
 create mode 100644 src/Avalonia.X11/Selections/DataFormatHelper.cs
 create mode 100644 src/Avalonia.X11/Selections/DragDrop/DragDropDataProvider.cs
 create mode 100644 src/Avalonia.X11/Selections/DragDrop/DragDropDataReader.cs
 create mode 100644 src/Avalonia.X11/Selections/DragDrop/DragDropDataTransfer.cs
 create mode 100644 src/Avalonia.X11/Selections/DragDrop/DragDropDataTransferItem.cs
 create mode 100644 src/Avalonia.X11/Selections/DragDrop/DragDropTimeoutManager.cs
 create mode 100644 src/Avalonia.X11/Selections/DragDrop/IXdndWindow.cs
 create mode 100644 src/Avalonia.X11/Selections/DragDrop/SynchronousXEventWaiter.cs
 create mode 100644 src/Avalonia.X11/Selections/DragDrop/X11DragSource.cs
 create mode 100644 src/Avalonia.X11/Selections/DragDrop/X11DropTarget.cs
 create mode 100644 src/Avalonia.X11/Selections/DragDrop/XdndActionHelper.cs
 create mode 100644 src/Avalonia.X11/Selections/DragDrop/XdndConstants.cs
 create mode 100644 src/Avalonia.X11/Selections/IXEventWaiter.cs
 create mode 100644 src/Avalonia.X11/Selections/SelectionDataProvider.cs
 create mode 100644 src/Avalonia.X11/Selections/SelectionDataReader.cs
 create mode 100644 src/Avalonia.X11/Selections/SelectionHelper.cs
 rename src/Avalonia.X11/{Clipboard/ClipboardReadSession.cs => Selections/SelectionReadSession.cs} (64%)
 rename src/Avalonia.X11/{Clipboard/ClipboardUriListHelper.cs => Selections/UriListHelper.cs} (94%)
 create mode 100644 src/Avalonia.X11/X11EnumExtensions.cs
 create mode 100644 src/Avalonia.X11/X11WindowInfo.cs

diff --git a/samples/ControlCatalog/Pages/DragAndDropPage.xaml b/samples/ControlCatalog/Pages/DragAndDropPage.xaml
index 2ca9ed27a0..7300f8c009 100644
--- a/samples/ControlCatalog/Pages/DragAndDropPage.xaml
+++ b/samples/ControlCatalog/Pages/DragAndDropPage.xaml
@@ -44,14 +44,14 @@
                 MaxWidth="260"
                 Background="{DynamicResource SystemAccentColorDark1}"
                 DragDrop.AllowDrop="True">
-          <TextBlock TextWrapping="Wrap">Drop some text or files here (Copy)</TextBlock>
+          <TextBlock TextWrapping="Wrap">Drop some text, files, bitmap or custom format here (Copy)</TextBlock>
         </Border>
         <Border Name="MoveTarget"
                 Padding="16"
                 MaxWidth="260"
                 Background="{DynamicResource SystemAccentColorDark1}"
                 DragDrop.AllowDrop="True">
-          <TextBlock TextWrapping="Wrap">Drop some text or files here (Move)</TextBlock>
+          <TextBlock TextWrapping="Wrap">Drop some text or custom format here (Move)</TextBlock>
         </Border>
       </StackPanel>
     </WrapPanel>
diff --git a/samples/ControlCatalog/Pages/DragAndDropPage.xaml.cs b/samples/ControlCatalog/Pages/DragAndDropPage.xaml.cs
index dcffeb611e..d9fe1af1d8 100644
--- a/samples/ControlCatalog/Pages/DragAndDropPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/DragAndDropPage.xaml.cs
@@ -54,6 +54,9 @@ namespace ControlCatalog.Pages
                 "Bitmap",
                 d => d.Add(DataTransferItem.Create(DataFormat.Bitmap, new Bitmap(AssetLoader.Open(new Uri("avares://ControlCatalog/Assets/image1.jpg"))))),
                 DragDropEffects.Copy);
+
+            AddHandlers(CopyTarget, DragDropEffects.Copy);
+            AddHandlers(MoveTarget, DragDropEffects.Move);
         }
 
         private void SetupDnd(string suffix, Action<DataTransfer> factory, DragDropEffects effects) =>
@@ -97,16 +100,18 @@ namespace ControlCatalog.Pages
                 }
             }
 
+            dragMe.PointerPressed += DoDrag;
+        }
+
+        private void AddHandlers(Control target, DragDropEffects allowedEffects)
+        {
+            DragDrop.AddDragEnterHandler(target, DragOver);
+            DragDrop.AddDragOverHandler(target, DragOver);
+            DragDrop.AddDropHandler(target, Drop);
+
             void DragOver(object? sender, DragEventArgs e)
             {
-                if (e.Source is Control c && c.Name == "MoveTarget")
-                {
-                    e.DragEffects = e.DragEffects & (DragDropEffects.Move);
-                }
-                else
-                {
-                    e.DragEffects = e.DragEffects & (DragDropEffects.Copy);
-                }
+                e.DragEffects &= allowedEffects;
 
                 // Only allow if the dragged data contains text or filenames.
                 if (!e.DataTransfer.Contains(DataFormat.Text)
@@ -118,14 +123,10 @@ namespace ControlCatalog.Pages
 
             async void Drop(object? sender, DragEventArgs e)
             {
-                if (e.Source is Control c && c.Name == "MoveTarget")
-                {
-                    e.DragEffects = e.DragEffects & (DragDropEffects.Move);
-                }
-                else
-                {
-                    e.DragEffects = e.DragEffects & (DragDropEffects.Copy);
-                }
+                e.DragEffects &= allowedEffects;
+
+                if (e.DragEffects == DragDropEffects.None)
+                    return;
 
                 if (e.DataTransfer.Contains(DataFormat.Text))
                 {
@@ -168,11 +169,6 @@ namespace ControlCatalog.Pages
                     DropState.Content = "Custom: " + e.DataTransfer.TryGetValue(_customFormat);
                 }
             }
-
-            dragMe.PointerPressed += DoDrag;
-
-            AddHandler(DragDrop.DropEvent, Drop);
-            AddHandler(DragDrop.DragOverEvent, DragOver);
         }
     }
 }
diff --git a/src/Avalonia.Base/Input/AsyncDataTransferExtensions.cs b/src/Avalonia.Base/Input/AsyncDataTransferExtensions.cs
index cf9d320310..a71a1e744d 100644
--- a/src/Avalonia.Base/Input/AsyncDataTransferExtensions.cs
+++ b/src/Avalonia.Base/Input/AsyncDataTransferExtensions.cs
@@ -27,6 +27,9 @@ public static class AsyncDataTransferExtensions
         return new AsyncToSyncDataTransfer(asyncDataTransfer);
     }
 
+    internal static IAsyncDataTransfer ToAsynchronous(this IDataTransfer dataTransfer)
+        => dataTransfer as IAsyncDataTransfer ?? new SyncToAsyncDataTransfer(dataTransfer);
+
     /// <summary>
     /// Gets whether a <see cref="IAsyncDataTransfer"/> supports a specific format.
     /// </summary>
diff --git a/src/Avalonia.Base/Input/SyncToAsyncDataTransfer.cs b/src/Avalonia.Base/Input/SyncToAsyncDataTransfer.cs
new file mode 100644
index 0000000000..c228e8b8db
--- /dev/null
+++ b/src/Avalonia.Base/Input/SyncToAsyncDataTransfer.cs
@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+
+namespace Avalonia.Input;
+
+/// <summary>
+/// Wraps a <see cref="IDataTransfer"/> into a <see cref="IAsyncDataTransfer"/>.
+/// </summary>
+/// <param name="dataTransfer">The sync object to wrap.</param>
+internal sealed class SyncToAsyncDataTransfer(IDataTransfer dataTransfer)
+    : IDataTransfer, IAsyncDataTransfer
+{
+    private SyncToAsyncDataTransferItem[]? _items;
+
+    public IReadOnlyList<DataFormat> Formats
+        => dataTransfer.Formats;
+
+    public IReadOnlyList<SyncToAsyncDataTransferItem> Items
+        => _items ??= ProvideItems();
+
+    IReadOnlyList<IDataTransferItem> IDataTransfer.Items
+        => dataTransfer.Items;
+
+    IReadOnlyList<IAsyncDataTransferItem> IAsyncDataTransfer.Items
+        => Items;
+
+    private SyncToAsyncDataTransferItem[] ProvideItems()
+    {
+        var asyncItems = dataTransfer.Items;
+        var count = asyncItems.Count;
+        var syncItems = new SyncToAsyncDataTransferItem[count];
+
+        for (var i = 0; i < count; ++i)
+        {
+            var asyncItem = asyncItems[i];
+            syncItems[i] = new SyncToAsyncDataTransferItem(asyncItem);
+        }
+
+        return syncItems;
+    }
+
+    public void Dispose()
+        => dataTransfer.Dispose();
+}
diff --git a/src/Avalonia.Base/Input/SyncToAsyncDataTransferItem.cs b/src/Avalonia.Base/Input/SyncToAsyncDataTransferItem.cs
new file mode 100644
index 0000000000..705ce0bdee
--- /dev/null
+++ b/src/Avalonia.Base/Input/SyncToAsyncDataTransferItem.cs
@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Avalonia.Input;
+
+/// <summary>
+/// Wraps a <see cref="IDataTransferItem"/> into a <see cref="IAsyncDataTransferItem"/>.
+/// </summary>
+/// <param name="dataTransferItem">The sync item to wrap.</param>
+internal sealed class SyncToAsyncDataTransferItem(IDataTransferItem dataTransferItem)
+    : IDataTransferItem, IAsyncDataTransferItem
+{
+    public IReadOnlyList<DataFormat> Formats
+        => dataTransferItem.Formats;
+
+    public object? TryGetRaw(DataFormat format)
+        => dataTransferItem.TryGetRaw(format);
+
+    public Task<object?> TryGetRawAsync(DataFormat format)
+        => Task.FromResult(dataTransferItem.TryGetRaw(format));
+}
diff --git a/src/Avalonia.Controls/Platform/InProcessDragSource.cs b/src/Avalonia.Controls/Platform/InProcessDragSource.cs
index 6a8b79eab6..7a591cdff3 100644
--- a/src/Avalonia.Controls/Platform/InProcessDragSource.cs
+++ b/src/Avalonia.Controls/Platform/InProcessDragSource.cs
@@ -63,6 +63,7 @@ namespace Avalonia.Platform
                     using (_result.Subscribe(new AnonymousObserver<DragDropEffects>(tcs)))
                     {
                         var effect = await tcs.Task;
+                        dataTransfer.Dispose();
                         return effect;
                     }
                 }
diff --git a/src/Avalonia.Wayland/Avalonia.Wayland.csproj b/src/Avalonia.Wayland/Avalonia.Wayland.csproj
index 4b4ebfece8..a8f11827f3 100644
--- a/src/Avalonia.Wayland/Avalonia.Wayland.csproj
+++ b/src/Avalonia.Wayland/Avalonia.Wayland.csproj
@@ -16,7 +16,7 @@
     <ProjectReference Include="..\Avalonia.FreeDesktop\Avalonia.FreeDesktop.csproj" />
     <Compile Include="..\Shared\RawEventGrouping.cs" />
     <Compile Include="..\Avalonia.X11\X11IconLoader.cs" />
-    <Compile Include="..\Avalonia.X11\Clipboard\ClipboardUriListHelper.cs" />
+    <Compile Include="..\Avalonia.X11\Selections\UriListHelper.cs" />
     <Compile Include="..\Avalonia.X11\Interop\Glib.cs" Link="Dispatching\Glib.cs" />
     <Compile Include="..\Avalonia.X11\Dispatching\GlibDispatcherImplBase.cs" Link="Dispatching\GlibDispatcherImplBase.cs" />
   </ItemGroup>
diff --git a/src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs b/src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs
index 8c0b7013bf..5c82470ee6 100644
--- a/src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs
+++ b/src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs
@@ -8,7 +8,7 @@ using Avalonia.Media.Imaging;
 using Avalonia.Platform.Storage;
 using Avalonia.Wayland.Server;
 using Avalonia.Wayland.Server.Transient.Clipboard;
-using Avalonia.X11.Clipboard;
+using Avalonia.X11.Selections;
 
 namespace Avalonia.Wayland.Clipboard;
 
@@ -79,7 +79,7 @@ class WaylandClipboardImpl : IOwnedClipboardImpl
         if (DataFormat.File.Equals(format))
         {
             if (await transfer.TryGetFilesAsync().ConfigureAwait(false) is { Length: > 0 } files)
-                await stream.WriteAsync(ClipboardUriListHelper.FileUriListToUtf8Bytes(files)).ConfigureAwait(false);
+                await stream.WriteAsync(UriListHelper.FileUriListToUtf8Bytes(files)).ConfigureAwait(false);
             return;
         }
         
diff --git a/src/Avalonia.Wayland/Clipboard/WaylandDataTransfer.cs b/src/Avalonia.Wayland/Clipboard/WaylandDataTransfer.cs
index 9634e6298c..50c4a937c5 100644
--- a/src/Avalonia.Wayland/Clipboard/WaylandDataTransfer.cs
+++ b/src/Avalonia.Wayland/Clipboard/WaylandDataTransfer.cs
@@ -11,7 +11,7 @@ using Avalonia.Platform.Storage;
 using Avalonia.Platform.Storage.FileIO;
 using Avalonia.Wayland.Server.Interop;
 using Avalonia.Wayland.Server.Transient.Clipboard;
-using Avalonia.X11.Clipboard;
+using Avalonia.X11.Selections;
 
 namespace Avalonia.Wayland.Clipboard;
 
@@ -118,7 +118,7 @@ class WaylandDataTransfer : IDataTransfer, IAsyncDataTransfer
         if (!BuildFormats().formatToMime.TryGetValue(DataFormat.File, out var mime))
             return null;
         var bytes = await WaylandDataTransferItem.ReadRawBytesAsync(_offerCookie, mime).ConfigureAwait(false);
-        return bytes is { Length: > 0 } ? ClipboardUriListHelper.Utf8BytesToFileUriList(bytes) : null;
+        return bytes is { Length: > 0 } ? UriListHelper.Utf8BytesToFileUriList(bytes) : null;
     }
 
     IReadOnlyList<DataFormat> IDataTransfer.Formats => GetFormats();
diff --git a/src/Avalonia.X11/Clipboard/ClipboardDataFormatHelper.cs b/src/Avalonia.X11/Clipboard/ClipboardDataFormatHelper.cs
deleted file mode 100644
index 5e53ff96c1..0000000000
--- a/src/Avalonia.X11/Clipboard/ClipboardDataFormatHelper.cs
+++ /dev/null
@@ -1,119 +0,0 @@
-using System;
-using System.Text;
-using Avalonia.Controls;
-using Avalonia.Input;
-
-namespace Avalonia.X11.Clipboard;
-
-internal static class ClipboardDataFormatHelper
-{
-    private const string MimeTypeTextUriList = "text/uri-list";
-    private const string AppPrefix = "application/avn-fmt.";
-    public const string PngFormatMimeType = "image/png";
-    public const string JpegFormatMimeType = "image/jpeg";
-
-    public static DataFormat? ToDataFormat(IntPtr formatAtom, X11Atoms atoms)
-    {
-        if (formatAtom == IntPtr.Zero)
-            return null;
-
-        if (formatAtom == atoms.UTF16_STRING ||
-            formatAtom == atoms.UTF8_STRING ||
-            formatAtom == atoms.STRING ||
-            formatAtom == atoms.OEMTEXT)
-        {
-            return DataFormat.Text;
-        }
-
-        if (formatAtom == atoms.MULTIPLE ||
-            formatAtom == atoms.TARGETS ||
-            formatAtom == atoms.SAVE_TARGETS)
-        {
-            return null;
-        }
-
-        if (atoms.GetAtomName(formatAtom) is { } atomName)
-        {
-            return atomName == MimeTypeTextUriList ?
-                DataFormat.File : DataFormat.FromSystemName<byte[]>(atomName, AppPrefix);
-        }
-
-        return null;
-    }
-
-    public static IntPtr ToAtom(DataFormat format, IntPtr[] textFormatAtoms, X11Atoms atoms, DataFormat[] dataFormats)
-    {
-        if (DataFormat.Text.Equals(format))
-            return GetPreferredStringFormatAtom(textFormatAtoms, atoms);
-
-        if (DataFormat.File.Equals(format))
-            return atoms.GetAtom(MimeTypeTextUriList);
-
-        if (DataFormat.Bitmap.Equals(format))
-        {
-            DataFormat? pngFormat = null, jpegFormat = null;
-            foreach (var imageFormat in dataFormats)
-            {
-                if (imageFormat.Identifier is PngFormatMimeType)
-                    pngFormat = imageFormat;
-                else if (imageFormat.Identifier is JpegFormatMimeType)
-                    jpegFormat = imageFormat;
-
-                if (pngFormat != null && jpegFormat != null)
-                    break;
-            }
-
-            var preferredFormat = pngFormat ?? jpegFormat ?? null;
-
-            if (preferredFormat != null)
-                return atoms.GetAtom(preferredFormat.ToSystemName(AppPrefix));
-            else
-                return IntPtr.Zero;
-        }
-
-        var systemName = format.ToSystemName(AppPrefix);
-        return atoms.GetAtom(systemName);
-    }
-
-    public static IntPtr[] ToAtoms(DataFormat format, IntPtr[] textFormatAtoms, X11Atoms atoms)
-    {
-        if (DataFormat.Text.Equals(format))
-            return textFormatAtoms;
-
-        if (DataFormat.File.Equals(format))
-            return [atoms.GetAtom(MimeTypeTextUriList)];
-
-        if (DataFormat.Bitmap.Equals(format))
-            return [atoms.GetAtom(PngFormatMimeType)];
-
-        var systemName = format.ToSystemName(AppPrefix);
-        return [atoms.GetAtom(systemName)];
-    }
-
-    private static IntPtr GetPreferredStringFormatAtom(IntPtr[] textFormatAtoms, X11Atoms atoms)
-    {
-        ReadOnlySpan<IntPtr> preferredFormats = [atoms.UTF16_STRING, atoms.UTF8_STRING, atoms.STRING];
-
-        foreach (var preferredFormat in preferredFormats)
-        {
-            if (Array.IndexOf(textFormatAtoms, preferredFormat) >= 0)
-                return preferredFormat;
-        }
-
-        return atoms.UTF8_STRING;
-    }
-
-    public static Encoding? TryGetStringEncoding(IntPtr formatAtom, X11Atoms atoms)
-    {
-        if (formatAtom == atoms.UTF16_STRING)
-           return Encoding.Unicode;
-
-        if (formatAtom == atoms.UTF8_STRING)
-            return Encoding.UTF8;
-
-        if (formatAtom == atoms.STRING || formatAtom == atoms.OEMTEXT)
-            return Encoding.ASCII;
-
-        return null;
-    }
-}
diff --git a/src/Avalonia.X11/Clipboard/ClipboardDataReader.cs b/src/Avalonia.X11/Clipboard/ClipboardDataReader.cs
deleted file mode 100644
index 910b76385c..0000000000
--- a/src/Avalonia.X11/Clipboard/ClipboardDataReader.cs
+++ /dev/null
@@ -1,82 +0,0 @@
-using System;
-using System.IO;
-using System.Text;
-using System.Threading.Tasks;
-using Avalonia.Input;
-using Avalonia.Media.Imaging;
-using static Avalonia.X11.XLib;
-
-namespace Avalonia.X11.Clipboard;
-
-/// <summary>
-/// An object used to read values, converted to the correct format, from the X11 clipboard.
-/// </summary>
-internal sealed class ClipboardDataReader(
-    X11Info x11,
-    AvaloniaX11Platform platform,
-    IntPtr[] textFormatAtoms,
-    IntPtr owner,
-    DataFormat[] dataFormats)
-    : IDisposable
-{
-    private readonly X11Info _x11 = x11;
-    private readonly AvaloniaX11Platform _platform = platform;
-    private readonly IntPtr[] _textFormatAtoms = textFormatAtoms;
-    private IntPtr _owner = owner;
-
-    private bool IsOwnerStillValid()
-        => _owner != IntPtr.Zero && XGetSelectionOwner(_x11.Display, _x11.Atoms.CLIPBOARD) == _owner;
-    
-    public async Task<object?> TryGetAsync(DataFormat format)
-    {
-        if (!IsOwnerStillValid())
-            return null;
-
-        var formatAtom = ClipboardDataFormatHelper.ToAtom(format, _textFormatAtoms, _x11.Atoms, dataFormats);
-        if (formatAtom == IntPtr.Zero)
-            return null;
-
-        using var session = new ClipboardReadSession(_platform);
-        var result = await session.SendDataRequest(formatAtom).ConfigureAwait(false);
-        return ConvertDataResult(result, format, formatAtom);
-    }
-
-    private object? ConvertDataResult(ClipboardReadSession.GetDataResult? result, DataFormat format, IntPtr formatAtom)
-    {
-        if (result is null)
-            return null;
-
-        if (DataFormat.Text.Equals(format))
-        {
-            return ClipboardDataFormatHelper.TryGetStringEncoding(result.TypeAtom, _x11.Atoms) is { } textEncoding ?
-                textEncoding.GetString(result.AsBytes()) :
-                null;
-        }
-
-        if(DataFormat.Bitmap.Equals(format))
-        {
-            using var data = result.AsStream();
-
-            return new Bitmap(data);
-        }
-
-        if (DataFormat.File.Equals(format))
-        {
-            // text/uri-list might not be supported
-            return formatAtom != IntPtr.Zero && result.TypeAtom == formatAtom ?
-                ClipboardUriListHelper.Utf8BytesToFileUriList(result.AsBytes()) :
-                null;
-        }
-
-        if (format is DataFormat<string>)
-            return Encoding.UTF8.GetString(result.AsBytes());
-
-        if (format is DataFormat<byte[]>)
-            return result.AsBytes();
-
-        return null;
-    }
-
-    public void Dispose()
-        => _owner = IntPtr.Zero;
-}
diff --git a/src/Avalonia.X11/Clipboard/X11Clipboard.cs b/src/Avalonia.X11/Clipboard/X11Clipboard.cs
deleted file mode 100644
index 48d50d076a..0000000000
--- a/src/Avalonia.X11/Clipboard/X11Clipboard.cs
+++ /dev/null
@@ -1,417 +0,0 @@
-using System;
-using System.Buffers;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Avalonia.Input;
-using Avalonia.Input.Platform;
-using Avalonia.Logging;
-using Avalonia.Platform.Storage;
-using static Avalonia.X11.XLib;
-
-namespace Avalonia.X11.Clipboard
-{
-    internal sealed class X11ClipboardImpl : IOwnedClipboardImpl
-    {
-        private readonly AvaloniaX11Platform _platform;
-        private readonly X11Info _x11;
-        private IAsyncDataTransfer? _storedDataTransfer;
-        private readonly IntPtr _handle;
-        private TaskCompletionSource<bool>? _storeAtomTcs;
-        private readonly IntPtr[] _textAtoms;
-        private readonly IntPtr _avaloniaSaveTargetsAtom;
-        private readonly int _maximumPropertySize;
-
-        public X11ClipboardImpl(AvaloniaX11Platform platform)
-        {
-            _platform = platform;
-            _x11 = platform.Info;
-            _handle = CreateEventWindow(platform, OnEvent);
-            _avaloniaSaveTargetsAtom = XInternAtom(_x11.Display, "AVALONIA_SAVE_TARGETS_PROPERTY_ATOM", false);
-            _textAtoms = new[]
-            {
-                _x11.Atoms.STRING,
-                _x11.Atoms.OEMTEXT,
-                _x11.Atoms.UTF8_STRING,
-                _x11.Atoms.UTF16_STRING
-            }.Where(a => a != IntPtr.Zero).ToArray();
-
-            var extendedMaxRequestSize = XExtendedMaxRequestSize(_platform.Display);
-            var maxRequestSize = XMaxRequestSize(_platform.Display);
-            _maximumPropertySize =
-                (int)Math.Min(0x100000, (extendedMaxRequestSize == IntPtr.Zero
-                    ? maxRequestSize
-                    : extendedMaxRequestSize).ToInt64() - 0x100);
-        }
-        
-        private unsafe void OnEvent(ref XEvent ev)
-        {
-            if (ev.type == XEventName.SelectionClear)
-            {
-                // We night have already regained the clipboard ownership by the time a SelectionClear message arrives.
-                if (GetOwner() != _handle)
-                    _storedDataTransfer = null;
-
-                _storeAtomTcs?.TrySetResult(true);
-            }
-
-            else if (ev.type == XEventName.SelectionRequest)
-            {
-                var sel = ev.SelectionRequestEvent;
-                var resp = new XEvent
-                {
-                    SelectionEvent =
-                    {
-                        type = XEventName.SelectionNotify,
-                        send_event = 1,
-                        display = _x11.Display,
-                        selection = sel.selection,
-                        target = sel.target,
-                        requestor = sel.requestor,
-                        time = sel.time,
-                        property = IntPtr.Zero
-                    }
-                };
-                if (sel.selection == _x11.Atoms.CLIPBOARD)
-                {
-                    resp.SelectionEvent.property = WriteTargetToProperty(sel.target, sel.requestor, sel.property);
-                }
-
-                XSendEvent(_x11.Display, sel.requestor, false, new IntPtr((int)EventMask.NoEventMask), ref resp);
-            }
-
-            else if (ev.type == XEventName.SelectionNotify)
-            {
-                if (ev.SelectionEvent.selection == _x11.Atoms.CLIPBOARD_MANAGER &&
-                    ev.SelectionEvent.target == _x11.Atoms.SAVE_TARGETS &&
-                    _x11.Atoms.CLIPBOARD_MANAGER != IntPtr.Zero &&
-                    _x11.Atoms.SAVE_TARGETS != IntPtr.Zero)
-                {
-                    _storeAtomTcs?.TrySetResult(true);
-                }
-            }
-
-            IntPtr WriteTargetToProperty(IntPtr target, IntPtr window, IntPtr property)
-            {
-                if (target == _x11.Atoms.TARGETS)
-                {
-                    var atoms = ConvertDataTransfer(_storedDataTransfer);
-                    XChangeProperty(_x11.Display, window, property,
-                        _x11.Atoms.ATOM, 32, PropertyMode.Replace, atoms, atoms.Length);
-                    return property;
-                }
-                else if (target == _x11.Atoms.SAVE_TARGETS && _x11.Atoms.SAVE_TARGETS != IntPtr.Zero)
-                {
-                    return property;
-                }
-                else if (ClipboardDataFormatHelper.ToDataFormat(target, _x11.Atoms) is { } dataFormat)
-                {
-                    if (_storedDataTransfer is null)
-                        return IntPtr.Zero;
-
-                    // Our default bitmap format is image/png
-                    if (dataFormat.Identifier is "image/png" && _storedDataTransfer.Contains(DataFormat.Bitmap))
-                        dataFormat = DataFormat.Bitmap;
-
-                    if (!_storedDataTransfer.Contains(dataFormat))
-                        return IntPtr.Zero;
-
-                    if (TryGetDataAsBytes(_storedDataTransfer, dataFormat, target) is not { } bytes)
-                        return IntPtr.Zero;
-
-                    _ = SendDataToClientAsync(window, property, target, bytes);
-                    return property;
-                }
-                else if (target == _x11.Atoms.MULTIPLE && _x11.Atoms.MULTIPLE != IntPtr.Zero)
-                {
-                    XGetWindowProperty(_x11.Display, window, property, IntPtr.Zero, new IntPtr(0x7fffffff), false,
-                        _x11.Atoms.ATOM_PAIR, out _, out var actualFormat, out var nitems, out _, out var prop);
-                    if (nitems == IntPtr.Zero)
-                        return IntPtr.Zero;
-                    if (actualFormat == 32)
-                    {
-                        var data = (IntPtr*)prop.ToPointer();
-                        for (var c = 0; c < nitems.ToInt32(); c += 2)
-                        {
-                            var subTarget = data[c];
-                            var subProp = data[c + 1];
-                            var converted = WriteTargetToProperty(subTarget, window, subProp);
-                            data[c + 1] = converted;
-                        }
-
-                        XChangeProperty(_x11.Display, window, property, _x11.Atoms.ATOM_PAIR, 32, PropertyMode.Replace,
-                            prop.ToPointer(), nitems.ToInt32());
-                    }
-
-                    XFree(prop);
-
-                    return property;
-                }
-                else
-                    return IntPtr.Zero;
-            }
-
-        }
-
-        private byte[]? TryGetDataAsBytes(IAsyncDataTransfer dataTransfer, DataFormat format, IntPtr targetFormatAtom)
-        {
-            if (DataFormat.Text.Equals(format))
-            {
-                var text = dataTransfer.TryGetValueAsync(DataFormat.Text).GetAwaiter().GetResult();
-
-                return ClipboardDataFormatHelper.TryGetStringEncoding(targetFormatAtom, _x11.Atoms) is { } encoding ?
-                    encoding.GetBytes(text ?? string.Empty) :
-                    null;
-            }
-
-            if (DataFormat.Bitmap.Equals(format))
-            {
-                if (dataTransfer.TryGetValueAsync(DataFormat.Bitmap).GetAwaiter().GetResult() is not { } bitmap)
-                    return null;
-
-                using var stream = new MemoryStream();
-                bitmap.Save(stream);
-
-                return stream.ToArray();
-            }
-            
-            if (DataFormat.File.Equals(format))
-            {
-                if (dataTransfer.TryGetValuesAsync(DataFormat.File).GetAwaiter().GetResult() is not { } files)
-                    return null;
-
-                return ClipboardUriListHelper.FileUriListToUtf8Bytes(files);
-            }
-
-            if (format is DataFormat<string> stringFormat)
-            {
-                return dataTransfer.TryGetValueAsync(stringFormat).GetAwaiter().GetResult() is { } stringValue ?
-                    Encoding.UTF8.GetBytes(stringValue) :
-                    null;
-            }
-
-            if (format is DataFormat<byte[]> bytesFormat)
-                return dataTransfer.TryGetValueAsync(bytesFormat).GetAwaiter().GetResult();
-
-            Logger.TryGet(LogEventLevel.Warning, LogArea.X11Platform)
-                ?.Log(this, "Unsupported data format {Format}", format);
-
-            return null;
-        }
-
-        private async Task SendIncrDataToClientAsync(IntPtr window, IntPtr property, IntPtr target, Stream data)
-        {
-            data.Position = 0;
-            using var events = new EventStreamWindow(_platform, window);
-            using var _ = data;
-            XSelectInput(_x11.Display, window, new IntPtr((int)XEventMask.PropertyChangeMask));
-            var size = new IntPtr(data.Length);
-            XChangeProperty(_x11.Display, window, property, _x11.Atoms.INCR, 32, PropertyMode.Replace, ref size, 1);
-            var buffer = ArrayPool<byte>.Shared.Rent((int)Math.Min(_maximumPropertySize, data.Length));
-            while (true)
-            {
-                if (null == await events.WaitForEventAsync(x =>
-                        x.type == XEventName.PropertyNotify && x.PropertyEvent.atom == property
-                                                            && x.PropertyEvent.state == 1, TimeSpan.FromMinutes(1)))
-                    break;
-                var read = await data.ReadAsync(buffer, 0, buffer.Length);
-                if(read == 0)
-                    break;
-                XChangeProperty(_x11.Display, window, property, target, 8, PropertyMode.Replace, buffer, read);
-            }
-            ArrayPool<byte>.Shared.Return(buffer);
-
-            // Finish the transfer
-            XChangeProperty(_x11.Display, window, property, target, 8, PropertyMode.Replace, IntPtr.Zero, 0);
-        }
-
-        private Task SendDataToClientAsync(IntPtr window, IntPtr property, IntPtr target, byte[] bytes)
-        {
-            if (bytes.Length < _maximumPropertySize)
-            {
-                XChangeProperty(_x11.Display, window, property, target, 8,
-                    PropertyMode.Replace,
-                    bytes, bytes.Length);
-                return Task.CompletedTask;
-            }
-
-            return SendIncrDataToClientAsync(window, property, target, new MemoryStream(bytes));
-        }
-
-        private IntPtr GetOwner()
-            => XGetSelectionOwner(_x11.Display, _x11.Atoms.CLIPBOARD);
-        
-        private ClipboardReadSession OpenReadSession() => new(_platform);
-
-        private IntPtr[] ConvertDataTransfer(IAsyncDataTransfer? dataTransfer)
-        {
-            var atoms = new List<IntPtr> { _x11.Atoms.TARGETS, _x11.Atoms.MULTIPLE };
-
-            if (dataTransfer is not null)
-            {
-                foreach (var format in dataTransfer.Formats)
-                {
-                    if (format.Kind == DataFormatKind.InProcess)
-                        continue;
-
-                    foreach (var atom in ClipboardDataFormatHelper.ToAtoms(format, _textAtoms, _x11.Atoms))
-                        atoms.Add(atom);
-                }
-            }
-
-            return atoms.ToArray();
-        }
-
-        private Task StoreAtomsInClipboardManager(IAsyncDataTransfer dataTransfer)
-        {
-            if (_x11.Atoms.CLIPBOARD_MANAGER == IntPtr.Zero || _x11.Atoms.SAVE_TARGETS == IntPtr.Zero)
-                return Task.CompletedTask;
-
-            var clipboardManager = XGetSelectionOwner(_x11.Display, _x11.Atoms.CLIPBOARD_MANAGER);
-            if (clipboardManager == IntPtr.Zero)
-                return Task.CompletedTask;
-
-            // Skip storing atoms if the data object contains any non-trivial formats
-            if (dataTransfer.Formats.Any(f => !DataFormat.Text.Equals(f)))
-                return Task.CompletedTask;
-
-            return StoreTextCoreAsync();
-
-            async Task StoreTextCoreAsync()
-            {
-                // Skip storing atoms if the trivial formats are too big
-                var text = await dataTransfer.TryGetTextAsync();
-                if (text is null || text.Length * 2 > 64 * 1024)
-                    return;
-
-                if (_storeAtomTcs is null || _storeAtomTcs.Task.IsCompleted)
-                    _storeAtomTcs = new TaskCompletionSource<bool>();
-
-                var atoms = ConvertDataTransfer(dataTransfer);
-                XChangeProperty(_x11.Display, _handle, _avaloniaSaveTargetsAtom, _x11.Atoms.ATOM, 32,
-                    PropertyMode.Replace, atoms, atoms.Length);
-                XConvertSelection(_x11.Display, _x11.Atoms.CLIPBOARD_MANAGER, _x11.Atoms.SAVE_TARGETS,
-                    _avaloniaSaveTargetsAtom, _handle, IntPtr.Zero);
-                await _storeAtomTcs.Task;
-            }
-        }
-
-        public Task ClearAsync()
-        {
-            _storedDataTransfer = null;
-            XSetSelectionOwner(_x11.Display, _x11.Atoms.CLIPBOARD, IntPtr.Zero, IntPtr.Zero);
-            return Task.CompletedTask;
-        }
-
-        public async Task<IAsyncDataTransfer?> TryGetDataAsync()
-        {
-            var owner = GetOwner();
-            if (owner == IntPtr.Zero)
-                return null;
-
-            if (owner == _handle && _storedDataTransfer is { } storedDataTransfer)
-                return storedDataTransfer;
-
-            // Get the formats while we're in an async method, since IAsyncDataTransfer.GetFormats() is synchronous.
-            var (dataFormats, textFormatAtoms) = await GetDataFormatsCoreAsync().ConfigureAwait(false);
-            if (dataFormats.Length == 0)
-                return null;
-
-            // Get the items while we're in an async method. This does not get values, except for DataFormat.File.
-            var reader = new ClipboardDataReader(_x11, _platform, textFormatAtoms, owner, dataFormats);
-            var items = await CreateItemsAsync(reader, dataFormats);
-            return new ClipboardDataTransfer(reader, dataFormats, items);
-        }
-
-        private async Task<(DataFormat[] DataFormats, IntPtr[] TextFormatAtoms)> GetDataFormatsCoreAsync()
-        {
-            using var session = OpenReadSession();
-
-            var formatAtoms = await session.SendFormatRequest();
-            if (formatAtoms is null)
-                return ([], []);
-
-            var formats = new List<DataFormat>(formatAtoms.Length);
-            List<IntPtr>? textFormatAtoms = null;
-
-            var hasImage = false;
-
-            foreach (var formatAtom in formatAtoms)
-            {
-                if (ClipboardDataFormatHelper.ToDataFormat(formatAtom, _x11.Atoms) is not { } format)
-                    continue;
-
-                if (DataFormat.Text.Equals(format))
-                {
-                    if (textFormatAtoms is null)
-                    {
-                        formats.Add(format);
-                        textFormatAtoms = [];
-                    }
-                    textFormatAtoms.Add(formatAtom);
-                }
-                else
-                {
-                    formats.Add(format);
-
-                    if(!hasImage)
-                    {
-                        if (format.Identifier is ClipboardDataFormatHelper.JpegFormatMimeType or ClipboardDataFormatHelper.PngFormatMimeType)
-                            hasImage = true;
-                    }
-                }
-            }
-
-            if (hasImage)
-                formats.Add(DataFormat.Bitmap);
-
-            return (formats.ToArray(), textFormatAtoms?.ToArray() ?? []);
-        }
-
-        private static async Task<IAsyncDataTransferItem[]> CreateItemsAsync(ClipboardDataReader reader, DataFormat[] formats)
-        {
-            List<DataFormat>? nonFileFormats = null;
-            var items = new List<IAsyncDataTransferItem>();
-            var hasFiles = false;
-
-            foreach (var format in formats)
-            {
-                if (DataFormat.File.Equals(format))
-                {
-                    if (hasFiles)
-                        continue;
-
-                    // We're reading the filenames ahead of time to generate the appropriate items.
-                    // This is async, so it should be fine.
-                    if (await reader.TryGetAsync(format) is IEnumerable<IStorageItem> storageItems)
-                    {
-                        hasFiles = true;
-
-                        foreach (var storageItem in storageItems)
-                            items.Add(PlatformDataTransferItem.Create(DataFormat.File, storageItem));
-                    }
-                }
-                else
-                    (nonFileFormats ??= new()).Add(format);
-            }
-
-            // Single item containing all formats except for DataFormat.File.
-            if (nonFileFormats is not null)
-                items.Add(new ClipboardDataTransferItem(reader, formats));
-
-            return items.ToArray();
-        }
-
-        public Task SetDataAsync(IAsyncDataTransfer dataTransfer)
-        {
-            _storedDataTransfer = dataTransfer;
-            XSetSelectionOwner(_x11.Display, _x11.Atoms.CLIPBOARD, _handle, IntPtr.Zero);
-            return StoreAtomsInClipboardManager(dataTransfer);
-        }
-
-        public Task<bool> IsCurrentOwnerAsync()
-            => Task.FromResult(GetOwner() == _handle);
-    }
-}
diff --git a/src/Avalonia.X11/Dispatching/X11EventDispatcher.cs b/src/Avalonia.X11/Dispatching/X11EventDispatcher.cs
index 36625a61cd..9a8dcf8060 100644
--- a/src/Avalonia.X11/Dispatching/X11EventDispatcher.cs
+++ b/src/Avalonia.X11/Dispatching/X11EventDispatcher.cs
@@ -8,20 +8,22 @@ internal class X11EventDispatcher
 {
     private readonly AvaloniaX11Platform _platform;
     private readonly IntPtr _display;
+    private readonly Dictionary<IntPtr, X11WindowInfo> _windows;
 
     public delegate void EventHandler(ref XEvent xev);
     public int Fd { get; }
-    private readonly Dictionary<IntPtr, EventHandler> _eventHandlers;
 
     public X11EventDispatcher(AvaloniaX11Platform platform)
     {
         _platform = platform;
         _display = platform.Display;
-        _eventHandlers = platform.Windows;
+        _windows = platform.Windows;
         Fd = XLib.XConnectionNumber(_display);
     }
 
     public bool IsPending => XPending(_display) != 0;
+
+    public IEventHook? EventHook { get; set; }
     
     public unsafe void DispatchX11Events(CancellationToken cancellationToken)
     {
@@ -38,6 +40,9 @@ internal class X11EventDispatcher
                 XGetEventData(_display, &xev.GenericEventCookie);
             try
             {
+                if (EventHook?.TryHandleEvent(in xev) == true)
+                    continue;
+
                 if (xev.type == XEventName.GenericEvent)
                 {
                     if (_platform.XI2 != null && _platform.Info.XInputOpcode ==
@@ -46,8 +51,8 @@ internal class X11EventDispatcher
                         _platform.XI2.OnEvent((XIEvent*)xev.GenericEventCookie.data);
                     }
                 }
-                else if (_eventHandlers.TryGetValue(xev.AnyEvent.window, out var handler))
-                    handler(ref xev);
+                else if (_windows.TryGetValue(xev.AnyEvent.window, out var windowInfo))
+                    windowInfo.EventHandler(ref xev);
             }
             finally
             {
@@ -59,4 +64,9 @@ internal class X11EventDispatcher
     }
 
     public void Flush() => XFlush(_display);
-}
\ No newline at end of file
+
+    public interface IEventHook
+    {
+        bool TryHandleEvent(in XEvent evt);
+    }
+}
diff --git a/src/Avalonia.X11/Selections/Clipboard/ClipboardDataReader.cs b/src/Avalonia.X11/Selections/Clipboard/ClipboardDataReader.cs
new file mode 100644
index 0000000000..d3dafbcc84
--- /dev/null
+++ b/src/Avalonia.X11/Selections/Clipboard/ClipboardDataReader.cs
@@ -0,0 +1,39 @@
+using System;
+using System.Threading.Tasks;
+using Avalonia.Input;
+using static Avalonia.X11.XLib;
+
+namespace Avalonia.X11.Selections.Clipboard;
+
+/// <summary>
+/// An object used to read values, converted to the correct format, from the X11 clipboard.
+/// </summary>
+internal sealed class ClipboardDataReader(
+    AvaloniaX11Platform platform,
+    IntPtr[] textFormatAtoms,
+    DataFormat[] dataFormats,
+    IntPtr owner)
+    : SelectionDataReader<IAsyncDataTransferItem>(platform.Info.Atoms, textFormatAtoms, dataFormats)
+{
+    private IntPtr _owner = owner;
+
+    private bool IsOwnerStillValid()
+        => _owner != IntPtr.Zero && XGetSelectionOwner(platform.Display, platform.Info.Atoms.CLIPBOARD) == _owner;
+
+    public override Task<object?> TryGetAsync(DataFormat format)
+    {
+        if (!IsOwnerStillValid())
+            return Task.FromResult<object?>(null);
+
+        return base.TryGetAsync(format);
+    }
+
+    protected override IAsyncDataTransferItem CreateSingleItem(DataFormat[] nonFileFormats)
+        => new ClipboardDataTransferItem(this, nonFileFormats);
+
+    protected override SelectionReadSession CreateReadSession()
+        => ClipboardReadSessionFactory.CreateSession(platform);
+
+    public override void Dispose()
+        => _owner = IntPtr.Zero;
+}
diff --git a/src/Avalonia.X11/Clipboard/ClipboardDataTransfer.cs b/src/Avalonia.X11/Selections/Clipboard/ClipboardDataTransfer.cs
similarity index 75%
rename from src/Avalonia.X11/Clipboard/ClipboardDataTransfer.cs
rename to src/Avalonia.X11/Selections/Clipboard/ClipboardDataTransfer.cs
index 3c9ef5b821..569a157aa3 100644
--- a/src/Avalonia.X11/Clipboard/ClipboardDataTransfer.cs
+++ b/src/Avalonia.X11/Selections/Clipboard/ClipboardDataTransfer.cs
@@ -1,7 +1,7 @@
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 
-namespace Avalonia.X11.Clipboard;
+namespace Avalonia.X11.Selections.Clipboard;
 
 /// <summary>
 /// Implementation of <see cref="IAsyncDataTransfer"/> for the X11 clipboard.
@@ -19,16 +19,12 @@ internal sealed class ClipboardDataTransfer(
     IAsyncDataTransferItem[] items)
     : PlatformAsyncDataTransfer
 {
-    private readonly ClipboardDataReader _reader = reader;
-    private readonly DataFormat[] _formats = formats;
-    private readonly IAsyncDataTransferItem[] _items = items;
-
     protected override DataFormat[] ProvideFormats()
-        => _formats;
+        => formats;
 
     protected override IAsyncDataTransferItem[] ProvideItems()
-        => _items;
+        => items;
 
     public override void Dispose()
-        => _reader.Dispose();
+        => reader.Dispose();
 }
diff --git a/src/Avalonia.X11/Clipboard/ClipboardDataTransferItem.cs b/src/Avalonia.X11/Selections/Clipboard/ClipboardDataTransferItem.cs
similarity index 73%
rename from src/Avalonia.X11/Clipboard/ClipboardDataTransferItem.cs
rename to src/Avalonia.X11/Selections/Clipboard/ClipboardDataTransferItem.cs
index 1b2fcbf5a4..a9c6bb1b39 100644
--- a/src/Avalonia.X11/Clipboard/ClipboardDataTransferItem.cs
+++ b/src/Avalonia.X11/Selections/Clipboard/ClipboardDataTransferItem.cs
@@ -2,7 +2,7 @@ using System.Threading.Tasks;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 
-namespace Avalonia.X11.Clipboard;
+namespace Avalonia.X11.Selections.Clipboard;
 
 /// <summary>
 /// Implementation of <see cref="IAsyncDataTransferItem"/> for the X11 clipboard.
@@ -12,12 +12,9 @@ namespace Avalonia.X11.Clipboard;
 internal sealed class ClipboardDataTransferItem(ClipboardDataReader reader, DataFormat[] formats)
     : PlatformAsyncDataTransferItem
 {
-    private readonly ClipboardDataReader _reader = reader;
-    private readonly DataFormat[] _formats = formats;
-
     protected override DataFormat[] ProvideFormats()
-        => _formats;
+        => formats;
 
     protected override Task<object?> TryGetRawCoreAsync(DataFormat format)
-        => _reader.TryGetAsync(format);
+        => reader.TryGetAsync(format);
 }
diff --git a/src/Avalonia.X11/Selections/Clipboard/ClipboardReadSessionFactory.cs b/src/Avalonia.X11/Selections/Clipboard/ClipboardReadSessionFactory.cs
new file mode 100644
index 0000000000..9233b87c3a
--- /dev/null
+++ b/src/Avalonia.X11/Selections/Clipboard/ClipboardReadSessionFactory.cs
@@ -0,0 +1,20 @@
+using System;
+using static Avalonia.X11.XLib;
+
+namespace Avalonia.X11.Selections.Clipboard;
+
+internal static class ClipboardReadSessionFactory
+{
+    public static SelectionReadSession CreateSession(AvaloniaX11Platform platform)
+    {
+        var window = new EventStreamWindow(platform);
+        XSelectInput(platform.Display, window.Handle, new IntPtr((int)XEventMask.PropertyChangeMask));
+
+        return new SelectionReadSession(
+            platform.Display,
+            window.Handle,
+            platform.Info.Atoms.CLIPBOARD,
+            window,
+            platform.Info.Atoms);
+    }
+}
diff --git a/src/Avalonia.X11/Clipboard/EventStreamWindow.cs b/src/Avalonia.X11/Selections/Clipboard/EventStreamWindow.cs
similarity index 87%
rename from src/Avalonia.X11/Clipboard/EventStreamWindow.cs
rename to src/Avalonia.X11/Selections/Clipboard/EventStreamWindow.cs
index 1c9edbde49..42729de647 100644
--- a/src/Avalonia.X11/Clipboard/EventStreamWindow.cs
+++ b/src/Avalonia.X11/Selections/Clipboard/EventStreamWindow.cs
@@ -5,9 +5,9 @@ using System.Linq;
 using System.Threading.Tasks;
 using Avalonia.Threading;
 
-namespace Avalonia.X11.Clipboard;
+namespace Avalonia.X11.Selections.Clipboard;
 
-internal class EventStreamWindow : IDisposable
+internal sealed class EventStreamWindow : IXEventWaiter
 {
     private readonly AvaloniaX11Platform _platform;
     private IntPtr _handle;
@@ -27,7 +27,7 @@ internal class EventStreamWindow : IDisposable
         {
             _isForeign = true;
             _handle = foreignWindow.Value;
-            _platform.Windows[_handle] = OnEvent;
+            _platform.Windows[_handle] = new X11WindowInfo(OnEvent, null);
         }
         else
             _handle = XLib.CreateEventWindow(platform, OnEvent);
@@ -73,22 +73,15 @@ internal class EventStreamWindow : IDisposable
         }
     }
 
-    public Task<XEvent?> WaitForEventAsync(Func<XEvent, bool> predicate, TimeSpan? timeout = null)
+    public Task<XEvent?> WaitForEventAsync(Func<XEvent, bool> predicate, TimeSpan timeout)
     {
-        timeout ??= TimeSpan.FromSeconds(5);
-        
-        if (timeout < TimeSpan.Zero)
-            throw new TimeoutException();
-        if(timeout > TimeSpan.FromDays(1))
-            throw new ArgumentOutOfRangeException(nameof(timeout));
-        
         var tcs = new TaskCompletionSource<XEvent?>();
-        _addedListeners.Add((predicate, tcs, _time.Elapsed + timeout.Value));
+        _addedListeners.Add((predicate, tcs, _time.Elapsed + timeout));
 
         _timeoutTimer.Start();
         return tcs.Task;
     }
-    
+
     public void Dispose()
     {
         _timeoutTimer.Stop();
diff --git a/src/Avalonia.X11/Selections/Clipboard/X11ClipboardImpl.cs b/src/Avalonia.X11/Selections/Clipboard/X11ClipboardImpl.cs
new file mode 100644
index 0000000000..a2503ef893
--- /dev/null
+++ b/src/Avalonia.X11/Selections/Clipboard/X11ClipboardImpl.cs
@@ -0,0 +1,140 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using static Avalonia.X11.XLib;
+
+namespace Avalonia.X11.Selections.Clipboard;
+
+internal sealed class X11ClipboardImpl : SelectionDataProvider, IOwnedClipboardImpl
+{
+    private TaskCompletionSource? _storeAtomTcs;
+    private IntPtr _handle;
+
+    public X11ClipboardImpl(AvaloniaX11Platform platform)
+        : base(platform, platform.Info.Atoms.CLIPBOARD)
+    {
+        _handle = CreateEventWindow(platform, OnEvent);
+    }
+
+    private void OnEvent(ref XEvent evt)
+    {
+        if (evt.type == XEventName.SelectionClear)
+        {
+            // We might have already regained the clipboard ownership by the time a SelectionClear message arrives.
+            if (GetOwner() != _handle)
+                DataTransfer = null;
+
+            _storeAtomTcs?.TrySetResult();
+        }
+
+        else if (evt.type == XEventName.SelectionNotify)
+        {
+            var atoms = Platform.Info.Atoms;
+
+            if (evt.SelectionEvent.selection == atoms.CLIPBOARD_MANAGER &&
+                evt.SelectionEvent.target == atoms.SAVE_TARGETS)
+            {
+                _storeAtomTcs?.TrySetResult();
+            }
+        }
+
+        else if (evt.type == XEventName.SelectionRequest)
+            OnSelectionRequest(in evt.SelectionRequestEvent);
+    }
+
+    private SelectionReadSession OpenReadSession()
+        => ClipboardReadSessionFactory.CreateSession(Platform);
+
+    private Task StoreAtomsInClipboardManager(IAsyncDataTransfer dataTransfer)
+    {
+        var atoms = Platform.Info.Atoms;
+
+        var clipboardManager = XGetSelectionOwner(Platform.Display, atoms.CLIPBOARD_MANAGER);
+        if (clipboardManager == IntPtr.Zero)
+            return Task.CompletedTask;
+
+        // Skip storing atoms if the data object contains any non-trivial formats
+        if (dataTransfer.Formats.Any(f => !DataFormat.Text.Equals(f)))
+            return Task.CompletedTask;
+
+        return StoreTextCoreAsync();
+
+        async Task StoreTextCoreAsync()
+        {
+            // Skip storing atoms if the trivial formats are too big
+            var text = await dataTransfer.TryGetTextAsync();
+            if (text is null || text.Length * 2 > 64 * 1024)
+                return;
+
+            if (_storeAtomTcs is null || _storeAtomTcs.Task.IsCompleted)
+                _storeAtomTcs = new TaskCompletionSource();
+
+            var atomValues = ConvertDataTransfer(dataTransfer);
+
+            XChangeProperty(Platform.Display, _handle, atoms.AVALONIA_SAVE_TARGETS_PROPERTY_ATOM, atoms.ATOM, 32,
+                PropertyMode.Replace, atomValues, atomValues.Length);
+
+            XConvertSelection(Platform.Display, atoms.CLIPBOARD_MANAGER, atoms.SAVE_TARGETS,
+                atoms.AVALONIA_SAVE_TARGETS_PROPERTY_ATOM, _handle, 0);
+
+            await _storeAtomTcs.Task;
+        }
+    }
+
+    public Task ClearAsync()
+    {
+        DataTransfer = null;
+        SetOwner(0);
+        return Task.CompletedTask;
+    }
+
+    public async Task<IAsyncDataTransfer?> TryGetDataAsync()
+    {
+        var owner = GetOwner();
+        if (owner == 0)
+            return null;
+
+        if (owner == _handle && DataTransfer is { } storedDataTransfer)
+            return storedDataTransfer;
+
+        // Get the formats while we're in an async method, since IAsyncDataTransfer.GetFormats() is synchronous.
+        var (dataFormats, textFormatAtoms) = await GetDataFormatsCoreAsync().ConfigureAwait(false);
+        if (dataFormats.Length == 0)
+            return null;
+
+        // Get the items while we're in an async method. This does not get values, except for DataFormat.File.
+        var reader = new ClipboardDataReader(Platform, textFormatAtoms, dataFormats, owner);
+        var items = await reader.CreateItemsAsync();
+        return new ClipboardDataTransfer(reader, dataFormats, items);
+    }
+
+    private async Task<(DataFormat[] DataFormats, IntPtr[] TextFormatAtoms)> GetDataFormatsCoreAsync()
+    {
+        using var session = OpenReadSession();
+
+        var formatAtoms = await session.SendFormatRequest(0) ?? [];
+        return DataFormatHelper.ToDataFormats(formatAtoms, Platform.Info.Atoms);
+    }
+
+    public Task SetDataAsync(IAsyncDataTransfer dataTransfer)
+    {
+        DataTransfer = dataTransfer;
+        SetOwner(_handle);
+        return StoreAtomsInClipboardManager(dataTransfer);
+    }
+
+    public Task<bool> IsCurrentOwnerAsync()
+        => Task.FromResult(GetOwner() == _handle);
+
+    public override void Dispose()
+    {
+        if (_handle == 0)
+            return;
+
+        Platform.Windows.Remove(_handle);
+        XDestroyWindow(Platform.Display, _handle);
+        _handle = 0;
+    }
+}
diff --git a/src/Avalonia.X11/Selections/DataFormatHelper.cs b/src/Avalonia.X11/Selections/DataFormatHelper.cs
new file mode 100644
index 0000000000..9885f4093f
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DataFormatHelper.cs
@@ -0,0 +1,177 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Avalonia.Input;
+
+namespace Avalonia.X11.Selections;
+
+internal static class DataFormatHelper
+{
+    private const string AppPrefix = "application/avn-fmt.";
+
+    public const string MimeTypeTextUriList = "text/uri-list";
+    public const string MimeTypePngFormat = "image/png";
+    public const string MimeTypeJpegFormat = "image/jpeg";
+    public const string MimeTypeTextPlain = "text/plain";
+    public const string MimeTypeTextPlainUtf8 = "text/plain;charset=utf-8";
+
+    public static DataFormat? ToDataFormat(IntPtr formatAtom, X11Atoms atoms)
+    {
+        if (formatAtom == IntPtr.Zero)
+            return null;
+
+        if (atoms.TextFormats.Contains(formatAtom))
+            return DataFormat.Text;
+
+        if (formatAtom == atoms.MULTIPLE ||
+            formatAtom == atoms.TARGETS ||
+            formatAtom == atoms.SAVE_TARGETS)
+        {
+            return null;
+        }
+
+        if (atoms.GetAtomName(formatAtom) is { } atomName)
+        {
+            return atomName == MimeTypeTextUriList ?
+                DataFormat.File : DataFormat.FromSystemName<byte[]>(atomName, AppPrefix);
+        }
+
+        return null;
+    }
+
+    public static (DataFormat[] DataFormats, IntPtr[] TextFormatAtoms) ToDataFormats(IntPtr[] formatAtoms, X11Atoms atoms)
+    {
+        if (formatAtoms.Length == 0)
+            return ([], []);
+
+        var formats = new List<DataFormat>(formatAtoms.Length);
+        List<IntPtr>? textFormatAtoms = null;
+
+        var hasImage = false;
+
+        foreach (var formatAtom in formatAtoms)
+        {
+            if (ToDataFormat(formatAtom, atoms) is not { } format)
+                continue;
+
+            if (DataFormat.Text.Equals(format))
+            {
+                if (textFormatAtoms is null)
+                {
+                    formats.Add(format);
+                    textFormatAtoms = [];
+                }
+                textFormatAtoms.Add(formatAtom);
+            }
+            else
+            {
+                formats.Add(format);
+
+                if(!hasImage)
+                {
+                    if (format.Identifier is MimeTypeJpegFormat or MimeTypePngFormat)
+                        hasImage = true;
+                }
+            }
+        }
+
+        if (hasImage)
+            formats.Add(DataFormat.Bitmap);
+
+        return (formats.ToArray(), textFormatAtoms?.ToArray() ?? []);
+    }
+
+    public static IntPtr ToAtom(DataFormat format, IntPtr[] textFormatAtoms, X11Atoms atoms, DataFormat[] dataFormats)
+    {
+        if (DataFormat.Text.Equals(format))
+            return GetPreferredStringFormatAtom(textFormatAtoms, atoms);
+
+        if (DataFormat.File.Equals(format))
+            return atoms.GetAtom(MimeTypeTextUriList);
+
+        if (DataFormat.Bitmap.Equals(format))
+        {
+            DataFormat? pngFormat = null, jpegFormat = null;
+            foreach (var imageFormat in dataFormats)
+            {
+                if (imageFormat.Identifier is MimeTypePngFormat)
+                    pngFormat = imageFormat;
+                else if (imageFormat.Identifier is MimeTypeJpegFormat)
+                    jpegFormat = imageFormat;
+
+                if (pngFormat != null && jpegFormat != null)
+                    break;
+            }
+
+            var preferredFormat = pngFormat ?? jpegFormat;
+
+            if (preferredFormat != null)
+                return atoms.GetAtom(preferredFormat.Identifier);
+            else
+                return IntPtr.Zero;
+        }
+
+        var systemName = format.ToSystemName(AppPrefix);
+        return atoms.GetAtom(systemName);
+    }
+
+    public static IntPtr[] ToAtoms(DataFormat format, X11Atoms atoms)
+    {
+        if (DataFormat.Text.Equals(format))
+            return atoms.TextFormats;
+
+        if (DataFormat.File.Equals(format))
+            return [atoms.GetAtom(MimeTypeTextUriList)];
+
+        if (DataFormat.Bitmap.Equals(format))
+            return [atoms.GetAtom(MimeTypePngFormat)];
+
+        var systemName = format.ToSystemName(AppPrefix);
+        return [atoms.GetAtom(systemName)];
+    }
+
+    public static IntPtr[] ToAtoms(IReadOnlyList<DataFormat> formats, X11Atoms atoms)
+    {
+        var atomValues = new List<IntPtr>(formats.Count);
+
+        foreach (var format in formats)
+        {
+            if (format.Kind == DataFormatKind.InProcess)
+                continue;
+
+            foreach (var atom in ToAtoms(format, atoms))
+                atomValues.Add(atom);
+        }
+
+        return atomValues.ToArray();
+    }
+
+    private static IntPtr GetPreferredStringFormatAtom(IntPtr[] textFormatAtoms, X11Atoms atoms)
+    {
+        foreach (var preferredFormat in atoms.TextFormats)
+        {
+            if (Array.IndexOf(textFormatAtoms, preferredFormat) >= 0)
+                return preferredFormat;
+        }
+
+        return atoms.UTF8_STRING;
+    }
+
+    public static Encoding? TryGetStringEncoding(IntPtr formatAtom, X11Atoms atoms)
+    {
+        if (formatAtom == atoms.UTF16_STRING)
+           return Encoding.Unicode;
+
+        if (formatAtom == atoms.UTF8_STRING ||
+            formatAtom == atoms.GetAtom(MimeTypeTextPlain) ||
+            formatAtom == atoms.GetAtom(MimeTypeTextPlainUtf8))
+        {
+            return Encoding.UTF8;
+        }
+
+        if (formatAtom == atoms.STRING)
+            return Encoding.ASCII;
+
+        return null;
+    }
+}
diff --git a/src/Avalonia.X11/Selections/DragDrop/DragDropDataProvider.cs b/src/Avalonia.X11/Selections/DragDrop/DragDropDataProvider.cs
new file mode 100644
index 0000000000..c8727f0c87
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DragDrop/DragDropDataProvider.cs
@@ -0,0 +1,30 @@
+using System;
+using Avalonia.Input;
+
+namespace Avalonia.X11.Selections.DragDrop;
+
+internal sealed class DragDropDataProvider : SelectionDataProvider
+{
+    public Action? Activity { get; set; }
+
+    public DragDropDataProvider(AvaloniaX11Platform platform, IAsyncDataTransfer dataTransfer)
+        : base(platform, platform.Info.Atoms.XdndSelection)
+        => DataTransfer = dataTransfer;
+
+    public new IntPtr GetOwner()
+        => base.GetOwner();
+
+    public new void SetOwner(IntPtr window)
+        => base.SetOwner(window);
+
+    protected override void OnActivity()
+        => Activity?.Invoke();
+
+    public override void Dispose()
+    {
+        Activity = null;
+
+        DataTransfer?.Dispose();
+        DataTransfer = null;
+    }
+}
diff --git a/src/Avalonia.X11/Selections/DragDrop/DragDropDataReader.cs b/src/Avalonia.X11/Selections/DragDrop/DragDropDataReader.cs
new file mode 100644
index 0000000000..379851751a
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DragDrop/DragDropDataReader.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Diagnostics;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+
+namespace Avalonia.X11.Selections.DragDrop;
+
+/// <summary>
+/// An object used to read values, converted to the correct format, from a Xdnd selection.
+/// </summary>
+internal sealed class DragDropDataReader(
+    X11Atoms atoms,
+    IntPtr[] textFormatAtoms,
+    DataFormat[] dataFormats,
+    IntPtr display,
+    IntPtr targetWindow)
+    : SelectionDataReader<PlatformDataTransferItem>(atoms, textFormatAtoms, dataFormats)
+{
+    protected override SelectionReadSession CreateReadSession()
+    {
+        var eventWaiter = new SynchronousXEventWaiter(display);
+        return new SelectionReadSession(display, targetWindow, Atoms.XdndSelection, eventWaiter, Atoms);
+    }
+
+    protected override PlatformDataTransferItem CreateSingleItem(DataFormat[] nonFileFormats)
+        => new DragDropDataTransferItem(this, nonFileFormats);
+
+    public PlatformDataTransferItem[] CreateItems()
+    {
+        // Note: this doesn't cause any deadlock, CreateItemsAsync() will always complete synchronously
+        // thanks to the SynchronousXEventWaiter used in the SelectionReadSession.
+        var task = CreateItemsAsync();
+        Debug.Assert(task.IsCompleted);
+        return task.GetAwaiter().GetResult();
+    }
+
+    public object? TryGet(DataFormat format)
+    {
+        // Note: this doesn't cause any deadlock, TryGetAsync() will always complete synchronously
+        // thanks to the SynchronousXEventWaiter used in the SelectionReadSession.
+        var task = TryGetAsync(format);
+        Debug.Assert(task.IsCompleted);
+        return task.GetAwaiter().GetResult();
+    }
+
+    public override void Dispose()
+    {
+    }
+}
diff --git a/src/Avalonia.X11/Selections/DragDrop/DragDropDataTransfer.cs b/src/Avalonia.X11/Selections/DragDrop/DragDropDataTransfer.cs
new file mode 100644
index 0000000000..b1dc030800
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DragDrop/DragDropDataTransfer.cs
@@ -0,0 +1,40 @@
+using System;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+
+namespace Avalonia.X11.Selections.DragDrop;
+
+/// <summary>
+/// Implementation of <see cref="IDataTransfer"/> for data being dragged into an Avalonia window via Xdnd.
+/// </summary>
+internal sealed class DragDropDataTransfer(
+    DragDropDataReader reader,
+    DataFormat[] dataFormats,
+    IntPtr sourceWindow,
+    IntPtr targetWindow,
+    IInputRoot inputRoot)
+    : PlatformDataTransfer
+{
+    public IntPtr SourceWindow { get; } = sourceWindow;
+
+    public IntPtr TargetWindow { get; } = targetWindow;
+
+    public IInputRoot InputRoot { get; } = inputRoot;
+
+    public Point? LastPosition { get; set; }
+
+    public IntPtr LastTimestamp { get; set; }
+
+    public DragDropEffects ResultEffects { get; set; } = DragDropEffects.None;
+
+    public bool Dropped { get; set; }
+
+    protected override DataFormat[] ProvideFormats()
+        => dataFormats;
+
+    protected override PlatformDataTransferItem[] ProvideItems()
+        => reader.CreateItems();
+
+    public override void Dispose()
+        => reader.Dispose();
+}
diff --git a/src/Avalonia.X11/Selections/DragDrop/DragDropDataTransferItem.cs b/src/Avalonia.X11/Selections/DragDrop/DragDropDataTransferItem.cs
new file mode 100644
index 0000000000..b6c87bf6dc
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DragDrop/DragDropDataTransferItem.cs
@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+
+namespace Avalonia.X11.Selections.DragDrop;
+
+/// <summary>
+/// Implementation of <see cref="IAsyncDataTransferItem"/> for Xdnd.
+/// </summary>
+/// <param name="reader">The object used to read values.</param>
+/// <param name="formats">The formats.</param>
+internal sealed class DragDropDataTransferItem(DragDropDataReader reader, DataFormat[] formats)
+    : PlatformDataTransferItem
+{
+    private Dictionary<DataFormat, object?>? _cachedValues;
+
+    protected override DataFormat[] ProvideFormats()
+        => formats;
+
+    protected override object? TryGetRawCore(DataFormat format)
+    {
+        if (_cachedValues is null || !_cachedValues.TryGetValue(format, out var value))
+        {
+            value = reader.TryGet(format);
+            _cachedValues ??= [];
+            _cachedValues[format] = value;
+        }
+
+        return value;
+    }
+}
diff --git a/src/Avalonia.X11/Selections/DragDrop/DragDropTimeoutManager.cs b/src/Avalonia.X11/Selections/DragDrop/DragDropTimeoutManager.cs
new file mode 100644
index 0000000000..d25564a00b
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DragDrop/DragDropTimeoutManager.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Threading;
+
+namespace Avalonia.X11.Selections.DragDrop;
+
+internal sealed class DragDropTimeoutManager : IDisposable
+{
+    private readonly TimeSpan _timeout;
+    private readonly Timer _timer;
+
+    public DragDropTimeoutManager(TimeSpan timeout, Action onTimeout)
+    {
+        _timeout = timeout;
+
+        _timer = new Timer(
+            static state => ((Action)state!)(),
+            onTimeout,
+            Timeout.InfiniteTimeSpan,
+            Timeout.InfiniteTimeSpan);
+    }
+
+    public void Stop()
+        => ChangeTimer(Timeout.InfiniteTimeSpan);
+
+    public void Restart()
+        => ChangeTimer(_timeout);
+
+    private void ChangeTimer(TimeSpan dueTime)
+    {
+        try
+        {
+            _timer.Change(dueTime, Timeout.InfiniteTimeSpan);
+        }
+        catch (ObjectDisposedException)
+        {
+        }
+    }
+
+    public void Dispose()
+        => _timer.Dispose();
+}
diff --git a/src/Avalonia.X11/Selections/DragDrop/IXdndWindow.cs b/src/Avalonia.X11/Selections/DragDrop/IXdndWindow.cs
new file mode 100644
index 0000000000..32a2e130fe
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DragDrop/IXdndWindow.cs
@@ -0,0 +1,13 @@
+using System;
+using Avalonia.Input;
+
+namespace Avalonia.X11.Selections.DragDrop;
+
+internal interface IXdndWindow
+{
+    IntPtr Handle { get; }
+
+    IInputRoot? InputRoot { get; }
+
+    Point PointToClient(PixelPoint point);
+}
diff --git a/src/Avalonia.X11/Selections/DragDrop/SynchronousXEventWaiter.cs b/src/Avalonia.X11/Selections/DragDrop/SynchronousXEventWaiter.cs
new file mode 100644
index 0000000000..9234207062
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DragDrop/SynchronousXEventWaiter.cs
@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+using static Avalonia.X11.XLib;
+
+namespace Avalonia.X11.Selections.DragDrop;
+
+/// <summary>
+/// An implementation of <see cref="IXEventWaiter"/> that waits for an event synchronously by using its own event loop.
+/// Unprocessed events are put back onto the main queue after the wait.
+/// </summary>
+internal sealed partial class SynchronousXEventWaiter(IntPtr display) : IXEventWaiter
+{
+    private const short POLLIN = 0x0001;
+
+    public XEvent? WaitForEvent(Func<XEvent, bool> predicate, TimeSpan timeout)
+    {
+        var startingTimestamp = Stopwatch.GetTimestamp();
+        TimeSpan elapsed;
+        List<XEvent>? stashedEvents = null;
+        var fd = 0;
+
+        try {
+            while (true)
+            {
+                if (!CheckTimeout())
+                    return null;
+
+                // First, wait until there's some event in the queue
+                while (XPending(display) == 0)
+                {
+                    if (fd == 0)
+                        fd = XConnectionNumber(display);
+
+                    if (!CheckTimeout())
+                        return null;
+
+                    var remainingTimeout = timeout - elapsed;
+
+                    var pollfd = new PollFd
+                    {
+                        fd = fd,
+                        events = POLLIN
+                    };
+
+                    unsafe
+                    {
+                        if (poll(&pollfd, 1, (int)remainingTimeout.TotalMilliseconds) != 1)
+                            return null;
+                    }
+                }
+
+                if (!CheckTimeout())
+                    return null;
+
+                // Second, check if there's an event we're interested in.
+                // Use XNextEvent and stash the unrelated events, then put them back onto the queue.
+                // We can't use XIfEvent because it could block indefinitely.
+                // We can't use XCheckIfEvent either: by leaving the event in the queue, the next poll()
+                // returns immediately, eating CPU, and we don't want to add arbitrary thread sleeps.
+                XNextEvent(display, out var evt);
+
+                if (evt.type == XEventName.GenericEvent)
+                {
+                    unsafe
+                    {
+                        XGetEventData(display, &evt.GenericEventCookie);
+                    }
+                }
+
+                if (predicate(evt))
+                    return evt;
+
+                stashedEvents ??= [];
+                stashedEvents.Add(evt);
+            }
+        }
+        finally
+        {
+            if (stashedEvents is not null)
+            {
+                foreach (var evt in stashedEvents)
+                {
+                    XPutBackEvent(display, evt);
+
+                    if (evt.type == XEventName.GenericEvent)
+                    {
+                        unsafe
+                        {
+                            if (evt.GenericEventCookie.data != null)
+                                XFreeEventData(display, &evt.GenericEventCookie);
+                        }
+                    }
+                }
+            }
+        }
+
+        bool CheckTimeout()
+        {
+            elapsed = Stopwatch.GetElapsedTime(startingTimestamp);
+            return elapsed < timeout;
+        }
+    }
+
+    Task<XEvent?> IXEventWaiter.WaitForEventAsync(Func<XEvent, bool> predicate, TimeSpan timeout)
+        => Task.FromResult(WaitForEvent(predicate, timeout));
+
+    void IDisposable.Dispose()
+    {
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct PollFd
+    {
+        public int fd;
+        public short events;
+        public short revents;
+    }
+
+    [LibraryImport("libc", SetLastError = true)]
+    private static unsafe partial int poll(PollFd* fds, nint nfds, int timeout);
+}
diff --git a/src/Avalonia.X11/Selections/DragDrop/X11DragSource.cs b/src/Avalonia.X11/Selections/DragDrop/X11DragSource.cs
new file mode 100644
index 0000000000..b5f2034b67
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DragDrop/X11DragSource.cs
@@ -0,0 +1,766 @@
+using System;
+using System.Diagnostics;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using Avalonia.Input.Raw;
+using Avalonia.Logging;
+using Avalonia.Platform;
+using Avalonia.Threading;
+using static Avalonia.X11.Selections.DragDrop.XdndConstants;
+using static Avalonia.X11.XLib;
+
+namespace Avalonia.X11.Selections.DragDrop;
+
+/// <summary>
+/// Implementation of <see cref="IPlatformDragSource"/> for X11 using XDND.
+/// Specs: https://www.freedesktop.org/wiki/Specifications/XDND/
+/// </summary>
+internal sealed class X11DragSource(AvaloniaX11Platform platform) : IPlatformDragSource
+{
+    public async Task<DragDropEffects> DoDragDropAsync(
+        PointerPressedEventArgs triggerEvent,
+        IDataTransfer dataTransfer,
+        DragDropEffects allowedEffects)
+    {
+        Dispatcher.UIThread.VerifyAccess();
+
+        if (TopLevel.GetTopLevel(triggerEvent.Source as Visual)?.PlatformImpl is not IXdndWindow window)
+            throw new ArgumentOutOfRangeException(nameof(triggerEvent), "Invalid drag source");
+
+        triggerEvent.Pointer.Capture(null);
+
+        var cursorFactory = AvaloniaLocator.Current.GetService<ICursorFactory>() as X11CursorFactory;
+
+        using var handler = new Handler(
+            platform,
+            window.Handle,
+            dataTransfer,
+            allowedEffects,
+            triggerEvent.KeyModifiers,
+            cursorFactory);
+
+        return await handler.Completion;
+    }
+
+    private sealed class Handler : X11EventDispatcher.IEventHook, IDisposable
+    {
+        private readonly AvaloniaX11Platform _platform;
+        private readonly IntPtr _sourceWindow;
+        private readonly IDataTransfer _dataTransfer;
+        private readonly DragDropEffects _allowedEffects;
+        private readonly X11CursorFactory? _cursorFactory;
+        private readonly DragDropDataProvider _dataProvider;
+        private readonly ParametrizedLogger? _logger;
+        private readonly TaskCompletionSource<DragDropEffects> _completionSource = new();
+        private readonly IntPtr[] _formatAtoms;
+        private bool _pointerGrabbed;
+        private DragDropEffects _currentEffects;
+        private TargetState _targetState;
+        private DragDropTimeoutManager? _timeoutManager;
+
+        public Handler(
+            AvaloniaX11Platform platform,
+            IntPtr sourceWindow,
+            IDataTransfer dataTransfer,
+            DragDropEffects allowedEffects,
+            KeyModifiers initialKeyModifiers,
+            X11CursorFactory? cursorFactory)
+        {
+            _platform = platform;
+            _sourceWindow = sourceWindow;
+            _dataTransfer = dataTransfer;
+            _allowedEffects = allowedEffects;
+            _cursorFactory = cursorFactory;
+            _logger = Logger.TryGet(LogEventLevel.Verbose, LogArea.X11Platform);
+            _dataProvider = new DragDropDataProvider(platform, dataTransfer.ToAsynchronous());
+
+            if (!platform.Windows.ContainsKey(sourceWindow))
+            {
+                _formatAtoms = [];
+                Complete(DragDropEffects.None);
+                return;
+            }
+
+            // Assume we have an implicit grab here.
+            _pointerGrabbed = true;
+            UpdateCurrentEffects(GetEffectiveAllowedEffects(initialKeyModifiers));
+
+            // Install our global event hook.
+            var eventDispatcher = platform.DispatcherImpl.EventDispatcher;
+            Debug.Assert(eventDispatcher.EventHook is null);
+            eventDispatcher.EventHook = this;
+
+            var atoms = _platform.Info.Atoms;
+            _formatAtoms = DataFormatHelper.ToAtoms(dataTransfer.Formats, atoms);
+            _dataProvider.SetOwner(_sourceWindow);
+
+            // Publish our formats.
+            XChangeProperty(
+                _platform.Display,
+                _sourceWindow,
+                atoms.XdndTypeList,
+                atoms.ATOM,
+                32,
+                PropertyMode.Replace,
+                _formatAtoms,
+                _formatAtoms.Length);
+        }
+
+        public Task<DragDropEffects> Completion
+            => _completionSource.Task;
+
+        private DragDropTimeoutManager TimeoutManager
+            => _timeoutManager ??= new DragDropTimeoutManager(SelectionHelper.Timeout, OnTimeout);
+
+        public bool TryHandleEvent(in XEvent evt)
+        {
+            if (evt.AnyEvent.window == _sourceWindow)
+            {
+                if (TryHandleSourceWindowEvent(evt))
+                    return true;
+            }
+
+            if (_pointerGrabbed)
+            {
+                if (TryHandleGlobalPointerEvent(evt))
+                    return true;
+            }
+
+            return false;
+        }
+
+        private bool TryHandleSourceWindowEvent(in XEvent evt)
+        {
+            switch (evt.type)
+            {
+                case XEventName.ClientMessage:
+                    ref readonly var message = ref evt.ClientMessageEvent;
+
+                    if (message.message_type == _platform.Info.Atoms.XdndStatus)
+                    {
+                        OnXdndStatus(in message);
+                        return true;
+                    }
+
+                    if (message.message_type == _platform.Info.Atoms.XdndFinished)
+                    {
+                        OnXdndFinished(in message);
+                        return true;
+                    }
+
+                    return false;
+
+                case XEventName.SelectionRequest:
+                    _dataProvider.OnSelectionRequest(in evt.SelectionRequestEvent);
+                    return true;
+
+                default:
+                    return false;
+            }
+        }
+
+        private bool TryHandleGlobalPointerEvent(in XEvent evt)
+        {
+            switch (evt.type)
+            {
+                case XEventName.MotionNotify:
+                    OnPointerMoved(
+                        new PixelPoint(evt.MotionEvent.x_root, evt.MotionEvent.y_root),
+                        evt.MotionEvent.time,
+                        evt.MotionEvent.state.ToRawInputModifiers());
+                    return true;
+
+                case XEventName.ButtonPress:
+                    return true;
+
+                case XEventName.ButtonRelease:
+                    OnPointerReleased(
+                        new PixelPoint(evt.ButtonEvent.x_root, evt.ButtonEvent.y_root),
+                        evt.ButtonEvent.time,
+                        evt.ButtonEvent.state.ToRawInputModifiers());
+                    return true;
+
+                case XEventName.KeyPress or XEventName.KeyRelease:
+                    OnKey(in evt.KeyEvent);
+                    return true;
+
+                case XEventName.GenericEvent:
+                    if (_platform.XI2 is null || _platform.Info.XInputOpcode != evt.GenericEventCookie.extension)
+                        return false;
+
+                    unsafe
+                    {
+                        var xiEvent = (XIEvent*)evt.GenericEventCookie.data;
+
+                        switch (xiEvent->evtype)
+                        {
+                            case XiEventType.XI_Motion:
+                            case XiEventType.XI_TouchUpdate:
+                            {
+                                var deviceEvent = (XIDeviceEvent*)xiEvent;
+                                var modifiers = ((XModifierMask)deviceEvent->mods.Effective).ToRawInputModifiers();
+                                OnPointerMoved(
+                                    new PixelPoint((int)deviceEvent->root_x, (int)deviceEvent->root_y),
+                                    deviceEvent->time,
+                                    modifiers);
+                                return true;
+                            }
+
+                            case XiEventType.XI_ButtonPress:
+                            case XiEventType.XI_TouchBegin:
+                                return true;
+
+                            case XiEventType.XI_ButtonRelease:
+                            case XiEventType.XI_TouchEnd:
+                            {
+                                var deviceEvent = (XIDeviceEvent*)xiEvent;
+                                var modifiers = ((XModifierMask)deviceEvent->mods.Effective).ToRawInputModifiers();
+                                OnPointerReleased(
+                                    new PixelPoint((int)deviceEvent->root_x, (int)deviceEvent->root_y),
+                                    deviceEvent->time,
+                                    modifiers);
+                                return true;
+                            }
+
+                            default:
+                                return false;
+                        }
+                    }
+
+                default:
+                    return false;
+            }
+        }
+
+        private void OnPointerMoved(PixelPoint rootPosition, IntPtr timestamp, RawInputModifiers modifiers)
+        {
+            // Drop pending, ignore any queued position change.
+            if (_targetState.PendingDrop is not null)
+                return;
+
+            var target = FindXdndTarget(rootPosition);
+
+            // Handle new target.
+            if (_targetState.Target != target)
+            {
+                _logger?.Log(
+                    this,
+                    "Pointer moved from window {OldTarget} to window {NewTarget}.",
+                    _targetState.Target?.TargetWindow,
+                    target?.TargetWindow);
+
+                if (_targetState.Target is { } lastTarget)
+                {
+                    if (lastTarget.InProcessWindow is { } window)
+                        ProcessRawDragEvent(window, RawDragEventType.DragLeave, rootPosition, modifiers);
+                    else
+                        SendXdndLeave(lastTarget);
+                }
+
+                _targetState = new TargetState(target);
+
+                var effectiveAllowedEffects = GetEffectiveAllowedEffects(modifiers.ToKeyModifiers());
+                UpdateCurrentEffects(effectiveAllowedEffects);
+
+                if (target is { } newTarget)
+                {
+                    if (newTarget.InProcessWindow is { } window)
+                    {
+                        var effects = ProcessRawDragEvent(window, RawDragEventType.DragEnter, rootPosition, modifiers);
+                        _targetState.AllowsDrop = effects != DragDropEffects.None;
+                        UpdateCurrentEffects(effects);
+                    }
+                    else
+                        SendXdndEnter(newTarget);
+                }
+            }
+
+            // Update current target.
+            if (target is { } currentTarget)
+                UpdateTargetPosition(currentTarget, rootPosition, modifiers, timestamp);
+        }
+
+        private void UpdateTargetPosition(
+            XdndTargetInfo target,
+            PixelPoint rootPosition,
+            RawInputModifiers modifiers,
+            IntPtr timestamp)
+        {
+            if (target.InProcessWindow is { } window)
+            {
+                var effects = ProcessRawDragEvent(window, RawDragEventType.DragOver, rootPosition, modifiers);
+                _targetState.AllowsDrop = effects != DragDropEffects.None;
+                UpdateCurrentEffects(effects);
+            }
+            else
+            {
+                var effectiveAllowedEffects = GetEffectiveAllowedEffects(modifiers.ToKeyModifiers());
+                var action = XdndActionHelper.EffectsToAction(effectiveAllowedEffects, _platform.Info.Atoms);
+                var positionRequest = new PositionRequest(rootPosition, timestamp, action);
+
+                if (_targetState.IsWaitingForStatus)
+                {
+                    // We already sent a position previously and are waiting for a response. Don't flood.
+                    _targetState.PendingPosition = positionRequest;
+
+                    _logger?.Log(
+                        this,
+                        "Pointer moved to point {Position} on window {Window} while waiting for XdndStatus. XdndPosition will be sent later.",
+                        rootPosition,
+                        target.TargetWindow);
+                }
+                else
+                {
+                    SendPositionRequest(positionRequest, target);
+                }
+            }
+        }
+
+        private void OnKey(in XKeyEvent key)
+        {
+            if (_targetState.Target is not { } target || _targetState.PendingDrop is not null)
+                return;
+
+            var keySym = XLookupKeysym(in key, 0);
+
+            // If Shift/Ctrl/Alt are pressed/released, effective effects might change: update the target.
+            var interestingModifiers = keySym switch
+            {
+                XKeySym.XK_Shift_L or XKeySym.XK_Shift_R => XModifierMask.ShiftMask,
+                XKeySym.XK_Control_L or XKeySym.XK_Control_R => XModifierMask.ControlMask,
+                XKeySym.XK_Alt_L or XKeySym.XK_Alt_R => XModifierMask.Mod1Mask,
+                _ => default
+            };
+
+            if (interestingModifiers == 0)
+                return;
+
+            var modifiers = key.state;
+            if (key.type == XEventName.KeyPress)
+                modifiers |= interestingModifiers;
+            else if (key.type == XEventName.KeyRelease)
+                modifiers &= ~interestingModifiers;
+
+            var position = new PixelPoint(key.x_root, key.y_root);
+
+            UpdateTargetPosition(target, position, modifiers.ToRawInputModifiers(), key.time);
+        }
+
+        private void OnPointerReleased(PixelPoint rootPosition, IntPtr timestamp, RawInputModifiers modifiers)
+        {
+            UngrabPointer();
+
+            if (_targetState.Target is not { } target || _targetState.PendingDrop is not null)
+            {
+                Complete(DragDropEffects.None);
+                return;
+            }
+
+            if (target.InProcessWindow is not null)
+            {
+                if (_targetState.AllowsDrop)
+                {
+                    var effects = ProcessRawDragEvent(target.InProcessWindow, RawDragEventType.Drop, rootPosition, modifiers);
+                    UpdateCurrentEffects(effects);
+                }
+                else
+                {
+                    ProcessRawDragEvent(target.InProcessWindow, RawDragEventType.DragLeave, rootPosition, modifiers);
+                    UpdateCurrentEffects(DragDropEffects.None);
+                }
+
+                _targetState = default;
+                Complete(_currentEffects);
+            }
+            else
+            {
+                var dropRequest = new DropRequest(timestamp);
+
+                if (_targetState.IsWaitingForStatus)
+                {
+                    // We're still waiting for a XdndStatus response for the last position, defer the drop.
+                    _targetState.PendingDrop = dropRequest;
+
+                    _logger?.Log(
+                        this,
+                        "Pointer released on window {Window} while waiting for XdndStatus. XdndDrop will be sent later.",
+                        target.TargetWindow);
+                }
+                else if (_targetState.AllowsDrop)
+                {
+                    SendDropRequest(dropRequest, target);
+                }
+                else
+                {
+                    _targetState = default;
+                    UpdateCurrentEffects(DragDropEffects.None);
+                    SendXdndLeave(target);
+                    Complete(DragDropEffects.None);
+                }
+            }
+        }
+
+        private void OnXdndStatus(in XClientMessageEvent message)
+        {
+            if (_targetState.Target is not { } target || message.ptr1 != target.TargetWindow)
+                return;
+
+            TimeoutManager.Stop();
+
+            var accepted = (message.ptr2 & 1) == 1;
+            var action = accepted ? message.ptr5 : 0;
+            var effects = XdndActionHelper.ActionToEffects(action, _platform.Info.Atoms);
+
+            _targetState.IsWaitingForStatus = false;
+            _targetState.AllowsDrop = action != 0;
+
+            UpdateCurrentEffects(effects & _allowedEffects);
+
+            _logger?.Log(
+                this,
+                "Received XdndStatus with action {Action} for window {Window}.",
+                _platform.Info.Atoms.GetAtomName(action),
+                target.TargetWindow);
+
+            // If we have any pending XdndPosition or XdndDrop to send, now is the time.
+            if (_targetState.PendingPosition is { } position)
+            {
+                _targetState.PendingPosition = null;
+                SendPositionRequest(position, target);
+            }
+            else if (_targetState.PendingDrop is { } drop)
+            {
+                SendDropRequest(drop, target);
+            }
+        }
+
+        private void OnXdndFinished(in XClientMessageEvent message)
+        {
+            if (_targetState.Target is not { } target || message.ptr1 != target.TargetWindow)
+                return;
+
+            _logger?.Log(this, "Received XdndFinished for window {Window}.", target.TargetWindow);
+
+            _targetState = default;
+            _dataProvider.Activity = null;
+            _timeoutManager?.Stop();
+
+            if (target.Version >= 5)
+            {
+                var accepted = (message.ptr2 & 1) == 1;
+                var action = accepted ? message.ptr3 : 0;
+                var effects = XdndActionHelper.ActionToEffects(action, _platform.Info.Atoms);
+                UpdateCurrentEffects(effects & _allowedEffects);
+            }
+
+            Complete(_currentEffects);
+        }
+
+        private XdndTargetInfo? FindXdndTarget(PixelPoint rootPosition)
+        {
+            var display = _platform.Display;
+            var rootWindow = _platform.Info.RootWindow;
+            var currentWindow = rootWindow;
+
+            while (currentWindow != 0)
+            {
+                if (TryGetXdndTargetInfo(currentWindow) is { } info)
+                    return info;
+
+                if (!XTranslateCoordinates(display, rootWindow, currentWindow, rootPosition.X, rootPosition.Y,
+                    out _, out _, out var childWindow))
+                {
+                    return null;
+                }
+
+                currentWindow = childWindow;
+            }
+
+            return null;
+        }
+
+        private XdndTargetInfo? TryGetXdndTargetInfo(IntPtr window)
+        {
+            // Special case our own windows: we don't need to go through X for them.
+            if (_platform.Windows.TryGetValue(window, out var windowInfo)
+                && windowInfo.Window is { } inProcessWindow)
+            {
+                return new XdndTargetInfo(XdndVersion, window, window, inProcessWindow);
+            }
+
+            var proxyWindow = GetXdndProxyWindow(window);
+            var messageWindow = proxyWindow != 0 ? proxyWindow : window;
+            var version = GetXdndVersion(messageWindow);
+
+            return version != 0 ? new XdndTargetInfo(version, window, messageWindow, null) : null;
+        }
+
+        private IntPtr GetXdndProxyWindow(IntPtr window)
+        {
+            var atoms = _platform.Info.Atoms;
+
+            // Spec: If this window property exists, it must be of type XA_WINDOW and must contain the ID of the proxy window
+            // that should be checked for XdndAware and that should receive all the client messages, etc.
+            var proxyWindow = XGetWindowPropertyAsIntPtr(_platform.Display, window, atoms.XdndProxy, atoms.WINDOW) ?? 0;
+            if (proxyWindow == 0)
+                return 0;
+
+            // Spec: The proxy window must have the XdndProxy property set to point to itself.
+            var proxyOnProxy = XGetWindowPropertyAsIntPtr(_platform.Display, proxyWindow, atoms.XdndProxy, atoms.WINDOW) ?? 0;
+            if (proxyOnProxy != proxyWindow)
+                return 0;
+
+            return proxyWindow;
+        }
+
+        private byte GetXdndVersion(IntPtr window)
+        {
+            var atoms = _platform.Info.Atoms;
+
+            var version = XGetWindowPropertyAsIntPtr(_platform.Display, window, atoms.XdndAware, atoms.ATOM) ?? 0;
+            if (version is < MinXdndVersion or > byte.MaxValue)
+                version = 0;
+
+            return (byte)version;
+        }
+
+        private void SendXdndEnter(XdndTargetInfo target)
+        {
+            var version = Math.Min(target.Version, XdndVersion);
+            var hasMoreFormats = _formatAtoms.Length > 3;
+
+            _logger?.Log(
+                this,
+                "Sending XdndEnter with version {Version} to window {Window}.",
+                version,
+                target.TargetWindow);
+
+            SendXdndMessage(
+                _platform.Info.Atoms.XdndEnter,
+                target.MessageWindow,
+                (version << 24) | (hasMoreFormats ? 1 : 0),
+                _formatAtoms.Length >= 1 ? _formatAtoms[0] : 0,
+                _formatAtoms.Length >= 2 ? _formatAtoms[1] : 0,
+                _formatAtoms.Length >= 3 ? _formatAtoms[2] : 0);
+        }
+
+        private void SendXdndPosition(XdndTargetInfo target, PixelPoint rootPosition, IntPtr timestamp, IntPtr action)
+        {
+            _logger?.Log(
+                this,
+                "Sending XdndPosition with action {Action} at point {Position} to window {Window}.",
+                _platform.Info.Atoms.GetAtomName(action),
+                rootPosition,
+                target.TargetWindow);
+
+            SendXdndMessage(
+                _platform.Info.Atoms.XdndPosition,
+                target.MessageWindow,
+                0,
+                (rootPosition.X << 16) | rootPosition.Y,
+                timestamp,
+                action);
+        }
+
+        private void SendXdndLeave(XdndTargetInfo target)
+        {
+            _logger?.Log(this, "Sending XdndLeave to window {Window}.", target.TargetWindow);
+
+            SendXdndMessage(_platform.Info.Atoms.XdndLeave, target.MessageWindow, 0, 0, 0, 0);
+        }
+
+        private void SendXdndDrop(XdndTargetInfo target, IntPtr timestamp)
+        {
+            _logger?.Log(this, "Sending XdndDrop to window {Window}.", target.TargetWindow);
+
+            SendXdndMessage(_platform.Info.Atoms.XdndDrop, target.MessageWindow, 0, timestamp, 0, 0);
+        }
+
+        private void SendXdndMessage(
+            IntPtr messageType,
+            IntPtr messageWindow,
+            IntPtr ptr2,
+            IntPtr ptr3,
+            IntPtr ptr4,
+            IntPtr ptr5)
+        {
+            var evt = new XEvent
+            {
+                ClientMessageEvent = new XClientMessageEvent
+                {
+                    type = XEventName.ClientMessage,
+                    display = _platform.Display,
+                    window = messageWindow,
+                    message_type = messageType,
+                    format = 32,
+                    ptr1 = _sourceWindow,
+                    ptr2 = ptr2,
+                    ptr3 = ptr3,
+                    ptr4 = ptr4,
+                    ptr5 = ptr5
+                }
+            };
+
+            XSendEvent(_platform.Display, messageWindow, false, (IntPtr)EventMask.NoEventMask, ref evt);
+            XFlush(_platform.Display);
+        }
+
+        private void SendPositionRequest(PositionRequest request, XdndTargetInfo target)
+        {
+            _targetState.IsWaitingForStatus = true;
+            TimeoutManager.Restart();
+
+            SendXdndPosition(target, request.Position, request.Timestamp, request.Action);
+        }
+
+        private void SendDropRequest(DropRequest dropRequest, XdndTargetInfo target)
+        {
+            TimeoutManager.Restart();
+            _dataProvider.Activity = TimeoutManager.Restart;
+
+            SendXdndDrop(target, dropRequest.Timestamp);
+        }
+
+        private DragDropEffects ProcessRawDragEvent(
+            X11Window targetWindow,
+            RawDragEventType eventType,
+            PixelPoint rootPosition,
+            RawInputModifiers modifiers)
+        {
+            if (targetWindow.DragDropDevice is not { } dragDropDevice)
+                return DragDropEffects.None;
+
+            var localPosition = targetWindow.PointToClient(rootPosition);
+            var effectiveAllowedEffects = GetEffectiveAllowedEffects(modifiers.ToKeyModifiers());
+
+            var dragEvent = new RawDragEvent(
+                dragDropDevice,
+                eventType,
+                targetWindow.InputRoot,
+                localPosition,
+                _dataTransfer,
+                effectiveAllowedEffects,
+                modifiers);
+
+            dragDropDevice.ProcessRawEvent(dragEvent);
+
+            return dragEvent.Effects & _allowedEffects;
+        }
+
+        private void UngrabPointer()
+        {
+            _pointerGrabbed = false;
+
+            XUngrabPointer(_platform.Display, 0);
+            XFlush(_platform.Display);
+        }
+
+        private void UpdateCurrentEffects(DragDropEffects effects)
+        {
+            if (_currentEffects == effects)
+                return;
+
+            _currentEffects = effects;
+
+            if (_pointerGrabbed)
+            {
+                XChangeActivePointerGrab(
+                    _platform.Display,
+                    EventMask.ButtonPressMask | EventMask.ButtonReleaseMask | EventMask.PointerMotionMask,
+                    GetCursor(effects),
+                    0);
+            }
+        }
+
+        private IntPtr GetCursor(DragDropEffects effects)
+        {
+            if (_cursorFactory is not null)
+            {
+                if ((effects & DragDropEffects.Copy) != 0)
+                    return _cursorFactory.GetCursorHandle(StandardCursorType.DragCopy);
+                if ((effects & DragDropEffects.Move) != 0)
+                    return _cursorFactory.GetCursorHandle(StandardCursorType.DragMove);
+                if ((effects & DragDropEffects.Link) != 0)
+                    return _cursorFactory.GetCursorHandle(StandardCursorType.DragLink);
+                return _cursorFactory.DragNoDropCursorHandle;
+            }
+
+            return _platform.Info.DefaultCursor;
+        }
+
+        private DragDropEffects GetEffectiveAllowedEffects(KeyModifiers keyModifiers)
+            => _allowedEffects & GetAllowedEffectsFromKeyModifiers(keyModifiers);
+
+        private static DragDropEffects GetAllowedEffectsFromKeyModifiers(KeyModifiers keyModifiers)
+        {
+            if ((keyModifiers & KeyModifiers.Control) != 0)
+                return DragDropEffects.Copy;
+            if ((keyModifiers & KeyModifiers.Shift) != 0)
+                return DragDropEffects.Move;
+            if ((keyModifiers & KeyModifiers.Alt) != 0)
+                return DragDropEffects.Link;
+            return DragDropEffects.Copy | DragDropEffects.Move | DragDropEffects.Link;
+        }
+
+        private void Complete(DragDropEffects resultEffects)
+            => _completionSource.TrySetResult(resultEffects);
+
+        private void OnTimeout()
+        {
+            _logger?.Log(
+                this,
+                _targetState.IsWaitingForStatus ? "Timeout waiting for XdndStatus." : "Timeout waiting for XdndFinished.");
+
+            Complete(DragDropEffects.None);
+        }
+
+        public void Dispose()
+        {
+            if (_pointerGrabbed)
+                UngrabPointer();
+
+            var eventDispatcher = _platform.DispatcherImpl.EventDispatcher;
+            if (eventDispatcher.EventHook == this)
+                eventDispatcher.EventHook = null;
+
+            _targetState = default;
+            _currentEffects = DragDropEffects.None;
+
+            _timeoutManager?.Dispose();
+
+            if (_dataProvider.GetOwner() == _sourceWindow)
+                _dataProvider.SetOwner(0);
+
+            _dataProvider.Dispose();
+        }
+
+        private readonly record struct XdndTargetInfo(
+            byte Version,
+            IntPtr TargetWindow,
+            IntPtr MessageWindow,
+            X11Window? InProcessWindow);
+
+        private readonly struct PositionRequest(PixelPoint position, IntPtr timestamp, IntPtr action)
+        {
+            public readonly PixelPoint Position = position;
+            public readonly IntPtr Timestamp = timestamp;
+            public readonly IntPtr Action = action;
+        }
+
+        private readonly struct DropRequest(IntPtr timestamp)
+        {
+            public readonly IntPtr Timestamp = timestamp;
+        }
+
+        private struct TargetState(XdndTargetInfo? target)
+        {
+            public readonly XdndTargetInfo? Target = target;
+            public bool AllowsDrop;
+            public bool IsWaitingForStatus; // XdndPosition sent, but no XdndStatus received yet
+            public PositionRequest? PendingPosition; // Position not sent via XdndPosition yet
+            public DropRequest? PendingDrop; // Drop not sent via XdndDrop yet
+        }
+    }
+}
diff --git a/src/Avalonia.X11/Selections/DragDrop/X11DropTarget.cs b/src/Avalonia.X11/Selections/DragDrop/X11DropTarget.cs
new file mode 100644
index 0000000000..26a910ec90
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DragDrop/X11DropTarget.cs
@@ -0,0 +1,204 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using static Avalonia.X11.Selections.DragDrop.XdndConstants;
+using static Avalonia.X11.XLib;
+
+namespace Avalonia.X11.Selections.DragDrop;
+
+/// <summary>
+/// Manages an XDND target for a given X11 window.
+/// Specs: https://www.freedesktop.org/wiki/Specifications/XDND/
+/// </summary>
+internal sealed class X11DropTarget
+{
+    private readonly IDragDropDevice _dragDropDevice;
+    private readonly IXdndWindow _window;
+    private readonly IntPtr _display;
+    private readonly X11Atoms _atoms;
+    private DragDropDataTransfer? _currentDrag;
+
+    public X11DropTarget(IDragDropDevice dragDropDevice, IXdndWindow window, IntPtr _display, X11Atoms atoms)
+    {
+        _dragDropDevice = dragDropDevice;
+        _window = window;
+        this._display = _display;
+        _atoms = atoms;
+
+        IntPtr version = XdndVersion;
+        XChangeProperty(_display, _window.Handle, _atoms.XdndAware, _atoms.ATOM, 32, PropertyMode.Replace, ref version, 1);
+    }
+
+    public void OnXdndEnter(in XClientMessageEvent message)
+    {
+        if (_window.InputRoot is not { } inputRoot)
+            return;
+
+        // Spec: If the version number in the XdndEnter message is higher than what the target can support,
+        // the target should ignore the source.
+        var version = (byte)((message.ptr2 >> 24) & 0xFF);
+        if (version is < MinXdndVersion or > XdndVersion)
+            return;
+
+        // If we ever receive a new XdndEnter message while a drag is in progress, it means something went wrong.
+        // In this case, assume the old drag is stale.
+        DisposeCurrentDrag();
+
+        var sourceWindow = message.ptr1;
+        var hasExtraFormats = (message.ptr2 & 1) == 1;
+
+        var formats = new HashSet<IntPtr>();
+
+        if (hasExtraFormats &&
+            XGetWindowPropertyAsIntPtrArray(_display, sourceWindow, _atoms.XdndTypeList, _atoms.ATOM) is { } formatList)
+        {
+            foreach (var format in formatList)
+            {
+                if (format != 0)
+                    formats.Add(format);
+            }
+        }
+        else
+        {
+            if (message.ptr3 != 0)
+                formats.Add(message.ptr3);
+            if (message.ptr4 != 0)
+                formats.Add(message.ptr4);
+            if (message.ptr5 != 0)
+                formats.Add(message.ptr5);
+        }
+
+        var (dataFormats, textFormats) = DataFormatHelper.ToDataFormats(formats.ToArray(), _atoms);
+        var reader = new DragDropDataReader(_atoms, textFormats, dataFormats, _display, _window.Handle);
+        _currentDrag = new DragDropDataTransfer(reader, dataFormats, sourceWindow, _window.Handle, inputRoot);
+    }
+
+    public void OnXdndPosition(in XClientMessageEvent message)
+    {
+        if (_currentDrag is not { } drag || message.ptr1 != drag.SourceWindow)
+            return;
+
+        var screenX = (ushort)((message.ptr3 >> 16) & 0xFFFF);
+        var screenY = (ushort)(message.ptr3 & 0xFFFF);
+        var position = _window.PointToClient(new PixelPoint(screenX, screenY));
+        var requestedEffects = XdndActionHelper.ActionToEffects(message.ptr5, _atoms);
+        var eventType = drag.LastPosition is null ? RawDragEventType.DragEnter : RawDragEventType.DragOver;
+        var modifiers = GetModifiers();
+
+        drag.LastPosition = position;
+        drag.LastTimestamp = message.ptr4;
+
+        var dragEvent = new RawDragEvent(
+            _dragDropDevice,
+            eventType,
+            drag.InputRoot,
+            position,
+            drag,
+            requestedEffects,
+            modifiers);
+
+        _dragDropDevice.ProcessRawEvent(dragEvent);
+
+        drag.ResultEffects = dragEvent.Effects;
+
+        var resultAction = XdndActionHelper.EffectsToAction(dragEvent.Effects, _atoms);
+        SendXdndMessage(_atoms.XdndStatus, drag, resultAction == 0 ? 0 : 1, 0, 0, resultAction);
+    }
+
+    public void OnXdndLeave(in XClientMessageEvent message)
+    {
+        if (_currentDrag is not { } drag || message.ptr1 != drag.SourceWindow)
+            return;
+
+        var modifiers = GetModifiers();
+
+        var dragLeave = new RawDragEvent(
+            _dragDropDevice,
+            RawDragEventType.DragLeave,
+            drag.InputRoot,
+            default,
+            drag,
+            DragDropEffects.None,
+            modifiers);
+
+        _dragDropDevice.ProcessRawEvent(dragLeave);
+
+        DisposeCurrentDrag();
+    }
+
+    public void OnXdndDrop(in XClientMessageEvent message)
+    {
+        if (_currentDrag is not { } drag || message.ptr1 != drag.SourceWindow)
+            return;
+
+        var modifiers = GetModifiers();
+
+        var drop = new RawDragEvent(
+            _dragDropDevice,
+            RawDragEventType.Drop,
+            drag.InputRoot,
+            drag.LastPosition ?? default,
+            drag,
+            drag.ResultEffects,
+            modifiers);
+
+        _dragDropDevice.ProcessRawEvent(drop);
+
+        drag.ResultEffects = drop.Effects;
+        drag.Dropped = true;
+
+        DisposeCurrentDrag();
+    }
+
+    private void SendXdndMessage(
+        IntPtr messageType,
+        DragDropDataTransfer drag,
+        IntPtr ptr2,
+        IntPtr ptr3,
+        IntPtr ptr4,
+        IntPtr ptr5)
+    {
+        var evt = new XEvent
+        {
+            ClientMessageEvent = new XClientMessageEvent
+            {
+                type = XEventName.ClientMessage,
+                display = _display,
+                window = drag.SourceWindow,
+                message_type = messageType,
+                format = 32,
+                ptr1 = drag.TargetWindow,
+                ptr2 = ptr2,
+                ptr3 = ptr3,
+                ptr4 = ptr4,
+                ptr5 = ptr5
+            }
+        };
+
+        XSendEvent(_display, drag.SourceWindow, false, (IntPtr)EventMask.NoEventMask, ref evt);
+        XFlush(_display);
+    }
+
+    private RawInputModifiers GetModifiers()
+        => XQueryPointer(_display, _window.Handle, out _, out _, out _, out _, out _, out _, out var mask) ?
+            mask.ToRawInputModifiers() :
+            RawInputModifiers.None;
+
+    private void DisposeCurrentDrag()
+    {
+        if (_currentDrag is not { } drag)
+            return;
+
+        _currentDrag = null;
+
+        if (drag.Dropped)
+        {
+            var resultAction = XdndActionHelper.EffectsToAction(drag.ResultEffects, _atoms);
+            SendXdndMessage(_atoms.XdndFinished, drag, resultAction == 0 ? 0 : 1, resultAction, 0, 0);
+        }
+
+        drag.Dispose();
+    }
+}
diff --git a/src/Avalonia.X11/Selections/DragDrop/XdndActionHelper.cs b/src/Avalonia.X11/Selections/DragDrop/XdndActionHelper.cs
new file mode 100644
index 0000000000..b8fbc17e36
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DragDrop/XdndActionHelper.cs
@@ -0,0 +1,29 @@
+using System;
+using Avalonia.Input;
+
+namespace Avalonia.X11.Selections.DragDrop;
+
+internal static class XdndActionHelper
+{
+    public static DragDropEffects ActionToEffects(IntPtr action, X11Atoms atoms)
+    {
+        if (action == atoms.XdndActionCopy)
+            return DragDropEffects.Copy;
+        if (action == atoms.XdndActionMove)
+            return DragDropEffects.Move;
+        if (action == atoms.XdndActionLink)
+            return DragDropEffects.Link;
+        return DragDropEffects.None;
+    }
+
+    public static IntPtr EffectsToAction(DragDropEffects effects, X11Atoms atoms)
+    {
+        if ((effects & DragDropEffects.Copy) != 0)
+            return atoms.XdndActionCopy;
+        if ((effects & DragDropEffects.Move) != 0)
+            return atoms.XdndActionMove;
+        if ((effects & DragDropEffects.Link) != 0)
+            return atoms.XdndActionLink;
+        return 0;
+    }
+}
diff --git a/src/Avalonia.X11/Selections/DragDrop/XdndConstants.cs b/src/Avalonia.X11/Selections/DragDrop/XdndConstants.cs
new file mode 100644
index 0000000000..53223b3f36
--- /dev/null
+++ b/src/Avalonia.X11/Selections/DragDrop/XdndConstants.cs
@@ -0,0 +1,8 @@
+namespace Avalonia.X11.Selections.DragDrop;
+
+internal static class XdndConstants
+{
+    // Spec: every application that supports XDND version N must also support all previous versions (3 to N-1).
+    public const byte MinXdndVersion = 3;
+    public const byte XdndVersion = 5;
+}
diff --git a/src/Avalonia.X11/Selections/IXEventWaiter.cs b/src/Avalonia.X11/Selections/IXEventWaiter.cs
new file mode 100644
index 0000000000..98398b615f
--- /dev/null
+++ b/src/Avalonia.X11/Selections/IXEventWaiter.cs
@@ -0,0 +1,9 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Avalonia.X11.Selections;
+
+internal interface IXEventWaiter : IDisposable
+{
+    Task<XEvent?> WaitForEventAsync(Func<XEvent, bool> predicate, TimeSpan timeout);
+}
diff --git a/src/Avalonia.X11/Selections/SelectionDataProvider.cs b/src/Avalonia.X11/Selections/SelectionDataProvider.cs
new file mode 100644
index 0000000000..c1a7be87fb
--- /dev/null
+++ b/src/Avalonia.X11/Selections/SelectionDataProvider.cs
@@ -0,0 +1,260 @@
+using System;
+using System.Buffers;
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+using Avalonia.Input;
+using Avalonia.Logging;
+using Avalonia.X11.Selections.Clipboard;
+using static Avalonia.X11.XLib;
+
+namespace Avalonia.X11.Selections;
+
+/// <summary>
+/// Provides an X11 selection (clipboard/drag-and-drop).
+/// </summary>
+internal abstract class SelectionDataProvider : IDisposable
+{
+    private readonly IntPtr _selection;
+    private readonly int _maximumPropertySize;
+
+    protected AvaloniaX11Platform Platform { get; }
+
+    public IAsyncDataTransfer? DataTransfer { get; protected set; }
+
+    protected SelectionDataProvider(AvaloniaX11Platform platform, IntPtr selection)
+    {
+        Platform = platform;
+        _selection = selection;
+
+        var maxRequestSize = XExtendedMaxRequestSize(Platform.Display);
+        if (maxRequestSize == 0)
+            maxRequestSize = XMaxRequestSize(Platform.Display);
+
+        _maximumPropertySize = (int)Math.Min(0x100000, maxRequestSize - 0x100);
+    }
+
+    protected IntPtr GetOwner()
+        => XGetSelectionOwner(Platform.Display, _selection);
+
+    protected void SetOwner(IntPtr owner)
+        => XSetSelectionOwner(Platform.Display, _selection, owner, 0);
+
+    public void OnSelectionRequest(in XSelectionRequestEvent request)
+    {
+        var response = new XEvent
+        {
+            SelectionEvent =
+            {
+                type = XEventName.SelectionNotify,
+                send_event = 1,
+                display = Platform.Display,
+                selection = request.selection,
+                target = request.target,
+                requestor = request.requestor,
+                time = request.time,
+                property = 0
+            }
+        };
+
+        if (request.selection == _selection)
+        {
+            response.SelectionEvent.property = WriteTargetToProperty(request.target, request.requestor, request.property);
+        }
+
+        XSendEvent(Platform.Display, request.requestor, false, new IntPtr((int)EventMask.NoEventMask), ref response);
+        OnActivity();
+
+        IntPtr WriteTargetToProperty(IntPtr target, IntPtr window, IntPtr property)
+        {
+            var atoms = Platform.Info.Atoms;
+
+            if (target == atoms.TARGETS)
+            {
+                var atomValues = ConvertDataTransfer(DataTransfer);
+                XChangeProperty(Platform.Display, window, property, atoms.ATOM, 32, PropertyMode.Replace,
+                    atomValues, atomValues.Length);
+                return property;
+            }
+
+            if (target == atoms.SAVE_TARGETS)
+            {
+                return property;
+            }
+
+            if (DataFormatHelper.ToDataFormat(target, atoms) is { } dataFormat)
+            {
+                if (DataTransfer is null)
+                    return 0;
+
+                // Our default bitmap format is image/png
+                if (dataFormat.Identifier is "image/png" && DataTransfer.Contains(DataFormat.Bitmap))
+                    dataFormat = DataFormat.Bitmap;
+
+                if (!DataTransfer.Contains(dataFormat))
+                    return 0;
+
+                if (TryGetDataAsBytes(DataTransfer, dataFormat, target) is not { } bytes)
+                    return 0;
+
+                _ = SendDataToClientAsync(window, property, target, bytes);
+                return property;
+            }
+
+            if (target == atoms.MULTIPLE)
+            {
+                XGetWindowProperty(Platform.Display, window, property, 0, int.MaxValue, false,
+                    atoms.ATOM_PAIR, out _, out var actualFormat, out var nitems, out _, out var prop);
+
+                if (nitems == 0)
+                    return 0;
+
+                if (actualFormat == 32)
+                {
+                    unsafe
+                    {
+                        var data = (IntPtr*)prop.ToPointer();
+                        for (var c = 0; c < nitems.ToInt32(); c += 2)
+                        {
+                            var subTarget = data[c];
+                            var subProp = data[c + 1];
+                            var converted = WriteTargetToProperty(subTarget, window, subProp);
+                            data[c + 1] = converted;
+                        }
+
+                        XChangeProperty(Platform.Display, window, property, atoms.ATOM_PAIR, 32, PropertyMode.Replace,
+                            prop.ToPointer(), nitems.ToInt32());
+                    }
+                }
+
+                XFree(prop);
+
+                return property;
+            }
+
+            return 0;
+        }
+
+    }
+
+    private byte[]? TryGetDataAsBytes(IAsyncDataTransfer dataTransfer, DataFormat format, IntPtr targetFormatAtom)
+    {
+        if (DataFormat.Text.Equals(format))
+        {
+            var text = dataTransfer.TryGetValueAsync(DataFormat.Text).GetAwaiter().GetResult();
+
+            return DataFormatHelper.TryGetStringEncoding(targetFormatAtom, Platform.Info.Atoms) is { } encoding ?
+                encoding.GetBytes(text ?? string.Empty) :
+                null;
+        }
+
+        if (DataFormat.Bitmap.Equals(format))
+        {
+            if (dataTransfer.TryGetValueAsync(DataFormat.Bitmap).GetAwaiter().GetResult() is not { } bitmap)
+                return null;
+
+            using var stream = new MemoryStream();
+            bitmap.Save(stream);
+
+            return stream.ToArray();
+        }
+
+        if (DataFormat.File.Equals(format))
+        {
+            if (dataTransfer.TryGetValuesAsync(DataFormat.File).GetAwaiter().GetResult() is not { } files)
+                return null;
+
+            return UriListHelper.FileUriListToUtf8Bytes(files);
+        }
+
+        if (format is DataFormat<string> stringFormat)
+        {
+            return dataTransfer.TryGetValueAsync(stringFormat).GetAwaiter().GetResult() is { } stringValue ?
+                Encoding.UTF8.GetBytes(stringValue) :
+                null;
+        }
+
+        if (format is DataFormat<byte[]> bytesFormat)
+            return dataTransfer.TryGetValueAsync(bytesFormat).GetAwaiter().GetResult();
+
+        Logger.TryGet(LogEventLevel.Warning, LogArea.X11Platform)
+            ?.Log(this, "Unsupported data format {Format}", format);
+
+        return null;
+    }
+
+    private async Task SendIncrDataToClientAsync(IntPtr window, IntPtr property, IntPtr target, Stream data)
+    {
+        data.Position = 0;
+
+        using var events = new EventStreamWindow(Platform, window);
+        using var _ = data;
+
+        XSelectInput(Platform.Display, window, new IntPtr((int)XEventMask.PropertyChangeMask));
+
+        var size = new IntPtr(data.Length);
+        XChangeProperty(Platform.Display, window, property, Platform.Info.Atoms.INCR, 32, PropertyMode.Replace,
+            ref size, 1);
+
+        var buffer = ArrayPool<byte>.Shared.Rent((int)Math.Min(_maximumPropertySize, data.Length));
+        var gotTimeout = false;
+
+        while (true)
+        {
+            var evt = await events.WaitForEventAsync(
+                x =>
+                    x.type == XEventName.PropertyNotify &&
+                    x.PropertyEvent.atom == property &&
+                    x.PropertyEvent.state == 1,
+                SelectionHelper.Timeout);
+
+            if (evt is null)
+            {
+                gotTimeout = true;
+                break;
+            }
+
+            var read = await data.ReadAsync(buffer, 0, buffer.Length);
+            if (read == 0)
+                break;
+
+            XChangeProperty(Platform.Display, window, property, target, 8, PropertyMode.Replace, buffer, read);
+            OnActivity();
+        }
+
+        ArrayPool<byte>.Shared.Return(buffer);
+
+        // Finish the transfer
+        XChangeProperty(Platform.Display, window, property, target, 8, PropertyMode.Replace, 0, 0);
+
+        if (!gotTimeout)
+            OnActivity();
+    }
+
+    private Task SendDataToClientAsync(IntPtr window, IntPtr property, IntPtr target, byte[] bytes)
+    {
+        if (bytes.Length < _maximumPropertySize)
+        {
+            XChangeProperty(Platform.Display, window, property, target, 8, PropertyMode.Replace,
+                bytes, bytes.Length);
+            OnActivity();
+            return Task.CompletedTask;
+        }
+
+        return SendIncrDataToClientAsync(window, property, target, new MemoryStream(bytes));
+    }
+
+    protected IntPtr[] ConvertDataTransfer(IAsyncDataTransfer? dataTransfer)
+    {
+        var atoms = Platform.Info.Atoms;
+
+        var formatAtoms = DataFormatHelper.ToAtoms(dataTransfer?.Formats ?? [], atoms);
+        return [atoms.TARGETS, atoms.MULTIPLE, ..formatAtoms];
+    }
+
+    protected virtual void OnActivity()
+    {
+    }
+
+    public abstract void Dispose();
+}
diff --git a/src/Avalonia.X11/Selections/SelectionDataReader.cs b/src/Avalonia.X11/Selections/SelectionDataReader.cs
new file mode 100644
index 0000000000..de6ff13653
--- /dev/null
+++ b/src/Avalonia.X11/Selections/SelectionDataReader.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform.Storage;
+
+namespace Avalonia.X11.Selections;
+
+/// <summary>
+/// An object used to read values, converted to the correct format, from an X11 selection (clipboard/drag-and-drop).
+/// </summary>
+internal abstract class SelectionDataReader<TItem>(
+    X11Atoms atoms,
+    IntPtr[] textFormatAtoms,
+    DataFormat[] dataFormats)
+    : IDisposable
+    where TItem : class
+{
+    protected X11Atoms Atoms { get; } = atoms;
+
+    public async Task<TItem[]> CreateItemsAsync()
+    {
+        List<DataFormat>? nonFileFormats = null;
+        var items = new List<TItem>();
+        var hasFiles = false;
+
+        foreach (var format in dataFormats)
+        {
+            if (DataFormat.File.Equals(format))
+            {
+                if (hasFiles)
+                    continue;
+
+                if (await TryGetAsync(format) is IEnumerable<IStorageItem> storageItems)
+                {
+                    hasFiles = true;
+
+                    foreach (var storageItem in storageItems)
+                        items.Add((TItem)(object)PlatformDataTransferItem.Create(DataFormat.File, storageItem));
+                }
+            }
+            else
+                (nonFileFormats ??= []).Add(format);
+        }
+
+        // Single item containing all formats except for DataFormat.File.
+        if (nonFileFormats is not null)
+            items.Add(CreateSingleItem(nonFileFormats.ToArray()));
+
+        return items.ToArray();
+    }
+
+    public virtual async Task<object?> TryGetAsync(DataFormat format)
+    {
+        var formatAtom = DataFormatHelper.ToAtom(format, textFormatAtoms, Atoms, dataFormats);
+        if (formatAtom == IntPtr.Zero)
+            return null;
+
+        using var session = CreateReadSession();
+        var result = await session.SendDataRequest(formatAtom, 0).ConfigureAwait(false);
+        return ConvertDataResult(result, format, formatAtom);
+    }
+
+    protected abstract TItem CreateSingleItem(DataFormat[] nonFileFormats);
+
+    protected abstract SelectionReadSession CreateReadSession();
+
+    private object? ConvertDataResult(SelectionReadSession.GetDataResult? result, DataFormat format, IntPtr formatAtom)
+    {
+        if (result is null)
+            return null;
+
+        if (DataFormat.Text.Equals(format))
+        {
+            return DataFormatHelper.TryGetStringEncoding(result.TypeAtom, Atoms) is { } textEncoding ?
+                textEncoding.GetString(result.AsBytes()) :
+                null;
+        }
+
+        if (DataFormat.Bitmap.Equals(format))
+        {
+            using var data = result.AsStream();
+
+            return new Bitmap(data);
+        }
+
+        if (DataFormat.File.Equals(format))
+        {
+            // text/uri-list might not be supported
+            return formatAtom != IntPtr.Zero && result.TypeAtom == formatAtom ?
+                UriListHelper.Utf8BytesToFileUriList(result.AsBytes()) :
+                null;
+        }
+
+        if (format is DataFormat<string>)
+            return Encoding.UTF8.GetString(result.AsBytes());
+
+        if (format is DataFormat<byte[]>)
+            return result.AsBytes();
+
+        return null;
+    }
+
+    public abstract void Dispose();
+}
diff --git a/src/Avalonia.X11/Selections/SelectionHelper.cs b/src/Avalonia.X11/Selections/SelectionHelper.cs
new file mode 100644
index 0000000000..1a6cd81f8c
--- /dev/null
+++ b/src/Avalonia.X11/Selections/SelectionHelper.cs
@@ -0,0 +1,8 @@
+using System;
+
+namespace Avalonia.X11.Selections;
+
+internal static class SelectionHelper
+{
+    public static TimeSpan Timeout { get; } = TimeSpan.FromSeconds(5);
+}
diff --git a/src/Avalonia.X11/Clipboard/ClipboardReadSession.cs b/src/Avalonia.X11/Selections/SelectionReadSession.cs
similarity index 64%
rename from src/Avalonia.X11/Clipboard/ClipboardReadSession.cs
rename to src/Avalonia.X11/Selections/SelectionReadSession.cs
index 7c83ecea40..207af91309 100644
--- a/src/Avalonia.X11/Clipboard/ClipboardReadSession.cs
+++ b/src/Avalonia.X11/Selections/SelectionReadSession.cs
@@ -5,25 +5,22 @@ using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using static Avalonia.X11.XLib;
 
-namespace Avalonia.X11.Clipboard;
+namespace Avalonia.X11.Selections;
 
-class ClipboardReadSession : IDisposable
+/// <summary>
+/// A session used to read a X11 selection (Clipboard/Drag-and-Drop) from a given window.
+/// </summary>
+internal sealed class SelectionReadSession(
+    IntPtr display,
+    IntPtr window,
+    IntPtr selection,
+    IXEventWaiter eventWaiter,
+    X11Atoms atoms)
+    : IDisposable
 {
-    private readonly AvaloniaX11Platform _platform;
-    private readonly EventStreamWindow _window;
-    private readonly X11Info _x11;
+    public void Dispose() => eventWaiter.Dispose();
 
-    public ClipboardReadSession(AvaloniaX11Platform platform)
-    {
-        _platform = platform;
-        _window = new EventStreamWindow(platform);
-        _x11 = _platform.Info;
-        XSelectInput(_x11.Display, _window.Handle, new IntPtr((int)XEventMask.PropertyChangeMask));
-    }
-
-    public void Dispose() => _window.Dispose();
-
-    class PropertyReadResult(IntPtr data, IntPtr actualTypeAtom, int actualFormat, IntPtr nItems)
+    private sealed class PropertyReadResult(IntPtr data, IntPtr actualTypeAtom, int actualFormat, IntPtr nItems)
         : IDisposable
     {
         public IntPtr Data => data;
@@ -40,39 +37,36 @@ class ClipboardReadSession : IDisposable
     private async Task<PropertyReadResult?>
         WaitForSelectionNotifyAndGetProperty(IntPtr property)
     {
-        var ev = await _window.WaitForEventAsync(ev =>
-            ev.type == XEventName.SelectionNotify 
-            && ev.SelectionEvent.selection == _x11.Atoms.CLIPBOARD
-            && ev.SelectionEvent.property == property
-        );
+        var ev = await eventWaiter.WaitForEventAsync(
+            ev => ev.type == XEventName.SelectionNotify &&
+                  ev.SelectionEvent.requestor == window &&
+                  ev.SelectionEvent.selection == selection &&
+                  ev.SelectionEvent.property == property,
+            SelectionHelper.Timeout);
         
         if (ev == null)
             return null;
         
-        var sel = ev.Value.SelectionEvent;
-        
-        return ReadProperty(sel.property);
+        return ReadProperty(property);
     }
 
     private PropertyReadResult ReadProperty(IntPtr property)
     {
-        XGetWindowProperty(_x11.Display, _window.Handle, property, IntPtr.Zero, new IntPtr (0x7fffffff), true, 
+        XGetWindowProperty(display, window, property, IntPtr.Zero, new IntPtr (0x7fffffff), true,
             (IntPtr)Atom.AnyPropertyType,
-            out var actualTypeAtom, out var actualFormat, out var nitems, out var bytes_after, out var prop);
+            out var actualTypeAtom, out var actualFormat, out var nitems, out _, out var prop);
         return new (prop, actualTypeAtom, actualFormat, nitems);
     }
 
-    private Task<PropertyReadResult?> ConvertSelectionAndGetProperty(
-        IntPtr target, IntPtr property)
+    private Task<PropertyReadResult?> ConvertSelectionAndGetProperty(IntPtr target, IntPtr property, IntPtr timestamp)
     {
-        XConvertSelection(_platform.Display, _x11.Atoms.CLIPBOARD, target, property, _window.Handle,
-            IntPtr.Zero);
+        XConvertSelection(display, selection, target, property, window, timestamp);
         return WaitForSelectionNotifyAndGetProperty(property);
     }
     
-    public async Task<IntPtr[]?> SendFormatRequest()
+    public async Task<IntPtr[]?> SendFormatRequest(IntPtr targetsAtom)
     {
-        using var res = await ConvertSelectionAndGetProperty(_x11.Atoms.TARGETS, _x11.Atoms.TARGETS);
+        using var res = await ConvertSelectionAndGetProperty(atoms.TARGETS, atoms.TARGETS, 0);
         if (res == null)
             return null;
         
@@ -97,7 +91,7 @@ class ClipboardReadSession : IDisposable
 
     private async Task<GetDataResult?> ReadIncr(IntPtr property)
     {
-        XFlush(_platform.Display);
+        XFlush(display);
         var ms = new MemoryStream();
         void Append(PropertyReadResult res)
         {
@@ -110,9 +104,11 @@ class ClipboardReadSession : IDisposable
         IntPtr actualTypeAtom = IntPtr.Zero;
         while (true)
         {
-            var ev = await _window.WaitForEventAsync(x =>
-                x is { type: XEventName.PropertyNotify, PropertyEvent.state: 0 } &&
-                x.PropertyEvent.atom == property);
+            var ev = await eventWaiter.WaitForEventAsync(
+                x => x is { type: XEventName.PropertyNotify, PropertyEvent.state: 0 } &&
+                     x.PropertyEvent.window == window &&
+                     x.PropertyEvent.atom == property,
+                SelectionHelper.Timeout);
             
             if (ev == null)
                 return null;
@@ -131,15 +127,15 @@ class ClipboardReadSession : IDisposable
         return new(null, ms, actualTypeAtom);
     }
     
-    public async Task<GetDataResult?> SendDataRequest(IntPtr format)
+    public async Task<GetDataResult?> SendDataRequest(IntPtr format, IntPtr timestamp)
     {
-        using var res = await ConvertSelectionAndGetProperty(format, format);
+        using var res = await ConvertSelectionAndGetProperty(format, format, timestamp);
         if (res == null)
             return null;
         
         if (res.NItems == IntPtr.Zero)
             return null;
-        if (res.ActualTypeAtom == _x11.Atoms.INCR)
+        if (res.ActualTypeAtom == atoms.INCR)
         {
             return await ReadIncr(format);
         }
diff --git a/src/Avalonia.X11/Clipboard/ClipboardUriListHelper.cs b/src/Avalonia.X11/Selections/UriListHelper.cs
similarity index 94%
rename from src/Avalonia.X11/Clipboard/ClipboardUriListHelper.cs
rename to src/Avalonia.X11/Selections/UriListHelper.cs
index b6717c2d2f..cb838a1661 100644
--- a/src/Avalonia.X11/Clipboard/ClipboardUriListHelper.cs
+++ b/src/Avalonia.X11/Selections/UriListHelper.cs
@@ -5,9 +5,9 @@ using System.Text;
 using Avalonia.Platform.Storage;
 using Avalonia.Platform.Storage.FileIO;
 
-namespace Avalonia.X11.Clipboard;
+namespace Avalonia.X11.Selections;
 
-internal static class ClipboardUriListHelper
+internal static class UriListHelper
 {
     private static readonly Encoding s_utf8NoBomEncoding = new UTF8Encoding(false);
 
diff --git a/src/Avalonia.X11/X11Atoms.cs b/src/Avalonia.X11/X11Atoms.cs
index afe3121cfc..bc150ffe1b 100644
--- a/src/Avalonia.X11/X11Atoms.cs
+++ b/src/Avalonia.X11/X11Atoms.cs
@@ -23,7 +23,7 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using static Avalonia.X11.Selections.DataFormatHelper;
 using static Avalonia.X11.XLib;
 // ReSharper disable FieldCanBeMadeReadOnly.Global
 // ReSharper disable IdentifierTypo
@@ -186,8 +186,6 @@ namespace Avalonia.X11
         public IntPtr CLIPBOARD_MANAGER;
         public IntPtr SAVE_TARGETS;
         public IntPtr MULTIPLE;
-        public IntPtr OEMTEXT;
-        public IntPtr UNICODETEXT;
         public IntPtr TARGETS;
         public IntPtr UTF8_STRING;
         public IntPtr UTF16_STRING;
@@ -196,15 +194,44 @@ namespace Avalonia.X11
         public IntPtr _KDE_NET_WM_BLUR_BEHIND_REGION;
         public IntPtr INCR;
         public IntPtr _NET_WM_STATE_FOCUSED;
+        public IntPtr AVALONIA_SAVE_TARGETS_PROPERTY_ATOM;
+
+        public IntPtr XdndActionCopy;
+        public IntPtr XdndActionLink;
+        public IntPtr XdndActionMove;
+        public IntPtr XdndAware;
+        public IntPtr XdndDrop;
+        public IntPtr XdndEnter;
+        public IntPtr XdndFinished;
+        public IntPtr XdndLeave;
+        public IntPtr XdndPosition;
+        public IntPtr XdndProxy;
+        public IntPtr XdndSelection;
+        public IntPtr XdndStatus;
+        public IntPtr XdndTypeList;
 
         private readonly Dictionary<string, IntPtr> _namesToAtoms  = new Dictionary<string, IntPtr>();
         private readonly Dictionary<IntPtr, string> _atomsToNames = new Dictionary<IntPtr, string>();
+
         public X11Atoms(IntPtr display)
         {
             _display = display;
             PopulateAtoms(display);
         }
 
+        /// <summary>
+        /// The atoms corresponding to text formats, by order of preference.
+        /// </summary>
+        public IntPtr[] TextFormats
+            => field ??=
+            [
+                UTF16_STRING,
+                UTF8_STRING,
+                GetAtom(MimeTypeTextPlain),
+                GetAtom(MimeTypeTextPlainUtf8),
+                STRING
+            ];
+
         private void InitAtom(ref IntPtr field, string name, IntPtr value)
         {
             if (value != IntPtr.Zero)
@@ -232,6 +259,9 @@ namespace Avalonia.X11
 
         public string? GetAtomName(IntPtr atom)
         {
+            if (atom == 0)
+                return null;
+
             if (_atomsToNames.TryGetValue(atom, out var rv))
                 return rv;
             var name = XLib.GetAtomName(_display, atom);
diff --git a/src/Avalonia.X11/X11CursorFactory.cs b/src/Avalonia.X11/X11CursorFactory.cs
index 1ac4c1fe8d..d68eed8c15 100644
--- a/src/Avalonia.X11/X11CursorFactory.cs
+++ b/src/Avalonia.X11/X11CursorFactory.cs
@@ -61,16 +61,28 @@ namespace Avalonia.X11
             _cursors = new Dictionary<StandardCursorType, IntPtr>();
         }
 
+        // We don't have a "DragNo" standard cursor type, but Xcursor provides one
+        public IntPtr DragNoDropCursorHandle
+        {
+            get
+            {
+                if (field == 0)
+                    field = LoadDragNoDropCursor();
+                return field;
+            }
+        }
+
         public ICursorImpl GetCursor(StandardCursorType cursorType)
         {
-            IntPtr handle;
-            if (cursorType == StandardCursorType.None)
-                handle = _nullCursor;
-            else
-                handle = GetCursorHandleCached(cursorType);
+            var handle = GetCursorHandle(cursorType);
             return new CursorImpl(handle);
         }
 
+        public IntPtr GetCursorHandle(StandardCursorType cursorType)
+        {
+            return cursorType == StandardCursorType.None ? _nullCursor : GetCursorHandleCached(cursorType);
+        }
+
         public unsafe ICursorImpl CreateCursor(Bitmap cursor, PixelPoint hotSpot)
         {
             return new XImageCursor(_display, cursor, hotSpot);
@@ -84,6 +96,15 @@ namespace Avalonia.X11
             return XLib.XCreatePixmapCursor(display, pixmap, pixmap, ref color, ref color, 0, 0);
         }
 
+        private IntPtr LoadDragNoDropCursor()
+        {
+            var handle = XLib.XcursorLibraryLoadCursor(_display, "dnd-no-drop");
+
+            if (handle == 0)
+                handle = GetCursorHandleCached(StandardCursorType.No);
+            return handle;
+        }
+
         private unsafe class XImageCursor : CursorImpl, IPlatformHandle
         {
             private readonly IntPtr _display;
@@ -130,9 +151,10 @@ namespace Avalonia.X11
         {
             if (!_cursors.TryGetValue(type, out var handle))
             {
-                if(s_libraryCursors.TryGetValue(type, out var cursorName))
+                if (s_libraryCursors.TryGetValue(type, out var cursorName))
                     handle = XLib.XcursorLibraryLoadCursor(_display, cursorName);
-                else if(s_mapping.TryGetValue(type, out var cursorShape))
+
+                if (handle == 0 && s_mapping.TryGetValue(type, out var cursorShape))
                     handle = XLib.XCreateFontCursor(_display, cursorShape);
 
                 if (handle == IntPtr.Zero)
diff --git a/src/Avalonia.X11/X11EnumExtensions.cs b/src/Avalonia.X11/X11EnumExtensions.cs
new file mode 100644
index 0000000000..a374a24bbd
--- /dev/null
+++ b/src/Avalonia.X11/X11EnumExtensions.cs
@@ -0,0 +1,30 @@
+using Avalonia.Input;
+
+namespace Avalonia.X11;
+
+internal static class X11EnumExtensions
+{
+    public static RawInputModifiers ToRawInputModifiers(this XModifierMask state)
+    {
+        var rv = default(RawInputModifiers);
+        if (state.HasAllFlags(XModifierMask.Button1Mask))
+            rv |= RawInputModifiers.LeftMouseButton;
+        if (state.HasAllFlags(XModifierMask.Button2Mask))
+            rv |= RawInputModifiers.RightMouseButton;
+        if (state.HasAllFlags(XModifierMask.Button3Mask))
+            rv |= RawInputModifiers.MiddleMouseButton;
+        if (state.HasAllFlags(XModifierMask.Button4Mask))
+            rv |= RawInputModifiers.XButton1MouseButton;
+        if (state.HasAllFlags(XModifierMask.Button5Mask))
+            rv |= RawInputModifiers.XButton2MouseButton;
+        if (state.HasAllFlags(XModifierMask.ShiftMask))
+            rv |= RawInputModifiers.Shift;
+        if (state.HasAllFlags(XModifierMask.ControlMask))
+            rv |= RawInputModifiers.Control;
+        if (state.HasAllFlags(XModifierMask.Mod1Mask))
+            rv |= RawInputModifiers.Alt;
+        if (state.HasAllFlags(XModifierMask.Mod4Mask))
+            rv |= RawInputModifiers.Meta;
+        return rv;
+    }
+}
diff --git a/src/Avalonia.X11/X11FocusProxy.cs b/src/Avalonia.X11/X11FocusProxy.cs
index 4856dbef65..7bcede3a53 100644
--- a/src/Avalonia.X11/X11FocusProxy.cs
+++ b/src/Avalonia.X11/X11FocusProxy.cs
@@ -41,7 +41,7 @@ namespace Avalonia.X11
             _handle = PrepareXWindow(platform.Info.Display, parent);
             _platform = platform;
             _ownerEventHandler = eventHandler;
-            _platform.Windows[_handle] = OnEvent;
+            _platform.Windows[_handle] = new X11WindowInfo(OnEvent, null);
         }
 
         internal void Cleanup()
diff --git a/src/Avalonia.X11/X11Globals.cs b/src/Avalonia.X11/X11Globals.cs
index 73ea2306b4..2358271d42 100644
--- a/src/Avalonia.X11/X11Globals.cs
+++ b/src/Avalonia.X11/X11Globals.cs
@@ -40,7 +40,7 @@ namespace Avalonia.X11
             _x11 = plat.Info;
             _screenNumber = XDefaultScreen(_x11.Display);
             _rootWindow = XRootWindow(_x11.Display, _screenNumber);
-            plat.Windows[_rootWindow] = OnRootWindowEvent;
+            plat.Windows[_rootWindow] = new X11WindowInfo(OnRootWindowEvent, null);
             XSelectInput(_x11.Display, _rootWindow,
                 new IntPtr((int)(EventMask.StructureNotifyMask | EventMask.PropertyChangeMask)));
             
@@ -156,7 +156,7 @@ namespace Avalonia.X11
                 CompositionAtomOwner = newOwner;
                 if (CompositionAtomOwner != IntPtr.Zero)
                 {
-                    _plat.Windows[newOwner] = HandleCompositionAtomOwnerEvents;
+                    _plat.Windows[newOwner] = new X11WindowInfo(HandleCompositionAtomOwnerEvents, null);
                     XSelectInput(_x11.Display, CompositionAtomOwner, new IntPtr((int)(EventMask.StructureNotifyMask)));
                 }
                 
diff --git a/src/Avalonia.X11/X11Platform.cs b/src/Avalonia.X11/X11Platform.cs
index 85f3c63577..408fe512ea 100644
--- a/src/Avalonia.X11/X11Platform.cs
+++ b/src/Avalonia.X11/X11Platform.cs
@@ -18,11 +18,12 @@ using Avalonia.Rendering.Composition;
 using Avalonia.Threading;
 using Avalonia.Vulkan;
 using Avalonia.X11;
-using Avalonia.X11.Clipboard;
 using Avalonia.X11.Dispatching;
 using Avalonia.X11.Glx;
-using Avalonia.X11.Vulkan;
 using Avalonia.X11.Screens;
+using Avalonia.X11.Selections.Clipboard;
+using Avalonia.X11.Selections.DragDrop;
+using Avalonia.X11.Vulkan;
 using static Avalonia.X11.XLib;
 
 namespace Avalonia.X11
@@ -35,7 +36,7 @@ namespace Avalonia.X11
         private X11AtSpiAccessibility? _accessibility;
         internal AtSpiServer? AtSpiServer => _accessibility?.Server;
         public KeyboardDevice KeyboardDevice => _keyboardDevice.Value;
-        public Dictionary<IntPtr, X11EventDispatcher.EventHandler> Windows { get; } = new ();
+        public Dictionary<IntPtr, X11WindowInfo> Windows { get; } = new ();
         public XI2Manager? XI2 { get; private set; }
         public X11Info Info { get; private set; } = null!;
         public X11Screens X11Screens { get; private set; } = null!;
@@ -97,6 +98,7 @@ namespace Avalonia.X11
                 .Bind<ICursorFactory>().ToConstant(new X11CursorFactory(Display))
                 .Bind<IClipboardImpl>().ToConstant(clipboardImpl)
                 .Bind<IClipboard>().ToConstant(clipboard)
+                .Bind<IPlatformDragSource>().ToConstant(new X11DragSource(this))
                 .Bind<IPlatformSettings>().ToSingleton<DBusPlatformSettings>()
                 .Bind<IPlatformIconLoader>().ToConstant(new X11IconLoader())
                 .Bind<IMountedVolumeInfoProvider>().ToConstant(new LinuxMountedVolumeInfoProvider())
diff --git a/src/Avalonia.X11/X11Window.Ime.cs b/src/Avalonia.X11/X11Window.Ime.cs
index 768a79af3d..e51934e65d 100644
--- a/src/Avalonia.X11/X11Window.Ime.cs
+++ b/src/Avalonia.X11/X11Window.Ime.cs
@@ -116,7 +116,7 @@ namespace Avalonia.X11
         {
             var physicalKey = X11KeyTransform.PhysicalKeyFromScanCode(ev.KeyEvent.keycode);
             var (x11Key, key, symbol) = LookupKey(ref ev.KeyEvent, physicalKey);
-            var modifiers = TranslateModifiers(ev.KeyEvent.state);
+            var modifiers = ev.KeyEvent.state.ToRawInputModifiers();
             var timestamp = (ulong)ev.KeyEvent.time.ToInt64();
 
             var args = ev.type == XEventName.KeyPress ?
diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index 12c3453d75..cece8e8bb0 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -2,31 +2,30 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using Avalonia.Reactive;
+using System.Runtime.InteropServices;
 using System.Text;
-using System.Threading.Tasks;
 using System.Threading;
+using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Controls.Platform;
 using Avalonia.Controls.Primitives.PopupPositioning;
+using Avalonia.Dialogs;
 using Avalonia.FreeDesktop;
 using Avalonia.Input;
+using Avalonia.Input.Platform;
 using Avalonia.Input.Raw;
 using Avalonia.Input.TextInput;
-using Avalonia.OpenGL;
 using Avalonia.OpenGL.Egl;
 using Avalonia.Platform;
-using Avalonia.Platform.Surfaces;
 using Avalonia.Platform.Storage;
+using Avalonia.Platform.Storage.FileIO;
+using Avalonia.Platform.Surfaces;
 using Avalonia.Rendering.Composition;
 using Avalonia.Threading;
 using Avalonia.X11.Glx;
 using Avalonia.X11.NativeDialogs;
+using Avalonia.X11.Selections.DragDrop;
 using static Avalonia.X11.XLib;
-using Avalonia.Input.Platform;
-using System.Runtime.InteropServices;
-using Avalonia.Dialogs;
-using Avalonia.Platform.Storage.FileIO;
 
 // ReSharper disable IdentifierTypo
 // ReSharper disable StringLiteralTypo
@@ -34,7 +33,7 @@ using Avalonia.Platform.Storage.FileIO;
 namespace Avalonia.X11
 {
     internal unsafe partial class X11Window : IWindowImpl, IPopupImpl, IXI2Client,
-        IX11OptionsToplevelImplFeature
+        IX11OptionsToplevelImplFeature, IXdndWindow
     {
         private readonly AvaloniaX11Platform _platform;
         private readonly bool _popup;
@@ -73,6 +72,7 @@ namespace Avalonia.X11
         private bool _usePositioningFlags = false;
         private X11WindowMode _mode;
         private IWindowIconImpl? _iconImpl;
+        private readonly X11DropTarget? _dropTarget;
 
         private enum XSyncState
         {
@@ -203,7 +203,7 @@ namespace Avalonia.X11
             _mode.OnHandleCreated(_handle);
             
             _realSize = new PixelSize(defaultWidth, defaultHeight);
-            platform.Windows[_handle] = OnEvent;
+            platform.Windows[_handle] = new X11WindowInfo(OnEvent, this);
             XEventMask ignoredMask = XEventMask.SubstructureRedirectMask
                                      | XEventMask.ResizeRedirectMask
                                      | XEventMask.PointerMotionHintMask;
@@ -290,6 +290,12 @@ namespace Avalonia.X11
                     : null)
             });
 
+            if (AvaloniaLocator.Current.GetService<IDragDropDevice>() is { } dragDropDevice)
+            {
+                DragDropDevice = dragDropDevice;
+                _dropTarget = new X11DropTarget(dragDropDevice, this, _x11.Display, _x11.Atoms);
+            }
+
             platform.X11Screens.Changed += OnScreensChanged;
 
             // The render surface (EGL/GLX) is created on the deferred display connection, which is a separate
@@ -536,6 +542,8 @@ namespace Avalonia.X11
 
         public Compositor Compositor => _platform.Compositor;
 
+        public IDragDropDevice? DragDropDevice { get; }
+
         private PlatformAllowedWindowActions GetAllowedActions(IntPtr[]? netSupported)
         {
             if (netSupported == null)
@@ -558,7 +566,7 @@ namespace Avalonia.X11
 
         private void OnNetSupportedChanged() =>
             AllowedWindowActionsChanged?.Invoke(AllowedWindowActions);
-        
+
         private void OnEvent(ref XEvent ev)
         {
             if (_inputRoot is null)
@@ -618,7 +626,7 @@ namespace Avalonia.X11
                                 : new Vector(-1, 0);
                     ScheduleInput(new RawMouseWheelEventArgs(_mouse, (ulong)ev.ButtonEvent.time.ToInt64(),
                         _inputRoot, new Point(ev.ButtonEvent.x, ev.ButtonEvent.y), delta,
-                        TranslateModifiers(ev.ButtonEvent.state)), ref ev);
+                        ev.ButtonEvent.state.ToRawInputModifiers()), ref ev);
                 }
                 
             }
@@ -697,7 +705,8 @@ namespace Avalonia.X11
             }
             else if (ev.type == XEventName.ClientMessage)
             {
-                if (ev.ClientMessageEvent.message_type == _x11.Atoms.WM_PROTOCOLS)
+                var messageType = ev.ClientMessageEvent.message_type;
+                if (messageType == _x11.Atoms.WM_PROTOCOLS)
                 {
                     if (ev.ClientMessageEvent.ptr1 == _x11.Atoms.WM_DELETE_WINDOW)
                     {
@@ -711,6 +720,14 @@ namespace Avalonia.X11
                         _xSyncState = XSyncState.WaitConfigure;
                     }
                 }
+                else if (messageType == _x11.Atoms.XdndEnter)
+                    _dropTarget?.OnXdndEnter(ev.ClientMessageEvent);
+                else if (messageType == _x11.Atoms.XdndPosition)
+                    _dropTarget?.OnXdndPosition(ev.ClientMessageEvent);
+                else if (messageType == _x11.Atoms.XdndLeave)
+                    _dropTarget?.OnXdndLeave(ev.ClientMessageEvent);
+                else if (messageType == _x11.Atoms.XdndDrop)
+                    _dropTarget?.OnXdndDrop(ev.ClientMessageEvent);
             }
             else if (ev.type == XEventName.KeyPress || ev.type == XEventName.KeyRelease)
             {
@@ -898,30 +915,6 @@ namespace Avalonia.X11
 
         }
 
-        private static RawInputModifiers TranslateModifiers(XModifierMask state)
-        {
-            var rv = default(RawInputModifiers);
-            if (state.HasAllFlags(XModifierMask.Button1Mask))
-                rv |= RawInputModifiers.LeftMouseButton;
-            if (state.HasAllFlags(XModifierMask.Button2Mask))
-                rv |= RawInputModifiers.RightMouseButton;
-            if (state.HasAllFlags(XModifierMask.Button3Mask))
-                rv |= RawInputModifiers.MiddleMouseButton;
-            if (state.HasAllFlags(XModifierMask.Button4Mask))
-                rv |= RawInputModifiers.XButton1MouseButton;
-            if (state.HasAllFlags(XModifierMask.Button5Mask))
-                rv |= RawInputModifiers.XButton2MouseButton;
-            if (state.HasAllFlags(XModifierMask.ShiftMask))
-                rv |= RawInputModifiers.Shift;
-            if (state.HasAllFlags(XModifierMask.ControlMask))
-                rv |= RawInputModifiers.Control;
-            if (state.HasAllFlags(XModifierMask.Mod1Mask))
-                rv |= RawInputModifiers.Alt;
-            if (state.HasAllFlags(XModifierMask.Mod4Mask))
-                rv |= RawInputModifiers.Meta;
-            return rv;
-        }
-        
         private WindowDecorations _requestedWindowDecorations = WindowDecorations.Full;
         private WindowDecorations _windowDecorations = WindowDecorations.Full;
         private bool _canResize = true;
@@ -1029,7 +1022,7 @@ namespace Avalonia.X11
                 return;
             var mev = new RawPointerEventArgs(
                 _mouse, (ulong)ev.ButtonEvent.time.ToInt64(), _inputRoot,
-                type, new Point(ev.ButtonEvent.x, ev.ButtonEvent.y), TranslateModifiers(mods));
+                type, new Point(ev.ButtonEvent.x, ev.ButtonEvent.y), mods.ToRawInputModifiers());
             ScheduleInput(mev, ref ev);
         }
 
@@ -1190,7 +1183,7 @@ namespace Avalonia.X11
 
             _platform.X11Screens.Changed -= OnScreensChanged;
             _platform.Globals.NetSupportedChanged -= OnNetSupportedChanged;
-            
+
             if (_useRenderWindow && _renderHandle != IntPtr.Zero)
             {                
                 _renderHandle = IntPtr.Zero;
@@ -1330,7 +1323,9 @@ namespace Avalonia.X11
         }
 
         public IPlatformHandle Handle { get; }
-        
+
+        IntPtr IXdndWindow.Handle => _handle;
+
         public PixelPoint Position
         {
             get
diff --git a/src/Avalonia.X11/X11WindowInfo.cs b/src/Avalonia.X11/X11WindowInfo.cs
new file mode 100644
index 0000000000..37a19a8874
--- /dev/null
+++ b/src/Avalonia.X11/X11WindowInfo.cs
@@ -0,0 +1,7 @@
+namespace Avalonia.X11;
+
+internal readonly struct X11WindowInfo(X11EventDispatcher.EventHandler eventHandler, X11Window? window)
+{
+    public X11EventDispatcher.EventHandler EventHandler { get; } = eventHandler;
+    public X11Window? Window { get; } = window;
+}
diff --git a/src/Avalonia.X11/XLib.Helpers.cs b/src/Avalonia.X11/XLib.Helpers.cs
index 7fb90e4595..1c3e3cc78d 100644
--- a/src/Avalonia.X11/XLib.Helpers.cs
+++ b/src/Avalonia.X11/XLib.Helpers.cs
@@ -24,7 +24,34 @@ internal static partial class XLib
         }
         finally
         {
-            XFree(prop);
+            if (prop != 0)
+                XFree(prop);
+        }
+    }
+
+    public static IntPtr? XGetWindowPropertyAsIntPtr(IntPtr display, IntPtr window, IntPtr atom, IntPtr reqType)
+    {
+        if ((Status)XGetWindowProperty(
+            display, window, atom, 0, 1, false, reqType,
+            out var actualType, out var actualFormat, out var itemCount, out _, out var prop) != Status.Success)
+        {
+            return null;
+        }
+
+        try
+        {
+            if (actualType != reqType || actualFormat != 32 || itemCount != 1)
+                return null;
+
+            unsafe
+            {
+                return *(IntPtr*)prop;
+            }
+        }
+        finally
+        {
+            if (prop != 0)
+                XFree(prop);
         }
     }
 
@@ -36,4 +63,4 @@ internal static partial class XLib
         XFree(pList);
         return rv;
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.X11/XLib.cs b/src/Avalonia.X11/XLib.cs
index cdede39624..108ae257c4 100644
--- a/src/Avalonia.X11/XLib.cs
+++ b/src/Avalonia.X11/XLib.cs
@@ -60,10 +60,13 @@ namespace Avalonia.X11
         public static extern IntPtr XDefaultRootWindow(IntPtr display);
 
         [DllImport(libX11)]
-        public static extern IntPtr XNextEvent(IntPtr display, out XEvent xevent);
+        public static extern int XNextEvent(IntPtr display, out XEvent xevent);
         
         [DllImport(libX11)]
-        public static extern IntPtr XNextEvent(IntPtr display, XEvent* xevent);
+        public static extern int XNextEvent(IntPtr display, XEvent* xevent);
+
+        [LibraryImport(libX11)]
+        public static partial int XPutBackEvent(IntPtr display, in XEvent evt);
 
         [DllImport(libX11)]
         public static extern int XConnectionNumber(IntPtr diplay);
@@ -164,7 +167,7 @@ namespace Avalonia.X11
         public static extern int XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count);
 
         [DllImport(libX11)]
-        public static extern int XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask,
+        public static extern GrabResult XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask,
             GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp);
 
         [DllImport(libX11)]
@@ -172,11 +175,11 @@ namespace Avalonia.X11
 
         [DllImport(libX11)]
         public static extern bool XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child,
-            out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons);
+            out int root_x, out int root_y, out int win_x, out int win_y, out XModifierMask mask);
 
         [DllImport(libX11)]
         public static extern bool XTranslateCoordinates(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x,
-            int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return);
+            int src_y, out int dest_x_return, out int dest_y_return, out IntPtr child_return);
 
         [DllImport(libX11)]
         public static extern bool XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y,
@@ -488,6 +491,9 @@ namespace Avalonia.X11
             XLookupKeySym = 3,
             XLookupBoth = 4
         }
+
+        [LibraryImport(libX11)]
+        public static partial XKeySym XLookupKeysym(in XKeyEvent key_event, int index);
         
         [DllImport (libX11)]
         public static extern int XLookupString(ref XKeyEvent xevent, byte* buffer, int num_bytes, out nint keysym, IntPtr composeStatus);
@@ -732,7 +738,7 @@ namespace Avalonia.X11
         
         public static void QueryPointer (IntPtr display, IntPtr w, out IntPtr root, out IntPtr child,
             out int root_x, out int root_y, out int child_x, out int child_y,
-            out int mask)
+            out XModifierMask mask)
         {
 
             IntPtr c;
@@ -767,7 +773,7 @@ namespace Avalonia.X11
             int root_y;
             int win_x;
             int win_y;
-            int keys_buttons;
+            XModifierMask keys_buttons;
 
 
 
@@ -789,7 +795,7 @@ namespace Avalonia.X11
         {
             var win = XCreateSimpleWindow(plat.Display, plat.Info.DefaultRootWindow, 
                 0, 0, 1, 1, 0, IntPtr.Zero, IntPtr.Zero);
-            plat.Windows[win] = handler;
+            plat.Windows[win] = new X11WindowInfo(handler, null);
             return win;
         }
 
@@ -798,5 +804,14 @@ namespace Avalonia.X11
 
         public static int XkbSetGroupForCoreState(int state, int newGroup)
             => (state & ~(0x3 << 13)) | ((newGroup & 0x3) << 13);
+
+        public enum GrabResult
+        {
+            GrabSuccess = 0,
+            AlreadyGrabbed = 1,
+            GrabInvalidTime = 2,
+            GrabNotViewable = 3,
+            GrabFrozen = 4,
+        }
     }
 }

From facc253b21a848644b5d0469019803c57ffa3f9e Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Fri, 3 Jul 2026 03:20:20 +0800
Subject: [PATCH 060/196] Convert ExpandCollapseState to its UIA wire value in
 the Win32 automation layer; Avalonia declares PartiallyExpanded and LeafNode
 in the opposite order from UIA. (#21693)

---
 .../AutomationNode.ExpandCollapse.cs              | 15 +++++++++++++--
 .../Avalonia.Win32.Automation/AutomationNode.cs   |  4 ++--
 .../Interop/IExpandCollapseProvider.cs            |  3 +--
 3 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/Windows/Avalonia.Win32.Automation/AutomationNode.ExpandCollapse.cs b/src/Windows/Avalonia.Win32.Automation/AutomationNode.ExpandCollapse.cs
index c28d000f56..200d1c93a9 100644
--- a/src/Windows/Avalonia.Win32.Automation/AutomationNode.ExpandCollapse.cs
+++ b/src/Windows/Avalonia.Win32.Automation/AutomationNode.ExpandCollapse.cs
@@ -6,11 +6,22 @@ namespace Avalonia.Win32.Automation
 {
     internal partial class AutomationNode : UIA.IExpandCollapseProvider
     {
-        ExpandCollapseState UIA.IExpandCollapseProvider.GetExpandCollapseState()
+        int UIA.IExpandCollapseProvider.GetExpandCollapseState()
         {
-            return InvokeSync<IExpandCollapseProvider, ExpandCollapseState>(x => x.ExpandCollapseState);
+            return ToUiaExpandCollapseState(InvokeSync<IExpandCollapseProvider, ExpandCollapseState>(x => x.ExpandCollapseState));
         }
 
+        // Avalonia declares PartiallyExpanded and LeafNode in the opposite order
+        // from the UIA wire values.
+        internal static int ToUiaExpandCollapseState(ExpandCollapseState state) => state switch
+        {
+            ExpandCollapseState.Collapsed => 0,
+            ExpandCollapseState.Expanded => 1,
+            ExpandCollapseState.PartiallyExpanded => 2,
+            ExpandCollapseState.LeafNode => 3,
+            _ => 0,
+        };
+
         void UIA.IExpandCollapseProvider.Expand() => InvokeSync<IExpandCollapseProvider>(x => x.Expand());
         void UIA.IExpandCollapseProvider.Collapse() => InvokeSync<IExpandCollapseProvider>(x => x.Collapse());
     }
diff --git a/src/Windows/Avalonia.Win32.Automation/AutomationNode.cs b/src/Windows/Avalonia.Win32.Automation/AutomationNode.cs
index e2ffca2ea7..1c0236e8c0 100644
--- a/src/Windows/Avalonia.Win32.Automation/AutomationNode.cs
+++ b/src/Windows/Avalonia.Win32.Automation/AutomationNode.cs
@@ -301,8 +301,8 @@ namespace Avalonia.Win32.Automation
                 UiaCoreProviderApi.UiaRaiseAutomationPropertyChangedEvent(
                     this,
                     (int)id,
-                    e.OldValue as IConvertible,
-                    e.NewValue as IConvertible);
+                    e.OldValue is ExpandCollapseState o ? ToUiaExpandCollapseState(o) : e.OldValue as IConvertible,
+                    e.NewValue is ExpandCollapseState n ? ToUiaExpandCollapseState(n) : e.NewValue as IConvertible);
             }
 
             if (id == UiaPropertyId.Name && Peer.GetLiveSetting() != AutomationLiveSetting.Off)
diff --git a/src/Windows/Avalonia.Win32.Automation/Interop/IExpandCollapseProvider.cs b/src/Windows/Avalonia.Win32.Automation/Interop/IExpandCollapseProvider.cs
index 7e5cc048de..2621edf28e 100644
--- a/src/Windows/Avalonia.Win32.Automation/Interop/IExpandCollapseProvider.cs
+++ b/src/Windows/Avalonia.Win32.Automation/Interop/IExpandCollapseProvider.cs
@@ -1,6 +1,5 @@
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.Marshalling;
-using Avalonia.Automation;
 
 namespace Avalonia.Win32.Automation.Interop;
 
@@ -10,5 +9,5 @@ internal partial interface IExpandCollapseProvider
 {
     void Expand();
     void Collapse();
-    ExpandCollapseState GetExpandCollapseState();
+    int GetExpandCollapseState();
 }

From bfa2319e77d5a828a11f2e6b3bead596a113e585 Mon Sep 17 00:00:00 2001
From: Nick Nassiri <nick@knnlabs.com>
Date: Thu, 2 Jul 2026 23:52:36 -0700
Subject: [PATCH 061/196] Win32/ARM64: let GraphicsAdapterSelectionCallback see
 unfiltered adapters and warn on Adreno WARP fallback (#21695)

* win32: let GraphicsAdapterSelectionCallback see unfiltered adapters on ARM64

The ARM64 Adreno blocklist in AngleWin32EglDisplay removed every Adreno
adapter from the list before it was handed to GraphicsAdapterSelectionCallback,
so an application had no way to opt back into hardware acceleration and no
indication that WARP (the Microsoft Basic Render Driver) was being forced.

Stop mutating the adapter list. The blocklist now only moves the *default*
selection to the first non-Adreno adapter when no callback is supplied, and
logs a warning about the CPU-usage impact and the available workarounds. When
a callback is present it receives the full, unfiltered adapter list and its
choice is used as-is.

As a side effect this also removes a latent IndexOutOfRange: the old code
could empty the list when every enumerated adapter was Adreno.

Refs #21689

* Update src/Windows/Avalonia.Win32/OpenGl/Angle/AngleWin32EglDisplay.cs

Co-authored-by: Max Katz <maxkatz6@outlook.com>

---------

Co-authored-by: nickna <nick@nassiri.xyz>
Co-authored-by: Max Katz <maxkatz6@outlook.com>
---
 .../OpenGl/Angle/AngleWin32EglDisplay.cs      | 30 ++++++++++++-------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/src/Windows/Avalonia.Win32/OpenGl/Angle/AngleWin32EglDisplay.cs b/src/Windows/Avalonia.Win32/OpenGl/Angle/AngleWin32EglDisplay.cs
index 9b23bc9aa8..afee6efd23 100644
--- a/src/Windows/Avalonia.Win32/OpenGl/Angle/AngleWin32EglDisplay.cs
+++ b/src/Windows/Avalonia.Win32/OpenGl/Angle/AngleWin32EglDisplay.cs
@@ -4,6 +4,7 @@ using System.ComponentModel;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using Avalonia.Logging;
 using Avalonia.OpenGL;
 using Avalonia.OpenGL.Angle;
 using Avalonia.OpenGL.Egl;
@@ -95,19 +96,28 @@ namespace Avalonia.Win32.OpenGl.Angle
                     if (adapters.Count == 0)
                         throw new OpenGlException("No adapters found");
 
-                    if (applyArmAdrenoBlacklist && adapters.Count > 1)
-                    {
-                        for (var c = adapters.Count - 1; c >= 0; c--)
-                            if (adapters[c].desc.Description?.Contains("adreno") == true)
-                            {
-                                adapters[c].adapter.Dispose();
-                                adapters.RemoveAt(c);
-                            }
-                    }
-
+                    // The Adreno blacklist (see #10405) now only moves the *default* selection away
+                    // from Adreno GPUs - it no longer hides adapters from the selection callback, so
+                    // an application can deliberately opt back into hardware acceleration.
                     var chosenAdapterIndex = 0;
                     if (selectionCallback != null)
+                    {
                         chosenAdapterIndex = selectionCallback(adapters.Select(a => a.desc).ToArray());
+                    }
+                    else if (applyArmAdrenoBlacklist && adapters.Count > 1)
+                    {
+                        var firstNonAdreno = adapters.FindIndex(a => a.desc.Description?.Contains("adreno") != true);
+                        if (firstNonAdreno > 0)
+                        {
+                            chosenAdapterIndex = firstNonAdreno;
+                            Logger.TryGet(LogEventLevel.Warning, "OpenGL")?.Log(null,
+                                "ARM64 Adreno GPU detected; the Adreno rendering blocklist is forcing a " +
+                                "fallback to '{FallbackAdapter}' (typically a software renderer). Set " +
+                                "Win32PlatformOptions.GraphicsAdapterSelectionCallback to choose an adapter " +
+                                "explicitly, or switch Win32PlatformOptions.RenderingMode to Vulkan or Wgl.",
+                                adapters[firstNonAdreno].desc.Description);
+                        }
+                    }
 
                     chosenAdapter = adapters[chosenAdapterIndex].adapter.CloneReference();
 

From 88a1fc14e0698600b9c22034d7a0dea36c44dda5 Mon Sep 17 00:00:00 2001
From: freddiesmartbox <Freddie.Nash@thinksmartbox.com>
Date: Fri, 3 Jul 2026 09:03:19 +0100
Subject: [PATCH 062/196] Return false by default from
 FocusManager.CanHaveFocusableChildren (#21640)

* Add tests around skipping controls for FocusManager #21620

* Return false by default in CanHaveFocusableChildren #21620

Importantly, this will return false for controls that are not focusable (e.g. TextBlock) or that have no focusable childen (e.g. an empty StackPanel)

* Add skip tests for FindFirstFocusableElement and FindLastFocusableElement #21620
---
 src/Avalonia.Base/Input/FocusHelpers.cs       |   2 +-
 .../Input/InputElement_Focus.cs               | 256 ++++++++++++++++++
 2 files changed, 257 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Base/Input/FocusHelpers.cs b/src/Avalonia.Base/Input/FocusHelpers.cs
index d1b6a11b04..f8b75a4501 100644
--- a/src/Avalonia.Base/Input/FocusHelpers.cs
+++ b/src/Avalonia.Base/Input/FocusHelpers.cs
@@ -27,7 +27,7 @@ namespace Avalonia.Input
 
             var children = GetInputElementChildren(parent);
 
-            bool hasFocusChildren = true;
+            bool hasFocusChildren = false;
 
             foreach (var child in children)
             {
diff --git a/tests/Avalonia.Base.UnitTests/Input/InputElement_Focus.cs b/tests/Avalonia.Base.UnitTests/Input/InputElement_Focus.cs
index 580c80e79f..dd2d77ca82 100644
--- a/tests/Avalonia.Base.UnitTests/Input/InputElement_Focus.cs
+++ b/tests/Avalonia.Base.UnitTests/Input/InputElement_Focus.cs
@@ -772,6 +772,42 @@ namespace Avalonia.Base.UnitTests.Input
             }
         }
 
+        [Fact]
+        public void Get_First_Focusable_Element_Skips_Unfocusable_Elements()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var skip1 = new Button { Focusable = false, Content = "s1" };
+                var skip2 = new TextBlock() { Text = "s2" };
+                var skip3 = new StackPanel();
+                var target4 = new Button { Focusable = true, Content = "4" };
+                var target5 = new Button { Focusable = true, Content = "5" };
+                var container = new StackPanel
+                {
+                    Children =
+                    {
+                        skip1,
+                        skip2,
+                        skip3,
+                        target4,
+                        target5
+                    }
+                };
+                var root = new TestRoot
+                {
+                    Child = container
+                };
+
+                var firstFocusable = FocusManager.FindFirstFocusableElement(container);
+
+                Assert.Equal(target4, firstFocusable);
+
+                firstFocusable = (root.FocusManager as FocusManager)?.FindFirstFocusableElement();
+
+                Assert.Equal(target4, firstFocusable);
+            }
+        }
+
         [Fact]
         public void Can_Get_Last_Focusable_Element()
         {
@@ -806,6 +842,42 @@ namespace Avalonia.Base.UnitTests.Input
             }
         }
 
+        [Fact]
+        public void Get_Last_Focusable_Element_Skips_Unfocusable_Elements()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var target1 = new Button { Focusable = true, Content = "1" };
+                var target2 = new Button { Focusable = true, Content = "2" };
+                var skip3 = new Button { Focusable = false, Content = "s3" };
+                var skip4 = new TextBlock() { Text = "s4" };
+                var skip5 = new StackPanel();
+                var container = new StackPanel
+                {
+                    Children =
+                    {
+                        target1,
+                        target2,
+                        skip3,
+                        skip4,
+                        skip5
+                    }
+                };
+                var root = new TestRoot
+                {
+                    Child = container
+                };
+
+                var lastFocusable = FocusManager.FindLastFocusableElement(container);
+
+                Assert.Equal(target2, lastFocusable);
+
+                lastFocusable = (root.FocusManager as FocusManager)?.FindLastFocusableElement();
+
+                Assert.Equal(target2, lastFocusable);
+            }
+        }
+
         [Fact]
         public void Can_Get_Next_Element()
         {
@@ -1050,6 +1122,190 @@ namespace Avalonia.Base.UnitTests.Input
             }
         }
 
+        [Fact]
+        public void Focus_Should_Skip_Elements_With_Focusable_Equal_False()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var target1 = new Button { Focusable = true, Content = "1" };
+                var skip1 = new Button { Focusable = false, Content = "s1" };
+                var target2 = new Button { Focusable = true, Content = "2" };
+                var skip2 = new Button { Focusable = false, Content = "s2" };
+                var target3 = new Button { Focusable = true, Content = "3" };
+                var container = new StackPanel
+                {
+                    Children =
+                    {
+                        target1,
+                        skip1,
+                        target2,
+                        skip2,
+                        target3,
+                    }
+                };
+                var root = new TestRoot
+                {
+                    Child = container
+                };
+
+                var focusManager = FocusManager.GetFocusManager(container);
+                Assert.NotNull(focusManager);
+
+                var hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target1.IsFocused);
+                Assert.True(hasMoved);
+
+                hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target2.IsFocused);
+                Assert.True(hasMoved);
+
+                hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target3.IsFocused);
+                Assert.True(hasMoved);
+            }
+        }
+
+        [Fact]
+        public void Focus_Should_Skip_Elements_With_IsTabStop_Equal_False()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var target1 = new Button { Focusable = true, Content = "1" };
+                var skip1 = new Button { IsTabStop = false, Focusable = true, Content = "s1" };
+                var target2 = new Button { Focusable = true, Content = "2" };
+                var skip2 = new Button { IsTabStop = false, Focusable = true, Content = "s2" };
+                var target3 = new Button { Focusable = true, Content = "3" };
+                var container = new StackPanel
+                {
+                    Children =
+                    {
+                        target1,
+                        skip1,
+                        target2,
+                        skip2,
+                        target3,
+                    }
+                };
+                var root = new TestRoot
+                {
+                    Child = container
+                };
+
+                var focusManager = FocusManager.GetFocusManager(container);
+                Assert.NotNull(focusManager);
+
+                var hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target1.IsFocused);
+                Assert.True(hasMoved);
+
+                hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target2.IsFocused);
+                Assert.True(hasMoved);
+
+                hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target3.IsFocused);
+                Assert.True(hasMoved);
+            }
+        }
+
+        [Fact]
+        public void Focus_Should_Skip_TextBlock_Elements()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var target1 = new Button { Focusable = true, Content = "1" };
+                var skip1 = new TextBlock { Focusable = false, Text = "s1" };
+                var target2 = new Button { Focusable = true, Content = "2" };
+                var skip2 = new TextBlock { Focusable = false, Text = "s2" };
+                var target3 = new Button { Focusable = true, Content = "3" };
+                var container = new StackPanel
+                {
+                    Children =
+                    {
+                        target1,
+                        skip1,
+                        target2,
+                        skip2,
+                        target3,
+                    }
+                };
+                var root = new TestRoot
+                {
+                    Child = container
+                };
+
+                var focusManager = FocusManager.GetFocusManager(container);
+                Assert.NotNull(focusManager);
+
+                var hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target1.IsFocused);
+                Assert.True(hasMoved);
+
+                hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target2.IsFocused);
+                Assert.True(hasMoved);
+
+                hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target3.IsFocused);
+                Assert.True(hasMoved);
+            }
+        }
+
+        [Fact]
+        public void Focus_Should_Skip_Empty_Containers()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var target1 = new Button { Focusable = true, Content = "1" };
+                var skip1 = new StackPanel();
+                var target2 = new Button { Focusable = true, Content = "2" };
+                var skip2 = new StackPanel();
+                var target3 = new Button { Focusable = true, Content = "3" };
+                var container = new StackPanel
+                {
+                    Children =
+                    {
+                        target1,
+                        skip1,
+                        target2,
+                        skip2,
+                        target3,
+                    }
+                };
+                var root = new TestRoot
+                {
+                    Child = container
+                };
+
+                var focusManager = FocusManager.GetFocusManager(container);
+                Assert.NotNull(focusManager);
+
+                var hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target1.IsFocused);
+                Assert.True(hasMoved);
+
+                hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target2.IsFocused);
+                Assert.True(hasMoved);
+
+                hasMoved = focusManager.TryMoveFocus(NavigationDirection.Next);
+
+                Assert.True(target3.IsFocused);
+                Assert.True(hasMoved);
+            }
+        }
+
         [Fact]
         public void Focus_Should_Move_According_To_XY_Direction()
         {

From 0f4fb6e71a8440878a9917d7a31bdf6c22442aea Mon Sep 17 00:00:00 2001
From: Isabelle Santin <isabelle@chosenfewsoftware.com>
Date: Fri, 3 Jul 2026 03:20:24 -0500
Subject: [PATCH 063/196] Fix: TalkBack should highlight controls instead of
 their ancestors (#21654)

* Fix: TalkBack should highlight controls instead of their ancestors

* Fix: make parent controls navigable for specific types

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../Avalonia.Android/AvaloniaAccessHelper.cs  | 45 +++++++++++++++++--
 .../EmbeddableControlRootAutomationPeer.cs    |  2 +-
 2 files changed, 43 insertions(+), 4 deletions(-)

diff --git a/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs b/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
index a71e42f894..7534d8c83d 100644
--- a/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
+++ b/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
@@ -8,13 +8,42 @@ using Avalonia.Android.Automation;
 using Avalonia.Automation;
 using Avalonia.Automation.Peers;
 using Avalonia.Automation.Provider;
-using Avalonia.Controls;
 using Java.Lang;
 
 namespace Avalonia.Android
 {
     internal class AvaloniaAccessHelper : ExploreByTouchHelper
     {
+        private static readonly HashSet<AutomationControlType> s_containerTypes =
+            new HashSet<AutomationControlType>()
+            {
+                AutomationControlType.Calendar,
+                AutomationControlType.ComboBoxItem,
+                AutomationControlType.Custom,
+                AutomationControlType.DataGrid,
+                AutomationControlType.DataItem,
+                AutomationControlType.Document,
+                AutomationControlType.Expander,
+                AutomationControlType.Group,
+                AutomationControlType.List,
+                AutomationControlType.ListItem,
+                AutomationControlType.Menu,
+                AutomationControlType.MenuBar,
+                AutomationControlType.MenuItem,
+                AutomationControlType.None,
+                AutomationControlType.Pane,
+                AutomationControlType.ScrollViewer,
+                AutomationControlType.SplitButton,
+                AutomationControlType.Tab,
+                AutomationControlType.TabItem,
+                AutomationControlType.Table,
+                AutomationControlType.TitleBar,
+                AutomationControlType.ToolBar,
+                AutomationControlType.Tree,
+                AutomationControlType.TreeItem,
+                AutomationControlType.Window,
+            };
+
         private readonly Dictionary<int, AutomationPeer> _peers;
         private readonly Dictionary<AutomationPeer, int> _peerIds;
 
@@ -109,7 +138,17 @@ namespace Avalonia.Android
             AutomationPeer? peer = embeddedRootProvider?.GetPeerFromPoint(p);
             if (peer is not null)
             {
-                GetOrCreateNodeInfoProvidersFromPeer(peer, out int virtualViewId);
+                int virtualViewId;
+                if (peer.GetParent() is AutomationPeer parent && 
+                    !s_containerTypes.Contains(parent.GetAutomationControlType()))
+                {
+                    GetOrCreateNodeInfoProvidersFromPeer(parent, out virtualViewId);
+                }
+                else
+                {
+                    GetOrCreateNodeInfoProvidersFromPeer(peer, out virtualViewId);
+                }
+
                 return virtualViewId == 0 ? InvalidId : virtualViewId;
             }
             else
@@ -199,7 +238,7 @@ namespace Avalonia.Android
             nodeInfo.Enabled = peer.IsEnabled();
 
             // Control focus state
-            bool canFocusAtAll = peer.IsContentElement() && !peer.IsOffscreen();
+            bool canFocusAtAll = peer.IsControlElement() && !peer.IsOffscreen();
             nodeInfo.ScreenReaderFocusable = canFocusAtAll;
             nodeInfo.Focusable = canFocusAtAll && peer.IsKeyboardFocusable();
 
diff --git a/src/Avalonia.Controls/Automation/Peers/EmbeddableControlRootAutomationPeer.cs b/src/Avalonia.Controls/Automation/Peers/EmbeddableControlRootAutomationPeer.cs
index f15b18b7d3..1df6edf564 100644
--- a/src/Avalonia.Controls/Automation/Peers/EmbeddableControlRootAutomationPeer.cs
+++ b/src/Avalonia.Controls/Automation/Peers/EmbeddableControlRootAutomationPeer.cs
@@ -33,7 +33,7 @@ namespace Avalonia.Controls.Automation.Peers
 
         public AutomationPeer? GetPeerFromPoint(Point p)
         {
-            var hit = Owner.GetVisualAt(p)?.FindAncestorOfType<Control>();
+            var hit = Owner.GetVisualAt(p)?.FindAncestorOfType<Control>(includeSelf: true);
 
             if (hit is null)
                 return null;

From ee767d5de19b6efffc5fc7d079867932166009d8 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Fri, 3 Jul 2026 11:11:22 +0200
Subject: [PATCH 064/196] Composition-aware geometries and drawing change
 detection (#21682)

* Composition-aware geometries

* Propagate resource changes in DrawingBrush

* Change detection in Drawing

* Make IRenderDataGeometry a private API
---
 src/Avalonia.Base/CombinedGeometry.cs         |  21 ++++
 src/Avalonia.Base/Media/Drawing.cs            |  58 ++++++++-
 src/Avalonia.Base/Media/DrawingBrush.cs       |  84 ++++++++++---
 src/Avalonia.Base/Media/DrawingContext.cs     |  15 ++-
 src/Avalonia.Base/Media/DrawingGroup.cs       |  38 ++++++
 src/Avalonia.Base/Media/DrawingImage.cs       |  14 ++-
 src/Avalonia.Base/Media/Geometry.cs           |  31 ++++-
 src/Avalonia.Base/Media/GeometryCollection.cs |   7 ++
 src/Avalonia.Base/Platform/IGeometryImpl.cs   |   5 +-
 .../Brushes/ServerSimpleContentBrush.cs       |  18 ++-
 .../Drawing/IRenderDataGeometry.cs            |  20 +++
 .../Drawing/RenderDataDrawingContext.cs       |  15 ++-
 .../Drawing/RenderDataStream.Visit.cs         |   7 +-
 .../Composition/Drawing/RenderDataStream.cs   |   4 +-
 .../Drawing/ServerResourceHelperExtensions.cs |  15 ++-
 .../Server/ServerCompositionSimpleGeometry.cs |   5 +
 src/Avalonia.Base/composition-schema.xml      |   3 +
 .../Media/DrawingGroupTests.cs                |  44 +++++++
 .../Media/GeometryRenderResourceTests.cs      |  84 +++++++++++++
 .../Rendering/DrawingBrushPropagationTests.cs |  56 +++++++++
 .../Rendering/DrawingImagePropagationTests.cs |  35 ++++++
 .../SceneGraph/DrawOperationTests.cs          |   9 +-
 .../RenderDataStreamHitTestTests.cs           |   2 +
 .../SceneGraph/RenderDataStreamTests.cs       |   5 +-
 .../Media/DrawingContentTests.cs              | 114 ++++++++++++++++++
 ...Reflects_Replaced_Inner_Brush.expected.png | Bin 0 -> 329 bytes
 ...Reflects_Replaced_Inner_Brush.expected.png | Bin 0 -> 329 bytes
 27 files changed, 671 insertions(+), 38 deletions(-)
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Drawing/IRenderDataGeometry.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionSimpleGeometry.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/Media/GeometryRenderResourceTests.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/Rendering/DrawingBrushPropagationTests.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/Rendering/DrawingImagePropagationTests.cs
 create mode 100644 tests/Avalonia.RenderTests/Media/DrawingContentTests.cs
 create mode 100644 tests/TestFiles/Skia/Media/DrawingContent/DrawingBrush_Reflects_Replaced_Inner_Brush.expected.png
 create mode 100644 tests/TestFiles/Skia/Media/DrawingContent/DrawingImage_Reflects_Replaced_Inner_Brush.expected.png

diff --git a/src/Avalonia.Base/CombinedGeometry.cs b/src/Avalonia.Base/CombinedGeometry.cs
index a47e756c88..d7297b3749 100644
--- a/src/Avalonia.Base/CombinedGeometry.cs
+++ b/src/Avalonia.Base/CombinedGeometry.cs
@@ -55,6 +55,11 @@ namespace Avalonia.Media
         public static readonly StyledProperty<GeometryCombineMode> GeometryCombineModeProperty =
             AvaloniaProperty.Register<CombinedGeometry, GeometryCombineMode>(nameof(GeometryCombineMode));
 
+        static CombinedGeometry()
+        {
+            AffectsGeometry(Geometry1Property, Geometry2Property, GeometryCombineModeProperty);
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="CombinedGeometry"/> class.
         /// </summary>
@@ -145,6 +150,22 @@ namespace Avalonia.Media
             return new CombinedGeometry(GeometryCombineMode, Geometry1, Geometry2, Transform);
         }
 
+        protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+        {
+            base.OnPropertyChanged(change);
+
+            if (change.Property == Geometry1Property || change.Property == Geometry2Property)
+            {
+                var (oldValue, newValue) = change.GetOldAndNewValue<Geometry?>();
+
+                oldValue?.Changed -= ChildGeometryChanged;
+                newValue?.Changed += ChildGeometryChanged;
+            }
+        }
+
+        private void ChildGeometryChanged(object? sender, EventArgs e)
+            => InvalidateGeometry();
+
         private protected sealed override IGeometryImpl? CreateDefiningGeometry()
         {
             var g1 = Geometry1;
diff --git a/src/Avalonia.Base/Media/Drawing.cs b/src/Avalonia.Base/Media/Drawing.cs
index 584e5978fc..f754eb5bfa 100644
--- a/src/Avalonia.Base/Media/Drawing.cs
+++ b/src/Avalonia.Base/Media/Drawing.cs
@@ -1,4 +1,6 @@
-namespace Avalonia.Media
+using System;
+
+namespace Avalonia.Media
 {
     /// <summary>
     /// Abstract class that describes a 2-D drawing.
@@ -7,9 +9,16 @@
     {
         internal Drawing()
         {
-            
         }
-        
+
+        /// <summary>
+        /// Raised when the drawing changes in a way that requires its consumer to re-record it: a referenced resource
+        /// is replaced (e.g. a new brush, pen, geometry or child), or a value that is baked into the recorded drawing
+        /// commands changes (e.g. a transform, opacity or effect). Mutations _within_ a referenced compositor-aware
+        /// resource (a brush's color, a geometry's shape) are not signaled here: the compositor propagates those on its own.
+        /// </summary>
+        internal event EventHandler? Invalidated;
+
         /// <summary>
         /// Draws this drawing to the given <see cref="DrawingContext"/>.
         /// </summary>
@@ -22,5 +31,48 @@
         /// Gets the drawing's bounding rectangle.
         /// </summary>
         public abstract Rect GetBounds();
+
+        private protected void RaiseInvalidated()
+            => Invalidated?.Invoke(this, EventArgs.Empty);
+
+        protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+        {
+            base.OnPropertyChanged(change);
+
+            // Every property of a drawing is baked into the recorded drawing commands or selects which resource is used,
+            // so any change requires a re-record. Keep subscriptions to nested values whose _own_ changes are also baked
+            // (and thus can't be propagated by the compositor) in sync.
+            UpdateValueSubscription(change.OldValue, subscribe: false);
+            UpdateValueSubscription(change.NewValue, subscribe: true);
+
+            RaiseInvalidated();
+        }
+
+        private void UpdateValueSubscription(object? value, bool subscribe)
+        {
+            switch (value)
+            {
+                // A transform's matrix is baked into the recorded commands, so its value changes (not just its
+                // replacement) require a re-record.
+                case Transform transform:
+                    if (subscribe)
+                        transform.Changed += ValueInvalidated;
+                    else
+                        transform.Changed -= ValueInvalidated;
+                    break;
+
+                // Effects are baked as immutable, and nested image sources (e.g. a DrawingImage) are inlined,
+                // so their visual changes require a re-record too.
+                case IAffectsRender affectsRender:
+                    if (subscribe)
+                        affectsRender.Invalidated += ValueInvalidated;
+                    else
+                        affectsRender.Invalidated -= ValueInvalidated;
+                    break;
+            }
+
+            void ValueInvalidated(object? sender, EventArgs e)
+                => RaiseInvalidated();
+        }
     }
 }
diff --git a/src/Avalonia.Base/Media/DrawingBrush.cs b/src/Avalonia.Base/Media/DrawingBrush.cs
index c4e5dc8d13..c1e0900ae5 100644
--- a/src/Avalonia.Base/Media/DrawingBrush.cs
+++ b/src/Avalonia.Base/Media/DrawingBrush.cs
@@ -1,6 +1,4 @@
 using System;
-using Avalonia.Media.Immutable;
-using Avalonia.Rendering;
 using Avalonia.Rendering.Composition;
 using Avalonia.Rendering.Composition.Drawing;
 using Avalonia.Rendering.Composition.Server;
@@ -19,7 +17,7 @@ namespace Avalonia.Media
         /// </summary>
         public static readonly StyledProperty<Drawing?> DrawingProperty =
             AvaloniaProperty.Register<DrawingBrush, Drawing?>(nameof(Drawing));
-        
+
         /// <summary>
         /// Initializes a new instance of the <see cref="DrawingBrush"/> class.
         /// </summary>
@@ -49,7 +47,7 @@ namespace Avalonia.Media
         {
             if (Drawing == null)
                 return null;
-            
+
             using var recorder = new RenderDataDrawingContext(null);
             Drawing?.Draw(recorder);
             return recorder.GetImmediateSceneBrushContent(this, null, true);
@@ -58,38 +56,84 @@ namespace Avalonia.Media
         internal override Func<Compositor, ServerCompositionSimpleBrush> Factory =>
             static c => new ServerCompositionSimpleContentBrush(c.Server);
 
-        private InlineDictionary<Compositor, CompositionRenderData?> _renderDataDictionary;
-
-        private protected override void OnReferencedFromCompositor(Compositor c)
+        private sealed class RenderDataItem(CompositionRenderData data) : IDisposable
         {
-            _renderDataDictionary.Add(c, CreateServerContent(c));
-            base.OnReferencedFromCompositor(c);
+            public CompositionRenderData Data { get; } = data;
+            public bool IsDirty;
+            public void Dispose() => Data.Dispose();
         }
 
+        private InlineDictionary<Compositor, RenderDataItem?> _renderDataDictionary;
+
         protected override void OnUnreferencedFromCompositor(Compositor c)
         {
             if (_renderDataDictionary.TryGetAndRemoveValue(c, out var content))
                 content?.Dispose();
             base.OnUnreferencedFromCompositor(c);
         }
-        
+
         private protected override void SerializeChanges(Compositor c, BatchStreamWriter writer)
         {
             base.SerializeChanges(c, writer);
-            if (_renderDataDictionary.TryGetValue(c, out var content) && content != null)
-                writer.WriteObject(new CompositionRenderDataSceneBrushContent.Properties(content.Server, null, true));
-            else
-                writer.WriteObject(null);
+
+            CompositionRenderDataSceneBrushContent.Properties? content = null;
+            if (IsOnCompositor(c)) // Should always be true here, but just in case do this check
+            {
+                _renderDataDictionary.TryGetValue(c, out var data);
+                if (data is null || data.IsDirty)
+                {
+                    var created = CreateServerContent(c);
+                    // Dispose the old render list _after_ creating a new one to avoid unnecessary detach/attach
+                    // sequence for referenced resources
+                    data?.Dispose();
+                    _renderDataDictionary[c] = data = created;
+                }
+
+                if (data is not null)
+                    content = new(data.Data.Server, null, true);
+            }
+
+            writer.WriteObject(content);
         }
-        
-        CompositionRenderData? CreateServerContent(Compositor c)
+
+        private void InvalidateContent()
         {
-            if (Drawing == null)
+            foreach (var item in _renderDataDictionary)
+                item.Value?.IsDirty = true;
+
+            RegisterForSerialization();
+        }
+
+        protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+        {
+            // Replacing the drawing, or a structural change inside it (e.g. a replaced brush, pen or geometry) changes
+            // the recorded content; mark it dirty so it's re-recorded. Mutations _within_ a referenced compositor-aware
+            // resource (a brush's color, a geometry's shape) are propagated by the server without re-recording.
+            if (change.Property == DrawingProperty)
+            {
+                var (oldValue, newValue) = change.GetOldAndNewValue<Drawing?>();
+
+                oldValue?.Invalidated -= DrawingInvalidated;
+                newValue?.Invalidated += DrawingInvalidated;
+
+                InvalidateContent();
+            }
+
+            base.OnPropertyChanged(change);
+
+            void DrawingInvalidated(object? sender, EventArgs e)
+                => InvalidateContent();
+        }
+
+        private RenderDataItem? CreateServerContent(Compositor c)
+        {
+            if (Drawing is not { } drawing)
                 return null;
-            
+
             using var recorder = new RenderDataDrawingContext(c);
-            Drawing?.Draw(recorder);
-            return recorder.GetRenderResults();
+            drawing.Draw(recorder);
+            var renderData = recorder.GetRenderResults();
+            return renderData is null ? null : new RenderDataItem(renderData);
         }
     }
 }
diff --git a/src/Avalonia.Base/Media/DrawingContext.cs b/src/Avalonia.Base/Media/DrawingContext.cs
index 8003fb7c32..d3b43f1b8b 100644
--- a/src/Avalonia.Base/Media/DrawingContext.cs
+++ b/src/Avalonia.Base/Media/DrawingContext.cs
@@ -90,8 +90,19 @@ namespace Avalonia.Media
         /// <param name="geometry">The geometry.</param>
         public void DrawGeometry(IBrush? brush, IPen? pen, Geometry geometry)
         {
-            if ((brush != null || PenIsVisible(pen)) && geometry.PlatformImpl != null)
-                DrawGeometryCore(brush, pen, geometry.PlatformImpl);
+            if (brush != null || PenIsVisible(pen))
+                DrawGeometryCore(brush, pen, geometry);
+        }
+
+        /// <summary>
+        /// Draws a mutable geometry. Implementations that support compositor-aware resources can keep a reference to
+        /// the <see cref="Geometry"/> so that subsequent changes to it are propagated without re-recording.
+        /// The default implementation simply forwards the geometry's current <see cref="Geometry.PlatformImpl"/>.
+        /// </summary>
+        protected virtual void DrawGeometryCore(IBrush? brush, IPen? pen, Geometry geometry)
+        {
+            if (geometry.PlatformImpl is { } geometryImpl)
+                DrawGeometryCore(brush, pen, geometryImpl);
         }
         
         /// <summary>
diff --git a/src/Avalonia.Base/Media/DrawingGroup.cs b/src/Avalonia.Base/Media/DrawingGroup.cs
index b2181d74fb..1b9157751b 100644
--- a/src/Avalonia.Base/Media/DrawingGroup.cs
+++ b/src/Avalonia.Base/Media/DrawingGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using Avalonia.Metadata;
 using Avalonia.Platform;
 using Avalonia.Rendering.SceneGraph;
@@ -35,6 +36,9 @@ namespace Avalonia.Media
 
         private DrawingCollection _children = new DrawingCollection();
 
+        public DrawingGroup()
+            => _children.CollectionChanged += ChildrenCollectionChanged;
+
         public double Opacity
         {
             get => GetValue(OpacityProperty);
@@ -81,12 +85,46 @@ namespace Avalonia.Media
             get => _children;
             set
             {
+                if (ReferenceEquals(_children, value))
+                    return;
+
+                _children.CollectionChanged -= ChildrenCollectionChanged;
+                foreach (var child in _children)
+                    child.Invalidated -= ChildInvalidated;
+
                 SetAndRaise(ChildrenProperty, ref _children, value);
+
+                _children.CollectionChanged += ChildrenCollectionChanged;
+                foreach (var child in _children)
+                    child.Invalidated += ChildInvalidated;
             }
         }
 
         public DrawingContext Open() => new DrawingGroupDrawingContext(this);
 
+        private void ChildrenCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+        {
+            if (e.Action == NotifyCollectionChangedAction.Reset)
+                throw new NotSupportedException();
+
+            if (e.OldItems is not null)
+            {
+                foreach (Drawing child in e.OldItems)
+                    child.Invalidated -= ChildInvalidated;
+            }
+
+            if (e.NewItems is not null)
+            {
+                foreach (Drawing child in e.NewItems)
+                    child.Invalidated += ChildInvalidated;
+            }
+
+            RaiseInvalidated();
+        }
+
+        private void ChildInvalidated(object? sender, EventArgs e)
+            => RaiseInvalidated();
+
         internal override void DrawCore(DrawingContext context)
         {
             // Compute local bounds from children only when EffectBounds is not explicitly set.
diff --git a/src/Avalonia.Base/Media/DrawingImage.cs b/src/Avalonia.Base/Media/DrawingImage.cs
index 7949eaa351..d34f1d5379 100644
--- a/src/Avalonia.Base/Media/DrawingImage.cs
+++ b/src/Avalonia.Base/Media/DrawingImage.cs
@@ -98,10 +98,22 @@ namespace Avalonia.Media
         {
             base.OnPropertyChanged(change);
 
-            if (change.Property == DrawingProperty || change.Property == ViewboxProperty)
+            if (change.Property == DrawingProperty)
+            {
+                var (oldValue, newValue) = change.GetOldAndNewValue<Drawing?>();
+
+                oldValue?.Invalidated -= DrawingInvalidated;
+                newValue?.Invalidated += DrawingInvalidated;
+
+                RaiseInvalidated(EventArgs.Empty);
+            }
+            else if (change.Property == ViewboxProperty)
             {
                 RaiseInvalidated(EventArgs.Empty);
             }
+
+            void DrawingInvalidated(object? sender, EventArgs e)
+                => RaiseInvalidated(EventArgs.Empty);
         }
 
         /// <summary>
diff --git a/src/Avalonia.Base/Media/Geometry.cs b/src/Avalonia.Base/Media/Geometry.cs
index 87b7c147d7..8082c2e71a 100644
--- a/src/Avalonia.Base/Media/Geometry.cs
+++ b/src/Avalonia.Base/Media/Geometry.cs
@@ -4,6 +4,10 @@ using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using Avalonia.Reactive;
+using Avalonia.Rendering.Composition;
+using Avalonia.Rendering.Composition.Drawing;
+using Avalonia.Rendering.Composition.Server;
+using Avalonia.Rendering.Composition.Transport;
 
 
 namespace Avalonia.Media
@@ -12,7 +16,10 @@ namespace Avalonia.Media
     /// Defines a geometric shape.
     /// </summary>
     [TypeConverter(typeof(GeometryTypeConverter))]
-    public abstract class Geometry : AvaloniaObject
+    public abstract class Geometry :
+        AvaloniaObject,
+        ICompositionRenderResource<ServerCompositionSimpleGeometry>,
+        ICompositorSerializable
     {
         /// <summary>
         /// Defines the <see cref="Transform"/> property.
@@ -168,6 +175,7 @@ namespace Avalonia.Media
 
             _isDirty = true;
             _platformImpl = null;
+            RegisterForSerialization();
             Changed?.Invoke(this, EventArgs.Empty);
         }
 
@@ -209,6 +217,7 @@ namespace Avalonia.Media
                 _platformImpl = _platformImpl.WithTransform(transform.Value);
             }
 
+            RegisterForSerialization();
             Changed?.Invoke(this, EventArgs.Empty);
         }
 
@@ -297,6 +306,26 @@ namespace Avalonia.Media
             segmentGeometry = new PlatformGeometry(segment);
             return true;
         }
+
+        private CompositorResourceHolder<ServerCompositionSimpleGeometry> _resource;
+
+        private protected void RegisterForSerialization()
+            => _resource.RegisterForInvalidationOnAllCompositors(this);
+
+        ServerCompositionSimpleGeometry ICompositionRenderResource<ServerCompositionSimpleGeometry>.GetForCompositor(Compositor c)
+            => _resource.GetForCompositor(c);
+
+        void ICompositionRenderResource.AddRefOnCompositor(Compositor c)
+            => _resource.CreateOrAddRef(c, this, out _, static c => new ServerCompositionSimpleGeometry(c.Server));
+
+        void ICompositionRenderResource.ReleaseOnCompositor(Compositor c)
+            => _resource.Release(c);
+
+        SimpleServerObject? ICompositorSerializable.TryGetServer(Compositor c)
+            => _resource.TryGetForCompositor(c);
+
+        void ICompositorSerializable.SerializeChanges(Compositor c, BatchStreamWriter writer)
+            => ServerCompositionSimpleGeometry.SerializeAllChanges(writer, PlatformImpl);
     }
 
     public class GeometryTypeConverter : TypeConverter
diff --git a/src/Avalonia.Base/Media/GeometryCollection.cs b/src/Avalonia.Base/Media/GeometryCollection.cs
index 2afa191dcf..3f2732943b 100644
--- a/src/Avalonia.Base/Media/GeometryCollection.cs
+++ b/src/Avalonia.Base/Media/GeometryCollection.cs
@@ -15,10 +15,12 @@ namespace Avalonia.Media
             this.ForEachItem(
                x =>
                {
+                   x.Changed += ChildChanged;
                    Parent?.Invalidate();
                },
                x =>
                {
+                   x.Changed -= ChildChanged;
                    Parent?.Invalidate();
                },
                () => throw new NotSupportedException());
@@ -31,15 +33,20 @@ namespace Avalonia.Media
             this.ForEachItem(
                x =>
                {
+                   x.Changed += ChildChanged;
                    Parent?.Invalidate();
                },
                x =>
                {
+                   x.Changed -= ChildChanged;
                    Parent?.Invalidate();
                },
                () => throw new NotSupportedException());
         }
 
         public GeometryGroup? Parent { get; set; }
+
+        private void ChildChanged(object? sender, EventArgs e)
+            => Parent?.Invalidate();
     }
 }
diff --git a/src/Avalonia.Base/Platform/IGeometryImpl.cs b/src/Avalonia.Base/Platform/IGeometryImpl.cs
index 0d1e7b972c..0e74f1e4c5 100644
--- a/src/Avalonia.Base/Platform/IGeometryImpl.cs
+++ b/src/Avalonia.Base/Platform/IGeometryImpl.cs
@@ -1,6 +1,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Avalonia.Media;
 using Avalonia.Metadata;
+using Avalonia.Rendering.Composition.Drawing;
 
 namespace Avalonia.Platform
 {
@@ -8,8 +9,10 @@ namespace Avalonia.Platform
     /// Defines the platform-specific interface for a <see cref="Geometry"/>.
     /// </summary>
     [Unstable]
-    public interface IGeometryImpl
+    public interface IGeometryImpl : IRenderDataGeometry
     {
+        IGeometryImpl IRenderDataGeometry.GeometryImpl => this;
+
         /// <summary>
         /// Gets the geometry's bounding rectangle.
         /// </summary>
diff --git a/src/Avalonia.Base/Rendering/Composition/Brushes/ServerSimpleContentBrush.cs b/src/Avalonia.Base/Rendering/Composition/Brushes/ServerSimpleContentBrush.cs
index 673804f7bd..2ff9f66787 100644
--- a/src/Avalonia.Base/Rendering/Composition/Brushes/ServerSimpleContentBrush.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Brushes/ServerSimpleContentBrush.cs
@@ -8,7 +8,7 @@ namespace Avalonia.Rendering.Composition.Server;
 internal sealed class ServerCompositionSimpleContentBrush : ServerCompositionSimpleTileBrush, ITileBrush, ISceneBrush
 {
     private CompositionRenderDataSceneBrushContent.Properties? _content;
-    
+
 
     internal ServerCompositionSimpleContentBrush(ServerCompositor compositor) : base(compositor)
     {
@@ -22,6 +22,20 @@ internal sealed class ServerCompositionSimpleContentBrush : ServerCompositionSim
     protected override void DeserializeChangesCore(BatchStreamReader reader, TimeSpan committedAt)
     {
         base.DeserializeChangesCore(reader, committedAt);
-        _content = reader.ReadObject<CompositionRenderDataSceneBrushContent.Properties?>();
+        var content = reader.ReadObject<CompositionRenderDataSceneBrushContent.Properties?>();
+
+        if (!ReferenceEquals(_content?.RenderData, content?.RenderData))
+        {
+            _content?.RenderData.RemoveObserver(this);
+            content?.RenderData.AddObserver(this);
+        }
+
+        _content = content;
+    }
+
+    public override void Dispose()
+    {
+        _content?.RenderData.RemoveObserver(this);
+        base.Dispose();
     }
 }
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/IRenderDataGeometry.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/IRenderDataGeometry.cs
new file mode 100644
index 0000000000..a7c7a6543e
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/IRenderDataGeometry.cs
@@ -0,0 +1,20 @@
+using Avalonia.Metadata;
+using Avalonia.Platform;
+
+namespace Avalonia.Rendering.Composition.Drawing;
+
+/// <summary>
+/// Common abstraction for a geometry to render.
+/// It is implemented by both the immutable platform <see cref="IGeometryImpl"/> (which returns itself)
+/// and the compositor-aware <see cref="Server.ServerCompositionSimpleGeometry"/> server resource
+/// (which returns its current, mutable backing geometry). This lets the render data stay strongly typed
+/// while still resolving to the concrete <see cref="IGeometryImpl"/> that platform drawing contexts require.
+/// </summary>
+[PrivateApi]
+public interface IRenderDataGeometry
+{
+    /// <summary>
+    /// The underlying immutable platform geometry, or <c>null</c> when there's nothing to draw.
+    /// </summary>
+    IGeometryImpl? GeometryImpl { get; }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs
index 2472d69f08..abe210e3c5 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs
@@ -103,6 +103,18 @@ internal class RenderDataDrawingContext : DrawingContext
         Stream.DrawGeometry(brush.GetServer(_compositor), pen.GetServer(_compositor), pen, geometry);
     }
 
+    protected override void DrawGeometryCore(IBrush? brush, IPen? pen, Geometry geometry)
+    {
+        if (brush is null && pen is null)
+            return;
+
+        AddResource(brush);
+        AddResource(pen);
+        AddResource(geometry);
+
+        Stream.DrawGeometry(brush.GetServer(_compositor), pen.GetServer(_compositor), pen, geometry.GetServer(_compositor));
+    }
+
     protected override void DrawRectangleCore(IBrush? brush, IPen? pen, RoundedRect rrect, BoxShadows boxShadows = default)
     {
         if (rrect.IsEmpty())
@@ -164,8 +176,9 @@ internal class RenderDataDrawingContext : DrawingContext
             return;
         }
 
+        AddResource(clip);
         var before = Stream.OpcodeLength;
-        Stream.PushGeometryClip(clip.PlatformImpl);
+        Stream.PushGeometryClip(clip.GetServer(_compositor));
         PushedScope(before);
     }
 
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Visit.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Visit.cs
index 370a79403c..7bb848495a 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Visit.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.Visit.cs
@@ -69,7 +69,7 @@ internal partial class RenderDataStream
                             (IBrush?)_resources[p.ServerBrush],
                             (IPen?)_resources[p.ServerPen],
                             (IPen?)_resources[p.ClientPen],
-                            (IGeometryImpl?)_resources[p.Geometry]);
+                            GetGeometryImpl(_resources[p.Geometry]));
                         break;
                     }
                     case RenderDataOpcode.DrawGlyphRun:
@@ -103,7 +103,7 @@ internal partial class RenderDataStream
                     case RenderDataOpcode.PushGeometryClip:
                     {
                         var p = reader.ReadPayload<PushGeometryClipPayload>();
-                        scopes[depth++] = visitor.OnPushGeometryClip((IGeometryImpl?)_resources[p.Geometry]);
+                        scopes[depth++] = visitor.OnPushGeometryClip(GetGeometryImpl(_resources[p.Geometry]));
                         break;
                     }
                     case RenderDataOpcode.PushOpacity:
@@ -174,4 +174,7 @@ internal partial class RenderDataStream
             rest[i] = reader.Read<BoxShadow>();
         return new BoxShadows(first, rest);
     }
+
+    private static IGeometryImpl? GetGeometryImpl(object? resource)
+        => ((IRenderDataGeometry?)resource)?.GeometryImpl;
 }
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.cs
index 910043ffea..ddfeae4251 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.cs
@@ -93,7 +93,7 @@ internal partial class RenderDataStream : IDisposable
         });
     }
 
-    public void DrawGeometry(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, IGeometryImpl? geometry)
+    public void DrawGeometry(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, IRenderDataGeometry? geometry)
     {
         _writer.WritePayload(new DrawGeometryPayload
         {
@@ -138,7 +138,7 @@ internal partial class RenderDataStream : IDisposable
         EnterScope();
     }
 
-    public void PushGeometryClip(IGeometryImpl? geometry)
+    public void PushGeometryClip(IRenderDataGeometry? geometry)
     {
         _writer.WritePayload(new PushGeometryClipPayload { Geometry = _resources.Intern(geometry) });
         EnterScope();
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs
index 2a6971e8ea..6fb646cd23 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs
@@ -3,6 +3,7 @@ using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using Avalonia.Media;
 using Avalonia.Media.Immutable;
+using Avalonia.Rendering.Composition.Server;
 
 namespace Avalonia.Rendering.Composition.Drawing;
 
@@ -52,4 +53,16 @@ static class ServerResourceHelperExtensions
             resource.GetForCompositor(compositor);
         return new ImmutableTransform(transform.Value);
     }
-}
\ No newline at end of file
+
+    public static IRenderDataGeometry? GetServer(this Geometry? geometry, Compositor? compositor)
+    {
+        if (geometry == null)
+            return null;
+        if (compositor == null)
+            return geometry.PlatformImpl;
+        if (geometry is ICompositionRenderResource<ServerCompositionSimpleGeometry> resource)
+            return resource.GetForCompositor(compositor);
+        ThrowNotCompatible(geometry);
+        return null;
+    }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionSimpleGeometry.cs b/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionSimpleGeometry.cs
new file mode 100644
index 0000000000..7b7ca2e7b5
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionSimpleGeometry.cs
@@ -0,0 +1,5 @@
+using Avalonia.Rendering.Composition.Drawing;
+
+namespace Avalonia.Rendering.Composition.Server;
+
+internal partial class ServerCompositionSimpleGeometry : IRenderDataGeometry;
diff --git a/src/Avalonia.Base/composition-schema.xml b/src/Avalonia.Base/composition-schema.xml
index 442d0c9197..460e402572 100644
--- a/src/Avalonia.Base/composition-schema.xml
+++ b/src/Avalonia.Base/composition-schema.xml
@@ -82,6 +82,9 @@
         <Property Name="MiterLimit" Type="double" />
         <Property Name="Thickness" Type="double" />
     </Object>
+    <Object Name="CompositionSimpleGeometry" Internal="true" ServerOnly="true" ServerBase="SimpleServerRenderResource">
+        <Property Name="GeometryImpl" Type="Avalonia.Platform.IGeometryImpl?" />
+    </Object>
     <Object Name="CompositionSimpleBrush" Internal="true" ServerOnly="true" ServerBase="SimpleServerRenderResource">
         <Property Name="Opacity" Type="double" />
         <Property Name="TransformOrigin" Type="RelativePoint" />
diff --git a/tests/Avalonia.Base.UnitTests/Media/DrawingGroupTests.cs b/tests/Avalonia.Base.UnitTests/Media/DrawingGroupTests.cs
index ccabf7303f..4fbce0c2ac 100644
--- a/tests/Avalonia.Base.UnitTests/Media/DrawingGroupTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Media/DrawingGroupTests.cs
@@ -110,6 +110,50 @@ public class DrawingGroupTests
         }
     }
 
+    [Fact]
+    public void Invalidated_Is_Raised_When_Child_Is_Added_Or_Removed()
+    {
+        var group = new DrawingGroup();
+        var child = new GeometryDrawing();
+        var count = 0;
+        group.Invalidated += (_, _) => count++;
+
+        group.Children.Add(child);
+        Assert.Equal(1, count);
+
+        group.Children.Remove(child);
+        Assert.Equal(2, count);
+    }
+
+    [Fact]
+    public void Invalidated_Is_Raised_When_Child_Changes()
+    {
+        var child = new GeometryDrawing();
+        var group = new DrawingGroup();
+        group.Children.Add(child);
+
+        var count = 0;
+        group.Invalidated += (_, _) => count++;
+
+        child.Brush = Brushes.Red;
+        Assert.True(count > 0);
+    }
+
+    [Fact]
+    public void Removed_Child_Is_No_Longer_Tracked()
+    {
+        var child = new GeometryDrawing();
+        var group = new DrawingGroup();
+        group.Children.Add(child);
+        group.Children.Remove(child);
+
+        var count = 0;
+        group.Invalidated += (_, _) => count++;
+
+        child.Brush = Brushes.Red;
+        Assert.Equal(0, count);
+    }
+
     private class MockDrawingContext : DrawingContext
     {
         public IEffect? Effect { get; private set; }
diff --git a/tests/Avalonia.Base.UnitTests/Media/GeometryRenderResourceTests.cs b/tests/Avalonia.Base.UnitTests/Media/GeometryRenderResourceTests.cs
new file mode 100644
index 0000000000..767f545689
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Media/GeometryRenderResourceTests.cs
@@ -0,0 +1,84 @@
+using Avalonia.Media;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Media;
+
+public class GeometryRenderResourceTests
+{
+    [Fact]
+    public void Changing_Geometry_Property_Raises_Invalidated()
+    {
+        var target = new EllipseGeometry(new Rect(0, 0, 10, 10));
+
+        RenderResourceTestHelper.AssertResourceInvalidation(
+            target,
+            () => target.Rect = new Rect(0, 0, 20, 20));
+    }
+
+    [Fact]
+    public void Changing_Transform_Raises_Invalidated()
+    {
+        var target = new EllipseGeometry(new Rect(0, 0, 10, 10));
+
+        RenderResourceTestHelper.AssertResourceInvalidation(
+            target,
+            () => target.Transform = new TranslateTransform(5, 5));
+    }
+
+    [Fact]
+    public void Changing_Transform_Value_Raises_Invalidated()
+    {
+        var transform = new TranslateTransform(5, 5);
+        var target = new EllipseGeometry(new Rect(0, 0, 10, 10)) { Transform = transform };
+
+        RenderResourceTestHelper.AssertResourceInvalidation(
+            target,
+            () => transform.X = 10);
+    }
+
+    [Fact]
+    public void Adding_Child_To_GeometryGroup_Raises_Invalidated()
+    {
+        var target = new GeometryGroup();
+
+        RenderResourceTestHelper.AssertResourceInvalidation(
+            target,
+            () => target.Children.Add(new EllipseGeometry(new Rect(0, 0, 10, 10))));
+    }
+
+    [Fact]
+    public void Changing_Child_Of_GeometryGroup_Raises_Invalidated()
+    {
+        var child = new EllipseGeometry(new Rect(0, 0, 10, 10));
+        var target = new GeometryGroup();
+        target.Children.Add(child);
+
+        RenderResourceTestHelper.AssertResourceInvalidation(
+            target,
+            () => child.Rect = new Rect(0, 0, 20, 20));
+    }
+
+    [Fact]
+    public void Changing_Geometry1_Of_CombinedGeometry_Raises_Invalidated()
+    {
+        var geometry1 = new EllipseGeometry(new Rect(0, 0, 10, 10));
+        var geometry2 = new RectangleGeometry(new Rect(5, 5, 10, 10));
+        var target = new CombinedGeometry(GeometryCombineMode.Union, geometry1, geometry2);
+
+        RenderResourceTestHelper.AssertResourceInvalidation(
+            target,
+            () => geometry1.Rect = new Rect(0, 0, 20, 20));
+    }
+
+    [Fact]
+    public void Changing_CombineMode_Of_CombinedGeometry_Raises_Invalidated()
+    {
+        var geometry1 = new EllipseGeometry(new Rect(0, 0, 10, 10));
+        var geometry2 = new RectangleGeometry(new Rect(5, 5, 10, 10));
+        var target = new CombinedGeometry(GeometryCombineMode.Union, geometry1, geometry2);
+
+        RenderResourceTestHelper.AssertResourceInvalidation(
+            target,
+            () => target.GeometryCombineMode = GeometryCombineMode.Intersect);
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/DrawingBrushPropagationTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/DrawingBrushPropagationTests.cs
new file mode 100644
index 0000000000..7a3b11f0f4
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Rendering/DrawingBrushPropagationTests.cs
@@ -0,0 +1,56 @@
+using Avalonia.Controls;
+using Avalonia.Media;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Rendering;
+
+public class DrawingBrushPropagationTests : CompositorTestsBase
+{
+    private static Border CreateBorder(DrawingBrush brush) => new()
+    {
+        Background = brush,
+        Width = 20,
+        Height = 10,
+        [Canvas.LeftProperty] = 30,
+        [Canvas.TopProperty] = 50
+    };
+
+    [Fact]
+    public void Mutating_Geometry_Inside_DrawingBrush_Invalidates_Consumer()
+    {
+        using var services = new CompositorCanvas();
+
+        var geometry = new RectangleGeometry(new Rect(0, 0, 20, 10));
+        var brush = new DrawingBrush(new GeometryDrawing { Brush = Brushes.Red, Geometry = geometry });
+        services.Canvas.Children.Add(CreateBorder(brush));
+        services.RunJobs();
+        services.Events.Rects.Clear();
+
+        geometry.Rect = new Rect(0, 0, 30, 15);
+
+        services.AssertRects(new Rect(30, 50, 20, 10));
+    }
+
+    [Fact]
+    public void Replacing_Drawing_Invalidates_Consumer()
+    {
+        using var services = new CompositorCanvas();
+
+        var brush = new DrawingBrush(new GeometryDrawing
+        {
+            Brush = Brushes.Red,
+            Geometry = new RectangleGeometry(new Rect(0, 0, 20, 10))
+        });
+        services.Canvas.Children.Add(CreateBorder(brush));
+        services.RunJobs();
+        services.Events.Rects.Clear();
+
+        brush.Drawing = new GeometryDrawing
+        {
+            Brush = Brushes.Blue,
+            Geometry = new RectangleGeometry(new Rect(0, 0, 20, 10))
+        };
+
+        services.AssertRects(new Rect(30, 50, 20, 10));
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/DrawingImagePropagationTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/DrawingImagePropagationTests.cs
new file mode 100644
index 0000000000..18fff7a86a
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Rendering/DrawingImagePropagationTests.cs
@@ -0,0 +1,35 @@
+using Avalonia.Controls;
+using Avalonia.Media;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Rendering;
+
+public class DrawingImagePropagationTests : CompositorTestsBase
+{
+    private static Image CreateImage(DrawingImage image) => new()
+    {
+        Source = image,
+        Width = 20,
+        Height = 10,
+        [Canvas.LeftProperty] = 30,
+        [Canvas.TopProperty] = 50
+    };
+
+    [Fact]
+    public void Mutating_Geometry_Inside_DrawingImage_Invalidates_Consumer()
+    {
+        using var services = new CompositorCanvas();
+
+        var geometry = new RectangleGeometry(new Rect(0, 0, 20, 10));
+        var image = new DrawingImage(new GeometryDrawing { Brush = Brushes.Red, Geometry = geometry });
+        services.Canvas.Children.Add(CreateImage(image));
+        services.RunJobs();
+        services.Events.Rects.Clear();
+
+        geometry.Rect = new Rect(0, 0, 30, 15);
+
+        services.AssertRects(
+            new Rect(30, 50, 20, 10),
+            new Rect(30, 50, 30, 15));
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
index 7ee04c32ad..a0ff9f2134 100644
--- a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
@@ -120,7 +120,12 @@ namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
         {
             var ctx = new TestContext(_services);
             using (ctx.Context.PushTransform(new Matrix()))
-                ctx.Context.DrawGeometry(Brushes.Black, null, Mock.Of<IGeometryImpl>());
+            {
+                var geometry = new Mock<IGeometryImpl>();
+                geometry.Setup(g => g.GeometryImpl).Returns(geometry.Object);
+                ctx.Context.DrawGeometry(Brushes.Black, null, geometry.Object);
+            }
+
             Assert.False(ctx.Context.GetRenderResults()!.HitTest(default));
         }
 
@@ -405,6 +410,7 @@ namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
         public void Geometry_Node_HitTest_Uses_FillContains_When_Brush_Set()
         {
             var geomMock = new Mock<IGeometryImpl>();
+            geomMock.Setup(g => g.GeometryImpl).Returns(geomMock.Object);
             geomMock.Setup(g => g.FillContains(new Point(5, 5))).Returns(true);
             geomMock.Setup(g => g.FillContains(new Point(50, 50))).Returns(false);
 
@@ -421,6 +427,7 @@ namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
         {
             var pen = new ImmutablePen(Brushes.Black, 1);
             var geomMock = new Mock<IGeometryImpl>();
+            geomMock.Setup(g => g.GeometryImpl).Returns(geomMock.Object);
             geomMock.Setup(g => g.StrokeContains(pen, new Point(5, 5))).Returns(true);
             geomMock.Setup(g => g.StrokeContains(pen, new Point(50, 50))).Returns(false);
 
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamHitTestTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamHitTestTests.cs
index 65dc9470f3..cb71c17f9a 100644
--- a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamHitTestTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamHitTestTests.cs
@@ -61,6 +61,7 @@ namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
         public void Geometry_Is_Hit_Via_FillContains()
         {
             var geometry = new Mock<IGeometryImpl>();
+            geometry.Setup(g => g.GeometryImpl).Returns(geometry.Object);
             geometry.Setup(x => x.FillContains(new Point(5, 5))).Returns(true);
             geometry.Setup(x => x.FillContains(new Point(50, 50))).Returns(false);
 
@@ -113,6 +114,7 @@ namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
         public void Geometry_Clip_Restricts_The_Hit_Region()
         {
             var geometry = new Mock<IGeometryImpl>();
+            geometry.Setup(g => g.GeometryImpl).Returns(geometry.Object);
             geometry.Setup(x => x.FillContains(new Point(5, 5))).Returns(true);
             geometry.Setup(x => x.FillContains(new Point(50, 50))).Returns(false);
 
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamTests.cs
index 943ae19994..619cb3e9ea 100644
--- a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/RenderDataStreamTests.cs
@@ -123,9 +123,12 @@ namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
             var calls = new List<string>();
             var context = RecordingContext(calls);
 
+            var geometry = new Mock<IGeometryImpl>();
+            geometry.Setup(g => g.GeometryImpl).Returns(geometry.Object);
+
             using var stream = new RenderDataStream();
             stream.PushClip(new RoundedRect(new Rect(0, 0, 10, 10)));
-            stream.PushGeometryClip(Mock.Of<IGeometryImpl>());
+            stream.PushGeometryClip(geometry.Object);
             stream.Pop();
             stream.Pop();
             stream.Replay(context.Object);
diff --git a/tests/Avalonia.RenderTests/Media/DrawingContentTests.cs b/tests/Avalonia.RenderTests/Media/DrawingContentTests.cs
new file mode 100644
index 0000000000..dc11cfd666
--- /dev/null
+++ b/tests/Avalonia.RenderTests/Media/DrawingContentTests.cs
@@ -0,0 +1,114 @@
+#if AVALONIA_SKIA
+using System;
+using System.IO;
+using System.Runtime.CompilerServices;
+using Avalonia.Controls;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Platform.Surfaces;
+using Avalonia.Rendering;
+using Avalonia.Rendering.Composition;
+using Avalonia.Threading;
+using Avalonia.UnitTests;
+using SkiaSharp;
+using Xunit;
+
+namespace Avalonia.Skia.RenderTests;
+
+/// <summary>
+/// Verifies that replacing a resource inside a <see cref="Drawing"/> is reflected in what a
+/// consuming control renders. The initial frame is intentionally ignored (covered elsewhere); only
+/// the frame produced _after_ the change is compared against the reference image.
+/// </summary>
+public class DrawingContentTests()
+    : TestBase(@"Media\DrawingContent")
+{
+    private sealed class FuncFramebufferSurface(Func<IFramebufferRenderTarget> cb) : IFramebufferPlatformSurface
+    {
+        public IFramebufferRenderTarget CreateFramebufferRenderTarget() => cb();
+    }
+
+    [Fact]
+    public void DrawingBrush_Reflects_Replaced_Inner_Brush()
+    {
+        var drawing = new GeometryDrawing
+        {
+            Brush = Brushes.Blue,
+            Geometry = new RectangleGeometry(new Rect(0, 0, 100, 100))
+        };
+
+        var target = new Border
+        {
+            Width = 100,
+            Height = 100,
+            Background = new DrawingBrush(drawing) { Stretch = Stretch.Fill }
+        };
+
+        RenderChange(target, () => drawing.Brush = Brushes.Red);
+        CompareImages(skipImmediate: true);
+    }
+
+    [Fact]
+    public void DrawingImage_Reflects_Replaced_Inner_Brush()
+    {
+        var drawing = new GeometryDrawing
+        {
+            Brush = Brushes.Blue,
+            Geometry = new RectangleGeometry(new Rect(0, 0, 100, 100))
+        };
+
+        var target = new Image
+        {
+            Width = 100,
+            Height = 100,
+            Stretch = Stretch.Fill,
+            Source = new DrawingImage(drawing)
+        };
+
+        RenderChange(target, () => drawing.Brush = Brushes.Red);
+        CompareImages(skipImmediate: true);
+    }
+
+    // Renders the target once, applies the change, renders again and writes the second frame to the
+    // standard composited output path so it can be compared against the committed reference image.
+    private void RenderChange(Control target, Action change, [CallerMemberName] string testName = "")
+    {
+        var timer = new ManualRenderTimer();
+        var compositor = new Compositor(
+            RenderLoop.FromTimer(timer),
+            null,
+            true,
+            new DispatcherCompositorScheduler(), true, Dispatcher.UIThread);
+
+        var root = new TestRenderRoot(1, null!);
+        using var frameBuffer = new SKBitmap(100, 100, SKColorType.Rgba8888, SKAlphaType.Premul);
+
+        var renderTarget = new FuncFramebufferRenderTarget(() => new LockedFramebuffer(
+            frameBuffer.GetAddress(0, 0),
+            new PixelSize(frameBuffer.Width, frameBuffer.Height),
+            frameBuffer.RowBytes,
+            new Vector(96, 96),
+            PixelFormat.Rgba8888,
+            AlphaFormat.Premul,
+            null));
+
+        using (var renderer = new CompositingRenderer(root, compositor, () => [new FuncFramebufferSurface(() => renderTarget)]))
+        {
+            root.Initialize(renderer, target);
+            renderer.Start();
+            Dispatcher.UIThread.RunJobs();
+            timer.TriggerTick();
+
+            change();
+            Dispatcher.UIThread.RunJobs();
+            timer.TriggerTick();
+        }
+
+        Directory.CreateDirectory(OutputPath);
+        var path = Path.Combine(OutputPath, testName + ".composited.out.png");
+        using var data = frameBuffer.Encode(SKEncodedImageFormat.Png, 100);
+        using var file = File.Create(path);
+        data.SaveTo(file);
+    }
+}
+#endif
diff --git a/tests/TestFiles/Skia/Media/DrawingContent/DrawingBrush_Reflects_Replaced_Inner_Brush.expected.png b/tests/TestFiles/Skia/Media/DrawingContent/DrawingBrush_Reflects_Replaced_Inner_Brush.expected.png
new file mode 100644
index 0000000000000000000000000000000000000000..7de0e220fecfa177b1ff634504ed1c9a09b85e98
GIT binary patch
literal 329
zcmeAS@N?(olHy`uVBq!ia0vp^DIm<j1|$m}O$`B3EX7WqAsj$Z!;#X#z`)4h>Eakt
zG3V_?M_vX6fdd<u|Id5a%k(WnROhCZar%iH`<W{wg_1pb6b;*sNDM#58P+#GOvn6p
SZnp=94TGnvpUXO@geCxrsc1a_

literal 0
HcmV?d00001

diff --git a/tests/TestFiles/Skia/Media/DrawingContent/DrawingImage_Reflects_Replaced_Inner_Brush.expected.png b/tests/TestFiles/Skia/Media/DrawingContent/DrawingImage_Reflects_Replaced_Inner_Brush.expected.png
new file mode 100644
index 0000000000000000000000000000000000000000..7de0e220fecfa177b1ff634504ed1c9a09b85e98
GIT binary patch
literal 329
zcmeAS@N?(olHy`uVBq!ia0vp^DIm<j1|$m}O$`B3EX7WqAsj$Z!;#X#z`)4h>Eakt
zG3V_?M_vX6fdd<u|Id5a%k(WnROhCZar%iH`<W{wg_1pb6b;*sNDM#58P+#GOvn6p
SZnp=94TGnvpUXO@geCxrsc1a_

literal 0
HcmV?d00001


From bc5d32dca7e3d7756281e834d39c16262a04509a Mon Sep 17 00:00:00 2001
From: lambgoesbaa <lamb.goes.baa@gmail.com>
Date: Fri, 3 Jul 2026 11:39:52 -0400
Subject: [PATCH 065/196] X11: re-read _NET_WORKAREA on WM PropertyNotify
 (#21651)

Co-authored-by: lucas <lucas@rxmusic.com>
---
 src/Avalonia.X11/Screens/X11Screen.Providers.cs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/Avalonia.X11/Screens/X11Screen.Providers.cs b/src/Avalonia.X11/Screens/X11Screen.Providers.cs
index af0e47cfd5..1e3f0e0e8a 100644
--- a/src/Avalonia.X11/Screens/X11Screen.Providers.cs
+++ b/src/Avalonia.X11/Screens/X11Screen.Providers.cs
@@ -130,6 +130,14 @@ internal partial class X11Screens
             
             if (_scalingProvider is IScalingProviderWithChanges scalingWithChanges)
                 scalingWithChanges.SettingsChanged += () => Changed?.Invoke();
+
+            platform.Globals.RootPropertyChanged += OnRootPropertyChanged;
+        }
+
+        private void OnRootPropertyChanged(IntPtr atom)
+        {
+            if (atom == _x11.Atoms._NET_WORKAREA)
+                Dispatcher.UIThread.Post(() => Changed?.Invoke(), DispatcherPriority.Normal);
         }
 
         private void OnEvent(ref XEvent ev)

From fa3f4978ce15f0f19374dd59651aad56648de6a5 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Mon, 6 Jul 2026 09:40:41 +0200
Subject: [PATCH 066/196] Implement IStorageProvider.OpenFileWithResultAsync
 (#21418)

* Implement IStorageProvider.OpenFileWithResult

* Update API suppressions
---
 api/Avalonia.nupkg.xml                        |  12 ++
 .../src/OSX/StorageProvider.mm                |  41 ++++---
 .../Storage/AndroidStorageProvider.cs         |   6 +
 .../Storage/FallbackStorageProvider.cs        |   5 +
 .../Storage/FileIO/BclStorageProvider.cs      |  17 ++-
 .../Platform/Storage/IStorageProvider.cs      |  20 ++--
 .../Platform/Storage/NoopStorageProvider.cs   |  10 +-
 .../Platform/Storage/OpenFilePickerResult.cs  |  23 ++++
 .../Platform/Storage/SaveFilePickerResult.cs  |   6 +-
 src/Avalonia.DesignerSupport/Remote/Stubs.cs  |  26 ----
 .../ManagedStorageProvider.cs                 |  34 +++---
 src/Avalonia.FreeDesktop/DBusSystemDialog.cs  | 111 +++++++++---------
 src/Avalonia.Native/StorageProviderApi.cs     |  21 ++--
 src/Avalonia.Native/StorageProviderImpl.cs    |  15 ++-
 .../NativeDialogs/GtkNativeFileDialogs.cs     |  44 +++----
 .../Storage/BrowserStorageProvider.cs         |   6 +
 .../Avalonia.Win32/Win32StorageProvider.cs    |  86 ++++++++------
 .../Storage/IOSStorageProvider.cs             |   6 +
 18 files changed, 281 insertions(+), 208 deletions(-)
 create mode 100644 src/Avalonia.Base/Platform/Storage/OpenFilePickerResult.cs

diff --git a/api/Avalonia.nupkg.xml b/api/Avalonia.nupkg.xml
index 4b2aa63ef1..1751d863e6 100644
--- a/api/Avalonia.nupkg.xml
+++ b/api/Avalonia.nupkg.xml
@@ -121,6 +121,12 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.Storage.IStorageProvider.OpenFilePickerWithResultAsync(Avalonia.Platform.Storage.FilePickerOpenOptions)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Controls.Platform.IWin32OptionsTopLevelImpl.SetWindowCornerPreference(Avalonia.Controls.Win32Properties.WindowCornerPreference)</Target>
@@ -133,6 +139,12 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Controls.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Controls.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.Storage.IStorageProvider.OpenFilePickerWithResultAsync(Avalonia.Platform.Storage.FilePickerOpenOptions)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Controls.Platform.IWin32OptionsTopLevelImpl.SetWindowCornerPreference(Avalonia.Controls.Win32Properties.WindowCornerPreference)</Target>
diff --git a/native/Avalonia.Native/src/OSX/StorageProvider.mm b/native/Avalonia.Native/src/OSX/StorageProvider.mm
index a608f6ffaf..7f9f622171 100644
--- a/native/Avalonia.Native/src/OSX/StorageProvider.mm
+++ b/native/Avalonia.Native/src/OSX/StorageProvider.mm
@@ -165,6 +165,17 @@ public:
         
         return nullptr;
     }
+    
+    static int GetSelectedFilterIndex(NSSavePanel* _Nonnull panel)
+    {
+        if (panel.accessoryView != nil)
+        {
+            auto popup = [panel.accessoryView viewWithTag:kFileTypePopupTag];
+            if ([popup isKindOfClass:[NSPopUpButton class]])
+                return (int)[(NSPopUpButton*)popup indexOfSelectedItem];
+        }
+        return -1;
+    }
 
     virtual void SelectFolderDialog (IAvnTopLevel* parentTopLevel,
                                      IAvnSystemDialogEvents* events,
@@ -270,30 +281,32 @@ public:
             auto parentWindow = GetEffectiveNSWindow(parentTopLevel);
             
             auto handler = ^(NSModalResponse result) {
+                auto selectedIndex = GetSelectedFilterIndex(panel);
+
                 if(result == NSFileHandlingPanelOKButton)
                 {
                     auto urls = [panel URLs];
-                    
+
                     if(urls.count > 0)
                     {
                         auto uriStrings = CreateAvnStringArray(urls);
-                        ownedEvents->OnCompleted(uriStrings);
+                        ownedEvents->OnCompletedWithFilter(uriStrings, selectedIndex);
 
                         [panel orderOut:panel];
-                        
+
                         if (parentWindow != nullptr)
                         {
                             [parentWindow makeKeyAndOrderFront:parentWindow];
                         }
-                        
+
                         return;
                     }
                 }
-                
-                ownedEvents->OnCompleted(nullptr);
-                
+
+                ownedEvents->OnCompletedWithFilter(nullptr, selectedIndex);
+
             };
-            
+
             if (parentWindow != nullptr)
             {
                 [panel beginSheetModalForWindow:parentWindow completionHandler:handler];
@@ -304,7 +317,7 @@ public:
             }
         }
     }
-    
+
     virtual void SaveFileDialog (IAvnTopLevel* parentTopLevel,
                                  IAvnSystemDialogEvents* events,
                                  const char* title,
@@ -340,15 +353,7 @@ public:
             auto parentWindow = GetEffectiveNSWindow(parentTopLevel);
             
             auto handler = ^(NSModalResponse result) {
-                int selectedIndex = -1;
-                if (panel.accessoryView != nil)
-                {
-                    auto popup = [panel.accessoryView viewWithTag:kFileTypePopupTag];
-                    if ([popup isKindOfClass:[NSPopUpButton class]])
-                    {
-                        selectedIndex = (int)[(NSPopUpButton*)popup indexOfSelectedItem];
-                    }
-                }
+                auto selectedIndex = GetSelectedFilterIndex(panel);
 
                 if(result == NSFileHandlingPanelOKButton)
                 {
diff --git a/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs b/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
index c64431a034..e55689f93d 100644
--- a/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
+++ b/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
@@ -165,6 +165,12 @@ internal class AndroidStorageProvider : IStorageProvider
         return uris.Select(u => new AndroidStorageFile(_activity, u)).ToArray();
     }
 
+    public async Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options)
+    {
+        var files = await OpenFilePickerAsync(options).ConfigureAwait(false);
+        return new OpenFilePickerResult { Files = files };
+    }
+
     public async Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options)
     {
         var mimeTypes = options.FileTypeChoices?.Where(t => t != FilePickerFileTypes.All)
diff --git a/src/Avalonia.Base/Platform/Storage/FallbackStorageProvider.cs b/src/Avalonia.Base/Platform/Storage/FallbackStorageProvider.cs
index 0852bbf329..d5760408a0 100644
--- a/src/Avalonia.Base/Platform/Storage/FallbackStorageProvider.cs
+++ b/src/Avalonia.Base/Platform/Storage/FallbackStorageProvider.cs
@@ -65,6 +65,11 @@ internal class FallbackStorageProvider : IStorageProvider
         return await (await GetFor(p => p.CanOpen)).OpenFilePickerAsync(options);
     }
 
+    public async Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options)
+    {
+        return await (await GetFor(p => p.CanOpen)).OpenFilePickerWithResultAsync(options);
+    }
+
     public async Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options)
     {
         return await (await GetFor(p => p.CanSave)).SaveFilePickerAsync(options);
diff --git a/src/Avalonia.Base/Platform/Storage/FileIO/BclStorageProvider.cs b/src/Avalonia.Base/Platform/Storage/FileIO/BclStorageProvider.cs
index a471dba720..61a0674b2e 100644
--- a/src/Avalonia.Base/Platform/Storage/FileIO/BclStorageProvider.cs
+++ b/src/Avalonia.Base/Platform/Storage/FileIO/BclStorageProvider.cs
@@ -10,13 +10,26 @@ namespace Avalonia.Platform.Storage.FileIO;
 internal abstract class BclStorageProvider : IStorageProvider
 {
     public abstract bool CanOpen { get; }
-    public abstract Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options);
+
+    public async Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options)
+    {
+        var result = await OpenFilePickerWithResultAsync(options).ConfigureAwait(false);
+        return result.Files;
+    }
+    public abstract Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options);
 
     public abstract bool CanSave { get; }
-    public abstract Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options);
+
+    public async Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options)
+    {
+        var result = await SaveFilePickerWithResultAsync(options).ConfigureAwait(false);
+        return result.File;
+    }
+
     public abstract Task<SaveFilePickerResult> SaveFilePickerWithResultAsync(FilePickerSaveOptions options);
 
     public abstract bool CanPickFolder { get; }
+
     public abstract Task<IReadOnlyList<IStorageFolder>> OpenFolderPickerAsync(FolderPickerOpenOptions options);
 
     public virtual Task<IStorageBookmarkFile?> OpenFileBookmarkAsync(string bookmark)
diff --git a/src/Avalonia.Base/Platform/Storage/IStorageProvider.cs b/src/Avalonia.Base/Platform/Storage/IStorageProvider.cs
index 22f8d8bd0a..f4fe7ca5eb 100644
--- a/src/Avalonia.Base/Platform/Storage/IStorageProvider.cs
+++ b/src/Avalonia.Base/Platform/Storage/IStorageProvider.cs
@@ -10,40 +10,46 @@ namespace Avalonia.Platform.Storage;
 public interface IStorageProvider
 {
     /// <summary>
-    /// Returns true if it's possible to open file picker on the current platform. 
+    /// Returns true if it's possible to open the file picker on the current platform.
     /// </summary>
     bool CanOpen { get; }
 
     /// <summary>
-    /// Opens file picker dialog.
+    /// Opens the file picker dialog.
     /// </summary>
     /// <returns>Array of selected <see cref="IStorageFile"/> or empty collection if user canceled the dialog.</returns>
     Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options);
 
     /// <summary>
-    /// Returns true if it's possible to open save file picker on the current platform. 
+    /// Opens the file picker dialog and returns additional information about the result.
+    /// </summary>
+    /// <returns><see cref="OpenFilePickerResult"/> with selected files and additional dialog information such as selected file type.</returns>
+    Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options);
+
+    /// <summary>
+    /// Returns true if it's possible to open the save file picker on the current platform.
     /// </summary>
     bool CanSave { get; }
 
     /// <summary>
-    /// Opens save file picker dialog.
+    /// Opens the save file picker dialog.
     /// </summary>
     /// <returns>Saved <see cref="IStorageFile"/> or null if user canceled the dialog.</returns>
     Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options);
 
     /// <summary>
-    /// Opens save file picker dialog and returns additional information about the result.
+    /// Opens the save file picker dialog and returns additional information about the result.
     /// </summary>
     /// <returns><see cref="SaveFilePickerResult"/> with saved file and additional dialog information such as selected file type.</returns>
     Task<SaveFilePickerResult> SaveFilePickerWithResultAsync(FilePickerSaveOptions options);
 
     /// <summary>
-    /// Returns true if it's possible to open folder picker on the current platform. 
+    /// Returns true if it's possible to open the folder picker on the current platform.
     /// </summary>
     bool CanPickFolder { get; }
 
     /// <summary>
-    /// Opens folder picker dialog.
+    /// Opens the folder picker dialog.
     /// </summary>
     /// <returns>Array of selected <see cref="IStorageFolder"/> or empty collection if user canceled the dialog.</returns>
     Task<IReadOnlyList<IStorageFolder>> OpenFolderPickerAsync(FolderPickerOpenOptions options);
diff --git a/src/Avalonia.Base/Platform/Storage/NoopStorageProvider.cs b/src/Avalonia.Base/Platform/Storage/NoopStorageProvider.cs
index 4b056d104e..c2c984d43d 100644
--- a/src/Avalonia.Base/Platform/Storage/NoopStorageProvider.cs
+++ b/src/Avalonia.Base/Platform/Storage/NoopStorageProvider.cs
@@ -8,16 +8,13 @@ namespace Avalonia.Platform.Storage;
 internal class NoopStorageProvider : BclStorageProvider
 {
     public override bool CanOpen => false;
-    public override Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options)
+
+    public override Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options)
     {
-        return Task.FromResult<IReadOnlyList<IStorageFile>>(Array.Empty<IStorageFile>());
+        return Task.FromResult(new OpenFilePickerResult());
     }
 
     public override bool CanSave => false;
-    public override Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options)
-    {
-        return Task.FromResult<IStorageFile?>(null);
-    }
 
     public override Task<SaveFilePickerResult> SaveFilePickerWithResultAsync(FilePickerSaveOptions options)
     {
@@ -25,6 +22,7 @@ internal class NoopStorageProvider : BclStorageProvider
     }
 
     public override bool CanPickFolder => false;
+
     public override Task<IReadOnlyList<IStorageFolder>> OpenFolderPickerAsync(FolderPickerOpenOptions options)
     {
         return Task.FromResult<IReadOnlyList<IStorageFolder>>(Array.Empty<IStorageFolder>());
diff --git a/src/Avalonia.Base/Platform/Storage/OpenFilePickerResult.cs b/src/Avalonia.Base/Platform/Storage/OpenFilePickerResult.cs
new file mode 100644
index 0000000000..91e7c7eccf
--- /dev/null
+++ b/src/Avalonia.Base/Platform/Storage/OpenFilePickerResult.cs
@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+
+namespace Avalonia.Platform.Storage;
+
+/// <summary>
+/// Represents the result of the <see cref="IStorageProvider.OpenFilePickerWithResultAsync"/> operation.
+/// </summary>
+public readonly record struct OpenFilePickerResult
+{
+    /// <summary>
+    /// Gets the list of files selected by the user, or empty if the user canceled the dialog.
+    /// </summary>
+    public IReadOnlyList<IStorageFile> Files
+    {
+        get => field ?? [];
+        init;
+    }
+
+    /// <summary>
+    /// Gets the file type selected by the user, or null if the platform does not support this feature.
+    /// </summary>
+    public FilePickerFileType? SelectedFileType { get; init; }
+}
diff --git a/src/Avalonia.Base/Platform/Storage/SaveFilePickerResult.cs b/src/Avalonia.Base/Platform/Storage/SaveFilePickerResult.cs
index 222b4a4dbc..c643011453 100644
--- a/src/Avalonia.Base/Platform/Storage/SaveFilePickerResult.cs
+++ b/src/Avalonia.Base/Platform/Storage/SaveFilePickerResult.cs
@@ -1,17 +1,17 @@
 namespace Avalonia.Platform.Storage;
 
 /// <summary>
-/// Extended result of the <see cref="IStorageProvider.SaveFilePickerWithResultAsync(FilePickerSaveOptions)"/> operation.
+/// Represents the result of the <see cref="IStorageProvider.SaveFilePickerWithResultAsync"/> operation.
 /// </summary>
 public readonly record struct SaveFilePickerResult
 {
     /// <summary>
-    /// Saved <see cref="IStorageFile"/> or null if user canceled the dialog.
+    /// Gets the file selected by the user, or null if the user canceled the dialog.
     /// </summary>
     public IStorageFile? File { get; init; }
 
     /// <summary>
-    /// Selected file type or null if not supported.
+    /// Gets the file type selected by the user, or null if the platform does not support this feature.
     /// </summary>
     public FilePickerFileType? SelectedFileType { get; init; }
 }
diff --git a/src/Avalonia.DesignerSupport/Remote/Stubs.cs b/src/Avalonia.DesignerSupport/Remote/Stubs.cs
index b53645c67b..97fda7d8d1 100644
--- a/src/Avalonia.DesignerSupport/Remote/Stubs.cs
+++ b/src/Avalonia.DesignerSupport/Remote/Stubs.cs
@@ -274,30 +274,4 @@ namespace Avalonia.DesignerSupport.Remote
             }
         }
     }
-
-    internal class NoopStorageProvider : BclStorageProvider
-    {
-        public override bool CanOpen => false;
-        public override Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options)
-        {
-            return Task.FromResult<IReadOnlyList<IStorageFile>>(Array.Empty<IStorageFile>());
-        }
-
-        public override bool CanSave => false;
-        public override Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options)
-        {
-            return Task.FromResult<IStorageFile?>(null);
-        }
-
-        public override Task<SaveFilePickerResult> SaveFilePickerWithResultAsync(FilePickerSaveOptions options)
-        {
-            return Task.FromResult(new SaveFilePickerResult());
-        }
-
-        public override bool CanPickFolder => false;
-        public override Task<IReadOnlyList<IStorageFolder>> OpenFolderPickerAsync(FolderPickerOpenOptions options)
-        {
-            return Task.FromResult<IReadOnlyList<IStorageFolder>>(Array.Empty<IStorageFolder>());
-        }
-    }
 }
diff --git a/src/Avalonia.Dialogs/ManagedStorageProvider.cs b/src/Avalonia.Dialogs/ManagedStorageProvider.cs
index 58edc32224..30328fabeb 100644
--- a/src/Avalonia.Dialogs/ManagedStorageProvider.cs
+++ b/src/Avalonia.Dialogs/ManagedStorageProvider.cs
@@ -27,23 +27,16 @@ internal class ManagedStorageProvider : BclStorageProvider
     public override bool CanSave => true;
     public override bool CanOpen => true;
     public override bool CanPickFolder => true;
-            
-    public override async Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options)
-    {
-        var model = new ManagedFileChooserViewModel(options, _managedOptions);
-        var results = await Show(model);
-
-        return results.Select(f => new BclStorageFile(new FileInfo(f))).ToArray();
-    }
 
-    public override async Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options)
+    public override async Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options)
     {
         var model = new ManagedFileChooserViewModel(options, _managedOptions);
         var results = await Show(model);
 
-        return results.FirstOrDefault() is { } result
-            ? new BclStorageFile(new FileInfo(result))
-            : null;
+        var files = results.Select(f => new BclStorageFile(new FileInfo(f))).ToArray<IStorageFile>();
+        var fileType = TryGetSelectedFileType(options.FileTypeFilter, model.SelectedFilter);
+
+        return new OpenFilePickerResult { Files = files, SelectedFileType = fileType };
     }
 
     public override async Task<SaveFilePickerResult> SaveFilePickerWithResultAsync(FilePickerSaveOptions options)
@@ -52,11 +45,9 @@ internal class ManagedStorageProvider : BclStorageProvider
         var results = await Show(model);
 
         var file = results.FirstOrDefault() is { } result ? new BclStorageFile(new FileInfo(result)) : null;
-        var filterType = model.SelectedFilter?.Index is { } index && index < options.FileTypeChoices?.Count ?
-            options.FileTypeChoices[index] :
-            null;
+        var fileType = TryGetSelectedFileType(options.FileTypeChoices, model.SelectedFilter);
 
-        return new SaveFilePickerResult { File = file, SelectedFileType = filterType };
+        return new SaveFilePickerResult { File = file, SelectedFileType = fileType };
     }
 
     public override async Task<IReadOnlyList<IStorageFolder>> OpenFolderPickerAsync(FolderPickerOpenOptions options)
@@ -88,7 +79,7 @@ internal class ManagedStorageProvider : BclStorageProvider
 
         return root;
     }
-    
+
     private Task<string[]> Show(ManagedFileChooserViewModel model)
     {
         var root = PrepareRoot(model);
@@ -149,7 +140,7 @@ internal class ManagedStorageProvider : BclStorageProvider
 
         return result;
     }
-    
+
     private async Task<string[]> ShowAsPopup(ContentControl root, ManagedFileChooserViewModel model)
     {
         var tcs = new TaskCompletionSource<bool>();
@@ -236,4 +227,11 @@ internal class ManagedStorageProvider : BclStorageProvider
 
         return promptResult;
     }
+
+    private static FilePickerFileType? TryGetSelectedFileType(
+        IReadOnlyList<FilePickerFileType>? fileTypes,
+        ManagedFileChooserFilterViewModel? selectedFileType)
+        => fileTypes is not null && selectedFileType?.Index is { } index && index >= 0 && index < fileTypes.Count ?
+            fileTypes[index] :
+            null;
 }
diff --git a/src/Avalonia.FreeDesktop/DBusSystemDialog.cs b/src/Avalonia.FreeDesktop/DBusSystemDialog.cs
index 078a79ca90..43f7816449 100644
--- a/src/Avalonia.FreeDesktop/DBusSystemDialog.cs
+++ b/src/Avalonia.FreeDesktop/DBusSystemDialog.cs
@@ -5,7 +5,6 @@ using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-using Avalonia.Platform;
 using Avalonia.Platform.Storage;
 using Avalonia.Platform.Storage.FileIO;
 using Avalonia.Threading;
@@ -70,64 +69,64 @@ namespace Avalonia.FreeDesktop
 
         public override bool CanPickFolder => _version >= 3;
 
-        public override async Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options)
+        public override async Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options)
         {
-            await using var parentLease = await AcquireParentLeaseAsync().ConfigureAwait(false);
-            var parentWindow = parentLease?.Handle ?? string.Empty;
-            var (expectedPath, token) = CreateRequestToken();
-            var chooserOptions = new Dictionary<string, VariantValue>();
-
-            if (TryParseFilters(options.FileTypeFilter, options.SuggestedFileType, out var filters,
-                    out var currentFilter))
-            {
-                chooserOptions.Add("filters", filters);
-                if (currentFilter is { } filter)
-                    chooserOptions.Add("current_filter", filter);
-            }
-
-            if (options.SuggestedStartLocation?.TryGetLocalPath() is { } folderPath)
-                chooserOptions.Add("current_folder", VariantValue.Array(Encoding.UTF8.GetBytes(folderPath + "\0")));
-
-            chooserOptions.Add("multiple", VariantValue.Bool(options.AllowMultiple));
-            chooserOptions.Add("handle_token", token);
-
-            var request = new Request(_connection, "org.freedesktop.portal.Desktop", expectedPath);
-            var tsc = new TaskCompletionSource<string[]?>();
-            using var disposable = await request.WatchResponseAsync(notification =>
-            {
-                if (notification.IsCompletion)
-                    tsc.TrySetException(notification.Exception);
-                else
-                    tsc.TrySetResult(notification.Value.Results["uris"].GetArray<string>());
-            }, ObserverFlags.EmitAll);
-
-            var actualPath = await _fileChooser.OpenFileAsync(parentWindow, options.Title ?? string.Empty, chooserOptions);
-            VerifyRequestPath(tsc, expectedPath, actualPath);
+            var (paths, selectedType) = await ShowFilePickerAsync(
+                options.SuggestedFileType,
+                options.SuggestedFileName,
+                options.SuggestedStartLocation,
+                options.FileTypeFilter,
+                options.Title,
+                options.AllowMultiple,
+                _fileChooser.OpenFileAsync)
+                .ConfigureAwait(false);
 
-            var uris = await tsc.Task ?? [];
-            return uris.Select(static path => new BclStorageFile(new FileInfo(new Uri(path).LocalPath))).ToList();
-        }
+            var files = paths.Select(path => new BclStorageFile(new FileInfo(path))).ToArray();
 
-        public override async Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options)
-        {
-            var (file, _) = await SaveFilePickerCoreAsync(options).ConfigureAwait(false);
-            return file;
+            return new OpenFilePickerResult { Files = files, SelectedFileType = selectedType };
         }
 
         public override async Task<SaveFilePickerResult> SaveFilePickerWithResultAsync(FilePickerSaveOptions options)
         {
-            var (file, selectedType) = await SaveFilePickerCoreAsync(options).ConfigureAwait(false);
+            var (paths, selectedType) = await ShowFilePickerAsync(
+                options.SuggestedFileType,
+                options.SuggestedFileName,
+                options.SuggestedStartLocation,
+                options.FileTypeChoices,
+                options.Title,
+                null,
+                _fileChooser.SaveFileAsync)
+            .ConfigureAwait(false);
+
+            var path = paths.FirstOrDefault();
+
+            BclStorageFile? file;
+            if (path is null)
+                file = null;
+            else
+            {
+                // WSL2 freedesktop automatically adds extension from selected file type, but we can't pass "default ext". So apply it manually.
+                path = StorageProviderHelpers.NameWithExtension(path, options.DefaultExtension, selectedType);
+                file = new BclStorageFile(new FileInfo(path));
+            }
+
             return new SaveFilePickerResult { File = file, SelectedFileType = selectedType };
         }
 
-        private async Task<(IStorageFile? file, FilePickerFileType? selectedType)> SaveFilePickerCoreAsync(
-            FilePickerSaveOptions options)
+        private async Task<(string[] paths, FilePickerFileType? selectedType)> ShowFilePickerAsync(
+            FilePickerFileType? suggestedFileType,
+            string? suggestedFileName,
+            IStorageFolder? suggestedStartLocation,
+            IReadOnlyList<FilePickerFileType>? fileTypes,
+            string? title,
+            bool? allowMultiple,
+            Func<string, string, Dictionary<string, VariantValue>, Task<ObjectPath>> showAsync)
         {
             await using var parentLease = await AcquireParentLeaseAsync().ConfigureAwait(false);
             var parentWindow = parentLease?.Handle ?? string.Empty;
             var (expectedPath, token) = CreateRequestToken();
             var chooserOptions = new Dictionary<string, VariantValue>();
-            if (TryParseFilters(options.FileTypeChoices, options.SuggestedFileType, out var filters,
+            if (TryParseFilters(fileTypes,suggestedFileType, out var filters,
                     out var currentFilter))
             {
                 chooserOptions.Add("filters", filters);
@@ -135,10 +134,12 @@ namespace Avalonia.FreeDesktop
                     chooserOptions.Add("current_filter", filter);
             }
 
-            if (options.SuggestedFileName is { } currentName)
-                chooserOptions.Add("current_name", VariantValue.String(currentName));
-            if (options.SuggestedStartLocation?.TryGetLocalPath() is { } folderPath)
+            if (suggestedFileName is not null)
+                chooserOptions.Add("current_name", VariantValue.String(suggestedFileName));
+            if (suggestedStartLocation?.TryGetLocalPath() is { } folderPath)
                 chooserOptions.Add("current_folder", VariantValue.Array(Encoding.UTF8.GetBytes(folderPath + "\0")));
+            if (allowMultiple.HasValue)
+                chooserOptions.Add("multiple", VariantValue.Bool(allowMultiple.Value));
             chooserOptions.Add("handle_token", token);
 
             var request = new Request(_connection, "org.freedesktop.portal.Desktop", expectedPath);
@@ -170,7 +171,7 @@ namespace Avalonia.FreeDesktop
                         // Reuse the file type objects from options
                         // so the consuming code can match exactly the
                         // file type selected instead of spawning one.
-                        selectedType = options.FileTypeChoices?.FirstOrDefault(type => type.Name == name && (
+                        selectedType = fileTypes?.FirstOrDefault(type => type.Name == name && (
                             (type.MimeTypes?.All(y => mimeTypes.Contains(y)) ?? false) ||
                             (type.Patterns?.All(y => patterns.Contains(y)) ?? false)))
                             ?? new FilePickerFileType(name) { MimeTypes = mimeTypes, Patterns = patterns };
@@ -180,19 +181,13 @@ namespace Avalonia.FreeDesktop
                 }
             }, ObserverFlags.EmitAll).ConfigureAwait(false);
 
-            var actualPath = await _fileChooser.SaveFileAsync(parentWindow, options.Title ?? string.Empty, chooserOptions)
+            var actualPath = await showAsync(parentWindow, title ?? string.Empty, chooserOptions)
                 .ConfigureAwait(false);
             VerifyRequestPath(tsc, expectedPath, actualPath);
 
-            var uris = await tsc.Task.ConfigureAwait(false);
-            var path = uris?.FirstOrDefault() is { } filePath ? new Uri(filePath).LocalPath : null;
-
-            if (path is null)
-                return (null, selectedType);
-
-            // WSL2 freedesktop automatically adds extension from selected file type, but we can't pass "default ext". So apply it manually.
-            path = StorageProviderHelpers.NameWithExtension(path, options.DefaultExtension, selectedType);
-            return (new BclStorageFile(new FileInfo(path)), selectedType);
+            var uris = await tsc.Task.ConfigureAwait(false) ?? [];
+            var paths = uris.Select(uri => new Uri(uri).LocalPath).ToArray();
+            return (paths, selectedType);
         }
 
         public override async Task<IReadOnlyList<IStorageFolder>> OpenFolderPickerAsync(FolderPickerOpenOptions options)
diff --git a/src/Avalonia.Native/StorageProviderApi.cs b/src/Avalonia.Native/StorageProviderApi.cs
index 1a8fc12de4..305b43dc57 100644
--- a/src/Avalonia.Native/StorageProviderApi.cs
+++ b/src/Avalonia.Native/StorageProviderApi.cs
@@ -151,12 +151,12 @@ internal class StorageProviderApi(IAvnStorageProvider native, bool sandboxEnable
         _native.Dispose();
     }
 
-    public async Task<IReadOnlyList<IStorageFile>> OpenFileDialog(TopLevelImpl? topLevel, FilePickerOpenOptions options)
+    public async Task<(IReadOnlyList<IStorageFile> files, FilePickerFileType? selectedType)> OpenFileDialog(TopLevelImpl? topLevel, FilePickerOpenOptions options)
     {
         using var fileTypes = new FilePickerFileTypesWrapper(options.FileTypeFilter, null, options.SuggestedFileType);
         var suggestedDirectory = options.SuggestedStartLocation?.Path.AbsoluteUri ?? string.Empty;
 
-        var (items, _) = await OpenDialogAsync(events =>
+        var (items, selectedFilterIndex) = await OpenDialogAsync(events =>
         {
             _native.OpenFileDialog(topLevel?.Native,
                 events,
@@ -167,7 +167,10 @@ internal class StorageProviderApi(IAvnStorageProvider native, bool sandboxEnable
                 fileTypes);
         }).ConfigureAwait(false);
 
-        return items.OfType<IStorageFile>().ToArray();
+        var files = items.OfType<IStorageFile>().ToArray();
+        var selectedType = TryGetSelectedFileType(options.FileTypeFilter, selectedFilterIndex);
+
+        return (files, selectedType);
     }
 
     public async Task<(IStorageFile? file, FilePickerFileType? selectedType)> SaveFileDialog(TopLevelImpl? topLevel, FilePickerSaveOptions options)
@@ -186,11 +189,7 @@ internal class StorageProviderApi(IAvnStorageProvider native, bool sandboxEnable
         }, create: true).ConfigureAwait(false);
 
         var file = items.OfType<IStorageFile>().FirstOrDefault();
-        FilePickerFileType? selectedType = null;
-        if (selectedFilterIndex is { } index && index >= 0 && options.FileTypeChoices is { Count: > 0 } choices && index < choices.Count)
-        {
-            selectedType = choices[index];
-        }
+        var selectedType = TryGetSelectedFileType(options.FileTypeChoices, selectedFilterIndex);
 
         return (file, selectedType);
     }
@@ -233,6 +232,12 @@ internal class StorageProviderApi(IAvnStorageProvider native, bool sandboxEnable
         return Uri.TryCreate(resultString?.String, UriKind.Absolute, out var resultUri) ? resultUri : null;
     }
 
+    private static FilePickerFileType? TryGetSelectedFileType(
+        IReadOnlyList<FilePickerFileType>? fileTypes, int? nullableIndex)
+        => fileTypes is not null && nullableIndex is { } index && index >= 0 && index < fileTypes.Count ?
+            fileTypes[index] :
+            null;
+
     internal class FilePickerFileTypesWrapper(
         IReadOnlyList<FilePickerFileType>? types,
         string? defaultExtension,
diff --git a/src/Avalonia.Native/StorageProviderImpl.cs b/src/Avalonia.Native/StorageProviderImpl.cs
index d3062715c8..b07d630b0f 100644
--- a/src/Avalonia.Native/StorageProviderImpl.cs
+++ b/src/Avalonia.Native/StorageProviderImpl.cs
@@ -14,15 +14,22 @@ internal sealed class StorageProviderImpl(TopLevelImpl topLevel, StorageProvider
 
     public bool CanPickFolder => true;
 
-    public Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options)
+    public async Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options)
     {
-        return native.OpenFileDialog(topLevel, options);
+        var result = await OpenFilePickerWithResultAsync(options).ConfigureAwait(false);
+        return result.Files;
+    }
+
+    public async Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options)
+    {
+        var (files, selectedType) = await native.OpenFileDialog(topLevel, options).ConfigureAwait(false);
+        return new OpenFilePickerResult { Files = files, SelectedFileType = selectedType };
     }
 
     public async Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options)
     {
-        var (file, _) = await native.SaveFileDialog(topLevel, options).ConfigureAwait(false);
-        return file;
+        var result = await SaveFilePickerWithResultAsync(options).ConfigureAwait(false);
+        return result.File;
     }
 
     public async Task<SaveFilePickerResult> SaveFilePickerWithResultAsync(FilePickerSaveOptions options)
diff --git a/src/Avalonia.X11/NativeDialogs/GtkNativeFileDialogs.cs b/src/Avalonia.X11/NativeDialogs/GtkNativeFileDialogs.cs
index f70525b819..b30d8ad62b 100644
--- a/src/Avalonia.X11/NativeDialogs/GtkNativeFileDialogs.cs
+++ b/src/Avalonia.X11/NativeDialogs/GtkNativeFileDialogs.cs
@@ -35,15 +35,28 @@ namespace Avalonia.X11.NativeDialogs
             return await _initialized ? new GtkSystemDialog(window) : null;
         }
 
-        public override async Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options)
+        public override async Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options)
         {
             return await await RunOnGlibThread(async () =>
             {
-                var (files, _) = await ShowDialog(options.Title, _window, GtkFileChooserAction.Open,
-                        options.AllowMultiple, options.SuggestedStartLocation, null, options.SuggestedFileType, options.FileTypeFilter, null, false)
-                    .ConfigureAwait(false);
-                return files?.Where(f => File.Exists(f)).Select(f => new BclStorageFile(new FileInfo(f))).ToArray() ??
-                       Array.Empty<IStorageFile>();
+                var (files, selectedFilter) = await ShowDialog(
+                    options.Title,
+                    _window,
+                    GtkFileChooserAction.Open,
+                    options.AllowMultiple,
+                    options.SuggestedStartLocation,
+                    null,
+                    options.SuggestedFileType,
+                    options.FileTypeFilter,
+                    null,
+                    false)
+                .ConfigureAwait(false);
+
+                var storageFiles =
+                    files?.Where(File.Exists).Select(f => new BclStorageFile(new FileInfo(f))).ToArray() ??
+                    Array.Empty<IStorageFile>();
+
+                return new OpenFilePickerResult { Files = storageFiles, SelectedFileType = selectedFilter };
             });
         }
 
@@ -59,20 +72,6 @@ namespace Avalonia.X11.NativeDialogs
                        Array.Empty<IStorageFolder>();
             });
         }
-        
-        public override async Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options)
-        {
-            return await await RunOnGlibThread(async () =>
-            {
-                var (files, _) = await ShowDialog(options.Title, _window, GtkFileChooserAction.Save,
-                        false, options.SuggestedStartLocation, options.SuggestedFileName,options.SuggestedFileType, options.FileTypeChoices,
-                        options.DefaultExtension, options.ShowOverwritePrompt ?? false)
-                    .ConfigureAwait(false);
-                return files?.FirstOrDefault() is { } file
-                    ? new BclStorageFile(new FileInfo(file))
-                    : null;
-            });
-        }
 
         public override async Task<SaveFilePickerResult> SaveFilePickerWithResultAsync(FilePickerSaveOptions options)
         {
@@ -199,11 +198,12 @@ namespace Avalonia.X11.NativeDialogs
                         g_slist_free(gs);
                         result = resultList.ToArray();
 
+                        var currentFilter = gtk_file_chooser_get_filter(dlg);
+                        filtersDic.TryGetValue(currentFilter, out selectedFilter);
+
                         // GTK doesn't auto-append the extension, so we need to do that manually
                         if (action == GtkFileChooserAction.Save)
                         {
-                            var currentFilter = gtk_file_chooser_get_filter(dlg);
-                            filtersDic.TryGetValue(currentFilter, out selectedFilter);
                             for (var c = 0; c < result.Length; c++)
                             {
                                 result[c] = StorageProviderHelpers.NameWithExtension(result[c], defaultExtension,
diff --git a/src/Browser/Avalonia.Browser/Storage/BrowserStorageProvider.cs b/src/Browser/Avalonia.Browser/Storage/BrowserStorageProvider.cs
index 957642bfad..5bf34c9920 100644
--- a/src/Browser/Avalonia.Browser/Storage/BrowserStorageProvider.cs
+++ b/src/Browser/Avalonia.Browser/Storage/BrowserStorageProvider.cs
@@ -60,6 +60,12 @@ internal class BrowserStorageProvider : IStorageProvider
         }
     }
 
+    public async Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options)
+    {
+        var files = await OpenFilePickerAsync(options).ConfigureAwait(false);
+        return new OpenFilePickerResult { Files = files };
+    }
+
     public async Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options)
     {
         await AvaloniaModule.ImportStorage();
diff --git a/src/Windows/Avalonia.Win32/Win32StorageProvider.cs b/src/Windows/Avalonia.Win32/Win32StorageProvider.cs
index 6519933de7..ce62c4bb82 100644
--- a/src/Windows/Avalonia.Win32/Win32StorageProvider.cs
+++ b/src/Windows/Avalonia.Win32/Win32StorageProvider.cs
@@ -32,58 +32,67 @@ namespace Avalonia.Win32
 
         public override async Task<IReadOnlyList<IStorageFolder>> OpenFolderPickerAsync(FolderPickerOpenOptions options)
         {
-            var (folders, _) = await ShowFilePicker(
-                true, true,
-                options.AllowMultiple, false,
-                options.Title, options.SuggestedFileName, null, options.SuggestedStartLocation, null, null,
+            var (folders, _) = await ShowFilePickerAsync(
+                true,
+                true,
+                options.AllowMultiple,
+                false,
+                options.Title,
+                options.SuggestedFileName,
+                null,
+                options.SuggestedStartLocation,
+                null,
+                null,
                 f => new BclStorageFolder(new DirectoryInfo(f)))
-                .ConfigureAwait(false);
+            .ConfigureAwait(false);
+
             return folders;
         }
 
-        public override async Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options)
+        public override async Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options)
         {
-            var (files, _) = await ShowFilePicker(
-                true, false,
-                options.AllowMultiple, false,
-                options.Title, options.SuggestedFileName, options.SuggestedFileType, options.SuggestedStartLocation,
-                null, options.FileTypeFilter,
+            var (files, typeIndex) = await ShowFilePickerAsync(
+                true,
+                false,
+                options.AllowMultiple,
+                false,
+                options.Title,
+                options.SuggestedFileName,
+                options.SuggestedFileType,
+                options.SuggestedStartLocation,
+                null,
+                options.FileTypeFilter,
                 f => new BclStorageFile(new FileInfo(f)))
-                .ConfigureAwait(false);
-            return files;
-        }
+            .ConfigureAwait(false);
 
-        public override async Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options)
-        {
-            var (files, _) = await ShowFilePicker(
-                false, false,
-                false, options.ShowOverwritePrompt,
-                options.Title, options.SuggestedFileName, options.SuggestedFileType, options.SuggestedStartLocation,
-                options.DefaultExtension, options.FileTypeChoices,
-                f => new BclStorageFile(new FileInfo(f)))
-                .ConfigureAwait(false);
-            return files.Count > 0 ? files[0] : null;
+            var selectedFileType = TryGetSelectedFileType(options.FileTypeFilter, typeIndex);
+
+            return new OpenFilePickerResult { Files = files, SelectedFileType = selectedFileType };
         }
 
         public override async Task<SaveFilePickerResult> SaveFilePickerWithResultAsync(FilePickerSaveOptions options)
         {
-            var (files, index) = await ShowFilePicker(
-                    false, false,
-                    false, options.ShowOverwritePrompt,
-                    options.Title, options.SuggestedFileName, options.SuggestedFileType, options.SuggestedStartLocation,
-                    options.DefaultExtension, options.FileTypeChoices,
-                    f => new BclStorageFile(new FileInfo(f)))
-                .ConfigureAwait(false);
+            var (files, typeIndex) = await ShowFilePickerAsync(
+                false,
+                false,
+                false,
+                options.ShowOverwritePrompt,
+                options.Title,
+                options.SuggestedFileName,
+                options.SuggestedFileType,
+                options.SuggestedStartLocation,
+                options.DefaultExtension,
+                options.FileTypeChoices,
+                f => new BclStorageFile(new FileInfo(f)))
+            .ConfigureAwait(false);
+
             var file = files.Count > 0 ? files[0] : null;
-            var selectedFileType = options.FileTypeChoices?.Count > 0
-                                   && (index > 0 && index <= options.FileTypeChoices.Count) ?
-                options.FileTypeChoices[index - 1] :
-                null;
+            var selectedFileType = TryGetSelectedFileType(options.FileTypeChoices, typeIndex);
 
             return new SaveFilePickerResult { File = file, SelectedFileType = selectedFileType };
         }
 
-        private unsafe Task<(IReadOnlyList<TStorageItem> items, int typeIndex)> ShowFilePicker<TStorageItem>(
+        private unsafe Task<(IReadOnlyList<TStorageItem> items, int typeIndex)> ShowFilePickerAsync<TStorageItem>(
             bool isOpenFile,
             bool openFolder,
             bool allowMultiple,
@@ -237,6 +246,11 @@ namespace Avalonia.Win32
             return tcs.Task;
         }
 
+        private static FilePickerFileType? TryGetSelectedFileType(IReadOnlyList<FilePickerFileType>? fileTypes, int index)
+            => fileTypes is not null && index >= 1 && index <= fileTypes.Count ?
+                fileTypes[index - 1] :
+                null;
+
         private static string? GetParsingName(IShellItem shellItem)
         {
             return GetDisplayName(shellItem, SIGDN_DESKTOPABSOLUTEPARSING);
diff --git a/src/iOS/Avalonia.iOS/Storage/IOSStorageProvider.cs b/src/iOS/Avalonia.iOS/Storage/IOSStorageProvider.cs
index a4d993d540..8fc11debdf 100644
--- a/src/iOS/Avalonia.iOS/Storage/IOSStorageProvider.cs
+++ b/src/iOS/Avalonia.iOS/Storage/IOSStorageProvider.cs
@@ -43,6 +43,12 @@ internal class IOSStorageProvider : IStorageProvider
         }
     }
 
+    public async Task<OpenFilePickerResult> OpenFilePickerWithResultAsync(FilePickerOpenOptions options)
+    {
+        var files = await OpenFilePickerAsync(options).ConfigureAwait(false);
+        return new OpenFilePickerResult { Files = files };
+    }
+
     private async Task<IReadOnlyList<IStorageFile>> OpenImagePickerAsync(FilePickerOpenOptions options)
     {
 #pragma warning disable CA1422 // Validate platform compatibility - we can't use PHImagePicker here.

From 63a5f830c4d2496c795752a90f011e4295672cf0 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@users.noreply.github.com>
Date: Mon, 6 Jul 2026 10:26:06 +0100
Subject: [PATCH 067/196] Generate a CycloneDX SBOM per published NuGet package
 (#21681)

* Generate a CycloneDX SBOM per published NuGet package

GitHub's dependency-graph SBOM export reports unresolved version ranges
for most packages and can't see which source projects get merged into
which final package by Numerge. Add a CreateSbom Nuke target that runs
CycloneDX against each project's already-restored assets, reassembles
the Numerge merge groups from numerge.json, and publishes one accurate
SBOM per shipped package as a pipeline artifact.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* Fix SBOM dependency graph merge and cover bundled npm packages

The per-package SBOM merge only kept the dependency-graph (dependsOn)
edges from the first-scanned constituent project, so the flagship
Avalonia package listed 38 components but wired only 3 into its graph.
Union dependsOn edges by ref (each constituent's -sn/-sv override makes
its root collapse onto the shared final-package ref) so all edges are
retained - the Avalonia root now reports 17 direct dependencies.

cyclonedx-dotnet only walks the NuGet graph, so JS that ships inside a
package via a Bun/npm-built webapp was invisible: Avalonia.Browser's
staticwebassets and Avalonia.DesignerSupport's embedded previewer (which
merges into Avalonia). Scan each constituent's webapp/package.json
production dependencies, resolving versions from the installed
node_modules (git-pinned deps become pkg:github purls), so those shipped
components appear in the SBOM.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Enrich npm SBOM components to match NuGet component fidelity

Previously the bundled-webapp npm packages were added as bare inventory
entries: no bom-ref, no license, no hashes, direct-only, and orphaned
from the dependency graph - second-class next to the fully-formed NuGet
components cyclonedx-dotnet emits.

Walk the installed node_modules transitively so npm depth matches the
NuGet side (e.g. react-dom now pulls in scheduler, loose-envify,
object-assign; loose-envify pulls in js-tokens), assign each component a
bom-ref, resolve its license from the installed package.json (SPDX id or
expression, with legacy license/licenses object fallback), and wire the
whole tree into the CycloneDX dependency graph - the shipped package now
declares its direct npm deps and every transitive edge below them.

Hashes are intentionally omitted for npm: the verifiable integrity
hashes live in bun's binary lockfile, not the installed tree, and a hash
of the unpacked directory couldn't be checked against a registry.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Enrich SBOM root component and verify package contents

Two gaps remained after the npm work. First, cyclonedx-dotnet emits only
type/name/version for the root metadata.component - no manufacturer,
license, or provenance, which a CRA-facing SBOM is expected to carry.
Read the shipped .nuspec and fill in purl, publisher/supplier (also set
as the document-level manufacturer), SPDX license, description,
copyright, and website/vcs external references.

Second, nothing checked what the package actually ships against the
components derived from the dependency graph. Scan the final .nupkg's
binaries: Avalonia's own Numerge-merged modules (e.g. Avalonia.Base,
Avalonia.Controls folded into Avalonia; Avalonia.Win32.Automation into
Avalonia.Win32) are recorded as manufacturer-supplied components with a
SHA-512 of the shipped bytes, and any third-party binary that no
restored dependency accounts for is added and flagged - a regression
guard so bundled binaries can't silently escape the SBOM. Reference
assemblies under ref/ and the package's own primary assembly are skipped.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Exclude type-only @types/* packages from the SBOM

The DesignerSupport previewer's package.json lists @types/react and
@types/react-dom under "dependencies" rather than "devDependencies", so
they were being scanned in. TypeScript declaration packages are stripped
by esbuild and never appear in the shipped bytes, so they fall outside
the SBOM's scope of delivery. Skip @types/* at both the direct and
transitive level (which also drops csstype, only reachable via
@types/react), leaving the SBOM listing exactly the npm packages that
are actually bundled and delivered.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Add SBOM coverage rules to Copilot review instructions

Instruct code review to flag two cases that would otherwise let a
package ship without accurate SBOM coverage (EU CRA): a newly published
NuGet package not covered by CreateSbom, and a change to what
dependencies are delivered with a component - notably adding npm/JS to a
previously .NET-only component, bundling third-party binaries directly,
or new Numerge merge groups - without a corresponding update to
nukebuild/SbomGenerator.cs.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Link package-content binaries into the dependency graph

The binary:* components from the .nupkg content scan were added to
components but had no dependency node or root edge, leaving them
unreachable for SBOM consumers that traverse the graph from the root -
so the shipped merged modules (and any flagged third-party binary)
didn't appear in the delivered dependency tree. Give each its own leaf
node and a dependsOn edge from the root component.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Prune dangling dependency edges from generated SBOMs

cyclonedx-dotnet leaves dependsOn edges pointing at packages it excluded
as dev dependencies (e.g. analyzers stripped by -ed), so after exclusion
the graph references components that aren't in the SBOM. Drop any
dependsOn target that doesn't resolve to a present component, keeping the
dependency graph internally consistent - consistent with treating those
build-only dev dependencies as out of scope of delivery.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Reference upstream issue for dangling-edge prune

Cite CycloneDX/cyclonedx-dotnet#761 in the PruneDanglingDependencyEdges
comment so a future reader knows the dangling dependsOn edges are an
upstream bug (still reproducing in 6.2.0), not something introduced here.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Resolve CycloneDX via NuGetPackage instead of a global tool install

`dotnet tool update --global CycloneDX` mutated the developer's (and CI
agent's) global tool set as a side effect of running the build. Follow the
same pattern as the other build tools (ApiCompat, ApiDiff, ilrepack): pin
the package via PackageDownload in _build.csproj and resolve it through a
[NuGetPackage] Tool, passed into SbomGenerator.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Reuse existing nuspec/numerge parsing helpers in the SBOM generator

Drop the hand-rolled Numerge* POCOs in favour of Numerge.MergeConfiguration.
LoadFile (already used by CreateNugetPackages), and have BuildToNuGetCache
call SbomGenerator.ReadPackageId instead of duplicating the nuspec-id
extraction inline, so the two can't drift.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Resolve each package's nupkg from a prebuilt id->path map

GenerateForPackage's fallback re-globbed and re-parsed every nupkg in the
output directory once per final package whenever the versioned-filename glob
missed - O(n^2) archive reads. Build the id->path map once in Generate
(reading each nupkg's id a single time) and look each package up in it.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Degrade unrecognised git/URL npm specifiers instead of throwing

ResolveNpmComponent routed any git/URL dependency range to a GitHub-only
parser that threw NotSupportedException on anything else (GitLab/Bitbucket,
a raw tarball URL, ...). Because CreateSbom is a hard release dependency,
one such spec would fail the whole build. Fall back to a generic component
(preferring the installed on-disk version) with a warning instead.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Guard against an npm package.json with no version field

A package.json without a "version" (valid for private packages) made the
null-forgiving ["version"]! throw an NRE, aborting the build. Fall back to
the declared range with a warning instead.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Don't emit a file-license path as an SPDX id

A nuspec <license type="file"> (from PackageLicenseFile) stores a file path,
not an SPDX id. It was being fed to SpdxToLicenses and emitted as
{license:{id:"licenses/LICENSE"}}, an invalid SPDX id that can fail license
validation. Map type="file" to a license name instead. (Avalonia's own
packages all use PackageLicenseExpression=MIT, so this is a latent-correctness
fix rather than a live bug.)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Generate and publish SBOMs from the macOS CI job too

CreateSbom was only wired into CiAzureWindows, so the macOS job's NuGetOSX
artifact - which carries the real macOS-native binaries the Windows build
can't produce - shipped without matching SBOMs. Wire CreateSbom into
CiAzureOSX and publish its output as a SBOMOSX artifact.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Embed each package's CycloneDX SBOM inside its .nupkg

The SBOM previously existed only as a detached build artifact. Also embed
it at _manifest/cyclonedx/bom.cdx.json inside the shipped .nupkg so it
travels with the package, mirroring the _manifest/ layout Microsoft.Sbom.
Targets uses for SPDX. A .nupkg is an OPC package, so [Content_Types].xml
gains a json default or strict OPC readers (including NuGet signature
verification) would reject the modified package. Skips already-signed
packages to avoid invalidating their signature.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Address Copilot review: SBOM zip ordering, nuspec read, component key

- Order ZipFiles after CreateSbom so zipped NuGet artifacts include the
  embedded SBOM.
- Read the .nuspec entry with an ordinal EndsWith and dispose its stream.
- Key components by purl/bom-ref, falling back to name+version so distinct
  versions sharing a name aren't de-duplicated.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Model bundled assemblies as a composition, not dependencies

The numerge-folded first-party assemblies (Avalonia.Base, Avalonia.Controls,
etc.) are constituents of the package, not dependencies of it. Represent them
as a CycloneDX "assembly" via a top-level compositions entry with
aggregate=complete instead of drawing dependsOn edges from the root - contains
and depends-on are distinct relationships. They stay flat top-level components
so their per-assembly hashes remain visible to scanners that ignore nested
components, and the dependency graph is left holding only genuine dependencies.

Also carry the package's licence onto these first-party components, which
previously came out blank (cyclonedx-dotnet only sets it on the root).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
---
 .github/copilot-instructions.md |  12 +
 .nuke/build.schema.json         |   1 +
 azure-pipelines.yml             |  12 +
 nukebuild/Build.cs              |  32 +-
 nukebuild/BuildParameters.cs    |   2 +
 nukebuild/SbomGenerator.cs      | 740 ++++++++++++++++++++++++++++++++
 nukebuild/_build.csproj         |   1 +
 7 files changed, 793 insertions(+), 7 deletions(-)
 create mode 100644 nukebuild/SbomGenerator.cs

diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index 228145f620..1ae5315758 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -2,3 +2,15 @@
 When running code review, please refer to the following documents if they are relevant to the changed parts of the codebase:
 - `native/Avalonia.Native/**` -> `native/Avalonia.Native/README.md`
 - `src/Avalonia.Wayland/**` -> `src/Avalonia.Wayland/README.md`
+
+## SBOM (EU Cyber Resilience Act)
+
+We generate a CycloneDX SBOM per published NuGet package (`nukebuild/SbomGenerator.cs`, `CreateSbom` target) so that every shipped package carries an accurate bill of materials, as required for EU CRA compliance. When reviewing, flag the following:
+
+- **New shipped package:** if a change adds a new NuGet package that is published to end users (a new packable project, or a new final package in `nukebuild/numerge.json`), it must be covered by SBOM generation. Confirm `CreateSbom` produces an SBOM for it, and call it out if the package would ship without one.
+- **New kinds of shipped dependencies:** if a change alters what dependencies are delivered with a component in a way the existing scan doesn't already understand, `nukebuild/SbomGenerator.cs` must be updated so those dependencies appear in the SBOM. In particular:
+  - Adding npm/JS dependencies to a component that was previously .NET-only (e.g. a new `webapp` bundled into a package), or changing how existing bundled JS is built.
+  - Bundling third-party binaries directly into a package (copy-local/ILRepack/embedded assemblies) rather than referencing them as normal NuGet dependencies.
+  - New Numerge merge groups, or any other mechanism that folds a project's shipped output into a package other than via ordinary `PackageReference`/`ProjectReference`.
+
+  The scope is what is *delivered* with the package (BSI TR-03183-2 "scope of delivery"), not build/test-only tooling. Purely development-time dependencies that are never shipped do not need to be in the SBOM.
diff --git a/.nuke/build.schema.json b/.nuke/build.schema.json
index b5f565a399..9b765c53ca 100644
--- a/.nuke/build.schema.json
+++ b/.nuke/build.schema.json
@@ -33,6 +33,7 @@
         "CompileNative",
         "CreateIntermediateNugetPackages",
         "CreateNugetPackages",
+        "CreateSbom",
         "DownloadApiBaselinePackages",
         "GenerateCppHeaders",
         "GenerateUnicodeData",
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 06da4bcd2b..b61baece36 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -132,6 +132,12 @@ jobs:
       artifactName: 'NuGetOSX'
     condition: succeeded()
 
+  - task: PublishBuildArtifacts@1
+    inputs:
+      pathtoPublish: '$(Build.SourcesDirectory)/artifacts/sbom'
+      artifactName: 'SBOMOSX'
+    condition: succeeded()
+
 - job: Windows
   pool:
     vmImage: 'windows-2025'
@@ -187,3 +193,9 @@ jobs:
       artifactName: 'Samples'
     condition: succeeded()
 
+  - task: PublishBuildArtifacts@1
+    inputs:
+      pathtoPublish: '$(Build.SourcesDirectory)/artifacts/sbom'
+      artifactName: 'SBOM'
+    condition: succeeded()
+
diff --git a/nukebuild/Build.cs b/nukebuild/Build.cs
index 7f479a883a..438da98d05 100644
--- a/nukebuild/Build.cs
+++ b/nukebuild/Build.cs
@@ -43,6 +43,9 @@ partial class Build : NukeBuild
     [NuGetPackage("dotnet-ilrepack", "ILRepackTool.dll", Framework = "net8.0")]
     Tool IlRepackTool;
 
+    [NuGetPackage("CycloneDX", "CycloneDX.dll", Framework = "net10.0")]
+    Tool CycloneDxTool;
+
     protected override void OnBuildInitialized()
     {
         Parameters = new BuildParameters(this, ScheduledTargets.Contains(BuildToNuGetCache));
@@ -315,7 +318,9 @@ partial class Build : NukeBuild
         });
 
     Target ZipFiles => _ => _
-        .After(CreateNugetPackages, Compile, RunCoreLibsTests, Package)
+        // CreateSbom embeds the SBOM into each .nupkg in NugetRoot, so it must run before we zip
+        // that directory - otherwise the zipped NuGet artifacts would omit the embedded SBOM.
+        .After(CreateNugetPackages, Compile, RunCoreLibsTests, Package, CreateSbom)
         .Executes(() =>
         {
             var data = Parameters;
@@ -347,6 +352,20 @@ partial class Build : NukeBuild
                 Parameters.NugetRoot / $"Avalonia.{Parameters.Version}.snupkg");
         });
 
+    Target CreateSbom => _ => _
+        .DependsOn(CreateNugetPackages)
+        .Executes(() =>
+        {
+            SbomGenerator.Generate(
+                CycloneDxTool,
+                RootDirectory,
+                Parameters.NugetRoot,
+                Parameters.NugetIntermediateRoot,
+                RootDirectory / "nukebuild" / "numerge.json",
+                Parameters.SbomRoot,
+                Parameters.Version);
+        });
+
     Target DownloadApiBaselinePackages => _ => _
         .DependsOn(CreateNugetPackages)
         .Executes(async () =>
@@ -416,12 +435,14 @@ partial class Build : NukeBuild
 
     Target CiAzureOSX => _ => _
         .DependsOn(Package)
-        .DependsOn(ZipFiles);
+        .DependsOn(ZipFiles)
+        .DependsOn(CreateSbom);
 
     Target CiAzureWindows => _ => _
         .DependsOn(Package)
         .DependsOn(VerifyXamlCompilation)
-        .DependsOn(ZipFiles);
+        .DependsOn(ZipFiles)
+        .DependsOn(CreateSbom);
 
     Target BuildToNuGetCache => _ => _
         .DependsOn(CreateNugetPackages)
@@ -437,10 +458,7 @@ partial class Build : NukeBuild
             {
                 using var f = File.Open(path.ToString(), FileMode.Open, FileAccess.Read);
                 using var zip = new ZipArchive(f, ZipArchiveMode.Read);
-                var nuspecEntry = zip.Entries.First(e => e.FullName.EndsWith(".nuspec") && e.FullName == e.Name);
-                var packageId = XDocument.Load(nuspecEntry.Open()).Document.Root
-                    .Elements().First(x => x.Name.LocalName == "metadata")
-                    .Elements().First(x => x.Name.LocalName == "id").Value;
+                var packageId = SbomGenerator.ReadPackageId(path);
 
                 var packagePath = Path.Combine(
                     globalPackagesFolder,
diff --git a/nukebuild/BuildParameters.cs b/nukebuild/BuildParameters.cs
index 4b55e1691e..18d9e154ca 100644
--- a/nukebuild/BuildParameters.cs
+++ b/nukebuild/BuildParameters.cs
@@ -60,6 +60,7 @@ public partial class Build
         public AbsolutePath ArtifactsDir { get; }
         public AbsolutePath NugetIntermediateRoot { get; }
         public AbsolutePath NugetRoot { get; }
+        public AbsolutePath SbomRoot { get; }
         public AbsolutePath ZipRoot { get; }
         public AbsolutePath TestResultsRoot { get; }
         public string DirSuffix { get; }
@@ -139,6 +140,7 @@ public partial class Build
             ArtifactsDir = RootDirectory / "artifacts";
             NugetRoot = ArtifactsDir / "nuget";
             NugetIntermediateRoot = RootDirectory / "build-intermediate" / "nuget";
+            SbomRoot = ArtifactsDir / "sbom";
             ZipRoot = ArtifactsDir / "zip";
             TestResultsRoot = ArtifactsDir / "test-results";
             BuildDirs = RootDirectory.GlobDirectories("**/bin")
diff --git a/nukebuild/SbomGenerator.cs b/nukebuild/SbomGenerator.cs
new file mode 100644
index 0000000000..a35620f2db
--- /dev/null
+++ b/nukebuild/SbomGenerator.cs
@@ -0,0 +1,740 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
+using System.Security.Cryptography;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.RegularExpressions;
+using System.Xml.Linq;
+using Nuke.Common.IO;
+using Nuke.Common.Tooling;
+using static Serilog.Log;
+
+// Generates one CycloneDX SBOM per published NuGet package, using the already-restored
+// solution (obj/project.assets.json) so component versions are the ones actually resolved
+// into the build, rather than the floating PackageReference ranges GitHub's own dependency
+// graph reports.
+//
+// Numerge (see numerge.json) merges several source projects' packed output into a handful of
+// the final NuGet packages (e.g. "Avalonia" absorbs Avalonia.Base, Avalonia.Controls, the
+// build tasks/analyzers, etc). That merge happens on the built .nupkg files, not via MSBuild
+// ProjectReferences, so it can't be discovered by pointing CycloneDX at a single project with
+// -rs/--recursive. Instead this compares the intermediate and final package sets to work out
+// which source projects were folded into which final package, generates a BOM per constituent
+// project, and unions their components (de-duplicated by purl) into one BOM per final package.
+public static class SbomGenerator
+{
+    public static void Generate(
+        Tool cycloneDx,
+        AbsolutePath rootDirectory,
+        AbsolutePath nugetRoot,
+        AbsolutePath nugetIntermediateRoot,
+        AbsolutePath numergeConfigPath,
+        AbsolutePath outputDirectory,
+        string version)
+    {
+        outputDirectory.CreateOrCleanDirectory();
+
+        // Read each final package's id exactly once here (opening/unzipping a nupkg to parse its
+        // nuspec isn't free) and reuse the id->path map when locating each package's own nupkg
+        // below, rather than re-scanning every nupkg per final package.
+        var finalPackagePathsById = nugetRoot.GlobFiles("*.nupkg")
+            .GroupBy(p => ReadPackageId((string)p))
+            .ToDictionary(g => g.Key, g => g.First());
+        var finalPackageIds = finalPackagePathsById.Keys.ToHashSet();
+        var intermediatePackageIds = nugetIntermediateRoot.GlobFiles("*.nupkg")
+            .Select(p => ReadPackageId((string)p)).Distinct();
+
+        var numerge = Numerge.MergeConfiguration.LoadFile(numergeConfigPath);
+        var explicitParentByChild = numerge.Packages
+            .SelectMany(p => p.Merge.Select(c => (Parent: p.Id, Child: c.Id)))
+            .ToDictionary(x => x.Child, x => x.Parent);
+        var mergeAllParent = numerge.Packages.FirstOrDefault(p => p.MergeAll)?.Id;
+
+        // Every final package starts out as its own sole constituent; leftover intermediate
+        // packages (ones that never shipped standalone) get assigned to whichever final
+        // package absorbed them, per numerge.json.
+        var constituentProjectIdsByFinalId = finalPackageIds.ToDictionary(id => id, id => new List<string> { id });
+        foreach (var id in intermediatePackageIds.Where(id => !finalPackageIds.Contains(id)))
+        {
+            var owner = explicitParentByChild.TryGetValue(id, out var explicitOwner) ? explicitOwner : mergeAllParent;
+            if (owner is not null && constituentProjectIdsByFinalId.TryGetValue(owner, out var siblings))
+                siblings.Add(id);
+            else
+                Warning($"SBOM: couldn't determine which published package absorbs intermediate package '{id}' - it will be missing from all generated SBOMs.");
+        }
+
+        foreach (var (finalId, projectIds) in constituentProjectIdsByFinalId)
+            GenerateForPackage(cycloneDx, rootDirectory, finalPackagePathsById, outputDirectory, version, finalId, projectIds);
+    }
+
+    static void GenerateForPackage(Tool cycloneDx, AbsolutePath rootDirectory,
+        IReadOnlyDictionary<string, AbsolutePath> finalPackagePathsById,
+        AbsolutePath outputDirectory, string version, string finalId, List<string> projectIds)
+    {
+        JsonObject? merged = null;
+        var seenComponentKeys = new HashSet<string>();
+        var scannedProjectDirs = new List<AbsolutePath>();
+
+        foreach (var projectId in projectIds)
+        {
+            var project = rootDirectory.GlobFiles($"src/**/{projectId}.csproj")
+                .Concat(rootDirectory.GlobFiles($"packages/**/{projectId}.csproj"))
+                .FirstOrDefault();
+            if (project is null)
+            {
+                Warning($"SBOM: couldn't locate source project for '{projectId}', skipping it in the SBOM for '{finalId}'.");
+                continue;
+            }
+            scannedProjectDirs.Add(project.Parent);
+
+            var tempBom = outputDirectory / $"_{projectId}.tmp.json";
+            cycloneDx(
+                $"\"{project}\" -o \"{outputDirectory}\" -fn \"{tempBom.Name}\" -F Json -dpr -ed -sn \"{finalId}\" -sv \"{version}\"",
+                workingDirectory: rootDirectory);
+
+            var doc = JsonNode.Parse(File.ReadAllText(tempBom))!.AsObject();
+            File.Delete(tempBom);
+
+            var components = doc["components"]?.AsArray() ?? new JsonArray();
+            if (merged is null)
+            {
+                merged = doc;
+                foreach (var component in components)
+                    seenComponentKeys.Add(ComponentKey(component));
+            }
+            else
+            {
+                var target = merged["components"]?.AsArray() ?? (JsonArray)(merged["components"] = new JsonArray());
+                foreach (var component in components)
+                {
+                    if (seenComponentKeys.Add(ComponentKey(component)))
+                        target.Add(component!.DeepClone());
+                }
+
+                // Every constituent project's own -sn/-sv override makes its root component (and
+                // therefore its dependency-graph "ref") identical to the final package's, so merging
+                // by ref correctly unions all constituents' dependsOn edges onto that shared root
+                // instead of silently keeping only the first project's edges.
+                MergeDependencyGraph(merged, doc["dependencies"]?.AsArray() ?? new JsonArray());
+            }
+        }
+
+        if (merged is null)
+        {
+            Warning($"SBOM: no source projects could be scanned for '{finalId}', no SBOM was generated for it.");
+            return;
+        }
+
+        // cyclonedx-dotnet only sees the MSBuild/NuGet graph. Some projects also bundle a
+        // Bun/npm-built webapp directly into their published package (e.g. Avalonia.Browser's
+        // staticwebassets, Avalonia.DesignerSupport's embedded previewer) - scan those separately
+        // so their shipped JS dependencies aren't silently absent from the SBOM.
+        var rootRef = merged["metadata"]?["component"]?["bom-ref"]?.GetValue<string>();
+        foreach (var projectDir in scannedProjectDirs)
+            AddNpmComponents(merged, seenComponentKeys, projectDir, rootRef);
+
+        // The final .nupkg carries the authoritative publisher/license/repository metadata and the
+        // actual shipped binaries; use it to flesh out the thin root component cyclonedx-dotnet
+        // emits and to verify nothing ships that the dependency scan didn't already account for.
+        var finalNupkg = finalPackagePathsById.GetValueOrDefault(finalId);
+        if (finalNupkg is not null)
+        {
+            var nuspec = ReadNuspecMetadata((string)finalNupkg);
+            EnrichRootComponent(merged, nuspec);
+            AddPackageContentComponents(merged, seenComponentKeys, (string)finalNupkg, finalId, projectIds, nuspec);
+        }
+        else
+        {
+            Warning($"SBOM: couldn't find the built .nupkg for '{finalId}' - root metadata and package-content verification were skipped.");
+        }
+
+        // cyclonedx-dotnet leaves dependsOn edges pointing at packages it excluded as dev
+        // dependencies (e.g. analyzers stripped by -ed), which dangle once the component is gone
+        // (upstream bug CycloneDX/cyclonedx-dotnet#761, still reproducing in 6.2.0). Drop those so
+        // the graph only references components actually present in the SBOM.
+        PruneDanglingDependencyEdges(merged);
+
+        var sbomJson = merged.ToJsonString(new JsonSerializerOptions { WriteIndented = true });
+        File.WriteAllText(outputDirectory / $"{finalId}.{version}.cdx.json", sbomJson);
+
+        // Embed the SBOM inside the shipped .nupkg so it travels with the package, in addition to
+        // the standalone copy written above (which CI publishes as the SBOM artifact) - belt and
+        // suspenders: consumers who only ever see the package still get its bill of materials.
+        if (finalNupkg is not null)
+            EmbedSbomInPackage(finalNupkg, sbomJson);
+    }
+
+    // The path inside the .nupkg where the CycloneDX SBOM is embedded. Mirrors the _manifest/
+    // layout Microsoft.Sbom.Targets uses for its SPDX manifest, but keeps CycloneDX's recognised
+    // *.cdx.json filename so tools that scan for that pattern still find it once unpacked.
+    const string EmbeddedSbomEntryPath = "_manifest/cyclonedx/bom.cdx.json";
+
+    // Adds the generated SBOM as a new part inside the shipped package. Must run before the package
+    // is signed - a NuGet signature covers the whole archive, so adding a part afterwards would
+    // invalidate it. That holds here: these packages are signed server-side by nuget.org on push,
+    // which happens after this build step.
+    static void EmbedSbomInPackage(AbsolutePath nupkgPath, string sbomJson)
+    {
+        using var file = File.Open(nupkgPath, FileMode.Open, FileAccess.ReadWrite);
+        using var zip = new ZipArchive(file, ZipArchiveMode.Update);
+
+        if (zip.Entries.Any(e => e.FullName.EndsWith(".signature.p7s", StringComparison.OrdinalIgnoreCase)))
+        {
+            Warning($"SBOM: '{nupkgPath.Name}' is already signed - skipping embed so its signature stays valid.");
+            return;
+        }
+
+        // Re-embedding (e.g. a re-run over the same output) should replace, not stack duplicates.
+        zip.GetEntry(EmbeddedSbomEntryPath)?.Delete();
+        using (var entryStream = zip.CreateEntry(EmbeddedSbomEntryPath).Open())
+        using (var writer = new StreamWriter(entryStream))
+            writer.Write(sbomJson);
+
+        EnsureJsonContentTypeRegistered(zip);
+    }
+
+    // A .nupkg is an OPC package: every part's extension must be declared in [Content_Types].xml or
+    // strict OPC readers - including NuGet's own signature verification - reject the package. The
+    // SBOM is a .json part, so register that extension before (or as) we add it.
+    static void EnsureJsonContentTypeRegistered(ZipArchive zip)
+    {
+        const string contentTypesEntryName = "[Content_Types].xml";
+        XNamespace ns = "http://schemas.openxmlformats.org/package/2006/content-types";
+
+        var entry = zip.GetEntry(contentTypesEntryName);
+        if (entry is null)
+            return; // not a well-formed OPC package; don't fabricate one
+
+        XDocument doc;
+        using (var read = entry.Open())
+            doc = XDocument.Load(read);
+
+        var alreadyRegistered = doc.Root!.Elements(ns + "Default")
+            .Any(d => string.Equals((string?)d.Attribute("Extension"), "json", StringComparison.OrdinalIgnoreCase));
+        if (alreadyRegistered)
+            return;
+
+        doc.Root.Add(new XElement(ns + "Default",
+            new XAttribute("Extension", "json"),
+            new XAttribute("ContentType", "application/json")));
+
+        entry.Delete();
+        using var write = zip.CreateEntry(contentTypesEntryName).Open();
+        doc.Save(write);
+    }
+
+    static void PruneDanglingDependencyEdges(JsonObject merged)
+    {
+        var deps = merged["dependencies"]?.AsArray();
+        if (deps is null)
+            return;
+
+        var known = new HashSet<string>();
+        var rootRef = merged["metadata"]?["component"]?["bom-ref"]?.GetValue<string>();
+        if (rootRef is not null)
+            known.Add(rootRef);
+        foreach (var component in merged["components"]?.AsArray() ?? new JsonArray())
+        {
+            if (component?["bom-ref"]?.GetValue<string>() is { } bomRef)
+                known.Add(bomRef);
+            if (component?["purl"]?.GetValue<string>() is { } purl)
+                known.Add(purl);
+        }
+
+        foreach (var node in deps.OfType<JsonObject>())
+        {
+            var dependsOn = node["dependsOn"]?.AsArray();
+            if (dependsOn is null)
+                continue;
+            var kept = new JsonArray();
+            foreach (var edge in dependsOn)
+                if (known.Contains(edge!.GetValue<string>()))
+                    kept.Add(edge.GetValue<string>());
+            node["dependsOn"] = kept;
+        }
+    }
+
+    static void MergeDependencyGraph(JsonObject target, JsonArray incoming)
+    {
+        var targetDeps = target["dependencies"]?.AsArray() ?? (JsonArray)(target["dependencies"] = new JsonArray());
+        var byRef = targetDeps.OfType<JsonObject>().ToDictionary(d => d["ref"]!.GetValue<string>());
+
+        foreach (var node in incoming.OfType<JsonObject>())
+        {
+            var nodeRef = node["ref"]!.GetValue<string>();
+            var dependsOn = node["dependsOn"]?.AsArray().Select(x => x!.GetValue<string>()) ?? Enumerable.Empty<string>();
+
+            if (!byRef.TryGetValue(nodeRef, out var existing))
+            {
+                existing = node.DeepClone().AsObject();
+                targetDeps.Add(existing);
+                byRef[nodeRef] = existing;
+            }
+
+            var existingDependsOn = existing["dependsOn"]?.AsArray() ?? (JsonArray)(existing["dependsOn"] = new JsonArray());
+            var seen = existingDependsOn.Select(x => x!.GetValue<string>()).ToHashSet();
+            foreach (var dep in dependsOn)
+                if (seen.Add(dep))
+                    existingDependsOn.Add(dep);
+        }
+    }
+
+    // Scans <projectDir>/**/webapp/package.json for production "dependencies" (deliberately
+    // ignoring devDependencies, which never ship) and adds them - plus their transitive
+    // dependencies, walked through the installed node_modules - as fully-formed components:
+    // bom-ref, resolved version, license, and dependency-graph edges, matching the shape of the
+    // NuGet components cyclonedx-dotnet emits so npm packages aren't second-class SBOM entries.
+    // Versions come from the actually-installed node_modules (same rationale as reading
+    // project.assets.json rather than trusting floating ranges).
+    static void AddNpmComponents(JsonObject merged, HashSet<string> seenComponentKeys, AbsolutePath projectDir,
+        string? rootRef)
+    {
+        foreach (string packageJsonPath in projectDir.GlobFiles("**/webapp/package.json"))
+        {
+            var packageJson = JsonNode.Parse(File.ReadAllText(packageJsonPath))!.AsObject();
+            var nodeModules = ((AbsolutePath)packageJsonPath).Parent / "node_modules";
+            var dependencies = packageJson["dependencies"]?.AsObject() ?? new JsonObject();
+
+            // The webapp is bundled into the shipped package, so its direct production
+            // dependencies are direct dependencies of the final NuGet package.
+            foreach (var (name, rangeNode) in dependencies)
+            {
+                if (IsTypeOnlyPackage(name))
+                    continue;
+                var purl = AddNpmComponentTree(merged, seenComponentKeys, nodeModules, name,
+                    rangeNode!.GetValue<string>(), nodeModules);
+                if (rootRef is not null)
+                    AddDependsOn(merged, rootRef, purl);
+            }
+        }
+    }
+
+    // Adds the component for (name, range) and, recursively, everything it depends on, returning
+    // its purl. The component/graph node/subtree are materialised only the first time a purl is
+    // seen (which also breaks any dependency cycles); repeat encounters just return the purl so
+    // the caller can still record its own edge to it.
+    static string AddNpmComponentTree(JsonObject merged, HashSet<string> seenComponentKeys,
+        AbsolutePath topLevelNodeModules, string name, string declaredRange, AbsolutePath parentNodeModules)
+    {
+        var (purl, componentVersion, installedDir) =
+            ResolveNpmComponent(name, declaredRange, parentNodeModules, topLevelNodeModules);
+
+        if (!seenComponentKeys.Add(purl))
+            return purl;
+
+        var installed = installedDir is not null && File.Exists(installedDir / "package.json")
+            ? JsonNode.Parse(File.ReadAllText(installedDir / "package.json"))!.AsObject()
+            : null;
+
+        var component = new JsonObject
+        {
+            ["type"] = "library",
+            ["bom-ref"] = purl,
+            ["name"] = name,
+            ["version"] = componentVersion,
+            ["purl"] = purl
+        };
+        // No hashes: npm's verifiable hashes live in the (binary bun) lockfile, not the installed
+        // tree, and a hash of the unpacked directory wouldn't be checkable against a registry.
+        var licenses = installed is null ? null : BuildLicenses(installed);
+        if (licenses is not null)
+            component["licenses"] = licenses;
+
+        var target = merged["components"]?.AsArray() ?? (JsonArray)(merged["components"] = new JsonArray());
+        target.Add(component);
+
+        var node = new JsonObject { ["ref"] = purl, ["dependsOn"] = new JsonArray() };
+        (merged["dependencies"]?.AsArray() ?? (JsonArray)(merged["dependencies"] = new JsonArray())).Add(node);
+
+        var childDeps = installed?["dependencies"]?.AsObject() ?? new JsonObject();
+        var childNodeModules = installedDir is not null ? installedDir / "node_modules" : parentNodeModules;
+        var dependsOn = node["dependsOn"]!.AsArray();
+        foreach (var (childName, childRange) in childDeps)
+        {
+            if (IsTypeOnlyPackage(childName))
+                continue;
+            var childPurl = AddNpmComponentTree(merged, seenComponentKeys, topLevelNodeModules, childName,
+                childRange!.GetValue<string>(), childNodeModules);
+            dependsOn.Add(childPurl);
+        }
+
+        return purl;
+    }
+
+    // @types/* packages are TypeScript declaration stubs: esbuild strips them at build time, so
+    // they're never part of the shipped bytes and don't belong in a scope-of-delivery SBOM.
+    static bool IsTypeOnlyPackage(string name) => name.StartsWith("@types/", StringComparison.Ordinal);
+
+    static void AddDependsOn(JsonObject merged, string fromRef, string toPurl)
+    {
+        var deps = merged["dependencies"]?.AsArray() ?? (JsonArray)(merged["dependencies"] = new JsonArray());
+        var node = deps.OfType<JsonObject>().FirstOrDefault(d => d["ref"]?.GetValue<string>() == fromRef);
+        if (node is null)
+        {
+            node = new JsonObject { ["ref"] = fromRef, ["dependsOn"] = new JsonArray() };
+            deps.Add(node);
+        }
+
+        var dependsOn = node["dependsOn"]?.AsArray() ?? (JsonArray)(node["dependsOn"] = new JsonArray());
+        if (!dependsOn.Any(x => x!.GetValue<string>() == toPurl))
+            dependsOn.Add(toPurl);
+    }
+
+    static JsonArray? BuildLicenses(JsonObject installedPackageJson)
+    {
+        // Modern npm: "license" is an SPDX id or expression. Legacy: "license"/"licenses" objects.
+        if (installedPackageJson["license"] is JsonValue licenseValue && licenseValue.TryGetValue(out string? spdx))
+        {
+            var licenses = SpdxToLicenses(spdx);
+            if (licenses is not null)
+                return licenses;
+        }
+
+        var legacy = (installedPackageJson["license"] as JsonObject)?["type"]?.GetValue<string>()
+            ?? (installedPackageJson["licenses"] as JsonArray)?.OfType<JsonObject>()
+                .FirstOrDefault()?["type"]?.GetValue<string>();
+        return legacy is null
+            ? null
+            : new JsonArray(new JsonObject { ["license"] = new JsonObject { ["name"] = legacy } });
+    }
+
+    // Turns an SPDX string into a CycloneDX licenses array: a single license id becomes a
+    // {license:{id}} entry, a compound SPDX expression becomes an {expression} entry.
+    static JsonArray? SpdxToLicenses(string? spdx)
+    {
+        if (string.IsNullOrWhiteSpace(spdx))
+            return null;
+        var isExpression = spdx.IndexOf(" OR ", StringComparison.Ordinal) >= 0
+            || spdx.IndexOf(" AND ", StringComparison.Ordinal) >= 0
+            || spdx.IndexOf(" WITH ", StringComparison.Ordinal) >= 0;
+        return new JsonArray(isExpression
+            ? new JsonObject { ["expression"] = spdx }
+            : new JsonObject { ["license"] = new JsonObject { ["id"] = spdx } });
+    }
+
+    static (string Purl, string Version, AbsolutePath? InstalledDir) ResolveNpmComponent(
+        string name, string declaredRange, AbsolutePath parentNodeModules, AbsolutePath topLevelNodeModules)
+    {
+        // npm/bun hoist most packages to the top level but may nest a conflicting version under
+        // the depending package, so prefer the nested copy and fall back to the hoisted one.
+        var installedDir = new[] { parentNodeModules / name, topLevelNodeModules / name }
+            .FirstOrDefault(d => File.Exists(d / "package.json"));
+
+        if (declaredRange.StartsWith("github:") || declaredRange.StartsWith("git") || declaredRange.Contains("://"))
+        {
+            if (TryParseGitHubDependency(declaredRange, out var owner, out var repo, out var reference))
+                return ($"pkg:github/{owner}/{repo}@{reference}", reference, installedDir);
+
+            // A non-GitHub git/URL specifier (GitLab/Bitbucket, a raw tarball URL, ...). We have no
+            // provider-specific purl for it, so degrade to a generic component - preferring the
+            // version installed on disk - rather than throwing and failing the whole release over a
+            // single dependency we can't classify precisely.
+            var resolvedVersion = installedDir is not null
+                ? JsonNode.Parse(File.ReadAllText(installedDir / "package.json"))!["version"]?.GetValue<string>()
+                : null;
+            resolvedVersion ??= declaredRange;
+            Warning($"SBOM: npm dependency '{name}' uses an unrecognised git/URL specifier '{declaredRange}' - recording it as a generic component with version '{resolvedVersion}'.");
+            return ($"pkg:generic/{EncodeNpmName(name)}@{resolvedVersion}", resolvedVersion, installedDir);
+        }
+
+        if (installedDir is null)
+        {
+            Warning($"SBOM: npm dependency '{name}' isn't installed near {parentNodeModules} - recording its declared range '{declaredRange}' instead of a resolved version.");
+            return ($"pkg:npm/{EncodeNpmName(name)}@{declaredRange}", declaredRange, null);
+        }
+
+        var installedVersion = JsonNode.Parse(File.ReadAllText(installedDir / "package.json"))!["version"]?.GetValue<string>();
+        if (installedVersion is null)
+        {
+            // package.json without a "version" is valid for private packages; don't let it NRE.
+            Warning($"SBOM: npm dependency '{name}' installed at {installedDir} has no version in its package.json - recording its declared range '{declaredRange}' instead.");
+            installedVersion = declaredRange;
+        }
+        return ($"pkg:npm/{EncodeNpmName(name)}@{installedVersion}", installedVersion, installedDir);
+    }
+
+    static string EncodeNpmName(string name) => name.StartsWith("@") ? $"%40{name[1..]}" : name;
+
+    static bool TryParseGitHubDependency(string spec, out string owner, out string repo, out string reference)
+    {
+        owner = repo = "";
+        var hashIndex = spec.IndexOf('#');
+        reference = hashIndex >= 0 ? spec[(hashIndex + 1)..] : "HEAD";
+        var withoutRef = hashIndex >= 0 ? spec[..hashIndex] : spec;
+
+        var match = Regex.Match(withoutRef, @"github(?:\.com)?[:/]+([^/]+)/([^/#]+?)(?:\.git)?$");
+        if (!match.Success)
+            return false;
+        owner = match.Groups[1].Value;
+        repo = match.Groups[2].Value;
+        return true;
+    }
+
+    // Prefer purl (or bom-ref) as the identity; both encode version. Fall back to name+version so
+    // distinct versions of the same package aren't collapsed into one, and to a fresh GUID when
+    // there's nothing identifiable to key on (treating it as unique rather than deduping blindly).
+    static string ComponentKey(JsonNode? component) =>
+        component?["purl"]?.GetValue<string>()
+        ?? component?["bom-ref"]?.GetValue<string>()
+        ?? (component?["name"]?.GetValue<string>() is { } name
+            ? $"{name}@{component?["version"]?.GetValue<string>()}"
+            : Guid.NewGuid().ToString());
+
+    // Fills in the root component with the publisher, licence, description and repository details
+    // from the shipped .nuspec - cyclonedx-dotnet only emits type/name/version, which is far short
+    // of the manufacturer/provenance information a CRA-facing SBOM is expected to carry.
+    static void EnrichRootComponent(JsonObject merged, NuspecMetadata meta)
+    {
+        var component = merged["metadata"]?["component"]?.AsObject();
+        if (component is null)
+            return;
+
+        // These are shipped libraries, not applications (cyclonedx-dotnet's default type).
+        component["type"] = "library";
+        component["purl"] = $"pkg:nuget/{meta.Id}@{meta.Version}";
+        if (meta.Description is not null)
+            component["description"] = meta.Description;
+        if (meta.Copyright is not null)
+            component["copyright"] = meta.Copyright;
+
+        JsonObject? supplier = null;
+        if (meta.Authors is not null)
+        {
+            component["publisher"] = meta.Authors;
+            component["author"] = meta.Authors;
+            supplier = new JsonObject { ["name"] = meta.Authors };
+            if (meta.ProjectUrl is not null)
+                supplier["url"] = new JsonArray(meta.ProjectUrl);
+            component["supplier"] = supplier;
+        }
+
+        var licenses = SpdxToLicenses(meta.LicenseExpression ?? meta.LicenseId);
+        // A file license has no SPDX id; record it by name rather than emitting an invalid id.
+        if (licenses is null && meta.LicenseFile is not null)
+            licenses = new JsonArray(new JsonObject
+                { ["license"] = new JsonObject { ["name"] = Path.GetFileName(meta.LicenseFile) } });
+        if (licenses is not null)
+            component["licenses"] = licenses;
+
+        var externalReferences = new JsonArray();
+        if (meta.ProjectUrl is not null)
+            externalReferences.Add(new JsonObject { ["url"] = meta.ProjectUrl, ["type"] = "website" });
+        if (meta.RepositoryUrl is not null)
+            externalReferences.Add(new JsonObject { ["url"] = meta.RepositoryUrl, ["type"] = "vcs" });
+        if (externalReferences.Count > 0)
+            component["externalReferences"] = externalReferences;
+
+        // Also record the manufacturer at the document level (the entity that supplied the BOM).
+        if (supplier is not null && merged["metadata"] is JsonObject metadata)
+            metadata["supplier"] = supplier.DeepClone();
+    }
+
+    // Cross-checks what the package actually ships against the components derived from the
+    // dependency graph. Avalonia's own merged modules (Numerge folds several projects' assemblies
+    // into one package) are recorded as manufacturer-supplied components with a verifiable SHA-512
+    // of the shipped bytes; any third-party binary that no restored dependency accounts for is
+    // added and flagged, so a future bundling regression can't silently escape the SBOM.
+    //
+    // These shipped binaries are *constituents* of the package, not dependencies of it: the package
+    // is made up of them (Component C bundles D and E, in CycloneDX's terms), so they're modelled as
+    // a CycloneDX "assembly" via a top-level `compositions` entry rather than with a dependsOn edge
+    // from the root - "contains" and "depends on" are different relationships, and an assembly does
+    // not imply a dependency. They stay flat top-level components (not nested subcomponents) so their
+    // per-assembly hashes remain visible to scanners that ignore nested components.
+    static void AddPackageContentComponents(JsonObject merged, HashSet<string> seenComponentKeys,
+        string nupkgPath, string finalId, List<string> constituentProjectIds, NuspecMetadata meta)
+    {
+        var productNames = new HashSet<string>(constituentProjectIds, StringComparer.OrdinalIgnoreCase) { finalId };
+        var representedNames = (merged["components"]?.AsArray() ?? new JsonArray())
+            .Select(c => c?["name"]?.GetValue<string>())
+            .Where(n => n is not null)
+            .ToHashSet(StringComparer.OrdinalIgnoreCase)!;
+
+        var supplier = meta.Authors is null ? null : new JsonObject { ["name"] = meta.Authors };
+        var target = merged["components"]?.AsArray() ?? (JsonArray)(merged["components"] = new JsonArray());
+        var rootRef = merged["metadata"]?["component"]?["bom-ref"]?.GetValue<string>();
+
+        // The bundled first-party assemblies share the package's licence; cyclonedx-dotnet only puts
+        // it on the root component, so carry it onto them too (same derivation as EnrichRootComponent).
+        var productLicenses = SpdxToLicenses(meta.LicenseExpression ?? meta.LicenseId);
+        if (productLicenses is null && meta.LicenseFile is not null)
+            productLicenses = new JsonArray(new JsonObject
+                { ["license"] = new JsonObject { ["name"] = Path.GetFileName(meta.LicenseFile) } });
+
+        // bom-refs of every shipped binary added below; declared as a complete assembly at the end.
+        var assemblyRefs = new List<string>();
+
+        using var file = File.Open(nupkgPath, FileMode.Open, FileAccess.Read);
+        using var zip = new ZipArchive(file, ZipArchiveMode.Read);
+        foreach (var entry in zip.Entries)
+        {
+            var path = entry.FullName;
+            // Reference assemblies under ref/ are compile-time surface, not shipped runtime code;
+            // the real implementation lives under lib/ and is scanned there.
+            if (!IsShippedBinary(path) || path.StartsWith("ref/", StringComparison.OrdinalIgnoreCase))
+                continue;
+
+            var bytes = ReadEntry(entry);
+            var assemblyName = TryReadAssemblyName(bytes, out var assemblyVersion);
+            var simpleName = assemblyName ?? Path.GetFileNameWithoutExtension(path);
+
+            // Third-party binaries already represented by a NuGet/npm component need no duplicate.
+            if (assemblyName is not null && representedNames.Contains(simpleName))
+                continue;
+
+            var isProduct = productNames.Contains(simpleName)
+                || simpleName.StartsWith("Avalonia.", StringComparison.OrdinalIgnoreCase)
+                || simpleName.Equals("Avalonia", StringComparison.OrdinalIgnoreCase);
+
+            // The package's primary assembly is the root component itself - don't list it as its own subcomponent.
+            if (isProduct && simpleName.Equals(finalId, StringComparison.OrdinalIgnoreCase))
+                continue;
+
+            var version = assemblyVersion ?? meta.Version;
+            var bomRef = $"binary:{simpleName}@{version}";
+            if (!seenComponentKeys.Add(bomRef))
+                continue;
+
+            if (!isProduct)
+                Warning($"SBOM: package '{finalId}' ships '{path}' ({simpleName}) which no restored dependency accounts for - added from package contents, please verify its provenance.");
+
+            var component = new JsonObject
+            {
+                ["type"] = "library",
+                ["bom-ref"] = bomRef,
+                ["name"] = simpleName,
+                ["version"] = version,
+                ["scope"] = "required",
+                ["hashes"] = new JsonArray(new JsonObject
+                {
+                    ["alg"] = "SHA-512",
+                    ["content"] = Convert.ToHexString(SHA512.HashData(bytes))
+                }),
+                ["properties"] = new JsonArray(new JsonObject
+                {
+                    ["name"] = "avalonia:packagePath",
+                    ["value"] = path
+                })
+            };
+            if (isProduct)
+            {
+                if (supplier is not null)
+                    component["supplier"] = supplier.DeepClone();
+                if (productLicenses is not null)
+                    component["licenses"] = productLicenses.DeepClone();
+            }
+            target.Add(component);
+
+            assemblyRefs.Add(bomRef);
+        }
+
+        // Declare the package's assembly: the root component consists of exactly these bundled
+        // binaries. We've read every shipped binary out of the .nupkg, so the enumeration is
+        // complete (third-party dependencies remain in the dependency graph, as they should).
+        if (assemblyRefs.Count > 0)
+        {
+            var assemblies = new JsonArray();
+            if (rootRef is not null)
+                assemblies.Add(rootRef);
+            foreach (var bomRef in assemblyRefs)
+                assemblies.Add(bomRef);
+
+            var compositions = merged["compositions"]?.AsArray()
+                ?? (JsonArray)(merged["compositions"] = new JsonArray());
+            compositions.Add(new JsonObject
+            {
+                ["aggregate"] = "complete",
+                ["assemblies"] = assemblies
+            });
+        }
+    }
+
+    static bool IsShippedBinary(string path)
+    {
+        var ext = Path.GetExtension(path).ToLowerInvariant();
+        return ext is ".dll" or ".so" or ".dylib" or ".wasm" or ".node" or ".a";
+    }
+
+    static byte[] ReadEntry(ZipArchiveEntry entry)
+    {
+        using var stream = entry.Open();
+        using var ms = new MemoryStream();
+        stream.CopyTo(ms);
+        return ms.ToArray();
+    }
+
+    // Returns the managed assembly's simple name (and version), or null for native / non-managed binaries.
+    static string? TryReadAssemblyName(byte[] bytes, out string? version)
+    {
+        version = null;
+        try
+        {
+            using var pe = new PEReader(new MemoryStream(bytes));
+            if (!pe.HasMetadata)
+                return null;
+            var reader = pe.GetMetadataReader();
+            if (!reader.IsAssembly)
+                return null;
+            var assembly = reader.GetAssemblyDefinition();
+            version = assembly.Version.ToString();
+            return reader.GetString(assembly.Name);
+        }
+        catch (BadImageFormatException)
+        {
+            return null;
+        }
+    }
+
+    class NuspecMetadata
+    {
+        public string Id = "";
+        public string Version = "";
+        public string? Authors;
+        public string? LicenseId;
+        public string? LicenseExpression;
+        public string? LicenseFile;
+        public string? ProjectUrl;
+        public string? RepositoryUrl;
+        public string? Description;
+        public string? Copyright;
+    }
+
+    static NuspecMetadata ReadNuspecMetadata(string nupkgPath)
+    {
+        using var file = File.Open(nupkgPath, FileMode.Open, FileAccess.Read);
+        using var zip = new ZipArchive(file, ZipArchiveMode.Read);
+        var nuspecEntry = zip.Entries.First(e => e.FullName.EndsWith(".nuspec", StringComparison.Ordinal) && e.FullName == e.Name);
+        using var nuspecStream = nuspecEntry.Open();
+        var metadata = XDocument.Load(nuspecStream).Root!
+            .Elements().First(x => x.Name.LocalName == "metadata");
+
+        string? Value(string name) => metadata.Elements().FirstOrDefault(x => x.Name.LocalName == name)?.Value;
+        var license = metadata.Elements().FirstOrDefault(x => x.Name.LocalName == "license");
+        var repository = metadata.Elements().FirstOrDefault(x => x.Name.LocalName == "repository");
+
+        return new NuspecMetadata
+        {
+            Id = Value("id") ?? "",
+            Version = Value("version") ?? "",
+            Authors = Value("authors"),
+            // A nuspec <license> is either type="expression" (an SPDX expression) or type="file"
+            // (a path to a bundled licence file); only the former is a valid SPDX id/expression.
+            LicenseExpression = license?.Attribute("type")?.Value == "expression" ? license.Value : null,
+            LicenseFile = license?.Attribute("type")?.Value == "file" ? license.Value : null,
+            LicenseId = license?.Attribute("type")?.Value is "expression" or "file" ? null : license?.Value,
+            ProjectUrl = Value("projectUrl"),
+            RepositoryUrl = repository?.Attribute("url")?.Value,
+            Description = Value("description"),
+            Copyright = Value("copyright")
+        };
+    }
+
+    public static string ReadPackageId(string nupkgPath) => ReadNuspecMetadata(nupkgPath).Id;
+}
diff --git a/nukebuild/_build.csproj b/nukebuild/_build.csproj
index c58a2b894b..bf31a5f9a2 100644
--- a/nukebuild/_build.csproj
+++ b/nukebuild/_build.csproj
@@ -20,6 +20,7 @@
     <PackageDownload Include="Microsoft.DotNet.ApiCompat.Tool" Version="[10.0.100]" />
     <PackageDownload Include="Microsoft.DotNet.ApiDiff.Tool" Version="[10.0.100-rtm.25531.102]" />
     <PackageDownload Include="dotnet-ilrepack" Version="[2.0.44]" />
+    <PackageDownload Include="CycloneDX" Version="[6.2.0]" />
   </ItemGroup>
 
   <Import Project="..\build\MicroCOM.props" />

From 20c1d6a2e2bc8a6d9502c4f2c2bc3011bb66da23 Mon Sep 17 00:00:00 2001
From: Benedikt Stebner <Gillibald@users.noreply.github.com>
Date: Mon, 6 Jul 2026 12:05:12 +0200
Subject: [PATCH 068/196] [Text] InterWordJustification fixes (#21701)

* Fix inter-word justification distribution and safety

TextAlignment.Justify was incorrect or a no-op in several common cases.
This corrects glyph targeting, buffer safety, run partitioning, the fill
target, and which lines get justified.

- Target the glyph ending each break boundary; step zero-width breaks
  (CJK/Korean ideograph boundaries, hyphens) back one so the widened gap
  sits on the break and the last visible glyph is never stretched.
- Copy-on-write the shaped buffer before adjusting advances and swap in a
  fresh run, so justification never mutates glyph storage shared with a
  TextRunCache entry, a Split sibling or a WithBidiLevel alias. Adds
  ShapedBuffer.CloneWritable and TextLineImpl.ReplaceTextRun, which also
  repoints the bidi-reordered runs used by draw and hit-test.
- Consume break opportunities per run instead of draining the whole queue
  against the first run.
- Fill the visible Width to the paragraph width rather than the width
  including trailing whitespace, so wrapped lines with trailing whitespace
  justify instead of being left un-justified.
- Target MaxWidth for wrapped text rather than the widest produced line.
- Skip the last line, newline-terminated lines and hard-break lines.

Adds justification test coverage: CJK, mixed Latin+CJK, Arabic buffer
integrity, Latin wrapping, trailing whitespace and multi-run lines.

* Add failing test for trailing-whitespace overcount across runs

- TextLineImpl.CreateLineMetrics walks a line's runs backward to
  compute trailing whitespace, stopping only when a run has none of
  its own - not when a run is only partly whitespace.
- On a multi-run line where an interior run also ends in a space
  (common at a script boundary, since each script run tends to end at
  the following space), that space gets wrongly counted as trailing
  too, even though visible content follows it later in the line.
- This shrinks Width, which InterWordJustification uses to decide how
  much space a line still needs to reach the target width.

* Fix trailing-whitespace overcount across runs

- Only continue accumulating trailing whitespace from an earlier run
  when the current run is entirely whitespace; otherwise the current
  run's own visible content is the line's true end, and an earlier
  run's trailing space is interior, not trailing.
- Width now correctly includes interior, non-trailing whitespace, so
  wrapped multi-run lines (e.g. mixed-script text) no longer get
  stretched past the target width when justified.

* Ignore CLAUDE.md
---
 .gitignore                                    |   1 +
 .../Media/TextFormatting/IndexedTextRun.cs    |   2 +-
 .../TextFormatting/InterWordJustification.cs  | 117 +++-
 .../Media/TextFormatting/ShapedBuffer.cs      |  17 +
 .../Media/TextFormatting/TextLayout.cs        |  24 +-
 .../Media/TextFormatting/TextLineImpl.cs      |  42 ++
 .../Media/TextFormatting/TextLayoutTests.cs   | 567 ++++++++++++++++++
 7 files changed, 737 insertions(+), 33 deletions(-)

diff --git a/.gitignore b/.gitignore
index 558b91f822..e2e3a8ef73 100644
--- a/.gitignore
+++ b/.gitignore
@@ -228,3 +228,4 @@ src/Browser/Avalonia.Browser/staticwebassets
 /planning
 BenchmarkDotNet.Artifacts.*
 .tokensave
+/CLAUDE.md
diff --git a/src/Avalonia.Base/Media/TextFormatting/IndexedTextRun.cs b/src/Avalonia.Base/Media/TextFormatting/IndexedTextRun.cs
index 0eb98533d2..3c9d0894c7 100644
--- a/src/Avalonia.Base/Media/TextFormatting/IndexedTextRun.cs
+++ b/src/Avalonia.Base/Media/TextFormatting/IndexedTextRun.cs
@@ -5,6 +5,6 @@
         public int TextSourceCharacterIndex { get; init; }
         public int RunIndex { get; set; }
         public int NextRunIndex { get; set; }
-        public TextRun? TextRun { get; init; }
+        public TextRun? TextRun { get; set; }
     }
 }
diff --git a/src/Avalonia.Base/Media/TextFormatting/InterWordJustification.cs b/src/Avalonia.Base/Media/TextFormatting/InterWordJustification.cs
index 75249ff7e7..692ed09d08 100644
--- a/src/Avalonia.Base/Media/TextFormatting/InterWordJustification.cs
+++ b/src/Avalonia.Base/Media/TextFormatting/InterWordJustification.cs
@@ -4,6 +4,21 @@ using Avalonia.Media.TextFormatting.Unicode;
 
 namespace Avalonia.Media.TextFormatting
 {
+    /// <summary>
+    /// Distributes the remaining line width across the break opportunities reported by the line
+    /// breaker - inter-word gaps for space-delimited scripts, and inter-character/inter-syllable
+    /// gaps for CJK and Korean (which the line breaker treats as break opportunities).
+    /// </summary>
+    /// <remarks>
+    /// Known limitations:
+    /// <list type="bullet">
+    /// <item>Thai, Lao, Khmer and Myanmar produce no line-break opportunities without dictionary or
+    /// ML based word segmentation (character-class line breaking cannot find their word boundaries),
+    /// so such lines are left un-justified (start-aligned) rather than spaced incorrectly.</item>
+    /// <item>Arabic and Hebrew are justified with inter-word spacing rather than the idiomatic
+    /// kashida (tatweel) elongation, which would require shaper-level support.</item>
+    /// </list>
+    /// </remarks>
     internal class InterWordJustification : JustificationProperties
     {
         public InterWordJustification(double width)
@@ -31,6 +46,12 @@ namespace Avalonia.Media.TextFormatting
 
             var currentPosition = textLine.FirstTextSourceIndex;
 
+            // Note: trailing whitespace needs no special handling here. The LineBreakEnumerator does
+            // not emit a non-required break inside trailing whitespace (LB07 forbids breaking before
+            // a space, LB06 before a hard break), and the run-final break is excluded by
+            // PositionWrap != textRun.Length below - so no break opportunity ever targets a glyph in
+            // the trailing whitespace. Verified for ASCII and ideographic (U+3000) spaces by
+            // Justify_Does_Not_Space_Trailing_Whitespace.
             for (var i = 0; i < lineImpl.TextRuns.Count; ++i)
             {
                 var textRun = lineImpl.TextRuns[i];
@@ -47,7 +68,25 @@ namespace Avalonia.Media.TextFormatting
                 {
                     if (!currentBreak.Required && currentBreak.PositionWrap != textRun.Length)
                     {
-                        breakOportunities.Enqueue(currentPosition + currentBreak.PositionMeasure);
+                        // The extra advance must land on the glyph that ENDS at the break
+                        // boundary (the last glyph before the break), so the widened gap sits on
+                        // the break itself. For whitespace breaks GetLineBreak has already pulled
+                        // PositionMeasure back onto the trailing whitespace glyph
+                        // (PositionMeasure < PositionWrap), so that position is the target as-is.
+                        // For zero-width breaks - CJK/Korean ideograph boundaries, hyphens and
+                        // other break-after punctuation - PositionMeasure == PositionWrap and
+                        // points one glyph PAST the boundary; step back one so we widen the gap the
+                        // break represents rather than the following gap. This also keeps the last
+                        // visible glyph of a CJK/Korean line unstretched: its only inbound break is
+                        // the run-final break, already excluded by PositionWrap != textRun.Length.
+                        var target = currentPosition + currentBreak.PositionMeasure;
+
+                        if (currentBreak.PositionMeasure == currentBreak.PositionWrap)
+                        {
+                            target -= 1;
+                        }
+
+                        breakOportunities.Enqueue(target);
                     }
                 }
 
@@ -59,46 +98,72 @@ namespace Avalonia.Media.TextFormatting
                 return;
             }
 
-            var remainingSpace = Math.Max(0, paragraphWidth - lineImpl.WidthIncludingTrailingWhitespace);
+            // Fill the visible content to the paragraph width, not the width including trailing
+            // whitespace. A wrapped line keeps the space at its wrap point as trailing whitespace,
+            // which can push WidthIncludingTrailingWhitespace to or past the paragraph width; using
+            // it here would leave remainingSpace at zero and the line unjustified. The distributed
+            // space only ever lands on visible glyphs (trailing whitespace gets no break), so the
+            // visible content reaches the margin and the trailing whitespace hangs past it.
+            var remainingSpace = Math.Max(0, paragraphWidth - lineImpl.Width);
             var spacing = remainingSpace / breakOportunities.Count;
 
             currentPosition = textLine.FirstTextSourceIndex;
 
-            foreach (var textRun in lineImpl.TextRuns)
+            for (var runIndex = 0; runIndex < lineImpl.TextRuns.Count; runIndex++)
             {
-                var text = textRun.Text;
-
-                if (text.IsEmpty)
+                var textRun = lineImpl.TextRuns[runIndex];
+                var runLength = textRun.Length;
+                var runEnd = currentPosition + runLength;
+
+                var shapedText = textRun.Text.IsEmpty ? null : textRun as ShapedTextRun;
+                var glyphRun = shapedText?.GlyphRun;
+                ShapedBuffer? writableBuffer = null;
+
+                // Consume only the break opportunities that fall inside this run's range. The queue
+                // is in ascending position order, so once the front break is at or past runEnd it
+                // belongs to a later run and must be left for it, instead of draining the whole
+                // queue against this run.
+                while (breakOportunities.Count > 0)
                 {
-                    continue;
-                }
+                    var characterIndex = breakOportunities.Peek();
 
-                if (textRun is ShapedTextRun shapedText)
-                {
-                    var glyphRun = shapedText.GlyphRun;
-                    var shapedBuffer = shapedText.ShapedBuffer;
+                    if (characterIndex >= runEnd)
+                    {
+                        break;
+                    }
 
-                    while (breakOportunities.Count > 0)
+                    breakOportunities.Dequeue();
+
+                    // Skip stale breaks and breaks in runs we cannot justify (non-shaped).
+                    if (characterIndex < currentPosition || shapedText is null)
                     {
-                        var characterIndex = breakOportunities.Dequeue();
+                        continue;
+                    }
 
-                        if (characterIndex < currentPosition)
-                        {
-                            continue;
-                        }
+                    // Copy-on-write: the run's own ShapedBuffer may share its pooled glyph storage
+                    // with a TextRunCache entry, a Split sibling or a WithBidiLevel alias, so
+                    // mutating it in place would corrupt those. Adjust a private clone and swap in a
+                    // fresh run below.
+                    writableBuffer ??= shapedText.ShapedBuffer.CloneWritable();
 
-                        var offset = Math.Max(0, currentPosition - glyphRun.Metrics.FirstCluster);
-                        var glyphIndex = glyphRun.FindGlyphIndex(characterIndex - offset);
-                        var glyphInfo = shapedBuffer[glyphIndex];
+                    var offset = Math.Max(0, currentPosition - glyphRun!.Metrics.FirstCluster);
+                    var glyphIndex = glyphRun.FindGlyphIndex(characterIndex - offset);
+                    var glyphInfo = writableBuffer[glyphIndex];
 
-                        shapedBuffer[glyphIndex] = new GlyphInfo(glyphInfo.GlyphIndex,
-                            glyphInfo.GlyphCluster, glyphInfo.GlyphAdvance + spacing);
-                    }
+                    writableBuffer[glyphIndex] = new GlyphInfo(glyphInfo.GlyphIndex,
+                        glyphInfo.GlyphCluster, glyphInfo.GlyphAdvance + spacing);
+                }
+
+                if (writableBuffer != null)
+                {
+                    var justifiedRun = new ShapedTextRun(writableBuffer, shapedText!.Properties);
 
-                    glyphRun.GlyphInfos = shapedBuffer;
+                    lineImpl.ReplaceTextRun(runIndex, justifiedRun);
+
+                    shapedText.Dispose();
                 }
 
-                currentPosition += textRun.Length;
+                currentPosition += runLength;
             }
         }
     }
diff --git a/src/Avalonia.Base/Media/TextFormatting/ShapedBuffer.cs b/src/Avalonia.Base/Media/TextFormatting/ShapedBuffer.cs
index 7be486717e..0a9f2f1e86 100644
--- a/src/Avalonia.Base/Media/TextFormatting/ShapedBuffer.cs
+++ b/src/Avalonia.Base/Media/TextFormatting/ShapedBuffer.cs
@@ -562,6 +562,23 @@ namespace Avalonia.Media.TextFormatting
                 _glyphRef, prefixRef, startsRef, startIdx, count, _cacheGeneration);
         }
 
+        /// <summary>
+        /// Creates a deep copy backed by a fresh, non-pooled <see cref="GlyphInfo"/> array so the
+        /// copy's advances can be mutated (e.g. by justification) without touching glyph storage
+        /// shared with a <see cref="TextRunCache"/> entry, a <see cref="Split"/> sibling or a
+        /// <see cref="WithBidiLevel"/> alias. The copy owns no ref-counted pooled handles (its
+        /// <c>_glyphRef</c> is null) and builds its own cluster cache lazily.
+        /// </summary>
+        internal ShapedBuffer CloneWritable()
+        {
+            var span = _glyphInfos.Span;
+            var glyphs = new GlyphInfo[span.Length];
+
+            span.CopyTo(glyphs);
+
+            return new ShapedBuffer(Text, new ArraySlice<GlyphInfo>(glyphs), GlyphTypeface, FontRenderingEmSize, BidiLevel);
+        }
+
         int IReadOnlyCollection<GlyphInfo>.Count => _glyphInfos.Length;
 
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
diff --git a/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs b/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs
index 0e7a624d17..a72e9e875e 100644
--- a/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs
+++ b/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs
@@ -657,14 +657,14 @@ namespace Avalonia.Media.TextFormatting
 
                 if (_paragraphProperties.TextAlignment == TextAlignment.Justify)
                 {
+                    // Justify fills each line to the column width, which is MaxWidth for both
+                    // wrapped and non-wrapped text. Targeting the widest produced line instead
+                    // (the previous behaviour for wrapping) leaves wrapped text short of the
+                    // margin, since the full non-last lines already equal that width. When
+                    // MaxWidth is infinite there is no column to fill, so skip.
                     var justificationWidth = MaxWidth;
 
-                    if (_paragraphProperties.TextWrapping != TextWrapping.NoWrap)
-                    {
-                        justificationWidth = WidthIncludingTrailingWhitespace;
-                    }
-
-                    if (justificationWidth > 0)
+                    if (!double.IsInfinity(justificationWidth) && justificationWidth > 0)
                     {
                         var justificationProperties = new InterWordJustification(justificationWidth);
 
@@ -672,6 +672,18 @@ namespace Avalonia.Media.TextFormatting
                         {
                             var line = textLines[i];
 
+                            // Only width-driven wrapped lines are stretched to the column. Skip
+                            // the last line of the layout, any line ended by a newline
+                            // (NewLineLength > 0), and any line ended by a source-provided required
+                            // break (TextEndOfLine) - these stay start-aligned per standard
+                            // typographic convention.
+                            if (i == textLines.Count - 1
+                                || line.NewLineLength > 0
+                                || line.TextLineBreak?.TextEndOfLine != null)
+                            {
+                                continue;
+                            }
+
                             line.Justify(justificationProperties);
                         }
                     }
diff --git a/src/Avalonia.Base/Media/TextFormatting/TextLineImpl.cs b/src/Avalonia.Base/Media/TextFormatting/TextLineImpl.cs
index 6437d04298..2289f9508e 100644
--- a/src/Avalonia.Base/Media/TextFormatting/TextLineImpl.cs
+++ b/src/Avalonia.Base/Media/TextFormatting/TextLineImpl.cs
@@ -197,6 +197,39 @@ namespace Avalonia.Media.TextFormatting
             _textLineMetrics = CreateLineMetrics();
         }
 
+        /// <summary>
+        /// Replaces the run at <paramref name="index"/> in <see cref="_textRuns"/> and re-points the
+        /// matching bidi-reordered <see cref="IndexedTextRun"/> at the new run, so draw and hit-test
+        /// paths that resolve runs through <see cref="_indexedTextRuns"/> observe the replacement.
+        /// Used by justification to swap in a copy-on-write run without mutating shared glyph storage.
+        /// </summary>
+        internal void ReplaceTextRun(int index, TextRun textRun)
+        {
+            var oldRun = _textRuns[index];
+
+            if (ReferenceEquals(oldRun, textRun))
+            {
+                return;
+            }
+
+            _textRuns[index] = textRun;
+
+            if (_indexedTextRuns is null)
+            {
+                return;
+            }
+
+            for (var i = 0; i < _indexedTextRuns.Count; i++)
+            {
+                if (ReferenceEquals(_indexedTextRuns[i].TextRun, oldRun))
+                {
+                    _indexedTextRuns[i].TextRun = textRun;
+
+                    break;
+                }
+            }
+        }
+
         /// <inheritdoc/>
         public override CharacterHit GetCharacterHitFromDistance(double distance)
         {
@@ -1428,6 +1461,15 @@ namespace Avalonia.Media.TextFormatting
                     var whitespaceWidth = glyphRun.Bounds.Width - glyphRunMetrics.Width;
 
                     width -= whitespaceWidth;
+
+                    if (glyphRunMetrics.TrailingWhitespaceLength != currentRun.Length)
+                    {
+                        // This run has visible content before its own trailing whitespace, so it -
+                        // not an earlier run - is the true end of the line's visible content. An
+                        // earlier run's own trailing whitespace is interior to the line (followed by
+                        // this run's visible content) and must not be excluded from Width too.
+                        break;
+                    }
                 }
             }
 
diff --git a/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLayoutTests.cs b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLayoutTests.cs
index 3c688d8e79..1c8ad72f0f 100644
--- a/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLayoutTests.cs
+++ b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLayoutTests.cs
@@ -1246,6 +1246,573 @@ namespace Avalonia.Skia.UnitTests.Media.TextFormatting
             }
         }
         
+        [Fact]
+        public void InterWordJustification_Does_Not_Stretch_Last_CJK_Glyph()
+        {
+            using (Start())
+            {
+                // Pure CJK (Han) has no inter-word spaces; UAX#14 LB31 yields a break opportunity
+                // between essentially every ideograph, so justification distributes space
+                // inter-character. Justifying to a width wider than the shaped line must widen
+                // interior glyphs (including the first) but leave the final visible glyph's advance
+                // untouched - otherwise the last ideograph is not flush to the line edge. Drives
+                // InterWordJustification directly with an explicit target width to avoid the
+                // widest-line / last-line behaviour of the full TextLayout pipeline.
+                const string text = "一二三四五";
+
+                var defaultProperties = new GenericTextRunProperties(Typeface.Default);
+                var textSource = new SingleBufferTextSource(text, defaultProperties);
+                var formatter = new TextFormatterImpl();
+
+                var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity,
+                    new GenericTextParagraphProperties(defaultProperties));
+
+                Assert.NotNull(textLine);
+
+                var naturalWidth = textLine.WidthIncludingTrailingWhitespace;
+                var before = GlyphAdvances(textLine);
+
+                Assert.True(before.Count >= 2);
+
+                var targetWidth = naturalWidth + 40;
+
+                textLine.Justify(new InterWordJustification(targetWidth));
+
+                var after = GlyphAdvances(textLine);
+
+                Assert.Equal(before.Count, after.Count);
+
+                // The line is stretched to the requested width.
+                Assert.Equal(targetWidth, textLine.WidthIncludingTrailingWhitespace, 3);
+
+                // The last visible glyph keeps its original advance (no trailing overshoot).
+                Assert.Equal(before[before.Count - 1], after[after.Count - 1], 3);
+
+                // The first glyph participates in justification (the leading gap is widened).
+                AssertGreaterThan(after[0], before[0], "The first glyph should be widened");
+            }
+        }
+
+        [Fact]
+        public void Should_Justify_Wrapped_CJK_Line_To_MaxWidth()
+        {
+            using (Start())
+            {
+                // With the MaxWidth justification target (not the widest produced line), a wrapped
+                // CJK paragraph fills each justified line to the paragraph margin, without stretching
+                // the last visible glyph of the line. Compared against a Left layout of the same
+                // text/width so the assertions do not depend on the fallback font's metrics.
+                const string text = "一二三四五六七八九十一二三四五六七八九十";
+                const double maxWidth = 100;
+
+                var foreground = Brushes.Black.ToImmutable();
+
+                var left = new TextLayout(text, Typeface.Default, 12.0f, foreground,
+                    textAlignment: TextAlignment.Left, textWrapping: TextWrapping.Wrap, maxWidth: maxWidth);
+
+                var justified = new TextLayout(text, Typeface.Default, 12.0f, foreground,
+                    textAlignment: TextAlignment.Justify, textWrapping: TextWrapping.Wrap, maxWidth: maxWidth);
+
+                // A wrapped, non-last line (the last line's treatment is a separate concern).
+                Assert.True(justified.TextLines.Count >= 2);
+
+                var leftLine = left.TextLines[0];
+                var justifiedLine = justified.TextLines[0];
+
+                // The line must have slack to distribute, otherwise the test proves nothing.
+                AssertGreaterThan(maxWidth, leftLine.WidthIncludingTrailingWhitespace,
+                    "The unjustified line must be narrower than MaxWidth");
+
+                var before = GlyphAdvances(leftLine);
+                var after = GlyphAdvances(justifiedLine);
+
+                Assert.Equal(before.Count, after.Count);
+
+                // The wrapped non-last line fills to MaxWidth (not the widest produced line).
+                Assert.Equal(maxWidth, justifiedLine.WidthIncludingTrailingWhitespace, 3);
+
+                // The last visible glyph is unchanged; the first glyph is widened.
+                Assert.Equal(before[before.Count - 1], after[after.Count - 1], 3);
+                AssertGreaterThan(after[0], before[0], "The first glyph should be widened");
+            }
+        }
+
+        [Fact]
+        public void Does_Not_Justify_Last_Line_Of_Wrapped_Paragraph()
+        {
+            using (Start())
+            {
+                // The last line of a justified paragraph stays start-aligned (its natural width),
+                // while the preceding wrapped lines fill to the margin.
+                var text = new string('一', 40);
+                const double maxWidth = 80;
+
+                var foreground = Brushes.Black.ToImmutable();
+
+                var left = new TextLayout(text, Typeface.Default, 12.0f, foreground,
+                    textAlignment: TextAlignment.Left, textWrapping: TextWrapping.Wrap, maxWidth: maxWidth);
+
+                var justified = new TextLayout(text, Typeface.Default, 12.0f, foreground,
+                    textAlignment: TextAlignment.Justify, textWrapping: TextWrapping.Wrap, maxWidth: maxWidth);
+
+                var lineCount = justified.TextLines.Count;
+
+                Assert.True(lineCount >= 2);
+
+                var lastLeft = left.TextLines[lineCount - 1];
+                var lastJustified = justified.TextLines[lineCount - 1];
+
+                // Precondition: the last line is shorter than the margin, so stretching would show.
+                AssertGreaterThan(maxWidth, lastLeft.WidthIncludingTrailingWhitespace,
+                    "The last line must be shorter than MaxWidth for the test to be meaningful");
+
+                // The last line is not stretched.
+                Assert.Equal(lastLeft.WidthIncludingTrailingWhitespace,
+                    lastJustified.WidthIncludingTrailingWhitespace, 3);
+
+                // A preceding wrapped line is still justified to the margin.
+                Assert.Equal(maxWidth, justified.TextLines[0].WidthIncludingTrailingWhitespace, 3);
+            }
+        }
+
+        [Fact]
+        public void Does_Not_Justify_Line_Ending_In_Hard_Break()
+        {
+            using (Start())
+            {
+                // "一二三" ends in an explicit newline (a hard break); it stays start-aligned while
+                // the following width-wrapped, non-last line fills to the margin.
+                var text = "一二三\n" + new string('一', 40);
+                const double maxWidth = 80;
+
+                var foreground = Brushes.Black.ToImmutable();
+
+                var left = new TextLayout(text, Typeface.Default, 12.0f, foreground,
+                    textAlignment: TextAlignment.Left, textWrapping: TextWrapping.Wrap, maxWidth: maxWidth);
+
+                var justified = new TextLayout(text, Typeface.Default, 12.0f, foreground,
+                    textAlignment: TextAlignment.Justify, textWrapping: TextWrapping.Wrap, maxWidth: maxWidth);
+
+                // Line 0 ends in '\n', line 1 is a wrapped non-last line, line 2 is the last line.
+                Assert.True(justified.TextLines.Count >= 3);
+
+                var hardBreakLeft = left.TextLines[0];
+                var hardBreakJustified = justified.TextLines[0];
+
+                AssertGreaterThan(maxWidth, hardBreakLeft.WidthIncludingTrailingWhitespace,
+                    "The hard-break line must be shorter than MaxWidth for the test to be meaningful");
+
+                // The hard-break line is not stretched.
+                Assert.Equal(hardBreakLeft.WidthIncludingTrailingWhitespace,
+                    hardBreakJustified.WidthIncludingTrailingWhitespace, 3);
+
+                // The following width-wrapped, non-last line is justified to the margin.
+                Assert.Equal(maxWidth, justified.TextLines[1].WidthIncludingTrailingWhitespace, 3);
+            }
+        }
+
+        [Fact]
+        public void Justify_Does_Not_Mutate_Shared_ShapedBuffer()
+        {
+            using (Start())
+            {
+                // A TextRunCache keeps the same ShapedTextRun (and its pooled glyph storage) alive
+                // across layouts. Justification must copy-on-write rather than mutate that shared
+                // buffer in place. Simulate the cache's reference with AddRef and assert the
+                // original buffer is untouched while the line's run is replaced with a widened copy.
+                const string text = "一二三四五";
+
+                var defaultProperties = new GenericTextRunProperties(Typeface.Default);
+                var textSource = new SingleBufferTextSource(text, defaultProperties);
+                var formatter = new TextFormatterImpl();
+
+                var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity,
+                    new GenericTextParagraphProperties(defaultProperties));
+
+                Assert.NotNull(textLine);
+
+                var originalRun = textLine.TextRuns.OfType<ShapedTextRun>().First();
+                var originalBuffer = originalRun.ShapedBuffer;
+                var originalFirstAdvance = originalBuffer[0].GlyphAdvance;
+
+                // Second owner (stands in for the TextRunCache) so the buffer survives the run's
+                // disposal during justification.
+                originalRun.AddRef();
+
+                textLine.Justify(new InterWordJustification(originalRun.Size.Width + 40));
+
+                // The shared buffer is not mutated...
+                Assert.Equal(originalFirstAdvance, originalBuffer[0].GlyphAdvance, 5);
+
+                // ...and the line now holds a different run whose first glyph was widened.
+                var justifiedRun = textLine.TextRuns.OfType<ShapedTextRun>().First();
+
+                Assert.NotSame(originalRun, justifiedRun);
+                AssertGreaterThan(justifiedRun.ShapedBuffer[0].GlyphAdvance, originalFirstAdvance,
+                    "The justified copy's first glyph should be widened");
+
+                originalRun.Dispose();
+            }
+        }
+
+        [Fact]
+        public void Justify_Repoints_Indexed_Runs_At_Replacement()
+        {
+            using (Start())
+            {
+                // Draw and hit-test resolve runs through the bidi-reordered IndexedTextRun list, so
+                // after justification replaces a run its IndexedTextRun must point at the
+                // replacement. GetTextBounds walks the indexed runs; its total must match the
+                // justified line width, not the pre-justification width.
+                var text = new string('一', 40);
+                const double maxWidth = 80;
+
+                var justified = new TextLayout(text, Typeface.Default, 12.0f, Brushes.Black.ToImmutable(),
+                    textAlignment: TextAlignment.Justify, textWrapping: TextWrapping.Wrap, maxWidth: maxWidth);
+
+                Assert.True(justified.TextLines.Count >= 2);
+
+                var line = justified.TextLines[0];
+
+                var bounds = line.GetTextBounds(line.FirstTextSourceIndex, line.Length);
+
+                Assert.Equal(line.WidthIncludingTrailingWhitespace, bounds.Sum(b => b.Rectangle.Width), 2);
+                Assert.Equal(maxWidth, bounds.Sum(b => b.Rectangle.Width), 2);
+            }
+        }
+
+        [Fact]
+        public void Justify_Distributes_Across_Multiple_Runs()
+        {
+            using (Start())
+            {
+                // Two shaped runs on one line (split by a font-size change). Each must receive its
+                // own break opportunities: the pre-fix apply loop drained the whole queue against
+                // the first run, leaving later runs unjustified.
+                const string text = "一二三四五六";
+
+                var first = new GenericTextRunProperties(Typeface.Default, 20);
+                var second = new GenericTextRunProperties(Typeface.Default, 12);
+                var textSource = new SplitStyleTextSource(text, 3, first, second);
+                var formatter = new TextFormatterImpl();
+
+                var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity,
+                    new GenericTextParagraphProperties(first));
+
+                Assert.NotNull(textLine);
+
+                var runs = textLine.TextRuns.OfType<ShapedTextRun>().ToList();
+
+                // Confirm the line really is multi-run, otherwise the test proves nothing.
+                Assert.True(runs.Count >= 2);
+
+                var beforeWidths = runs.Select(r => r.Size.Width).ToList();
+
+                textLine.Justify(new InterWordJustification(textLine.WidthIncludingTrailingWhitespace + 60));
+
+                var afterRuns = textLine.TextRuns.OfType<ShapedTextRun>().ToList();
+
+                Assert.Equal(runs.Count, afterRuns.Count);
+
+                // Every shaped run participated in justification, not just the first.
+                for (var i = 0; i < afterRuns.Count; i++)
+                {
+                    AssertGreaterThan(afterRuns[i].Size.Width, beforeWidths[i], $"Run {i} should be widened");
+                }
+            }
+        }
+
+        [Theory]
+        [InlineData("aa bb   ")]     // trailing ASCII spaces
+        [InlineData("一二　　　")]    // trailing ideographic (U+3000) spaces
+        public void Justify_Does_Not_Space_Trailing_Whitespace(string text)
+        {
+            using (Start())
+            {
+                // Trailing whitespace (which sits before a wrap point or hard break) must never
+                // receive justification space; the full distributed amount lands in the visible
+                // region instead. This is guaranteed by the LineBreakEnumerator (it emits no
+                // non-required break inside trailing whitespace), so no explicit guard is needed in
+                // InterWordJustification - this test locks that invariant. Width excludes trailing
+                // whitespace, so it must grow by the entire distributed space; if trailing
+                // whitespace absorbed part of it, Width would grow less.
+                const double extra = 40;
+
+                var defaultProperties = new GenericTextRunProperties(Typeface.Default);
+                var textSource = new SingleBufferTextSource(text, defaultProperties);
+                var formatter = new TextFormatterImpl();
+
+                var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity,
+                    new GenericTextParagraphProperties(defaultProperties));
+
+                Assert.NotNull(textLine);
+
+                // Confirm the line actually carries trailing whitespace, otherwise the test proves nothing.
+                Assert.True(textLine.TrailingWhitespaceLength >= 2);
+                AssertGreaterThan(textLine.WidthIncludingTrailingWhitespace, textLine.Width,
+                    "The line must have measurable trailing whitespace");
+
+                var widthBefore = textLine.Width;
+
+                textLine.Justify(new InterWordJustification(textLine.Width + extra));
+
+                Assert.Equal(widthBefore + extra, textLine.Width, 2);
+            }
+        }
+
+        [Fact]
+        public void Should_Justify_Wrapped_Latin_Line()
+        {
+            // The classic inter-word case. A wrapped non-last Latin line fills to the margin; the
+            // last line stays start-aligned.
+            using (Start())
+            {
+                AssertWrappedNonLastLineFillsToMaxWidth(
+                    "the quick brown fox jumps over the lazy dog and then runs away quite quickly today", 140);
+            }
+        }
+
+        // Korean Hangul justifies inter-syllable via the same code path as CJK (LB26/27 bind within
+        // a syllable, LB31 breaks between syllable blocks). A live Korean advance test is not
+        // possible here because the test harness's fallback fonts render Hangul with zero advance
+        // (no Korean font installed), so the CJK tests stand in for it.
+
+        [Fact]
+        public void Does_Not_Justify_Latin_Line_With_Trailing_Spaces_Before_Hard_Break()
+        {
+            using (Start())
+            {
+                // A line ending in trailing spaces + a hard break stays start-aligned (its trailing
+                // whitespace is not stretched), while the following wrapped lines still fill to the
+                // margin.
+                var text = "aa bb   \n" + string.Join(" ", Enumerable.Repeat("cc", 40));
+                const double maxWidth = 120;
+
+                var foreground = Brushes.Black.ToImmutable();
+
+                var left = new TextLayout(text, Typeface.Default, 12.0f, foreground,
+                    textAlignment: TextAlignment.Left, textWrapping: TextWrapping.Wrap, maxWidth: maxWidth);
+
+                var justified = new TextLayout(text, Typeface.Default, 12.0f, foreground,
+                    textAlignment: TextAlignment.Justify, textWrapping: TextWrapping.Wrap, maxWidth: maxWidth);
+
+                Assert.True(justified.TextLines.Count >= 3);
+
+                var line0Left = left.TextLines[0];
+                var line0Justified = justified.TextLines[0];
+
+                AssertGreaterThan(maxWidth, line0Left.WidthIncludingTrailingWhitespace,
+                    "The hard-break line must be shorter than MaxWidth for the test to be meaningful");
+
+                // The trailing-spaces + '\n' line is not stretched.
+                Assert.Equal(line0Left.WidthIncludingTrailingWhitespace,
+                    line0Justified.WidthIncludingTrailingWhitespace, 2);
+
+                // A following width-wrapped, non-last line fills its visible content to the margin.
+                Assert.Equal(maxWidth, justified.TextLines[1].Width, 2);
+            }
+        }
+
+        [Fact]
+        public void Justify_Distributes_Across_Latin_And_CJK()
+        {
+            using (Start())
+            {
+                // A mixed Latin+CJK line distributes space across both the inter-word gap and the
+                // inter-ideograph gaps (the line reaches the target width) without stretching the
+                // last visible glyph.
+                const string text = "ab 日本語";
+
+                var defaultProperties = new GenericTextRunProperties(Typeface.Default);
+                var textSource = new SingleBufferTextSource(text, defaultProperties);
+                var formatter = new TextFormatterImpl();
+
+                var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity,
+                    new GenericTextParagraphProperties(defaultProperties));
+
+                Assert.NotNull(textLine);
+
+                var lastGlyphBefore = LastGlyphAdvance(textLine);
+
+                var target = textLine.WidthIncludingTrailingWhitespace + 40;
+
+                textLine.Justify(new InterWordJustification(target));
+
+                // Space was distributed across the mixed content (the line reaches the target)...
+                Assert.Equal(target, textLine.WidthIncludingTrailingWhitespace, 2);
+
+                // ...but the last visible glyph is not stretched.
+                Assert.Equal(lastGlyphBefore, LastGlyphAdvance(textLine), 3);
+            }
+        }
+
+        [Fact]
+        public void Justify_Arabic_Does_Not_Corrupt_Shared_Buffer()
+        {
+            using (Start())
+            {
+                // Arabic is cursive and right-to-left (ligated, not one-char-per-cluster), so
+                // justification exercises the copy-on-write path on a non-trivial run. It must run
+                // without corrupting a cache-shared buffer.
+                const string text = "مرحبا بالعالم";
+
+                var defaultProperties = new GenericTextRunProperties(Typeface.Default);
+                var textSource = new SingleBufferTextSource(text, defaultProperties);
+                var formatter = new TextFormatterImpl();
+
+                var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity,
+                    new GenericTextParagraphProperties(defaultProperties));
+
+                Assert.NotNull(textLine);
+
+                var originalRun = textLine.TextRuns.OfType<ShapedTextRun>().First();
+                var originalBuffer = originalRun.ShapedBuffer;
+                var originalAdvances = Enumerable.Range(0, originalBuffer.Length)
+                    .Select(i => originalBuffer[i].GlyphAdvance).ToList();
+
+                // Second owner (stands in for a TextRunCache) so the buffer survives run disposal.
+                originalRun.AddRef();
+
+                var widthBefore = textLine.WidthIncludingTrailingWhitespace;
+
+                textLine.Justify(new InterWordJustification(widthBefore + 40));
+
+                // Justification happened (the inter-word gap was widened)...
+                AssertGreaterThan(textLine.WidthIncludingTrailingWhitespace, widthBefore,
+                    "Justifying an Arabic line should widen it");
+
+                // ...and the shared buffer was not mutated in place.
+                for (var i = 0; i < originalBuffer.Length; i++)
+                {
+                    Assert.Equal(originalAdvances[i], originalBuffer[i].GlyphAdvance, 5);
+                }
+
+                originalRun.Dispose();
+            }
+        }
+
+        private static void AssertWrappedNonLastLineFillsToMaxWidth(string text, double maxWidth)
+        {
+            var foreground = Brushes.Black.ToImmutable();
+
+            var left = new TextLayout(text, Typeface.Default, 12.0f, foreground,
+                textAlignment: TextAlignment.Left, textWrapping: TextWrapping.Wrap, maxWidth: maxWidth);
+
+            var justified = new TextLayout(text, Typeface.Default, 12.0f, foreground,
+                textAlignment: TextAlignment.Justify, textWrapping: TextWrapping.Wrap, maxWidth: maxWidth);
+
+            Assert.True(justified.TextLines.Count >= 2);
+
+            var leftLine = left.TextLines[0];
+            var justifiedLine = justified.TextLines[0];
+
+            AssertGreaterThan(maxWidth, leftLine.Width,
+                "The unjustified line's visible content must be narrower than MaxWidth");
+
+            // The non-last wrapped line's visible content fills to the margin. (Width excludes any
+            // trailing whitespace, which hangs past the margin.)
+            Assert.Equal(maxWidth, justifiedLine.Width, 2);
+
+            // The last line stays start-aligned.
+            var lastLeft = left.TextLines[left.TextLines.Count - 1];
+            var lastJustified = justified.TextLines[justified.TextLines.Count - 1];
+
+            Assert.Equal(lastLeft.WidthIncludingTrailingWhitespace,
+                lastJustified.WidthIncludingTrailingWhitespace, 2);
+        }
+
+        private static double LastGlyphAdvance(TextLine line)
+        {
+            var glyphs = line.TextRuns.OfType<ShapedTextRun>().Last().GlyphRun.GlyphInfos;
+
+            return glyphs[glyphs.Count - 1].GlyphAdvance;
+        }
+
+        private sealed class SplitStyleTextSource : ITextSource
+        {
+            private readonly string _text;
+            private readonly int _splitAt;
+            private readonly GenericTextRunProperties _first;
+            private readonly GenericTextRunProperties _second;
+
+            public SplitStyleTextSource(string text, int splitAt,
+                GenericTextRunProperties first, GenericTextRunProperties second)
+            {
+                _text = text;
+                _splitAt = splitAt;
+                _first = first;
+                _second = second;
+            }
+
+            public TextRun? GetTextRun(int textSourceIndex)
+            {
+                if (textSourceIndex >= _text.Length)
+                {
+                    return null;
+                }
+
+                if (textSourceIndex < _splitAt)
+                {
+                    return new TextCharacters(_text.AsMemory(textSourceIndex, _splitAt - textSourceIndex), _first);
+                }
+
+                return new TextCharacters(_text.AsMemory(textSourceIndex), _second);
+            }
+        }
+
+        private static List<double> GlyphAdvances(TextLine line)
+        {
+            var advances = new List<double>();
+
+            foreach (var run in line.TextRuns)
+            {
+                if (run is ShapedTextRun shaped)
+                {
+                    foreach (var glyph in shaped.GlyphRun.GlyphInfos)
+                    {
+                        advances.Add(glyph.GlyphAdvance);
+                    }
+                }
+            }
+
+            return advances;
+        }
+
+        [Fact]
+        public void Width_Excludes_Only_The_Lines_True_Trailing_Whitespace()
+        {
+            using (Start())
+            {
+                // Two runs split by a font-size change. The FIRST (interior) run also ends in a
+                // space of its own ("foo "), but that space is followed by more visible content
+                // ("bar") in the next run, so it is NOT trailing whitespace for the line as a
+                // whole - only the space at the true end of the line is. A reference line without
+                // any trailing space isolates exactly how much Width should differ.
+                var first = new GenericTextRunProperties(Typeface.Default, 20);
+                var second = new GenericTextRunProperties(Typeface.Default, 14);
+                var formatter = new TextFormatterImpl();
+
+                var reference = formatter.FormatLine(new SplitStyleTextSource("foo bar", 4, first, second), 0,
+                    double.PositiveInfinity, new GenericTextParagraphProperties(first));
+
+                var withTrailingSpace = formatter.FormatLine(new SplitStyleTextSource("foo bar ", 4, first, second), 0,
+                    double.PositiveInfinity, new GenericTextParagraphProperties(first));
+
+                Assert.NotNull(reference);
+                Assert.NotNull(withTrailingSpace);
+
+                // Confirm both lines are genuinely multi-run, and the reference truly has no
+                // trailing whitespace, otherwise the comparison proves nothing.
+                Assert.True(reference.TextRuns.OfType<ShapedTextRun>().Count() >= 2);
+                Assert.Equal(0, reference.TrailingWhitespaceLength);
+
+                // Only the one added trailing space is excluded - not that space AND "foo "'s own
+                // interior trailing space too.
+                Assert.Equal(1, withTrailingSpace.TrailingWhitespaceLength);
+                Assert.Equal(reference.Width, withTrailingSpace.Width, 3);
+            }
+        }
+
         private static void AssertGreaterThan(double x, double y, string message) => Assert.True(x > y, $"{message}. {x} is not > {y}");
 
         private static IDisposable Start()

From 9becf5d6345621707e10cac038465eb5e4f078a9 Mon Sep 17 00:00:00 2001
From: JoshuaRowePhantom <49595589+JoshuaRowePhantom@users.noreply.github.com>
Date: Mon, 6 Jul 2026 04:13:38 -0700
Subject: [PATCH 069/196] Fix SelectableTextBlock selection offset with
 InlineUIContainer (#21646)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Fix SelectableTextBlock selection offset with InlineUIContainer (#15880)

EmbeddedControlRun inherits TextRun.DefaultTextSourceLength = 1, so each
InlineUIContainer occupies one position in TextLayout. However,
InlineUIContainer.AppendText was a no-op, causing Inlines.Text to have
zero characters for each embedded control. This made TextLayout.HitTestPoint
return positions that were ahead of Inlines.Text indices by one per
InlineUIContainer, breaking SelectedText for any text after an embedded
control.

Fix: append the Unicode Object Replacement Character (U+FFFC) — the
standard placeholder for embedded objects — in AppendText so that
Inlines.Text character offsets stay in sync with the TextLayout positions.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Expand InlineUIContainer selection tests with fencepost cases

Replace single assertion with a [Theory] covering all boundary positions
around the embedded control in 'foo\uFFFCbar':
- entirely before the container
- exactly the container character
- up to and including the container
- starting exactly after the container
- container through end
- one character either side of the container
- entire content

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Documents/InlineUIContainer.cs            |  4 ++
 .../SelectableTextBlockTests.cs               | 40 +++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/src/Avalonia.Controls/Documents/InlineUIContainer.cs b/src/Avalonia.Controls/Documents/InlineUIContainer.cs
index 35f04231bf..b71c2bc289 100644
--- a/src/Avalonia.Controls/Documents/InlineUIContainer.cs
+++ b/src/Avalonia.Controls/Documents/InlineUIContainer.cs
@@ -66,6 +66,10 @@ namespace Avalonia.Controls.Documents
 
         internal override void AppendText(StringBuilder stringBuilder)
         {
+            // EmbeddedControlRun occupies one position in TextLayout (TextRun.DefaultTextSourceLength = 1).
+            // Append the Unicode Object Replacement Character so that Inlines.Text stays in sync with
+            // the character offsets returned by TextLayout.HitTestPoint.
+            stringBuilder.Append('\uFFFC');
         }
 
         protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
diff --git a/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs b/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs
index 7fe31449cf..58b9654e61 100644
--- a/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs
@@ -9,6 +9,46 @@ namespace Avalonia.Controls.UnitTests
 {
     public class SelectableTextBlockTests : ScopedTestBase
     {
+        // Content: Run("foo") + InlineUIContainer + Run("bar")
+        // Inlines.Text after fix: "foo\uFFFCbar" (indices 0-6)
+        //   0='f', 1='o', 2='o', 3='\uFFFC' (embedded control), 4='b', 5='a', 6='r'
+        [Theory]
+        // Entirely before InlineUIContainer
+        [InlineData(0, 3, "foo")]
+        // Exactly the InlineUIContainer character
+        [InlineData(3, 4, "\uFFFC")]
+        // Up to and including InlineUIContainer (fencepost: last char before "bar")
+        [InlineData(0, 4, "foo\uFFFC")]
+        // Starting exactly after InlineUIContainer (fencepost: first char of "bar")
+        [InlineData(4, 7, "bar")]
+        // InlineUIContainer through end
+        [InlineData(3, 7, "\uFFFCbar")]
+        // Spanning InlineUIContainer (one char either side)
+        [InlineData(2, 5, "o\uFFFCb")]
+        // Entire content
+        [InlineData(0, 7, "foo\uFFFCbar")]
+        public void Selection_With_InlineUIContainer_Returns_Correct_Text(int start, int end, string expected)
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                var target = new SelectableTextBlock();
+
+                target.Inlines!.Add(new Run("foo"));
+                target.Inlines!.Add(new InlineUIContainer(new Border()));
+                target.Inlines!.Add(new Run("bar"));
+
+                target.Measure(Size.Infinity);
+
+                // SelectionStart/End values correspond to TextLayout character positions.
+                // EmbeddedControlRun occupies 1 position (TextRun.DefaultTextSourceLength),
+                // and Inlines.Text now has a matching U+FFFC placeholder, so they stay in sync.
+                target.SelectionStart = start;
+                target.SelectionEnd = end;
+
+                Assert.Equal(expected, target.SelectedText);
+            }
+        }
+
         [Fact]
         public void SelectionForeground_Should_Not_Reset_Run_Typeface_And_Style()
         {

From 4e0632cf4280adf6d5ec0d5bf2e86b4488a3ec0f Mon Sep 17 00:00:00 2001
From: yoyo <zrt2399@163.com>
Date: Mon, 6 Jul 2026 19:32:37 +0800
Subject: [PATCH 070/196] Allow copying and cutting revealed TextBox passwords
 (#21710)

---
 src/Avalonia.Controls/TextBox.cs              | 10 +++---
 .../TextBoxTests.cs                           | 34 +++++++++++++++++++
 2 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/src/Avalonia.Controls/TextBox.cs b/src/Avalonia.Controls/TextBox.cs
index eb72638744..0f2e3d51ce 100644
--- a/src/Avalonia.Controls/TextBox.cs
+++ b/src/Avalonia.Controls/TextBox.cs
@@ -1041,7 +1041,9 @@ namespace Avalonia.Controls
                 UpdatePseudoclasses();
                 UpdateCommandStates();
             }
-            else if (change.Property == IsReadOnlyProperty || change.Property == PasswordCharProperty)
+            else if (change.Property == IsReadOnlyProperty ||
+                change.Property == PasswordCharProperty ||
+                change.Property == RevealPasswordProperty)
             {
                 UpdateCommandStates();
             }
@@ -1746,7 +1748,7 @@ namespace Avalonia.Controls
                 else
                 {
                     // We select the current held word, or the whole hidden content
-                    if (IsPasswordBox && !RevealPassword)
+                    if (IsPasswordBox)
                     {
                         _wordSelectionStart = -1;
 
@@ -1881,7 +1883,7 @@ namespace Avalonia.Controls
 
         private void SelectWord(string text, int caretIndex, int selectionStart, int selectionEnd)
         {
-            if (IsPasswordBox && !RevealPassword)
+            if (IsPasswordBox)
             {
                 // double-clicking in a cloaked single-line password box selects all text
                 // see https://github.com/AvaloniaUI/Avalonia/issues/14956
@@ -2530,7 +2532,7 @@ namespace Avalonia.Controls
             PseudoClasses.Set(":touch-mode", _isInTouchMode);
         }
 
-        private bool IsPasswordBox => PasswordChar != default(char);
+        private bool IsPasswordBox => PasswordChar != default(char) && !RevealPassword;
 
         UndoRedoState UndoRedoHelper<UndoRedoState>.IUndoRedoHost.UndoRedoState
         {
diff --git a/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs b/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
index bf0af90b27..46af86b98d 100644
--- a/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
@@ -1527,6 +1527,40 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Command_States_Update_When_RevealPassword_Changes()
+        {
+            using (UnitTestApplication.Start(Services))
+            {
+                var tb = new TextBox
+                {
+                    Template = CreateTemplate(),
+                    Text = "1234",
+                    PasswordChar = '*',
+                    SelectionStart = 1,
+                    SelectionEnd = 3,
+                };
+
+                tb.Measure(Size.Infinity);
+
+                Assert.False(tb.CanCopy);
+                Assert.False(tb.CanCut);
+                Assert.True(tb.CanPaste);
+
+                tb.RevealPassword = true;
+
+                Assert.True(tb.CanCopy);
+                Assert.True(tb.CanCut);
+                Assert.True(tb.CanPaste);
+
+                tb.RevealPassword = false;
+
+                Assert.False(tb.CanCopy);
+                Assert.False(tb.CanCut);
+                Assert.True(tb.CanPaste);
+            }
+        }
+
         [Fact]
         public void ReadOnly_Editing_Hotkeys_Do_Not_Modify_Text_Or_Undo_State()
         {

From 50ad0828704354c08c19c64956380a7123b1abd6 Mon Sep 17 00:00:00 2001
From: Misaka_L <lipww1234@foxmail.com>
Date: Mon, 6 Jul 2026 22:41:08 +0800
Subject: [PATCH 071/196] Fix working area changed on windows platform won't
 update screen (#21707)

* Fix working area changed on windows platform won't trigger screens changed

* Fix ScreensPage on IntegrationTestApp won't remove Screens.Changed listener

* Add SystemParametersInfo.SPI_SETWORKAREA to Win32 UnmanagedMethods class

* Move notify screen working area changed to Win32Platform.WndProc instead of WindowImpl.AppWndProc

* Notify working area changed to screens without check PlatformSettings is Win32PlatformSettings
---
 .../Pages/ScreensPage.axaml                   |  5 +++
 .../Pages/ScreensPage.axaml.cs                | 38 +++++++++++++++++++
 .../Interop/UnmanagedMethods.cs               |  5 +++
 src/Windows/Avalonia.Win32/Win32Platform.cs   | 20 +++++++---
 4 files changed, 62 insertions(+), 6 deletions(-)

diff --git a/samples/IntegrationTestApp/Pages/ScreensPage.axaml b/samples/IntegrationTestApp/Pages/ScreensPage.axaml
index 7f0b341714..183351b5d6 100644
--- a/samples/IntegrationTestApp/Pages/ScreensPage.axaml
+++ b/samples/IntegrationTestApp/Pages/ScreensPage.axaml
@@ -3,11 +3,15 @@
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+             AttachedToVisualTree="OnAttachedToVisualTree" DetachedFromVisualTree="OnDetachedFromVisualTree"
              x:Class="IntegrationTestApp.Pages.ScreensPage">
   <StackPanel Spacing="4">
     <Button Name="ScreenRefresh"
             Content="Refresh"
             Click="ScreenRefresh_Click"/>
+    <Button Name="UpdateViewOnly"
+            Content="Update View Only"
+            Click="UpdateViewOnly_OnClick"/>
     <TextBox Name="ScreenName" PlaceholderText="DisplayName" UseFloatingPlaceholder="true" />
     <TextBox Name="ScreenHandle" PlaceholderText="Handle" UseFloatingPlaceholder="true" />
     <TextBox Name="ScreenScaling" PlaceholderText="Scaling" UseFloatingPlaceholder="true" />
@@ -15,5 +19,6 @@
     <TextBox Name="ScreenWorkArea" PlaceholderText="WorkArea" UseFloatingPlaceholder="true" />
     <TextBox Name="ScreenOrientation" PlaceholderText="Orientation" UseFloatingPlaceholder="true" />
     <TextBox Name="ScreenSameReference" PlaceholderText="Is same reference" UseFloatingPlaceholder="true" />
+    <TextBox Name="ScreenOnChangedCounter" PlaceholderText="Screens.Changed Counter" UseFloatingPlaceholder="True" />
   </StackPanel>
 </UserControl>
diff --git a/samples/IntegrationTestApp/Pages/ScreensPage.axaml.cs b/samples/IntegrationTestApp/Pages/ScreensPage.axaml.cs
index a9348f86e3..9415b58097 100644
--- a/samples/IntegrationTestApp/Pages/ScreensPage.axaml.cs
+++ b/samples/IntegrationTestApp/Pages/ScreensPage.axaml.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Globalization;
 using Avalonia;
 using Avalonia.Controls;
@@ -9,12 +10,37 @@ namespace IntegrationTestApp.Pages;
 public partial class ScreensPage : UserControl
 {
     private Screen? _lastScreen;
+    private int _onScreenChangedCounter;
+
+    private Window? _lastWindow;
 
     public ScreensPage()
     {
         InitializeComponent();
     }
 
+    private void OnAttachedToVisualTree(object? sender, VisualTreeAttachmentEventArgs e)
+    {
+        _lastWindow = TopLevel.GetTopLevel(this) as Window ??
+                      throw new AvaloniaInternalException("ScreensPage is not attached to a Window.");
+        _lastWindow.Screens.Changed += OnScreenChanged;
+
+        _onScreenChangedCounter = 0;
+        ScreenOnChangedCounter.Text = _onScreenChangedCounter.ToString();
+    }
+
+    private void OnDetachedFromVisualTree(object? sender, VisualTreeAttachmentEventArgs e)
+    {
+        _lastWindow?.Screens.Changed -= OnScreenChanged;
+        _lastWindow = null;
+    }
+
+    private void OnScreenChanged(object? sender, EventArgs e)
+    {
+        _onScreenChangedCounter++;
+        ScreenOnChangedCounter.Text = _onScreenChangedCounter.ToString();
+    }
+
     private void ScreenRefresh_Click(object? sender, RoutedEventArgs e)
     {
         var window = TopLevel.GetTopLevel(this) as Window ??
@@ -29,4 +55,16 @@ public partial class ScreensPage : UserControl
         ScreenOrientation.Text = screen?.CurrentOrientation.ToString();
         ScreenSameReference.Text = ReferenceEquals(lastScreen, screen).ToString();
     }
+
+    private void UpdateViewOnly_OnClick(object? sender, RoutedEventArgs e)
+    {
+        var screen = _lastScreen;
+        ScreenName.Text = screen?.DisplayName;
+        ScreenHandle.Text = screen?.TryGetPlatformHandle()?.ToString();
+        ScreenBounds.Text = screen?.Bounds.ToString();
+        ScreenWorkArea.Text = screen?.WorkingArea.ToString();
+        ScreenScaling.Text = screen?.Scaling.ToString(CultureInfo.InvariantCulture);
+        ScreenOrientation.Text = screen?.CurrentOrientation.ToString();
+        ScreenSameReference.Text = ReferenceEquals(_lastScreen, screen).ToString();
+    }
 }
diff --git a/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs b/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs
index 1f8b0bdce3..e7aecc508c 100644
--- a/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs
+++ b/src/Windows/Avalonia.Win32/Interop/UnmanagedMethods.cs
@@ -833,6 +833,11 @@ namespace Avalonia.Win32.Interop
             WM_DISPATCH_WORK_ITEM = WM_USER,
         }
 
+        public enum SystemParametersInfo
+        {
+            SPI_SETWORKAREA = 0x002F
+        }
+
         public enum DwmWindowAttribute : uint
         {
             DWMWA_NCRENDERING_ENABLED = 1,
diff --git a/src/Windows/Avalonia.Win32/Win32Platform.cs b/src/Windows/Avalonia.Win32/Win32Platform.cs
index 6be81dd2d9..5eaee60448 100644
--- a/src/Windows/Avalonia.Win32/Win32Platform.cs
+++ b/src/Windows/Avalonia.Win32/Win32Platform.cs
@@ -176,14 +176,22 @@ namespace Avalonia.Win32
                 }
             }
 
-            if (msg == (uint)WindowsMessage.WM_SETTINGCHANGE 
-                && PlatformSettings is Win32PlatformSettings win32PlatformSettings)
+            if (msg == (uint)WindowsMessage.WM_SETTINGCHANGE)
             {
-                var changedSetting = Marshal.PtrToStringAuto(lParam);
-                if (changedSetting == "ImmersiveColorSet" // dark/light mode
-                    || changedSetting == "WindowsThemeElement") // high contrast mode
+                if (PlatformSettings is Win32PlatformSettings win32PlatformSettings)
                 {
-                    win32PlatformSettings.OnColorValuesChanged();   
+                    var changedSetting = Marshal.PtrToStringAuto(lParam);
+                    if (changedSetting == "ImmersiveColorSet" // dark/light mode
+                        || changedSetting == "WindowsThemeElement") // high contrast mode
+                    {
+                        win32PlatformSettings.OnColorValuesChanged();
+                    }
+                }
+
+                // Notify WorkingArea changed to Screens
+                if ((SystemParametersInfo)wParam == SystemParametersInfo.SPI_SETWORKAREA)
+                {
+                    Screen?.OnChanged();
                 }
             }
 

From 176b2b892d67f59187aab915d84ff17377e37a63 Mon Sep 17 00:00:00 2001
From: Misaka_L <lipww1234@foxmail.com>
Date: Tue, 7 Jul 2026 01:30:21 +0800
Subject: [PATCH 072/196] Fix `BclLauncher.Exec` throw exception instead of
 return false (#21704)

* Fix BclLauncher throw exception instead of return false when Process.Start thrown

* Add logging message when BclLauncher.Exec fail
---
 .../Platform/Storage/FileIO/BclLauncher.cs    | 52 +++++++++++--------
 1 file changed, 31 insertions(+), 21 deletions(-)

diff --git a/src/Avalonia.Base/Platform/Storage/FileIO/BclLauncher.cs b/src/Avalonia.Base/Platform/Storage/FileIO/BclLauncher.cs
index da4cb01df5..a380be57e2 100644
--- a/src/Avalonia.Base/Platform/Storage/FileIO/BclLauncher.cs
+++ b/src/Avalonia.Base/Platform/Storage/FileIO/BclLauncher.cs
@@ -2,6 +2,7 @@
 using System.Diagnostics;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+using Avalonia.Logging;
 
 namespace Avalonia.Platform.Storage.FileIO;
 
@@ -38,31 +39,40 @@ internal class BclLauncher : ILauncher
     
     private static bool Exec(string urlOrFile)
     {
-        if (OperatingSystem.IsLinux())
+        try
         {
-            // If no associated application/json MimeType is found xdg-open opens return error
-            // but it tries to open it anyway using the console editor (nano, vim, other..)
-            var args = EscapeForShell(urlOrFile);
-            ShellExecRaw($"xdg-open \\\"{args}\\\"", waitForExit: false);
-            return true;
-        }
-        else if (OperatingSystem.IsWindows() || OperatingSystem.IsMacOS())
-        {
-            var info = new ProcessStartInfo
+            if (OperatingSystem.IsLinux())
+            {
+                // If no associated application/json MimeType is found xdg-open opens return error
+                // but it tries to open it anyway using the console editor (nano, vim, other..)
+                var args = EscapeForShell(urlOrFile);
+                ShellExecRaw($"xdg-open \\\"{args}\\\"", waitForExit: false);
+                return true;
+            }
+            else if (OperatingSystem.IsWindows() || OperatingSystem.IsMacOS())
             {
-                FileName = OperatingSystem.IsWindows() ? urlOrFile : "open",
-                CreateNoWindow = true,
-                UseShellExecute = OperatingSystem.IsWindows()
-            };
-            // Using the argument list avoids having to escape spaces and other special 
-            // characters that are part of valid macos file and folder paths.
-            if (OperatingSystem.IsMacOS())
-                info.ArgumentList.Add(urlOrFile);
-            using var process = Process.Start(info);
-            return true;
+                var info = new ProcessStartInfo
+                {
+                    FileName = OperatingSystem.IsWindows() ? urlOrFile : "open",
+                    CreateNoWindow = true,
+                    UseShellExecute = OperatingSystem.IsWindows()
+                };
+                // Using the argument list avoids having to escape spaces and other special 
+                // characters that are part of valid macos file and folder paths.
+                if (OperatingSystem.IsMacOS())
+                    info.ArgumentList.Add(urlOrFile);
+                using var process = Process.Start(info);
+                return true;
+            }
+            else
+            {
+                return false;
+            }
         }
-        else
+        catch(Exception ex)
         {
+            Logger.TryGet(LogEventLevel.Error, nameof(BclLauncher))?
+                .Log(null, "Exception during BclLauncher.Exec: {Error}", ex);
             return false;
         }
     }

From 04e8b20e4767ce7a607ec61efe7699af514242ac Mon Sep 17 00:00:00 2001
From: Jaex <Jaex@users.noreply.github.com>
Date: Mon, 6 Jul 2026 20:43:30 +0300
Subject: [PATCH 073/196] Show checkerboard background for transparent color
 palette items (#21613)

---
 .../Themes/Fluent/ColorPicker.xaml            | 20 +++++++++++--------
 .../Themes/Fluent/ColorView.xaml              | 20 +++++++++++--------
 .../Themes/Simple/ColorPicker.xaml            | 20 +++++++++++--------
 .../Themes/Simple/ColorView.xaml              | 20 +++++++++++--------
 4 files changed, 48 insertions(+), 32 deletions(-)

diff --git a/src/Avalonia.Controls.ColorPicker/Themes/Fluent/ColorPicker.xaml b/src/Avalonia.Controls.ColorPicker/Themes/Fluent/ColorPicker.xaml
index b74e4e59aa..90904fbc75 100644
--- a/src/Avalonia.Controls.ColorPicker/Themes/Fluent/ColorPicker.xaml
+++ b/src/Avalonia.Controls.ColorPicker/Themes/Fluent/ColorPicker.xaml
@@ -182,14 +182,18 @@
                              Margin="12">
                       <ListBox.ItemTemplate>
                         <DataTemplate DataType="{x:Type Color}">
-                          <Border AutomationProperties.Name="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
-                                  ToolTip.Tip="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
-                                  HorizontalAlignment="Stretch"
-                                  VerticalAlignment="Stretch">
-                            <Border.Background>
-                              <SolidColorBrush Color="{Binding}" />
-                            </Border.Background>
-                          </Border>
+                          <Panel AutomationProperties.Name="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
+                                 ToolTip.Tip="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
+                                 HorizontalAlignment="Stretch"
+                                 VerticalAlignment="Stretch">
+                            <Border Background="{StaticResource ColorControlCheckeredBackgroundBrush}" />
+                            <Border HorizontalAlignment="Stretch"
+                                    VerticalAlignment="Stretch">
+                              <Border.Background>
+                                <SolidColorBrush Color="{Binding}" />
+                              </Border.Background>
+                            </Border>
+                          </Panel>
                         </DataTemplate>
                       </ListBox.ItemTemplate>
                       <ListBox.ItemsPanel>
diff --git a/src/Avalonia.Controls.ColorPicker/Themes/Fluent/ColorView.xaml b/src/Avalonia.Controls.ColorPicker/Themes/Fluent/ColorView.xaml
index ad517e8e80..6f92d20043 100644
--- a/src/Avalonia.Controls.ColorPicker/Themes/Fluent/ColorView.xaml
+++ b/src/Avalonia.Controls.ColorPicker/Themes/Fluent/ColorView.xaml
@@ -426,14 +426,18 @@
                        Margin="12">
                 <ListBox.ItemTemplate>
                   <DataTemplate DataType="{x:Type Color}">
-                    <Border AutomationProperties.Name="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
-                            ToolTip.Tip="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
-                            HorizontalAlignment="Stretch"
-                            VerticalAlignment="Stretch">
-                      <Border.Background>
-                        <SolidColorBrush Color="{Binding}" />
-                      </Border.Background>
-                    </Border>
+                    <Panel AutomationProperties.Name="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
+                           ToolTip.Tip="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
+                           HorizontalAlignment="Stretch"
+                           VerticalAlignment="Stretch">
+                      <Border Background="{StaticResource ColorControlCheckeredBackgroundBrush}" />
+                      <Border HorizontalAlignment="Stretch"
+                              VerticalAlignment="Stretch">
+                        <Border.Background>
+                          <SolidColorBrush Color="{Binding}" />
+                        </Border.Background>
+                      </Border>
+                    </Panel>
                   </DataTemplate>
                 </ListBox.ItemTemplate>
                 <ListBox.ItemsPanel>
diff --git a/src/Avalonia.Controls.ColorPicker/Themes/Simple/ColorPicker.xaml b/src/Avalonia.Controls.ColorPicker/Themes/Simple/ColorPicker.xaml
index c2535086fa..79ddbc602a 100644
--- a/src/Avalonia.Controls.ColorPicker/Themes/Simple/ColorPicker.xaml
+++ b/src/Avalonia.Controls.ColorPicker/Themes/Simple/ColorPicker.xaml
@@ -184,14 +184,18 @@
                              Margin="12">
                       <ListBox.ItemTemplate>
                         <DataTemplate DataType="{x:Type Color}">
-                          <Border AutomationProperties.Name="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
-                                  ToolTip.Tip="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
-                                  HorizontalAlignment="Stretch"
-                                  VerticalAlignment="Stretch">
-                            <Border.Background>
-                              <SolidColorBrush Color="{Binding}" />
-                            </Border.Background>
-                          </Border>
+                          <Panel AutomationProperties.Name="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
+                                 ToolTip.Tip="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
+                                 HorizontalAlignment="Stretch"
+                                 VerticalAlignment="Stretch">
+                            <Border Background="{StaticResource ColorControlCheckeredBackgroundBrush}" />
+                            <Border HorizontalAlignment="Stretch"
+                                    VerticalAlignment="Stretch">
+                              <Border.Background>
+                                <SolidColorBrush Color="{Binding}" />
+                              </Border.Background>
+                            </Border>
+                          </Panel>
                         </DataTemplate>
                       </ListBox.ItemTemplate>
                       <ListBox.ItemsPanel>
diff --git a/src/Avalonia.Controls.ColorPicker/Themes/Simple/ColorView.xaml b/src/Avalonia.Controls.ColorPicker/Themes/Simple/ColorView.xaml
index 095c82a176..f46bc3f86d 100644
--- a/src/Avalonia.Controls.ColorPicker/Themes/Simple/ColorView.xaml
+++ b/src/Avalonia.Controls.ColorPicker/Themes/Simple/ColorView.xaml
@@ -390,14 +390,18 @@
                        Margin="12">
                 <ListBox.ItemTemplate>
                   <DataTemplate DataType="{x:Type Color}">
-                    <Border AutomationProperties.Name="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
-                            ToolTip.Tip="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
-                            HorizontalAlignment="Stretch"
-                            VerticalAlignment="Stretch">
-                      <Border.Background>
-                        <SolidColorBrush Color="{Binding}" />
-                      </Border.Background>
-                    </Border>
+                    <Panel AutomationProperties.Name="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
+                           ToolTip.Tip="{Binding Converter={StaticResource ColorToDisplayNameConverter}}"
+                           HorizontalAlignment="Stretch"
+                           VerticalAlignment="Stretch">
+                      <Border Background="{StaticResource ColorControlCheckeredBackgroundBrush}" />
+                      <Border HorizontalAlignment="Stretch"
+                              VerticalAlignment="Stretch">
+                        <Border.Background>
+                          <SolidColorBrush Color="{Binding}" />
+                        </Border.Background>
+                      </Border>
+                    </Panel>
                   </DataTemplate>
                 </ListBox.ItemTemplate>
                 <ListBox.ItemsPanel>

From a0e17b69581fcfd72cfddf7e82f5e7a2dc2ee884 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Tue, 7 Jul 2026 09:36:08 +0200
Subject: [PATCH 074/196] Implement TableView (#21511)

* Implemented TableView

* TableView: reuse cells

* TableView: invalidate on column size change

* TableView: add unit tests

* TableView: fix replacing whole Columns collection

* TableView: add more cell tests

* TableView: add column resizing

* TableView: enable text trimming

* TableView: add TableViewColumn.CanResize

* TableView: add more column tests

* TableView: add TableViewColumn.HorizontalColumnAlignment

* TableView: update cells when column properties change

* TableView: use similar logic to update header and cells

* TableView: adjust resizer position

* TableView: compact density

* TableView: simple theme

* TableView: extract dedicated brush resources

* TableView: rename TableViewRowPresenter to TableViewCellsPresenter

* TableView: document that there is no column virtualization

* Update AvaloniaUI.DiagnosticsSupport to 2.2.2

* Remove DataGridPage from ControlCatalog

* TableView: make TableViewCell a logical child of TableViewRow

* Address copilot review

* Use layout rounding for columns

* Fix row retemplating

* Remove extra table border

* Verify that column can be resized on thumb drag

* Clear unused column header properties

* Make TableView.DisplayMemberBinding/ItemTemplate obsolete

* Rename CanResizeColumns to CanUserResizeColumns

* Fix samples
---
 .../Converter/GdpToBrushConverter.cs          |  31 +
 .../TableViewColumnWidthConverter.cs          |  27 +
 .../ControlCatalog/Pages/DataGridPage.xaml    |  12 -
 .../ControlCatalog/Pages/DataGridPage.xaml.cs |  22 -
 .../ControlCatalog/Pages/TableViewPage.axaml  |  71 ++
 .../Pages/TableViewPage.axaml.cs              |  13 +
 .../MainWindowViewModel_PageList.cs           |   2 +-
 .../ViewModels/TableViewPageViewModel.cs      | 246 +++++++
 .../Presenters/TableViewCellsPresenter.cs     |  93 +++
 .../TableViewColumnHeadersPresenter.cs        | 104 +++
 .../Presenters/TableViewLayoutHelper.cs       | 143 ++++
 src/Avalonia.Controls/TableView.cs            | 284 ++++++++
 src/Avalonia.Controls/TableViewCell.cs        |  71 ++
 src/Avalonia.Controls/TableViewColumn.cs      | 258 +++++++
 .../TableViewColumnHeader.cs                  | 108 +++
 src/Avalonia.Controls/TableViewRow.cs         |  54 ++
 .../Accents/FluentControlResources.xaml       |  48 +-
 .../Controls/FluentControls.xaml              |   4 +
 .../Controls/TableView.xaml                   | 116 +++
 .../Controls/TableViewCell.xaml               |  11 +
 .../Controls/TableViewColumnHeader.xaml       |  54 ++
 .../Controls/TableViewRow.xaml                |  67 ++
 .../DensityStyles/Compact.xaml                |   5 +-
 .../Controls/SimpleControls.xaml              |   4 +
 .../Controls/TableView.xaml                   | 102 +++
 .../Controls/TableViewCell.xaml               |  11 +
 .../Controls/TableViewColumnHeader.xaml       |  54 ++
 .../Controls/TableViewRow.xaml                |  72 ++
 .../Presenters/TableViewLayoutHelperTests.cs  | 277 ++++++++
 .../TableViewColumnHeaderTests.cs             |  89 +++
 .../TableViewTests.cs                         | 658 ++++++++++++++++++
 31 files changed, 3070 insertions(+), 41 deletions(-)
 create mode 100644 samples/ControlCatalog/Converter/GdpToBrushConverter.cs
 create mode 100644 samples/ControlCatalog/Converter/TableViewColumnWidthConverter.cs
 delete mode 100644 samples/ControlCatalog/Pages/DataGridPage.xaml
 delete mode 100644 samples/ControlCatalog/Pages/DataGridPage.xaml.cs
 create mode 100644 samples/ControlCatalog/Pages/TableViewPage.axaml
 create mode 100644 samples/ControlCatalog/Pages/TableViewPage.axaml.cs
 create mode 100644 samples/ControlCatalog/ViewModels/TableViewPageViewModel.cs
 create mode 100644 src/Avalonia.Controls/Presenters/TableViewCellsPresenter.cs
 create mode 100644 src/Avalonia.Controls/Presenters/TableViewColumnHeadersPresenter.cs
 create mode 100644 src/Avalonia.Controls/Presenters/TableViewLayoutHelper.cs
 create mode 100644 src/Avalonia.Controls/TableView.cs
 create mode 100644 src/Avalonia.Controls/TableViewCell.cs
 create mode 100644 src/Avalonia.Controls/TableViewColumn.cs
 create mode 100644 src/Avalonia.Controls/TableViewColumnHeader.cs
 create mode 100644 src/Avalonia.Controls/TableViewRow.cs
 create mode 100644 src/Avalonia.Themes.Fluent/Controls/TableView.xaml
 create mode 100644 src/Avalonia.Themes.Fluent/Controls/TableViewCell.xaml
 create mode 100644 src/Avalonia.Themes.Fluent/Controls/TableViewColumnHeader.xaml
 create mode 100644 src/Avalonia.Themes.Fluent/Controls/TableViewRow.xaml
 create mode 100644 src/Avalonia.Themes.Simple/Controls/TableView.xaml
 create mode 100644 src/Avalonia.Themes.Simple/Controls/TableViewCell.xaml
 create mode 100644 src/Avalonia.Themes.Simple/Controls/TableViewColumnHeader.xaml
 create mode 100644 src/Avalonia.Themes.Simple/Controls/TableViewRow.xaml
 create mode 100644 tests/Avalonia.Controls.UnitTests/Presenters/TableViewLayoutHelperTests.cs
 create mode 100644 tests/Avalonia.Controls.UnitTests/TableViewColumnHeaderTests.cs
 create mode 100644 tests/Avalonia.Controls.UnitTests/TableViewTests.cs

diff --git a/samples/ControlCatalog/Converter/GdpToBrushConverter.cs b/samples/ControlCatalog/Converter/GdpToBrushConverter.cs
new file mode 100644
index 0000000000..d5d6f5cd07
--- /dev/null
+++ b/samples/ControlCatalog/Converter/GdpToBrushConverter.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Globalization;
+using Avalonia;
+using Avalonia.Data.Converters;
+using Avalonia.Media;
+using Avalonia.Media.Immutable;
+
+namespace ControlCatalog.Converter;
+
+public sealed class GdpToBrushConverter : IValueConverter
+{
+    private readonly ImmutableSolidColorBrush _orangeBrush = new(Colors.Orange, 0.6);
+    private readonly ImmutableSolidColorBrush _yellowBrush = new(Colors.Yellow, 0.6);
+    private readonly ImmutableSolidColorBrush _greenBrush = new(Colors.LightGreen, 0.6);
+
+    public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        if (value is not int gdp)
+            return AvaloniaProperty.UnsetValue;
+
+        return gdp switch
+        {
+            <= 5000 => _orangeBrush,
+            <= 10000 => _yellowBrush,
+            _ => _greenBrush
+        };
+    }
+
+    object IValueConverter.ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+        => throw new NotSupportedException();
+}
diff --git a/samples/ControlCatalog/Converter/TableViewColumnWidthConverter.cs b/samples/ControlCatalog/Converter/TableViewColumnWidthConverter.cs
new file mode 100644
index 0000000000..e9f976f6f3
--- /dev/null
+++ b/samples/ControlCatalog/Converter/TableViewColumnWidthConverter.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Globalization;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Data.Converters;
+
+namespace ControlCatalog.Converter;
+
+public sealed class TableViewColumnWidthConverter : IValueConverter
+{
+    public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+    {
+        if (value is bool useStarSize &&
+            parameter is string stringParameter &&
+            double.TryParse(stringParameter, NumberStyles.Number, CultureInfo.InvariantCulture, out var baseWidth))
+        {
+            return useStarSize ?
+                new GridLength(baseWidth, GridUnitType.Star) :
+                new GridLength(baseWidth * 100, GridUnitType.Pixel);
+        }
+
+        return AvaloniaProperty.UnsetValue;
+    }
+
+    object? IValueConverter.ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+        => throw new NotSupportedException();
+}
diff --git a/samples/ControlCatalog/Pages/DataGridPage.xaml b/samples/ControlCatalog/Pages/DataGridPage.xaml
deleted file mode 100644
index 04adf56700..0000000000
--- a/samples/ControlCatalog/Pages/DataGridPage.xaml
+++ /dev/null
@@ -1,12 +0,0 @@
-<ContentPage Theme="{StaticResource ScrollPage}" xmlns="https://github.com/avaloniaui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             Header="DataGrid"
-             x:Class="ControlCatalog.Pages.DataGridPage">
-
-  <StackPanel>
-    <TextBlock Text="DataGrid has moved to its own repository!" Margin="8" />
-    <HyperlinkButton Content="https://github.com/AvaloniaUI/Avalonia.Controls.DataGrid"
-                     Click="OnLinkClicked" />
-  </StackPanel>
-
-</ContentPage>
diff --git a/samples/ControlCatalog/Pages/DataGridPage.xaml.cs b/samples/ControlCatalog/Pages/DataGridPage.xaml.cs
deleted file mode 100644
index 1154506e2e..0000000000
--- a/samples/ControlCatalog/Pages/DataGridPage.xaml.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using System.Diagnostics;
-using Avalonia.Controls;
-using Avalonia.Interactivity;
-
-namespace ControlCatalog.Pages;
-
-public partial class DataGridPage : ContentPage
-{
-    public DataGridPage()
-    {
-        InitializeComponent();
-    }
-
-    private void OnLinkClicked(object? sender, RoutedEventArgs e)
-    {
-        Process.Start(new ProcessStartInfo
-        {
-            FileName = "https://github.com/AvaloniaUI/Avalonia.Controls.DataGrid",
-            UseShellExecute = true
-        });
-    }
-}
diff --git a/samples/ControlCatalog/Pages/TableViewPage.axaml b/samples/ControlCatalog/Pages/TableViewPage.axaml
new file mode 100644
index 0000000000..bd730eb650
--- /dev/null
+++ b/samples/ControlCatalog/Pages/TableViewPage.axaml
@@ -0,0 +1,71 @@
+<ContentPage xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:viewModels="clr-namespace:ControlCatalog.ViewModels"
+             xmlns:converter="clr-namespace:ControlCatalog.Converter"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+             x:Class="ControlCatalog.Pages.TableViewPage"
+             x:DataType="viewModels:TableViewPageViewModel"
+             Header="TableView">
+
+  <ContentPage.Resources>
+
+    <converter:GdpToBrushConverter x:Key="GdpToBrushConverter" />
+    <converter:TableViewColumnWidthConverter x:Key="TableViewColumnWidthConverter" />
+
+    <ControlTheme x:Key="GdpCellTheme"
+                  TargetType="TableViewCell"
+                  BasedOn="{StaticResource {x:Type TableViewCell}}"
+                  x:DataType="viewModels:TableViewPageViewModel+Country">
+      <Setter Property="Background" Value="{Binding GDP, Converter={StaticResource GdpToBrushConverter}}" />
+    </ControlTheme>
+
+  </ContentPage.Resources>
+
+  <DockPanel>
+
+    <StackPanel Orientation="Horizontal"
+                DockPanel.Dock="Top">
+
+      <CheckBox Name="UseStarSizes"
+                Content="Use star-sized columns"
+                IsChecked="True"
+                Margin="8" />
+
+      <CheckBox Name="CanUserResizeColumns"
+                Content="Allow column resizing"
+                IsChecked="True"
+                Margin="8" />
+
+    </StackPanel>
+
+    <TableView ItemsSource="{Binding Countries}"
+               CanUserResizeColumns="{Binding #CanUserResizeColumns.IsChecked}">
+      <TableView.Columns>
+        <TableViewColumn Header="Name"
+                         Binding="{Binding Name}"
+                         Width="{Binding #UseStarSizes.IsChecked, Converter={StaticResource TableViewColumnWidthConverter}, ConverterParameter=3}" />
+        <TableViewColumn Header="Region"
+                         Binding="{Binding Region}"
+                         Width="{Binding #UseStarSizes.IsChecked, Converter={StaticResource TableViewColumnWidthConverter}, ConverterParameter=2}" />
+        <TableViewColumn Header="Population"
+                         Binding="{Binding Population, StringFormat=N0}"
+                         Width="{Binding #UseStarSizes.IsChecked, Converter={StaticResource TableViewColumnWidthConverter}, ConverterParameter=1.5}"
+                         HorizontalContentAlignment="Right" />
+        <TableViewColumn Header="Area"
+                         Binding="{Binding Area, StringFormat=N0}"
+                         Width="{Binding #UseStarSizes.IsChecked, Converter={StaticResource TableViewColumnWidthConverter}, ConverterParameter=1}"
+                         HorizontalContentAlignment="Right" />
+        <TableViewColumn Header="GDP"
+                         Binding="{Binding GDP, StringFormat=N0}"
+                         Width="{Binding #UseStarSizes.IsChecked, Converter={StaticResource TableViewColumnWidthConverter}, ConverterParameter=1}"
+                         CellTheme="{StaticResource GdpCellTheme}"
+                         HorizontalContentAlignment="Right">
+        </TableViewColumn>
+      </TableView.Columns>
+    </TableView>
+
+  </DockPanel>
+
+</ContentPage>
diff --git a/samples/ControlCatalog/Pages/TableViewPage.axaml.cs b/samples/ControlCatalog/Pages/TableViewPage.axaml.cs
new file mode 100644
index 0000000000..af753dd79d
--- /dev/null
+++ b/samples/ControlCatalog/Pages/TableViewPage.axaml.cs
@@ -0,0 +1,13 @@
+using Avalonia.Controls;
+using ControlCatalog.ViewModels;
+
+namespace ControlCatalog.Pages;
+
+public partial class TableViewPage : ContentPage
+{
+    public TableViewPage()
+    {
+        InitializeComponent();
+        DataContext = new TableViewPageViewModel();
+    }
+}
diff --git a/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs b/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
index 03047bedae..89d20de6fe 100644
--- a/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
+++ b/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
@@ -50,7 +50,6 @@ namespace ControlCatalog.ViewModels
             new PageItem("ContextMenu",() => new ContextMenuPage(), Icons.Menu),
             new PageItem("Cursor",() => new CursorPage(), Icons.Cursor),
             new PageItem("Custom Drawing",() => new CustomDrawing(), Icons.Brush),
-            new PageItem("DataGrid",() => new DataGridPage(), Icons.Grid),
             new PageItem("Data Validation",() => new DataValidationPage(), Icons.Shield),
             new PageItem("Date/Time Picker",() => new DateTimePickerPage(), Icons.Clock),
             new PageItem("CalendarDatePicker",() => new CalendarDatePickerPage(), Icons.Calendar),
@@ -84,6 +83,7 @@ namespace ControlCatalog.ViewModels
             new PageItem("TabbedPage",() => new TabbedDemoPage(), Icons.Tab),
             new PageItem("TabControl",() => new TabControlPage(), Icons.Tab),
             new PageItem("TabStrip",() => new TabStripPage(), Icons.Tab),
+            new PageItem("TableView",() => new TableViewPage(), Icons.Grid),
             new PageItem("TextBox",() => new TextBoxPage(), Icons.TextInput),
             new PageItem("TextBlock",() => new TextBlockPage(), Icons.TextInput),
             new PageItem("Theme Variants",() => new ThemePage(), Icons.Theme),
diff --git a/samples/ControlCatalog/ViewModels/TableViewPageViewModel.cs b/samples/ControlCatalog/ViewModels/TableViewPageViewModel.cs
new file mode 100644
index 0000000000..1a969ceea2
--- /dev/null
+++ b/samples/ControlCatalog/ViewModels/TableViewPageViewModel.cs
@@ -0,0 +1,246 @@
+using System.Collections.ObjectModel;
+using MiniMvvm;
+
+namespace ControlCatalog.ViewModels;
+
+public sealed class TableViewPageViewModel : ViewModelBase
+{
+    public ObservableCollection<Country> Countries { get; } =
+    [
+        new("Afghanistan", "ASIA (EX. NEAR EAST)", 31056997, 647500, 700),
+        new("Albania", "EASTERN EUROPE", 3581655, 28748, 4500),
+        new("Algeria", "NORTHERN AFRICA", 32930091, 2381740, 6000),
+        new("American Samoa", "OCEANIA", 57794, 199, 8000),
+        new("Andorra", "WESTERN EUROPE", 71201, 468, 19000),
+        new("Angola", "SUB-SAHARAN AFRICA", 12127071, 1246700, 1900),
+        new("Anguilla", "LATIN AMER. & CARIB", 13477, 102, 8600),
+        new("Antigua & Barbuda", "LATIN AMER. & CARIB", 69108, 443, 11000),
+        new("Argentina", "LATIN AMER. & CARIB", 39921833, 2766890, 11200),
+        new("Armenia", "C.W. OF IND. STATES", 2976372, 29800, 3500),
+        new("Aruba", "LATIN AMER. & CARIB", 71891, 193, 28000),
+        new("Australia", "OCEANIA", 20264082, 7686850, 29000),
+        new("Austria", "WESTERN EUROPE", 8192880, 83870, 30000),
+        new("Azerbaijan", "C.W. OF IND. STATES", 7961619, 86600, 3400),
+        new("The Bahamas", "LATIN AMER. & CARIB", 303770, 13940, 16700),
+        new("Bahrain", "NEAR EAST", 698585, 665, 16900),
+        new("Bangladesh", "ASIA (EX. NEAR EAST)", 147365352, 144000, 1900),
+        new("Barbados", "LATIN AMER. & CARIB", 279912, 431, 15700),
+        new("Belarus", "C.W. OF IND. STATES", 10293011, 207600, 6100),
+        new("Belgium", "WESTERN EUROPE", 10379067, 30528, 29100),
+        new("Belize", "LATIN AMER. & CARIB", 287730, 22966, 4900),
+        new("Benin", "SUB-SAHARAN AFRICA", 7862944, 112620, 1100),
+        new("Bermuda", "NORTHERN AMERICA", 65773, 53, 36000),
+        new("Bhutan", "ASIA (EX. NEAR EAST)", 2279723, 47000, 1300),
+        new("Bolivia", "LATIN AMER. & CARIB", 8989046, 1098580, 2400),
+        new("Bosnia & Herzegovina", "EASTERN EUROPE", 4498976, 51129, 6100),
+        new("Botswana", "SUB-SAHARAN AFRICA", 1639833, 600370, 9000),
+        new("Brazil", "LATIN AMER. & CARIB", 188078227, 8511965, 7600),
+        new("British Virgin Is.", "LATIN AMER. & CARIB", 23098, 153, 16000),
+        new("Brunei", "ASIA (EX. NEAR EAST)", 379444, 5770, 18600),
+        new("Bulgaria", "EASTERN EUROPE", 7385367, 110910, 7600),
+        new("Burkina Faso", "SUB-SAHARAN AFRICA", 13902972, 274200, 1100),
+        new("Burma", "ASIA (EX. NEAR EAST)", 47382633, 678500, 1800),
+        new("Burundi", "SUB-SAHARAN AFRICA", 8090068, 27830, 600),
+        new("Cambodia", "ASIA (EX. NEAR EAST)", 13881427, 181040, 1900),
+        new("Cameroon", "SUB-SAHARAN AFRICA", 17340702, 475440, 1800),
+        new("Canada", "NORTHERN AMERICA", 33098932, 9984670, 29800),
+        new("Cape Verde", "SUB-SAHARAN AFRICA", 420979, 4033, 1400),
+        new("Cayman Islands", "LATIN AMER. & CARIB", 45436, 262, 35000),
+        new("Central African Rep.", "SUB-SAHARAN AFRICA", 4303356, 622984, 1100),
+        new("Chad", "SUB-SAHARAN AFRICA", 9944201, 1284000, 1200),
+        new("Chile", "LATIN AMER. & CARIB", 16134219, 756950, 9900),
+        new("China", "ASIA (EX. NEAR EAST)", 1313973713, 9596960, 5000),
+        new("Colombia", "LATIN AMER. & CARIB", 43593035, 1138910, 6300),
+        new("Comoros", "SUB-SAHARAN AFRICA", 690948, 2170, 700),
+        new("Congo, Dem.Rep.", "SUB - SAHARAN AFRICA", 62660551, 2345410, 700),
+        new("Congo, Repub.of the", "SUB - SAHARAN AFRICA", 3702314, 342000, 700),
+        new("Cook Islands", "OCEANIA", 21388, 240, 5000),
+        new("Costa Rica", "LATIN AMER. & CARIB", 4075261, 51100, 9100),
+        new("Cote d'Ivoire", "SUB-SAHARAN AFRICA", 17654843, 322460, 1400),
+        new("Croatia", "EASTERN EUROPE", 4494749, 56542, 10600),
+        new("Cuba", "LATIN AMER. & CARIB", 11382820, 110860, 2900),
+        new("Cyprus", "NEAR EAST", 784301, 9250, 19200),
+        new("Czech Republic", "EASTERN EUROPE", 10235455, 78866, 15700),
+        new("Denmark", "WESTERN EUROPE", 5450661, 43094, 31100),
+        new("Djibouti", "SUB-SAHARAN AFRICA", 486530, 23000, 1300),
+        new("Dominica", "LATIN AMER. & CARIB", 68910, 754, 5400),
+        new("Dominican Republic", "LATIN AMER. & CARIB", 9183984, 48730, 6000),
+        new("East Timor", "ASIA (EX. NEAR EAST)", 1062777, 15007, 500),
+        new("Ecuador", "LATIN AMER. & CARIB", 13547510, 283560, 3300),
+        new("Egypt", "NORTHERN AFRICA", 78887007, 1001450, 4000),
+        new("El Salvador", "LATIN AMER. & CARIB", 6822378, 21040, 4800),
+        new("Equatorial Guinea", "SUB-SAHARAN AFRICA", 540109, 28051, 2700),
+        new("Eritrea", "SUB-SAHARAN AFRICA", 4786994, 121320, 700),
+        new("Estonia", "BALTICS", 1324333, 45226, 12300),
+        new("Ethiopia", "SUB-SAHARAN AFRICA", 74777981, 1127127, 700),
+        new("Faroe Islands", "WESTERN EUROPE", 47246, 1399, 22000),
+        new("Fiji", "OCEANIA", 905949, 18270, 5800),
+        new("Finland", "WESTERN EUROPE", 5231372, 338145, 27400),
+        new("France", "WESTERN EUROPE", 60876136, 547030, 27600),
+        new("French Guiana", "LATIN AMER. & CARIB", 199509, 91000, 8300),
+        new("French Polynesia", "OCEANIA", 274578, 4167, 17500),
+        new("Gabon", "SUB-SAHARAN AFRICA", 1424906, 267667, 5500),
+        new("Gambia, The", "SUB - SAHARAN AFRICA", 1641564, 11300, 1700),
+        new("Gaza Strip", "NEAR EAST", 1428757, 360, 600),
+        new("Georgia", "C.W. OF IND. STATES", 4661473, 69700, 2500),
+        new("Germany", "WESTERN EUROPE", 82422299, 357021, 27600),
+        new("Ghana", "SUB-SAHARAN AFRICA", 22409572, 239460, 2200),
+        new("Gibraltar", "WESTERN EUROPE", 27928, 7, 17500),
+        new("Greece", "WESTERN EUROPE", 10688058, 131940, 20000),
+        new("Greenland", "NORTHERN AMERICA", 56361, 2166086, 20000),
+        new("Grenada", "LATIN AMER. & CARIB", 89703, 344, 5000),
+        new("Guadeloupe", "LATIN AMER. & CARIB", 452776, 1780, 8000),
+        new("Guam", "OCEANIA", 171019, 541, 21000),
+        new("Guatemala", "LATIN AMER. & CARIB", 12293545, 108890, 4100),
+        new("Guernsey", "WESTERN EUROPE", 65409, 78, 20000),
+        new("Guinea", "SUB-SAHARAN AFRICA", 9690222, 245857, 2100),
+        new("Guinea-Bissau", "SUB-SAHARAN AFRICA", 1442029, 36120, 800),
+        new("Guyana", "LATIN AMER. & CARIB", 767245, 214970, 4000),
+        new("Haiti", "LATIN AMER. & CARIB", 8308504, 27750, 1600),
+        new("Honduras", "LATIN AMER. & CARIB", 7326496, 112090, 2600),
+        new("Hong Kong", "ASIA (EX. NEAR EAST)", 6940432, 1092, 28800),
+        new("Hungary", "EASTERN EUROPE", 9981334, 93030, 13900),
+        new("Iceland", "WESTERN EUROPE", 299388, 103000, 30900),
+        new("India", "ASIA (EX. NEAR EAST)", 1095351995, 3287590, 2900),
+        new("Indonesia", "ASIA (EX. NEAR EAST)", 245452739, 1919440, 3200),
+        new("Iran", "ASIA (EX. NEAR EAST)", 68688433, 1648000, 7000),
+        new("Iraq", "NEAR EAST", 26783383, 437072, 1500),
+        new("Ireland", "WESTERN EUROPE", 4062235, 70280, 29600),
+        new("Isle of Man", "WESTERN EUROPE", 75441, 572, 21000),
+        new("Israel", "NEAR EAST", 6352117, 20770, 19800),
+        new("Italy", "WESTERN EUROPE", 58133509, 301230, 26700),
+        new("Jamaica", "LATIN AMER. & CARIB", 2758124, 10991, 3900),
+        new("Japan", "ASIA (EX. NEAR EAST)", 127463611, 377835, 28200),
+        new("Jersey", "WESTERN EUROPE", 91084, 116, 24800),
+        new("Jordan", "NEAR EAST", 5906760, 92300, 4300),
+        new("Kazakhstan", "C.W. OF IND. STATES", 15233244, 2717300, 6300),
+        new("Kenya", "SUB-SAHARAN AFRICA", 34707817, 582650, 1000),
+        new("Kiribati", "OCEANIA", 105432, 811, 800),
+        new("North Korea", "ASIA(EX.NEAR EAST)", 23113019, 120540, 1300),
+        new("South Korea", "ASIA(EX.NEAR EAST)", 48846823, 98480, 17800),
+        new("Kuwait", "NEAR EAST", 2418393, 17820, 19000),
+        new("Kyrgyzstan", "C.W. OF IND. STATES", 5213898, 198500, 1600),
+        new("Laos", "ASIA (EX. NEAR EAST)", 6368481, 236800, 1700),
+        new("Latvia", "BALTICS", 2274735, 64589, 10200),
+        new("Lebanon", "NEAR EAST", 3874050, 10400, 4800),
+        new("Lesotho", "SUB-SAHARAN AFRICA", 2022331, 30355, 3000),
+        new("Liberia", "SUB-SAHARAN AFRICA", 3042004, 111370, 1000),
+        new("Libya", "NORTHERN AFRICA", 5900754, 1759540, 6400),
+        new("Liechtenstein", "WESTERN EUROPE", 33987, 160, 25000),
+        new("Lithuania", "BALTICS", 3585906, 65200, 11400),
+        new("Luxembourg", "WESTERN EUROPE", 474413, 2586, 55100),
+        new("Macau", "ASIA (EX. NEAR EAST)", 453125, 28, 19400),
+        new("Macedonia", "EASTERN EUROPE", 2050554, 25333, 6700),
+        new("Madagascar", "SUB-SAHARAN AFRICA", 18595469, 587040, 800),
+        new("Malawi", "SUB-SAHARAN AFRICA", 13013926, 118480, 600),
+        new("Malaysia", "ASIA (EX. NEAR EAST)", 24385858, 329750, 9000),
+        new("Maldives", "ASIA (EX. NEAR EAST)", 359008, 300, 3900),
+        new("Mali", "SUB-SAHARAN AFRICA", 11716829, 1240000, 900),
+        new("Malta", "WESTERN EUROPE", 400214, 316, 17700),
+        new("Marshall Islands", "OCEANIA", 60422, 11854, 1600),
+        new("Martinique", "LATIN AMER. & CARIB", 436131, 1100, 14400),
+        new("Mauritania", "SUB-SAHARAN AFRICA", 3177388, 1030700, 1800),
+        new("Mauritius", "SUB-SAHARAN AFRICA", 1240827, 2040, 11400),
+        new("Mayotte", "SUB-SAHARAN AFRICA", 201234, 374, 2600),
+        new("Mexico", "LATIN AMER. & CARIB", 107449525, 1972550, 9000),
+        new("Micronesia, Fed.St.", "OCEANIA", 108004, 702, 2000),
+        new("Moldova", "C.W. OF IND. STATES", 4466706, 33843, 1800),
+        new("Monaco", "WESTERN EUROPE", 32543, 2, 27000),
+        new("Mongolia", "ASIA (EX. NEAR EAST)", 2832224, 1564116, 1800),
+        new("Montserrat", "LATIN AMER. & CARIB", 9439, 102, 3400),
+        new("Morocco", "NORTHERN AFRICA", 33241259, 446550, 4000),
+        new("Mozambique", "SUB-SAHARAN AFRICA", 19686505, 801590, 1200),
+        new("Namibia", "SUB-SAHARAN AFRICA", 2044147, 825418, 7200),
+        new("Nauru", "OCEANIA", 13287, 21, 5000),
+        new("Nepal", "ASIA (EX. NEAR EAST)", 28287147, 147181, 1400),
+        new("Netherlands", "WESTERN EUROPE", 16491461, 41526, 28600),
+        new("Netherlands Antilles", "LATIN AMER. & CARIB", 221736, 960, 11400),
+        new("New Caledonia", "OCEANIA", 219246, 19060, 15000),
+        new("New Zealand", "OCEANIA", 4076140, 268680, 21600),
+        new("Nicaragua", "LATIN AMER. & CARIB", 5570129, 129494, 2300),
+        new("Niger", "SUB-SAHARAN AFRICA", 12525094, 1267000, 800),
+        new("Nigeria", "SUB-SAHARAN AFRICA", 131859731, 923768, 900),
+        new("N. Mariana Islands", "OCEANIA", 82459, 477, 12500),
+        new("Norway", "WESTERN EUROPE", 4610820, 323802, 37800),
+        new("Oman", "NEAR EAST", 3102229, 212460, 13100),
+        new("Pakistan", "ASIA (EX. NEAR EAST)", 165803560, 803940, 2100),
+        new("Palau", "OCEANIA", 20579, 458, 9000),
+        new("Panama", "LATIN AMER. & CARIB", 3191319, 78200, 6300),
+        new("Papua New Guinea", "OCEANIA", 5670544, 462840, 2200),
+        new("Paraguay", "LATIN AMER. & CARIB", 6506464, 406750, 4700),
+        new("Peru", "LATIN AMER. & CARIB", 28302603, 1285220, 5100),
+        new("Philippines", "ASIA (EX. NEAR EAST)", 89468677, 300000, 4600),
+        new("Poland", "EASTERN EUROPE", 38536869, 312685, 11100),
+        new("Portugal", "WESTERN EUROPE", 10605870, 92391, 18000),
+        new("Puerto Rico", "LATIN AMER. & CARIB", 3927188, 13790, 16800),
+        new("Qatar", "NEAR EAST", 885359, 11437, 21500),
+        new("Reunion", "SUB-SAHARAN AFRICA", 787584, 2517, 5800),
+        new("Romania", "EASTERN EUROPE", 22303552, 237500, 7000),
+        new("Russia", "C.W. OF IND. STATES", 142893540, 17075200, 8900),
+        new("Rwanda", "SUB-SAHARAN AFRICA", 8648248, 26338, 1300),
+        new("Saint Helena", "SUB-SAHARAN AFRICA", 7502, 413, 2500),
+        new("Saint Kitts & Nevis", "LATIN AMER. & CARIB", 39129, 261, 8800),
+        new("Saint Lucia", "LATIN AMER. & CARIB", 168458, 616, 5400),
+        new("St Pierre & Miquelon", "NORTHERN AMERICA", 7026, 242, 6900),
+        new("Saint Vincent and the Grenadines", "LATIN AMER. & CARIB", 117848, 389, 2900),
+        new("Samoa", "OCEANIA", 176908, 2944, 5600),
+        new("San Marino", "WESTERN EUROPE", 29251, 61, 34600),
+        new("Sao Tome & Principe", "SUB-SAHARAN AFRICA", 193413, 1001, 1200),
+        new("Saudi Arabia", "NEAR EAST", 27019731, 1960582, 11800),
+        new("Senegal", "SUB-SAHARAN AFRICA", 11987121, 196190, 1600),
+        new("Serbia", "EASTERN EUROPE", 9396411, 88361, 2200),
+        new("Seychelles", "SUB-SAHARAN AFRICA", 81541, 455, 7800),
+        new("Sierra Leone", "SUB-SAHARAN AFRICA", 6005250, 71740, 500),
+        new("Singapore", "ASIA (EX. NEAR EAST)", 4492150, 693, 23700),
+        new("Slovakia", "EASTERN EUROPE", 5439448, 48845, 13300),
+        new("Slovenia", "EASTERN EUROPE", 2010347, 20273, 19000),
+        new("Solomon Islands", "OCEANIA", 552438, 28450, 1700),
+        new("Somalia", "SUB-SAHARAN AFRICA", 8863338, 637657, 500),
+        new("South Africa", "SUB-SAHARAN AFRICA", 44187637, 1219912, 10700),
+        new("Spain", "WESTERN EUROPE", 40397842, 504782, 22000),
+        new("Sri Lanka", "ASIA (EX. NEAR EAST)", 20222240, 65610, 3700),
+        new("Sudan", "SUB-SAHARAN AFRICA", 41236378, 2505810, 1900),
+        new("Suriname", "LATIN AMER. & CARIB", 439117, 163270, 4000),
+        new("Swaziland", "SUB-SAHARAN AFRICA", 1136334, 17363, 4900),
+        new("Sweden", "WESTERN EUROPE", 9016596, 449964, 26800),
+        new("Switzerland", "WESTERN EUROPE", 7523934, 41290, 32700),
+        new("Syria", "NEAR EAST", 18881361, 185180, 3300),
+        new("Taiwan", "ASIA (EX. NEAR EAST)", 23036087, 35980, 23400),
+        new("Tajikistan", "C.W. OF IND. STATES", 7320815, 143100, 1000),
+        new("Tanzania", "SUB-SAHARAN AFRICA", 37445392, 945087, 600),
+        new("Thailand", "ASIA (EX. NEAR EAST)", 64631595, 514000, 7400),
+        new("Togo", "SUB-SAHARAN AFRICA", 5548702, 56785, 1500),
+        new("Tonga", "OCEANIA", 114689, 748, 2200),
+        new("Trinidad & Tobago", "LATIN AMER. & CARIB", 1065842, 5128, 9500),
+        new("Tunisia", "NORTHERN AFRICA", 10175014, 163610, 6900),
+        new("Turkey", "NEAR EAST", 70413958, 780580, 6700),
+        new("Turkmenistan", "C.W. OF IND. STATES", 5042920, 488100, 5800),
+        new("Turks & Caicos Is", "LATIN AMER. & CARIB", 21152, 430, 9600),
+        new("Tuvalu", "OCEANIA", 11810, 26, 1100),
+        new("Uganda", "SUB-SAHARAN AFRICA", 28195754, 236040, 1400),
+        new("Ukraine", "C.W. OF IND. STATES", 46710816, 603700, 5400),
+        new("United Arab Emirates", "NEAR EAST", 2602713, 82880, 23200),
+        new("United Kingdom", "WESTERN EUROPE", 60609153, 244820, 27700),
+        new("United States", "NORTHERN AMERICA", 298444215, 9631420, 37800),
+        new("Uruguay", "LATIN AMER. & CARIB", 3431932, 176220, 12800),
+        new("Uzbekistan", "C.W. OF IND. STATES", 27307134, 447400, 1700),
+        new("Vanuatu", "OCEANIA", 208869, 12200, 2900),
+        new("Venezuela", "LATIN AMER. & CARIB", 25730435, 912050, 4800),
+        new("Vietnam", "ASIA (EX. NEAR EAST)", 84402966, 329560, 2500),
+        new("Virgin Islands", "LATIN AMER. & CARIB", 108605, 1910, 17200),
+        new("Wallis and Futuna", "OCEANIA", 16025, 274, 3700),
+        new("West Bank", "NEAR EAST", 2460492, 5860, 800),
+        new("Yemen", "NEAR EAST", 21456188, 527970, 800),
+        new("Zambia", "SUB-SAHARAN AFRICA", 11502010, 752614, 800),
+        new("Zimbabwe", "SUB-SAHARAN AFRICA", 12236805, 390580, 1900)
+    ];
+
+    public sealed class Country(string name, string region, int population, int area, int gdp)
+    {
+        public string Name { get; set; } = name;
+        public string Region { get; set; } = region;
+        public int Population { get; set; } = population;
+        public int Area { get; set; } = area; // Square miles
+        public int GDP { get; set; } = gdp;
+    }
+}
diff --git a/src/Avalonia.Controls/Presenters/TableViewCellsPresenter.cs b/src/Avalonia.Controls/Presenters/TableViewCellsPresenter.cs
new file mode 100644
index 0000000000..513978c2c5
--- /dev/null
+++ b/src/Avalonia.Controls/Presenters/TableViewCellsPresenter.cs
@@ -0,0 +1,93 @@
+using Avalonia.Layout;
+using static Avalonia.Controls.Presenters.TableViewLayoutHelper;
+
+namespace Avalonia.Controls.Presenters;
+
+/// <summary>
+/// Lays out the cells of a <see cref="TableViewRow"/> according to the column definitions
+/// of the parent <see cref="TableView"/>.
+/// </summary>
+/// <remarks>
+/// The cells are recycled alongside their owning row in a <see cref="VirtualizingStackPanel"/>,
+/// but are not virtualized in a single row (i.e. there is no column virtualization).
+/// </remarks>
+public class TableViewCellsPresenter : Panel
+{
+    internal TableViewRow? Row { get; set; }
+
+    internal void ClearCells()
+    {
+        foreach (var child in Children)
+        {
+            if (child is TableViewCell cell)
+                cell.Column = null;
+        }
+    }
+
+    internal void RemoveCells()
+    {
+        ClearCells();
+        Children.Clear();
+        Row?.LogicalChildren.Clear();
+    }
+
+    internal void RebuildCells()
+    {
+        if (Row?.Columns is not { } columns)
+        {
+            RemoveCells();
+            return;
+        }
+
+        if (columns.Count != Children.Count)
+        {
+            RemoveCells();
+
+            foreach (var column in columns)
+            {
+                var cell = new TableViewCell { Column = column };
+                Children.Add(cell);
+            }
+
+            Row.LogicalChildren.AddRange(Children);
+        }
+        else
+        {
+            for (var i = 0; i < columns.Count; i++)
+            {
+                ((TableViewCell)Children[i]).Column = columns[i];
+            }
+        }
+
+        InvalidateMeasure();
+    }
+
+    internal void RefreshCell(int columnIndex)
+        => ((TableViewCell)Children[columnIndex]).Refresh();
+
+    /// <inheritdoc/>
+    protected override Size MeasureOverride(Size availableSize)
+    {
+        if (Row?.Columns is not { } columns)
+            return default;
+
+        // In a standard template, the column widths should have been computed by the headers' presenter.
+        // If for some reason they weren't, do it now.
+        if (NeedsActualWidths(columns))
+            UpdateActualWidths(columns, availableSize.Width, UseLayoutRounding, LayoutHelper.GetLayoutScale(this));
+
+        return MeasureRow(columns, Children, availableSize);
+    }
+
+    /// <inheritdoc/>
+    protected override Size ArrangeOverride(Size finalSize)
+    {
+        if (Row?.Columns is not { } columns)
+            return finalSize;
+
+        if (NeedsActualWidths(columns))
+            UpdateActualWidths(columns, finalSize.Width, UseLayoutRounding, LayoutHelper.GetLayoutScale(this));
+
+        return ArrangeRow(columns, Children, finalSize, 0);
+    }
+}
diff --git a/src/Avalonia.Controls/Presenters/TableViewColumnHeadersPresenter.cs b/src/Avalonia.Controls/Presenters/TableViewColumnHeadersPresenter.cs
new file mode 100644
index 0000000000..8c82b6f790
--- /dev/null
+++ b/src/Avalonia.Controls/Presenters/TableViewColumnHeadersPresenter.cs
@@ -0,0 +1,104 @@
+using System.ComponentModel;
+using Avalonia.Controls.Primitives;
+using Avalonia.Layout;
+using Avalonia.LogicalTree;
+using static Avalonia.Controls.Presenters.TableViewLayoutHelper;
+
+namespace Avalonia.Controls.Presenters;
+
+/// <summary>
+/// Displays the column headers for a <see cref="TableView"/>.
+/// Computes column widths (pixel and star) and exposes them via
+/// <see cref="TableViewColumn.ActualWidth"/> so that <see cref="TableViewCellsPresenter"/>
+/// can align cells with the headers.
+/// </summary>
+public class TableViewColumnHeadersPresenter : Panel
+{
+    internal TableView? TableView { get; set; }
+
+    internal void RebuildHeaders()
+    {
+        Children.Clear();
+
+        if (TableView is null)
+            return;
+
+        foreach (var column in TableView.Columns)
+        {
+            var header = new TableViewColumnHeader { Column = column };
+            Children.Add(header);
+        }
+
+        InvalidateMeasure();
+    }
+
+    /// <inheritdoc />
+    protected override void OnAttachedToLogicalTree(LogicalTreeAttachmentEventArgs e)
+    {
+        base.OnAttachedToLogicalTree(e);
+
+        TableView = this.FindLogicalAncestorOfType<TableView>();
+
+        RebuildHeaders();
+
+        if (TableView is not null)
+        {
+            TableView.HeadersPresenter = this;
+
+            if (TableView.Scroll is INotifyPropertyChanged notifyPropertyChanged)
+                notifyPropertyChanged.PropertyChanged += OnScrollPropertyChanged;
+        }
+    }
+
+    protected override void OnDetachedFromLogicalTree(LogicalTreeAttachmentEventArgs e)
+    {
+        if (TableView is not null)
+        {
+            TableView.HeadersPresenter = null;
+
+            if (TableView.Scroll is INotifyPropertyChanged notifyPropertyChanged)
+                notifyPropertyChanged.PropertyChanged -= OnScrollPropertyChanged;
+
+            TableView = null;
+            RebuildHeaders();
+        }
+
+        base.OnDetachedFromLogicalTree(e);
+    }
+
+    private void OnScrollPropertyChanged(object? sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName == nameof(IScrollable.Offset))
+            InvalidateArrange();
+    }
+
+    internal void RefreshHeader(int columnIndex)
+        => ((TableViewColumnHeader)Children[columnIndex]).Refresh();
+
+    /// <inheritdoc/>
+    protected override Size MeasureOverride(Size availableSize)
+    {
+        if (TableView is null)
+            return default;
+
+        if (UpdateActualWidths(TableView.Columns, availableSize.Width, UseLayoutRounding, LayoutHelper.GetLayoutScale(this)))
+            TableView.InvalidateCellsMeasure();
+
+        return MeasureRow(TableView.Columns, Children, availableSize);
+    }
+
+    /// <inheritdoc/>
+    protected override Size ArrangeOverride(Size finalSize)
+    {
+        if (TableView is null)
+            return finalSize;
+
+        var columns = TableView.Columns;
+
+        if (UpdateActualWidths(columns, finalSize.Width, UseLayoutRounding, LayoutHelper.GetLayoutScale(this)))
+            TableView.InvalidateCellsMeasure();
+
+        var offset = TableView.Scroll?.Offset.X ?? 0;
+        return ArrangeRow(columns, Children, finalSize, -offset);
+    }
+}
diff --git a/src/Avalonia.Controls/Presenters/TableViewLayoutHelper.cs b/src/Avalonia.Controls/Presenters/TableViewLayoutHelper.cs
new file mode 100644
index 0000000000..9492427db9
--- /dev/null
+++ b/src/Avalonia.Controls/Presenters/TableViewLayoutHelper.cs
@@ -0,0 +1,143 @@
+using System;
+using Avalonia.Collections;
+using Avalonia.Layout;
+
+namespace Avalonia.Controls.Presenters;
+
+internal static class TableViewLayoutHelper
+{
+    /// <summary>
+    /// Distributes <paramref name="availableWidth"/> among the columns.
+    /// Pixel columns take their fixed size; remaining space is split proportionally among star columns.
+    /// Auto is treated as 1*.
+    /// </summary>
+    public static bool UpdateActualWidths(
+        AvaloniaList<TableViewColumn> columns,
+        double availableWidth,
+        bool useLayoutRounding,
+        double layoutScale)
+    {
+        if (columns.Count == 0)
+            return false;
+
+        var fixedTotal = 0.0;
+        var starTotal = 0.0;
+        var modified = false;
+
+        for (var i = 0; i < columns.Count; i++)
+        {
+            var width = columns[i].Width;
+            if (width.IsAbsolute)
+            {
+                var actualWidth = width.Value;
+
+                if (useLayoutRounding)
+                    actualWidth = LayoutHelper.RoundLayoutValue(actualWidth, layoutScale);
+
+                if (columns[i].ActualWidth != actualWidth)
+                {
+                    columns[i].ActualWidth = actualWidth;
+                    modified = true;
+                }
+
+                fixedTotal += actualWidth;
+            }
+            else
+            {
+                // Star or Auto — treat both as star
+                starTotal += width.IsStar ? width.Value : 1.0;
+            }
+        }
+
+        double starBudget;
+
+        if (double.IsPositiveInfinity(availableWidth))
+        {
+            // The headers aren't supposed to be measured with infinity, as they're normally outside the main ScrollViewer.
+            // If they've been relocated, or are missing, use 1000 pixels arbitrarily so star columns are still displayed.
+            starBudget = 1000;
+        }
+        else
+            starBudget = Math.Max(0.0, availableWidth - fixedTotal);
+
+        // Distribute the star budget by rounding the cumulative right edge of each star column rather than each width in
+        // isolation. This spreads the sub-pixel remainders across the columns instead of letting them accumulate, so the
+        // sum of the rounded star widths equals the rounded star budget and the final layout matches the available width.
+        var unroundedEdge = 0.0;
+        var roundedEdge = 0.0;
+
+        for (var i = 0; i < columns.Count; i++)
+        {
+            var width = columns[i].Width;
+            if (!width.IsAbsolute)
+            {
+                var share = width.IsStar ? width.Value : 1.0;
+                unroundedEdge += starTotal > 0 ? share / starTotal * starBudget : 0;
+
+                var actualWidth = unroundedEdge - roundedEdge;
+
+                if (useLayoutRounding)
+                {
+                    var nextRoundedEdge = LayoutHelper.RoundLayoutValue(unroundedEdge, layoutScale);
+                    actualWidth = nextRoundedEdge - roundedEdge;
+                    roundedEdge = nextRoundedEdge;
+                }
+                else
+                    roundedEdge = unroundedEdge;
+
+                if (columns[i].ActualWidth != actualWidth)
+                {
+                    columns[i].ActualWidth = actualWidth;
+                    modified = true;
+                }
+            }
+        }
+
+        return modified;
+    }
+
+    public static bool NeedsActualWidths(AvaloniaList<TableViewColumn> columns)
+        => columns.Count > 0 && double.IsNaN(columns[0].ActualWidth);
+
+    public static void ResetActualWidths(AvaloniaList<TableViewColumn> columns)
+    {
+        foreach (var column in columns)
+            column.ActualWidth = double.NaN;
+    }
+
+    public static Size MeasureRow(AvaloniaList<TableViewColumn> columns, Controls cells, Size availableSize)
+    {
+        if (cells.Count != columns.Count)
+            return default;
+
+        var totalWidth = 0.0;
+        var totalHeight = 0.0;
+
+        for (var i = 0; i < cells.Count; i++)
+        {
+            var child = cells[i];
+            var columnWidth = columns[i].ActualWidth;
+            child.Measure(new Size(columnWidth, availableSize.Height));
+            totalWidth += columnWidth;
+            totalHeight = Math.Max(totalHeight, child.DesiredSize.Height);
+        }
+
+        return new Size(totalWidth, totalHeight);
+    }
+
+    public static Size ArrangeRow(AvaloniaList<TableViewColumn> columns, Controls cells, Size finalSize, double offset)
+    {
+        if (cells.Count != columns.Count)
+            return finalSize;
+
+        var x = offset;
+        for (var i = 0; i < cells.Count; i++)
+        {
+            var width = columns[i].ActualWidth;
+            cells[i].Arrange(new Rect(x, 0, width, finalSize.Height));
+            x += width;
+        }
+
+        return finalSize;
+    }
+}
diff --git a/src/Avalonia.Controls/TableView.cs b/src/Avalonia.Controls/TableView.cs
new file mode 100644
index 0000000000..87141677f0
--- /dev/null
+++ b/src/Avalonia.Controls/TableView.cs
@@ -0,0 +1,284 @@
+using System;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using Avalonia.Collections;
+using Avalonia.Controls.Presenters;
+using Avalonia.Controls.Templates;
+using Avalonia.Data;
+using Avalonia.Metadata;
+using static Avalonia.Controls.Presenters.TableViewLayoutHelper;
+
+namespace Avalonia.Controls;
+
+/// <summary>
+/// A read-only tabular control that presents items in configurable columns.
+/// </summary>
+public class TableView : ListBox
+{
+    /// <summary>
+    /// Defines the <see cref="Columns"/> property.
+    /// </summary>
+    public static readonly DirectProperty<TableView, AvaloniaList<TableViewColumn>?> ColumnsProperty =
+        AvaloniaProperty.RegisterDirect<TableView, AvaloniaList<TableViewColumn>?>(
+            nameof(Columns),
+            o => o.Columns,
+            (o, v) => o.Columns = v);
+
+    /// <summary>
+    /// Defines the <see cref="CanUserResizeColumns"/> property.
+    /// </summary>
+    public static readonly StyledProperty<bool> CanUserResizeColumnsProperty =
+        AvaloniaProperty.Register<TableView, bool>(nameof(CanUserResizeColumns), true);
+
+    private IDisposable? _columnsSubscription;
+    private AvaloniaList<TableViewColumn>? _columns;
+
+    [Obsolete(
+        $"{nameof(ItemsControl.DisplayMemberBinding)} has no effect on a {nameof(TableView)}. " +
+        $"Use {nameof(TableViewColumn)}.{nameof(TableViewColumn.Binding)} instead.")]
+    [SuppressMessage("AvaloniaProperty", "AVP1012", Justification = "Calls the base")]
+    [AssignBinding]
+    [InheritDataTypeFromItems(nameof(ItemsSource))]
+    public new BindingBase? DisplayMemberBinding
+    {
+        get => base.DisplayMemberBinding;
+        set => base.DisplayMemberBinding = value;
+    }
+
+    [Obsolete(
+        $"{nameof(ItemsControl.ItemTemplate)} has no effect on a {nameof(TableView)}. " +
+        $"Use {nameof(TableViewColumn)}.{nameof(TableViewColumn.CellTemplate)} instead.")]
+    [SuppressMessage("AvaloniaProperty", "AVP1012", Justification = "Calls the base")]
+    [InheritDataTypeFromItems(nameof(ItemsSource))]
+    public new IDataTemplate? ItemTemplate
+    {
+        get => base.ItemTemplate;
+        set => base.ItemTemplate = value;
+    }
+
+    /// <summary>
+    /// Gets or sets the collection of columns displayed by this <see cref="TableView"/>.
+    /// </summary>
+    [NotNull]
+    public AvaloniaList<TableViewColumn>? Columns
+    {
+        get
+        {
+            if (_columns is null)
+            {
+                _columns = new AvaloniaList<TableViewColumn> { ResetBehavior = ResetBehavior.Remove };
+                if (IsInitialized)
+                    SubscribeToColumns(_columns);
+            }
+
+            return _columns;
+        }
+        set
+        {
+            var oldValue = _columns;
+            if (oldValue == value)
+                return;
+
+            UnsubscribeFromColumns();
+            value?.ResetBehavior = ResetBehavior.Remove;
+            SetAndRaise(ColumnsProperty, ref _columns, value);
+
+            if (IsInitialized)
+            {
+                if (value is not null)
+                    SubscribeToColumns(value);
+
+                RebuildHeaders();
+                RebuildCells();
+            }
+        }
+    }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the user can resize columns by dragging the
+    /// separator between column headers.
+    /// </summary>
+    public bool CanUserResizeColumns
+    {
+        get => GetValue(CanUserResizeColumnsProperty);
+        set => SetValue(CanUserResizeColumnsProperty, value);
+    }
+
+    internal TableViewColumnHeadersPresenter? HeadersPresenter { get; set; }
+
+    private void SubscribeToColumns(AvaloniaList<TableViewColumn> columns)
+    {
+        Debug.Assert(_columnsSubscription is null);
+
+        var isInitialIteration = true;
+
+        _columnsSubscription = columns.ForEachItem(
+            [SuppressMessage("ReSharper", "AccessToModifiedClosure")]
+            (column) =>
+            {
+                AttachColumn(column);
+                if (!isInitialIteration)
+                    OnColumnsChanged();
+            },
+            column =>
+            {
+                DetachColumn(column);
+                OnColumnsChanged();
+            },
+            () => { });
+
+        isInitialIteration = false;
+    }
+
+    private void AttachColumn(TableViewColumn column)
+    {
+        if (column.TableView is not null && column.TableView != this)
+        {
+            throw new InvalidOperationException(
+                $"The column {column.DebugDisplay} is already attached to a {nameof(TableView)}.");
+        }
+
+        column.TableView = this;
+    }
+
+    private void DetachColumn(TableViewColumn column)
+    {
+        Debug.Assert(column.TableView == this || column.TableView is null);
+
+        column.TableView = null;
+        column.ActualWidth = double.NaN;
+    }
+
+    private void UnsubscribeFromColumns()
+    {
+        if (_columnsSubscription is null)
+            return;
+
+        _columnsSubscription.Dispose();
+        _columnsSubscription = null;
+
+        foreach (var column in Columns)
+            DetachColumn(column);
+    }
+
+    /// <inheritdoc/>
+    protected internal override Control CreateContainerForItemOverride(object? item, int index, object? recycleKey)
+        => new TableViewRow();
+
+    /// <inheritdoc/>
+    protected internal override void PrepareContainerForItemOverride(Control container, object? item, int index)
+    {
+        base.PrepareContainerForItemOverride(container, item, index);
+
+        if (container is TableViewRow row)
+        {
+            row.Columns = Columns;
+            row.RebuildCells();
+        }
+    }
+
+    /// <inheritdoc/>
+    protected internal override bool NeedsContainerOverride(object? item, int index, out object? recycleKey)
+        => NeedsContainer<TableViewRow>(item, out recycleKey);
+
+    /// <inheritdoc/>
+    protected internal override void ClearContainerForItemOverride(Control element)
+    {
+        base.ClearContainerForItemOverride(element);
+
+        if (element is TableViewRow row)
+        {
+            row.Columns = null;
+            row.ClearCells();
+        }
+    }
+
+    private void OnColumnsChanged()
+    {
+        ResetActualWidths(Columns);
+        RebuildHeaders();
+        RebuildCells();
+    }
+
+    internal void OnColumnsSizeChanged()
+    {
+        ResetActualWidths(Columns);
+        InvalidateHeadersMeasure();
+        InvalidateCellsMeasure();
+    }
+
+    /// <inheritdoc />
+    protected override void OnInitialized()
+    {
+        base.OnInitialized();
+
+        if (_columns is not null)
+            SubscribeToColumns(_columns);
+    }
+
+    private void RebuildHeaders()
+        => HeadersPresenter?.RebuildHeaders();
+
+    private void RebuildCells()
+    {
+        var columns = Columns;
+
+        foreach (var row in GetRealizedContainers())
+        {
+            if (row is TableViewRow tableViewRow)
+            {
+                tableViewRow.Columns = columns;
+                tableViewRow.RebuildCells();
+            }
+            else
+                row.InvalidateMeasure();
+        }
+    }
+
+    internal void InvalidateHeadersMeasure()
+        => HeadersPresenter?.InvalidateMeasure();
+
+    internal void InvalidateCellsMeasure()
+    {
+        foreach (var row in GetRealizedContainers())
+        {
+            if (row is TableViewRow tableViewRow)
+                tableViewRow.InvalidateCellsMeasure();
+            else
+                row.InvalidateMeasure();
+        }
+    }
+
+    internal void RefreshColumnHeaders(TableViewColumn column)
+    {
+        var columnIndex = Columns.IndexOf(column);
+        if (columnIndex < 0)
+            return;
+
+        HeadersPresenter?.RefreshHeader(columnIndex);
+    }
+
+    internal void RefreshColumnCells(TableViewColumn column)
+    {
+        var columnIndex = Columns.IndexOf(column);
+        if (columnIndex < 0)
+            return;
+
+        foreach (var row in GetRealizedContainers())
+        {
+            if (row is TableViewRow tableViewRow)
+                tableViewRow.RefreshCell(columnIndex);
+        }
+    }
+
+    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+    {
+        base.OnPropertyChanged(change);
+
+        if (change.Property == CanUserResizeColumnsProperty && _columns is not null)
+        {
+            foreach (var column in _columns)
+                column.UpdateCanUserEffectivelyResize();
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/TableViewCell.cs b/src/Avalonia.Controls/TableViewCell.cs
new file mode 100644
index 0000000000..2eacde12b4
--- /dev/null
+++ b/src/Avalonia.Controls/TableViewCell.cs
@@ -0,0 +1,71 @@
+using Avalonia.Data;
+
+namespace Avalonia.Controls;
+
+/// <summary>
+/// Represents a single cell in a <see cref="TableViewRow"/>.
+/// </summary>
+public class TableViewCell : ContentControl
+{
+    private static CompiledBinding RowBinding
+        => field ??= new();
+
+    public static readonly DirectProperty<TableViewCell, TableViewColumn?> ColumnProperty =
+        AvaloniaProperty.RegisterDirect<TableViewCell, TableViewColumn?>(nameof(Column), o => o.Column);
+
+    /// <summary>
+    /// Gets the column associated with this cell.
+    /// </summary>
+    public TableViewColumn? Column
+    {
+        get;
+        internal set
+        {
+            var oldValue = field;
+            if (!SetAndRaise(ColumnProperty, ref field, value))
+                return;
+
+            if (oldValue is not null)
+                ClearProperties();
+
+            if (value is not null)
+                SetProperties(value);
+        }
+    }
+
+    private void ClearProperties()
+    {
+        ClearValue(ThemeProperty);
+        ClearValue(HorizontalContentAlignmentProperty);
+        ClearValue(ContentTemplateProperty);
+        ClearValue(ContentProperty);
+    }
+
+    private void SetProperties(TableViewColumn column)
+    {
+        // We don't bind the various properties here.
+        // First, it's pretty rare for a column's properties to change after the initial setup.
+        // Second, we have additional logic depending on whether a cell template is specified.
+        // Instead, values are updated manually via Refresh().
+
+        SetValue(ThemeProperty, column.CellTheme);
+        SetValue(HorizontalContentAlignmentProperty, column.HorizontalContentAlignment);
+
+        if (column.CellTemplate is { } cellTemplate)
+        {
+            SetValue(ContentTemplateProperty, cellTemplate);
+            Bind(ContentProperty, RowBinding);
+        }
+        else
+        {
+            SetValue(ContentTemplateProperty, null);
+            Bind(ContentProperty, column.Binding ?? RowBinding);
+        }
+    }
+
+    internal void Refresh()
+    {
+        if (Column is not null)
+            SetProperties(Column);
+    }
+}
diff --git a/src/Avalonia.Controls/TableViewColumn.cs b/src/Avalonia.Controls/TableViewColumn.cs
new file mode 100644
index 0000000000..d10278faf9
--- /dev/null
+++ b/src/Avalonia.Controls/TableViewColumn.cs
@@ -0,0 +1,258 @@
+using System;
+using System.Text;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.Templates;
+using Avalonia.Data;
+using Avalonia.Layout;
+using Avalonia.Metadata;
+using Avalonia.Styling;
+
+namespace Avalonia.Controls;
+
+/// <summary>
+/// Defines a column in a <see cref="TableView"/>.
+/// </summary>
+public class TableViewColumn : StyledElement, IHeadered
+{
+    /// <summary>
+    /// Defines the <see cref="HeaderTheme"/> property.
+    /// </summary>
+    public static readonly StyledProperty<ControlTheme?> HeaderThemeProperty =
+        AvaloniaProperty.Register<TableViewColumn, ControlTheme?>(nameof(HeaderTheme));
+
+    /// <summary>
+    /// Defines the <see cref="HeaderTemplate"/> property.
+    /// </summary>
+    public static readonly StyledProperty<IDataTemplate?> HeaderTemplateProperty =
+        HeaderedContentControl.HeaderTemplateProperty.AddOwner<TableViewColumn>();
+
+    /// <summary>
+    /// Defines the <see cref="Header"/> property.
+    /// </summary>
+    public static readonly StyledProperty<object?> HeaderProperty =
+        HeaderedContentControl.HeaderProperty.AddOwner<TableViewColumn>();
+
+    /// <summary>
+    /// Defines the <see cref="Width"/> property.
+    /// </summary>
+    public static readonly StyledProperty<GridLength> WidthProperty =
+        AvaloniaProperty.Register<TableViewColumn, GridLength>(nameof(Width), new GridLength(1, GridUnitType.Star));
+
+    /// <summary>
+    /// Defines the <see cref="CellTheme"/> property.
+    /// </summary>
+    public static readonly StyledProperty<ControlTheme?> CellThemeProperty =
+        AvaloniaProperty.Register<TableViewColumn, ControlTheme?>(nameof(CellTheme));
+
+    /// <summary>
+    /// Defines the <see cref="CellTemplate"/> property.
+    /// </summary>
+    public static readonly StyledProperty<IDataTemplate?> CellTemplateProperty =
+        AvaloniaProperty.Register<TableViewColumn, IDataTemplate?>(nameof(CellTemplate));
+
+    /// <summary>
+    /// Defines the <see cref="Binding" /> property.
+    /// </summary>
+    public static readonly StyledProperty<BindingBase?> BindingProperty =
+        AvaloniaProperty.Register<TableViewColumn, BindingBase?>(nameof(Binding));
+
+    /// <summary>
+    /// Defines the <see cref="CanUserResize"/> property.
+    /// </summary>
+    public static readonly StyledProperty<bool?> CanUserResizeProperty =
+        AvaloniaProperty.Register<TableViewColumn, bool?>(nameof(CanUserResize));
+
+    /// <summary>
+    /// Defines the <see cref="HorizontalContentAlignment"/> property.
+    /// </summary>
+    public static readonly StyledProperty<HorizontalAlignment> HorizontalContentAlignmentProperty =
+        ContentControl.HorizontalContentAlignmentProperty.AddOwner<TableViewColumn>(
+            new StyledPropertyMetadata<HorizontalAlignment>(defaultValue: HorizontalAlignment.Left));
+
+    /// <summary>
+    /// Defines the <see cref="TableView"/> property.
+    /// </summary>
+    public static readonly DirectProperty<TableViewColumn, TableView?> TableViewProperty =
+        AvaloniaProperty.RegisterDirect<TableViewColumn, TableView?>(nameof(TableView), o => o.TableView);
+
+    /// <summary>
+    /// Defines the <see cref="ActualWidth"/> property.
+    /// </summary>
+    public static readonly DirectProperty<TableViewColumn, double> ActualWidthProperty =
+        AvaloniaProperty.RegisterDirect<TableViewColumn, double>(nameof(ActualWidth), o => o.ActualWidth);
+
+    /// <summary>
+    /// Defines the <see cref="CanUserEffectivelyResize"/> property.
+    /// </summary>
+    public static readonly DirectProperty<TableViewColumn, bool> CanUserEffectivelyResizeProperty =
+        AvaloniaProperty.RegisterDirect<TableViewColumn, bool>(nameof(CanUserEffectivelyResize), o => o.CanUserEffectivelyResize);
+
+    /// <summary>
+    /// Gets or sets the theme to apply to the header.
+    /// It must target <see cref="TableViewColumnHeader"/>.
+    /// </summary>
+    public ControlTheme? HeaderTheme
+    {
+        get => GetValue(HeaderThemeProperty);
+        set => SetValue(HeaderThemeProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the data template used to display the header.
+    /// </summary>
+    public IDataTemplate? HeaderTemplate
+    {
+        get => GetValue(HeaderTemplateProperty);
+        set => SetValue(HeaderTemplateProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the column header content.
+    /// </summary>
+    public object? Header
+    {
+        get => GetValue(HeaderProperty);
+        set => SetValue(HeaderProperty, value);
+    }
+
+
+    /// <summary>
+    /// Gets or sets the column width. Supports pixel, star (*) and auto sizing.
+    /// </summary>
+    public GridLength Width
+    {
+        get => GetValue(WidthProperty);
+        set => SetValue(WidthProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the theme to apply to the cells.
+    /// It must target <see cref="TableViewCell"/>.
+    /// </summary>
+    public ControlTheme? CellTheme
+    {
+        get => GetValue(CellThemeProperty);
+        set => SetValue(CellThemeProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the data template used to display cell content.
+    /// When set, the whole row data item is passed as the template's data context.
+    /// </summary>
+    /// <remarks>This property takes priority over <see cref="Binding"/>.</remarks>
+    [InheritDataTypeFromItems(nameof(TableView.ItemsSource), AncestorType = typeof(TableView))]
+    public IDataTemplate? CellTemplate
+    {
+        get => GetValue(CellTemplateProperty);
+        set => SetValue(CellTemplateProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets a binding that retrieves the cell value from the row data item.
+    /// Use this for simple property display, e.g. <c>Binding="{Binding Name}"</c>.
+    /// </summary>
+    [AssignBinding]
+    [InheritDataTypeFromItems(nameof(TableView.ItemsSource), AncestorType = typeof(TableView))]
+    public BindingBase? Binding
+    {
+        get => GetValue(BindingProperty);
+        set => SetValue(BindingProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets whether the column can be resized.
+    /// Set to null to use the value from <see cref="Avalonia.Controls.TableView.CanUserResizeColumns"/>.
+    /// The default is null.
+    /// </summary>
+    public bool? CanUserResize
+    {
+        get => GetValue(CanUserResizeProperty);
+        set => SetValue(CanUserResizeProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets the horizontal alignment of the content within a cell.
+    /// </summary>
+    public HorizontalAlignment HorizontalContentAlignment
+    {
+        get => GetValue(HorizontalContentAlignmentProperty);
+        set => SetValue(HorizontalContentAlignmentProperty, value);
+    }
+
+    /// <summary>
+    /// Gets the <see cref="TableView"/> associated with this column.
+    /// </summary>
+    public TableView? TableView
+    {
+        get;
+        internal set
+        {
+            if (SetAndRaise(TableViewProperty, ref field, value))
+                UpdateCanUserEffectivelyResize();
+        }
+    }
+
+    /// <summary>
+    /// Gets the actual width of the column, in device independent pixels.
+    /// If the column hasn't yet been measured, returns <see cref="double.NaN"/>.
+    /// </summary>
+    public double ActualWidth
+    {
+        get;
+        internal set => SetAndRaise(ActualWidthProperty, ref field, value);
+    } = double.NaN;
+
+    /// <summary>
+    /// Gets whether the column can be effectively resized.
+    /// The value of this property depends on both <see cref="CanUserResize"/> and
+    /// <see cref="Avalonia.Controls.TableView.CanUserResizeColumns"/>.
+    /// </summary>
+    public bool CanUserEffectivelyResize
+    {
+        get;
+        internal set => SetAndRaise(CanUserEffectivelyResizeProperty, ref field, value);
+    }
+
+    private static bool IsCellProperty(AvaloniaProperty property)
+        => property == CellThemeProperty ||
+           property == CellTemplateProperty ||
+           property == BindingProperty ||
+           property == HorizontalContentAlignmentProperty;
+
+    private static bool IsHeaderProperty(AvaloniaProperty property)
+        => property == HeaderThemeProperty ||
+           property == HeaderTemplateProperty ||
+           property == HeaderProperty ||
+           property == HorizontalContentAlignmentProperty;
+
+    /// <inheritdoc />
+    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+    {
+        base.OnPropertyChanged(change);
+
+        if (change.Property == WidthProperty)
+            TableView?.OnColumnsSizeChanged();
+        else if (change.Property == CanUserResizeProperty)
+            UpdateCanUserEffectivelyResize();
+        else
+        {
+            if (IsHeaderProperty(change.Property))
+                TableView?.RefreshColumnHeaders(this);
+            if (IsCellProperty(change.Property))
+                TableView?.RefreshColumnCells(this);
+        }
+    }
+
+    internal void UpdateCanUserEffectivelyResize()
+        => CanUserEffectivelyResize = CanUserResize ?? TableView?.CanUserResizeColumns ?? true;
+
+    internal override void BuildDebugDisplay(StringBuilder builder, bool includeContent)
+    {
+        base.BuildDebugDisplay(builder, includeContent);
+
+        if (includeContent)
+        {
+            DebugDisplayHelper.AppendOptionalValue(builder, nameof(Header), Header, includeContent);
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/TableViewColumnHeader.cs b/src/Avalonia.Controls/TableViewColumnHeader.cs
new file mode 100644
index 0000000000..4afe51e475
--- /dev/null
+++ b/src/Avalonia.Controls/TableViewColumnHeader.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Text;
+using Avalonia.Controls.Metadata;
+using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+
+namespace Avalonia.Controls;
+
+/// <summary>
+/// Represents the header of a <see cref="TableViewColumn"/>.
+/// </summary>
+[TemplatePart(PartResizer, typeof(Thumb))]
+public class TableViewColumnHeader : ContentControl
+{
+    private const string PartResizer = "PART_Resizer";
+
+    /// <summary>
+    /// Identifies the <see cref="Column"/> property.
+    /// </summary>
+    public static readonly DirectProperty<TableViewColumnHeader, TableViewColumn?> ColumnProperty =
+        AvaloniaProperty.RegisterDirect<TableViewColumnHeader, TableViewColumn?>(nameof(Column), o => o.Column);
+
+    private Thumb? _resizer;
+
+    /// <summary>
+    /// Gets the column associated with this header.
+    /// </summary>
+    public TableViewColumn? Column
+    {
+        get;
+        internal set
+        {
+            var oldValue = field;
+            if (!SetAndRaise(ColumnProperty, ref field, value))
+                return;
+
+            if (oldValue is not null)
+                ClearProperties();
+
+            if (value is not null)
+                SetProperties(value);
+        }
+    }
+
+    /// <inheritdoc />
+    protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+    {
+        base.OnApplyTemplate(e);
+
+        _resizer?.DragDelta -= OnResizerDragDelta;
+        _resizer = e.NameScope.Find<Thumb>(PartResizer);
+        _resizer?.DragDelta += OnResizerDragDelta;
+    }
+
+    private void OnResizerDragDelta(object? sender, VectorEventArgs e)
+    {
+        if (Column is not { CanUserEffectivelyResize: true } column)
+            return;
+
+        var actualWidth = column.ActualWidth;
+        if (double.IsNaN(actualWidth))
+            return;
+
+        var minWidth = _resizer?.Bounds.Width ?? 0;
+        var newWidth = Math.Max(minWidth, actualWidth + e.Vector.X);
+        column.Width = new GridLength(newWidth, GridUnitType.Pixel);
+    }
+
+    internal override void BuildDebugDisplay(StringBuilder builder, bool includeContent)
+    {
+        base.BuildDebugDisplay(builder, includeContent);
+
+        if (includeContent)
+        {
+            DebugDisplayHelper.AppendOptionalValue(builder, nameof(Column), Column?.Header, includeContent);
+        }
+    }
+
+    private void ClearProperties()
+    {
+        ClearValue(ThemeProperty);
+        ClearValue(HorizontalContentAlignmentProperty);
+        ClearValue(ContentTemplateProperty);
+        ClearValue(ContentProperty);
+    }
+
+    private void SetProperties(TableViewColumn column)
+    {
+        SetOrClearValue(ThemeProperty, column.HeaderTheme);
+        SetValue(HorizontalContentAlignmentProperty, column.HorizontalContentAlignment);
+        SetOrClearValue(ContentTemplateProperty, column.HeaderTemplate);
+        SetOrClearValue(ContentProperty, column.Header);
+
+        void SetOrClearValue<T>(StyledProperty<T?> property, T? value) where T : class
+        {
+            if (value is not null)
+                SetValue(property, value);
+            else
+                ClearValue(property);
+        }
+    }
+
+    internal void Refresh()
+    {
+        if (Column is not null)
+            SetProperties(Column);
+    }
+}
diff --git a/src/Avalonia.Controls/TableViewRow.cs b/src/Avalonia.Controls/TableViewRow.cs
new file mode 100644
index 0000000000..3084f23844
--- /dev/null
+++ b/src/Avalonia.Controls/TableViewRow.cs
@@ -0,0 +1,54 @@
+using System.Diagnostics;
+using Avalonia.Collections;
+using Avalonia.Controls.Metadata;
+using Avalonia.Controls.Presenters;
+using Avalonia.Controls.Primitives;
+
+namespace Avalonia.Controls;
+
+/// <summary>
+/// A row container in a <see cref="TableView"/>.
+/// </summary>
+[TemplatePart(PartCellsPresenter, typeof(TableViewCellsPresenter))]
+public class TableViewRow : ListBoxItem
+{
+    private const string PartCellsPresenter = "PART_CellsPresenter";
+
+    private TableViewCellsPresenter? _cellsPresenter;
+
+    internal AvaloniaList<TableViewColumn>? Columns { get; set; }
+
+    /// <inheritdoc />
+    protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
+    {
+        base.OnApplyTemplate(e);
+
+        if (_cellsPresenter is not null)
+        {
+            Debug.Assert(_cellsPresenter.Row == this);
+            _cellsPresenter.RemoveCells();
+            _cellsPresenter.Row = null;
+        }
+
+        _cellsPresenter = e.NameScope.Find<TableViewCellsPresenter>(PartCellsPresenter);
+
+        if (_cellsPresenter is not null)
+        {
+            Debug.Assert(_cellsPresenter.Row is null);
+            _cellsPresenter.Row = this;
+            _cellsPresenter.RebuildCells();
+        }
+    }
+
+    internal void ClearCells()
+        => _cellsPresenter?.ClearCells();
+
+    internal void InvalidateCellsMeasure()
+        => _cellsPresenter?.InvalidateMeasure();
+
+    internal void RebuildCells()
+        => _cellsPresenter?.RebuildCells();
+
+    internal void RefreshCell(int columnIndex)
+        => _cellsPresenter?.RefreshCell(columnIndex);
+}
diff --git a/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml b/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml
index f7d04ccd9b..2248551a95 100644
--- a/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml
+++ b/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml
@@ -817,15 +817,34 @@
       <SolidColorBrush x:Key="ScrollViewerScrollBarsSeparatorBackground"
                        Color="{StaticResource SystemChromeMediumColor}" Opacity="0.9" />
 
-      <!-- BaseResources for RefreshVisualizer.xaml -->
+      <!-- Resources for RefreshVisualizer.xaml -->
       <SolidColorBrush x:Key="RefreshVisualizerForeground" Color="Black" />
       <SolidColorBrush x:Key="RefreshVisualizerBackground" Color="Transparent" />
       
-      <!-- BaseResources for WindowDrawnDecorations.xaml -->
+      <!-- Resources for WindowDrawnDecorations.xaml -->
       <SolidColorBrush x:Key="CaptionButtonForeground" Color="Black" />
       <SolidColorBrush x:Key="CaptionButtonBackground" Color="#ffe5e5e5" />
       <SolidColorBrush x:Key="CaptionButtonBorderBrush" Color="#ffcacaca" />
       <StaticResource x:Key="TitleBarBackgroundBrush" ResourceKey="SystemControlBackgroundAltHighBrush" />
+
+      <!-- Resources for TableViewColumnHeader.xaml -->
+      <StaticResource x:Key="TableViewColumnHeaderSeparatorBackground" ResourceKey="SystemBaseLowColor" />
+
+      <!-- Resources for TableViewRow.xaml -->
+      <SolidColorBrush x:Key="TableViewRowBackground">Transparent</SolidColorBrush>
+      <SolidColorBrush x:Key="TableViewRowBackgroundDisabled">Transparent</SolidColorBrush>
+      <StaticResource x:Key="TableViewRowForegroundDisabled" ResourceKey="SystemControlDisabledBaseMediumLowBrush" />
+      <StaticResource x:Key="TableViewRowBackgroundPointerOver" ResourceKey="SystemControlHighlightListLowBrush" />
+      <StaticResource x:Key="TableViewRowForegroundPointerOver" ResourceKey="SystemControlHighlightAltBaseHighBrush" />
+      <StaticResource x:Key="TableViewRowBackgroundPressed" ResourceKey="SystemControlHighlightListMediumBrush" />
+      <StaticResource x:Key="TableViewRowForegroundPressed" ResourceKey="SystemControlHighlightAltBaseHighBrush" />
+      <StaticResource x:Key="TableViewRowBackgroundSelected" ResourceKey="SystemControlHighlightListAccentLowBrush" />
+      <StaticResource x:Key="TableViewRowForegroundSelected" ResourceKey="SystemControlHighlightAltBaseHighBrush" />
+      <StaticResource x:Key="TableViewRowBackgroundSelectedPointerOver" ResourceKey="SystemControlHighlightListAccentMediumBrush" />
+      <StaticResource x:Key="TableViewRowForegroundSelectedPointerOver" ResourceKey="SystemControlHighlightAltBaseHighBrush" />
+      <StaticResource x:Key="TableViewRowBackgroundSelectedPressed" ResourceKey="SystemControlHighlightListAccentHighBrush" />
+      <StaticResource x:Key="TableViewRowForegroundSelectedPressed" ResourceKey="SystemControlHighlightAltBaseHighBrush" />
+
     </ResourceDictionary>
     <ResourceDictionary x:Key="Dark">
       <!-- Resources for Button.xaml -->
@@ -1641,19 +1660,38 @@
       <StaticResource x:Key="FlyoutPresenterBackground" ResourceKey="SystemControlBackgroundChromeMediumLowBrush" />
       <StaticResource x:Key="FlyoutBorderThemeBrush" ResourceKey="SystemControlTransientBorderBrush" />
 
-      <!-- BaseResources for ScrollViewer.xaml -->
+      <!-- Resources for ScrollViewer.xaml -->
       <SolidColorBrush x:Key="ScrollViewerScrollBarsSeparatorBackground"
                        Color="{StaticResource SystemChromeMediumColor}" Opacity="0.9" />
 
-      <!-- BaseResources for RefreshVisualizer.xaml -->
+      <!-- Resources for RefreshVisualizer.xaml -->
       <SolidColorBrush x:Key="RefreshVisualizerForeground" Color="White" />
       <SolidColorBrush x:Key="RefreshVisualizerBackground" Color="Transparent" />
 
-      <!-- BaseResources for WindowDrawnDecorations.xaml -->
+      <!-- Resources for WindowDrawnDecorations.xaml -->
       <SolidColorBrush x:Key="CaptionButtonForeground" Color="White" />
       <SolidColorBrush x:Key="CaptionButtonBackground" Color="#ff1d170f" />
       <SolidColorBrush x:Key="CaptionButtonBorderBrush" Color="#ffcacaca" />
       <StaticResource x:Key="TitleBarBackgroundBrush" ResourceKey="SystemControlBackgroundAltHighBrush" />
+
+      <!-- Resources for TableViewColumnHeader.xaml -->
+      <StaticResource x:Key="TableViewColumnHeaderSeparatorBackground" ResourceKey="SystemBaseLowColor" />
+
+      <!-- Resources for TableViewRow.xaml -->
+      <SolidColorBrush x:Key="TableViewRowBackground">Transparent</SolidColorBrush>
+      <SolidColorBrush x:Key="TableViewRowBackgroundDisabled">Transparent</SolidColorBrush>
+      <StaticResource x:Key="TableViewRowForegroundDisabled" ResourceKey="SystemControlDisabledBaseMediumLowBrush" />
+      <StaticResource x:Key="TableViewRowBackgroundPointerOver" ResourceKey="SystemControlHighlightListLowBrush" />
+      <StaticResource x:Key="TableViewRowForegroundPointerOver" ResourceKey="SystemControlHighlightAltBaseHighBrush" />
+      <StaticResource x:Key="TableViewRowBackgroundPressed" ResourceKey="SystemControlHighlightListMediumBrush" />
+      <StaticResource x:Key="TableViewRowForegroundPressed" ResourceKey="SystemControlHighlightAltBaseHighBrush" />
+      <StaticResource x:Key="TableViewRowBackgroundSelected" ResourceKey="SystemControlHighlightListAccentLowBrush" />
+      <StaticResource x:Key="TableViewRowForegroundSelected" ResourceKey="SystemControlHighlightAltBaseHighBrush" />
+      <StaticResource x:Key="TableViewRowBackgroundSelectedPointerOver" ResourceKey="SystemControlHighlightListAccentMediumBrush" />
+      <StaticResource x:Key="TableViewRowForegroundSelectedPointerOver" ResourceKey="SystemControlHighlightAltBaseHighBrush" />
+      <StaticResource x:Key="TableViewRowBackgroundSelectedPressed" ResourceKey="SystemControlHighlightListAccentHighBrush" />
+      <StaticResource x:Key="TableViewRowForegroundSelectedPressed" ResourceKey="SystemControlHighlightAltBaseHighBrush" />
+
     </ResourceDictionary>
   </ResourceDictionary.ThemeDictionaries>
 </ResourceDictionary>
diff --git a/src/Avalonia.Themes.Fluent/Controls/FluentControls.xaml b/src/Avalonia.Themes.Fluent/Controls/FluentControls.xaml
index 0daa900a4c..5ccb856bc0 100644
--- a/src/Avalonia.Themes.Fluent/Controls/FluentControls.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/FluentControls.xaml
@@ -52,6 +52,10 @@
                 <MergeResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/SplitView.xaml" />
                 <MergeResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/TabControl.xaml" />
                 <MergeResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/TabItem.xaml" />
+                <MergeResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/TableView.xaml" />
+                <MergeResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/TableViewCell.xaml" />
+                <MergeResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/TableViewColumnHeader.xaml" />
+                <MergeResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/TableViewRow.xaml" />
                 <MergeResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/TabStrip.xaml" />
                 <MergeResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/TabStripItem.xaml" />
                 <MergeResourceInclude Source="avares://Avalonia.Themes.Fluent/Controls/TextBox.xaml" />
diff --git a/src/Avalonia.Themes.Fluent/Controls/TableView.xaml b/src/Avalonia.Themes.Fluent/Controls/TableView.xaml
new file mode 100644
index 0000000000..09661e3cbf
--- /dev/null
+++ b/src/Avalonia.Themes.Fluent/Controls/TableView.xaml
@@ -0,0 +1,116 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    x:ClassModifier="internal">
+
+  <Design.PreviewWith>
+    <Border Padding="20">
+      <TableView Height="200" Width="400">
+        <TableView.Columns>
+          <TableViewColumn Header="Name" Width="*" />
+          <TableViewColumn Header="Value" Width="120" />
+        </TableView.Columns>
+      </TableView>
+    </Border>
+  </Design.PreviewWith>
+
+  <!-- ScrollViewer in TableView -->
+  <ControlTheme x:Key="TableViewScrollViewerTheme" TargetType="ScrollViewer">
+    <Setter Property="Background" Value="Transparent" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Grid ColumnDefinitions="*,Auto"
+              RowDefinitions="*,Auto">
+            <DockPanel Name="ContentPanel">
+              <Border Background="{DynamicResource SystemControlBackgroundChromeMediumBrush}"
+                      Padding="{DynamicResource TableViewRowPadding}"
+                      DockPanel.Dock="Top">
+                <TableViewColumnHeadersPresenter />
+              </Border>
+              <ScrollContentPresenter Name="PART_ContentPresenter"
+                                      Background="{TemplateBinding Background}"
+                                      HorizontalSnapPointsType="{TemplateBinding HorizontalSnapPointsType}"
+                                      VerticalSnapPointsType="{TemplateBinding VerticalSnapPointsType}"
+                                      HorizontalSnapPointsAlignment="{TemplateBinding HorizontalSnapPointsAlignment}"
+                                      VerticalSnapPointsAlignment="{TemplateBinding VerticalSnapPointsAlignment}"
+                                      Padding="{TemplateBinding Padding}"
+                                      ScrollViewer.IsScrollInertiaEnabled="{TemplateBinding IsScrollInertiaEnabled}">
+                <ScrollContentPresenter.GestureRecognizers>
+                  <ScrollGestureRecognizer CanHorizontallyScroll="{Binding CanHorizontallyScroll, ElementName=PART_ContentPresenter}"
+                                           CanVerticallyScroll="{Binding CanVerticallyScroll, ElementName=PART_ContentPresenter}"
+                                           IsScrollInertiaEnabled="{Binding (ScrollViewer.IsScrollInertiaEnabled), ElementName=PART_ContentPresenter}" />
+                </ScrollContentPresenter.GestureRecognizers>
+              </ScrollContentPresenter>
+            </DockPanel>
+          <ScrollBar Name="PART_HorizontalScrollBar"
+                     Orientation="Horizontal"
+                     Grid.Column="0"
+                     Grid.Row="1" />
+          <ScrollBar Name="PART_VerticalScrollBar"
+                     Orientation="Vertical"
+                     Grid.Column="1"
+                     Grid.Row="0" />
+          <Panel x:Name="PART_ScrollBarsSeparator"
+                 Grid.Row="1"
+                 Grid.Column="1"
+                 Background="{DynamicResource ScrollViewerScrollBarsSeparatorBackground}"
+                 Opacity="0">
+            <Panel.Transitions>
+              <Transitions>
+                <DoubleTransition Property="Opacity" Duration="0:0:0.1" />
+              </Transitions>
+            </Panel.Transitions>
+          </Panel>
+        </Grid>
+      </ControlTemplate>
+    </Setter>
+
+    <Style Selector="^[IsExpanded=true] /template/ Panel#PART_ScrollBarsSeparator">
+      <Setter Property="Opacity" Value="1" />
+    </Style>
+
+    <Style Selector="^[AllowAutoHide=True] /template/ DockPanel#ContentPanel">
+      <Setter Property="Grid.ColumnSpan" Value="2" />
+      <Setter Property="Grid.RowSpan" Value="2" />
+    </Style>
+
+  </ControlTheme>
+
+  <!-- TableView theme -->
+  <ControlTheme x:Key="{x:Type TableView}" TargetType="TableView">
+    <Setter Property="Foreground" Value="{DynamicResource SystemControlForegroundBaseHighBrush}" />
+    <Setter Property="Background" Value="{DynamicResource SystemControlBackgroundChromeMediumLowBrush}" />
+    <Setter Property="BorderBrush" Value="{DynamicResource SystemControlForegroundBaseHighBrush}" />
+    <Setter Property="BorderThickness" Value="{DynamicResource ListBoxBorderThemeThickness}" />
+    <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Auto" />
+    <Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Auto" />
+    <Setter Property="ScrollViewer.IsScrollChainingEnabled" Value="True" />
+    <Setter Property="ScrollViewer.IsScrollInertiaEnabled" Value="True" />
+    <Setter Property="TextBlock.TextTrimming" Value="{x:Static TextTrimming.CharacterEllipsis}" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Border ClipToBounds="{TemplateBinding ClipToBounds}"
+                Background="{TemplateBinding Background}"
+                BorderBrush="{TemplateBinding BorderBrush}"
+                BorderThickness="{TemplateBinding BorderThickness}"
+                CornerRadius="{TemplateBinding CornerRadius}">
+          <ScrollViewer Name="PART_ScrollViewer"
+                        Theme="{StaticResource TableViewScrollViewerTheme}"
+                        VerticalSnapPointsType="{TemplateBinding (ScrollViewer.VerticalSnapPointsType)}"
+                        HorizontalSnapPointsType="{TemplateBinding (ScrollViewer.HorizontalSnapPointsType)}"
+                        HorizontalScrollBarVisibility="{TemplateBinding (ScrollViewer.HorizontalScrollBarVisibility)}"
+                        VerticalScrollBarVisibility="{TemplateBinding (ScrollViewer.VerticalScrollBarVisibility)}"
+                        IsScrollChainingEnabled="{TemplateBinding (ScrollViewer.IsScrollChainingEnabled)}"
+                        IsScrollInertiaEnabled="{TemplateBinding (ScrollViewer.IsScrollInertiaEnabled)}"
+                        IsDeferredScrollingEnabled="{TemplateBinding (ScrollViewer.IsDeferredScrollingEnabled)}"
+                        AllowAutoHide="{TemplateBinding (ScrollViewer.AllowAutoHide)}"
+                        BringIntoViewOnFocusChange="{TemplateBinding (ScrollViewer.BringIntoViewOnFocusChange)}">
+            <ItemsPresenter Name="PART_ItemsPresenter"
+                            ItemsPanel="{TemplateBinding ItemsPanel}"
+                            Margin="{TemplateBinding Padding}" />
+          </ScrollViewer>
+        </Border>
+      </ControlTemplate>
+    </Setter>
+  </ControlTheme>
+
+</ResourceDictionary>
diff --git a/src/Avalonia.Themes.Fluent/Controls/TableViewCell.xaml b/src/Avalonia.Themes.Fluent/Controls/TableViewCell.xaml
new file mode 100644
index 0000000000..87ecc8d0f0
--- /dev/null
+++ b/src/Avalonia.Themes.Fluent/Controls/TableViewCell.xaml
@@ -0,0 +1,11 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    x:ClassModifier="internal">
+
+  <Thickness x:Key="TableViewCellPadding">6,0</Thickness>
+
+  <ControlTheme x:Key="{x:Type TableViewCell}" TargetType="TableViewCell">
+    <Setter Property="Padding" Value="{DynamicResource TableViewCellPadding}" />
+  </ControlTheme>
+
+</ResourceDictionary>
diff --git a/src/Avalonia.Themes.Fluent/Controls/TableViewColumnHeader.xaml b/src/Avalonia.Themes.Fluent/Controls/TableViewColumnHeader.xaml
new file mode 100644
index 0000000000..7ce900adba
--- /dev/null
+++ b/src/Avalonia.Themes.Fluent/Controls/TableViewColumnHeader.xaml
@@ -0,0 +1,54 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    x:ClassModifier="internal">
+
+  <Design.PreviewWith>
+    <Border Margin="20" BorderThickness="1" BorderBrush="LightGray">
+      <TableViewColumnHeader Content="Header" />
+    </Border>
+  </Design.PreviewWith>
+
+  <x:Double x:Key="TableViewColumnResizerWidth">12</x:Double>
+  <Thickness x:Key="TableViewColumnResizerMargin">0,-9,-6,-12</Thickness>
+
+  <ControlTemplate x:Key="TableViewColumnHeaderResizerTemplate" TargetType="Thumb">
+    <Border Background="Transparent">
+      <Rectangle Width="1"
+                 Fill="{DynamicResource TableViewColumnHeaderSeparatorBackground}"
+                 HorizontalAlignment="Center" />
+    </Border>
+  </ControlTemplate>
+
+  <ControlTheme x:Key="{x:Type TableViewColumnHeader}" TargetType="TableViewColumnHeader">
+    <Setter Property="FontWeight" Value="SemiBold" />
+    <Setter Property="Padding" Value="{DynamicResource TableViewCellPadding}" />
+    <Setter Property="HorizontalContentAlignment" Value="Left" />
+    <Setter Property="VerticalContentAlignment" Value="Center" />
+    <Setter Property="ClipToBounds" Value="False" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Panel>
+          <ContentPresenter Name="PART_ContentPresenter"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}"
+                            BorderThickness="{TemplateBinding BorderThickness}"
+                            CornerRadius="{TemplateBinding CornerRadius}"
+                            ContentTemplate="{TemplateBinding ContentTemplate}"
+                            Content="{TemplateBinding Content}"
+                            Padding="{TemplateBinding Padding}"
+                            VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}"
+                            HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}" />
+          <Thumb Name="PART_Resizer"
+                 Template="{StaticResource TableViewColumnHeaderResizerTemplate}"
+                 Width="{DynamicResource TableViewColumnResizerWidth}"
+                 HorizontalAlignment="Right"
+                 Cursor="SizeWestEast"
+                 Margin="{DynamicResource TableViewColumnResizerMargin}"
+                 IsEnabled="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Column?.CanUserEffectivelyResize, FallbackValue=False}">
+          </Thumb>
+        </Panel>
+      </ControlTemplate>
+    </Setter>
+  </ControlTheme>
+
+</ResourceDictionary>
diff --git a/src/Avalonia.Themes.Fluent/Controls/TableViewRow.xaml b/src/Avalonia.Themes.Fluent/Controls/TableViewRow.xaml
new file mode 100644
index 0000000000..2eda8a45fe
--- /dev/null
+++ b/src/Avalonia.Themes.Fluent/Controls/TableViewRow.xaml
@@ -0,0 +1,67 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    x:ClassModifier="internal">
+
+  <Thickness x:Key="TableViewRowPadding">6,9,6,12</Thickness>
+
+  <ControlTheme x:Key="{x:Type TableViewRow}" TargetType="TableViewRow">
+    <Setter Property="Background" Value="{DynamicResource TableViewRowBackground}" />
+    <Setter Property="Padding" Value="{DynamicResource TableViewRowPadding}" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Border Name="Border"
+                Background="{TemplateBinding Background}"
+                BorderBrush="{TemplateBinding BorderBrush}"
+                BorderThickness="{TemplateBinding BorderThickness}"
+                CornerRadius="{TemplateBinding CornerRadius}"
+                Padding="{TemplateBinding Padding}"
+                VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
+                HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}">
+          <TableViewCellsPresenter Name="PART_CellsPresenter" />
+        </Border>
+      </ControlTemplate>
+    </Setter>
+
+    <!-- Disabled -->
+    <Style Selector="^:disabled /template/ Border#Border">
+      <Setter Property="Background" Value="{DynamicResource TableViewRowBackgroundDisabled}" />
+      <Setter Property="TextElement.Foreground" Value="{DynamicResource TableViewRowForegroundDisabled}" />
+    </Style>
+
+    <!-- PointerOver -->
+    <Style Selector="^:pointerover /template/ Border#Border">
+      <Setter Property="Background" Value="{DynamicResource TableViewRowBackgroundPointerOver}" />
+      <Setter Property="TextElement.Foreground" Value="{DynamicResource TableViewRowForegroundPointerOver}" />
+    </Style>
+
+    <!-- Pressed -->
+    <Style Selector="^:pressed /template/ Border#Border">
+      <Setter Property="Background" Value="{DynamicResource TableViewRowBackgroundPressed}" />
+      <Setter Property="TextElement.Foreground" Value="{DynamicResource TableViewRowForegroundPressed}" />
+    </Style>
+
+    <!-- Selected -->
+    <Style Selector="^:selected">
+
+      <Style Selector="^ /template/ Border#Border">
+        <Setter Property="Background" Value="{DynamicResource TableViewRowBackgroundSelected}" />
+        <Setter Property="TextElement.Foreground" Value="{DynamicResource TableViewRowForegroundSelected}" />
+      </Style>
+
+      <!-- Selected PointerOver  -->
+      <Style Selector="^:pointerover /template/ Border#Border">
+        <Setter Property="Background" Value="{DynamicResource TableViewRowBackgroundSelectedPointerOver}" />
+        <Setter Property="TextElement.Foreground" Value="{DynamicResource TableViewRowForegroundSelectedPointerOver}" />
+      </Style>
+
+      <!-- Selected Pressed  -->
+      <Style Selector="^:pressed /template/ Border#Border">
+        <Setter Property="Background" Value="{DynamicResource TableViewRowBackgroundSelectedPressed}" />
+        <Setter Property="TextElement.Foreground" Value="{DynamicResource TableViewRowForegroundSelectedPressed}" />
+      </Style>
+
+    </Style>
+
+  </ControlTheme>
+
+</ResourceDictionary>
diff --git a/src/Avalonia.Themes.Fluent/DensityStyles/Compact.xaml b/src/Avalonia.Themes.Fluent/DensityStyles/Compact.xaml
index f306a0795f..6c67196063 100644
--- a/src/Avalonia.Themes.Fluent/DensityStyles/Compact.xaml
+++ b/src/Avalonia.Themes.Fluent/DensityStyles/Compact.xaml
@@ -6,7 +6,10 @@
   <x:Double x:Key="TextControlThemeMinWidth">32</x:Double>
   <Thickness x:Key="TextControlThemePadding">4, 2</Thickness>
   <Thickness x:Key="ListBoxItemPadding">4,2</Thickness>
-  <x:Double x:Key="ListViewItemMinHeight">24</x:Double>
+  <Thickness x:Key="TableViewRowPadding">2,2</Thickness>
+  <Thickness x:Key="TableViewCellPadding">2,0</Thickness>
+  <x:Double x:Key="TableViewColumnResizerWidth">4</x:Double>
+  <Thickness x:Key="TableViewColumnResizerMargin">0,-2,-2,-2</Thickness>
   <Thickness x:Key="ComboBoxItemThemePadding">11,5,11,7</Thickness>
   <Thickness x:Key="MenuFlyoutItemThemePaddingNarrow">4 4 8 4</Thickness>
   <Thickness x:Key="MenuBarItemPadding">5, 2</Thickness>
diff --git a/src/Avalonia.Themes.Simple/Controls/SimpleControls.xaml b/src/Avalonia.Themes.Simple/Controls/SimpleControls.xaml
index ef6de7ca78..ca1a07498d 100644
--- a/src/Avalonia.Themes.Simple/Controls/SimpleControls.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/SimpleControls.xaml
@@ -79,6 +79,10 @@
         <MergeResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/DrawerPage.xaml" />
         <MergeResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/NavigationPage.xaml" />
         <MergeResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/TabbedPage.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/TableView.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/TableViewCell.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/TableViewColumnHeader.xaml" />
+        <MergeResourceInclude Source="avares://Avalonia.Themes.Simple/Controls/TableViewRow.xaml" />
       </ResourceDictionary.MergedDictionaries>
     </ResourceDictionary>
   </Styles.Resources>
diff --git a/src/Avalonia.Themes.Simple/Controls/TableView.xaml b/src/Avalonia.Themes.Simple/Controls/TableView.xaml
new file mode 100644
index 0000000000..83463b326e
--- /dev/null
+++ b/src/Avalonia.Themes.Simple/Controls/TableView.xaml
@@ -0,0 +1,102 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    x:ClassModifier="internal">
+
+  <Design.PreviewWith>
+    <Border Padding="20">
+      <TableView Height="200" Width="400">
+        <TableView.Columns>
+          <TableViewColumn Header="Name" Width="*" />
+          <TableViewColumn Header="Value" Width="120" />
+        </TableView.Columns>
+      </TableView>
+    </Border>
+  </Design.PreviewWith>
+
+  <!-- ScrollViewer in TableView -->
+  <ControlTheme x:Key="TableViewScrollViewerTheme" TargetType="ScrollViewer">
+    <Setter Property="Background" Value="Transparent" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Grid ColumnDefinitions="*,Auto"
+              RowDefinitions="*,Auto">
+            <DockPanel Name="ContentPanel">
+              <Border Background="{DynamicResource ThemeControlMidBrush}"
+                      Padding="{DynamicResource TableViewRowPadding}"
+                      DockPanel.Dock="Top">
+                <TableViewColumnHeadersPresenter />
+              </Border>
+              <Rectangle Height="1"
+                         Fill="{DynamicResource ThemeBorderMidBrush}"
+                         DockPanel.Dock="Top" />
+              <ScrollContentPresenter Name="PART_ContentPresenter"
+                                      Background="{TemplateBinding Background}"
+                                      HorizontalSnapPointsType="{TemplateBinding HorizontalSnapPointsType}"
+                                      VerticalSnapPointsType="{TemplateBinding VerticalSnapPointsType}"
+                                      HorizontalSnapPointsAlignment="{TemplateBinding HorizontalSnapPointsAlignment}"
+                                      VerticalSnapPointsAlignment="{TemplateBinding VerticalSnapPointsAlignment}"
+                                      Padding="{TemplateBinding Padding}"
+                                      ScrollViewer.IsScrollInertiaEnabled="{TemplateBinding IsScrollInertiaEnabled}">
+                <ScrollContentPresenter.GestureRecognizers>
+                  <ScrollGestureRecognizer CanHorizontallyScroll="{Binding CanHorizontallyScroll, ElementName=PART_ContentPresenter}"
+                                           CanVerticallyScroll="{Binding CanVerticallyScroll, ElementName=PART_ContentPresenter}"
+                                           IsScrollInertiaEnabled="{Binding (ScrollViewer.IsScrollInertiaEnabled), ElementName=PART_ContentPresenter}" />
+                </ScrollContentPresenter.GestureRecognizers>
+              </ScrollContentPresenter>
+            </DockPanel>
+          <ScrollBar Name="PART_HorizontalScrollBar"
+                     Orientation="Horizontal"
+                     Grid.Column="0"
+                     Grid.Row="1" />
+          <ScrollBar Name="PART_VerticalScrollBar"
+                     Orientation="Vertical"
+                     Grid.Column="1"
+                     Grid.Row="0" />
+          <Panel x:Name="PART_ScrollBarsSeparator"
+                 Grid.Row="1"
+                 Grid.Column="1"
+                 Background="{DynamicResource ThemeControlMidBrush}" />
+        </Grid>
+      </ControlTemplate>
+    </Setter>
+  </ControlTheme>
+
+  <!-- TableView theme -->
+  <ControlTheme x:Key="{x:Type TableView}" TargetType="TableView">
+    <Setter Property="Foreground" Value="{DynamicResource ThemeForegroundBrush}" />
+    <Setter Property="Background" Value="{DynamicResource ThemeBackgroundBrush}" />
+    <Setter Property="BorderBrush" Value="{DynamicResource ThemeBorderMidBrush}" />
+    <Setter Property="BorderThickness" Value="{DynamicResource ThemeBorderThickness}" />
+    <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Auto" />
+    <Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Auto" />
+    <Setter Property="ScrollViewer.IsScrollChainingEnabled" Value="True" />
+    <Setter Property="ScrollViewer.IsScrollInertiaEnabled" Value="True" />
+    <Setter Property="TextBlock.TextTrimming" Value="{x:Static TextTrimming.CharacterEllipsis}" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Border ClipToBounds="{TemplateBinding ClipToBounds}"
+                Background="{TemplateBinding Background}"
+                BorderBrush="{TemplateBinding BorderBrush}"
+                BorderThickness="{TemplateBinding BorderThickness}"
+                CornerRadius="{TemplateBinding CornerRadius}">
+          <ScrollViewer Name="PART_ScrollViewer"
+                        Theme="{StaticResource TableViewScrollViewerTheme}"
+                        VerticalSnapPointsType="{TemplateBinding (ScrollViewer.VerticalSnapPointsType)}"
+                        HorizontalSnapPointsType="{TemplateBinding (ScrollViewer.HorizontalSnapPointsType)}"
+                        HorizontalScrollBarVisibility="{TemplateBinding (ScrollViewer.HorizontalScrollBarVisibility)}"
+                        VerticalScrollBarVisibility="{TemplateBinding (ScrollViewer.VerticalScrollBarVisibility)}"
+                        IsScrollChainingEnabled="{TemplateBinding (ScrollViewer.IsScrollChainingEnabled)}"
+                        IsScrollInertiaEnabled="{TemplateBinding (ScrollViewer.IsScrollInertiaEnabled)}"
+                        IsDeferredScrollingEnabled="{TemplateBinding (ScrollViewer.IsDeferredScrollingEnabled)}"
+                        AllowAutoHide="{TemplateBinding (ScrollViewer.AllowAutoHide)}"
+                        BringIntoViewOnFocusChange="{TemplateBinding (ScrollViewer.BringIntoViewOnFocusChange)}">
+            <ItemsPresenter Name="PART_ItemsPresenter"
+                            ItemsPanel="{TemplateBinding ItemsPanel}"
+                            Margin="{TemplateBinding Padding}" />
+          </ScrollViewer>
+        </Border>
+      </ControlTemplate>
+    </Setter>
+  </ControlTheme>
+
+</ResourceDictionary>
diff --git a/src/Avalonia.Themes.Simple/Controls/TableViewCell.xaml b/src/Avalonia.Themes.Simple/Controls/TableViewCell.xaml
new file mode 100644
index 0000000000..e9ab28b0e5
--- /dev/null
+++ b/src/Avalonia.Themes.Simple/Controls/TableViewCell.xaml
@@ -0,0 +1,11 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    x:ClassModifier="internal">
+
+  <Thickness x:Key="TableViewCellPadding">2,0</Thickness>
+
+  <ControlTheme x:Key="{x:Type TableViewCell}" TargetType="TableViewCell">
+    <Setter Property="Padding" Value="{DynamicResource TableViewCellPadding}" />
+  </ControlTheme>
+
+</ResourceDictionary>
diff --git a/src/Avalonia.Themes.Simple/Controls/TableViewColumnHeader.xaml b/src/Avalonia.Themes.Simple/Controls/TableViewColumnHeader.xaml
new file mode 100644
index 0000000000..c35cc13d8c
--- /dev/null
+++ b/src/Avalonia.Themes.Simple/Controls/TableViewColumnHeader.xaml
@@ -0,0 +1,54 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    x:ClassModifier="internal">
+
+  <Design.PreviewWith>
+    <Border Margin="20" BorderThickness="1" BorderBrush="LightGray">
+      <TableViewColumnHeader Content="Header" />
+    </Border>
+  </Design.PreviewWith>
+
+  <x:Double x:Key="TableViewColumnResizerWidth">4</x:Double>
+  <Thickness x:Key="TableViewColumnResizerMargin">0,-2,-1,-2</Thickness>
+
+  <ControlTemplate x:Key="TableViewColumnHeaderResizerTemplate" TargetType="Thumb">
+    <Border Background="Transparent">
+      <Rectangle Width="1"
+                 Fill="{DynamicResource ThemeBorderMidBrush}"
+                 HorizontalAlignment="Center" />
+    </Border>
+  </ControlTemplate>
+
+  <ControlTheme x:Key="{x:Type TableViewColumnHeader}" TargetType="TableViewColumnHeader">
+    <Setter Property="FontWeight" Value="SemiBold" />
+    <Setter Property="Padding" Value="{DynamicResource TableViewCellPadding}" />
+    <Setter Property="HorizontalContentAlignment" Value="Left" />
+    <Setter Property="VerticalContentAlignment" Value="Center" />
+    <Setter Property="ClipToBounds" Value="False" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Panel>
+          <ContentPresenter Name="PART_ContentPresenter"
+                            Background="{TemplateBinding Background}"
+                            BorderBrush="{TemplateBinding BorderBrush}"
+                            BorderThickness="{TemplateBinding BorderThickness}"
+                            CornerRadius="{TemplateBinding CornerRadius}"
+                            ContentTemplate="{TemplateBinding ContentTemplate}"
+                            Content="{TemplateBinding Content}"
+                            Padding="{TemplateBinding Padding}"
+                            VerticalContentAlignment="{TemplateBinding VerticalContentAlignment}"
+                            HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}" />
+          <Thumb Name="PART_Resizer"
+                 Template="{StaticResource TableViewColumnHeaderResizerTemplate}"
+                 Width="{DynamicResource TableViewColumnResizerWidth}"
+                 HorizontalAlignment="Right"
+                 Cursor="SizeWestEast"
+                 Margin="{DynamicResource TableViewColumnResizerMargin}"
+                 IsEnabled="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Column?.CanUserEffectivelyResize, FallbackValue=False}">
+          </Thumb>
+        </Panel>
+      </ControlTemplate>
+    </Setter>
+  </ControlTheme>
+
+</ResourceDictionary>
diff --git a/src/Avalonia.Themes.Simple/Controls/TableViewRow.xaml b/src/Avalonia.Themes.Simple/Controls/TableViewRow.xaml
new file mode 100644
index 0000000000..2e31720b10
--- /dev/null
+++ b/src/Avalonia.Themes.Simple/Controls/TableViewRow.xaml
@@ -0,0 +1,72 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+                    x:ClassModifier="internal">
+
+  <Thickness x:Key="TableViewRowPadding">2,1</Thickness>
+
+  <ControlTheme x:Key="{x:Type TableViewRow}" TargetType="TableViewRow">
+    <Setter Property="Background" Value="Transparent" />
+    <Setter Property="Padding" Value="{DynamicResource TableViewRowPadding}" />
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Border Name="Border"
+                Background="{TemplateBinding Background}"
+                BorderBrush="{TemplateBinding BorderBrush}"
+                BorderThickness="{TemplateBinding BorderThickness}"
+                CornerRadius="{TemplateBinding CornerRadius}"
+                Padding="{TemplateBinding Padding}"
+                VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
+                HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}">
+          <TableViewCellsPresenter Name="PART_CellsPresenter" />
+        </Border>
+      </ControlTemplate>
+    </Setter>
+
+    <!-- Disabled -->
+    <Style Selector="^:disabled /template/ Border#Border">
+      <Setter Property="TextElement.Foreground" Value="{DynamicResource ThemeForegroundLowBrush}" />
+    </Style>
+
+    <!-- PointerOver -->
+    <Style Selector="^:pointerover /template/ Border#Border">
+      <Setter Property="Background" Value="{DynamicResource ThemeControlHighlightMidBrush}" />
+      <Setter Property="TextElement.Foreground" Value="{DynamicResource ThemeForegroundBrush}" />
+    </Style>
+
+    <!-- Pressed -->
+    <Style Selector="^:pressed /template/ Border#Border">
+      <Setter Property="Background" Value="{DynamicResource ThemeControlHighlightHighBrush}" />
+      <Setter Property="TextElement.Foreground" Value="{DynamicResource ThemeForegroundBrush}" />
+    </Style>
+
+    <!-- Selected -->
+    <Style Selector="^:selected">
+
+      <Style Selector="^ /template/ Border#Border">
+        <Setter Property="Background" Value="{DynamicResource ThemeAccentBrush4}" />
+        <Setter Property="TextElement.Foreground" Value="{DynamicResource ThemeForegroundBrush}" />
+      </Style>
+
+      <!-- Selected Unfocused  -->
+      <Style Selector="^:not(:focus) /template/ Border#Border">
+        <Setter Property="Background" Value="{DynamicResource ThemeAccentBrush4}" />
+        <Setter Property="TextElement.Foreground" Value="{DynamicResource ThemeForegroundBrush}" />
+      </Style>
+
+      <!-- Selected PointerOver  -->
+      <Style Selector="^:pointerover /template/ Border#Border">
+        <Setter Property="Background" Value="{DynamicResource ThemeAccentBrush3}" />
+        <Setter Property="TextElement.Foreground" Value="{DynamicResource ThemeForegroundBrush}" />
+      </Style>
+
+      <!-- Selected Pressed  -->
+      <Style Selector="^:pressed /template/ Border#Border">
+        <Setter Property="Background" Value="{DynamicResource ThemeAccentBrush2}" />
+        <Setter Property="TextElement.Foreground" Value="{DynamicResource ThemeForegroundBrush}" />
+      </Style>
+
+    </Style>
+
+  </ControlTheme>
+
+</ResourceDictionary>
diff --git a/tests/Avalonia.Controls.UnitTests/Presenters/TableViewLayoutHelperTests.cs b/tests/Avalonia.Controls.UnitTests/Presenters/TableViewLayoutHelperTests.cs
new file mode 100644
index 0000000000..66146ff80e
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/Presenters/TableViewLayoutHelperTests.cs
@@ -0,0 +1,277 @@
+using Avalonia.Collections;
+using Avalonia.Controls.Presenters;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests.Presenters;
+
+public sealed class TableViewLayoutHelperTests : ScopedTestBase
+{
+    [Fact]
+    public void UpdateActualWidths_With_No_Columns_Returns_False()
+    {
+        var columns = new AvaloniaList<TableViewColumn>();
+
+        Assert.False(TableViewLayoutHelper.UpdateActualWidths(columns, 100, false, 1.0));
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Single_Star_Column_Gets_Full_Width()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+        };
+
+        Assert.True(TableViewLayoutHelper.UpdateActualWidths(columns, 200, false, 1.0));
+        Assert.Equal(200, columns[0].ActualWidth);
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Distributes_Star_Columns_Proportionally()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+            new() { Width = new GridLength(3, GridUnitType.Star) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, 400, false, 1.0);
+
+        Assert.Equal(100, columns[0].ActualWidth);
+        Assert.Equal(300, columns[1].ActualWidth);
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Pixel_Column_Uses_Its_Fixed_Width()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(80) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, 500, false, 1.0);
+
+        Assert.Equal(80, columns[0].ActualWidth);
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Pixel_Plus_Star_Subtracts_Fixed_From_Star_Budget()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(50) },
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, 200, false, 1.0);
+
+        Assert.Equal(50, columns[0].ActualWidth);
+        Assert.Equal(150, columns[1].ActualWidth);
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Star_Clamped_To_Zero_When_Pixel_Exceeds_Available()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(300) },
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, 200, false, 1.0);
+
+        Assert.Equal(300, columns[0].ActualWidth);
+        Assert.Equal(0, columns[1].ActualWidth);
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Treats_Auto_As_One_Star()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = GridLength.Auto },
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, 200, false, 1.0);
+
+        Assert.Equal(100, columns[0].ActualWidth);
+        Assert.Equal(100, columns[1].ActualWidth);
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Falls_Back_To_1000_For_Infinite_Width()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, double.PositiveInfinity, false, 1.0);
+
+        Assert.Equal(500, columns[0].ActualWidth);
+        Assert.Equal(500, columns[1].ActualWidth);
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Returns_False_When_No_Change()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+            new() { Width = new GridLength(50) },
+        };
+
+        Assert.True(TableViewLayoutHelper.UpdateActualWidths(columns, 200, false, 1.0));
+        Assert.False(TableViewLayoutHelper.UpdateActualWidths(columns, 200, false, 1.0));
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Returns_True_When_Width_Changes()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+        };
+
+        Assert.True(TableViewLayoutHelper.UpdateActualWidths(columns, 200, false, 1.0));
+        Assert.True(TableViewLayoutHelper.UpdateActualWidths(columns, 300, false, 1.0));
+        Assert.Equal(300, columns[0].ActualWidth);
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Spreads_Rounding_Across_Star_Columns()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(2, GridUnitType.Star) },
+            new() { Width = new GridLength(3, GridUnitType.Star) },
+            new() { Width = new GridLength(2, GridUnitType.Star) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, 100, useLayoutRounding: true, layoutScale: 1);
+
+        // Weights 2:3:2 over 100 give 28.57 / 42.86 / 28.57. Rounding each column independently
+        // would produce 29 / 43 / 29 = 101; spreading the remainder keeps the total at 100.
+        Assert.Equal(29, columns[0].ActualWidth);
+        Assert.Equal(42, columns[1].ActualWidth);
+        Assert.Equal(29, columns[2].ActualWidth);
+        Assert.Equal(100, columns[0].ActualWidth + columns[1].ActualWidth + columns[2].ActualWidth);
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Spreads_Rounding_With_Intertwined_Fixed_Columns()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(50) },
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+            new() { Width = new GridLength(30) },
+            new() { Width = new GridLength(3, GridUnitType.Star) },
+            new() { Width = new GridLength(2, GridUnitType.Star) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, 201, useLayoutRounding: true, layoutScale: 1);
+
+        // Fixed columns keep their exact size (80 total). The remaining 121px star budget is split
+        // 1:3:2 (20.17 / 60.5 / 40.33). Rounding each independently would drop to 200; spreading the
+        // remainder gives the extra pixel to the 3* column so everything fills exactly 201.
+        Assert.Equal(50, columns[0].ActualWidth);
+        Assert.Equal(20, columns[1].ActualWidth);
+        Assert.Equal(30, columns[2].ActualWidth);
+        Assert.Equal(61, columns[3].ActualWidth);
+        Assert.Equal(40, columns[4].ActualWidth);
+        Assert.Equal(
+            201,
+            columns[0].ActualWidth + columns[1].ActualWidth + columns[2].ActualWidth +
+            columns[3].ActualWidth + columns[4].ActualWidth);
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Spreads_Rounding_At_Fractional_Layout_Scale()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(3, GridUnitType.Star) },
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+            new() { Width = new GridLength(3, GridUnitType.Star) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, 100, useLayoutRounding: true, layoutScale: 2);
+
+        // At 2x scale widths snap to half-pixels (whole device pixels). Weights 3:1:3 give
+        // 42.86 / 14.29 / 42.86; rounding each independently would drift the total to 100.5,
+        // while spreading the remainder keeps it at 100.
+        Assert.Equal(43, columns[0].ActualWidth);
+        Assert.Equal(14, columns[1].ActualWidth);
+        Assert.Equal(43, columns[2].ActualWidth);
+        Assert.Equal(100, columns[0].ActualWidth + columns[1].ActualWidth + columns[2].ActualWidth);
+    }
+
+    [Fact]
+    public void UpdateActualWidths_Rounds_Fixed_Column_Width_And_Star_Absorbs_Remainder()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(50.4) },
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+            new() { Width = new GridLength(2, GridUnitType.Star) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, 200, useLayoutRounding: true, layoutScale: 1);
+
+        // The fixed column rounds to a whole pixel (50); the remaining 150px star budget is split
+        // 1:2 between the star columns.
+        Assert.Equal(50, columns[0].ActualWidth);
+        Assert.Equal(50, columns[1].ActualWidth);
+        Assert.Equal(100, columns[2].ActualWidth);
+    }
+
+    [Fact]
+    public void NeedsActualWidths_Returns_False_For_Empty_Columns()
+    {
+        var columns = new AvaloniaList<TableViewColumn>();
+
+        Assert.False(TableViewLayoutHelper.NeedsActualWidths(columns));
+    }
+
+    [Fact]
+    public void NeedsActualWidths_Returns_True_When_First_Column_Has_NaN_Width()
+    {
+        var columns = new AvaloniaList<TableViewColumn> { new(), new() };
+
+        Assert.True(TableViewLayoutHelper.NeedsActualWidths(columns));
+    }
+
+    [Fact]
+    public void NeedsActualWidths_Returns_False_After_Widths_Are_Computed()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, 200, false, 1.0);
+
+        Assert.False(TableViewLayoutHelper.NeedsActualWidths(columns));
+    }
+
+    [Fact]
+    public void ResetActualWidths_Sets_All_Widths_To_NaN()
+    {
+        var columns = new AvaloniaList<TableViewColumn>
+        {
+            new() { Width = new GridLength(50) },
+            new() { Width = new GridLength(1, GridUnitType.Star) },
+        };
+
+        TableViewLayoutHelper.UpdateActualWidths(columns, 200, false, 1.0);
+        TableViewLayoutHelper.ResetActualWidths(columns);
+
+        Assert.True(double.IsNaN(columns[0].ActualWidth));
+        Assert.True(double.IsNaN(columns[1].ActualWidth));
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/TableViewColumnHeaderTests.cs b/tests/Avalonia.Controls.UnitTests/TableViewColumnHeaderTests.cs
new file mode 100644
index 0000000000..ab2098311c
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/TableViewColumnHeaderTests.cs
@@ -0,0 +1,89 @@
+using System;
+using System.Linq;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.Templates;
+using Avalonia.Input;
+using Avalonia.Styling;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests;
+
+public sealed class TableViewColumnHeaderTests : ScopedTestBase
+{
+    [Fact]
+    public void Dragging_Resizer_Sets_Column_Width_To_Pixel_Value()
+    {
+        using var app = Start();
+
+        var column = new TableViewColumn
+        {
+            Width = new GridLength(1, GridUnitType.Star),
+            CanUserResize = true,
+            ActualWidth = 100
+        };
+        var header = new TableViewColumnHeader
+        {
+            Column = column,
+            Theme = TableViewColumnHeaderTheme(0)
+        };
+        var root = new TestRoot { Child = header };
+        root.LayoutManager.ExecuteInitialLayoutPass();
+
+        var thumb = header.GetVisualDescendants().OfType<Thumb>().Single();
+        thumb.RaiseEvent(new VectorEventArgs
+        {
+            RoutedEvent = Thumb.DragDeltaEvent,
+            Vector = new Vector(15, 0)
+        });
+
+        Assert.Equal(new GridLength(115), column.Width);
+    }
+
+    [Fact]
+    public void Dragging_Resizer_Clamps_Column_Width_To_Resizer_Width()
+    {
+        using var app = Start();
+
+        var column = new TableViewColumn
+        {
+            Width = new GridLength(50),
+            CanUserResize = true,
+            ActualWidth = 50
+        };
+        var header = new TableViewColumnHeader
+        {
+            Column = column,
+            Theme = TableViewColumnHeaderTheme(6)
+        };
+        var root = new TestRoot { Child = header };
+        root.LayoutManager.ExecuteInitialLayoutPass();
+
+        var thumb = header.GetVisualDescendants().OfType<Thumb>().Single();
+        thumb.RaiseEvent(new VectorEventArgs
+        {
+            RoutedEvent = Thumb.DragDeltaEvent,
+            Vector = new Vector(-500, 0)
+        });
+
+        Assert.Equal(new GridLength(6), column.Width);
+    }
+
+    private static IDisposable Start()
+        => UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
+
+    private static ControlTheme TableViewColumnHeaderTheme(int resizerWidth)
+        => new(typeof(TableViewColumnHeader))
+        {
+            Setters =
+            {
+                new Setter(TemplatedControl.TemplateProperty, new FuncControlTemplate<TableViewColumnHeader>((_, scope) =>
+                    new Thumb
+                    {
+                        Name = "PART_Resizer",
+                        Width = resizerWidth
+                    }.RegisterInNameScope(scope)))
+            }
+        };
+}
diff --git a/tests/Avalonia.Controls.UnitTests/TableViewTests.cs b/tests/Avalonia.Controls.UnitTests/TableViewTests.cs
new file mode 100644
index 0000000000..139a11c13d
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/TableViewTests.cs
@@ -0,0 +1,658 @@
+using System;
+using System.Collections;
+using System.Linq;
+using Avalonia.Controls.Presenters;
+using Avalonia.Controls.Primitives;
+using Avalonia.Controls.Templates;
+using Avalonia.Data;
+using Avalonia.Layout;
+using Avalonia.LogicalTree;
+using Avalonia.Styling;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests;
+
+public sealed class TableViewTests : ScopedTestBase
+{
+    [Fact]
+    public void Container_For_Each_Item_Is_TableViewRow()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo", "Bar", "Baz" });
+
+        Prepare(target);
+
+        var containers = target.GetRealizedContainers().ToList();
+        Assert.Equal(3, containers.Count);
+        Assert.All(containers, c => Assert.IsType<TableViewRow>(c));
+    }
+
+    [Fact]
+    public void Row_Has_One_Cell_Per_Column()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        target.Columns.Add(new TableViewColumn());
+        target.Columns.Add(new TableViewColumn());
+        target.Columns.Add(new TableViewColumn());
+
+        Prepare(target);
+
+        var row = (TableViewRow)target.GetRealizedContainers().Single();
+        var cells = GetCellsPresenter(row).Children;
+        Assert.Equal(3, cells.Count);
+        Assert.All(cells, c => Assert.IsType<TableViewCell>(c));
+
+        // Cells must also be part of the row's logical tree.
+        var logicalChildren = row.GetLogicalChildren().ToArray();
+        Assert.Equal(cells, logicalChildren);
+    }
+
+    [Fact]
+    public void Column_TableView_Is_Set_When_Added_And_Unset_When_Removed()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        var column = new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) };
+        target.Columns.Add(column);
+
+        Prepare(target);
+
+        Assert.Same(target, column.TableView);
+
+        target.Columns.Remove(column);
+
+        Assert.Null(column.TableView);
+    }
+
+    [Fact]
+    public void Column_Cannot_Belong_To_Two_TableViews()
+    {
+        using var app = Start();
+
+        var column = new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) };
+
+        var first = CreateTarget(new[] { "Foo" });
+        first.Columns.Add(column);
+        Prepare(first);
+
+        Assert.Same(first, column.TableView);
+
+        var second = CreateTarget(new[] { "Bar" });
+        second.Columns.Add(column);
+
+        Assert.Throws<InvalidOperationException>(() => Prepare(second));
+    }
+
+    [Fact]
+    public void Adding_Column_Adds_Cell_To_Realized_Rows_And_Headers()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+
+        Prepare(target);
+
+        var row = (TableViewRow)target.GetRealizedContainers().Single();
+        var cellsPresenter = GetCellsPresenter(row);
+        Assert.Equal(2, cellsPresenter.Children.Count);
+
+        var headersPresenter = GetColumnHeadersPresenter(target);
+        Assert.Equal(2, headersPresenter.Children.Count);
+
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+
+        Assert.Equal(3, cellsPresenter.Children.Count);
+        Assert.Equal(3, headersPresenter.Children.Count);
+
+        // The newly added cell must also be part of the row's logical tree.
+        var logicalChildren = row.GetLogicalChildren().ToArray();
+        Assert.Equal(cellsPresenter.Children, logicalChildren);
+    }
+
+    [Fact]
+    public void Removing_Column_Removes_Cell_From_Realized_Rows_And_Headers()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+
+        Prepare(target);
+
+        var row = (TableViewRow)target.GetRealizedContainers().Single();
+        var cellsPresenter = GetCellsPresenter(row);
+        Assert.Equal(3, cellsPresenter.Children.Count);
+
+        var headersPresenter = GetColumnHeadersPresenter(target);
+        Assert.Equal(3, headersPresenter.Children.Count);
+
+        var removedCell = (TableViewCell)cellsPresenter.Children[2];
+
+        target.Columns.RemoveAt(2);
+
+        Assert.Equal(2, cellsPresenter.Children.Count);
+        Assert.Equal(2, headersPresenter.Children.Count);
+
+        // The removed cell must also be detached from the row's logical tree, while the remaining cells stay in it.
+        var logicalChildren = row.GetLogicalChildren().ToArray();
+        Assert.DoesNotContain(removedCell, logicalChildren);
+        Assert.Equal(cellsPresenter.Children, logicalChildren);
+    }
+
+    [Fact]
+    public void Changing_Column_Width_Does_Not_Recreate_Cells()
+    {
+        using var app = Start();
+
+        var column = new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) };
+        var target = CreateTarget(new[] { "Foo" });
+        target.Columns.Add(column);
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+
+        Prepare(target, width: 200);
+
+        var presenter = GetCellsPresenter((TableViewRow)target.GetRealizedContainers().Single());
+        var cellsBefore = presenter.Children.ToArray();
+
+        column.Width = new GridLength(2, GridUnitType.Star);
+        Layout(target);
+
+        var cellsAfter = presenter.Children.ToArray();
+        Assert.Equal(cellsBefore, cellsAfter);
+    }
+
+    [Fact]
+    public void Changing_Column_Width_Invalidates_Row_Presenter_Measure()
+    {
+        using var app = Start();
+
+        var column = new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) };
+        var target = CreateTarget(new[] { "Foo" });
+        target.Columns.Add(column);
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+
+        Prepare(target, width: 200);
+
+        var presenter = GetCellsPresenter((TableViewRow)target.GetRealizedContainers().Single());
+        Assert.True(presenter.IsMeasureValid);
+
+        column.Width = new GridLength(2, GridUnitType.Star);
+
+        Assert.False(presenter.IsMeasureValid);
+    }
+
+    [Fact]
+    public void Changing_Column_Width_Updates_ActualWidth_After_Layout()
+    {
+        using var app = Start();
+
+        var column = new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) };
+        var target = CreateTarget(new[] { "Foo" });
+        target.Columns.Add(column);
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+
+        Prepare(target, width: 200);
+
+        Assert.Equal(100, target.Columns[0].ActualWidth);
+        Assert.Equal(100, target.Columns[1].ActualWidth);
+
+        column.Width = new GridLength(3, GridUnitType.Star);
+        Layout(target);
+
+        Assert.Equal(150, target.Columns[0].ActualWidth);
+        Assert.Equal(50, target.Columns[1].ActualWidth);
+    }
+
+    [Fact]
+    public void Replacing_Columns_Collection_Updates_Realized_Rows_And_Headers()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+
+        Prepare(target);
+
+        var row = (TableViewRow)target.GetRealizedContainers().Single();
+        var cellsPresenter = GetCellsPresenter(row);
+        Assert.Equal(2, cellsPresenter.Children.Count);
+
+        var headersPresenter = GetColumnHeadersPresenter(target);
+        Assert.Equal(2, headersPresenter.Children.Count);
+
+        var oldCells = cellsPresenter.Children.ToArray();
+
+        target.Columns =
+        [
+            new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) },
+            new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) },
+            new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) }
+        ];
+
+        Assert.Equal(3, cellsPresenter.Children.Count);
+        Assert.Equal(3, headersPresenter.Children.Count);
+
+        // The new cells must be in the row's logical tree, and the old ones gone.
+        var logicalChildren = row.GetLogicalChildren().ToArray();
+        Assert.Equal(cellsPresenter.Children, logicalChildren);
+        Assert.All(oldCells, cell => Assert.DoesNotContain(cell, logicalChildren));
+    }
+
+    [Fact]
+    public void Cell_Content_Defaults_To_Row_Item_When_No_Template_Or_Binding()
+    {
+        using var app = Start();
+
+        var item = new Person("Alice");
+        var target = CreateTarget(new[] { item });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+
+        Prepare(target);
+
+        var row = (TableViewRow)target.GetRealizedContainers().Single();
+        var firstCell = (TableViewCell)GetCellsPresenter(row).Children[0];
+
+        Assert.Same(item, firstCell.Content);
+    }
+
+    [Fact]
+    public void Cell_Uses_Column_Binding()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { new Person("Alice"), new Person("Bob") });
+        target.Columns.Add(new TableViewColumn
+        {
+            Width = new GridLength(1, GridUnitType.Star),
+            Binding = new ReflectionBinding(nameof(Person.Name))
+        });
+        target.Columns.Add(new TableViewColumn
+        {
+            Width = new GridLength(1, GridUnitType.Star)
+        });
+
+        Prepare(target);
+
+        var rows = target.GetRealizedContainers().Cast<TableViewRow>().ToArray();
+        var firstCell = (TableViewCell)GetCellsPresenter(rows[0]).Children[0];
+        var secondCell = (TableViewCell)GetCellsPresenter(rows[1]).Children[0];
+
+        Assert.Equal("Alice", firstCell.Content);
+        Assert.Equal("Bob", secondCell.Content);
+    }
+
+    [Fact]
+    public void Cell_Uses_Column_CellTemplate()
+    {
+        using var app = Start();
+
+        var template = new FuncDataTemplate<object>((_, _) => new TextBlock());
+        var item = new Person("Alice");
+        var target = CreateTarget(new[] { item });
+        target.Columns.Add(new TableViewColumn
+        {
+            Width = new GridLength(1, GridUnitType.Star),
+            CellTemplate = template
+        });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+
+        Prepare(target);
+
+        var row = (TableViewRow)target.GetRealizedContainers().Single();
+        var firstCell = (TableViewCell)GetCellsPresenter(row).Children[0];
+
+        Assert.Same(template, firstCell.ContentTemplate);
+        Assert.Same(item, firstCell.Content);
+    }
+
+    [Fact]
+    public void Cell_Uses_Column_CellTheme()
+    {
+        using var app = Start();
+
+        var cellTheme = new ControlTheme(typeof(TableViewCell));
+        var target = CreateTarget(new[] { "Foo" });
+        target.Columns.Add(new TableViewColumn
+        {
+            Width = new GridLength(1, GridUnitType.Star),
+            CellTheme = cellTheme
+        });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+
+        Prepare(target);
+
+        var row = (TableViewRow)target.GetRealizedContainers().Single();
+        var firstCell = (TableViewCell)GetCellsPresenter(row).Children[0];
+        var secondCell = (TableViewCell)GetCellsPresenter(row).Children[1];
+
+        Assert.Same(cellTheme, firstCell.Theme);
+        Assert.Null(secondCell.Theme);
+    }
+
+    [Fact]
+    public void Cell_Column_Property_Is_Set_To_Owning_Column()
+    {
+        using var app = Start();
+
+        var column0 = new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) };
+        var column1 = new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) };
+        var target = CreateTarget(new[] { "Foo" });
+        target.Columns.Add(column0);
+        target.Columns.Add(column1);
+
+        Prepare(target);
+
+        var row = (TableViewRow)target.GetRealizedContainers().Single();
+        var firstCell = (TableViewCell)GetCellsPresenter(row).Children[0];
+        var secondCell = (TableViewCell)GetCellsPresenter(row).Children[1];
+
+        Assert.Same(column0, firstCell.Column);
+        Assert.Same(column1, secondCell.Column);
+    }
+
+    [Fact]
+    public void Cell_Uses_Column_HorizontalContentAlignment()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        target.Columns.Add(new TableViewColumn
+        {
+            Width = new GridLength(1, GridUnitType.Star),
+            HorizontalContentAlignment = HorizontalAlignment.Right
+        });
+        target.Columns.Add(new TableViewColumn { Width = new GridLength(1, GridUnitType.Star) });
+
+        Prepare(target);
+
+        var row = (TableViewRow)target.GetRealizedContainers().Single();
+        var firstCell = (TableViewCell)GetCellsPresenter(row).Children[0];
+        var secondCell = (TableViewCell)GetCellsPresenter(row).Children[1];
+
+        Assert.Equal(HorizontalAlignment.Right, firstCell.HorizontalContentAlignment);
+        Assert.Equal(HorizontalAlignment.Left, secondCell.HorizontalContentAlignment);
+    }
+
+    [Fact]
+    public void Changing_Column_Properties_Updates_Existing_Headers_And_Cells()
+    {
+        using var app = Start();
+
+        var cellThemeA = new ControlTheme(typeof(TableViewCell));
+        var cellThemeB = new ControlTheme(typeof(TableViewCell));
+        var headerThemeA = new ControlTheme(typeof(TableViewColumnHeader));
+        var headerThemeB = new ControlTheme(typeof(TableViewColumnHeader));
+        var headerTemplateA = new FuncDataTemplate<object>((_, _) => new TextBlock());
+        var headerTemplateB = new FuncDataTemplate<object>((_, _) => new TextBlock());
+
+        var item = new Person("Alice", "Ally");
+        var column = new TableViewColumn
+        {
+            Width = new GridLength(1, GridUnitType.Star),
+            CellTheme = cellThemeA,
+            HorizontalContentAlignment = HorizontalAlignment.Left,
+            Binding = new ReflectionBinding(nameof(Person.Name)),
+            Header = "H1",
+            HeaderTheme = headerThemeA,
+            HeaderTemplate = headerTemplateA
+        };
+        var target = CreateTarget(new[] { item });
+        target.Columns.Add(column);
+
+        Prepare(target);
+
+        var row = (TableViewRow)target.GetRealizedContainers().Single();
+        var cell = (TableViewCell)GetCellsPresenter(row).Children[0];
+        var header = (TableViewColumnHeader)GetColumnHeadersPresenter(target).Children[0];
+
+        Assert.Same(cellThemeA, cell.Theme);
+        Assert.Equal(HorizontalAlignment.Left, cell.HorizontalContentAlignment);
+        Assert.Null(cell.ContentTemplate);
+        Assert.Equal("Alice", cell.Content);
+
+        Assert.Same(headerThemeA, header.Theme);
+        Assert.Equal(HorizontalAlignment.Left, header.HorizontalContentAlignment);
+        Assert.Same(headerTemplateA, header.ContentTemplate);
+        Assert.Equal("H1", header.Content);
+
+        // Mutating the column after the cell and header were built should update both.
+        // Switch the Binding first to confirm it's reflected in the cell content.
+        column.CellTheme = cellThemeB;
+        column.HorizontalContentAlignment = HorizontalAlignment.Right;
+        column.Binding = new ReflectionBinding(nameof(Person.Nickname));
+        column.Header = "H2";
+        column.HeaderTheme = headerThemeB;
+        column.HeaderTemplate = headerTemplateB;
+
+        Assert.Same(cellThemeB, cell.Theme);
+        Assert.Equal(HorizontalAlignment.Right, cell.HorizontalContentAlignment);
+        Assert.Null(cell.ContentTemplate);
+        Assert.Equal("Ally", cell.Content);
+
+        Assert.Same(headerThemeB, header.Theme);
+        Assert.Equal(HorizontalAlignment.Right, header.HorizontalContentAlignment);
+        Assert.Same(headerTemplateB, header.ContentTemplate);
+        Assert.Equal("H2", header.Content);
+
+        // CellTemplate takes priority over Binding: the row item flows through the template.
+        var cellTemplateB = new FuncDataTemplate<object>((_, _) => new TextBlock());
+        column.CellTemplate = cellTemplateB;
+
+        Assert.Same(cellTemplateB, cell.ContentTemplate);
+        Assert.Same(item, cell.Content);
+    }
+
+    [Fact]
+    public void Re_Templating_Row_Detaches_Old_Cells_And_Rebuilds_New_Cells()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        target.Columns.Add(new TableViewColumn());
+        target.Columns.Add(new TableViewColumn());
+
+        Prepare(target);
+
+        var row = (TableViewRow)target.GetRealizedContainers().Single();
+        var oldCells = GetCellsPresenter(row).Children.ToArray();
+        Assert.Equal(2, oldCells.Length);
+        Assert.Equal(oldCells, row.GetLogicalChildren());
+
+        row.Template = RowTemplate();
+        row.ApplyTemplate();
+
+        var newCells = GetCellsPresenter(row).Children.ToArray();
+        Assert.Equal(2, newCells.Length);
+
+        Assert.All(oldCells, cell => Assert.Null(cell.Parent));
+        Assert.Equal(newCells, row.GetLogicalChildren());
+    }
+
+    [Fact]
+    public void CanUserResizeColumns_Defaults_To_True()
+    {
+        Assert.True(new TableView().CanUserResizeColumns);
+    }
+
+    [Theory]
+    [InlineData(true, null, true)] // inherits the table's value
+    [InlineData(true, true, true)] // column opts in
+    [InlineData(true, false, false)] // column opts out
+    [InlineData(false, null, false)] // inherits the table's value
+    [InlineData(false, true, true)] // column opts in
+    [InlineData(false, false, false)] // column opts out
+    public void Column_CanUserEffectivelyResize_Combines_TableView_And_Column_Settings(
+        bool canResizeColumns,
+        bool? canResize,
+        bool expected)
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        target.CanUserResizeColumns = canResizeColumns;
+        var column = new TableViewColumn { CanUserResize = canResize };
+        target.Columns.Add(column);
+
+        Prepare(target);
+
+        Assert.Equal(expected, column.CanUserEffectivelyResize);
+    }
+
+    [Fact]
+    public void Column_CanUserEffectivelyResize_Updates_When_TableView_CanResizeColumns_Changes()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        var column = new TableViewColumn();
+        target.Columns.Add(column);
+
+        Prepare(target);
+
+        Assert.True(column.CanUserEffectivelyResize);
+
+        target.CanUserResizeColumns = false;
+        Assert.False(column.CanUserEffectivelyResize);
+
+        target.CanUserResizeColumns = true;
+        Assert.True(column.CanUserEffectivelyResize);
+    }
+
+    [Fact]
+    public void Column_CanUserEffectivelyResize_Updates_When_Column_CanResize_Changes()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        target.CanUserResizeColumns = false;
+        var column = new TableViewColumn();
+        target.Columns.Add(column);
+
+        Prepare(target);
+
+        Assert.False(column.CanUserEffectivelyResize);
+
+        column.CanUserResize = true;
+        Assert.True(column.CanUserEffectivelyResize);
+
+        column.CanUserResize = null;
+        Assert.False(column.CanUserEffectivelyResize);
+    }
+
+    private static IDisposable Start()
+        => UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
+
+    private static TableView CreateTarget(IEnumerable items)
+        => new()
+        {
+            Template = TableViewTemplate(),
+            ItemContainerTheme = TableViewRowTheme(),
+            ItemsSource = items
+        };
+
+    private static TableViewCellsPresenter GetCellsPresenter(TableViewRow row)
+    {
+        var presenter = row.GetVisualDescendants()
+            .OfType<TableViewCellsPresenter>()
+            .FirstOrDefault();
+        Assert.NotNull(presenter);
+        return presenter;
+    }
+
+    private static TableViewColumnHeadersPresenter GetColumnHeadersPresenter(TableView target)
+    {
+        var presenter = target.GetVisualDescendants()
+            .OfType<TableViewColumnHeadersPresenter>()
+            .FirstOrDefault();
+        Assert.NotNull(presenter);
+        return presenter;
+    }
+
+    private static void Prepare(TableView target, double width = 300, double height = 200)
+    {
+        target.Width = width;
+        target.Height = height;
+        var root = new TestRoot(target);
+        root.LayoutManager.ExecuteInitialLayoutPass();
+    }
+
+    private static void Layout(Control control)
+        => control.GetLayoutManager()?.ExecuteLayoutPass();
+
+    private static FuncControlTemplate TableViewTemplate()
+        => new FuncControlTemplate<TableView>((parent, scope) =>
+            new DockPanel
+            {
+                Children =
+                {
+                    new TableViewColumnHeadersPresenter
+                    {
+                        [DockPanel.DockProperty] = Dock.Top
+                    },
+                    new ScrollViewer
+                    {
+                        Name = "PART_ScrollViewer",
+                        Template = ScrollViewerTemplate(),
+                        Content = new ItemsPresenter
+                        {
+                            Name = "PART_ItemsPresenter",
+                            [~ItemsPresenter.ItemsPanelProperty] =
+                                parent.GetObservable(ItemsControl.ItemsPanelProperty).ToBinding()
+                        }.RegisterInNameScope(scope)
+                    }.RegisterInNameScope(scope)
+                }
+            });
+
+    private static FuncControlTemplate ScrollViewerTemplate()
+        => new FuncControlTemplate<ScrollViewer>((_, scope) =>
+            new Panel
+            {
+                Children =
+                {
+                    new ScrollContentPresenter
+                    {
+                        Name = "PART_ContentPresenter"
+                    }.RegisterInNameScope(scope)
+                }
+            });
+
+    private static ControlTheme TableViewRowTheme()
+        => new(typeof(TableViewRow))
+        {
+            Setters =
+            {
+                new Setter(TemplatedControl.TemplateProperty, RowTemplate())
+            }
+        };
+
+    private static FuncControlTemplate<TableViewRow> RowTemplate()
+        => new((_, scope) =>
+            new TableViewCellsPresenter
+            {
+                Name = "PART_CellsPresenter"
+            }.RegisterInNameScope(scope));
+
+    private class Person
+    {
+        public Person(string name, string? nickname = null)
+        {
+            Name = name;
+            Nickname = nickname;
+        }
+
+        public string Name { get; }
+        public string? Nickname { get; }
+    }
+}

From 6ef2d0b708cb3dcccb0fff52246106cf0b30b4d8 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Tue, 7 Jul 2026 12:18:20 +0200
Subject: [PATCH 075/196] Implement Bitmap.Save with a format (#21455)

* Implement Bitmap.Save with format options

* Rename BitmapEncoderOptions.cs to match its type

* Update API suppressions
---
 api/Avalonia.nupkg.xml                        |  36 ++++++
 samples/GpuInterop/VulkanDemo/VulkanImage.cs  |   3 +-
 .../Avalonia.Android/PlatformIconLoader.cs    |   3 +-
 src/Android/Avalonia.Android/Stubs.cs         |   3 +-
 src/Avalonia.Base/Media/Imaging/Bitmap.cs     |  33 ++++-
 .../Media/Imaging/BitmapEncoderOptions.cs     |  14 ++
 src/Avalonia.Base/Media/Imaging/IBitmap.cs    |  22 +---
 .../Media/Imaging/JpegBitmapEncoderOptions.cs |  18 +++
 .../Media/Imaging/PngBitmapEncoderOptions.cs  |  20 +++
 src/Avalonia.Base/Platform/IBitmapImpl.cs     |  23 +---
 src/Avalonia.Native/Cursor.cs                 |   2 +-
 ...ansferItemToAvnClipboardDataItemWrapper.cs |   3 +-
 src/Avalonia.Native/IAvnMenuItem.cs           |   2 +-
 src/Avalonia.Native/IconLoader.cs             |   5 +-
 .../Clipboard/WaylandClipboardImpl.cs         |   2 +-
 .../Selections/SelectionDataProvider.cs       |   3 +-
 src/Avalonia.X11/X11IconLoader.cs             |   4 +-
 src/Browser/Avalonia.Browser/ClipboardImpl.cs |   3 +-
 src/Browser/Avalonia.Browser/Cursor.cs        |   3 +-
 .../HeadlessPlatformRenderInterface.cs        |   9 +-
 .../Helpers/ImageSavingHelper.cs              | 121 +++++++++++++-----
 src/Skia/Avalonia.Skia/ImmutableBitmap.cs     |  11 +-
 src/Skia/Avalonia.Skia/SurfaceRenderTarget.cs |  20 +--
 src/Skia/Avalonia.Skia/WriteableBitmapImpl.cs |  19 +--
 .../Avalonia.Win32/OleDataObjectHelper.cs     |   2 +-
 src/Windows/Avalonia.Win32/Win32Platform.cs   |   8 +-
 .../Avalonia.iOS/Clipboard/ClipboardImpl.cs   |   3 +-
 src/iOS/Avalonia.iOS/Stubs.cs                 |  10 +-
 .../Avalonia.RenderTests/Media/BitmapTests.cs |   6 +-
 .../Avalonia.RenderTests/TestRenderHelper.cs  |   5 +-
 .../Media/BitmapSaveTests.cs                  | 108 ++++++++++++++++
 31 files changed, 376 insertions(+), 148 deletions(-)
 create mode 100644 src/Avalonia.Base/Media/Imaging/BitmapEncoderOptions.cs
 create mode 100644 src/Avalonia.Base/Media/Imaging/JpegBitmapEncoderOptions.cs
 create mode 100644 src/Avalonia.Base/Media/Imaging/PngBitmapEncoderOptions.cs
 create mode 100644 tests/Avalonia.Skia.UnitTests/Media/BitmapSaveTests.cs

diff --git a/api/Avalonia.nupkg.xml b/api/Avalonia.nupkg.xml
index 1751d863e6..ce13834a0b 100644
--- a/api/Avalonia.nupkg.xml
+++ b/api/Avalonia.nupkg.xml
@@ -19,6 +19,18 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.IBitmapImpl.Save(System.IO.Stream,System.Nullable{System.Int32})</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.IBitmapImpl.Save(System.String,System.Nullable{System.Int32})</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:Avalonia.Platform.IRenderTarget.RenderTargetSceneInfo.#ctor(Avalonia.PixelSize,System.Double,Avalonia.Size)</Target>
@@ -79,6 +91,18 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.IBitmapImpl.Save(System.IO.Stream,System.Nullable{System.Int32})</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Avalonia.Platform.IBitmapImpl.Save(System.String,System.Nullable{System.Int32})</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0002</DiagnosticId>
     <Target>M:Avalonia.Platform.IRenderTarget.RenderTargetSceneInfo.#ctor(Avalonia.PixelSize,System.Double,Avalonia.Size)</Target>
@@ -121,6 +145,12 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.IBitmapImpl.Save(System.IO.Stream,Avalonia.Media.Imaging.BitmapEncoderOptions)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Platform.Storage.IStorageProvider.OpenFilePickerWithResultAsync(Avalonia.Platform.Storage.FilePickerOpenOptions)</Target>
@@ -139,6 +169,12 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Controls.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Controls.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.IBitmapImpl.Save(System.IO.Stream,Avalonia.Media.Imaging.BitmapEncoderOptions)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Platform.Storage.IStorageProvider.OpenFilePickerWithResultAsync(Avalonia.Platform.Storage.FilePickerOpenOptions)</Target>
diff --git a/samples/GpuInterop/VulkanDemo/VulkanImage.cs b/samples/GpuInterop/VulkanDemo/VulkanImage.cs
index 216cb3f815..15d2952cfe 100644
--- a/samples/GpuInterop/VulkanDemo/VulkanImage.cs
+++ b/samples/GpuInterop/VulkanDemo/VulkanImage.cs
@@ -4,6 +4,7 @@ using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
 using Avalonia;
+using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 using Avalonia.Vulkan;
 using Silk.NET.Core.Native;
@@ -355,7 +356,7 @@ public unsafe class VulkanImage : IDisposable
                     using var b = new Avalonia.Media.Imaging.Bitmap(PixelFormat.Bgra8888,
                         AlphaFormat.Premul, pSurface, new PixelSize(w, h),
                         new Vector(96, 96), (int)sstride);
-                    b.Save(path);
+                    b.Save(path, PngBitmapEncoderOptions.Default);
 
                     NativeMethods.IOSurfaceUnlock(surf, 0, IntPtr.Zero);
                     return;
diff --git a/src/Android/Avalonia.Android/PlatformIconLoader.cs b/src/Android/Avalonia.Android/PlatformIconLoader.cs
index f557685dd2..5b5705753e 100644
--- a/src/Android/Avalonia.Android/PlatformIconLoader.cs
+++ b/src/Android/Avalonia.Android/PlatformIconLoader.cs
@@ -1,4 +1,5 @@
 using System.IO;
+using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 
 namespace Avalonia.Android
@@ -9,7 +10,7 @@ namespace Avalonia.Android
         {
             using (var stream = new MemoryStream())
             {
-                bitmap.Save(stream);
+                bitmap.Save(stream, PngBitmapEncoderOptions.Default);
                 return LoadIcon(stream);
             }
         }
diff --git a/src/Android/Avalonia.Android/Stubs.cs b/src/Android/Avalonia.Android/Stubs.cs
index 0620919e4d..57de1b1b10 100644
--- a/src/Android/Avalonia.Android/Stubs.cs
+++ b/src/Android/Avalonia.Android/Stubs.cs
@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 
 namespace Avalonia.Android
@@ -22,7 +23,7 @@ namespace Avalonia.Android
         {
             using (var stream = new MemoryStream())
             {
-                bitmap.Save(stream);
+                bitmap.Save(stream, PngBitmapEncoderOptions.Default);
                 return LoadIcon(stream);
             }
         }
diff --git a/src/Avalonia.Base/Media/Imaging/Bitmap.cs b/src/Avalonia.Base/Media/Imaging/Bitmap.cs
index 87ef0a234f..e04603914c 100644
--- a/src/Avalonia.Base/Media/Imaging/Bitmap.cs
+++ b/src/Avalonia.Base/Media/Imaging/Bitmap.cs
@@ -147,7 +147,7 @@ namespace Avalonia.Media.Imaging
         IRef<IBitmapImpl> IBitmap.PlatformImpl => PlatformImpl;
 
         /// <summary>
-        /// Saves the bitmap to a file.
+        /// Saves the bitmap to a file, in PNG format.
         /// </summary>
         /// <param name="fileName">The filename.</param>
         /// <param name="quality">
@@ -155,23 +155,44 @@ namespace Avalonia.Media.Imaging
         /// The quality value is interpreted from 0 - 100. If quality is null the default quality 
         /// setting is applied.
         /// </param>
+        [Obsolete($"Use the overload accepting {nameof(BitmapEncoderOptions)} instead.")]
         public void Save(string fileName, int? quality = null)
+            => Save(fileName, PngBitmapEncoderOptions.Default);
+
+        /// <summary>
+        /// Saves the bitmap to a file with the specified options.
+        /// </summary>
+        /// <param name="fileName">The filename.</param>
+        /// <param name="options">
+        /// The options specifying the format and settings to use.
+        /// Typical usages include <see cref="PngBitmapEncoderOptions"/> and <see cref="JpegBitmapEncoderOptions"/>.
+        /// </param>
+        public void Save(string fileName, BitmapEncoderOptions options)
         {
-            PlatformImpl.Item.Save(fileName, quality);
+            using var stream = File.Create(fileName);
+
+            Save(stream, options);
         }
 
         /// <summary>
-        /// Saves the bitmap to a stream.
+        /// Saves the bitmap to a stream, in PNG format.
         /// </summary>
         /// <param name="stream">The stream.</param>
         /// <param name="quality">
-        /// The optional quality for compression. 
-        /// The quality value is interpreted from 0 - 100. If quality is null the default quality 
+        /// The optional quality for compression.
+        /// The quality value is interpreted from 0 - 100. If quality is null the default quality
         /// setting is applied.
         /// </param>
+        [Obsolete($"Use the overload accepting {nameof(BitmapEncoderOptions)} instead.")]
         public void Save(Stream stream, int? quality = null)
         {
-            PlatformImpl.Item.Save(stream, quality);
+            PlatformImpl.Item.Save(stream, PngBitmapEncoderOptions.Default);
+        }
+
+        /// <inheritdoc />
+        public void Save(Stream stream, BitmapEncoderOptions options)
+        {
+            PlatformImpl.Item.Save(stream, options);
         }
 
         public virtual PixelFormat? Format => (PlatformImpl.Item as IReadableBitmapImpl)?.Format;
diff --git a/src/Avalonia.Base/Media/Imaging/BitmapEncoderOptions.cs b/src/Avalonia.Base/Media/Imaging/BitmapEncoderOptions.cs
new file mode 100644
index 0000000000..e75e2ab65c
--- /dev/null
+++ b/src/Avalonia.Base/Media/Imaging/BitmapEncoderOptions.cs
@@ -0,0 +1,14 @@
+using System.IO;
+
+namespace Avalonia.Media.Imaging;
+
+/// <summary>
+/// Represents the options used while saving a bitmap using <see cref="Bitmap.Save(Stream, BitmapEncoderOptions)"/>.
+/// Common implementations are <see cref="PngBitmapEncoderOptions"/>, <see cref="JpegBitmapEncoderOptions"/>.
+/// </summary>
+public abstract class BitmapEncoderOptions
+{
+    internal BitmapEncoderOptions()
+    {
+    }
+}
diff --git a/src/Avalonia.Base/Media/Imaging/IBitmap.cs b/src/Avalonia.Base/Media/Imaging/IBitmap.cs
index f2cbc7a11e..e2e1611383 100644
--- a/src/Avalonia.Base/Media/Imaging/IBitmap.cs
+++ b/src/Avalonia.Base/Media/Imaging/IBitmap.cs
@@ -32,25 +32,13 @@ namespace Avalonia.Media.Imaging
         IRef<IBitmapImpl> PlatformImpl { get; }
 
         /// <summary>
-        /// Saves the bitmap to a file.
-        /// </summary>
-        /// <param name="fileName">The filename.</param>
-        /// <param name="quality">
-        /// The optional quality for compression if supported by the specific backend. 
-        /// The quality value is interpreted from 0 - 100. If quality is null the default quality 
-        /// setting of the backend is applied.
-        /// </param>
-        void Save(string fileName, int? quality = null);
-
-        /// <summary>
-        /// Saves the bitmap to a stream in png format.
+        /// Saves the bitmap to a stream with the specified options.
         /// </summary>
         /// <param name="stream">The stream.</param>
-        /// <param name="quality">
-        /// The optional quality for compression if supported by the specific backend. 
-        /// The quality value is interpreted from 0 - 100. If quality is null the default quality 
-        /// setting of the backend is applied.
+        /// <param name="options">
+        /// The options specifying the format and settings to use.
+        /// Typical usages include <see cref="PngBitmapEncoderOptions"/> and <see cref="JpegBitmapEncoderOptions"/>.
         /// </param>
-        void Save(Stream stream, int? quality = null);
+        void Save(Stream stream, BitmapEncoderOptions options);
     }
 }
diff --git a/src/Avalonia.Base/Media/Imaging/JpegBitmapEncoderOptions.cs b/src/Avalonia.Base/Media/Imaging/JpegBitmapEncoderOptions.cs
new file mode 100644
index 0000000000..9745c60f92
--- /dev/null
+++ b/src/Avalonia.Base/Media/Imaging/JpegBitmapEncoderOptions.cs
@@ -0,0 +1,18 @@
+namespace Avalonia.Media.Imaging;
+
+/// <summary>
+/// Represents the options used to save a bitmap in the JPEG format.
+/// </summary>
+public sealed class JpegBitmapEncoderOptions : BitmapEncoderOptions
+{
+    /// <summary>
+    /// Gets the default JPEG encoder options.
+    /// </summary>
+    public static JpegBitmapEncoderOptions Default { get; } = new();
+    
+    /// <summary>
+    /// Gets or sets the quality to use, from 0 (lowest) to 100 (highest).
+    /// Defaults to 100.
+    /// </summary>
+    public int Quality { get; init; } = 100;
+}
diff --git a/src/Avalonia.Base/Media/Imaging/PngBitmapEncoderOptions.cs b/src/Avalonia.Base/Media/Imaging/PngBitmapEncoderOptions.cs
new file mode 100644
index 0000000000..0931ec9b8c
--- /dev/null
+++ b/src/Avalonia.Base/Media/Imaging/PngBitmapEncoderOptions.cs
@@ -0,0 +1,20 @@
+using System.IO.Compression;
+
+namespace Avalonia.Media.Imaging;
+
+/// <summary>
+/// Represents the options used to save a bitmap in the PNG format.
+/// </summary>
+public sealed class PngBitmapEncoderOptions : BitmapEncoderOptions
+{
+    /// <summary>
+    /// Gets the default PNG encoder options.
+    /// </summary>
+    public static PngBitmapEncoderOptions Default { get; } = new();
+    
+    /// <summary>
+    /// Gets or sets the compression level to use.
+    /// Defaults to <see cref="System.IO.Compression.CompressionLevel.Optimal"/>.
+    /// </summary>
+    public CompressionLevel CompressionLevel { get; init; } = CompressionLevel.Optimal;
+}
diff --git a/src/Avalonia.Base/Platform/IBitmapImpl.cs b/src/Avalonia.Base/Platform/IBitmapImpl.cs
index 586ac76a3a..bec184e6aa 100644
--- a/src/Avalonia.Base/Platform/IBitmapImpl.cs
+++ b/src/Avalonia.Base/Platform/IBitmapImpl.cs
@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using Avalonia.Media.Imaging;
 using Avalonia.Metadata;
 
 namespace Avalonia.Platform
@@ -26,25 +27,13 @@ namespace Avalonia.Platform
         int Version { get; }
 
         /// <summary>
-        /// Saves the bitmap to a file.
-        /// </summary>
-        /// <param name="fileName">The filename.</param>
-        /// <param name="quality">
-        /// The optional quality for compression if supported by the specific backend. 
-        /// The quality value is interpreted from 0 - 100. If quality is null the default quality 
-        /// setting of the backend is applied.
-        /// </param>
-        void Save(string fileName, int? quality = null);
-
-        /// <summary>
-        /// Saves the bitmap to a stream in png format.
+        /// Saves the bitmap to a stream with the specified options.
         /// </summary>
         /// <param name="stream">The stream.</param>
-        /// <param name="quality">
-        /// The optional quality for compression if supported by the specific backend. 
-        /// The quality value is interpreted from 0 - 100. If quality is null the default quality 
-        /// setting of the backend is applied.
+        /// <param name="options">
+        /// The options specifying the format and settings to use.
+        /// Typical usages include <see cref="PngBitmapEncoderOptions"/> and <see cref="JpegBitmapEncoderOptions"/>.
         /// </param>
-        void Save(Stream stream, int? quality = null);
+        void Save(Stream stream, BitmapEncoderOptions options);
     }
 }
diff --git a/src/Avalonia.Native/Cursor.cs b/src/Avalonia.Native/Cursor.cs
index 58306b5698..37bb18feb6 100644
--- a/src/Avalonia.Native/Cursor.cs
+++ b/src/Avalonia.Native/Cursor.cs
@@ -45,7 +45,7 @@ namespace Avalonia.Native
         {
             using(var ms = new MemoryStream())
             {
-                cursor.Save(ms);
+                cursor.Save(ms, PngBitmapEncoderOptions.Default);
 
                 var imageData = ms.ToArray();
 
diff --git a/src/Avalonia.Native/DataTransferItemToAvnClipboardDataItemWrapper.cs b/src/Avalonia.Native/DataTransferItemToAvnClipboardDataItemWrapper.cs
index 4b659a3cc4..ccaae66379 100644
--- a/src/Avalonia.Native/DataTransferItemToAvnClipboardDataItemWrapper.cs
+++ b/src/Avalonia.Native/DataTransferItemToAvnClipboardDataItemWrapper.cs
@@ -3,6 +3,7 @@ using System.IO;
 using System.Linq;
 using Avalonia.Input;
 using Avalonia.Logging;
+using Avalonia.Media.Imaging;
 using Avalonia.Native.Interop;
 
 namespace Avalonia.Native;
@@ -35,7 +36,7 @@ internal sealed class DataTransferItemToAvnClipboardDataItemWrapper(IDataTransfe
                 if (_item.TryGetValue(DataFormat.Bitmap) is { } bitmap)
                 {
                     var memoryStream = new MemoryStream();
-                    bitmap.Save(memoryStream);
+                    bitmap.Save(memoryStream, PngBitmapEncoderOptions.Default);
                     memoryStream.Seek(0, SeekOrigin.Begin);
                     return new StreamValue(memoryStream);
                 }
diff --git a/src/Avalonia.Native/IAvnMenuItem.cs b/src/Avalonia.Native/IAvnMenuItem.cs
index 441b974df2..65b8563055 100644
--- a/src/Avalonia.Native/IAvnMenuItem.cs
+++ b/src/Avalonia.Native/IAvnMenuItem.cs
@@ -56,7 +56,7 @@ namespace Avalonia.Native.Interop.Impl
             {
                 using(var ms = new MemoryStream())
                 {
-                    icon.Save(ms);
+                    icon.Save(ms, PngBitmapEncoderOptions.Default);
 
                     var imageData = ms.ToArray();
 
diff --git a/src/Avalonia.Native/IconLoader.cs b/src/Avalonia.Native/IconLoader.cs
index dbc6379bd8..104ec2078c 100644
--- a/src/Avalonia.Native/IconLoader.cs
+++ b/src/Avalonia.Native/IconLoader.cs
@@ -1,4 +1,5 @@
 using System.IO;
+using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 
 namespace Avalonia.Native
@@ -20,7 +21,7 @@ namespace Avalonia.Native
 
             public void Save(Stream outputStream)
             {
-                _bitmap.Save(outputStream);
+                _bitmap.Save(outputStream, PngBitmapEncoderOptions.Default);
             }
         }
 
@@ -39,7 +40,7 @@ namespace Avalonia.Native
         public IWindowIconImpl LoadIcon(IBitmapImpl bitmap)
         {
             var ms = new MemoryStream();
-            bitmap.Save(ms);
+            bitmap.Save(ms, PngBitmapEncoderOptions.Default);
             ms.Seek(0, SeekOrigin.Begin);
             return LoadIcon(ms);
         }
diff --git a/src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs b/src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs
index 5c82470ee6..70a7c6d315 100644
--- a/src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs
+++ b/src/Avalonia.Wayland/Clipboard/WaylandClipboardImpl.cs
@@ -109,7 +109,7 @@ class WaylandClipboardImpl : IOwnedClipboardImpl
                     await Task.Run(() =>
                     {
                         using (bitmapRef)
-                            bitmapRef.Item.Save(stream);
+                            bitmapRef.Item.Save(stream, PngBitmapEncoderOptions.Default);
                     }).ConfigureAwait(false);
                     return;
                 }
diff --git a/src/Avalonia.X11/Selections/SelectionDataProvider.cs b/src/Avalonia.X11/Selections/SelectionDataProvider.cs
index c1a7be87fb..846a25bb6e 100644
--- a/src/Avalonia.X11/Selections/SelectionDataProvider.cs
+++ b/src/Avalonia.X11/Selections/SelectionDataProvider.cs
@@ -5,6 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using Avalonia.Input;
 using Avalonia.Logging;
+using Avalonia.Media.Imaging;
 using Avalonia.X11.Selections.Clipboard;
 using static Avalonia.X11.XLib;
 
@@ -154,7 +155,7 @@ internal abstract class SelectionDataProvider : IDisposable
                 return null;
 
             using var stream = new MemoryStream();
-            bitmap.Save(stream);
+            bitmap.Save(stream, PngBitmapEncoderOptions.Default);
 
             return stream.ToArray();
         }
diff --git a/src/Avalonia.X11/X11IconLoader.cs b/src/Avalonia.X11/X11IconLoader.cs
index ab0946f531..caa5662e00 100644
--- a/src/Avalonia.X11/X11IconLoader.cs
+++ b/src/Avalonia.X11/X11IconLoader.cs
@@ -22,7 +22,7 @@ namespace Avalonia.X11
         public IWindowIconImpl LoadIcon(IBitmapImpl bitmap)
         {
             var ms = new MemoryStream();
-            bitmap.Save(ms);
+            bitmap.Save(ms, PngBitmapEncoderOptions.Default);
             ms.Position = 0;
             return LoadIcon(ms);
         }
@@ -81,7 +81,7 @@ namespace Avalonia.X11
                             fbp[fbr + x] = Data[r + x + 2].ToUInt32();
                     }
                 }
-                wr.Save(outputStream);
+                wr.Save(outputStream, PngBitmapEncoderOptions.Default);
             }
         }
     }
diff --git a/src/Browser/Avalonia.Browser/ClipboardImpl.cs b/src/Browser/Avalonia.Browser/ClipboardImpl.cs
index 50cec8721c..1c39f62742 100644
--- a/src/Browser/Avalonia.Browser/ClipboardImpl.cs
+++ b/src/Browser/Avalonia.Browser/ClipboardImpl.cs
@@ -6,6 +6,7 @@ using Avalonia.Browser.Interop;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Logging;
+using Avalonia.Media.Imaging;
 using static Avalonia.Browser.BrowserDataFormatHelper;
 using static Avalonia.Browser.Interop.InputHelper;
 
@@ -78,7 +79,7 @@ internal sealed class ClipboardImpl : IClipboardImpl
                     if (bitmap != null)
                     {
                         using var stream = new MemoryStream();
-                        bitmap.Save(stream);
+                        bitmap.Save(stream, PngBitmapEncoderOptions.Default);
 
                         writeableItem ??= CreateWriteableClipboardItem(source);
                         AddBytesToWriteableClipboardItem(writeableItem, formatString, stream.ToArray());
diff --git a/src/Browser/Avalonia.Browser/Cursor.cs b/src/Browser/Avalonia.Browser/Cursor.cs
index bf782f2126..39db876376 100644
--- a/src/Browser/Avalonia.Browser/Cursor.cs
+++ b/src/Browser/Avalonia.Browser/Cursor.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using Avalonia.Input;
+using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 
 namespace Avalonia.Browser
@@ -79,7 +80,7 @@ namespace Avalonia.Browser
         public ICursorImpl CreateCursor(Avalonia.Media.Imaging.Bitmap cursor, PixelPoint hotSpot)
         {
             using var imageStream = new MemoryStream();
-            cursor.Save(imageStream);
+            cursor.Save(imageStream, PngBitmapEncoderOptions.Default);
 
             //not memory optimized because CryptoStream with ToBase64Transform is not supported in the browser.
             var base64String = Convert.ToBase64String(imageStream.ToArray());
diff --git a/src/Headless/Avalonia.Headless/HeadlessPlatformRenderInterface.cs b/src/Headless/Avalonia.Headless/HeadlessPlatformRenderInterface.cs
index 1c152d0fe4..0d8114f7f5 100644
--- a/src/Headless/Avalonia.Headless/HeadlessPlatformRenderInterface.cs
+++ b/src/Headless/Avalonia.Headless/HeadlessPlatformRenderInterface.cs
@@ -428,17 +428,10 @@ namespace Avalonia.Headless
             public AlphaFormat? AlphaFormat => Platform.AlphaFormat.Premul;
             public int Version { get; set; }
 
-            public void Save(string fileName, int? quality = null)
+            public void Save(Stream stream, BitmapEncoderOptions options)
             {
-
-            }
-
-            public void Save(Stream stream, int? quality = null)
-            {
-
             }
 
-
             public ILockedFramebuffer Lock()
             {
                 Version++;
diff --git a/src/Skia/Avalonia.Skia/Helpers/ImageSavingHelper.cs b/src/Skia/Avalonia.Skia/Helpers/ImageSavingHelper.cs
index 6adfc01951..89c40186d0 100644
--- a/src/Skia/Avalonia.Skia/Helpers/ImageSavingHelper.cs
+++ b/src/Skia/Avalonia.Skia/Helpers/ImageSavingHelper.cs
@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using System.IO.Compression;
+using Avalonia.Media.Imaging;
 using SkiaSharp;
 
 namespace Avalonia.Skia.Helpers
@@ -10,57 +12,116 @@ namespace Avalonia.Skia.Helpers
     public static class ImageSavingHelper
     {
         /// <summary>
-        /// Save Skia image to a file.
+        /// Saves a Skia image to a file in the PNG format.
         /// </summary>
-        /// <param name="image">Image to save</param>
-        /// <param name="fileName">Target file.</param>
+        /// <param name="image">The image to save</param>
+        /// <param name="fileName">The output file to save the image to.</param>
         /// <param name="quality">
-        /// The optional quality for PNG compression. 
-        /// The quality value is interpreted from 0 - 100. If quality is null 
-        /// the encoder applies the default quality value.
+        /// The optional quality for compression.
+        /// The quality value is interpreted from 0 to 100. When null, 100 is used.
         /// </param>
+        [Obsolete($"Use the overload accepting {nameof(BitmapEncoderOptions)} instead.")]
         public static void SaveImage(SKImage image, string fileName, int? quality = null)
         {
-            if (image == null) throw new ArgumentNullException(nameof(image));
-            if (fileName == null) throw new ArgumentNullException(nameof(fileName));
+            SaveImage(image, fileName, PngBitmapEncoderOptions.Default);
+        }
 
-            using (var stream = File.Create(fileName))
-            {
-                SaveImage(image, stream, quality);
-            }
+        /// <summary>
+        /// Saves a Skia image to a file in the specified format.
+        /// </summary>
+        /// <param name="image">The image to save</param>
+        /// <param name="fileName">The output file to save the image to.</param>
+        /// <param name="options">
+        /// The options specifying the format and settings to use.
+        /// Typical usages include <see cref="PngBitmapEncoderOptions"/> and <see cref="JpegBitmapEncoderOptions"/>.
+        /// </param>
+        public static void SaveImage(SKImage image, string fileName, BitmapEncoderOptions options)
+        {
+            ArgumentNullException.ThrowIfNull(image);
+            ArgumentNullException.ThrowIfNull(fileName);
+
+            using var stream = File.Create(fileName);
+
+            SaveImage(image, stream, options);
         }
 
         /// <summary>
-        /// Save Skia image to a stream.
+        /// Saves a Skia image to a stream in the PNG format.
         /// </summary>
-        /// <param name="image">Image to save</param>
-        /// <param name="stream">The output stream to save the image.</param>
+        /// <param name="image">The image to save</param>
+        /// <param name="stream">The output stream to save the image to.</param>
         /// <param name="quality">
-        /// The optional quality for PNG compression. 
-        /// The quality value is interpreted from 0 - 100. If quality is null 
-        /// the encoder applies the default quality value.
+        /// The optional quality for compression.
+        /// The quality value is interpreted from 0 to 100. When null, 100 is used.
         /// </param>
+        [Obsolete($"Use the overload accepting {nameof(BitmapEncoderOptions)} instead.")]
         public static void SaveImage(SKImage image, Stream stream, int? quality = null)
         {
-            if (image == null) throw new ArgumentNullException(nameof(image));
-            if (stream == null) throw new ArgumentNullException(nameof(stream));
+            SaveImage(image, stream, PngBitmapEncoderOptions.Default);
+        }
 
-            if (quality == null)
+        /// <summary>
+        /// Saves a Skia image to a stream in the specified format.
+        /// </summary>
+        /// <param name="image">The image to save</param>
+        /// <param name="stream">The output stream to save the image to.</param>
+        /// <param name="options">
+        /// The options specifying the format and settings to use.
+        /// Typical usages include <see cref="PngBitmapEncoderOptions"/> and <see cref="JpegBitmapEncoderOptions"/>.
+        /// </param>
+        public static void SaveImage(SKImage image, Stream stream, BitmapEncoderOptions options)
+        {
+            ArgumentNullException.ThrowIfNull(image);
+            ArgumentNullException.ThrowIfNull(stream);
+            ArgumentNullException.ThrowIfNull(options);
+            
+            var raster = image.ToRasterImage(true);
+            
+            try
             {
-                using (var data = image.Encode())
+                using var pixmap = raster.PeekPixels() ?? throw new InvalidOperationException("Could not get image pixels");
+
+                using var data = options switch
                 {
-                    data.SaveTo(stream);
-                }
+                    PngBitmapEncoderOptions pngOptions => pixmap.Encode(ToSkia(pngOptions)),
+                    JpegBitmapEncoderOptions jpegOptions => pixmap.Encode(ToSkia(jpegOptions)),
+                    _ => throw new ArgumentOutOfRangeException(nameof(options), options, "Unknown encoder options type")
+                };
+
+                if (data is null)
+                    throw new InvalidOperationException("Could not encode image");
+                
+                data.SaveTo(stream);    
             }
-            else
+            finally
             {
-                using (var data = image.Encode(SKEncodedImageFormat.Png, (int)quality))
-                {
-                    data.SaveTo(stream);
-                }
+                if (image != raster)
+                    raster.Dispose();
             }
         }
 
+        private static SKPngEncoderOptions ToSkia(PngBitmapEncoderOptions options)
+        {
+            var zLibLevel = options.CompressionLevel switch
+            {
+                CompressionLevel.Optimal => 6,
+                CompressionLevel.Fastest => 1,
+                CompressionLevel.NoCompression => 0,
+                CompressionLevel.SmallestSize => 9,
+                _ => throw new ArgumentOutOfRangeException(nameof(options), "Unknown compression level")
+            };
+
+            return new SKPngEncoderOptions(SKPngEncoderFilterFlags.AllFilters, zLibLevel);
+        }
+
+        private static SKJpegEncoderOptions ToSkia(JpegBitmapEncoderOptions options)
+        {
+            if (options.Quality is < 0 or > 100)
+                throw new ArgumentOutOfRangeException(nameof(options), "Unknown quality");
+            
+            return new SKJpegEncoderOptions(options.Quality);
+        }
+
         // This method is here mostly for debugging purposes
         internal static void SavePicture(SKPicture picture, float scale, string path)
         {
@@ -68,7 +129,7 @@ namespace Avalonia.Skia.Helpers
                 (int)Math.Ceiling(picture.CullRect.Height * scale));
             using var snap =
                 SKImage.FromPicture(picture, snapshotSize, SKMatrix.CreateScale(scale, scale));
-            SaveImage(snap, path);
+            SaveImage(snap, path, PngBitmapEncoderOptions.Default);
         }
     }
 }
diff --git a/src/Skia/Avalonia.Skia/ImmutableBitmap.cs b/src/Skia/Avalonia.Skia/ImmutableBitmap.cs
index c168394768..e2994f7b64 100644
--- a/src/Skia/Avalonia.Skia/ImmutableBitmap.cs
+++ b/src/Skia/Avalonia.Skia/ImmutableBitmap.cs
@@ -173,16 +173,9 @@ namespace Avalonia.Skia
             _bitmap?.Dispose();
         }
 
-        /// <inheritdoc />
-        public void Save(string fileName, int? quality = null)
-        {
-            ImageSavingHelper.SaveImage(_image, fileName, quality);
-        }
-
-        /// <inheritdoc />
-        public void Save(Stream stream, int? quality = null)
+        public void Save(Stream stream, BitmapEncoderOptions options)
         {
-            ImageSavingHelper.SaveImage(_image, stream, quality);
+            ImageSavingHelper.SaveImage(_image, stream, options);
         }
 
         /// <inheritdoc />
diff --git a/src/Skia/Avalonia.Skia/SurfaceRenderTarget.cs b/src/Skia/Avalonia.Skia/SurfaceRenderTarget.cs
index 3e54394541..889abb9d8d 100644
--- a/src/Skia/Avalonia.Skia/SurfaceRenderTarget.cs
+++ b/src/Skia/Avalonia.Skia/SurfaceRenderTarget.cs
@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using Avalonia.Media.Imaging;
 using Avalonia.Reactive;
 using Avalonia.Platform;
 using Avalonia.Skia.Helpers;
@@ -126,23 +127,12 @@ namespace Avalonia.Skia
         public PixelSize PixelSize { get; }
 
         public int Version { get; private set; } = 1;
-
-        /// <inheritdoc />
-        public void Save(string fileName, int? quality = null)
+        
+        public void Save(Stream stream, BitmapEncoderOptions options)
         {
-            using (var image = SnapshotImage())
-            {
-                ImageSavingHelper.SaveImage(image, fileName, quality);
-            }
-        }
+            using var image = SnapshotImage();
 
-        /// <inheritdoc />
-        public void Save(Stream stream, int? quality = null)
-        {
-            using (var image = SnapshotImage())
-            {
-                ImageSavingHelper.SaveImage(image, stream, quality);
-            }
+            ImageSavingHelper.SaveImage(image, stream, options);
         }
 
         public void Blit(IDrawingContextImpl contextImpl)
diff --git a/src/Skia/Avalonia.Skia/WriteableBitmapImpl.cs b/src/Skia/Avalonia.Skia/WriteableBitmapImpl.cs
index f57f84b168..3fd7664dca 100644
--- a/src/Skia/Avalonia.Skia/WriteableBitmapImpl.cs
+++ b/src/Skia/Avalonia.Skia/WriteableBitmapImpl.cs
@@ -149,24 +149,13 @@ namespace Avalonia.Skia
             }
         }
 
-        /// <inheritdoc />
-        public void Save(Stream stream, int? quality = null)
+        public void Save(Stream stream, BitmapEncoderOptions options)
         {
-            using (var image = GetSnapshot())
-            {
-                ImageSavingHelper.SaveImage(image, stream, quality);
-            }
-        }
+            using var image = GetSnapshot();
 
-        /// <inheritdoc />
-        public void Save(string fileName, int? quality = null)
-        {
-            using (var image = GetSnapshot())
-            {
-                ImageSavingHelper.SaveImage(image, fileName, quality);
-            }
+            ImageSavingHelper.SaveImage(image, stream, options);
         }
-
+        
         public PixelFormat? Format => _bitmap.ColorType.ToAvalonia();
 
         public AlphaFormat? AlphaFormat => _bitmap.AlphaType.ToAlphaFormat();
diff --git a/src/Windows/Avalonia.Win32/OleDataObjectHelper.cs b/src/Windows/Avalonia.Win32/OleDataObjectHelper.cs
index 198c6fca07..c69fba5f10 100644
--- a/src/Windows/Avalonia.Win32/OleDataObjectHelper.cs
+++ b/src/Windows/Avalonia.Win32/OleDataObjectHelper.cs
@@ -445,7 +445,7 @@ internal static class OleDataObjectHelper
             if (bitmap != null)
             {
                 using var stream = new MemoryStream();
-                bitmap.Save(stream);
+                bitmap.Save(stream, PngBitmapEncoderOptions.Default);
 
                 return WriteBytesToHGlobal(ref hGlobal, stream.ToArray().AsSpan());
             }
diff --git a/src/Windows/Avalonia.Win32/Win32Platform.cs b/src/Windows/Avalonia.Win32/Win32Platform.cs
index 5eaee60448..c7cd651ca5 100644
--- a/src/Windows/Avalonia.Win32/Win32Platform.cs
+++ b/src/Windows/Avalonia.Win32/Win32Platform.cs
@@ -1,24 +1,22 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
-using Avalonia.Reactive;
 using System.Runtime.InteropServices;
-using System.Threading;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Controls.Platform;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
+using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 using Avalonia.Rendering;
 using Avalonia.Rendering.Composition;
 using Avalonia.Threading;
 using Avalonia.Utilities;
 using Avalonia.Win32.Input;
-using Avalonia.Win32.Interop;
 using static Avalonia.Win32.Interop.UnmanagedMethods;
-using System.Collections.Generic;
 
 namespace Avalonia
 {
@@ -282,7 +280,7 @@ namespace Avalonia.Win32
         {
             using (var memoryStream = new MemoryStream())
             {
-                bitmap.Save(memoryStream);
+                bitmap.Save(memoryStream, PngBitmapEncoderOptions.Default);
                 memoryStream.Seek(0, SeekOrigin.Begin);
                 return new IconImpl(memoryStream);
             }
diff --git a/src/iOS/Avalonia.iOS/Clipboard/ClipboardImpl.cs b/src/iOS/Avalonia.iOS/Clipboard/ClipboardImpl.cs
index 57ff3c9043..5f02c24604 100644
--- a/src/iOS/Avalonia.iOS/Clipboard/ClipboardImpl.cs
+++ b/src/iOS/Avalonia.iOS/Clipboard/ClipboardImpl.cs
@@ -5,6 +5,7 @@ using System.Threading.Tasks;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Logging;
+using Avalonia.Media.Imaging;
 using Foundation;
 using UIKit;
 using static Avalonia.iOS.Clipboard.ClipboardDataFormatHelper;
@@ -100,7 +101,7 @@ internal sealed class ClipboardImpl(UIPasteboard pasteboard)
             if (bitmap is null)
                 return null;
             using var memoryStream = new MemoryStream();
-            bitmap.Save(memoryStream, 100);
+            bitmap.Save(memoryStream, PngBitmapEncoderOptions.Default);
             memoryStream.Seek(0, SeekOrigin.Begin);
             using var data = NSData.FromStream(memoryStream)!;
             return UIImage.LoadFromData(data);
diff --git a/src/iOS/Avalonia.iOS/Stubs.cs b/src/iOS/Avalonia.iOS/Stubs.cs
index c78823cd81..913b8ba2fd 100644
--- a/src/iOS/Avalonia.iOS/Stubs.cs
+++ b/src/iOS/Avalonia.iOS/Stubs.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using Avalonia.Input;
+using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 
 namespace Avalonia.iOS
@@ -34,11 +35,10 @@ namespace Avalonia.iOS
     {
         public IWindowIconImpl LoadIcon(IBitmapImpl bitmap)
         {
-            using (var stream = new MemoryStream())
-            {
-                bitmap.Save(stream);
-                return LoadIcon(stream);
-            }
+            using var stream = new MemoryStream();
+
+            bitmap.Save(stream, PngBitmapEncoderOptions.Default);
+            return LoadIcon(stream);
         }
 
         public IWindowIconImpl LoadIcon(Stream stream)
diff --git a/tests/Avalonia.RenderTests/Media/BitmapTests.cs b/tests/Avalonia.RenderTests/Media/BitmapTests.cs
index 1db7556b46..12f6becd8f 100644
--- a/tests/Avalonia.RenderTests/Media/BitmapTests.cs
+++ b/tests/Avalonia.RenderTests/Media/BitmapTests.cs
@@ -94,7 +94,7 @@ namespace Avalonia.Skia.RenderTests
                     var rc = new Rect(0, 0, 60, 60);
                     ctx.DrawBitmap(bmp.PlatformImpl, 1, rc, rc);
                 }
-                rtb.Save(Path.Combine(OutputPath, testName + ".out.png"));
+                rtb.Save(Path.Combine(OutputPath, testName + ".out.png"), PngBitmapEncoderOptions.Default);
             }
             CompareImagesNoRenderer(testName);
         }
@@ -123,7 +123,7 @@ namespace Avalonia.Skia.RenderTests
 
             var name = nameof(WriteableBitmapShouldBeUsable) + "_" + fmt;
 
-            writeableBitmap.Save(Path.Combine(OutputPath, name + ".out.png"));
+            writeableBitmap.Save(Path.Combine(OutputPath, name + ".out.png"), PngBitmapEncoderOptions.Default);
             CompareImagesNoRenderer(name);
 
         }
@@ -215,7 +215,7 @@ namespace Avalonia.Skia.RenderTests
                             Assert.Equal(data.ToArray(), copyTo);
                         }
 
-                        b.Save(path);
+                        b.Save(path, PngBitmapEncoderOptions.Default);
                         CompareImagesNoRenderer(testName, expectedName);
                     }
                     finally
diff --git a/tests/Avalonia.RenderTests/TestRenderHelper.cs b/tests/Avalonia.RenderTests/TestRenderHelper.cs
index 2bd12cfa81..7b3a94d6b7 100644
--- a/tests/Avalonia.RenderTests/TestRenderHelper.cs
+++ b/tests/Avalonia.RenderTests/TestRenderHelper.cs
@@ -69,7 +69,7 @@ static class TestRenderHelper
                 target.Measure(size);
                 target.Arrange(new Rect(size));
                 bitmap.Render(target);
-                bitmap.Save(path);
+                bitmap.Save(path, PngBitmapEncoderOptions.Default);
             }
         }
         else
@@ -91,7 +91,8 @@ static class TestRenderHelper
                     renderer.Paint(new Rect(root.Bounds.Size), false);
                 }
 
-                writableBitmap.Save(path);
+                using var fileStream = File.Create(path);
+                writableBitmap.Save(fileStream, PngBitmapEncoderOptions.Default);
             }
         }
 
diff --git a/tests/Avalonia.Skia.UnitTests/Media/BitmapSaveTests.cs b/tests/Avalonia.Skia.UnitTests/Media/BitmapSaveTests.cs
new file mode 100644
index 0000000000..5107e778a9
--- /dev/null
+++ b/tests/Avalonia.Skia.UnitTests/Media/BitmapSaveTests.cs
@@ -0,0 +1,108 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Runtime.InteropServices;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using Avalonia.UnitTests;
+using SkiaSharp;
+using Xunit;
+
+namespace Avalonia.Skia.UnitTests.Media
+{
+    public class BitmapSaveTests
+    {
+        [Fact]
+        public void Save_With_Null_Options_Throws()
+        {
+            using var app = Start();
+            
+            using var bitmap = CreateBitmap(SKColors.Red, 16, 16);
+            using var stream = new MemoryStream();
+
+            Assert.Throws<ArgumentNullException>(() => bitmap.Save(stream, (BitmapEncoderOptions)null!));
+        }
+        
+        [Fact]
+        public void Save_With_Invalid_Png_CompressionLevel_Throws()
+        {
+            using var app = Start();
+            
+            using var bitmap = CreateBitmap(SKColors.Red, 16, 16);
+            using var stream = new MemoryStream();
+            var options = new PngBitmapEncoderOptions { CompressionLevel = (CompressionLevel)42 };
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => bitmap.Save(stream, options));
+        }
+        
+        [Fact]
+        public void Save_With_Invalid_Jpeg_Quality_Throws()
+        {
+            using var app = Start();
+            
+            using var bitmap = CreateBitmap(SKColors.Red, 16, 16);
+            using var stream = new MemoryStream();
+            var options = new JpegBitmapEncoderOptions { Quality = -1 };
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => bitmap.Save(stream, options));
+        }
+
+        [Fact]
+        public void Save_With_Png_Options_Produces_Png()
+        {
+            using var app = Start();
+            
+            using var bitmap = CreateBitmap(SKColors.Red, 16, 16);
+            using var stream = new MemoryStream();
+
+            bitmap.Save(stream, PngBitmapEncoderOptions.Default);
+
+            stream.Position = 0;
+            using var codec = SKCodec.Create(stream);
+
+            Assert.Equal(SKEncodedImageFormat.Png, codec.EncodedFormat);
+        }
+
+        [Fact]
+        public void Save_With_Jpeg_Options_Produces_Jpeg()
+        {
+            using var app = Start();
+            
+            using var bitmap = CreateBitmap(SKColors.Red, 16, 16);
+            using var stream = new MemoryStream();
+
+            bitmap.Save(stream, JpegBitmapEncoderOptions.Default);
+                
+            stream.Position = 0;
+            using var codec = SKCodec.Create(stream);
+
+            Assert.Equal(SKEncodedImageFormat.Jpeg, codec.EncodedFormat);
+        }
+
+        private static WriteableBitmap CreateBitmap(SKColor color, int width, int height)
+        {
+            var pixel = (color.Alpha << 24) | (color.Red << 16) | (color.Green << 8) | color.Blue;
+
+            var data = new int[width * height];
+            data.AsSpan().Fill(pixel);
+
+            return CreateBitmap(width, height, data);
+        }
+
+        private static WriteableBitmap CreateBitmap(int width, int height, int[] data)
+        {
+            var bitmap = new WriteableBitmap(new PixelSize(width, height), new Vector(96, 96), PixelFormat.Bgra8888, AlphaFormat.Premul);
+
+            using var fb = bitmap.Lock();
+            
+            for (var y = 0; y < height; y++)
+                Marshal.Copy(data, y * width, fb.Address + y * fb.RowBytes, width);
+
+            return bitmap;
+        }
+
+        private static IDisposable Start()
+            => UnitTestApplication.Start(
+                TestServices.MockPlatformRenderInterface.With(renderInterface: new PlatformRenderInterface()));
+    }
+}

From 94a5671d584ae0becd8a8ddecb2c922334c7e1bc Mon Sep 17 00:00:00 2001
From: yoyo <zrt2399@163.com>
Date: Wed, 8 Jul 2026 14:33:45 +0800
Subject: [PATCH 076/196] Fix typo in PART_OnContentPresenter name (#21728)

---
 src/Avalonia.Controls/ToggleSwitch.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/ToggleSwitch.cs b/src/Avalonia.Controls/ToggleSwitch.cs
index 30f9de12c4..8fea3a5af4 100644
--- a/src/Avalonia.Controls/ToggleSwitch.cs
+++ b/src/Avalonia.Controls/ToggleSwitch.cs
@@ -169,7 +169,7 @@ namespace Avalonia.Controls
         {
             var result = base.RegisterContentPresenter(presenter);
 
-            if (presenter.Name == "Part_OnContentPresenter")
+            if (presenter.Name == "PART_OnContentPresenter")
             {
                 OnContentPresenter = presenter;
                 result = true;

From 121d354af84287f569e57aa9af96b77509809f0e Mon Sep 17 00:00:00 2001
From: Mike Goatly <4577868+mikegoatly@users.noreply.github.com>
Date: Wed, 8 Jul 2026 08:00:38 +0100
Subject: [PATCH 077/196] Fix Android crash populating accessibility node for
 peers that conditionally hide a provider (#21726)

Co-authored-by: Steven Kirk <grokys@users.noreply.github.com>
---
 .../Avalonia.Android/AvaloniaAccessHelper.cs       | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs b/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
index 7534d8c83d..4da035f877 100644
--- a/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
+++ b/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
@@ -111,19 +111,19 @@ namespace Avalonia.Android
                     }
                 };
 
-                if (peer is IExpandCollapseProvider)
+                if (peer.GetProvider<IExpandCollapseProvider>() is not null)
                     nodeInfoProviders.Add(new ExpandCollapseNodeInfoProvider(this, peer, peerViewId));
-                if (peer is IInvokeProvider)
+                if (peer.GetProvider<IInvokeProvider>() is not null)
                     nodeInfoProviders.Add(new InvokeNodeInfoProvider(this, peer, peerViewId));
-                if (peer is IRangeValueProvider)
+                if (peer.GetProvider<IRangeValueProvider>() is not null)
                     nodeInfoProviders.Add(new RangeValueNodeInfoProvider(this, peer, peerViewId));
-                if (peer is IScrollProvider)
+                if (peer.GetProvider<IScrollProvider>() is not null)
                     nodeInfoProviders.Add(new ScrollNodeInfoProvider(this, peer, peerViewId));
-                if (peer is ISelectionItemProvider)
+                if (peer.GetProvider<ISelectionItemProvider>() is not null)
                     nodeInfoProviders.Add(new SelectionItemNodeInfoProvider(this, peer, peerViewId));
-                if (peer is IToggleProvider)
+                if (peer.GetProvider<IToggleProvider>() is not null)
                     nodeInfoProviders.Add(new ToggleNodeInfoProvider(this, peer, peerViewId));
-                if (peer is IValueProvider)
+                if (peer.GetProvider<IValueProvider>() is not null)
                     nodeInfoProviders.Add(new ValueNodeInfoProvider(this, peer, peerViewId));
             }
 

From 3290fd1ad93e8f36e327f9d4c35401cba432e66b Mon Sep 17 00:00:00 2001
From: Max Katz <maxkatz6@outlook.com>
Date: Wed, 8 Jul 2026 02:45:08 -0700
Subject: [PATCH 078/196] Don't include non-text files in Roslyn's
 AdditionalFiles (#21729)

* Only include XAML/AXAML AvaloniaResource in the AdditionalFiles

* Expose AvaloniaResourcePaths for the source generators and Roslyn

* Typo

* Update Generators.Sandbox, include some test assets
---
 packages/Avalonia/AvaloniaBuildTasks.targets    |  16 +++++++++++-----
 samples/Generators.Sandbox/Assets/Icon.png      | Bin 0 -> 14349 bytes
 samples/Generators.Sandbox/Assets/Strings.xaml  |   6 ++++++
 .../Generators.Sandbox.csproj                   |   8 +++++---
 .../Avalonia.Generators.props                   |   1 +
 5 files changed, 23 insertions(+), 8 deletions(-)
 create mode 100644 samples/Generators.Sandbox/Assets/Icon.png
 create mode 100644 samples/Generators.Sandbox/Assets/Strings.xaml

diff --git a/packages/Avalonia/AvaloniaBuildTasks.targets b/packages/Avalonia/AvaloniaBuildTasks.targets
index 9ed50e6137..ec1ef7b46c 100644
--- a/packages/Avalonia/AvaloniaBuildTasks.targets
+++ b/packages/Avalonia/AvaloniaBuildTasks.targets
@@ -39,15 +39,21 @@
                       Condition="'$(ApplicationIcon)' != ''" />
   </ItemGroup>
 
-  <!-- Include AvaloniaXaml and AvaloniaResource as a Roslyn-visible additional files -->
-  <!-- This is necessary to use these files in source generators and other Roslyn-based extension -->
   <Target Name="_InjectAvaloniaAdditionalFiles" BeforeTargets="GenerateMSBuildEditorConfigFileShouldRun">
+    <!-- Include AvaloniaXaml and AvaloniaResource (XAML only) as a Roslyn-visible additional files. -->
+    <!-- This is necessary to use these files in source generators and other Roslyn-based extension. -->
+    <!-- AdditionalFiles ensures that each file has Compilation available for them. -->
     <ItemGroup>
       <AdditionalFiles Include="@(AvaloniaXaml)" SourceItemGroup="AvaloniaXaml" />
-      <_AvaloniaResourceOnly Include="@(AvaloniaResource)"
-                             Exclude="@(AvaloniaXaml)" />
-      <AdditionalFiles Include="@(_AvaloniaResourceOnly)" SourceItemGroup="AvaloniaResource" />
+      <_AvaloniaResourceXamlOnly Include="@(AvaloniaResource)"
+                                 Condition="'%(Extension)' == '.xaml' OR '%(Extension)' == '.axaml'"
+                                 Exclude="@(AvaloniaXaml)" />
+      <AdditionalFiles Include="@(_AvaloniaResourceXamlOnly)" SourceItemGroup="AvaloniaResource" />
     </ItemGroup>
+    <!-- Unfortunatelly, we can't include binary files as AdditionalFiles, so for general use avalonia resources we add AvaloniaResourcePaths instead -->
+    <PropertyGroup>
+      <AvaloniaResourcePaths>@(AvaloniaResource->'%(FullPath)', ',')</AvaloniaResourcePaths>
+    </PropertyGroup>
   </Target>
 
   <UsingTask TaskName="GenerateAvaloniaResourcesTask"
diff --git a/samples/Generators.Sandbox/Assets/Icon.png b/samples/Generators.Sandbox/Assets/Icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..41a2a618fb02e4cb7f6a15caf572b693bfe1ebb1
GIT binary patch
literal 14349
zcmdtJ^<R|1_cy%D(z$d>EU0vMF0h26NSCC5pomCGr^Esh3km|#NF&{iw9?Wnjl|N@
z`CNWJ_xJlef5G#^&FjT4v*$W9bLKr~&Ybg}2rW%D5<&(-5C}x_NFAXA0)gZH{o~^T
zErD&~zd#^~-;WTAdY)f*(0E^|PA(J<hDDkT?Fmma&|M2q?X5K`(Pg`m_WJ=UFBC-;
zh1$W~+fLbI#SA%a-SKNs4M9bm!)%y%Zo#9SFZL8fG}0bTiyL>dJoCHg9rW(}-q6s{
z#*KHDgh<nsY@LKm#?8>qFB4W6%q0k{gg|^3gd>rC)VTQM<PDu5HW<v1junAeBZPz?
zk)~FGP;wLxF%%FE{l7=J(_8}n>FLhj#M%Yxxfs$Hp@c8So3dxQzuFO6D`+4HKNdX3
zU$5ATBk*Iq3h=^S&l?<abo{6qF2GnlvuY8<Y2AgvMUFWdWaOX5KJE_c>Fl7GP}W<6
z!%2fSTZ=YX;Xa}7q3U>`3qD>$uw??ic;UcQ;9H#~hXP-|5dmoD!@!eAn4`WPE8Fhp
zy2m^eUcq1`spUO?vi%Bn9Z$EuO(AZVukaXyO(D>WJHqBYfuJ(b8>&849Qm+KnMB)`
z7Tegq#og}ib#n=|-&DBx7egWPvHNLcUtf2*)w1R@*xP~qm)tG5^s?F&uss>G895?J
z)+xMi{%i;=thrkw+=bwr#awz1G8)#-%fBfEt2^N|VoCnOw900JZowTqgkDlMYoE1;
zEv{Rqo@$o^(wJYH&%NWxF}z|GBjw)U#@H!2+d=_qPn@{V%UW(TeRfd_$Bk@+G`RR)
zL-J0qFyb-;P0Gizoc!4D3Z~>PwAY=fEO8Kqo2S=yJ>MHGqo(Av-&zO8J$#UH^E)UT
zb&Dm(0x#p0AK5jO0X1_5Km7UQW&hyM$hM<KwgEX}=)e~OKjuXl-ceV+J~)nl=ifNt
z2ZT%d<h%wI{tA~3QEfoy10=-I$Ho0}>96gmRU=i7b#S~P_+Dt;c71rc67ek^I{8e}
z!&O^D5YEY$m!>;AL+4NcN&?wq+!faB^Wllyf_BG|w>-^n!>+@@N?anv!@5_7tS<Kv
zWuSMTrf#$-s4x?qra6C>84ald_T6RH$cUk@E2iz0pV~`iDy(+ATb$#M)FF6Yr7Guh
z=v|hYwbKJ)Gkh~wJKOBC(jZ7jnpp;DF)0ZS?Y}>K5@5o*?Jn}kkB;@zCwlbb=PGkX
zhG0&DP5NcUYQ?PaI*$>B0|qlaT1ZGrH$S)IoHXwg79GwKXt{_Ik)bTaUX7lYaB)8*
zElXwFcjkddrx+h2uG9;zy+hq0*gjKcJx~Jf8wplQq9c>xd#yVG9$sh?ukhy}7aKC(
zL8lu&e#7p2SUZMdh72V_#3=Yx5`NxB`18eKR)Pnumt2}#?PDW7PwSuHv=#b1Et;hc
zWm7t&I-jPfs5|w%BA=^`2Bz}o;PbPlr`ylHztg2*cSPvBt{9Sq;fpOl{kch!V?gTL
zjZx(kIWKznMCuBa^O0Z}`yD?+1c@M`fF9ek5ysSbn`g&AyXh|Q$=tUaZ~C_@O-%&i
zNR?<!Reg{kP-mk}j1Kmx`d;8XTAHFIVeuxt$<wL{q*Fk3Dz&F$trS4f=haje+2k`f
z49%kX2^p#Cj91)XGQJ)?ihX>s8zF@(I}S`XI==cb(a8iJ`ktce<O)cNLYH3s{NkYY
zo%ePgW6tT$TgI6A3mGl_ApN3G%gD1yT(&5wYf*3yFLbrjTh}B&`$p|spzcz>_D^p+
zlg0bW)|hNy>aP#T=s}cG%+flgBeEa`7Y4&jZ)P>vC-O*IJ|n|e@7ou9lSfjmjjmrD
z=L{5Qv~won7k{@r=2s4>Y=2Mwk=s~)$-j(|?d*JDNZaG|_J++sofd4e)~t;ONOV*&
z2qndG@!Xb8MQa_M7Y!+Tq+i$v1Py`94Obc61reN#z65=ra}1B~ssIU>^T;8#1fO3{
zwEY6te1RSA8zP84JgSkVT9w)bn<TS}am>pCuk+VK<aHSrn*?lM?t@|qQxbluwk+>D
zBm&xUs4&V_B9?1a-7MZ{La}I;)j_aF`pL*$m8JOvdO3(g!Da5?R7~TX++u)JvDf~$
ziO9*$eOj-7vQ9XDzxch`m@4I)bg8V1|5Ur#jQo?8q{t%Hh3CD&T$~OzcRHP}@J#3L
zR0RZB7QimQz?-BT(e$uS?6(wL(_))>3Ko~8z(kaNPcBE!tC*!H===!dK42VsS04Zn
zV3#NCFco!CIh-?>P&)J^?y}pHbRF&P*^B~_#>k{By({m$5sD0}D>Lr2hOGs$s9LoM
z*X+l;w!95l5rX@!#bo0-1$MjuIlkTyMsPxBu`YjqYK^@a!>AU}oZUNb-x;d<+iE}e
zni+v7;c!ObVW-VcnPyb!+b$V&U>4qc{(8_wci8y%OSOg`)q6Lu{|F(F<s8+6rsDtE
zevAadtvXfHA@XE<_X-6A!ff3O+di@>g(PJQZlLS4&wa`m3AkGySA9ZT-v&{T%CWaU
z`Ye*WoDm7g)N$zCuEtktw4OGiSXX#NiDp!YVyQoGfS7{ocZHNg`Z{D7gzWxCwkG!)
z+9ehel9gbu1#A!5A)#X1lty{On;Ve|hrp-HJR(uQ!|;lJuy?2?vMH^tWpHoGyu1h`
zYkteY>B+2~Sl@EinULwJ?GcVgk)f7FqR=v3@>kq59e=%6S*7MpPpn4laU&|zGSDVy
zZuslsDDpeDn}w(c`%fsF3oD*#&g4LZg4fEsG8qD_J=%lmdo8rg)S<1|9k(^E3Df8w
zXk&z?JaKsL8Pe|Rt{0=~La)ZkTp9I;nMvP_)G}a-9TI~;er2MM*e0sFl&xu-ie3}O
zMXK#&&s?<|4Hs@&@hudH{FBgSqaJ=Ddxj!4mxwQ>V`VOHl5Gx8IjACJG8B7=!{{D{
zk4n((Y$Cj~q2=QRMr=xT)EJc6(7K4mDJ8kZQm+fs(0%tYxEF!kmZ@&%md(3bT21=&
z`SYQf8lf|Gyf*i}+S+snR)xoNeSz%c*|=2F<-0|c54_Q8-<R<@KD@>Fm6M>B#l~OV
zqkqStq!)WEc@^GmA#hiJOj0J(Pwm@n+gIB1=i0Q(yILxBGvz)pxx`8RW8IwW#J=vF
z#Iw5uU}jjYv%;39`(7=|`Ycm}!{@4LY)X2IG}Plhzm8Vi%_UYme7}85Hgj8C9<@Jz
z3i9!()dm){o4mWn#V8+rechefyw^SK36+c9$qo%2wco5T@@)SJLCcnFQmNsDhj(9B
zxLI<=Lh3*ej_B;X6?0G;#&NqSz!E7r2~iFaRt}VBY$HJLxwH89IQyr}&$<qk>AiDG
zXtJ!A`Psl+FB2uKr1GtP?cz4p3yows{QMbr)%({jcj9f$QKr{wYU4Hw9W3Ug9h&uV
z`c3wqj}-z`Z5!_F{y)r&xZYb2FS<j2UXzbpr+7v0xD}?X?D1}RFYWOTAmx;-93uP{
z#wLL&N)X3U5ov6CfJjSITqIAI1@*<E*j9|lh{+!-=zkq~sdk}Pc6GoQgVEhgG<W@O
zFd;>929?^WeJq;MRP_}T)KtZJ!;2#FjJNuG`1up8?zr`iQ_PbnuJ+wLzX*a3wg#~X
zRUSiGASPtzLqB6poi#PVNgji%(JiUpIu_#dJnRnHTj$eM(&r>7#E7T{Jm?17L63su
z>elXX+qr67O=w`U<qPU^fb&DIJscl47oNxPUk7r{DXn_X2c$%Pr%|t89@|Fq&Zl*w
zjn^b(x|Q<dH*l|iU{ossZ1Y)WXr(wIXhHZgZK>;fB@Zyp97;2VBXqpgj;V8fst5hA
zf+9&5=egS-iH&dJlkW|^&SeHXnLL)8<IPdTlqXtEe03WAtwL^ppDwr+%vyFUykQ2L
zPn)oj+Z)Q>shUBog;dzyDEw_iz3C!H5{bY0IkqVaXAHrUq*zuDap`BK5I^%qBWhm+
z)|VGw-A;jAOeRhzygnpsLkrWoq0S|EVff#|;X@fNrz=6`XQ*gN^JimETlN-cA6%1x
zd?tPs&yKHN>$!L&{`3ayG_&4@<0TVI-}+|cWf^1t1EwGjjne+WJ!%P_5A4A3SJXpf
zo#9@&mS3ly+Ay|uKkl4<d-lGLx7qZndBR8HCrW+$KPJeT*TLleH*AcyA&P;g^oKb{
zgf70G|MP93X@)o!K{21qjtYBPR}LJOdR&Xh<P~?ynGo>UlP2#SSNcFr``5}{Xyd}N
zUTD^ib4NAcrl&CvDsg)M3<_q?eKf!^xb*>%z8c!Q|IWj}d)uo{#z7>|o>#4iS?n~*
zfetPc-udZjVTNX=DZ%Xh%Px#+^PhJ&4~oiIKPfOV5RvJ%J^SpfAob+c8<CtC#=7aI
znJ_jT_qn1gv9F6pEh%R`V+TWGvD+hRY5XfRGHCV=y*!M53~_FUX4eBuw}jalGda!z
z?dBq)BwBS)m1r_w8_@>WYpdioabjrN4(7A(T4R1zQ#HFY+lweKL+;>J#6U-XWJxl$
zAA(}Aps#m?`aCq>+*@!H3%qK6+vUI%Bx<EMy5rZmPR$Z&IedPfDdPMc#}PAcb9P*k
zvg#By&CcQ8f$d$>&t*+6k(}qRiX&?$2@<m@vE?#1!ApH^leteu0>W#zQ0#`Z`v;Ab
z0?ycDA@95{_yTvfUfO`jRAK2Ki7P!gj_!BKLX3VsX*jta6rc_WB`#iQZ#KShdi!SK
zQ}!5yV|bfLMFBnpcFTBjrowk0FGbviFEH8MW95DfoI&XOoFASF#}Qj#XW~cVxMft|
zUZG_SLY~$rs(UF`Ci3>M(Q&RP%X6~aaqjia7=aujm#!TI!t+E^ip?dJ*WOtkyMCwx
zd<}4~jIOV^a@yCiPZLNye1^n+<1wiTX4dU)K4NLP)2R(tg?)o)C};RHO6z7SQ`JM^
zLBKs>m8$;LuSjr0^WG00;yCQLdt!eBvPTbk^>bny>0p{QvPEYo?!5|_k=yvsB!A4o
zQma^&#a8Pw;YBF?JLKILAY4;gq*~jRg%u=8E(^tB!ybs@j&$lV=YSN_J{NhHMQ$In
zpA80NdpbK;cTgrn-kKYDHNQ+TJMJv0^-9Gp8sLP>_@HUU%BQ|Z8nA<|djMRulOsQj
z<}dmLuBj+sjWBFUt9GD}sorIUMypQ7Ui~`Zczs^FSNvN<n+Q<87n*3|{$gzmg6y7w
zLGuJgQ#hI(iboL>Q$j$NYh?rSm*$!A-e>5Ju1h5GZtO^)W(8t9i>#52{4>8DSZG)9
znthp1Hr;MHA5$Y%yPUa4{41uQ-y(UvYwt%4?yyH%Z-rwJDUE6aYOuwk6$x!7UxDGv
zXo;r3JI#DPyEnzte<8mW)FNaL`fK|Z)bJeT)@#bQg=V)2|9KP&bF#uq1`QIL!XM8_
zb!Xq1H*UZ3)y`LQY$ghidLo9I)#;y#;`_qVFCcj|S^0C1a5kz^>btS)Q<eTBut!H_
zj6ol}`I)k0w)?^q5ECNuoUwJnN#<rJOMhH}{J$Lj6&E%ez8IPjq`1Hy$*N1dc@e5i
z`Ki6SisnpLV{i3gt?Wt9CN*T}pfTdf3Vv=(DO%bTN<?PkX|tr#g6(nY#sO=;8GSFK
zY2(RJX0zUI`%-P;QMPA0#vE(sn9Gmm?C9TzipSE}blM)$33!bnW&%G+O9E`UzBjIy
zeSlnS73meW9;{O9Udh)I$6bMUm)xHz>b8)0^<(6PLz~KrKD#BmR~i{vh^-&)eY4yh
zGO;~^b)Oy;-|lK5O;g@a#{c-;Ns%rS?@Z3_6&`KougE%Sx7S%@wY)t`;N&4-+noM4
zZM;oJ!!~B7Zo-&2_BW65%-wi!vw_@e{v~yKO46)rm$KA8su*}tn;<tf#uaq0^0iG|
z6U$*~;7Zcn*~<Fgd(5A7-n?Gy{SFa~TGWWAC-iM@*^p7YI7xZazl5KA1dkIFq+#x>
zMJc}Z@ABYbr4^JF25zh1HtMDMZ6||VQOYGeM|1ft-m<GcY+Us>;}5*u#ozuGF?$9K
z45N@edvkYt8D&dKhIpk{`J%n*Me?*N-|Aun#S`zEse3j`OCDCyThf0e+0UQve%+aC
z`LyNzYBufU*=Ku}rZ;`zF>TnkUDfj6dW-v9;H1ZmNlb?3C_B>ct(-512(R(GKuJBr
z{jDg)Jj^$Lk3?TOLKPno*=EBd-^0b<AwH1v-xzZjQ-A-i#xBf*F}?$E_DIHsRZjYr
zHy1G~K=F9zxdG`iE|11XW3N%Q*Ghh%_58&#b$$Oo?qpjun;@<&>0+Wlb{+{|`RM|?
zMsq@?wWzpnc5}9dZ`|H|k)<Re*HE_OJ|-&j={K8oUwM`;37qC*TqEFYL4{(O_3&u#
zJWLHMqO~g9Amh13{kB}MYQJkvdfT}l9VVbyo?h)0YnHlA;MCJxT}wz;*u5)s)GBaQ
zU`Sj11trf^;w5f&oLJwN7FRd6{xxvx6fruD2{e?|gebn<?;(5>=)33`YYrlPT_3_W
zwt1Z=fTX*!LYlq5FM!;nyw8KjuWMO9<+oNap7-^ni>&1>%nXZ>^~JH$Ml>%S?CGEr
z2ZBl%?SELL5<{Xr$x!v8-4B|)>(0`k-bLkuR&K-=hwH7Ga?JMyvyJuny0^N%xg~mW
z^Y=loDkp|I<T)C&BnGUx*o$SQG9UFMc)Ge|(Ok8){`$WAhE&E!!<H_*hj+G(=06fh
zPF#5?q$d2=lPsjg;jMxV_Wd0ObPiy2FR(bs!afnawUtMqK}<n(MjI0uy(o2;lkMFh
z;Y8}jugl8;);});9`q1v*27SY2L26SSKTSMpnV{6YyWN047PaFmK3yc_Dfu{l#Q79
z&yXZVn;2lu6zm2Hz^KC8ar&a=9=_L7JX;g5v_x{GlzDEX*2*|J^QyMilnMrLfXuxg
zs9>L0IL=AcwG1{`6mT^S{7}&f!T29n%ZI5~Vd!g)Q+yIh7T1lCzCX>q7v58ggfvy^
zsGPkzSvds!t4a|LKb+M-d;L!A_B!+uFzgiNrrD|m(`BSJ_^3tbXVhI0_w_;|RYi%`
z&~6W*d0;!$?k$RKEZ#fA(MjL4com{MgrwPH`mqmvM7_J}j#o%i0HS~26Vd|yN>`_7
zi>xoQ!<NwWd3zw<i}&rT^LU29jR7`rs;R|DuI~8<Z~^X1k5Df#<i4rim5d0&bc(WB
z`nJ26#obqMKq|ae!Zpii-<?G&GxNn%?U1<y>TwVuv|U;;$bMH;x$CLisQsgzwiq&m
zR6cMD>G9oL1rX3~H1-3-tiz=RcA0XxU#E7)Z4cpb6Rti=#os8}R%>!<hrX&z$4^8b
zjtLk_$%EEQgnr`5<1O6>00EYwX0<9~?5p06{n~1FQ|2P^YjaQ6--w*V3^t;XC8_%D
zh*C8s38%2xG;`Hf@dcaCUFE}?Sn@mjlRVK{E6qIf3CH5Sq*3o8)dmIGOub*F*#^l|
ze&?nhp^<BS`0{a6ov(kDHEC{vYkH7N%>zu2wr6$v4jt^4w+;m?=9Yv7sh9wVdx{kZ
z10sD9O0nJ;zbwgzt@eCcP30-plf~8sgWjcUSQ^gRSh21i27K(3qP>i|mIanYQ*!5K
zeU**gXyqb7IK`J+lm5k*ttMlObi0tvIn6o(BV@DG;kT>+_hvSnp3U`}q=>*p(HSgU
z@AxUXTtY}LL6td6i;IIw(-2`=VEwaq`UH=WoHlu@B%E5<*{|#QtC67zEpOTM=~xE^
z?FPlDMJ)K}9~P;AZuJAaKuT*EzTNkH&Zg=el(VOJpwyPPKk7b#Db&X;c)VuxjLbmI
z+5yJ=;YcOg!{7)#>wlq*;@X+{*|H(lOu)8O?EZ#3OCfOC7%LHDzpbiyp+QddY|<jJ
zn2n;+E!`SIWrS<`(4@;=^P>_SEB`NJYp1)ZtZ-uJCd;<K&km>;W{5WY23;YEGdaBu
zS-@^T>Ac^Mf@~2(lV}9^V`}FrPiV2sOahGGh9VQCY3@^a{ld`r?jXt-)p2muiKh2w
z*Hue0){lh9e}>efSk+(yM6Vlj<AA)5GWS|n^5zFkX4j8Kc@latlzpSPv*rjwD{hIj
z#fZ%|ke7wN#p29^M(@MzWEmaffG4s2c&gdUQ(z{&faKv}BMSxRi84)RUWA_e%S${^
z%yA<b%cUD|28H{e5gHfbaBgMgV;4^TprsLxy++D*5iGOgVN%DW#LqJ*y<?Hexnp@P
zUJq~08wObR7un^{7U(aTUa%*art`O<roh&ar$VpJJuUqgS%gkSSBLDsw<6gVtzFHG
z$zh=#Z3EW}^&cR)u-|1VF)OUiIqsXif80L-!6PNEsV<{0R+B5s_K@NGi`nBPu`&+s
ziQuM3*){KV<SWg|?6@MQo>qTy!m?Q+ct6*X|1tf3Pcv7$3fJ}xo>sE%`7ODVsrNv^
z`19L$lTQQvH><nC*(x2!PoZu5Um0pz$}@@K4FL2}<gOu8a@C&%u-3*BdeZgi7EZ&s
z->MJa->gaaHd*vjI);8C9_=k+7&~u;os%$Ez%HYVINWB+AS>g#+4;8Nh-VZ1PYo7v
zoEzi3^RMJYTXWoZZ&EbY!P1Uey`xcK@0n9JP8DC4@_Xq7QTvmTBabw43X<!;*Jp9J
zDj?G*z{2&bn;G24^dKLbqCC)tTD8+_YmJyF&W~m-5t`+)SIS*<>w7$}X|x65rclT8
z!l!Nhv!IJ^t{fjuEkag>@fw`^f(g9v#r@OUD)W0)gpm{eq~ts$PWSEOI5iQ(Q`EFn
z({mVR6K)>JT4jR9sctE8tbzGSW+YpZJCkcE<_aRRG`DXwb@#;g)wv--3VWo;`|kDt
z@c9r%-naKfU~Z_%B!rM@)14)7sJVK)U==-I<yTz#OzDItAPiZ<uc(V4(F<s+TTS||
z%}#aYiB{6EH47x(HqzlOx@q3aG0CzmxkCF2|KzV?hk9kZblS0HXE&=e-&g5y;&KaO
zkJDqA^|DWg=K(ipxfa|E9hcTrnMl+u5&0!IVl4rC5Gu7Qy{Z~M7W9ozK4M10n3`24
z+sB-6NwDmy;F<ngR}sP)>#M{h5Ze3-ev41O+!Gkjk<Hk$*AZS4;7`4^<W9+l(g$OG
zurjZUYcKpD6Z7cuiTjmV6I0yOiujT|J_^b$|8xW!#ooI0PE9G)#|y2jVe>T5^!@gi
zRaVJCj68+*rlrT3sKA7*QX1aRZRn`_rUC&2s|!_hFy<o>Zr%uBU6=zFw(9WT#!yu*
z(-S+Y{oj6ZjS4ScArVC8cb9Y6-4RT??SIOELB(S0EV+~Mq2$2XlH(W}hWnDov=3u6
zFEuO?hl-ui-tWWuB*fn&WD26#n|318K($`z@I^YFzYibh>zrcazbl#|5mn*a`n2OW
zFjrmJEL|3>6p};cf?+IUJV=FlSk=t0=U+F<1^zQV*Xv~K_?F@QfiOoLt&2yz79mJI
z|798!V^j0nb|=vRa`h;EbxxuoX{Qv1I=fy>B3hw)IQB}2M+tF(CS6O}A1)aZWgnaP
zH$NUM4jU!Mmc1+~#K_RZJ?iJFHQK{5P^-W=9@x7ZF?>bah$GoJnyQZiLp@aF9u_a}
z7u+tmvxFcyc;UYb!Z0jikE(1KcXSLyS)xN~0pI0H*Znfdqg14G;0UVS8pV->Fbznx
z(<*GATD(lA2E#6zd=Keew4EpNvv0qbm5`EK1n{TH=B7~3QD#JVqTw1g-7MG3VpX@0
zdVh}$AwoZenJeO5SsAh-M~1h1RpJOb*0soY*zux4f^Z!rKWC{;kN6hlxsg0}ZiT&4
z&D5(MB69HQlY>A+w643yN5OWz&rRhzonyjf&+R)snqp?^<!5B*jnsD24-}F1>uN%u
z_c^$@s$_<T#-|zYKaPY;VLig(DH`@fD_dh9&98Jv<?!z@1RPnNhN~}}nC&^AIolGJ
zl+D%sJ<+#q`Il)sT$&rVz>2F$3Na8PYii6;Cky`vC$5majHMtX(>i+w04MHFKr$Q4
zY}1{Rz;}|{sVa(GXUA|XeJH9@0@2l(MZg@=hZ6epuFU6vUHjw&hqH<cUe3<c_&jjG
zWiLk_ocGIE<l&YF;gox-Z#LG|{rLjBSIB}Cb_!V#N<@R6^*cU<L!YKB`MM=i^Q19W
zGB~zmf9{vNt07O(jf4NGE)r?$Yz^-xKX@9>Ba2Me*{$14!CjIA_L}uMgwZj{u;6o$
zd;T>AtY@==U{8JRiSySfKCM5%mY@H-EZ4+q%|95Xp&Yf;8b0~-CMxynwh?o#3zloW
z^##zkw1({gbIEOwFh7GQC%J=zi=Nq(l5dhQ*Bv&Vn5ClL?!WoXpnZ~{%WLC@ygo2g
zIlEjT>|bm7S14p`S2RCUOiua?rl_*Nsh%Nh_>sDO<UdV#_j~tyF*$lqR-Gi0((w{?
z!}g+vUqFGY;~sJaxwo_FPPP_ZLK62SeCk=lQ#Og0^*c?fqjt-)5f%-8fsup`Z`RdT
z#SZgWjG1BC_MW$dC`j><X+8o&vtC(33e^kkvmtM2{^MXZ{s=o@mcG_ow$f_A?k$V;
zG(BYuO-D_W-MJ`&YD}(!Bx0o?@^6FYr@xi*@E0_tsYjVO7-D3}qh~m1!U;y8!Fzc{
zEaABub0kh07VEHA4k=40@^ne8qJZmPiUic?0-|`*iXZm{Z|a%9$A)%>8+a`V>sm&I
zj1lLUP4Rd-T>MFs%rZ?~a#)(sAxyua-I;Q~4Lak5s7t=KArae7DEqYqIz4D4I|?h~
zZ!`51`f*jJaC8~ESi?t0%x(xD8SGZ}Bj{rhwL$+qc%C5tM8#?9ecf3CVN2Uflj0%E
z*sDU99DdTj9*b&h?>xs@h{y}ux+;`{y-6IzOv;22*jDNaAg70iqFU{U?qf=$7zgro
zc?%r%Xdn4zJKDg8ih!iAZmVQUY~!@50obTjkQ^=?BP}5Tx+U23A;h>NjW3L^Y6X%$
z&v3~=+?LwMv^-bw$RLdwfAi)u*j^N2**yN6K|sia%J^NPLM1D8VaNg;4GWV;Ewct+
zIwQOHXJ6g5o?wRP6d;l0HLfce2F@u01b_C^6PBKhvmz)A)U}2$oGE`73kE}8erLXj
zb`_zrS@n@SRxmI>uSzjnwu-XI&*0U*r+0MSt_I|u_$+{YrjFn84<`|A2cwNc<!WhJ
zCN<D4bHrL`U=-+=(?XS^BE<j^$w>Wb!4QB5{zWFlu<8#@77OChtJg8o4`nmcHp}bC
zNJ|(qryB?erE&cC0KD<xA~mMc<o%&~ENHpNpQBLnZsYst{Jo8NY@CVQ)^Fk5Bhe3`
zxQvjlP>VGGUJ}(4#ou?NoAbn|@`x}z840)|wHURbK}#E4L*YhKJ~5#eK4xog*W|9Q
zbf)ZV+?j)00YzP^F<kpSK_JR--7fcbad1rj)px^FxxW`Ae>eG1{~DWIjdjosP4AIT
zlQ{A`*vRv@x}bPp3#xDQzM0)kUxOshAYSUgaM0uVDP|G*;0X4(2VJW7tTf(!WN^*V
zGtbVwZ91|1h|n7(0Sz#C6>+j6*2BDcUf=h}<?)ondZfNSJO1|03x85UZ`}ao6|q=~
zXUPF`x$P6lW7#$R68yq9L+zQt($^xc^%3?ZNvuLUAX2+sz?r-ct4o4AE3Nw!olEQx
zER=3st9MaosDjRIvo~T~G8p(!+aIi&rV6~-$q7ksXNt|nw@zacZE?BQC_s3fTi1K%
zlueYfegs2XH2FT~dmm5ItOjLX4><fVv)D_&c6c$Wtj17rYkn4OhZf^z8qjE#k7rMh
z*wZz1Ykaln%e9H4hyvL`{!Cxy9OCZJNl|cpe0(7pqZG`=?UD-r5iw;<m;!GxtItc2
zqZ{F2m1J)B*KccyLMfK3!PXOndNqCgjvo%;aM7YieMX%P`n;P?=kvoHG$lU`ldH#H
z%VQBtE4ooKTGQ%>;k{lEZIB!(JxRjZZuf2_cW8DM8qj~yZxb!!Tw5XbB^ag!&Q9cV
zD9;u_#FLSC46A(=%1Hub#8!uW>&dV;f+`eGu({!XN*eyM!xe0iq9$2VY_Jzwyo~QN
zCo@<pqs;Mn+zcl4#xcA&8cX6J?jytAL0)B!8K{)I>(u)xN!n~vRDMQuVD^w9qX?qF
zU<s>Br&K;Qg>4KG`X{6>SIF!E%Z@4XdWhe|v!49gVjVG`0o1niv1nPzqraD=y+Dd;
zXB9$c*kQ{)X;E<*TzZ}5f55Y<4t720><(VSuRt2$x@J`Y=Rk9pDNLP`I)xDRSM7b8
ze}gOeQL#)UGjm>?yuPmcBy|}61bIEEF!#u<g`ODI!y`%!Yg>1(bm;}EtSkZ}T!*go
zu-{s&kS@aHe8wSQs@ho<&{sK$yg+pLJ{`~&^&dt>_8+pq+Sm2fhtRAg0-HdlgO~PV
znHJ)vozPd=N}W)0`=na0=lL?UtZmaNZL4*G>Ay?d6WJ&{gNUJwwb~sbga4|MDKZod
z{x(TlAHEW4)i&j9b~v!sSH6_KfM#U^I=c!+zddsNO%EF+BJbGIHp_E=&kvv3J{4iv
z%qsGj$N&fjJwOHr<`b5ITb|4|R&GwDoLgg3>85w~DqM;-^NsbH=>bH{lL@XkcxgbZ
z96~|xCQw%E<vz9>S3LS(_oU<#ciNv7Vs~X<J=?(g#J7{Jc7}>O;SIcb{iEF$skH>C
zf6-;sR(A1!)USo8OE&KS$6>8IKis_PUj=pZdmBiy@+Gr!NIdx_NO7}mxbTJUAcu0U
zRZC(BlCZI6wqcc^sgK_c_#k<-wE8oZ-Zeq{7QtQoqcD7&XPFS2p%f`<*kwH?T3R`G
z3ktq`J2O*zeCh8&D@mLA1c-CqwnzocC2*f>@0y0;-xnAG>pc3lJ=abL+agB&J!&mJ
zA0HX2dM*P9C(m2^%T)JY5oK;<Hej@L*pw70&Oymdr!lnPn@pErw)i1y*hcl>;w3Rz
ziBIpIxKr6ZHV2&dv9j?-;Xvh&^#H7ML-=KJ<=;@G*v5)s3QiLwa{JQ18$jQF^0jO*
zXL(I>!-tV~%0h@fIUpB$QYJ_SDzHR~8uQ)H7$Q_*FFUgN@vFjTP==k@K`gU(GE5Qu
zToBQB4;MesYyZi4C;V1VtQ)|H$?G9XaxTUh_sd~m@r$Ng{#cNrgmF&G0P=*sdjbhL
zVM_TFi4Do9SJ9@xXUdAC4?DLOyI-Y6-j5Gx5InvvnO>EeXCKug!em{l@I9I=zSZuw
z@?V`OQbKGCIG4m_rq|-Ek+C-pN;*9EO2q&>H!s_Y+y(Q`t~)iQgH)lUPHy)iuaxgs
z3>lO;QN3Xb(vw*$J#YodKb`>!*r+@;SjFI%?GXURhDT!$3tct#L)F};C;xmi@)UKr
z_ZTP@28V)m2E!adEsTZp|KLOo19=yrNOBsVH2rG87n>@T+aRrl`VozcI{?H6PBS`I
z_b<EDL||XMFeEKoWq2en!-V@Ri_@mCL%@d8r@s2PXZPG3${L<UE-4m>*ZUGHhl~Y*
zb$Wx(^4^e-dWnq_qdtb?Q|T}%9kT$PFq*hmhcM*pNNwYXOMvP#D}YrC(TN7@#Ht?c
zVY!`w&BE0GC}Rhoatr$)rjm=*-X||iG|)w3obO)Moupg|BUrHA%2F;CLe(qVz!&!x
zm!;^&Ud^+Bu1ogD$CvV@hrj;L(6)Q@p&@>gIU>)*sLZ7{%6mdVddR8S#8xi<xrBa0
zt@%9PlQ-|^B2}HzE_=S*Nz)S3G}-TUpb9iWg7_rzMC%8#GQK87#+W!!_t^77gXKx+
zvd@?eayv7A15bX%o#pLe*)Ck~;eCIWA(T4hgpLG7A;ojGaD;MJG_ZPK<Svi7@FZym
z{UlCI%J%^XK8ZvOUIm)hUQyOK*SUD6i^x%AwJ+gw1hJ*{$Pp|B7jeZPDlIv5tcwfg
z?Re+KTu=Ij(}*?_ozVe4Urd(Cu^LRUPx#emj{hbXqSUSG#du@j@hfNK_|G_=AWCF1
z|6E_%or|46@~X6AcqZ;PTVJC;I+{2Dtm@Eti*0{NVcAEcsq*@}|CkXbt;E)?b7SJ@
zd22pCY&X~kXVScNn3T@#PkW=@(b4A39`;rEEf=;zY1$8zI!!cU`*(tvmLI2p(^U2&
zfyLueSIS#Uj|QLE$mWA#YL{rZrlV)nwq2K(O3|5aaG_{4g7AkUaK=-pu{Qjwd{ZD*
zckAQdn;}Wjf2^LXDYr|kxDlz|k*jTHSE4oAJt<ygGaEKK#~_~I_mAH|jWV-?NS8Bt
z3$Z%J9bA;$IyBKm{2qEd1wc0};Oc>?*FgO@gLzJDrU;u|b&eq#aJp`vh^m`$?L7hd
zshhfRdV(87pg-X*Pq29ZjsKn+tcE@EcMJj;5VIPql;+2UT(+%;@PhaJYOon8iimN|
zpj*&oI4kFt_^Oju2}Ol@OnbAi>j^TpDC2-wi++5yHAgvek8qbjkqpA5dq(+8KOoY^
zU*U`$g;x0H$)VKogIrz2bmG<g^|WQK*M7Pb1>h)vji|4|AU~Q4ZiXy523?zpT{^3m
zSLiEtJbXV>UP{1Rpl$8_<gFcSHwHiS7kT0mKD&2w!B^rXZ1}AB#ntYu?zt<+SR{K~
zt}`|Th#I$U-T1r#t2EXB?AJfQ3CmFwnq;3SBhEm%GFnpH1+w5F&~$AvR!$ST<{m5+
zapHg@Zj1#%?XL#lIFcdn$F)#TKM(ZFw5KLi;qehM3HY$sY)u7(s#+t0@D!`j%fk!{
z_klqXHsPUHBK^=qM<hql6hq`BArnPv5#fi+lU$THpUlW0l&x*avnu&L&Dt~YF^^>H
z6VbzGCU*v!0>bGP3y4tcldmiiRxJZiXKkl5-GnD{rLJu|-}4Vu(wJ)w`M)p*b%S2z
zshL+vC_B5ZBvC1cu&rFz`xo>=*(B&#A4%Gn-C}VX{Nr;BmTi<lwKrrQwvlSH3c}+p
ze~9-iNpofslZUDQ#aui@0BjTvpuPItkB~a5dWA#Pd%#b~Rns+3q}BnD?3&h(3lIss
z6GTw_hA4B;DsgnAG5V!*838#~J!UPu$J`I;U_$_><<JLd|F5{|zVjjY19)ZZ+MSX)
zbm?$_APngWut5Nh#!os{J}8MHG34OsI<|6G1HjuLCLhozj-&BhiY~m<??9qO{;SIh
zsm1>yuzDo8hLQ&C`TC6bzdBqL5S;dOtXx`I!o=-)|0CSL4g?`qfw}G3C#wp0ZtC+-
z{<lXSKv*~c-Ssfq^8Np(nFwgk_4#vW5=3$+(gC$Xasb2%w(KE~yg<vq+!2WFspij4
z+oEaux<IxSQ-E627LHE`3+e$qs_=4pI-Qvq^XB${%yiC&;Cx5N`l|fhZr7FGFRU<i
z5lj$UCzMSA$k|2g8A}q6NB}Vmz#38K55dPFf^a-#=B)AvQ_fQeEc@>d_{t&IA>epb
z*U2Zh`S|{%_Mh0setBCWfrC>3&@3LX8?uo_moWc7UD~)K|A9@|vg0yB1axsvnIqyq
z(wuWbaABLD+APF)2crMmnEJ2raHU&&2WcKWATj~;`5iccER;fm!@=>2L<^~vDqYen
zk$1v~_yU020<a{>Asj#cl-;}I;{8hrS`_-<b`nSzglJOJ+{xHL0W?PkdjudNgiQ%x
znXI6^oT3A$vuUxWyP=P=ft8)P2czO3hLZ6a$-D~vR*wz;#1@bEFAhim`dMn7|H>-J
zpP*gvf3!FEfcmkBCZB%g;WqpS+!$SX0&+rTT=m2+ZT_8D`ova%L74IZ9EH-c8rv*i
zMiA+{L1QESHCD?12N=dLmuDZf(RNUSV8ken?SIRV^~5^RChNlCp*%-VBV9Xbm^uZ3
zRRCWPgy5CGuSr&u7(TH4{pb!L9@s>c0P!nIuH0%xgH22h?A!C-sQ@4a3crb|P5wts
zi3BIO2lD?lu8lN;)02)>UeM`BT86rcq6EId|JraY0=z=`cd@2T%56B91yY~%zq98j
zhO$)r-02H;r!4#Mf+|z{e-M-9W*K-s5`02wSFoZ4mjEIPV*q*p*@ywsl~40M<GfmN
zQxq;C_`mHGkgi^4BaaQdJU>O+0)V?HS_K$>i-??%0T($e2ZXw&<^C&B>YL97{!;qD
zw%!0>lFN>e#3umE8e>%de#H+rk2WxNg+>qoP{Y{b6QNmftH8B5yve8D>{J5^#`^m)
z&)cES0AK)Im;{64t^br%)Cm|V9O7#4l39-L;rv%C098IfWy-%*eF4ia*c?EM(ErCR
zJbL;cu)0h)ljzFJxH)#rV431sYOMdio0J#$u*xdc3-e&Um_mxCJ>m2J`4m_sVLDcD
zh2`$2fME-XWf(jX>^lg3r1c-Oh|xkgEdP`-wi&@BwF6c3pA!OO%xyRU!g_!!uMQgY
zvFoJ$JNfiHH1aFB+u^_dP6$yz1L0_=DY<v|hYfSo#B)FdZ^Kf~UH1Lw@&pk`u#)(j
zD$Csv70zJ=gUmA!Cty|HE~vBreB%j%BPCO4K${p^Bzk9dmFng2ka+6du_T;XzrAZQ
z7yz5Izo|X~^o!_`r*d!}ry9WR9}1Ru;3pffo0eqKBW;WmwVEUhK--xZLHnFW^Go%1
zW3fsuOi}q$&cA09Gq3h8WfpL>d~JJEhpTxpcc2^XiTG(%#MgkLH0>MfH2S7)ab*gH
zx}%qxXX>I8o!$itI*;Q|iURbUzbtyz6amQy4JICrf{o)QF&!XL#Bs{=zz{e-#_i=G
z6TN!Mr=JXg3RspT4mKo&p~mtigcj5+SpBy?y=RFAr0^1nEsl6mb!U@3I+xdS>ah16
zhKnyY{8en#0{0++M+QABge~$oD+x=dfe6^lf7x_MmttX)Yh1<OeWtSTai}06@s*al
z_b_1M*6i`837v7vgcxB^DLqVz9=6E6Ca)K=mwee%ekUy}h{FU4F*ODNxCk=!nIJeF
z<Sd|rasQx_1Qb)U9aTiS8_r#iU^Ts&HVDUKFX{qi(Inq}zaa_adXJJ@t=ea&<vunE
z`btm$TqdebYD3i<lrpM6{&KjP^%$NjkNyFHc3TB%J)X9GkKJxv5umJDOO~j$rUNen
zui=NO(}W|J{6Iv3k)h+}^f%vr+(S~l2-F%FoU;tTwX7uZ+1|)csZtrFE^?8_E(I#V
z=OMQ8h*qJ<he~X+lI|0INlb6yzj=Wt5vc=cR;OiS&~VJAc=p5}v)xM*K?u0PC`g<b
zb?&`IOpa6gJWc^}sWr!!no+Y@^OI3r@e>m+zHQg92@wyF5yO>-ZLH7_B^knD!_lB@
zZ*kVrRi{Cy;wp6tBWzLmkQQ<+RB3pg{I5PgQO=3-0iJ8r;}qw;0UxOEEUv4(w^}$u
zrI(kqW=oQ_AL`e=KxQ5i4xJzr!Uo0(9k$Y+w+5itNgh80o{nq>3Hv+@q@K8Y+uWGr
zR~?dlN3`^W)4Qn8oEQ~C{X#bt<OMDoUJD(p<SOpDZCZv<e8Yo;R1VCaoL<4#AAWe*
zofqKMcmttSvB2>r)WY6m1CycdkbOV3N-6`B=2~jq`4n6<%mJ$#H0_gIS%X}Q?yUOy
z>zK$%jq{64(yU(D!KHc1Jz~Q8?6^JWbR0gI`~gf^)MU<hrXoDdqAe{1?=$@4SPvXI
z6#*Kr|BztZHmn{{ZQ--`!jI|TvD$qVpwl1)r8Odm?;C;z?ay_5JeRfV9bv%L#y=rA
z|0Aa(P-^fw``)sy3(A<x2+)`CDZ4h4WPpXk*I7fEUq?u(TiwI%W`ph!W$Jq?clnYS
zrGnlB4+Kn%J>%_Gr6f`m$_Od#d<LW}8`!&_MLhhtO^H=<)<~uhQ3O2sA>&(iOC;B}
zG&Q%Otz8H^MTSYUa@<4Iv}nI#Ppq995Q4D2uAz-?10juGKD5+-drp0>iJ<P8)u*PK
z=D<xoHGke3(fbey{B18A&Qkne`1I@lm$z*fcVH0c?k-uUNN?Df#0z-l2YRHUiTJK$
H8T|hMTHCz{

literal 0
HcmV?d00001

diff --git a/samples/Generators.Sandbox/Assets/Strings.xaml b/samples/Generators.Sandbox/Assets/Strings.xaml
new file mode 100644
index 0000000000..b979094031
--- /dev/null
+++ b/samples/Generators.Sandbox/Assets/Strings.xaml
@@ -0,0 +1,6 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+  <x:String x:Key="WelcomeMessage">Welcome to the application!</x:String>
+
+</ResourceDictionary>
diff --git a/samples/Generators.Sandbox/Generators.Sandbox.csproj b/samples/Generators.Sandbox/Generators.Sandbox.csproj
index 2654e1b5b6..22ea309db2 100644
--- a/samples/Generators.Sandbox/Generators.Sandbox.csproj
+++ b/samples/Generators.Sandbox/Generators.Sandbox.csproj
@@ -7,9 +7,11 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <AvaloniaXaml Include="**\*.xaml"/>
-    <!-- Note this AdditionalFiles directive. -->
-    <AdditionalFiles Include="**\*.xaml" SourceItemGroup="AvaloniaXaml" />
+    <AvaloniaXaml Include="**\*.xaml" />
+
+    <AvaloniaResource Include="Assets\*" />
+    <!-- Test Strings.xaml as a resource only, not a compiled XAML -->
+    <AvaloniaXaml Remove="Assets\Strings.xaml" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/tools/Avalonia.Generators/Avalonia.Generators.props b/src/tools/Avalonia.Generators/Avalonia.Generators.props
index 3712b390ee..5cd17b1f6a 100644
--- a/src/tools/Avalonia.Generators/Avalonia.Generators.props
+++ b/src/tools/Avalonia.Generators/Avalonia.Generators.props
@@ -23,5 +23,6 @@
     <CompilerVisibleProperty Include="AvaloniaUseCompiledBindingsByDefault" />
     <CompilerVisibleProperty Include="AvaloniaMainPackageVersion" />
     <CompilerVisibleProperty Include="AvaloniaPreviewerNetCoreToolPath" />
+    <CompilerVisibleProperty Include="AvaloniaResourcePaths" />
   </ItemGroup>
 </Project>

From a6dbeb7d9cbe50bcbc978c0b2485036f6134e208 Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Wed, 8 Jul 2026 19:20:55 +0800
Subject: [PATCH 079/196] Fix empty automation bounds for custom root providers
 (#21730)

* Add AutomationPeer.ToScreen so each peer converts its own bounding rectangle to screen coordinates, fixing empty UIA bounds for root providers that are not ControlAutomationPeers.

* Update AutomationPeer.cs

* Update AutomationPeer.cs
---
 .../Automation/Peers/AutomationPeer.cs        | 13 ++++++++++
 .../Automation/Peers/ControlAutomationPeer.cs |  7 ++++++
 .../AutomationNode.cs                         | 14 +----------
 .../Automation/ControlAutomationPeerTests.cs  | 25 +++++++++++++++++++
 4 files changed, 46 insertions(+), 13 deletions(-)

diff --git a/src/Avalonia.Controls/Automation/Peers/AutomationPeer.cs b/src/Avalonia.Controls/Automation/Peers/AutomationPeer.cs
index b28d445443..9fb8f4026d 100644
--- a/src/Avalonia.Controls/Automation/Peers/AutomationPeer.cs
+++ b/src/Avalonia.Controls/Automation/Peers/AutomationPeer.cs
@@ -420,6 +420,17 @@ namespace Avalonia.Automation.Peers
         [PrivateApi]
         public AutomationPeer? GetAutomationRoot() => GetAutomationRootCore();
 
+        /// <summary>
+        /// Converts a rectangle in the peer's coordinate space, as returned by
+        /// <see cref="GetBoundingRectangle"/>, to screen coordinates; returns null if the peer is
+        /// not currently hosted in a rendered visual tree.
+        /// </summary>
+        /// <param name="rect">
+        /// A rectangle in the peer's own coordinate space, as returned by
+        /// <see cref="GetBoundingRectangle"/>.
+        /// </param>
+        public Rect? ToScreen(Rect rect) => ToScreenCore(rect);
+
         /// <summary>
         /// Gets a value that indicates whether the element that is associated with this automation
         /// peer currently has keyboard focus.
@@ -669,6 +680,8 @@ namespace Avalonia.Automation.Peers
 
         private protected virtual AutomationPeer? GetVisualRootCore() => GetAutomationRootCore();
 
+        private protected virtual Rect? ToScreenCore(Rect rect) => null;
+
 
         protected virtual bool IsContentElementOverrideCore()
         {
diff --git a/src/Avalonia.Controls/Automation/Peers/ControlAutomationPeer.cs b/src/Avalonia.Controls/Automation/Peers/ControlAutomationPeer.cs
index c4128465b7..24f143f408 100644
--- a/src/Avalonia.Controls/Automation/Peers/ControlAutomationPeer.cs
+++ b/src/Avalonia.Controls/Automation/Peers/ControlAutomationPeer.cs
@@ -155,6 +155,13 @@ namespace Avalonia.Automation.Peers
             return null;
         }
 
+        private protected override Rect? ToScreenCore(Rect rect)
+        {
+            if (Owner?.PresentationSource?.RootVisual is not { } root)
+                return null;
+            return new PixelRect(root.PointToScreen(rect.TopLeft), root.PointToScreen(rect.BottomRight)).ToRect(1);
+        }
+
         /// <summary>
         /// Invalidates the peer's children and causes a re-read from <see cref="GetChildrenCore"/>.
         /// </summary>
diff --git a/src/Windows/Avalonia.Win32.Automation/AutomationNode.cs b/src/Windows/Avalonia.Win32.Automation/AutomationNode.cs
index 1c0236e8c0..d5b0a84179 100644
--- a/src/Windows/Avalonia.Win32.Automation/AutomationNode.cs
+++ b/src/Windows/Avalonia.Win32.Automation/AutomationNode.cs
@@ -11,7 +11,6 @@ using Avalonia.Automation;
 using Avalonia.Automation.Peers;
 using Avalonia.Controls.Automation.Peers;
 using Avalonia.Threading;
-using Avalonia.VisualTree;
 using Avalonia.Win32.Automation.Interop;
 using AAP = Avalonia.Automation.Provider;
 using UIA = Avalonia.Win32.Automation.Interop;
@@ -76,18 +75,7 @@ namespace Avalonia.Win32.Automation
 
         public virtual Rect GetBoundingRectangle()
         {
-            return InvokeSync(() =>
-            {
-                if (Peer.GetVisualRoot() is ControlAutomationPeer root &&
-                    root.Owner.GetPresentationSource() is not null)
-                {
-                    var originalRect = Peer.GetBoundingRectangle();
-                    return new PixelRect(root.Owner.PointToScreen(originalRect.TopLeft),
-                        root.Owner.PointToScreen(originalRect.BottomRight)).ToRect(1);
-                }
-
-                return default;
-            });
+            return InvokeSync(() => Peer.ToScreen(Peer.GetBoundingRectangle()) ?? default);
         }
 
         public virtual IRawElementProviderFragmentRoot? GetFragmentRoot()
diff --git a/tests/Avalonia.Controls.UnitTests/Automation/ControlAutomationPeerTests.cs b/tests/Avalonia.Controls.UnitTests/Automation/ControlAutomationPeerTests.cs
index 7ba9ff4fdb..41aa697237 100644
--- a/tests/Avalonia.Controls.UnitTests/Automation/ControlAutomationPeerTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Automation/ControlAutomationPeerTests.cs
@@ -232,6 +232,31 @@ namespace Avalonia.Controls.UnitTests.Automation
             }
         }
 
+        public class ToScreen : ScopedTestBase
+        {
+            [Fact]
+            public void Converts_Rect_When_Attached_To_Rooted_Tree()
+            {
+                var border = new Border();
+                var root = new TestRoot(border);
+                var peer = CreatePeer(border);
+
+                Assert.Equal(new Rect(10, 20, 30, 40), peer.ToScreen(new Rect(10, 20, 30, 40)));
+            }
+
+            [Fact]
+            public void Returns_Null_When_Detached()
+            {
+                var border = new Border();
+                var root = new TestRoot(border);
+                var peer = CreatePeer(border);
+
+                root.Child = null;
+
+                Assert.Null(peer.ToScreen(new Rect(10, 20, 30, 40)));
+            }
+        }
+
         private static AutomationPeer CreatePeer(Control control)
         {
             return ControlAutomationPeer.CreatePeerForElement(control);

From b451fc7a413c37bcc1a24f2a2824695092942d6a Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Thu, 9 Jul 2026 12:20:42 +0200
Subject: [PATCH 080/196] Fix AvaloniaView double root creation on Android
 (#21738)

---
 src/Android/Avalonia.Android/AvaloniaView.cs | 41 +++-----------------
 1 file changed, 5 insertions(+), 36 deletions(-)

diff --git a/src/Android/Avalonia.Android/AvaloniaView.cs b/src/Android/Avalonia.Android/AvaloniaView.cs
index cec520acb7..a5a45be61a 100644
--- a/src/Android/Avalonia.Android/AvaloniaView.cs
+++ b/src/Android/Avalonia.Android/AvaloniaView.cs
@@ -20,12 +20,10 @@ namespace Avalonia.Android
     public partial class AvaloniaView : FrameLayout
     {
         private EmbeddableControlRoot? _root;
-        private ExploreByTouchHelper? _accessHelper;
-
         private readonly ViewImpl _view;
+        private readonly ExploreByTouchHelper _accessHelper;
 
         private IDisposable? _timerSubscription;
-        private object? _content;
         private bool _surfaceCreated;
 
         public AvaloniaView(Context context) : base(context)
@@ -34,8 +32,6 @@ namespace Avalonia.Android
 
             AddView(_view.View);
 
-            this.SetBackgroundColor(global::Android.Graphics.Color.Transparent);
-
             _root = new EmbeddableControlRoot(_view);
             _root.Prepare();
 
@@ -73,47 +69,20 @@ namespace Avalonia.Android
 
         public object? Content
         {
-            get { return _root?.Content; }
-            set
-            {
-                _content = value;
-                if (_root != null)
-                    _root.Content = value;
-            }
+            get => _root?.Content;
+            set => _root?.Content = value;
         }
 
         internal new void Dispose()
         {
-            _root?.Dispose();
-            _root = null;
-            _content = null;
-        }
-
-        protected override void OnDetachedFromWindow()
-        {
-            base.OnDetachedFromWindow();
             OnVisibilityChanged(false);
             _surfaceCreated = false;
-
-            if (_accessHelper is { } accessHelper)
-            {
-                ViewCompat.SetAccessibilityDelegate(this, null);
-                _accessHelper = null;
-            }
+            _root?.Dispose();
+            _root = null;
         }
 
         protected override void OnAttachedToWindow()
         {
-            _root?.Content = null;
-            _root = new EmbeddableControlRoot(_view);
-            _root.Prepare();
-            if (_content != null)
-            {
-                _root.Content = _content;
-            }
-
-            _accessHelper = new AvaloniaAccessHelper(this);
-            ViewCompat.SetAccessibilityDelegate(this, _accessHelper);
             SendConfigurationChanged(Context?.Resources?.Configuration);
 
             base.OnAttachedToWindow();

From e8a82f113c8798e7067b862da96259516a52f169 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Thu, 9 Jul 2026 15:57:53 +0200
Subject: [PATCH 081/196] Bump development version to 12.2

---
 build/SharedVersion.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build/SharedVersion.props b/build/SharedVersion.props
index cff9a24f54..2a4e07c3d2 100644
--- a/build/SharedVersion.props
+++ b/build/SharedVersion.props
@@ -2,7 +2,7 @@
   xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <Product>Avalonia</Product>
-    <Version>12.1.999</Version>
+    <Version>12.2.999</Version>
     <Authors>Avalonia Team</Authors>
     <Copyright>Copyright 2013-$([System.DateTime]::Now.ToString(`yyyy`)) &#169; The AvaloniaUI Project</Copyright>
     <PackageProjectUrl>https://avaloniaui.net/?utm_source=nuget&amp;utm_medium=referral&amp;utm_content=project_homepage_link</PackageProjectUrl>

From fc9679491a1a395a6c24316a3bbbf24336bab85f Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Thu, 9 Jul 2026 20:53:48 +0500
Subject: [PATCH 082/196] Fixes a dispatcher bug that loses background
 processing state if jobs were submitted before ReplaceImplementation (#21735)

---
 src/Avalonia.Base/Threading/Dispatcher.cs     |  3 ++
 .../DispatcherTests.cs                        | 32 +++++++++++++++++++
 2 files changed, 35 insertions(+)

diff --git a/src/Avalonia.Base/Threading/Dispatcher.cs b/src/Avalonia.Base/Threading/Dispatcher.cs
index 4f3acc5d02..04ea63e9e4 100644
--- a/src/Avalonia.Base/Threading/Dispatcher.cs
+++ b/src/Avalonia.Base/Threading/Dispatcher.cs
@@ -162,6 +162,9 @@ public partial class Dispatcher : IDispatcher
             _backgroundProcessingImpl.ReadyForBackgroundProcessing += OnReadyForExplicitBackgroundProcessing;
         if (_signaled)
             _impl.Signal();
+        if (_explicitBackgroundProcessingRequested) 
+            _backgroundProcessingImpl?.RequestBackgroundProcessing();
+            
         _osTimerSetTo = null;
         UpdateOSTimer();
     }
diff --git a/tests/Avalonia.Base.UnitTests/DispatcherTests.cs b/tests/Avalonia.Base.UnitTests/DispatcherTests.cs
index 03c8133b74..d4e39d34b6 100644
--- a/tests/Avalonia.Base.UnitTests/DispatcherTests.cs
+++ b/tests/Avalonia.Base.UnitTests/DispatcherTests.cs
@@ -151,6 +151,38 @@ public partial class DispatcherTests
         Assert.Equal(new[] { "PromotedRender", "PromotedRender2", "Render" }, actions);
     }
 
+    [Fact]
+    public void DispatcherRepeatsBackgroundProcessingRequestToTheNewImplementation()
+    {
+        var actions = new List<string>();
+
+        // Requests background processing from the pre-initialization implementation
+        _uiThread.Post(() => actions.Add("Background"), DispatcherPriority.Background);
+
+        var impl = new SimpleDispatcherWithBackgroundProcessingImpl();
+        Dispatcher.InitializeUIThreadDispatcher(impl);
+
+        Assert.True(impl.AskedForBackgroundProcessing);
+        impl.FireBackgroundProcessing();
+        Assert.Equal(new[] { "Background" }, actions);
+    }
+
+    [Fact]
+    public void DispatcherRepeatsSignalToTheNewImplementation()
+    {
+        var actions = new List<string>();
+
+        // Signals the pre-initialization implementation
+        _uiThread.Post(() => actions.Add("Render"), DispatcherPriority.Render);
+
+        var impl = new SimpleDispatcherWithBackgroundProcessingImpl();
+        Dispatcher.InitializeUIThreadDispatcher(impl);
+
+        Assert.True(impl.AskedForSignal);
+        impl.ExecuteSignal();
+        Assert.Equal(new[] { "Render" }, actions);
+    }
+
     [Fact]
     public void DispatcherStopsItemProcessingWhenInteractivityDeadlineIsReached()
     {

From 59355cb58d825833ebdd2c84a4948a60caad61f7 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Fri, 10 Jul 2026 15:25:33 +0500
Subject: [PATCH 083/196] Added UseWaylandWithFallback to opt-in for wayland
 support (#21734)

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 samples/ControlCatalog.Desktop/Program.cs     |  1 +
 .../AvaloniaWaylandPlatformExtensions.cs      | 37 +++++++++++
 .../Server/Interop/WakeupFd.cs                |  4 +-
 src/Avalonia.Wayland/Server/WaylandWorker.cs  | 52 +++++++++++----
 src/Avalonia.Wayland/WaylandPlatform.cs       | 66 +++++++++++++------
 5 files changed, 128 insertions(+), 32 deletions(-)

diff --git a/samples/ControlCatalog.Desktop/Program.cs b/samples/ControlCatalog.Desktop/Program.cs
index 1f553d116e..9be5c7ad52 100644
--- a/samples/ControlCatalog.Desktop/Program.cs
+++ b/samples/ControlCatalog.Desktop/Program.cs
@@ -142,6 +142,7 @@ namespace ControlCatalog.Desktop
         public static AppBuilder BuildAvaloniaApp()
             => AppBuilder.Configure<App>()
                 .UsePlatformDetect()
+                .UseWaylandWithFallback()
                 .With(new X11PlatformOptions
                 {
                     EnableMultiTouch = true,
diff --git a/src/Avalonia.Wayland/AvaloniaWaylandPlatformExtensions.cs b/src/Avalonia.Wayland/AvaloniaWaylandPlatformExtensions.cs
index b0152b8422..6edafe3292 100644
--- a/src/Avalonia.Wayland/AvaloniaWaylandPlatformExtensions.cs
+++ b/src/Avalonia.Wayland/AvaloniaWaylandPlatformExtensions.cs
@@ -1,3 +1,5 @@
+using System;
+using Avalonia.Logging;
 using Avalonia.Wayland;
 
 // UseXxx are deliberately in global Avalonia namespace
@@ -25,4 +27,39 @@ public static class AvaloniaWaylandPlatformExtensions
         return builder;
     }
 
+    /// <summary>
+    /// Configures the application to use the Wayland windowing backend when a usable Wayland
+    /// compositor is available, falling back to the previously configured windowing backend
+    /// otherwise. Call it after <c>UseX11</c> or <c>UsePlatformDetect</c>, e. g.
+    /// <c>.UsePlatformDetect().UseWaylandWithFallback()</c>. Does nothing on non-Linux platforms.
+    /// </summary>
+    /// <param name="builder">The application builder.</param>
+    /// <returns>The same <paramref name="builder"/> for chaining.</returns>
+    /// <exception cref="InvalidOperationException">
+    /// No windowing backend was configured prior to this call (on Linux).
+    /// </exception>
+    public static AppBuilder UseWaylandWithFallback(this AppBuilder builder)
+    {
+        if (!OperatingSystem.IsLinux())
+            return builder;
+
+        var fallback = builder.WindowingSubsystemInitializer
+            ?? throw new InvalidOperationException(
+                "A fallback windowing backend must be configured before calling UseWaylandWithFallback, " +
+                "e.g. via UseX11 or UsePlatformDetect.");
+
+        return builder
+            .UseStandardRuntimePlatformSubsystem()
+            .UseWindowingSubsystem(() =>
+            {
+                var error = WaylandPlatform.TryInitialize(
+                    AvaloniaLocator.Current.GetService<WaylandPlatformOptions>() ?? new WaylandPlatformOptions());
+                if (error != null)
+                {
+                    Logger.TryGet(LogEventLevel.Warning, LogArea.Platform)?.Log(null,
+                        "Unable to initialize the Wayland backend, falling back: {Error}", error.SourceException);
+                    fallback();
+                }
+            });
+    }
 }
\ No newline at end of file
diff --git a/src/Avalonia.Wayland/Server/Interop/WakeupFd.cs b/src/Avalonia.Wayland/Server/Interop/WakeupFd.cs
index 67afd24aa3..a65425401b 100644
--- a/src/Avalonia.Wayland/Server/Interop/WakeupFd.cs
+++ b/src/Avalonia.Wayland/Server/Interop/WakeupFd.cs
@@ -28,7 +28,7 @@ unsafe class WakeupFd : System.IDisposable
     {
         lock (_lock)
         {
-            if(!_signaled)
+            if(_disposed || !_signaled)
                 return;
             var readNow = read(_read, s_readBuf, 1);
             Debug.Assert(readNow <= 1);
@@ -40,7 +40,7 @@ unsafe class WakeupFd : System.IDisposable
     {
         lock (_lock)
         {
-            if(_signaled)
+            if(_disposed || _signaled)
                 return;
             byte b = 0;
             write(_write, &b, 1);
diff --git a/src/Avalonia.Wayland/Server/WaylandWorker.cs b/src/Avalonia.Wayland/Server/WaylandWorker.cs
index c6712efa34..7bfbd5e505 100644
--- a/src/Avalonia.Wayland/Server/WaylandWorker.cs
+++ b/src/Avalonia.Wayland/Server/WaylandWorker.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.ExceptionServices;
 using System.Threading;
 using System.Threading.Tasks;
 using Avalonia.Logging;
@@ -113,12 +114,26 @@ partial class WaylandWorker
         return tcs.Task;
     }
 
-    void Run(WaylandPlatformOptions options, WaylandConnection connection)
+    void Run(WaylandPlatformOptions options, WaylandConnection connection,
+        TaskCompletionSource<ExceptionDispatchInfo?>? initTcs)
     {
         var reconnectsDisabled = options.EnableReconnects == false || options.DisplayFd.HasValue;
         while (true)
         {
-            RunConnection(connection, options);
+            try
+            {
+                RunConnection(connection, options, initTcs);
+            }
+            catch (Exception e) when (initTcs?.Task.IsCompleted == false)
+            {
+                // Globals init failed on the initial connection: report to the waiting caller
+                // and exit without entering the reconnect loop
+                initTcs.TrySetResult(ExceptionDispatchInfo.Capture(e));
+                connection.Dispose();
+                _wakeupFd.Dispose();
+                return;
+            }
+            initTcs = null;
             foreach (var obj in _persistentObjects.ToList())
                 obj.OnDisconnected();
             Compositor.Server.ResetAllGpuResources();
@@ -160,11 +175,15 @@ partial class WaylandWorker
         }
     }
     
-    void RunConnection(WaylandConnection connection, WaylandPlatformOptions options)
+    void RunConnection(WaylandConnection connection, WaylandPlatformOptions options,
+        TaskCompletionSource<ExceptionDispatchInfo?>? initTcs = null)
     {
         _thread = Thread.CurrentThread;
         _connection = connection;
         _globals = new WaylandGlobals(_connection, this, options, _outputsSink);
+        // Globals are fully constructed (required globals bound, sanity checks passed),
+        // the display is deemed usable
+        initTcs?.TrySetResult(null);
 
         foreach (var obj in _persistentObjects)
             ConnectPersistentObject(obj);
@@ -229,8 +248,11 @@ partial class WaylandWorker
         }
     }
     
-    public static WaylandConnection? Probe(WaylandPlatformOptions options)
+    public static WaylandConnection? Probe(WaylandPlatformOptions options) => Probe(options, out _);
+
+    public static WaylandConnection? Probe(WaylandPlatformOptions options, out ExceptionDispatchInfo? error)
     {
+        error = null;
         try
         {
             var conn = options.DisplayFd is { } fd
@@ -243,30 +265,38 @@ partial class WaylandWorker
         catch(Exception e)
         {
             Logger.TryGet(LogEventLevel.Error, "Wayland")?.Log(null, "Failed to connect to Wayland display: " + e);
+            error = ExceptionDispatchInfo.Capture(e);
             return null;
         }
     }
 
+    /// <summary>
+    /// Starts the worker on a probed connection. When <paramref name="initTcs"/> is provided, it completes
+    /// with <c>null</c> once the initial <see cref="WaylandGlobals"/> construction succeeds, or with the
+    /// captured failure, in which case the worker thread exits without reconnecting.
+    /// </summary>
     public void Start(WaylandPlatformOptions options, WaylandConnection probedConnection,
-        WaylandOutputsSinkProxy? outputsSink = null)
+        WaylandOutputsSinkProxy? outputsSink = null,
+        TaskCompletionSource<ExceptionDispatchInfo?>? initTcs = null)
     {
         _outputsSink = outputsSink;
-        StartCore(options, probedConnection, null);
+        StartCore(options, probedConnection, null, initTcs);
     }
-    
+
     public void Start(WaylandPlatformOptions options, WlDisplay foreignDisplay,
         WaylandOutputsSinkProxy? outputsSink = null)
     {
         _outputsSink = outputsSink;
-        StartCore(options, null, foreignDisplay);
+        StartCore(options, null, foreignDisplay, null);
     }
-    
-    void StartCore(WaylandPlatformOptions options, WaylandConnection? probedConnection, WlDisplay? foreignDisplay)
+
+    void StartCore(WaylandPlatformOptions options, WaylandConnection? probedConnection, WlDisplay? foreignDisplay,
+        TaskCompletionSource<ExceptionDispatchInfo?>? initTcs)
     {
         new Thread(() =>
         {
             if(probedConnection!=null)
-                Run(options, probedConnection);
+                Run(options, probedConnection, initTcs);
             else if (foreignDisplay != null)
             {
                 RunConnection(new WaylandConnection(foreignDisplay), options);
diff --git a/src/Avalonia.Wayland/WaylandPlatform.cs b/src/Avalonia.Wayland/WaylandPlatform.cs
index 01e608ef92..95e0f22a84 100644
--- a/src/Avalonia.Wayland/WaylandPlatform.cs
+++ b/src/Avalonia.Wayland/WaylandPlatform.cs
@@ -1,4 +1,7 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Runtime.ExceptionServices;
+using System.Threading.Tasks;
 using Avalonia.Controls.Platform;
 using Avalonia.FreeDesktop;
 using Avalonia.Input;
@@ -16,32 +19,55 @@ namespace Avalonia.Wayland;
 class WaylandPlatform
 {
 
-    public static void Initialize(WaylandPlatformOptions options)
+    public static void Initialize(WaylandPlatformOptions options) => TryInitialize(options)?.Throw();
+
+    internal static ExceptionDispatchInfo? TryInitialize(WaylandPlatformOptions options)
     {
-        var connection = WaylandWorker.Probe(options);
+        // In some cases we aren't allowed to open multiple connections (e. g. WAYLAND_SOCKET env
+        // is used), so we can't do separate usability checks and bail before doing any initialization.
+        // Instead we do full startup sequence with WaylandWorker on compositor thread and wait for it
+        // to get to  WaylandGlobals, which is the point where we can make an informed decision
+        // about wl_display being usable.
+
+        var connection = WaylandWorker.Probe(options, out var connectError);
         if (connection == null)
-            throw new AvaloniaWaylandException("Unable to connect to Wayland display");
-        // TODO: wait for globals to be ready on the wayland thread and perform sanity checks too.
-        // This is needed for UsePlatformDetect() in Avalonia.Desktop: if we detect a compositor we
-        // can't support we should fail here so the caller can fall back to X11. Later we'll also want
-        // feature-detection flags (e.g. xdg-toplevel-drag-v1 for docks) so apps can request features
-        // that force an X11 fallback when the compositor lacks them.
+            return connectError?.SourceException is AvaloniaWaylandException
+                ? connectError
+                : ExceptionDispatchInfo.Capture(
+                    new AvaloniaWaylandException("Unable to connect to Wayland display",
+                        connectError?.SourceException));
 
-        var inputDispatchQueue = new AutomaticRawEventGrouperDispatchQueue();
-        IDispatcherImpl dispatcherImpl = options.UseGLibMainLoop
-            ? new WaylandGlibDispatcher(options.ExternalGLibMainLoopExceptionLogger)
-            : new ManagedDispatcherImpl(null);
-        Dispatcher.InitializeUIThreadDispatcher(dispatcherImpl);
-        
-        var worker = new WaylandWorker(inputDispatchQueue);
+        WaylandWorker worker;
+        SnapshotScreensImpl screens;
+        TaskCompletionSource<ExceptionDispatchInfo?> initTcs;
+        try
+        {
+            // NOTE: This technically mutates the global state since it touches Dispatcher,
+            // which designates the current thread as the UI one in static ctor, but it's generally safe to do
+            var inputDispatchQueue = new AutomaticRawEventGrouperDispatchQueue();
 
-        var screens = new SnapshotScreensImpl();
-        var screensProxy = new WaylandOutputsSinkProxy(screens, WaylandMarshallers.UIThread);
+            worker = new WaylandWorker(inputDispatchQueue);
 
-        worker.Start(options, connection, screensProxy);
+            screens = new SnapshotScreensImpl();
+            var screensProxy = new WaylandOutputsSinkProxy(screens, WaylandMarshallers.UIThread);
 
+            initTcs = new TaskCompletionSource<ExceptionDispatchInfo?>(TaskCreationOptions.RunContinuationsAsynchronously);
+            worker.Start(options, connection, screensProxy, initTcs);
+        }
+        catch (Exception e)
+        {
+            connection.Dispose();
+            return ExceptionDispatchInfo.Capture(e);
+        }
 
+        if (initTcs.Task.GetAwaiter().GetResult() is { } initError)
+            return initError;
 
+        IDispatcherImpl dispatcherImpl = options.UseGLibMainLoop
+            ? new WaylandGlibDispatcher(options.ExternalGLibMainLoopExceptionLogger)
+            : new ManagedDispatcherImpl(null);
+        Dispatcher.InitializeUIThreadDispatcher(dispatcherImpl);
+        
         var clipboardImpl = new WaylandClipboardImpl(worker);
         var clipboard = new Input.Platform.Clipboard(clipboardImpl);
 
@@ -61,5 +87,7 @@ class WaylandPlatform
             .Bind<IMountedVolumeInfoProvider>().ToConstant(new LinuxMountedVolumeInfoProvider())
             .Bind<IPlatformIconLoader>().ToConstant(new X11IconLoader())
             .Bind<IScreenImpl>().ToConstant(screens);
+
+        return null;
     }
 }
\ No newline at end of file

From 4862e605f10f0362aa416fd7115e46f9f0ce919b Mon Sep 17 00:00:00 2001
From: Isabelle Santin <isabelle@chosenfewsoftware.com>
Date: Fri, 10 Jul 2026 03:38:04 -0700
Subject: [PATCH 084/196] Fix: BuildToNuGetCache target should not open
 duplicate file handles (#21745)

---
 nukebuild/Build.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/nukebuild/Build.cs b/nukebuild/Build.cs
index 438da98d05..0cff8fa18c 100644
--- a/nukebuild/Build.cs
+++ b/nukebuild/Build.cs
@@ -456,9 +456,10 @@ partial class Build : NukeBuild
             
             foreach (var path in Parameters.NugetRoot.GlobFiles("*.nupkg"))
             {
+                var packageId = SbomGenerator.ReadPackageId(path);
+
                 using var f = File.Open(path.ToString(), FileMode.Open, FileAccess.Read);
                 using var zip = new ZipArchive(f, ZipArchiveMode.Read);
-                var packageId = SbomGenerator.ReadPackageId(path);
 
                 var packagePath = Path.Combine(
                     globalPackagesFolder,

From cc08405da9511bd554308eeeab8c7b63f598bbc3 Mon Sep 17 00:00:00 2001
From: Alexander Marek <gentledepp@gmail.com>
Date: Fri, 10 Jul 2026 12:46:30 +0200
Subject: [PATCH 085/196] @ (#21741)

#21740 - SplitView must not steal BackRequested when its pane is closed

When the SplitView is in Overlay or CompactOverlay mode it handled the
TopLevel.BackRequested event even if its pane was not open, which broke
system back navigation. Now it only closes the pane and marks the event
handled when the pane is actually open; otherwise the event bubbles on.

Adds unit tests covering both overlay modes.
@

Co-authored-by: alexander.marek <alexander.marek@opti-q.com>
---
 src/Avalonia.Controls/SplitView/SplitView.cs  |  3 ++
 .../SplitViewTests.cs                         | 37 +++++++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/src/Avalonia.Controls/SplitView/SplitView.cs b/src/Avalonia.Controls/SplitView/SplitView.cs
index 14054d183f..ee44f2fbec 100644
--- a/src/Avalonia.Controls/SplitView/SplitView.cs
+++ b/src/Avalonia.Controls/SplitView/SplitView.cs
@@ -598,6 +598,9 @@ namespace Avalonia.Controls
             if (!IsInOverlayMode())
                 return;
 
+            if (!IsPaneOpen)
+                return;
+
             SetCurrentValue(IsPaneOpenProperty, false);
             e.Handled = true;
         }
diff --git a/tests/Avalonia.Controls.UnitTests/SplitViewTests.cs b/tests/Avalonia.Controls.UnitTests/SplitViewTests.cs
index ad2dffc7bb..6beaf8c0f6 100644
--- a/tests/Avalonia.Controls.UnitTests/SplitViewTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/SplitViewTests.cs
@@ -284,6 +284,43 @@ namespace Avalonia.Controls.UnitTests
             Assert.True(splitView.IsPaneOpen);
         }
 
+        [Theory]
+        [InlineData(SplitViewDisplayMode.Overlay)]
+        [InlineData(SplitViewDisplayMode.CompactOverlay)]
+        public void Top_Level_Back_Requested_Should_Not_Be_Handled_When_Pane_Is_Closed(SplitViewDisplayMode displayMode)
+        {
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow
+                .With(globalClock: new MockGlobalClock()));
+            var wnd = new Window
+            {
+                Width = 1280,
+                Height = 720
+            };
+            var splitView = new SplitView
+            {
+                DisplayMode = displayMode
+            };
+            wnd.Content = splitView;
+            wnd.Show();
+
+            // Pane is closed: the SplitView must ignore the event so back navigation can proceed.
+            Assert.False(splitView.IsPaneOpen);
+
+            var closedArgs = new Interactivity.RoutedEventArgs(TopLevel.BackRequestedEvent);
+            wnd.RaiseEvent(closedArgs);
+
+            Assert.False(closedArgs.Handled);
+
+            // Pane is open: the SplitView should close it and handle the event.
+            splitView.IsPaneOpen = true;
+
+            var openArgs = new Interactivity.RoutedEventArgs(TopLevel.BackRequestedEvent);
+            wnd.RaiseEvent(openArgs);
+
+            Assert.True(openArgs.Handled);
+            Assert.False(splitView.IsPaneOpen);
+        }
+
         [Fact]
         public void With_Default_IsPaneOpen_Value_Should_Have_Closed_Pseudo_Class_Set()
         {

From c00a2f23750a2a5e649073e663952482bf2babb7 Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Fri, 10 Jul 2026 21:08:46 +1000
Subject: [PATCH 086/196] Fix CommandBar secondary visibility during overflow
 open (#21742)

---
 .../CommandBar/CommandBar.cs                  | 54 +++++++++++++++----
 .../CommandBarTests.cs                        | 32 +++++++++++
 2 files changed, 76 insertions(+), 10 deletions(-)

diff --git a/src/Avalonia.Controls/CommandBar/CommandBar.cs b/src/Avalonia.Controls/CommandBar/CommandBar.cs
index 54f5e16398..0930aedcd9 100644
--- a/src/Avalonia.Controls/CommandBar/CommandBar.cs
+++ b/src/Avalonia.Controls/CommandBar/CommandBar.cs
@@ -140,6 +140,8 @@ namespace Avalonia.Controls
         private readonly CommandBarSeparator _overflowPrimarySecondarySeparator = new();
         private readonly CompositeDisposable _secondaryCommandVisibilitySubscriptions = new();
         private bool _isDynamicUpdateInProgress;
+        private bool _isOpeningOverflowPopup;
+        private bool _hasDeferredDynamicOverflowUpdate;
         private double _constraintWidth = double.PositiveInfinity;
         private bool _openedViaKeyboard;
 
@@ -387,7 +389,7 @@ namespace Avalonia.Controls
             ApplyLabelPositionToChildren();
             UpdateOverflowButtonVisibility();
             UpdateStickyBehavior();
-            UpdateDynamicOverflow();
+            RequestDynamicOverflowUpdate();
         }
 
         protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
@@ -413,7 +415,19 @@ namespace Avalonia.Controls
                 {
                     RaiseEvent(new RoutedEventArgs(OpeningEvent));
                     if (_overflowPopup != null)
-                        _overflowPopup.IsOpen = true;
+                    {
+                        try
+                        {
+                            _isOpeningOverflowPopup = true;
+                            _overflowPopup.IsOpen = true;
+                        }
+                        finally
+                        {
+                            _isOpeningOverflowPopup = false;
+                        }
+
+                        ApplyDeferredDynamicOverflowUpdate();
+                    }
                     RaiseEvent(new RoutedEventArgs(OpenedEvent));
                 }
                 else
@@ -428,7 +442,7 @@ namespace Avalonia.Controls
             {
                 ApplyLabelPositionToChildren();
                 if (IsDynamicOverflowEnabled)
-                    UpdateDynamicOverflow();
+                    RequestDynamicOverflowUpdate();
             }
             else if (change.Property == OverflowButtonVisibilityProperty)
             {
@@ -440,7 +454,7 @@ namespace Avalonia.Controls
             }
             else if (change.Property == IsDynamicOverflowEnabledProperty)
             {
-                UpdateDynamicOverflow();
+                RequestDynamicOverflowUpdate();
             }
             else if (change.Property == PrimaryCommandsProperty)
             {
@@ -449,7 +463,7 @@ namespace Avalonia.Controls
                 if (change.NewValue is INotifyCollectionChanged newPrimary)
                     newPrimary.CollectionChanged += OnPrimaryCommandsChanged;
                 ApplyLabelPositionToChildren();
-                UpdateDynamicOverflow();
+                RequestDynamicOverflowUpdate();
             }
             else if (change.Property == SecondaryCommandsProperty)
             {
@@ -458,7 +472,7 @@ namespace Avalonia.Controls
                 if (change.NewValue is INotifyCollectionChanged newSecondary)
                     newSecondary.CollectionChanged += OnSecondaryCommandsChanged;
                 RebuildSecondaryCommandVisibilitySubscriptions();
-                UpdateDynamicOverflow();
+                RequestDynamicOverflowUpdate();
             }
         }
 
@@ -472,7 +486,7 @@ namespace Avalonia.Controls
             if (newConstraint != _constraintWidth)
             {
                 _constraintWidth = newConstraint;
-                UpdateDynamicOverflow();
+                RequestDynamicOverflowUpdate();
             }
 
             return base.MeasureOverride(availableSize);
@@ -480,7 +494,7 @@ namespace Avalonia.Controls
 
         private void CommandBar_SizeChanged(object? sender, SizeChangedEventArgs e)
         {
-            UpdateDynamicOverflow();
+            RequestDynamicOverflowUpdate();
         }
 
         private void OnOverflowButtonClick(object? sender, Interactivity.RoutedEventArgs e)
@@ -597,12 +611,32 @@ namespace Avalonia.Controls
                         ApplyLabelPositionToElement(element);
                 }
             }
-            UpdateDynamicOverflow();
+            RequestDynamicOverflowUpdate();
         }
 
         private void OnSecondaryCommandsChanged(object? sender, NotifyCollectionChangedEventArgs e)
         {
             RebuildSecondaryCommandVisibilitySubscriptions();
+            RequestDynamicOverflowUpdate();
+        }
+
+        private void RequestDynamicOverflowUpdate()
+        {
+            if (_isOpeningOverflowPopup)
+            {
+                _hasDeferredDynamicOverflowUpdate = true;
+                return;
+            }
+
+            UpdateDynamicOverflow();
+        }
+
+        private void ApplyDeferredDynamicOverflowUpdate()
+        {
+            if (!_hasDeferredDynamicOverflowUpdate)
+                return;
+
+            _hasDeferredDynamicOverflowUpdate = false;
             UpdateDynamicOverflow();
         }
 
@@ -829,7 +863,7 @@ namespace Avalonia.Controls
                                 return;
                             }
 
-                            UpdateDynamicOverflow();
+                            RequestDynamicOverflowUpdate();
                         })
                         .DisposeWith(_secondaryCommandVisibilitySubscriptions);
                 }
diff --git a/tests/Avalonia.Controls.UnitTests/CommandBarTests.cs b/tests/Avalonia.Controls.UnitTests/CommandBarTests.cs
index e886bea535..5c5210e37b 100644
--- a/tests/Avalonia.Controls.UnitTests/CommandBarTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/CommandBarTests.cs
@@ -1364,6 +1364,20 @@ public class CommandBarOverflowKeyboardTests : ScopedTestBase
         Assert.True(first.Classes.Contains(":focus-visible"));
     }
 
+    [Fact]
+    public void Open_DoesNotThrow_WhenSecondaryCommandVisibilityChangesDuringOverflowRealization()
+    {
+        var secondary = new VisibilityChangingCommandBarButton { Label = "Bound" };
+        var cb = new CommandBar();
+        cb.SecondaryCommands.Add(secondary);
+        var window = CreateWindow(cb);
+
+        cb.IsOpen = true;
+
+        Assert.True(cb.IsOpen);
+        Assert.False(secondary.IsVisible);
+    }
+
     private static ItemsControl GetOverflowPresenter(CommandBar cb)
     {
         var popup = cb.GetVisualDescendants()
@@ -1412,6 +1426,24 @@ public class CommandBarOverflowKeyboardTests : ScopedTestBase
             new PointerPointProperties(RawInputModifiers.LeftMouseButton, PointerUpdateKind.LeftButtonPressed),
             KeyModifiers.None));
     }
+
+    private class VisibilityChangingCommandBarButton : CommandBarButton
+    {
+        private bool _hasUpdatedVisibility;
+
+        protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+        {
+            base.OnPropertyChanged(change);
+
+            if (!_hasUpdatedVisibility &&
+                change.Property == ParentProperty &&
+                change.NewValue is not null)
+            {
+                _hasUpdatedVisibility = true;
+                SetCurrentValue(IsVisibleProperty, false);
+            }
+        }
+    }
 }
 
 public class CommandBarSeparatorOverflowTests : ScopedTestBase

From 984b6428c6310addbdc3d72f5990734297a07b6d Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Fri, 10 Jul 2026 14:51:26 +0200
Subject: [PATCH 087/196] Fix AutoCompleteBox popup not closing on focus lost
 (#21749)

* Add failing test for AutoCompleteBox

* Fix AutoCompleteBox popup not closing on focus lost
---
 .../AutoCompleteBox/AutoCompleteBox.cs        | 108 ++++--------------
 .../AutoCompleteBoxTests.cs                   |  34 ++++++
 2 files changed, 55 insertions(+), 87 deletions(-)

diff --git a/src/Avalonia.Controls/AutoCompleteBox/AutoCompleteBox.cs b/src/Avalonia.Controls/AutoCompleteBox/AutoCompleteBox.cs
index f4132a5ced..32d5d9f648 100644
--- a/src/Avalonia.Controls/AutoCompleteBox/AutoCompleteBox.cs
+++ b/src/Avalonia.Controls/AutoCompleteBox/AutoCompleteBox.cs
@@ -212,8 +212,6 @@ namespace Avalonia.Controls
         private bool _itemTemplateIsFromValueMemberBinding = true;
         private bool _settingItemTemplateFromValueMemberBinding;
 
-        private bool _isFocused = false;
-
         private string? _searchText = string.Empty;
 
         private readonly EventHandler _populateDropDownHandler;
@@ -751,28 +749,34 @@ namespace Avalonia.Controls
             }
         }
 
-        /// <summary>
-        /// Provides handling for the
-        /// <see cref="E:Avalonia.Controls.Control.GotFocus" /> event.
-        /// </summary>
-        /// <param name="e">A <see cref="T:RoutedEventArgs" />
-        /// that contains the event data.</param>
+        /// <inheritdoc/>
         protected override void OnGotFocus(FocusChangedEventArgs e)
         {
+            if (TextBox is not null && TextBoxSelectionLength <= 0)
+            {
+                TextBox.Focus();
+                TextBox.SelectAll();
+            }
+
             base.OnGotFocus(e);
-            FocusChanged(HasFocus());
         }
 
-        /// <summary>
-        /// Provides handling for the
-        /// <see cref="E:Avalonia.Controls.Control.LostFocus" /> event.
-        /// </summary>
-        /// <param name="e">A <see cref="T:RoutedEventArgs" />
-        /// that contains the event data.</param>
+        /// <inheritdoc/>
         protected override void OnLostFocus(FocusChangedEventArgs e)
         {
+            SetCurrentValue(IsDropDownOpenProperty, false);
+
+            _userCalledPopulate = false;
+
+            var textBoxContextMenuIsOpen = TextBox?.ContextFlyout?.IsOpen == true || TextBox?.ContextMenu?.IsOpen == true;
+            var contextMenuIsOpen = ContextFlyout?.IsOpen == true || ContextMenu?.IsOpen == true;
+
+            if (!textBoxContextMenuIsOpen && !contextMenuIsOpen && ClearSelectionOnLostFocus)
+            {
+                ClearTextBoxSelection();
+            }
+
             base.OnLostFocus(e);
-            FocusChanged(HasFocus());
         }
 
         protected override AutomationPeer OnCreateAutomationPeer() => new AutoCompleteBoxAutomationPeer(this);
@@ -785,79 +789,9 @@ namespace Avalonia.Controls
         /// <returns>true to indicate the
         /// <see cref="T:Avalonia.Controls.AutoCompleteBox" /> has focus;
         /// otherwise, false.</returns>
+        [Obsolete($"Use {nameof(IsKeyboardFocusWithin)} instead.")]
         protected bool HasFocus() => IsKeyboardFocusWithin;
 
-        /// <summary>
-        /// Handles the FocusChanged event.
-        /// </summary>
-        /// <param name="hasFocus">A value indicating whether the control
-        /// currently has the focus.</param>
-        private void FocusChanged(bool hasFocus)
-        {
-            // The OnGotFocus & OnLostFocus are asynchronously and cannot
-            // reliably tell you that have the focus.  All they do is let you
-            // know that the focus changed sometime in the past.  To determine
-            // if you currently have the focus you need to do consult the
-            // FocusManager (see HasFocus()).
-
-            bool wasFocused = _isFocused;
-            _isFocused = hasFocus;
-
-            if (hasFocus)
-            {
-
-                if (!wasFocused && TextBox != null && TextBoxSelectionLength <= 0)
-                {
-                    TextBox.Focus();
-                    TextBox.SelectAll();
-                }
-            }
-            else
-            {
-                // Check if we still have focus in the parent's focus scope
-                if (GetFocusScope() is { } scope &&
-                    (FocusManager.GetFocusManager(this)?.GetFocusedElement(scope) is not { } focused ||
-                    (focused != this &&
-                    (focused is Visual v && !this.IsVisualAncestorOf(v)))))
-                {
-                    SetCurrentValue(IsDropDownOpenProperty, false);
-                }
-
-                _userCalledPopulate = false;
-
-                var textBoxContextMenuIsOpen = TextBox?.ContextFlyout?.IsOpen == true || TextBox?.ContextMenu?.IsOpen == true;
-                var contextMenuIsOpen = ContextFlyout?.IsOpen == true || ContextMenu?.IsOpen == true;
-
-                if (!textBoxContextMenuIsOpen && !contextMenuIsOpen && ClearSelectionOnLostFocus)
-                {
-                    ClearTextBoxSelection();
-                }
-            }
-
-            _isFocused = hasFocus;
-
-            IFocusScope? GetFocusScope()
-            {
-                IInputElement? c = this;
-
-                while (c != null)
-                {
-                    if (c is IFocusScope scope &&
-                        c is Visual v &&
-                        v.VisualRoot is Visual root &&
-                        root.IsVisible)
-                    {
-                        return scope;
-                    }
-
-                    c = (c as Visual)?.GetVisualParent<IInputElement>() ??
-                        ((c as IHostedVisualTreeRoot)?.Host as IInputElement);
-                }
-
-                return null;
-            }
-        }
-
         /// <summary>
         /// Occurs asynchronously when the text in the <see cref="TextBox"/> portion of the
         /// <see cref="AutoCompleteBox" /> changes.
diff --git a/tests/Avalonia.Controls.UnitTests/AutoCompleteBoxTests.cs b/tests/Avalonia.Controls.UnitTests/AutoCompleteBoxTests.cs
index 4232624fad..d5bcde0c6d 100644
--- a/tests/Avalonia.Controls.UnitTests/AutoCompleteBoxTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/AutoCompleteBoxTests.cs
@@ -584,6 +584,40 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Losing_Focus_Closes_DropDown()
+        {
+            using var app = UnitTestApplication.Start(FocusServices);
+
+            var target1 = CreateControl();
+            target1.ItemsSource = CreateSimpleStringArray();
+            var textBox1 = GetTextBox(target1);
+
+            var target2 = CreateControl();
+
+            target1.ApplyTemplate();
+            target2.ApplyTemplate();
+
+            _ = new TestRoot
+            {
+                Child = new StackPanel
+                {
+                    Children = { target1, target2 }
+                }
+            };
+
+            target1.Focus();
+            textBox1.Text = "a";
+            Dispatcher.UIThread.RunJobs(null, TestContext.Current.CancellationToken);
+            Assert.True(target1.IsDropDownOpen);
+
+            target2.Focus();
+            Dispatcher.UIThread.RunJobs(null, TestContext.Current.CancellationToken);
+
+            Assert.False(target1.IsFocused);
+            Assert.False(target1.IsDropDownOpen);
+        }
+
         /// <summary>
         /// Retrieves a defined predicate filter through a new AutoCompleteBox
         /// control instance.

From 3bdc149c488f588b6fdf26127952ec902ad3dbda Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Sat, 11 Jul 2026 08:37:08 +0200
Subject: [PATCH 088/196] Position popup using the screen containing the anchor
 point (#21750)

---
 .../ManagedPopupPositioner.cs                 |  6 +-
 .../Primitives/ManagedPopupPositionerTests.cs | 59 +++++++++++++++++++
 2 files changed, 63 insertions(+), 2 deletions(-)
 create mode 100644 tests/Avalonia.Controls.UnitTests/Primitives/ManagedPopupPositionerTests.cs

diff --git a/src/Avalonia.Controls/Primitives/PopupPositioning/ManagedPopupPositioner.cs b/src/Avalonia.Controls/Primitives/PopupPositioning/ManagedPopupPositioner.cs
index f1a5159069..064edca9d1 100644
--- a/src/Avalonia.Controls/Primitives/PopupPositioning/ManagedPopupPositioner.cs
+++ b/src/Avalonia.Controls/Primitives/PopupPositioning/ManagedPopupPositioner.cs
@@ -109,10 +109,12 @@ namespace Avalonia.Controls.Primitives.PopupPositioning
             Rect GetBounds()
             {
                 var screens = _popup.Screens;
+                var anchorPoint = GetAnchorPoint(anchorRect, anchor);
+                var parentGeometryPoint = GetAnchorPoint(parentGeometry, anchor);
                 
-                var targetScreen =  screens.FirstOrDefault(s => s.Bounds.ContainsExclusive(anchorRect.TopLeft))
+                var targetScreen =  screens.FirstOrDefault(s => s.Bounds.ContainsExclusive(anchorPoint))
                                    ?? screens.FirstOrDefault(s => s.Bounds.Intersects(anchorRect))
-                                   ?? screens.FirstOrDefault(s => s.Bounds.ContainsExclusive(parentGeometry.TopLeft))
+                                   ?? screens.FirstOrDefault(s => s.Bounds.ContainsExclusive(parentGeometryPoint))
                                    ?? screens.FirstOrDefault(s => s.Bounds.Intersects(parentGeometry))
                                    ?? screens.FirstOrDefault();
 
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/ManagedPopupPositionerTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/ManagedPopupPositionerTests.cs
new file mode 100644
index 0000000000..33b6791285
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/ManagedPopupPositionerTests.cs
@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using Avalonia.Controls.Primitives.PopupPositioning;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests.Primitives;
+
+public class ManagedPopupPositionerTests : ScopedTestBase
+{
+    // The anchor rectangle overlaps the 4 screens, so each corner lands on a different screen.
+    // With no gravity the popup is centered on the anchor point and is slid back into the screen containing that point.
+    [Theory]
+    [InlineData(PopupAnchor.TopLeft, 600, 600)]
+    [InlineData(PopupAnchor.TopRight, 1000, 600)]
+    [InlineData(PopupAnchor.BottomLeft, 600, 1000)]
+    [InlineData(PopupAnchor.BottomRight, 1000, 1000)]
+    public void Uses_Screen_Containing_The_Anchor_Point(PopupAnchor anchor, double expectedX, double expectedY)
+    {
+        var popup = new MockManagedPopupPositionerPopup();
+        var positioner = new ManagedPopupPositioner(popup);
+
+        positioner.Update(new PopupPositionerParameters
+        {
+            Size = new Size(400, 400),
+            AnchorRectangle = new Rect(900, 900, 200, 200),
+            Anchor = anchor,
+            Gravity = PopupGravity.None,
+            ConstraintAdjustment = PopupPositionerConstraintAdjustment.All
+        });
+
+        Assert.Equal(new Point(expectedX, expectedY), popup.LastPosition);
+    }
+
+    private sealed class MockManagedPopupPositionerPopup : IManagedPopupPositionerPopup
+    {
+        // Four screens arranged in a 2x2 grid, meeting at (1000, 1000).
+        public IReadOnlyList<ManagedPopupPositionerScreenInfo> Screens { get; } =
+        [
+            new(new Rect(0, 0, 1000, 1000), new Rect(0, 0, 1000, 1000)),
+            new(new Rect(1000, 0, 1000, 1000), new Rect(1000, 0, 1000, 1000)),
+            new(new Rect(0, 1000, 1000, 1000), new Rect(0, 1000, 1000, 1000)),
+            new(new Rect(1000, 1000, 1000, 1000), new Rect(1000, 1000, 1000, 1000))
+        ];
+
+        public Rect ParentClientAreaScreenGeometry => new(0, 0, 1000, 1000);
+
+        public double Scaling => 1.0;
+
+        public Point LastPosition { get; private set; }
+
+        public Size LastSize { get; private set; }
+
+        public void MoveAndResize(Point devicePoint, Size virtualSize)
+        {
+            LastPosition = devicePoint;
+            LastSize = virtualSize;
+        }
+    }
+}

From bc3001bf77329f9f8d1db14a2d952d46cfe0414c Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Sat, 11 Jul 2026 08:38:37 +0200
Subject: [PATCH 089/196] Keep page in NavigationPage's logical tree until
 animation is complete (#21751)

* Keep page in NavigationPage's logical tree until animation is complete

* Share templates in NavigationPageTests
---
 src/Avalonia.Controls/Page/NavigationPage.cs  |  70 +++--
 .../NavigationPageTests.cs                    | 280 +++++++++---------
 2 files changed, 183 insertions(+), 167 deletions(-)

diff --git a/src/Avalonia.Controls/Page/NavigationPage.cs b/src/Avalonia.Controls/Page/NavigationPage.cs
index e43fe5f06d..adcef076e0 100644
--- a/src/Avalonia.Controls/Page/NavigationPage.cs
+++ b/src/Avalonia.Controls/Page/NavigationPage.cs
@@ -860,7 +860,9 @@ namespace Avalonia.Controls
             if (old != null)
                 _pageSet.Remove(old);
 
-            if (old is ILogical oldLogical)
+            // Remove the page from the logical tree only if it isn't in a presenter.
+            // If it is, it's animating out and will be removed once the animation completes.
+            if (old is ILogical oldLogical && !IsPageInPresenter(old))
                 LogicalChildren.Remove(oldLogical);
 
             InvalidateNavigationStackCache();
@@ -1035,20 +1037,13 @@ namespace Avalonia.Controls
 
                 var poppedPages = new List<Page>();
 
-                void TearDownPopped(Page popped)
+                while (_navigationStack.Count > 1)
                 {
-                    _pageSet.Remove(popped);
-                    if (popped is ILogical poppedLogical)
-                        LogicalChildren.Remove(poppedLogical);
-                    popped.Navigation = null;
-                    popped.SetInNavigationPage(false);
-                    popped.SafeAreaPadding = default;
+                    var popped = _navigationStack.Pop();
+                    TearDownPoppedPage(popped);
                     poppedPages.Add(popped);
                 }
 
-                while (_navigationStack.Count > 1)
-                    TearDownPopped(_navigationStack.Pop());
-
                 InvalidateNavigationStackCache();
                 _isPop = true;
                 UpdateActivePage();
@@ -1075,6 +1070,20 @@ namespace Avalonia.Controls
             }
         }
 
+        private void TearDownPoppedPage(Page popped)
+        {
+            _pageSet.Remove(popped);
+
+            // Remove the page from the logical tree only if it isn't in a presenter.
+            // If it is, it will be removed once the animation is complete.
+            if (popped is ILogical poppedLogical && !IsPageInPresenter(popped))
+                LogicalChildren.Remove(poppedLogical);
+
+            popped.Navigation = null;
+            popped.SetInNavigationPage(false);
+            popped.SafeAreaPadding = default;
+        }
+
         /// <summary>
         /// Pops all pages to the root page using <paramref name="transition"/>.
         /// </summary>
@@ -1137,20 +1146,13 @@ namespace Avalonia.Controls
 
                 var poppedPages = new List<Page>();
 
-                void TearDownPopped(Page popped)
+                while (_navigationStack.Count > 1 && _navigationStack.Peek() != page)
                 {
-                    _pageSet.Remove(popped);
-                    if (popped is ILogical poppedLogical)
-                        LogicalChildren.Remove(poppedLogical);
-                    popped.Navigation = null;
-                    popped.SetInNavigationPage(false);
-                    popped.SafeAreaPadding = default;
+                    var popped = _navigationStack.Pop();
+                    TearDownPoppedPage(popped);
                     poppedPages.Add(popped);
                 }
 
-                while (_navigationStack.Count > 1 && _navigationStack.Peek() != page)
-                    TearDownPopped(_navigationStack.Pop());
-
                 InvalidateNavigationStackCache();
                 _isPop = true;
                 UpdateActivePage();
@@ -1800,6 +1802,9 @@ namespace Avalonia.Controls
                 _currentTransition?.Dispose();
                 _currentTransition = null;
 
+                // A previous transition may have been canceled above before its teardown ran, leaving its outgoing page
+                // in the back presenter; reconcile the logical tree.
+                DetachOrphanedPageFromLogicalTree(_pageBackPresenter.Content);
                 _pageBackPresenter.IsVisible = false;
                 _pageBackPresenter.Content = null;
                 _pageBackPresenter.RenderTransform = null;
@@ -1839,6 +1844,7 @@ namespace Avalonia.Controls
                 }
                 else
                 {
+                    var oldPageContent = _pagePresenter.Content;
                     _lastPageTransitionTask = Task.CompletedTask;
 
                     _pagePresenter.Content = page;
@@ -1848,6 +1854,8 @@ namespace Avalonia.Controls
                     _pageBackPresenter.Content = null;
                     _pageBackPresenter.IsVisible = false;
                     _pageBackPresenter.ZIndex = 0;
+
+                    DetachOrphanedPageFromLogicalTree(oldPageContent);
                 }
 
                 if (page != null)
@@ -1932,10 +1940,12 @@ namespace Avalonia.Controls
             if (ct.IsCancellationRequested)
                 return;
 
+            var fromContent = from.Content;
             from.IsVisible = false;
             from.Content = null;
             from.RenderTransform = null;
             from.Opacity = 1;
+            DetachOrphanedPageFromLogicalTree(fromContent);
         }
 
         private Task AwaitPageTransitionAsync()
@@ -1974,7 +1984,9 @@ namespace Avalonia.Controls
             _pageSet.Add(page);
             InvalidateNavigationStackCache();
 
-            if (removed is ILogical removedLogical)
+            // Remove the replaced page from the logical tree only if it isn't in a presenter.
+            // If it is, it's animating out and will be removed once the animation completes.
+            if (removed is ILogical removedLogical && !IsPageInPresenter(removed))
                 LogicalChildren.Remove(removedLogical);
             if (page is ILogical addedLogical)
                 LogicalChildren.Add(addedLogical);
@@ -1985,6 +1997,20 @@ namespace Avalonia.Controls
             UpdateActivePage();
         }
 
+        private void DetachOrphanedPageFromLogicalTree(object? content)
+        {
+            if (content is ILogical logical
+                && content is Page page
+                && !_pageSet.Contains(page)
+                && logical.LogicalParent == this)
+            {
+                LogicalChildren.Remove(logical);
+            }
+        }
+
+        private bool IsPageInPresenter(Page page)
+            => ReferenceEquals(page, _pagePresenter?.Content) || ReferenceEquals(page, _pageBackPresenter?.Content);
+
         private void SwapModalPresenters()
         {
             if (_modalPresenter == null || _modalBackPresenter == null)
diff --git a/tests/Avalonia.Controls.UnitTests/NavigationPageTests.cs b/tests/Avalonia.Controls.UnitTests/NavigationPageTests.cs
index d0bd88bbbd..d00eab9936 100644
--- a/tests/Avalonia.Controls.UnitTests/NavigationPageTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/NavigationPageTests.cs
@@ -22,6 +22,60 @@ namespace Avalonia.Controls.UnitTests;
 
 public class NavigationPageTests
 {
+    private static NavigationPage CreateNavigationPage(IPageTransition? transition = null)
+    {
+        var nav = new NavigationPage
+        {
+            PageTransition = transition,
+            Template = CreateNavigationPageTemplate()
+        };
+        var root = new TestRoot { Child = nav };
+        root.LayoutManager.ExecuteInitialLayoutPass();
+        return nav;
+    }
+
+    private static IControlTemplate CreateNavigationPageTemplate()
+    {
+        return new FuncControlTemplate<NavigationPage>((_, ns) =>
+        {
+            var contentHost = new Panel
+            {
+                Name = "PART_ContentHost",
+                Children =
+                {
+                    new ContentPresenter { Name = "PART_PageBackPresenter" }.RegisterInNameScope(ns),
+                    new ContentPresenter { Name = "PART_PagePresenter" }.RegisterInNameScope(ns),
+                }
+            }.RegisterInNameScope(ns);
+
+            return new Panel
+            {
+                Children =
+                {
+                    new Border
+                    {
+                        Name = "PART_NavigationBar",
+                        Child = new Button { Name = "PART_BackButton" }.RegisterInNameScope(ns)
+                    }.RegisterInNameScope(ns),
+                    contentHost,
+                    new ContentPresenter { Name = "PART_TopCommandBar" }.RegisterInNameScope(ns),
+                    new ContentPresenter { Name = "PART_ModalBackPresenter" }.RegisterInNameScope(ns),
+                    new ContentPresenter { Name = "PART_ModalPresenter" }.RegisterInNameScope(ns),
+                }
+            };
+        });
+    }
+
+    private sealed class ControllableTransition(Task gate) : IPageTransition
+    {
+        public async Task Start(Visual? from, Visual? to, bool forward, CancellationToken cancellationToken)
+        {
+            to?.IsVisible = true;
+            await gate;
+            from?.IsVisible = false;
+        }
+    }
+
     public class PushTests : ScopedTestBase
     {
         [Fact]
@@ -1784,6 +1838,86 @@ public class NavigationPageTests
             Assert.Null(modal.Navigation);
             Assert.False(modal.IsInNavigationPage);
         }
+
+        [Fact]
+        public async Task Pop_KeepsOutgoingPageInLogicalTree_UntilTransitionCompletes()
+        {
+            var gate = new TaskCompletionSource();
+            var nav = CreateNavigationPage();
+
+            var root = new ContentPage();
+            var top = new ContentPage();
+            await nav.PushAsync(root);
+            await nav.PushAsync(top);
+
+            nav.PageTransition = new ControllableTransition(gate.Task);
+
+            var popTask = nav.PopAsync();
+
+            // The outgoing page is still animating out, so it must remain in the logical tree.
+            Assert.Contains(top, nav.GetLogicalChildren());
+
+            gate.SetResult();
+            await popTask;
+
+            // Once the transition completes, the page is detached.
+            Assert.DoesNotContain(top, nav.GetLogicalChildren());
+            Assert.Contains(root, nav.GetLogicalChildren());
+        }
+
+        [Fact]
+        public async Task Replace_KeepsOutgoingPageInLogicalTree_UntilTransitionCompletes()
+        {
+            var gate = new TaskCompletionSource();
+            var nav = CreateNavigationPage();
+
+            var original = new ContentPage();
+            await nav.PushAsync(original);
+
+            nav.PageTransition = new ControllableTransition(gate.Task);
+
+            var replacement = new ContentPage();
+            var replaceTask = nav.ReplaceAsync(replacement);
+
+            // The replaced page is still animating out, so both pages are in the logical tree.
+            Assert.Contains(original, nav.GetLogicalChildren());
+            Assert.Contains(replacement, nav.GetLogicalChildren());
+
+            gate.SetResult();
+            await replaceTask;
+
+            Assert.DoesNotContain(original, nav.GetLogicalChildren());
+            Assert.Contains(replacement, nav.GetLogicalChildren());
+        }
+
+        [Fact]
+        public async Task PopToRoot_KeepsVisibleTopPageInLogicalTree_UntilTransitionCompletes()
+        {
+            var gate = new TaskCompletionSource();
+            var nav = CreateNavigationPage();
+
+            var root = new ContentPage();
+            var middle = new ContentPage();
+            var top = new ContentPage();
+            await nav.PushAsync(root);
+            await nav.PushAsync(middle);
+            await nav.PushAsync(top);
+
+            nav.PageTransition = new ControllableTransition(gate.Task);
+
+            var popTask = nav.PopToRootAsync();
+
+            // The hidden intermediate page is detached eagerly, but the visible top page is
+            // animating out and must stay attached until the transition completes.
+            Assert.DoesNotContain(middle, nav.GetLogicalChildren());
+            Assert.Contains(top, nav.GetLogicalChildren());
+
+            gate.SetResult();
+            await popTask;
+
+            Assert.DoesNotContain(top, nav.GetLogicalChildren());
+            Assert.Contains(root, nav.GetLogicalChildren());
+        }
     }
 
     public class PopAllModalsTests : ScopedTestBase
@@ -2440,69 +2574,6 @@ public class NavigationPageTests
             Assert.False(navigatedFromDuringTransition);
             Assert.False(navigatedToDuringTransition);
         }
-
-        private static NavigationPage CreateNavigationPage(IPageTransition? transition)
-        {
-            var nav = new NavigationPage
-            {
-                PageTransition = transition,
-                Template = NavigationPageTemplate()
-            };
-            var root = new TestRoot { Child = nav };
-            root.LayoutManager.ExecuteInitialLayoutPass();
-            return nav;
-        }
-
-        private static IControlTemplate NavigationPageTemplate()
-        {
-            return new FuncControlTemplate<NavigationPage>((parent, ns) =>
-            {
-                var contentHost = new Panel
-                {
-                    Name = "PART_ContentHost",
-                    Children =
-                    {
-                        new ContentPresenter { Name = "PART_PageBackPresenter" }.RegisterInNameScope(ns),
-                        new ContentPresenter { Name = "PART_PagePresenter" }.RegisterInNameScope(ns),
-                    }
-                }.RegisterInNameScope(ns);
-
-                return new Panel
-                {
-                    Children =
-                    {
-                        new Border
-                        {
-                            Name = "PART_NavigationBar",
-                            Child = new Button { Name = "PART_BackButton" }.RegisterInNameScope(ns)
-                        }.RegisterInNameScope(ns),
-                        contentHost,
-                        new ContentPresenter { Name = "PART_TopCommandBar" }.RegisterInNameScope(ns),
-                        new ContentPresenter { Name = "PART_ModalBackPresenter" }.RegisterInNameScope(ns),
-                        new ContentPresenter { Name = "PART_ModalPresenter" }.RegisterInNameScope(ns),
-                    }
-                };
-            });
-        }
-
-        private class ControllableTransition : IPageTransition
-        {
-            private readonly Task _gate;
-
-            public ControllableTransition(Task gate)
-            {
-                _gate = gate;
-            }
-
-            public async Task Start(Visual? from, Visual? to, bool forward, CancellationToken cancellationToken)
-            {
-                if (to != null)
-                    to.IsVisible = true;
-                await _gate;
-                if (from != null)
-                    from.IsVisible = false;
-            }
-        }
     }
 
     public class SwipeGestureTests : ScopedTestBase
@@ -2654,59 +2725,6 @@ public class NavigationPageTests
 
             Assert.False(nav.IsNavigating);
         }
-
-        private static NavigationPage CreateNavigationPage(IPageTransition? transition)
-        {
-            var nav = new NavigationPage
-            {
-                PageTransition = transition,
-                Template = new FuncControlTemplate<NavigationPage>((parent, ns) =>
-                {
-                    return new Panel
-                    {
-                        Children =
-                        {
-                            new Panel
-                            {
-                                Name = "PART_ContentHost",
-                                Children =
-                                {
-                                    new ContentPresenter { Name = "PART_PageBackPresenter" }.RegisterInNameScope(ns),
-                                    new ContentPresenter { Name = "PART_PagePresenter" }.RegisterInNameScope(ns),
-                                }
-                            }.RegisterInNameScope(ns),
-                            new Border { Name = "PART_NavigationBar",
-                                Child = new Button { Name = "PART_BackButton" }.RegisterInNameScope(ns) }.RegisterInNameScope(ns),
-                            new ContentPresenter { Name = "PART_TopCommandBar" }.RegisterInNameScope(ns),
-                            new ContentPresenter { Name = "PART_ModalBackPresenter" }.RegisterInNameScope(ns),
-                            new ContentPresenter { Name = "PART_ModalPresenter" }.RegisterInNameScope(ns),
-                        }
-                    };
-                })
-            };
-            var root = new TestRoot { Child = nav };
-            root.LayoutManager.ExecuteInitialLayoutPass();
-            return nav;
-        }
-
-        private class ControllableTransition : IPageTransition
-        {
-            private readonly Task _gate;
-
-            public ControllableTransition(Task gate)
-            {
-                _gate = gate;
-            }
-
-            public async Task Start(Visual? from, Visual? to, bool forward, CancellationToken cancellationToken)
-            {
-                if (to != null)
-                    to.IsVisible = true;
-                await _gate;
-                if (from != null)
-                    from.IsVisible = false;
-            }
-        }
     }
 
     public class VisualTreeLifecycleTests : ScopedTestBase
@@ -2714,35 +2732,7 @@ public class NavigationPageTests
         [Fact]
         public async Task Detach_And_Reattach_PreservesModalStack()
         {
-            var nav = new NavigationPage
-            {
-                Template = new FuncControlTemplate<NavigationPage>((parent, ns) =>
-                {
-                    return new Panel
-                    {
-                        Children =
-                        {
-                            new Panel
-                            {
-                                Name = "PART_ContentHost",
-                                Children =
-                                {
-                                    new ContentPresenter { Name = "PART_PageBackPresenter" }.RegisterInNameScope(ns),
-                                    new ContentPresenter { Name = "PART_PagePresenter" }.RegisterInNameScope(ns),
-                                }
-                            }.RegisterInNameScope(ns),
-                            new Border
-                            {
-                                Name = "PART_NavigationBar",
-                                Child = new Button { Name = "PART_BackButton" }.RegisterInNameScope(ns)
-                            }.RegisterInNameScope(ns),
-                            new ContentPresenter { Name = "PART_TopCommandBar" }.RegisterInNameScope(ns),
-                            new ContentPresenter { Name = "PART_ModalBackPresenter" }.RegisterInNameScope(ns),
-                            new ContentPresenter { Name = "PART_ModalPresenter" }.RegisterInNameScope(ns),
-                        }
-                    };
-                })
-            };
+            var nav = new NavigationPage { Template = CreateNavigationPageTemplate() };
 
             var root = new TestRoot { Child = nav };
             root.LayoutManager.ExecuteInitialLayoutPass();

From 11564814b32a844145ed1450b5ea42e53889bf3a Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Mon, 13 Jul 2026 20:41:00 +0500
Subject: [PATCH 090/196] Fixed copypasta-induced bug with custom-hit-test
 housekeeping (#21769)

---
 .../Rendering/Composition/Visual.cs           |  2 +-
 .../Rendering/CompositorHitTestingTests.cs    | 36 +++++++++++++++++++
 2 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Base/Rendering/Composition/Visual.cs b/src/Avalonia.Base/Rendering/Composition/Visual.cs
index e4b469d327..6134d48220 100644
--- a/src/Avalonia.Base/Rendering/Composition/Visual.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Visual.cs
@@ -45,7 +45,7 @@ namespace Avalonia.Rendering.Composition
                 var parent = Parent;
                 while (parent != null)
                 {
-                    parent.CustomHitTestCountInSubTree -= CustomHitTestCountInSubTree;
+                    parent.CustomHitTestCountInSubTree += CustomHitTestCountInSubTree;
                     parent = parent.Parent;
                 }
             }
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/CompositorHitTestingTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/CompositorHitTestingTests.cs
index 6fe481a517..9dbb446bdc 100644
--- a/tests/Avalonia.Base.UnitTests/Rendering/CompositorHitTestingTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Rendering/CompositorHitTestingTests.cs
@@ -444,6 +444,42 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
     
+    [Fact]
+    public void Removing_ICustomHitTest_Child_Should_Restore_SubTree_Bounds_Optimization()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            var custom = new CustomHitTestBorder
+            {
+                Width = 100,
+                Height = 100,
+                Background = Brushes.Red
+            };
+            var container = new Panel
+            {
+                Width = 200,
+                Height = 200,
+                Children = { custom }
+            };
+
+            s.TopLevel.Content = container;
+            s.RunJobs();
+
+            var containerVisual = ElementComposition.GetElementVisual(container);
+            Assert.NotNull(containerVisual);
+
+            // While the subtree contains an ICustomHitTest visual, the bounds-based optimization must be disabled.
+            Assert.True(containerVisual!.DisableSubTreeBoundsHitTestOptimization);
+
+            container.Children.Remove(custom);
+            s.RunJobs();
+
+            // Once the custom hit test visual leaves the subtree, the accounting must return to zero and re-enable
+            // the optimization. A sign bug when attaching to a new parent leaves the count stuck at a non-zero value.
+            Assert.False(containerVisual.DisableSubTreeBoundsHitTestOptimization);
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Not_Hit_Controls_Next_Pixel()
     {

From 0bf2e4d6f0f074335820f1121c5f0fb0dff4f71a Mon Sep 17 00:00:00 2001
From: Stephen Monaco <1782158+stevemonaco@users.noreply.github.com>
Date: Wed, 15 Jul 2026 02:59:40 -0400
Subject: [PATCH 091/196] Assign ViewIdResourceName for Android (#21780)

---
 src/Android/Avalonia.Android/AvaloniaAccessHelper.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs b/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
index 4da035f877..2943e13a21 100644
--- a/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
+++ b/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
@@ -232,7 +232,9 @@ namespace Avalonia.Android
 
             // UI debug metadata
             nodeInfo.ClassName = peer.GetClassName();
-            nodeInfo.UniqueId = peer.GetAutomationId();
+            var automationId = peer.GetAutomationId();
+            nodeInfo.UniqueId = automationId;
+            nodeInfo.ViewIdResourceName = automationId;
 
             // Common control state
             nodeInfo.Enabled = peer.IsEnabled();

From 6278eb78bcd46140359a51a46025c48de9d8d4cf Mon Sep 17 00:00:00 2001
From: Sergey Mikolaitis <blasterloremaster@gmail.com>
Date: Mon, 20 Jul 2026 10:57:01 +0300
Subject: [PATCH 092/196] Respect disabled Avalonia name generator (#21804)

---
 .../NameGenerator/AvaloniaNameIncrementalGenerator.cs        | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/tools/Avalonia.Generators/NameGenerator/AvaloniaNameIncrementalGenerator.cs b/src/tools/Avalonia.Generators/NameGenerator/AvaloniaNameIncrementalGenerator.cs
index a1cec53ed9..1c37281bf3 100644
--- a/src/tools/Avalonia.Generators/NameGenerator/AvaloniaNameIncrementalGenerator.cs
+++ b/src/tools/Avalonia.Generators/NameGenerator/AvaloniaNameIncrementalGenerator.cs
@@ -34,6 +34,11 @@ public class AvaloniaNameIncrementalGenerator : IIncrementalGenerator
                 var (options, optionsProvider) = pair.Right;
                 var filePath = text.Path;
 
+                if (!options.AvaloniaNameGeneratorIsEnabled)
+                {
+                    return false;
+                }
+
                 if (!(filePath.EndsWith(".xaml", StringComparison.OrdinalIgnoreCase) ||
                       filePath.EndsWith(".paml", StringComparison.OrdinalIgnoreCase) ||
                       filePath.EndsWith(".axaml", StringComparison.OrdinalIgnoreCase)))

From fb297c1575e62ba255099146905b68df7f4fcd1f Mon Sep 17 00:00:00 2001
From: yoyo <zrt2399@163.com>
Date: Mon, 20 Jul 2026 16:17:00 +0800
Subject: [PATCH 093/196] fix(ScrollBar): use large scroll events for
 ScrollToHome and ScrollToEnd (#21748)

* fix(ScrollBar): use large scroll events for ScrollToHome and ScrollToEnd

* Fix failing test

---------

Co-authored-by: Tim <47110241+timunie@users.noreply.github.com>
---
 src/Avalonia.Controls/Primitives/ScrollBar.cs                 | 4 ++--
 .../Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs  | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Avalonia.Controls/Primitives/ScrollBar.cs b/src/Avalonia.Controls/Primitives/ScrollBar.cs
index 6044777a40..b4971a405c 100644
--- a/src/Avalonia.Controls/Primitives/ScrollBar.cs
+++ b/src/Avalonia.Controls/Primitives/ScrollBar.cs
@@ -579,7 +579,7 @@ namespace Avalonia.Controls.Primitives
         public void ScrollToHome()
         {
             SetCurrentValue(ValueProperty, Minimum);
-            OnScroll(ScrollEventType.SmallDecrement);
+            OnScroll(ScrollEventType.LargeDecrement);
         }
 
         /// <summary>
@@ -588,7 +588,7 @@ namespace Avalonia.Controls.Primitives
         public void ScrollToEnd()
         {
             SetCurrentValue(ValueProperty, Maximum);
-            OnScroll(ScrollEventType.SmallIncrement);
+            OnScroll(ScrollEventType.LargeIncrement);
         }
 
         /// <summary>
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs
index 81b03d7863..f6aff58cee 100644
--- a/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs
@@ -338,8 +338,8 @@ namespace Avalonia.Controls.UnitTests.Primitives
                 {
                     ScrollEventType.SmallIncrement,
                     ScrollEventType.LargeIncrement,
-                    ScrollEventType.SmallDecrement,
-                    ScrollEventType.SmallIncrement,
+                    ScrollEventType.LargeDecrement,
+                    ScrollEventType.LargeIncrement,
                 },
                 events);
         }

From 66449823060be98955f78c09e8a1226a0e3e0f48 Mon Sep 17 00:00:00 2001
From: Autumn <80438149+1419323749@users.noreply.github.com>
Date: Mon, 20 Jul 2026 16:46:22 +0800
Subject: [PATCH 094/196] fix(controls): stop HotKeyManager from executing on
 hidden controls (#21714)

- Added a check for 'target.IsEffectivelyVisible' inside 'HotkeyCommandWrapper.CanExecute'.
- Prevents HotKey from globally triggering and swallowing keyboard input when the host control or its parent panels are invisible (IsVisible="False").
- Added a corresponding unit test to verify input routing for hidden clickable controls.

Closes #21708

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 src/Avalonia.Controls/HotkeyManager.cs        | 12 ++++++-
 .../HotKeyedControlsTests.cs                  | 31 +++++++++++++++++++
 2 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/HotkeyManager.cs b/src/Avalonia.Controls/HotkeyManager.cs
index 06ff9cb18c..584a56a135 100644
--- a/src/Avalonia.Controls/HotkeyManager.cs
+++ b/src/Avalonia.Controls/HotkeyManager.cs
@@ -38,8 +38,18 @@ namespace Avalonia.Controls
 
             public bool CanExecute(object? parameter)
             {
-                if (reference.Target is { } target)
+                if (reference.Target is InputElement target)
                 {
+                    var current = target as Visual;
+                    while (current != null && current is not TopLevel)
+                    {
+                        if (!current.IsVisible)
+                        {
+                            return false;
+                        }
+                        current = current.VisualParent;
+                    }
+                    
                     if (target is ICommandSource commandSource && commandSource.Command is { } command)
                     {
                         return commandSource.IsEffectivelyEnabled
diff --git a/tests/Avalonia.Controls.UnitTests/HotKeyedControlsTests.cs b/tests/Avalonia.Controls.UnitTests/HotKeyedControlsTests.cs
index bdaa8d6a98..d27bc8d85c 100644
--- a/tests/Avalonia.Controls.UnitTests/HotKeyedControlsTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/HotKeyedControlsTests.cs
@@ -119,5 +119,36 @@ namespace Avalonia.Controls.UnitTests
             
             Assert.True(hotKeyedTextBox.IsFocused);
         }
+        
+        [Fact]
+        public void Hidden_Button_HotKey_Should_Not_Swallow_Input()
+        {
+            using var _ = CreateServicesWithFocus();
+            
+            var keyboardDevice = new KeyboardDevice();
+            var root = PreparedWindow();
+            var panel = new StackPanel { IsVisible = false };
+            var button = new Button { HotKey = KeyGesture.Parse("Escape") };
+    
+            bool buttonClicked = false;
+            button.Click += (s, e) => buttonClicked = true;
+
+            panel.Children.Add(button);
+            root.Content = panel;
+            root.Show();
+
+            keyboardDevice.ProcessRawEvent(
+                new RawKeyEventArgs(
+                    keyboardDevice,
+                    0,
+                    root.InputRoot,
+                    RawKeyEventType.KeyDown,
+                    Key.Escape,
+                    RawInputModifiers.None,
+                    PhysicalKey.Escape,
+                    ""));
+    
+            Assert.False(buttonClicked);
+        }
     }
 }

From c3a5c496999432b9f7878026631d51de67ecbbde Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Mon, 20 Jul 2026 18:51:36 +1000
Subject: [PATCH 095/196] fix(binding): reapply cached source values during
 UpdateTarget (#21756)

* Added failing test for #21746.

* fix(binding): reapply cached source values during UpdateTarget

UpdateTarget did not restore an uncommitted explicit two-way target value when the source still matched the binding expression's cached value. Equal-value suppression then prevented ValueStore from receiving the refresh.\n\nTrack the synchronous UpdateTarget rebuild and force publication only for that path, so the source value is reapplied without changing normal binding notification deduplication. The preceding regression test covers the observable behavior in both reflection and compiled binding paths.

---------

Co-authored-by: grokys <grokys@users.noreply.github.com>
---
 .../Data/Core/BindingExpression.cs            | 20 +++++++++++---
 ...dingExpressionTests.UpdateSourceTrigger.cs | 26 +++++++++++++++++++
 2 files changed, 42 insertions(+), 4 deletions(-)

diff --git a/src/Avalonia.Base/Data/Core/BindingExpression.cs b/src/Avalonia.Base/Data/Core/BindingExpression.cs
index 281e9f6b61..14c592b94c 100644
--- a/src/Avalonia.Base/Data/Core/BindingExpression.cs
+++ b/src/Avalonia.Base/Data/Core/BindingExpression.cs
@@ -31,6 +31,7 @@ internal class BindingExpression : UntypedBindingExpressionBase, IDescription, I
     private readonly List<ExpressionNode> _nodes;
     private readonly TargetTypeConverter? _targetTypeConverter;
     private readonly UncommonFields? _uncommon;
+    private int _updateTargetDepth;
     private bool _shouldUpdateOneTimeBindingTarget;
 
     /// <summary>
@@ -167,10 +168,19 @@ internal class BindingExpression : UntypedBindingExpressionBase, IDescription, I
 
         var source = _nodes[0].Source;
 
-        for (var i = 0; i < _nodes.Count; ++i)
-            _nodes[i].SetSource(AvaloniaProperty.UnsetValue, null);
+        ++_updateTargetDepth;
+
+        try
+        {
+            for (var i = 0; i < _nodes.Count; ++i)
+                _nodes[i].SetSource(AvaloniaProperty.UnsetValue, null);
 
-        _nodes[0].SetSource(source, null);
+            _nodes[0].SetSource(source, null);
+        }
+        finally
+        {
+            --_updateTargetDepth;
+        }
     }
 
     /// <summary>
@@ -206,7 +216,9 @@ internal class BindingExpression : UntypedBindingExpressionBase, IDescription, I
                     new BindingError(dataValidationError, BindingErrorType.DataValidationError) :
                     null;
 
-                var forceUpdate = _mode == BindingMode.OneWay;
+                // UpdateTarget must reapply the source value even if this expression already
+                // has it cached: a two-way target may contain an uncommitted local value.
+                var forceUpdate = _mode == BindingMode.OneWay || _updateTargetDepth > 0;
                 ConvertAndPublishValue(value, error, forceUpdate);
             }
         }
diff --git a/tests/Avalonia.Base.UnitTests/Data/Core/BindingExpressionTests.UpdateSourceTrigger.cs b/tests/Avalonia.Base.UnitTests/Data/Core/BindingExpressionTests.UpdateSourceTrigger.cs
index 434a0c38ae..83d887e3a8 100644
--- a/tests/Avalonia.Base.UnitTests/Data/Core/BindingExpressionTests.UpdateSourceTrigger.cs
+++ b/tests/Avalonia.Base.UnitTests/Data/Core/BindingExpressionTests.UpdateSourceTrigger.cs
@@ -111,5 +111,31 @@ namespace Avalonia.Base.UnitTests.Data.Core
             Assert.Equal("bar", target.String);
             Assert.Equal("bar", data.StringValue);
         }
+
+        [Fact]
+        public void TwoWay_Explicit_Should_Update_Target_On_Call_To_UpdateTarget()
+        {
+            var data = new ViewModel { StringValue = "foo" };
+            var (target, expression) = CreateTargetAndExpression<ViewModel, string?>(
+                o => o.StringValue,
+                mode: BindingMode.TwoWay,
+                source: data,
+                updateSourceTrigger: UpdateSourceTrigger.Explicit);
+
+            Assert.Equal("foo", target.String);
+            Assert.Equal("foo", data.StringValue);
+
+            target.String = "bar";
+
+            Assert.Equal("bar", target.String);
+            Assert.Equal("foo", data.StringValue);
+
+            // UpdateTarget forces a transfer from source to target, discarding the
+            // value set on the target.
+            expression.UpdateTarget();
+
+            Assert.Equal("foo", target.String);
+            Assert.Equal("foo", data.StringValue);
+        }
     }
 }

From 51bc95a45274c2b1626a8af36d70bbcd186e4f51 Mon Sep 17 00:00:00 2001
From: yoyo <zrt2399@163.com>
Date: Tue, 21 Jul 2026 01:50:21 +0800
Subject: [PATCH 096/196] Fix ComboBox dropdown not scrolling to selected item
 when opened (#21764)

---
 src/Avalonia.Controls/ComboBox.cs             |  7 +-
 .../ComboBoxTests.cs                          | 71 +++++++++++++++----
 2 files changed, 58 insertions(+), 20 deletions(-)

diff --git a/src/Avalonia.Controls/ComboBox.cs b/src/Avalonia.Controls/ComboBox.cs
index b0169d09f6..b9290d3c10 100644
--- a/src/Avalonia.Controls/ComboBox.cs
+++ b/src/Avalonia.Controls/ComboBox.cs
@@ -519,14 +519,9 @@ namespace Avalonia.Controls
             var selectedIndex = SelectedIndex;
             if (IsDropDownOpen && selectedIndex != -1)
             {
+                ScrollIntoView(selectedIndex);
                 var container = ContainerFromIndex(selectedIndex);
 
-                if (container == null && SelectedIndex != -1)
-                {
-                    ScrollIntoView(Selection.SelectedIndex);
-                    container = ContainerFromIndex(selectedIndex);
-                }
-
                 if (container != null && CanFocus(container))
                 {
                     container.Focus();
diff --git a/tests/Avalonia.Controls.UnitTests/ComboBoxTests.cs b/tests/Avalonia.Controls.UnitTests/ComboBoxTests.cs
index b3212ed0f7..0f7b37b4fe 100644
--- a/tests/Avalonia.Controls.UnitTests/ComboBoxTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ComboBoxTests.cs
@@ -19,7 +19,7 @@ namespace Avalonia.Controls.UnitTests
     public class ComboBoxTests : ScopedTestBase
     {
         MouseTestHelper _helper = new MouseTestHelper();
-        
+
         [Fact]
         public void Clicking_On_Control_Toggles_IsDropDownOpen()
         {
@@ -197,6 +197,7 @@ namespace Avalonia.Controls.UnitTests
                         new Popup
                         {
                             Name = "PART_Popup",
+                            [!!Popup.IsOpenProperty] = parent[!!ComboBox.IsDropDownOpenProperty],
                             Child = new ScrollViewer
                             {
                                 Name = "PART_ScrollViewer",
@@ -216,6 +217,48 @@ namespace Avalonia.Controls.UnitTests
             });
         }
 
+        [Fact]
+        public void Reopening_DropDown_Focuses_Selected_Item_After_Scrolled_To_Top()
+        {
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow.With(
+                keyboardDevice: () => new KeyboardDevice(),
+                keyboardNavigation: () => new KeyboardNavigationHandler()));
+
+            var target = new ComboBox { Template = GetTemplate() };
+
+            for (var i = 0; i < 100; ++i)
+            {
+                var item = new ComboBoxItem { Content = $"Item {i}" };
+                target.Items.Add(item);
+            }
+
+            var selectedItem = target.Items[60] as ComboBoxItem;
+            Assert.True(selectedItem != null);
+
+            var window = new Window { Content = target };
+            window.Show();
+            window.LayoutManager.ExecuteInitialLayoutPass();
+            target.ApplyTemplate();
+            target.Presenter!.ApplyTemplate();
+
+            var scrollViewer = target.GetVisualDescendants().OfType<ScrollViewer>().First();
+            Assert.True(scrollViewer != null);
+
+            target.SelectedItem = selectedItem;
+            target.Focus();
+            target.IsDropDownOpen = true;
+            window.LayoutManager.ExecuteLayoutPass();
+
+            scrollViewer.ScrollToHome();
+            target.IsDropDownOpen = false;
+            window.LayoutManager.ExecuteLayoutPass();
+
+            target.IsDropDownOpen = true;
+            window.LayoutManager.ExecuteLayoutPass();
+
+            Assert.True(selectedItem.IsFocused && selectedItem.IsVisible);
+        }
+
         [Fact]
         public void Detaching_Closed_ComboBox_Keeps_Current_Focus()
         {
@@ -381,7 +424,7 @@ namespace Avalonia.Controls.UnitTests
 
                 target.ApplyTemplate();
                 target.Presenter!.ApplyTemplate();
-                
+
                 var exception = new System.InvalidCastException("failed validation");
                 var textObservable = new BehaviorSubject<BindingNotification>(new BindingNotification(exception, BindingErrorType.DataValidationError));
                 target.Bind(ComboBox.SelectedItemProperty, textObservable);
@@ -389,7 +432,7 @@ namespace Avalonia.Controls.UnitTests
                 Assert.True(DataValidationErrors.GetHasErrors(target));
                 Assert.Equal([exception], DataValidationErrors.GetErrors(target));
             }
-            
+
         }
 
         [Fact]
@@ -404,7 +447,7 @@ namespace Avalonia.Controls.UnitTests
 
                 target.ApplyTemplate();
                 target.Presenter!.ApplyTemplate();
-                
+
                 var exception = new System.InvalidCastException("failed validation");
                 var textObservable = new BehaviorSubject<BindingNotification>(new BindingNotification(exception, BindingErrorType.DataValidationError));
                 target.Bind(ComboBox.TextProperty, textObservable);
@@ -426,8 +469,8 @@ namespace Avalonia.Controls.UnitTests
 
                 window.KeyDown += (s, e) =>
                  {
-                     if (e.Handled == false 
-                     && e.KeyModifiers.HasAllFlags(KeyModifiers.Alt) == true 
+                     if (e.Handled == false
+                     && e.KeyModifiers.HasAllFlags(KeyModifiers.Alt) == true
                      && e.Key == Key.F4 )
                      {
                          e.Handled = true;
@@ -511,7 +554,7 @@ namespace Avalonia.Controls.UnitTests
             };
             var target = new ComboBox
             {
-                Items = 
+                Items =
                 {
                     new ComboBoxItem()
                     {
@@ -531,7 +574,7 @@ namespace Avalonia.Controls.UnitTests
 
             parentContent.FlowDirection = FlowDirection.RightToLeft;
             target.FlowDirection = FlowDirection.RightToLeft;
-            
+
             Assert.Equal(FlowDirection.RightToLeft, rectangle.FlowDirection);
         }
 
@@ -571,7 +614,7 @@ namespace Avalonia.Controls.UnitTests
                 var popup = target.GetVisualDescendants().OfType<Popup>().First();
                 popup.PlacementTarget = new Window();
                 popup.Open();
-                
+
                 Assert.Equal(FlowDirection.RightToLeft, rectangle.FlowDirection);
             }
         }
@@ -587,10 +630,10 @@ namespace Avalonia.Controls.UnitTests
                 SelectionBoxItemTemplate = selectionBoxItemTemplate,
                 ItemTemplate = itemTemplate,
             };
-            
+
             Assert.Equal(selectionBoxItemTemplate, target.SelectionBoxItemTemplate);
         }
-        
+
         [Fact]
         public void SelectionBoxItemTemplate_Inherits_From_ItemTemplate_When_NotSet()
         {
@@ -600,7 +643,7 @@ namespace Avalonia.Controls.UnitTests
                 ItemsSource = new []{ "Foo" },
                 ItemTemplate = itemTemplate,
             };
-            
+
             Assert.Equal(itemTemplate, target.SelectionBoxItemTemplate);
         }
 
@@ -618,9 +661,9 @@ namespace Avalonia.Controls.UnitTests
             };
 
             Assert.Equal(selectionBoxItemTemplate, target.SelectionBoxItemTemplate);
-            
+
             target.ItemTemplate = itemTemplate2;
-            
+
             Assert.Equal(selectionBoxItemTemplate, target.SelectionBoxItemTemplate);
         }
 

From f8dd4248ca23070b510dde9a488c88185a394d91 Mon Sep 17 00:00:00 2001
From: Victor Chelaru <victor.chelaru@scribehow.com>
Date: Mon, 20 Jul 2026 12:26:44 -0600
Subject: [PATCH 097/196] Fix off-thread accessibility hit-test crash on macOS
 (#21779)

* Fix off-thread accessibility hit-test crash on macOS

GetAutomationPeer() returns null when called off the UI thread, but
-[AvnWindow automationPeer] called SetNode on it without checking, which
segfaults. Guard against the null peer so it returns nil instead.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Removed comment

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 native/Avalonia.Native/src/OSX/AvnWindow.mm     | 12 ++++++++----
 native/Avalonia.Native/src/OSX/WindowProtocol.h |  2 +-
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/native/Avalonia.Native/src/OSX/AvnWindow.mm b/native/Avalonia.Native/src/OSX/AvnWindow.mm
index b2f20d556b..de0c796d4a 100644
--- a/native/Avalonia.Native/src/OSX/AvnWindow.mm
+++ b/native/Avalonia.Native/src/OSX/AvnWindow.mm
@@ -628,14 +628,18 @@
     return GetNSStringAndRelease(automationPeer->GetAutomationId());
 }
 
-- (IAvnAutomationPeer* _Nonnull) automationPeer
+- (IAvnAutomationPeer* _Nullable) automationPeer
 {
     auto parent = _parent.tryGet();
     if (parent && _automationPeer == nullptr)
     {
-        _automationPeer = parent->BaseEvents->GetAutomationPeer();
-        _automationNode = new AvnAutomationNode(self);
-        _automationPeer->SetNode(_automationNode);
+        auto peer = parent->BaseEvents->GetAutomationPeer();
+        if (peer != nullptr)
+        {
+            _automationPeer = peer;
+            _automationNode = new AvnAutomationNode(self);
+            _automationPeer->SetNode(_automationNode);
+        }
     }
 
     return _automationPeer;
diff --git a/native/Avalonia.Native/src/OSX/WindowProtocol.h b/native/Avalonia.Native/src/OSX/WindowProtocol.h
index 5d1df951a6..0e1091b86c 100644
--- a/native/Avalonia.Native/src/OSX/WindowProtocol.h
+++ b/native/Avalonia.Native/src/OSX/WindowProtocol.h
@@ -17,7 +17,7 @@ struct IAvnAutomationPeer;
 -(void) showAppMenuOnly;
 -(void) showWindowMenuWithAppMenu;
 -(void) applyMenu:(AvnMenu* _Nullable)menu;
--(IAvnAutomationPeer* _Nonnull) automationPeer;
+-(IAvnAutomationPeer* _Nullable) automationPeer;
 
 -(double) getExtendedTitleBarHeight;
 -(void) setIsExtended:(bool)value;

From 0b3243e9c074d6d77f8e6fba5b718c0ef89c9d9c Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Tue, 21 Jul 2026 06:00:13 +1000
Subject: [PATCH 098/196] Fix headless session hang when cleanup throws
 (#21781)

* test(headless): reproduce cleanup exception dispatch hang

A dispatcher job that throws during work-item cleanup leaves the dispatch task incomplete and prevents later work from running. The session contract requires every queued dispatch to reach a terminal state.

Add behavioral coverage that posts a throwing cleanup job, expects its exception from Dispatch, and verifies the assembly session can process the next dispatch. The shared NUnit test runs under both PerTest and PerAssembly projects.

* fix(headless): report dispatch cleanup exceptions

An exception during application cleanup escapes the work item before its completion source is settled, faults the private consumer task, and leaves current and future Dispatch calls waiting forever.

Capture cleanup failures as the work item's exception so the consumer can continue. Restore synchronization context, locator scope, and dispatcher state in finally blocks before processing later work.

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../HeadlessUnitTestSession.cs                | 46 +++++++++++++++----
 .../HeadlessUnitTestSessionTests.cs           | 32 +++++++++++++
 2 files changed, 69 insertions(+), 9 deletions(-)
 create mode 100644 tests/Avalonia.Headless.UnitTests/HeadlessUnitTestSessionTests.cs

diff --git a/src/Headless/Avalonia.Headless/HeadlessUnitTestSession.cs b/src/Headless/Avalonia.Headless/HeadlessUnitTestSession.cs
index 5613244461..f215d867f0 100644
--- a/src/Headless/Avalonia.Headless/HeadlessUnitTestSession.cs
+++ b/src/Headless/Avalonia.Headless/HeadlessUnitTestSession.cs
@@ -145,7 +145,16 @@ public sealed class HeadlessUnitTestSession : IDisposable, IAsyncDisposable
             }
             finally
             {
-                application.Dispose();
+                try
+                {
+                    application.Dispose();
+                }
+                catch (Exception ex)
+                {
+                    // Cleanup runs before the TCS is completed, so its failure must be
+                    // reported by this work item instead of escaping the consumer loop.
+                    caught = ex;
+                }
             }
 
             if (caught != null)
@@ -173,8 +182,14 @@ public sealed class HeadlessUnitTestSession : IDisposable, IAsyncDisposable
 
         return Disposable.Create(() =>
         {
-            Dispatcher.UIThread.RunJobs();
-            SynchronizationContext.SetSynchronizationContext(oldContext);
+            try
+            {
+                Dispatcher.UIThread.RunJobs();
+            }
+            finally
+            {
+                SynchronizationContext.SetSynchronizationContext(oldContext);
+            }
         });
     }
 
@@ -195,12 +210,25 @@ public sealed class HeadlessUnitTestSession : IDisposable, IAsyncDisposable
 
         return Disposable.Create(() =>
         {
-            ((ToolTipService?)AvaloniaLocator.Current.GetService<IToolTipService>())?.Dispose();
-            (AvaloniaLocator.Current.GetService<FontManager>() as IDisposable)?.Dispose();
-            Dispatcher.ResetForUnitTests();
-            scope.Dispose();
-            Dispatcher.ResetBeforeUnitTests();
-            SynchronizationContext.SetSynchronizationContext(oldContext);
+            try
+            {
+                ((ToolTipService?)AvaloniaLocator.Current.GetService<IToolTipService>())?.Dispose();
+                (AvaloniaLocator.Current.GetService<FontManager>() as IDisposable)?.Dispose();
+                Dispatcher.ResetForUnitTests();
+            }
+            finally
+            {
+                // Cleanup jobs can throw, but the ambient state still belongs to this dispatch.
+                try
+                {
+                    scope.Dispose();
+                }
+                finally
+                {
+                    Dispatcher.ResetBeforeUnitTests();
+                    SynchronizationContext.SetSynchronizationContext(oldContext);
+                }
+            }
         });
     }
 
diff --git a/tests/Avalonia.Headless.UnitTests/HeadlessUnitTestSessionTests.cs b/tests/Avalonia.Headless.UnitTests/HeadlessUnitTestSessionTests.cs
new file mode 100644
index 0000000000..7372dd639a
--- /dev/null
+++ b/tests/Avalonia.Headless.UnitTests/HeadlessUnitTestSessionTests.cs
@@ -0,0 +1,32 @@
+#if NUNIT
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Avalonia.Threading;
+
+namespace Avalonia.Headless.UnitTests;
+
+public class HeadlessUnitTestSessionTests
+{
+    [Test]
+    public async Task Dispatch_Should_Report_Cleanup_Exceptions_And_Continue()
+    {
+        var session = HeadlessUnitTestSession.GetOrStartForAssembly(GetType().Assembly);
+
+        const string message = "Thrown by a dispatcher job during cleanup.";
+        var poisonedDispatch = session.Dispatch(
+            () => Dispatcher.UIThread.Post(() => throw new InvalidOperationException(message)),
+            CancellationToken.None);
+
+        var exception = Assert.ThrowsAsync<InvalidOperationException>(async () =>
+            await poisonedDispatch.WaitAsync(TimeSpan.FromSeconds(10)));
+
+        Assert.That(exception!.Message, Is.EqualTo(message));
+
+        var result = await session.Dispatch(() => 42, CancellationToken.None)
+            .WaitAsync(TimeSpan.FromSeconds(10));
+
+        Assert.That(result, Is.EqualTo(42));
+    }
+}
+#endif

From c8da7f891edbb25a303edb77948735967f3ee9be Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Tue, 21 Jul 2026 17:49:59 +1000
Subject: [PATCH 099/196] fix: detach platform input when presentation source
 closes (#21782)

* test: cover platform input detachment on close

Closed top levels retain the presentation source as the platform input callback. A late platform input event can therefore target an already disposed visual tree.\n\nThe regression test requires top-level closure to clear ITopLevelImpl.Input.

* fix: detach platform input when presentation source closes

Win32 can deliver WM_CAPTURECHANGED while destroying a popup that owns mouse capture. The platform then calls the input handler retained by the disposed presentation source, which logs a warning and can route input into a detached visual tree.\n\nClear the platform input callback at the start of presentation source disposal, alongside the existing scaling event unsubscription.

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../PresentationSource/PresentationSource.cs       |  7 ++++++-
 .../PresentationSourceTests.cs                     | 14 ++++++++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/PresentationSource/PresentationSource.cs b/src/Avalonia.Controls/PresentationSource/PresentationSource.cs
index c2d5516667..60ec963e6f 100644
--- a/src/Avalonia.Controls/PresentationSource/PresentationSource.cs
+++ b/src/Avalonia.Controls/PresentationSource/PresentationSource.cs
@@ -77,6 +77,12 @@ internal partial class PresentationSource : IPresentationSource, IInputRoot, IDi
 
     public void Dispose()
     {
+        if (PlatformImpl is { } platformImpl)
+        {
+            platformImpl.Input = null;
+            platformImpl.ScalingChanged -= HandleScalingChanged;
+        }
+
         _layoutDiagnosticBridge?.Dispose();
         _layoutDiagnosticBridge = null;
         LayoutManager.Dispose();
@@ -84,7 +90,6 @@ internal partial class PresentationSource : IPresentationSource, IInputRoot, IDi
         // We need to wait for the renderer to complete any in-flight operations
         Renderer.Dispose();
 
-        PlatformImpl?.ScalingChanged -= HandleScalingChanged;
         PlatformImpl = null;
         _pointerOverPreProcessor?.OnCompleted();
         _pointerOverPreProcessorSubscription?.Dispose();
diff --git a/tests/Avalonia.Controls.UnitTests/PresentationSourceTests.cs b/tests/Avalonia.Controls.UnitTests/PresentationSourceTests.cs
index 97892e9b4c..9a8172d3cf 100644
--- a/tests/Avalonia.Controls.UnitTests/PresentationSourceTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/PresentationSourceTests.cs
@@ -19,6 +19,20 @@ namespace Avalonia.Controls.UnitTests;
 
 public sealed class PresentationSourceTests : ScopedTestBase
 {
+    [Fact]
+    public void Closing_Should_Detach_Platform_Input_Handler()
+    {
+        using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+        var windowImpl = MockWindowingPlatform.CreateWindowMock();
+        var window = new Window(windowImpl.Object);
+
+        Assert.NotNull(windowImpl.Object.Input);
+
+        windowImpl.Object.Closed!();
+
+        Assert.Null(windowImpl.Object.Input);
+    }
+
     [Fact]
     public void ChromeHitTest_Prefers_Overlay_Over_Content()
     {

From 14118ef7cd57f515b61e504dffa251b7f9201ca0 Mon Sep 17 00:00:00 2001
From: Dong Bin <14807942+rabbitism@users.noreply.github.com>
Date: Tue, 21 Jul 2026 17:15:15 +0800
Subject: [PATCH 100/196] Fix line break enumerator infinite loop (#21808)

* Add failing test: LineBreakEnumerator infinite loop on empty string

* Return false immediately for empty string in LineBreakEnumerator

Empty text has no content and should not produce any line break
opportunities. Short-circuit in MoveNext before entering the
read/rule loop, while keeping the PeekAt EndOfText fix as a
defensive safeguard.
---
 .../Media/TextFormatting/Unicode/LineBreakEnumerator.cs   | 5 +++++
 .../Media/TextFormatting/LineBreakEnumeratorTests.cs      | 8 ++++++++
 2 files changed, 13 insertions(+)

diff --git a/src/Avalonia.Base/Media/TextFormatting/Unicode/LineBreakEnumerator.cs b/src/Avalonia.Base/Media/TextFormatting/Unicode/LineBreakEnumerator.cs
index 576f0ad872..2198a18cd3 100644
--- a/src/Avalonia.Base/Media/TextFormatting/Unicode/LineBreakEnumerator.cs
+++ b/src/Avalonia.Base/Media/TextFormatting/Unicode/LineBreakEnumerator.cs
@@ -24,6 +24,11 @@ namespace Avalonia.Media.TextFormatting.Unicode
         {
             lineBreak = default;
 
+            if (_text.IsEmpty)
+            {
+                return false;
+            }
+
             if (_state.Current.EndOfText)
             {
                 return false;
diff --git a/tests/Avalonia.Base.UnitTests/Media/TextFormatting/LineBreakEnumeratorTests.cs b/tests/Avalonia.Base.UnitTests/Media/TextFormatting/LineBreakEnumeratorTests.cs
index 59ddf6932e..56d346fc59 100644
--- a/tests/Avalonia.Base.UnitTests/Media/TextFormatting/LineBreakEnumeratorTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Media/TextFormatting/LineBreakEnumeratorTests.cs
@@ -19,6 +19,14 @@ namespace Avalonia.Base.UnitTests.Media.TextFormatting
             _outputHelper = outputHelper;
         }
 
+        [Fact]
+        public void ShouldHandleEmptyString()
+        {
+            var lineBreaker = new LineBreakEnumerator(string.Empty);
+
+            Assert.False(lineBreaker.MoveNext(out _));
+        }
+
         [Fact]
         public void BasicLatinTest()
         {

From efaa9260bcdaa3d140a4f4a92cc24357f4e36b9a Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Tue, 21 Jul 2026 14:15:36 +0500
Subject: [PATCH 101/196] Run render tests against llvmpipe/lavapipe MESA
 rasterizers (#21790)

* Run render tests against llvmpipe/lavapipe MESA rasterizers

* CI?

* Try desktop gl on mac?

* disable vulkan on mac
---
 Directory.Packages.props                      |   1 +
 src/Avalonia.OpenGL/Egl/EglConsts.cs          |   3 +
 src/Avalonia.OpenGL/Egl/EglDisplay.cs         |   3 +-
 src/Avalonia.OpenGL/Egl/EglDisplayOptions.cs  |   6 +
 src/Avalonia.OpenGL/Egl/EglDisplayUtils.cs    |   9 +-
 src/Avalonia.OpenGL/GlInterface.cs            |   3 +
 src/Avalonia.Vulkan/Avalonia.Vulkan.csproj    |   4 +
 src/Avalonia.Vulkan/IVulkanPlatformSurface.cs |  11 +
 .../Interop/VulkanDevice.Create.cs            |   8 +-
 src/Avalonia.Vulkan/Interop/VulkanInstance.cs |   5 +-
 .../UnmanagedInterop/VulkanDeviceApi.cs       |  38 +++-
 .../UnmanagedInterop/VulkanEnums.cs           |   7 +
 .../UnmanagedInterop/VulkanInstanceApi.cs     |  10 +-
 .../UnmanagedInterop/VulkanStructs.cs         |  27 +++
 src/Avalonia.Vulkan/VulkanContext.cs          |   3 +
 src/Avalonia.Vulkan/VulkanOptions.cs          |  14 +-
 .../Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs |  14 ++
 .../Composition/DirectFbCompositionTests.cs   |   4 +-
 .../Controls/AdornerTests.cs                  |   6 +-
 .../Controls/CommandBarTests.cs               |   2 +-
 .../Media/DrawingContentTests.cs              |   4 +-
 .../Media/VisualBrushTests.cs                 |   2 +-
 .../Mesa/FboReadbackGlPlatformSurface.cs      | 202 ++++++++++++++++++
 .../Mesa/MesaSoftwareRenderer.cs              |  98 +++++++++
 .../Mesa/VulkanReadbackPlatformSurface.cs     | 200 +++++++++++++++++
 .../Shapes/EllipseTests.cs                    |   2 +-
 .../Avalonia.RenderTests/Shapes/PathTests.cs  |   2 +-
 tests/Avalonia.RenderTests/TestBase.cs        |  48 +++--
 .../Avalonia.RenderTests/TestRenderHelper.cs  | 109 +++++++---
 .../Avalonia.Skia.RenderTests.csproj          |   1 +
 30 files changed, 776 insertions(+), 70 deletions(-)
 create mode 100644 tests/Avalonia.RenderTests/Mesa/FboReadbackGlPlatformSurface.cs
 create mode 100644 tests/Avalonia.RenderTests/Mesa/MesaSoftwareRenderer.cs
 create mode 100644 tests/Avalonia.RenderTests/Mesa/VulkanReadbackPlatformSurface.cs

diff --git a/Directory.Packages.props b/Directory.Packages.props
index da5809c36d..941451d635 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -66,6 +66,7 @@
     <PackageVersion Include="System.Text.Json" Version="10.0.0" />
     <PackageVersion Include="System.Text.RegularExpressions" Version="4.3.1" />
     <PackageVersion Include="Tmds.DBus.Protocol" Version="0.94.1" />
+    <PackageVersion Include="unofficial.mesa.softwarerenderer" Version="25.3.6.29" />
     <PackageVersion Include="Tmds.DBus.Generator" Version="0.94.1" />
     <PackageVersion Include="Xamarin.AndroidX.AppCompat" Version="1.7.1.3" />
     <PackageVersion Include="Xamarin.AndroidX.Core.SplashScreen" Version="1.2.0.2" />
diff --git a/src/Avalonia.OpenGL/Egl/EglConsts.cs b/src/Avalonia.OpenGL/Egl/EglConsts.cs
index a1969c7805..f4205f8637 100644
--- a/src/Avalonia.OpenGL/Egl/EglConsts.cs
+++ b/src/Avalonia.OpenGL/Egl/EglConsts.cs
@@ -205,6 +205,9 @@ namespace Avalonia.OpenGL.Egl
         // EGL_KHR_platform_gbm / EGL_MESA_platform_gbm
         public const int  EGL_PLATFORM_GBM_KHR = 0x31D7;
 
+        // EGL_MESA_platform_surfaceless
+        public const int  EGL_PLATFORM_SURFACELESS_MESA = 0x31DD;
+
         public const int  EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE = 0x3207;
         public const int  EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE = 0x3208;
         
diff --git a/src/Avalonia.OpenGL/Egl/EglDisplay.cs b/src/Avalonia.OpenGL/Egl/EglDisplay.cs
index 1b0761eeb4..3cb6a504e8 100644
--- a/src/Avalonia.OpenGL/Egl/EglDisplay.cs
+++ b/src/Avalonia.OpenGL/Egl/EglDisplay.cs
@@ -45,7 +45,8 @@ namespace Avalonia.OpenGL.Egl
             if(_display == IntPtr.Zero)
                 throw new ArgumentException();
 
-            _config = EglDisplayUtils.InitializeAndGetConfig(_egl, display, options.GlVersions, options.ProbeConfig);
+            _config = EglDisplayUtils.InitializeAndGetConfig(_egl, display, options.GlVersions, options.ProbeConfig,
+                options.AllowPbufferOnlyConfigs);
         }
         
         public EglInterface EglInterface => _egl;
diff --git a/src/Avalonia.OpenGL/Egl/EglDisplayOptions.cs b/src/Avalonia.OpenGL/Egl/EglDisplayOptions.cs
index 2963890d32..7f2e4a310c 100644
--- a/src/Avalonia.OpenGL/Egl/EglDisplayOptions.cs
+++ b/src/Avalonia.OpenGL/Egl/EglDisplayOptions.cs
@@ -16,6 +16,12 @@ public class EglDisplayOptions
     public EglInterface? Egl { get; set; }
     public bool SupportsContextSharing { get; set; }
     public bool SupportsMultipleContexts { get; set; }
+
+    /// <summary>
+    /// Also considers configs that can only be used with PBuffer surfaces. Required for EGL platforms
+    /// that have no window surface support at all, e.g. EGL_MESA_platform_surfaceless.
+    /// </summary>
+    public bool AllowPbufferOnlyConfigs { get; set; }
     public bool ContextLossIsDisplayLoss { get; set; }
     public Func<bool>? DeviceLostCheckCallback { get; set; }
     public Action? DisposeCallback { get; set; }
diff --git a/src/Avalonia.OpenGL/Egl/EglDisplayUtils.cs b/src/Avalonia.OpenGL/Egl/EglDisplayUtils.cs
index b214f6d85e..91c2798533 100644
--- a/src/Avalonia.OpenGL/Egl/EglDisplayUtils.cs
+++ b/src/Avalonia.OpenGL/Egl/EglDisplayUtils.cs
@@ -50,7 +50,8 @@ internal static class EglDisplayUtils
     }
 
     public static EglConfigInfo InitializeAndGetConfig(EglInterface egl, IntPtr display,
-        IEnumerable<GlVersion>? versions, EglConfigProbeCallback? probeConfig = null)
+        IEnumerable<GlVersion>? versions, EglConfigProbeCallback? probeConfig = null,
+        bool allowPbufferOnlyConfigs = false)
     {
         if (!egl.Initialize(display, out _, out _))
             throw OpenGlException.GetFormattedException("eglInitialize", egl);
@@ -123,11 +124,15 @@ internal static class EglDisplayUtils
                 }
             });
 
+        var surfaceTypes = allowPbufferOnlyConfigs
+            ? new[] { EGL_PBUFFER_BIT | EGL_WINDOW_BIT, EGL_WINDOW_BIT, EGL_PBUFFER_BIT }
+            : new[] { EGL_PBUFFER_BIT | EGL_WINDOW_BIT, EGL_WINDOW_BIT };
+
         foreach (var cfg in cfgs)
         {
             if (!egl.BindApi(cfg.Api))
                 continue;
-            foreach (var surfaceType in new[] { EGL_PBUFFER_BIT | EGL_WINDOW_BIT, EGL_WINDOW_BIT })
+            foreach (var surfaceType in surfaceTypes)
             foreach (var stencilSize in new[] { 8, 1, 0 })
             foreach (var depthSize in new[] { 8, 1, 0 })
             {
diff --git a/src/Avalonia.OpenGL/GlInterface.cs b/src/Avalonia.OpenGL/GlInterface.cs
index 7cbd11c072..7670281198 100644
--- a/src/Avalonia.OpenGL/GlInterface.cs
+++ b/src/Avalonia.OpenGL/GlInterface.cs
@@ -103,6 +103,9 @@ namespace Avalonia.OpenGL
         [GetProcAddress("glFinish")]
         public partial void Finish();
 
+        [GetProcAddress("glReadPixels")]
+        public partial void ReadPixels(int x, int y, int width, int height, int format, int type, IntPtr data);
+
         [GetProcAddress("glGenFramebuffers")]
         public partial void GenFramebuffers(int count, int* res);
 
diff --git a/src/Avalonia.Vulkan/Avalonia.Vulkan.csproj b/src/Avalonia.Vulkan/Avalonia.Vulkan.csproj
index 964648e5d7..810dfcccb9 100644
--- a/src/Avalonia.Vulkan/Avalonia.Vulkan.csproj
+++ b/src/Avalonia.Vulkan/Avalonia.Vulkan.csproj
@@ -10,6 +10,10 @@
       <ProjectReference Include="..\Avalonia.Controls\Avalonia.Controls.csproj" />
     </ItemGroup>
 
+    <ItemGroup Label="InternalsVisibleTo">
+      <InternalsVisibleTo Include="Avalonia.Skia.RenderTests, PublicKey=$(AvaloniaPublicKey)" />
+    </ItemGroup>
+
     <Import Project="..\..\build\DevAnalyzers.props" />
     <Import Project="..\..\build\SourceGenerators.props" />
     <Import Project="..\..\build\TrimmingEnable.props" />
diff --git a/src/Avalonia.Vulkan/IVulkanPlatformSurface.cs b/src/Avalonia.Vulkan/IVulkanPlatformSurface.cs
index 3c281c0bc9..6717951cea 100644
--- a/src/Avalonia.Vulkan/IVulkanPlatformSurface.cs
+++ b/src/Avalonia.Vulkan/IVulkanPlatformSurface.cs
@@ -1,4 +1,5 @@
 using System;
+using Avalonia.Metadata;
 using Avalonia.Platform.Surfaces;
 
 namespace Avalonia.Vulkan;
@@ -9,6 +10,16 @@ public interface IVulkanKhrSurfacePlatformSurface : IDisposable, IPlatformRender
     ulong CreateSurface(IVulkanPlatformGraphicsContext context);
 }
 
+/// <summary>
+/// A platform render surface that provides its own <see cref="IVulkanRenderTarget"/>,
+/// e.g. an offscreen image-based target that doesn't involve a swapchain.
+/// </summary>
+[PrivateApi]
+public interface IVulkanRenderTargetPlatformSurface : IPlatformRenderSurface
+{
+    IVulkanRenderTarget CreateRenderTarget(IVulkanPlatformGraphicsContext context);
+}
+
 public interface IVulkanKhrSurfacePlatformSurfaceFactory
 {
     bool CanRenderToSurface(IVulkanPlatformGraphicsContext context, IPlatformRenderSurface surface);
diff --git a/src/Avalonia.Vulkan/Interop/VulkanDevice.Create.cs b/src/Avalonia.Vulkan/Interop/VulkanDevice.Create.cs
index 08d1f637ab..3a362f7b4a 100644
--- a/src/Avalonia.Vulkan/Interop/VulkanDevice.Create.cs
+++ b/src/Avalonia.Vulkan/Interop/VulkanDevice.Create.cs
@@ -68,8 +68,10 @@ internal unsafe partial class VulkanDevice
         var enableExtensions =
             new HashSet<string>(options.DeviceExtensions.Concat(VulkanExternalObjectsFeature.RequiredDeviceExtensions));
 
-        var enabledExtensions = enableExtensions
-            .Intersect(dev.Extensions).Append(VK_KHR_swapchain).Distinct().ToArray();
+        var filteredExtensions = enableExtensions.Intersect(dev.Extensions);
+        if (options.RequireSwapchainExtension)
+            filteredExtensions = filteredExtensions.Append(VK_KHR_swapchain);
+        var enabledExtensions = filteredExtensions.Distinct().ToArray();
 
         using var pEnabledExtensions = new Utf8BufferArray(enabledExtensions);
 
@@ -127,7 +129,7 @@ internal unsafe partial class VulkanDevice
         instance.GetPhysicalDeviceProperties(physicalDevice, out var properties);
 
         var supportedExtensions = GetDeviceExtensions(instance, physicalDevice);
-        if (!supportedExtensions.Contains(VK_KHR_swapchain))
+        if (options.RequireSwapchainExtension && !supportedExtensions.Contains(VK_KHR_swapchain))
             return null;
         
         uint familyCount = 0;
diff --git a/src/Avalonia.Vulkan/Interop/VulkanInstance.cs b/src/Avalonia.Vulkan/Interop/VulkanInstance.cs
index a4b9c8bbf8..390b6b906d 100644
--- a/src/Avalonia.Vulkan/Interop/VulkanInstance.cs
+++ b/src/Avalonia.Vulkan/Interop/VulkanInstance.cs
@@ -48,8 +48,9 @@ internal class VulkanInstance : IVulkanInstance
         };
 
         var enabledExtensions = new HashSet<string>(options.InstanceExtensions
-            .Concat(platformOptions.RequiredInstanceExtensions)
-            .Append("VK_KHR_surface"));
+            .Concat(platformOptions.RequiredInstanceExtensions));
+        if (options.RequireSurfaceExtension)
+            enabledExtensions.Add("VK_KHR_surface");
         
         var enabledLayers = options.EnabledLayers.ToList();
 
diff --git a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanDeviceApi.cs b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanDeviceApi.cs
index f3f3e5f824..74d146c9a6 100644
--- a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanDeviceApi.cs
+++ b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanDeviceApi.cs
@@ -103,6 +103,32 @@ internal unsafe partial class VulkanDeviceApi
     public partial void DestroyImageView(VkDevice device, VkImageView imageView, IntPtr pAllocator);
     
 
+    [GetProcAddress("vkCreateBuffer")]
+    public partial VkResult CreateBuffer(VkDevice device, ref VkBufferCreateInfo pCreateInfo, IntPtr pAllocator,
+        out VkBuffer pBuffer);
+
+    [GetProcAddress("vkDestroyBuffer")]
+    public partial void DestroyBuffer(VkDevice device, VkBuffer buffer, IntPtr pAllocator);
+
+    [GetProcAddress("vkGetBufferMemoryRequirements")]
+    public partial void GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+        out VkMemoryRequirements pMemoryRequirements);
+
+    [GetProcAddress("vkBindBufferMemory")]
+    public partial VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
+        VkDeviceSize memoryOffset);
+
+    [GetProcAddress("vkMapMemory")]
+    public partial VkResult MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size,
+        uint32_t flags, out IntPtr ppData);
+
+    [GetProcAddress("vkUnmapMemory")]
+    public partial void UnmapMemory(VkDevice device, VkDeviceMemory memory);
+
+    [GetProcAddress("vkCmdCopyImageToBuffer")]
+    public partial void CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
+        VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, VkBufferImageCopy* pRegions);
+
     [GetProcAddress("vkCmdPipelineBarrier")]
     public partial void CmdPipelineBarrier(VkCommandBuffer commandBuffer,
         VkPipelineStageFlags srcStageMask,
@@ -115,14 +141,14 @@ internal unsafe partial class VulkanDeviceApi
         uint32_t imageMemoryBarrierCount,
         VkImageMemoryBarrier* pImageMemoryBarriers);
     
-    [GetProcAddress("vkCreateSwapchainKHR")]
+    [GetProcAddress("vkCreateSwapchainKHR", true)]
     public partial VkResult CreateSwapchainKHR(VkDevice device, ref VkSwapchainCreateInfoKHR pCreateInfo,
         IntPtr pAllocator, out VkSwapchainKHR pSwapchain);
-    
-    [GetProcAddress("vkDestroySwapchainKHR")]
+
+    [GetProcAddress("vkDestroySwapchainKHR", true)]
     public partial void DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, IntPtr pAllocator);
 
-    [GetProcAddress("vkGetSwapchainImagesKHR")]
+    [GetProcAddress("vkGetSwapchainImagesKHR", true)]
     public partial VkResult GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, ref uint32_t pSwapchainImageCount,
         VkImage* pSwapchainImages);
 
@@ -132,7 +158,7 @@ internal unsafe partial class VulkanDeviceApi
     [GetProcAddress("vkQueueWaitIdle")]
     public partial VkResult QueueWaitIdle(VkQueue queue);
 
-    [GetProcAddress("vkAcquireNextImageKHR")]
+    [GetProcAddress("vkAcquireNextImageKHR", true)]
     public partial VkResult AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
         VkSemaphore semaphore, VkFence fence, out uint32_t pImageIndex);
 
@@ -140,7 +166,7 @@ internal unsafe partial class VulkanDeviceApi
     public partial void CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
         VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, VkImageBlit* pRegions, VkFilter filter);
 
-    [GetProcAddress("vkQueuePresentKHR")]
+    [GetProcAddress("vkQueuePresentKHR", true)]
     public partial VkResult vkQueuePresentKHR(VkQueue queue, ref VkPresentInfoKHR pPresentInfo);
 
     [GetProcAddress("vkImportSemaphoreFdKHR", true)]
diff --git a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanEnums.cs b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanEnums.cs
index e3530489f4..66930a8c38 100644
--- a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanEnums.cs
+++ b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanEnums.cs
@@ -1688,6 +1688,13 @@ namespace Avalonia.Vulkan.UnmanagedInterop
         VK_ACCESS_NONE_KHR = VK_ACCESS_NONE,
     }
 
+    [Flags]
+    enum VkBufferUsageFlags
+    {
+        VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+        VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
+    }
+
     [Flags]
     enum VkImageUsageFlags
     {
diff --git a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanInstanceApi.cs b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanInstanceApi.cs
index 9a64319b00..bc1c64a185 100644
--- a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanInstanceApi.cs
+++ b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanInstanceApi.cs
@@ -32,7 +32,7 @@ internal unsafe partial class VulkanInstanceApi
     public partial VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, byte* pLayerName,
         ref uint32_t pPropertyCount, VkExtensionProperties* pProperties);
 
-    [GetProcAddress("vkGetPhysicalDeviceSurfaceSupportKHR")]
+    [GetProcAddress("vkGetPhysicalDeviceSurfaceSupportKHR", true)]
     public partial VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
         uint32_t queueFamilyIndex,
         VkSurfaceKHR surface, out VkBool32 pSupported);
@@ -56,10 +56,10 @@ internal unsafe partial class VulkanInstanceApi
     [GetProcAddress("vkGetDeviceProcAddr")]
     public partial IntPtr GetDeviceProcAddr(VkDevice device, IntPtr pName);
 
-    [GetProcAddress("vkDestroySurfaceKHR")]
+    [GetProcAddress("vkDestroySurfaceKHR", true)]
     public partial void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, IntPtr pAllocator);
 
-    [GetProcAddress("vkGetPhysicalDeviceSurfaceFormatsKHR")]
+    [GetProcAddress("vkGetPhysicalDeviceSurfaceFormatsKHR", true)]
     public partial VkResult GetPhysicalDeviceSurfaceFormatsKHR(
         VkPhysicalDevice physicalDevice,
         VkSurfaceKHR surface,
@@ -70,11 +70,11 @@ internal unsafe partial class VulkanInstanceApi
     public partial void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
         out VkPhysicalDeviceMemoryProperties pMemoryProperties);
 
-    [GetProcAddress("vkGetPhysicalDeviceSurfaceCapabilitiesKHR")]
+    [GetProcAddress("vkGetPhysicalDeviceSurfaceCapabilitiesKHR", true)]
     public partial VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
         out VkSurfaceCapabilitiesKHR pSurfaceCapabilities);
 
-    [GetProcAddress("vkGetPhysicalDeviceSurfacePresentModesKHR")]
+    [GetProcAddress("vkGetPhysicalDeviceSurfacePresentModesKHR", true)]
     public partial VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
         ref uint32_t pPresentModeCount, VkPresentModeKHR* pPresentModes);
     
diff --git a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanStructs.cs b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanStructs.cs
index bce6aa06bd..8f7ea11a06 100644
--- a/src/Avalonia.Vulkan/UnmanagedInterop/VulkanStructs.cs
+++ b/src/Avalonia.Vulkan/UnmanagedInterop/VulkanStructs.cs
@@ -700,6 +700,33 @@ namespace Avalonia.Vulkan.UnmanagedInterop
         public VkOffset3D dstOffsets2;
     }
 
+    struct VkBuffer
+    {
+        public ulong Handle;
+    }
+
+    unsafe struct VkBufferCreateInfo
+    {
+        public VkStructureType sType;
+        public void* pNext;
+        public uint32_t flags;
+        public VkDeviceSize size;
+        public VkBufferUsageFlags usage;
+        public VkSharingMode sharingMode;
+        public uint32_t queueFamilyIndexCount;
+        public uint32_t* pQueueFamilyIndices;
+    }
+
+    struct VkBufferImageCopy
+    {
+        public VkDeviceSize bufferOffset;
+        public uint32_t bufferRowLength;
+        public uint32_t bufferImageHeight;
+        public VkImageSubresourceLayers imageSubresource;
+        public VkOffset3D imageOffset;
+        public VkExtent3D imageExtent;
+    }
+
     unsafe struct VkPresentInfoKHR
     {
         public VkStructureType sType;
diff --git a/src/Avalonia.Vulkan/VulkanContext.cs b/src/Avalonia.Vulkan/VulkanContext.cs
index 8691e55a05..c03d4b4f90 100644
--- a/src/Avalonia.Vulkan/VulkanContext.cs
+++ b/src/Avalonia.Vulkan/VulkanContext.cs
@@ -63,6 +63,9 @@ internal class VulkanContext : IVulkanPlatformGraphicsContext
     {
         foreach (var surf in surfaces)
         {
+            if (surf is IVulkanRenderTargetPlatformSurface renderTargetSurface)
+                return renderTargetSurface.CreateRenderTarget(this);
+
             IVulkanKhrSurfacePlatformSurface khrSurface;
             if (surf is IVulkanKhrSurfacePlatformSurface khr)
                 khrSurface = khr;
diff --git a/src/Avalonia.Vulkan/VulkanOptions.cs b/src/Avalonia.Vulkan/VulkanOptions.cs
index 5a82af607b..66e5ebeed2 100644
--- a/src/Avalonia.Vulkan/VulkanOptions.cs
+++ b/src/Avalonia.Vulkan/VulkanOptions.cs
@@ -38,6 +38,12 @@ public class VulkanInstanceCreationOptions
     /// </summary>
     public bool UseDebug { get; set; }
 
+    /// <summary>
+    /// Requires and enables VK_KHR_surface on the created instance. Disable for offscreen-only
+    /// rendering with drivers that don't expose the extension.
+    /// </summary>
+    public bool RequireSurfaceExtension { get; set; } = true;
+
     /*
 
 
@@ -58,8 +64,14 @@ public class VulkanDeviceCreationOptions
     /// Selects the first suitable discrete gpu available
     /// </summary>
     public bool PreferDiscreteGpu { get; set; }
-    
+
     public bool RequireComputeBit { get; set; }
+
+    /// <summary>
+    /// Requires and enables VK_KHR_swapchain on the created device. Disable for offscreen-only
+    /// rendering with drivers that don't expose the extension.
+    /// </summary>
+    public bool RequireSwapchainExtension { get; set; } = true;
 }
 
 public class VulkanPlatformSpecificOptions
diff --git a/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs b/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs
index 54dfd68fc0..b66054b340 100644
--- a/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs
+++ b/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs
@@ -63,6 +63,19 @@ internal class VulkanSkiaGpu : ISkiaGpu
     
     public void Dispose()
     {
+        if (Vulkan.IsLost)
+        {
+            GrContext.AbandonContext();
+            GrContext.Dispose();
+        }
+        else
+            // Releasing resources does vkQueueWaitIdle and destroys API objects,
+            // both of which require external synchronization, i. e. the device lock
+            using (Vulkan.EnsureCurrent())
+            {
+                GrContext.AbandonContext(true);
+                GrContext.Dispose();
+            }
         Vulkan.Dispose();
     }
 
@@ -92,6 +105,7 @@ internal class VulkanSkiaGpu : ISkiaGpu
         foreach (var surface in surfaces)
         {
             if (surface is IVulkanKhrSurfacePlatformSurface
+                || surface is IVulkanRenderTargetPlatformSurface
                 || (factory?.CanRenderToSurface(Vulkan, surface) == true))
             {
                 return surface.IsReady;
diff --git a/tests/Avalonia.RenderTests/Composition/DirectFbCompositionTests.cs b/tests/Avalonia.RenderTests/Composition/DirectFbCompositionTests.cs
index 5c44809a85..b015b919f7 100644
--- a/tests/Avalonia.RenderTests/Composition/DirectFbCompositionTests.cs
+++ b/tests/Avalonia.RenderTests/Composition/DirectFbCompositionTests.cs
@@ -115,8 +115,8 @@ public class DirectFbCompositionTests : TestBase
         var image2 =
             $"{nameof(Should_Only_Update_Clipped_Rects_When_Retained_Fb_Is_Advertised)}_advertized-{advertised}_updated";
         SaveFile(fb, image2);
-        CompareImages(image1, skipImmediate: true);
-        CompareImages(image2, skipImmediate: true);
+        CompareImages(image1, skipImmediate: true, skipGpu: true);
+        CompareImages(image2, skipImmediate: true, skipGpu: true);
 
     }
 
diff --git a/tests/Avalonia.RenderTests/Controls/AdornerTests.cs b/tests/Avalonia.RenderTests/Controls/AdornerTests.cs
index fa60c12853..485206e8e9 100644
--- a/tests/Avalonia.RenderTests/Controls/AdornerTests.cs
+++ b/tests/Avalonia.RenderTests/Controls/AdornerTests.cs
@@ -35,7 +35,11 @@ public class AdornerTests : TestBase
         adorned.AttachedToVisualTree += delegate
         {
             AdornerLayer.SetAdornedElement(adorner, adorned);
-            AdornerLayer.GetAdornerLayer(adorned)!.Children.Add(adorner);
+            // The tree gets attached once per composited render, but the adorner stays
+            // in the layer after detach
+            var layer = AdornerLayer.GetAdornerLayer(adorned)!;
+            if (!layer.Children.Contains(adorner))
+                layer.Children.Add(adorner);
         };
         
         tree.Measure(size);
diff --git a/tests/Avalonia.RenderTests/Controls/CommandBarTests.cs b/tests/Avalonia.RenderTests/Controls/CommandBarTests.cs
index 2cf3991a6d..e5b882a803 100644
--- a/tests/Avalonia.RenderTests/Controls/CommandBarTests.cs
+++ b/tests/Avalonia.RenderTests/Controls/CommandBarTests.cs
@@ -81,7 +81,7 @@ namespace Avalonia.Direct2D1.RenderTests.Controls
             target.Styles.Add(new SimpleTheme());
             target.Styles.Add(FontStyle);
             await RenderToFile(target);
-            CompareImages(skipImmediate: true);
+            CompareImages(skipImmediate: true, gpuAllowedError: 0.03);
         }
 
         [Fact]
diff --git a/tests/Avalonia.RenderTests/Media/DrawingContentTests.cs b/tests/Avalonia.RenderTests/Media/DrawingContentTests.cs
index dc11cfd666..835afa4527 100644
--- a/tests/Avalonia.RenderTests/Media/DrawingContentTests.cs
+++ b/tests/Avalonia.RenderTests/Media/DrawingContentTests.cs
@@ -45,7 +45,7 @@ public class DrawingContentTests()
         };
 
         RenderChange(target, () => drawing.Brush = Brushes.Red);
-        CompareImages(skipImmediate: true);
+        CompareImages(skipImmediate: true, skipGpu: true);
     }
 
     [Fact]
@@ -66,7 +66,7 @@ public class DrawingContentTests()
         };
 
         RenderChange(target, () => drawing.Brush = Brushes.Red);
-        CompareImages(skipImmediate: true);
+        CompareImages(skipImmediate: true, skipGpu: true);
     }
 
     // Renders the target once, applies the change, renders again and writes the second frame to the
diff --git a/tests/Avalonia.RenderTests/Media/VisualBrushTests.cs b/tests/Avalonia.RenderTests/Media/VisualBrushTests.cs
index 2f86634c6b..4721d181fc 100644
--- a/tests/Avalonia.RenderTests/Media/VisualBrushTests.cs
+++ b/tests/Avalonia.RenderTests/Media/VisualBrushTests.cs
@@ -507,7 +507,7 @@ namespace Avalonia.Skia.RenderTests
             };
 
             await RenderToFile(target, dpi: 144);
-            CompareImages();
+            CompareImages(gpuAllowedError: 0.05);
         }
 
         [Fact]
diff --git a/tests/Avalonia.RenderTests/Mesa/FboReadbackGlPlatformSurface.cs b/tests/Avalonia.RenderTests/Mesa/FboReadbackGlPlatformSurface.cs
new file mode 100644
index 0000000000..92da1178a3
--- /dev/null
+++ b/tests/Avalonia.RenderTests/Mesa/FboReadbackGlPlatformSurface.cs
@@ -0,0 +1,202 @@
+using System;
+using System.Runtime.InteropServices;
+using Avalonia.OpenGL;
+using Avalonia.OpenGL.Surfaces;
+using Avalonia.Platform;
+using static Avalonia.OpenGL.GlConsts;
+
+namespace Avalonia.Skia.RenderTests;
+
+/// <summary>
+/// An offscreen GL surface that renders into an FBO and reads the pixels back
+/// into a writeable bitmap at the end of each rendering session.
+/// </summary>
+internal class FboReadbackGlPlatformSurface : IGlPlatformSurface
+{
+    private readonly IWriteableBitmapImpl _bitmap;
+    private readonly double _scaling;
+
+    public FboReadbackGlPlatformSurface(IWriteableBitmapImpl bitmap, double scaling)
+    {
+        _bitmap = bitmap;
+        _scaling = scaling;
+    }
+
+    public IGlPlatformSurfaceRenderTarget CreateGlRenderTarget(IGlContext context) =>
+        new RenderTarget(context, _bitmap, _scaling);
+
+    private class RenderTarget : IGlPlatformSurfaceRenderTarget
+    {
+        private static readonly bool[] s_trueFalse = { true, false };
+        private readonly IGlContext _context;
+        private readonly IWriteableBitmapImpl _bitmap;
+        private readonly double _scaling;
+        private int _fbo;
+        private int _color;
+        private int _depthStencil;
+        private PixelSize _size;
+
+        public RenderTarget(IGlContext context, IWriteableBitmapImpl bitmap, double scaling)
+        {
+            _context = context;
+            _bitmap = bitmap;
+            _scaling = scaling;
+        }
+
+        public void Dispose()
+        {
+            if (_fbo == 0 || _context.IsLost)
+                return;
+            using (_context.MakeCurrent())
+                DeleteFbo(_context.GlInterface);
+        }
+
+        private void DeleteFbo(GlInterface gl)
+        {
+            if (_fbo == 0)
+                return;
+            gl.DeleteFramebuffer(_fbo);
+            gl.DeleteRenderbuffer(_color);
+            if (_depthStencil != 0)
+                gl.DeleteRenderbuffer(_depthStencil);
+            _fbo = _color = _depthStencil = 0;
+        }
+
+        private void EnsureFbo(GlInterface gl, PixelSize size)
+        {
+            if (_fbo != 0 && size == _size)
+                return;
+            DeleteFbo(gl);
+
+            _fbo = gl.GenFramebuffer();
+            gl.BindFramebuffer(GL_FRAMEBUFFER, _fbo);
+
+            _color = gl.GenRenderbuffer();
+            gl.BindRenderbuffer(GL_RENDERBUFFER, _color);
+            gl.RenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, size.Width, size.Height);
+            gl.FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, _color);
+
+            var success = false;
+            foreach (var useStencil8 in s_trueFalse)
+            {
+                _depthStencil = gl.GenRenderbuffer();
+                gl.BindRenderbuffer(GL_RENDERBUFFER, _depthStencil);
+
+                if (useStencil8)
+                {
+                    gl.RenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, size.Width, size.Height);
+                    gl.FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, _depthStencil);
+                }
+                else
+                {
+                    gl.RenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, size.Width, size.Height);
+                    gl.FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, _depthStencil);
+                    gl.FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, _depthStencil);
+                }
+
+                if (gl.CheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE)
+                {
+                    success = true;
+                    break;
+                }
+
+                gl.DeleteRenderbuffer(_depthStencil);
+                _depthStencil = 0;
+            }
+
+            if (!success)
+            {
+                DeleteFbo(gl);
+                throw new OpenGlException("Unable to create FBO with stencil");
+            }
+
+            _size = size;
+        }
+
+        public IGlPlatformSurfaceRenderingSession BeginDraw(IRenderTarget.RenderTargetSceneInfo sceneInfo)
+        {
+            var restoreContext = _context.MakeCurrent();
+            var success = false;
+            try
+            {
+                var gl = _context.GlInterface;
+                var size = _bitmap.PixelSize;
+                EnsureFbo(gl, size);
+                gl.BindFramebuffer(GL_FRAMEBUFFER, _fbo);
+                gl.Viewport(0, 0, size.Width, size.Height);
+                success = true;
+                return new Session(this, restoreContext);
+            }
+            finally
+            {
+                if (!success)
+                    restoreContext.Dispose();
+            }
+        }
+
+        private void ReadPixels()
+        {
+            var gl = _context.GlInterface;
+            gl.BindFramebuffer(GL_FRAMEBUFFER, _fbo);
+            using (var fb = _bitmap.Lock())
+            {
+                var tightStride = _size.Width * 4;
+                if (fb.RowBytes == tightStride)
+                    gl.ReadPixels(0, 0, _size.Width, _size.Height, GL_RGBA, GL_UNSIGNED_BYTE, fb.Address);
+                else
+                {
+                    var temp = Marshal.AllocHGlobal(tightStride * _size.Height);
+                    try
+                    {
+                        gl.ReadPixels(0, 0, _size.Width, _size.Height, GL_RGBA, GL_UNSIGNED_BYTE, temp);
+                        for (var y = 0; y < _size.Height; y++)
+                            unsafe
+                            {
+                                Buffer.MemoryCopy(
+                                    (byte*)temp + y * tightStride,
+                                    (byte*)fb.Address + y * fb.RowBytes,
+                                    fb.RowBytes, tightStride);
+                            }
+                    }
+                    finally
+                    {
+                        Marshal.FreeHGlobal(temp);
+                    }
+                }
+            }
+        }
+
+        private class Session : IGlPlatformSurfaceRenderingSession
+        {
+            private readonly RenderTarget _target;
+            private readonly IDisposable _restoreContext;
+
+            public Session(RenderTarget target, IDisposable restoreContext)
+            {
+                _target = target;
+                _restoreContext = restoreContext;
+            }
+
+            public IGlContext Context => _target._context;
+            public PixelSize Size => _target._size;
+            public double Scaling => _target._scaling;
+
+            // The FBO is never presented anywhere, so we get to pick the orientation that
+            // makes glReadPixels return rows in top-down order.
+            public bool IsYFlipped => true;
+
+            public void Dispose()
+            {
+                try
+                {
+                    _target._context.GlInterface.Flush();
+                    _target.ReadPixels();
+                }
+                finally
+                {
+                    _restoreContext.Dispose();
+                }
+            }
+        }
+    }
+}
diff --git a/tests/Avalonia.RenderTests/Mesa/MesaSoftwareRenderer.cs b/tests/Avalonia.RenderTests/Mesa/MesaSoftwareRenderer.cs
new file mode 100644
index 0000000000..6fa07d4fbf
--- /dev/null
+++ b/tests/Avalonia.RenderTests/Mesa/MesaSoftwareRenderer.cs
@@ -0,0 +1,98 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using Avalonia.OpenGL;
+using Avalonia.OpenGL.Egl;
+using Avalonia.Platform;
+using Avalonia.Vulkan;
+using Avalonia.Vulkan.Interop;
+using static Avalonia.OpenGL.Egl.EglConsts;
+
+namespace Avalonia.Skia.RenderTests;
+
+/// <summary>
+/// Provides llvmpipe (GL) and lavapipe (Vulkan) platform graphics backed by the
+/// unofficial.mesa.softwarerenderer native library.
+/// </summary>
+internal static unsafe class MesaSoftwareRenderer
+{
+    public static bool GlEnabled { get; } =
+        Environment.GetEnvironmentVariable("AVALONIA_RENDER_TESTS_DISABLE_MESA_GL") != "1";
+
+    // macOS libSkiaSharp is built without Vulkan support
+    public static bool VulkanEnabled { get; } =
+        !OperatingSystem.IsMacOS()
+        && Environment.GetEnvironmentVariable("AVALONIA_RENDER_TESTS_DISABLE_MESA_VULKAN") != "1";
+
+    private static readonly Lazy<IntPtr> s_library = new(() =>
+        NativeLibrary.Load("softmesa", typeof(MesaSoftwareRenderer).Assembly, null));
+
+    private static readonly Lazy<EglPlatformGraphics> s_gl = new(CreateGl);
+    private static readonly Lazy<VulkanPlatformGraphics> s_vulkan = new(CreateVulkan);
+
+    public static IPlatformGraphics Gl => s_gl.Value;
+    public static IPlatformGraphics Vulkan => s_vulkan.Value;
+
+    private static IntPtr GetProcAddress(IntPtr proc, string name)
+    {
+        var bytes = new byte[Encoding.UTF8.GetByteCount(name) + 1];
+        Encoding.UTF8.GetBytes(name, bytes.AsSpan(0, bytes.Length - 1));
+        fixed (byte* ptr = bytes)
+            return ((delegate* unmanaged[Stdcall]<byte*, IntPtr>)proc)(ptr);
+    }
+
+    private static IntPtr GetInstanceProcAddress(IntPtr proc, IntPtr instance, string name)
+    {
+        var bytes = new byte[Encoding.UTF8.GetByteCount(name) + 1];
+        Encoding.UTF8.GetBytes(name, bytes.AsSpan(0, bytes.Length - 1));
+        fixed (byte* ptr = bytes)
+            return ((delegate* unmanaged[Stdcall]<IntPtr, byte*, IntPtr>)proc)(instance, ptr);
+    }
+
+    private static EglPlatformGraphics CreateGl()
+    {
+        var eglGetProcAddress = NativeLibrary.GetExport(s_library.Value, "eglGetProcAddress");
+        var egl = new EglInterface(name => GetProcAddress(eglGetProcAddress, name));
+
+        var display = new EglDisplay(new EglDisplayCreationOptions
+        {
+            Egl = egl,
+            SupportsMultipleContexts = true,
+            SupportsContextSharing = true,
+            AllowPbufferOnlyConfigs = true,
+            // macOS libSkiaSharp is built with skia_gl_standard="gl" and can't consume GLES contexts
+            GlVersions = OperatingSystem.IsMacOS()
+                ? new[]
+                {
+                    new GlVersion(GlProfileType.OpenGL, 4, 0),
+                    new GlVersion(GlProfileType.OpenGL, 3, 2)
+                }
+                : null,
+            // Windows build of Mesa uses the default platform for surfaceless operation
+            PlatformType = OperatingSystem.IsWindows() ? null : EGL_PLATFORM_SURFACELESS_MESA
+        });
+        return new EglPlatformGraphics(display);
+    }
+
+    private static VulkanPlatformGraphics CreateVulkan()
+    {
+        var vkGetInstanceProcAddr = NativeLibrary.GetExport(s_library.Value, "vkGetInstanceProcAddr");
+        VkGetInstanceProcAddressDelegate getProcAddress = (instance, name) =>
+            GetInstanceProcAddress(vkGetInstanceProcAddr, instance, name);
+
+        var platformOptions = new VulkanPlatformSpecificOptions
+        {
+            GetProcAddressDelegate = getProcAddress
+        };
+        // The softmesa build has no WSI support at all
+        var instance = VulkanInstance.Create(new VulkanInstanceCreationOptions
+        {
+            ApplicationName = "Avalonia render tests",
+            RequireSurfaceExtension = false
+        }, platformOptions);
+        var device = VulkanDevice.Create(instance,
+            new VulkanDeviceCreationOptions { RequireSwapchainExtension = false }, platformOptions);
+        return VulkanPlatformGraphics.TryCreate(new VulkanOptions { CustomSharedDevice = device }, platformOptions)
+               ?? throw new InvalidOperationException("Unable to create lavapipe-based VulkanPlatformGraphics");
+    }
+}
diff --git a/tests/Avalonia.RenderTests/Mesa/VulkanReadbackPlatformSurface.cs b/tests/Avalonia.RenderTests/Mesa/VulkanReadbackPlatformSurface.cs
new file mode 100644
index 0000000000..9fbaa483b4
--- /dev/null
+++ b/tests/Avalonia.RenderTests/Mesa/VulkanReadbackPlatformSurface.cs
@@ -0,0 +1,200 @@
+using System;
+using Avalonia.Platform;
+using Avalonia.Vulkan;
+using Avalonia.Vulkan.Interop;
+using Avalonia.Vulkan.UnmanagedInterop;
+
+namespace Avalonia.Skia.RenderTests;
+
+/// <summary>
+/// An offscreen Vulkan surface that renders into a VkImage and reads the pixels back
+/// into a writeable bitmap at the end of each rendering session.
+/// </summary>
+internal class VulkanReadbackPlatformSurface : IVulkanRenderTargetPlatformSurface
+{
+    private readonly IWriteableBitmapImpl _bitmap;
+    private readonly double _scaling;
+
+    public VulkanReadbackPlatformSurface(IWriteableBitmapImpl bitmap, double scaling)
+    {
+        _bitmap = bitmap;
+        _scaling = scaling;
+    }
+
+    public IVulkanRenderTarget CreateRenderTarget(IVulkanPlatformGraphicsContext context) =>
+        new RenderTarget(context, _bitmap, _scaling);
+
+    private class RenderTarget : IVulkanRenderTarget
+    {
+        private readonly IVulkanPlatformGraphicsContext _context;
+        private readonly IWriteableBitmapImpl _bitmap;
+        private readonly double _scaling;
+        private readonly VulkanCommandBufferPool _pool;
+        private VulkanImage? _image;
+
+        public RenderTarget(IVulkanPlatformGraphicsContext context, IWriteableBitmapImpl bitmap, double scaling)
+        {
+            _context = context;
+            _bitmap = bitmap;
+            _scaling = scaling;
+            _pool = new VulkanCommandBufferPool(context);
+        }
+
+        public IVulkanRenderSession BeginDraw()
+        {
+            var l = _context.EnsureCurrent();
+            try
+            {
+                _pool.FreeUsedCommandBuffers();
+                var size = _bitmap.PixelSize;
+                if (_image == null || _image.Size != size)
+                {
+                    DestroyImage();
+                    _image = new VulkanImage(_context, _pool, VkFormat.VK_FORMAT_R8G8B8A8_UNORM, size, 1);
+                }
+                else
+                    _image.TransitionLayout(VkImageLayout.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                        VkAccessFlags.VK_ACCESS_NONE);
+
+                return new Session(this, _image, l);
+            }
+            catch
+            {
+                l.Dispose();
+                throw;
+            }
+        }
+
+        private void DestroyImage()
+        {
+            if (_image == null)
+                return;
+            _context.DeviceApi.DeviceWaitIdle(_context.DeviceHandle);
+            _image.Dispose();
+            _image = null;
+        }
+
+        public void Dispose()
+        {
+            using (_context.EnsureCurrent())
+            {
+                DestroyImage();
+                _pool.Dispose();
+            }
+        }
+
+        private unsafe void ReadPixels(VulkanImage image)
+        {
+            image.TransitionLayout(VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                VkAccessFlags.VK_ACCESS_TRANSFER_READ_BIT);
+
+            var api = _context.DeviceApi;
+            var device = _context.DeviceHandle;
+            var size = image.Size;
+            var tightStride = size.Width * 4;
+            var byteSize = (ulong)(tightStride * size.Height);
+
+            var bufferCreateInfo = new VkBufferCreateInfo
+            {
+                sType = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                size = byteSize,
+                usage = VkBufferUsageFlags.VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+                sharingMode = VkSharingMode.VK_SHARING_MODE_EXCLUSIVE
+            };
+            api.CreateBuffer(device, ref bufferCreateInfo, IntPtr.Zero, out var buffer)
+                .ThrowOnError("vkCreateBuffer");
+            var memory = default(VkDeviceMemory);
+            try
+            {
+                api.GetBufferMemoryRequirements(device, buffer, out var memoryRequirements);
+                var allocateInfo = new VkMemoryAllocateInfo
+                {
+                    sType = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+                    allocationSize = memoryRequirements.size,
+                    memoryTypeIndex = (uint)VulkanMemoryHelper.FindSuitableMemoryTypeIndex(_context,
+                        memoryRequirements.memoryTypeBits,
+                        VkMemoryPropertyFlags.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                        VkMemoryPropertyFlags.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
+                };
+                api.AllocateMemory(device, ref allocateInfo, IntPtr.Zero, out memory)
+                    .ThrowOnError("vkAllocateMemory");
+                api.BindBufferMemory(device, buffer, memory, 0).ThrowOnError("vkBindBufferMemory");
+
+                var commandBuffer = _pool.CreateCommandBuffer();
+                commandBuffer.BeginRecording();
+                var region = new VkBufferImageCopy
+                {
+                    imageSubresource =
+                    {
+                        aspectMask = VkImageAspectFlags.VK_IMAGE_ASPECT_COLOR_BIT,
+                        layerCount = 1
+                    },
+                    imageExtent =
+                    {
+                        width = (uint)size.Width,
+                        height = (uint)size.Height,
+                        depth = 1
+                    }
+                };
+                api.CmdCopyImageToBuffer(commandBuffer.Handle, image.Handle,
+                    VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, 1, &region);
+                commandBuffer.EndRecording();
+                commandBuffer.Submit();
+                api.QueueWaitIdle(_context.MainQueueHandle).ThrowOnError("vkQueueWaitIdle");
+
+                api.MapMemory(device, memory, 0, byteSize, 0, out var mapped).ThrowOnError("vkMapMemory");
+                try
+                {
+                    using (var fb = _bitmap.Lock())
+                        for (var y = 0; y < size.Height; y++)
+                            Buffer.MemoryCopy(
+                                (byte*)mapped + y * tightStride,
+                                (byte*)fb.Address + y * fb.RowBytes,
+                                fb.RowBytes, tightStride);
+                }
+                finally
+                {
+                    api.UnmapMemory(device, memory);
+                }
+            }
+            finally
+            {
+                api.DestroyBuffer(device, buffer, IntPtr.Zero);
+                if (memory.Handle != 0)
+                    api.FreeMemory(device, memory, IntPtr.Zero);
+            }
+        }
+
+        private class Session : IVulkanRenderSession
+        {
+            private readonly RenderTarget _target;
+            private readonly VulkanImage _image;
+            private readonly IDisposable _lock;
+
+            public Session(RenderTarget target, VulkanImage image, IDisposable @lock)
+            {
+                _target = target;
+                _image = image;
+                _lock = @lock;
+            }
+
+            public double Scaling => _target._scaling;
+            public PixelSize Size => _image.Size;
+            public bool IsYFlipped => true;
+            public VulkanImageInfo ImageInfo => _image.ImageInfo;
+            public bool IsRgba => true;
+
+            public void Dispose()
+            {
+                try
+                {
+                    _target.ReadPixels(_image);
+                }
+                finally
+                {
+                    _lock.Dispose();
+                }
+            }
+        }
+    }
+}
diff --git a/tests/Avalonia.RenderTests/Shapes/EllipseTests.cs b/tests/Avalonia.RenderTests/Shapes/EllipseTests.cs
index 4c7e02ecf0..bbc545300f 100644
--- a/tests/Avalonia.RenderTests/Shapes/EllipseTests.cs
+++ b/tests/Avalonia.RenderTests/Shapes/EllipseTests.cs
@@ -51,7 +51,7 @@ namespace Avalonia.Skia.RenderTests
             RenderOptions.SetEdgeMode(target, EdgeMode.Aliased);
 
             await RenderToFile(target);
-            CompareImages();
+            CompareImages(gpuAllowedError: 0.05);
         }
 
         [Fact]
diff --git a/tests/Avalonia.RenderTests/Shapes/PathTests.cs b/tests/Avalonia.RenderTests/Shapes/PathTests.cs
index 0f95f61a4e..d491a13001 100644
--- a/tests/Avalonia.RenderTests/Shapes/PathTests.cs
+++ b/tests/Avalonia.RenderTests/Shapes/PathTests.cs
@@ -453,7 +453,7 @@ namespace Avalonia.Skia.RenderTests
             };
 
             await RenderToFile(target);
-            CompareImages();
+            CompareImages(gpuAllowedError: 0.05);
         }
 
         [Fact]
diff --git a/tests/Avalonia.RenderTests/TestBase.cs b/tests/Avalonia.RenderTests/TestBase.cs
index 6152c782f4..21f95e09ff 100644
--- a/tests/Avalonia.RenderTests/TestBase.cs
+++ b/tests/Avalonia.RenderTests/TestBase.cs
@@ -53,39 +53,61 @@ namespace Avalonia.Skia.RenderTests
             {
                 Directory.CreateDirectory(OutputPath);
             }
-            
+
             var immediatePath = Path.Combine(OutputPath, testName + ".immediate.out.png");
             var compositedPath = Path.Combine(OutputPath, testName + ".composited.out.png");
+            var glesPath = Path.Combine(OutputPath, testName + ".composited.gles.out.png");
+            var vulkanPath = Path.Combine(OutputPath, testName + ".composited.vulkan.out.png");
             await TestRenderHelper.RenderToFile(target, immediatePath, true, dpi);
             await TestRenderHelper.RenderToFile(target, compositedPath, false, dpi);
+            if (MesaSoftwareRenderer.GlEnabled)
+                await TestRenderHelper.RenderCompositedToFile(target, glesPath, MesaSoftwareRenderer.Gl, dpi);
+            if (MesaSoftwareRenderer.VulkanEnabled)
+                await TestRenderHelper.RenderCompositedToFile(target, vulkanPath, MesaSoftwareRenderer.Vulkan, dpi);
         }
 
+        /// <param name="testName">The base name of the compared images.</param>
+        /// <param name="skipImmediate">Skips the immediate renderer output comparison.</param>
+        /// <param name="skipCompositor">Skips all composited output comparisons.</param>
+        /// <param name="skipGpu">
+        /// Skips Mesa GPU output comparisons. For tests that render via a custom flow that only
+        /// produces the regular composited output.
+        /// </param>
+        /// <param name="gpuAllowedError">
+        /// Error tolerance override for Mesa GPU outputs, for tests with known minor
+        /// rasterization differences between GPU and CPU rendering.
+        /// </param>
         protected void CompareImages([CallerMemberName] string testName = "",
-            bool skipImmediate = false,  bool skipCompositor = false)
+            bool skipImmediate = false, bool skipCompositor = false, bool skipGpu = false,
+            double? gpuAllowedError = null)
         {
             var expectedPath = Path.Combine(OutputPath, testName + ".expected.png");
-            var immediatePath = Path.Combine(OutputPath, testName + ".immediate.out.png");
-            var compositedPath = Path.Combine(OutputPath, testName + ".composited.out.png");
 
             using (var expected = Image.Load<Rgba32>(expectedPath))
-            using (var immediate = skipImmediate ? null: Image.Load<Rgba32>(immediatePath))
-            using (var composited = skipCompositor ? null : Image.Load<Rgba32>(compositedPath))
             {
-                if (!skipImmediate)
+                void Compare(string outputType, double allowedError)
                 {
-                    var immediateError = TestRenderHelper.CompareImages(immediate!, expected);
-                    if (immediateError > AllowedError)
+                    var actualPath = Path.Combine(OutputPath, testName + "." + outputType + ".out.png");
+                    using var actual = Image.Load<Rgba32>(actualPath);
+                    var error = TestRenderHelper.CompareImages(actual, expected);
+                    if (error > allowedError)
                     {
-                        Assert.Fail(immediatePath + ": Error = " + immediateError);
+                        Assert.Fail(actualPath + ": Error = " + error);
                     }
                 }
 
+                if (!skipImmediate)
+                    Compare("immediate", AllowedError);
+
                 if (!skipCompositor)
                 {
-                    var compositedError = TestRenderHelper.CompareImages(composited!, expected);
-                    if (compositedError > AllowedError)
+                    Compare("composited", AllowedError);
+                    if (!skipGpu)
                     {
-                        Assert.Fail(compositedPath + ": Error = " + compositedError);
+                        if (MesaSoftwareRenderer.GlEnabled)
+                            Compare("composited.gles", gpuAllowedError ?? AllowedError);
+                        if (MesaSoftwareRenderer.VulkanEnabled)
+                            Compare("composited.vulkan", gpuAllowedError ?? AllowedError);
                     }
                 }
             }
diff --git a/tests/Avalonia.RenderTests/TestRenderHelper.cs b/tests/Avalonia.RenderTests/TestRenderHelper.cs
index 7b3a94d6b7..4ec70b2bb3 100644
--- a/tests/Avalonia.RenderTests/TestRenderHelper.cs
+++ b/tests/Avalonia.RenderTests/TestRenderHelper.cs
@@ -23,6 +23,7 @@ using Avalonia.Utilities;
 using SixLabors.ImageSharp.PixelFormats;
 using Image = SixLabors.ImageSharp.Image;
 using Avalonia.Harfbuzz;
+using Avalonia.OpenGL.Egl;
 using Avalonia.Skia;
 
 namespace Avalonia.Skia.RenderTests;
@@ -51,19 +52,14 @@ static class TestRenderHelper
     
     public static Task RenderToFile(Control target, string path, bool immediate, double dpi = 96)
     {
-        var dir = Path.GetDirectoryName(path);
-        Assert.NotNull(dir);
-
-        if (!Directory.Exists(dir))
-            Directory.CreateDirectory(dir);
-        
-        var factory = AvaloniaLocator.Current.GetRequiredService<IPlatformRenderInterface>();
-        var pixelSize = new PixelSize((int)target.Width, (int)target.Height);
-        var size = new Size(target.Width, target.Height);
-        var dpiVector = new Vector(dpi, dpi);
-
         if (immediate)
         {
+            EnsureOutputDirectory(path);
+
+            var pixelSize = new PixelSize((int)target.Width, (int)target.Height);
+            var size = new Size(target.Width, target.Height);
+            var dpiVector = new Vector(dpi, dpi);
+
             using (RenderTargetBitmap bitmap = new RenderTargetBitmap(pixelSize, dpiVector))
             {
                 target.Measure(size);
@@ -71,34 +67,91 @@ static class TestRenderHelper
                 bitmap.Render(target);
                 bitmap.Save(path, PngBitmapEncoderOptions.Default);
             }
+
+            return Task.CompletedTask;
         }
-        else
-        {
-            var timer = new ManualRenderTimer();
 
-            var compositor = new Compositor(RenderLoop.FromTimer(timer), null, true,
-                new DispatcherCompositorScheduler(), true, Dispatcher.UIThread);
-            using (var writableBitmap = factory.CreateWriteableBitmap(pixelSize, dpiVector, factory.DefaultPixelFormat,
-                       factory.DefaultAlphaFormat))
+        return RenderCompositedToFile(target, path, null, dpi);
+    }
+
+    public static Task RenderCompositedToFile(Control target, string path, IPlatformGraphics? gpu, double dpi = 96)
+    {
+        EnsureOutputDirectory(path);
+
+        var factory = AvaloniaLocator.Current.GetRequiredService<IPlatformRenderInterface>();
+        var pixelSize = new PixelSize((int)target.Width, (int)target.Height);
+        var dpiVector = new Vector(dpi, dpi);
+        var scaling = dpi / 96;
+
+        var timer = new ManualRenderTimer();
+
+        var compositor = new Compositor(RenderLoop.FromTimer(timer), gpu, true,
+            new DispatcherCompositorScheduler(), true, Dispatcher.UIThread);
+        // GPU readback surfaces produce RGBA
+        var pixelFormat = gpu == null ? factory.DefaultPixelFormat : PixelFormats.Rgba8888;
+        using (var writableBitmap = factory.CreateWriteableBitmap(pixelSize, dpiVector, pixelFormat,
+                   factory.DefaultAlphaFormat))
+        {
+            try
             {
-                var root = new TestRenderRoot(dpiVector.X / 96, null!);
-                using (var renderer = new CompositingRenderer(root, compositor,
-                           () => new[] { new BitmapFramebufferSurface(writableBitmap) }))
+                IPlatformRenderSurface surface = gpu switch
+                {
+                    null => new BitmapFramebufferSurface(writableBitmap),
+                    EglPlatformGraphics => new FboReadbackGlPlatformSurface(writableBitmap, scaling),
+                    _ => new VulkanReadbackPlatformSurface(writableBitmap, scaling)
+                };
+                var root = new TestRenderRoot(scaling, null!);
+                try
                 {
-                    root.Initialize(renderer, target);
-                    renderer.Start();
-                    Dispatcher.UIThread.RunJobs();
-                    renderer.Paint(new Rect(root.Bounds.Size), false);
+                    using (var renderer = new CompositingRenderer(root, compositor, () => new[] { surface }))
+                    {
+                        root.Initialize(renderer, target);
+                        renderer.Start();
+                        Dispatcher.UIThread.RunJobs();
+                        renderer.Paint(new Rect(root.Bounds.Size), false);
+                    }
                 }
-
-                using var fileStream = File.Create(path);
-                writableBitmap.Save(fileStream, PngBitmapEncoderOptions.Default);
+                finally
+                {
+                    // Detach the control, so it can be rendered again with a different root
+                    root.Child = null;
+                }
+            }
+            finally
+            {
+                if (gpu != null)
+                    DisposeGpuBackendContext(compositor, gpu);
             }
+
+            using var fileStream = File.Create(path);
+            writableBitmap.Save(fileStream, PngBitmapEncoderOptions.Default);
         }
 
         return Task.CompletedTask;
     }
 
+    // Compositors are created per render, so their backend contexts (GRContext etc.) have to be
+    // disposed deterministically instead of piling up until finalization
+    private static void DisposeGpuBackendContext(Compositor compositor, IPlatformGraphics gpu)
+    {
+        var renderInterface = compositor.Server.RenderInterface;
+        using (renderInterface.EnsureCurrent())
+            // TODO: Technically it should be disposing the GPU context as well,
+            // but need to re-check wayland code if it's safe to do
+            compositor.Server.ResetAllGpuResources();
+        if (!gpu.UsesSharedContext)
+            renderInterface.GpuContext?.Dispose();
+    }
+
+    private static void EnsureOutputDirectory(string path)
+    {
+        var dir = Path.GetDirectoryName(path);
+        Assert.NotNull(dir);
+
+        if (!Directory.Exists(dir))
+            Directory.CreateDirectory(dir);
+    }
+
     class BitmapFramebufferSurface : IFramebufferPlatformSurface
     {
         private readonly IWriteableBitmapImpl _bitmap;
diff --git a/tests/Avalonia.Skia.RenderTests/Avalonia.Skia.RenderTests.csproj b/tests/Avalonia.Skia.RenderTests/Avalonia.Skia.RenderTests.csproj
index f13d888bb2..500ac604a4 100644
--- a/tests/Avalonia.Skia.RenderTests/Avalonia.Skia.RenderTests.csproj
+++ b/tests/Avalonia.Skia.RenderTests/Avalonia.Skia.RenderTests.csproj
@@ -35,6 +35,7 @@
     <PackageReference Include="Moq" />
     <PackageReference Include="SixLabors.ImageSharp" />
     <PackageReference Include="System.Reactive" />
+    <PackageReference Include="unofficial.mesa.softwarerenderer" />
   </ItemGroup>
   <Import Project="..\..\build\XUnit.props" />
   <Import Project="..\..\build\SkiaSharp.props" />

From b3810fc08c6a1cb7dc3bcb836a4dc85d43829fd8 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Wed, 22 Jul 2026 18:46:56 +0500
Subject: [PATCH 102/196] Fixed a bug with stale _usedCache value that wasn't
 reset properly (#21823)

---
 .../ServerCompositionVisual.Render.cs         |   7 ++-
 .../Avalonia.RenderTests/Media/EffectTests.cs |  52 +++++++++++++++++-
 ...CachedSiblingFollowedByEffect.expected.png | Bin 0 -> 2255 bytes
 3 files changed, 57 insertions(+), 2 deletions(-)
 create mode 100644 tests/TestFiles/Skia/Media/Effects/CachedSiblingFollowedByEffect.expected.png

diff --git a/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionVisual/ServerCompositionVisual.Render.cs b/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionVisual/ServerCompositionVisual.Render.cs
index 8d8b862bb3..fe2b88e264 100644
--- a/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionVisual/ServerCompositionVisual.Render.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionVisual/ServerCompositionVisual.Render.cs
@@ -192,7 +192,12 @@ partial class ServerCompositionVisual
                 if (visual.RenderOptions != default)
                     _canvas.PopRenderOptions();
             }
-            
+
+            // A cached visual is always a leaf in the walk (children are skipped), so its
+            // PreSubgraph/PostSubgraph are adjacent. Reset here so the flag never leaks into a
+            // later sibling and causes its effect/mask/options pushes to be left unpopped.
+            _usedCache = false;
+
             // If we are rendering to bitmap cache, PreSubgraph skipped those for the root visual
             if (!bitmapCacheRoot)
             {
diff --git a/tests/Avalonia.RenderTests/Media/EffectTests.cs b/tests/Avalonia.RenderTests/Media/EffectTests.cs
index c8b931dae8..d2c346c582 100644
--- a/tests/Avalonia.RenderTests/Media/EffectTests.cs
+++ b/tests/Avalonia.RenderTests/Media/EffectTests.cs
@@ -1,6 +1,7 @@
 using System.Threading.Tasks;
 using Avalonia.Controls;
 using Avalonia.Controls.Shapes;
+using Avalonia.Layout;
 using Avalonia.Media;
 using Xunit;
 #pragma warning disable CS0649
@@ -76,6 +77,55 @@ public class EffectTests : TestBase
         await RenderToFile(target);
         CompareImages(skipImmediate: true);
     }
-    
+
+    [Fact]
+    public async Task CachedSiblingFollowedByEffect()
+    {
+        var target = new Border
+        {
+            Background = Brushes.White,
+            Width = 200,
+            Height = 200,
+            Child = new StackPanel
+            {
+                Orientation = Orientation.Horizontal,
+                Spacing = 10,
+                Margin = new Thickness(15),
+                Children =
+                {
+                    new Rectangle
+                    {
+                        Width = 50,
+                        Height = 50,
+                        Fill = Brushes.Yellow,
+                        CacheMode = new BitmapCache()
+                    },
+                    new Rectangle
+                    {
+                        Width = 50,
+                        Height = 50,
+                        Fill = Brushes.Blue,
+                        Effect = new DropShadowEffect
+                        {
+                            Opacity = 1,
+                            OffsetX = 0,
+                            OffsetY = 0,
+                            Color = Colors.Black,
+                            BlurRadius = 20
+                        }
+                    },
+                    new Rectangle
+                    {
+                        Width = 50,
+                        Height = 50,
+                        Fill = Brushes.Green
+                    }
+                }
+            }
+        };
+
+        await RenderToFile(target);
+        CompareImages(skipImmediate: true);
+    }
 }
 #endif
diff --git a/tests/TestFiles/Skia/Media/Effects/CachedSiblingFollowedByEffect.expected.png b/tests/TestFiles/Skia/Media/Effects/CachedSiblingFollowedByEffect.expected.png
new file mode 100644
index 0000000000000000000000000000000000000000..6c02b510a77e7ced83f3fe3c518654e902f77b38
GIT binary patch
literal 2255
zcmdUx`8yj}7spdes7e<dX%UlH+8JwTqcy0lsKk)k)t0K3Hwa@aRZC3TM$(!FsihAp
z<rRt&N)$ypm`1CuDQe3bN~}YKs3;Mc^j~;?oAZ3nJ->X<y+7RhdG5J)+2ayOMN<U;
z0DzFLPF}Lw|1Fh)vb8>-p-fg35*(2}%CbmTzD@=Jl(Udd4n8TRd~OJ}#O1rJnb9Nt
z11P`3moY{YzWVmMCwRROW{2G`Kn>ESt#AJN&n{pTD^?SWBE>`43Qv~Ww&Vf$8wzsD
z{}wIQLtjn(&TCtq&a{M_lZdyo?7`!ye@V&EThICsIrb_euoA7`g4l@jOOowPHp+}~
zm^UiDl&M3n?#VQf;`ue4zYXd^>w7EvgLIlsKKdPO`V%md@5iqbhj6Gr3MKK78wk4K
zk~6G;uohReTC^5@h;DY6)H{GTkrQj?r7LTbi!BOcYSiA2RtFgVK3S;JoUMIn?y{rO
zYynWh+jzufI5!j9Pg2<7NvvedM<Phy&cqN0?%{2uOcdUwN-qd<X<jvE6gIEr0naky
zf^=f9TaOk?1oh=RZXEcZVB0{2#kg(26<CjqYSCeP$ySfcM3TW%Jt=Buawi>aXeP#F
zu_Tl$bd5TT3^dOlQhz%1Y({ULBRgBfjxW89G;nWrdpoM{8GcZM>~GC{4#*076pP!$
zz~37Rx_jsiJ_Qlk!^`;}7B>^4WnHd|n>)+h!bUxp8R8NB8`XZdAiZXl-Gb~FwqS94
zI*y9(G4SgiZPd`oslXOjKPjoInZoE&@^zKGiY=nzzhuxl8qzwL?@6;t(|&}x<}Bhz
zgu7;z4ihJC@vG(1>^`9g;Rm(Ip5*}wFE}PiAw@F(q<`L1W`7`Rg%SwCaXjMZ2;+mc
z-{%;paw@XI9F@FMxxKTE4uak`ZtQYumxp*KX7+?Yke*Q~N+n^)K_|f^#Z@R8%bnFj
z2EW;jf=L-ae0aTRX)CDyf;K;#nVQrUIxJvGTjzT*?=hJY6S#bkKA*-PJ(8r(gGwdP
zs?TT1T+<Q<(QNWd_d`2-!nkhyebYo3w%C1P43?(a$M8il=3(oCN)EPA@yt#2=s1FL
zy9((QAtj+Gm5+#qucj0RS5QpTVLJwX`=}1gQvs2+D{6+jOQ-Lu&h4o9Wq@We1_CjD
znB95Wnki)WYgQUxhm}E<=;w`hx3BVvc2$#U{p&h0FuGY3OB`0MljfQB@YLD<x<<mB
z(7)3yE@L`-lJmt|WCKfq?W=F;PZg=3Iy#%8Zgupb^n;5*{smC!p2-f~Qk2+<aez%1
z;KlHq>+ppL(Ck+ym<O(Ll|OQk*i_96mM47Y^wSSHzn02uhgNX_K0jsZo;`r@e+t|<
zDCA^!X%AW-b9LCCd6cF;Z^^oCUpizz!2{H44^L4NKnlXgD!sPHlHnBge@icr=Z5k7
zj7$Rb=+3JqOA+Efd*+`UCx$oh&P(=(Njdz@K}OiP?4`G+KdpP7^IPi!rfbNOy^Wn^
z1&|s*>QvTp#VxGMv)N5A?1iqV=7Vxd*HGnO4<y*qs&R1HUJ+{P${OScgh9@j#$2Km
zeRIc#d(ORiIXu*R7=dOlL>`aGjnt9fum%6k$WE{ZVT(^&xIdh1<?fa@RN*+wZF|e$
z>@EKpc_h)>NDGmyIn>Hulf!b7t-90Q9bvQ{;I*O@9I)okFzHaJX;D2?7-d>CkQi*J
zR@p);Sj^0)UE8@_T!oZ@Gcf<W4&B}rY>Lin1lAnV?w?uTF#n6GxGTY<ah$ca@F(yh
zw+%$L_cMQz`RB;^d8i<Ure&*oQHIRcH<sK&#^@Zrs3n9khGngEjBHC<xPoo0QO5ps
zAUbKkq70W@JO?)&R|J+=bZ3aq@i`GqU%gGmB;Cv)6ylG_+>4s*CaXJNbKE>)?I*W6
zt?n7q=&&o01ZZ>T0*?`rF)(%+OgM7wjjEct3Oo^p?3BLUR~JbiXKplNi=!a70tBl1
zCT%K3gQxfX>K!WBdAdqeR>D?_&D#TfDY4ZdGEBACtloRCh65&yt48W9mgmQQqE9WA
z-v#wGAGpfe%wq{^6L)=!Efykjm}4;HJ6-xjADhaee$eeQPKVK_6*pKA-<KV}_w_J0
z=Nvlqa(yh_jk}Jww@z#?;_dWna|vJnZ0DXnaq-tXYj_sRi8?3)o?CVPJ%rBd-<H()
zEpt0;$u^Xs71+lUE3$hvrshA6+F@K#VDp+z-Yx!VDnq>sAzv8rFwl%?CKOW)zd^P)
zCi(fZ(j?WaH5FSU+I9W@{^YhDZ92{=O#V#)kf1n&X1|V4Z=Wq7Z5Sy~pA$l}t6CPw
z5GT_)qviG?15Xoxx=S}pF^L!*%Mxwo9qYfzH1dc_4p4hN7<^}>TV_wRzRCJ{l<b{q
z=%Wzi?AfeexcBXwp`aDKo|IABtD{${6Jmd<6C8hSBzNU11AWZl9nWx7&hAWZE9IU8
t%T(@)hI}HXXWzrBQGo!E`<JMPRrsQoE^O%7l}#uBq_c-pgX7iP{{Rno=qdmJ

literal 0
HcmV?d00001


From 5d2d9e4dc4f2b17a4c90386fbad31110efa7f684 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Wed, 22 Jul 2026 21:46:40 +0500
Subject: [PATCH 103/196] Properly wire CompositionInterop.IsLost (#21824)

---
 src/Avalonia.Base/Rendering/Composition/CompositionInterop.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.Base/Rendering/Composition/CompositionInterop.cs b/src/Avalonia.Base/Rendering/Composition/CompositionInterop.cs
index a66ab701a1..939eb1fddd 100644
--- a/src/Avalonia.Base/Rendering/Composition/CompositionInterop.cs
+++ b/src/Avalonia.Base/Rendering/Composition/CompositionInterop.cs
@@ -56,7 +56,7 @@ internal class CompositionInterop : ICompositionGpuInterop
         throw new System.NotSupportedException();
     }
 
-    public bool IsLost { get; }
+    public bool IsLost => _context.IsLost;
     public byte[]? DeviceLuid { get; set; }
     public byte[]? DeviceUuid { get; set; }
 }

From 82dc3b56c18a77e175724ca609a0534c40c11421 Mon Sep 17 00:00:00 2001
From: Dong Bin <14807942+rabbitism@users.noreply.github.com>
Date: Thu, 23 Jul 2026 01:37:42 +0800
Subject: [PATCH 104/196] Support {Binding ^} pattern for IObservable
 DataContext (#21812)

Previously {Binding ^} was not parsed because ParseStart did not
recognize the ^ stream operator. Also, {Binding .^} failed because
ParseDot returned State.End immediately, preventing subsequent
operators.

Changes:
- ParseStart: recognize ^, emit EmptyExpressionNode + StreamNode
- ParseDot: return State.AfterMember instead of State.End, so .^ works
- Add grammar tests for ^ and .^ patterns
---
 .../Core/Parsers/BindingExpressionGrammar.cs  |  8 +++++++-
 .../Parsers/BindingExpressionGrammarTests.cs  | 20 +++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Base/Data/Core/Parsers/BindingExpressionGrammar.cs b/src/Avalonia.Base/Data/Core/Parsers/BindingExpressionGrammar.cs
index c49468f1cd..36f3924d00 100644
--- a/src/Avalonia.Base/Data/Core/Parsers/BindingExpressionGrammar.cs
+++ b/src/Avalonia.Base/Data/Core/Parsers/BindingExpressionGrammar.cs
@@ -138,7 +138,13 @@ namespace Avalonia.Data.Core.Parsers
             else if (ParseDot(ref r))
             {
                 nodes.Add(new EmptyExpressionNode());
-                return State.End;
+                return State.AfterMember;
+            }
+            else if (ParseStreamOperator(ref r))
+            {
+                nodes.Add(new EmptyExpressionNode());
+                nodes.Add(new StreamNode());
+                return State.AfterMember;
             }
             else
             {
diff --git a/tests/Avalonia.Base.UnitTests/Data/Core/Parsers/BindingExpressionGrammarTests.cs b/tests/Avalonia.Base.UnitTests/Data/Core/Parsers/BindingExpressionGrammarTests.cs
index db78fbc5cd..5d5e42292f 100644
--- a/tests/Avalonia.Base.UnitTests/Data/Core/Parsers/BindingExpressionGrammarTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Data/Core/Parsers/BindingExpressionGrammarTests.cs
@@ -224,6 +224,26 @@ namespace Avalonia.Base.UnitTests.Data.Core.Parsers
             Assert.IsType<BindingExpressionGrammar.StreamNode>(result[1]);
         }
 
+        [Fact]
+        public void Should_Parse_Stream_Node_On_Empty_Expression()
+        {
+            var result = Parse("^");
+
+            Assert.Equal(2, result.Count);
+            Assert.IsType<BindingExpressionGrammar.EmptyExpressionNode>(result[0]);
+            Assert.IsType<BindingExpressionGrammar.StreamNode>(result[1]);
+        }
+
+        [Fact]
+        public void Should_Parse_Stream_Node_After_Dot()
+        {
+            var result = Parse(".^");
+
+            Assert.Equal(2, result.Count);
+            Assert.IsType<BindingExpressionGrammar.EmptyExpressionNode>(result[0]);
+            Assert.IsType<BindingExpressionGrammar.StreamNode>(result[1]);
+        }
+
         private static void AssertIsProperty(
             BindingExpressionGrammar.INode node,
             string name,

From d307f886dc651f6653ffd29cac5495757a0dcb62 Mon Sep 17 00:00:00 2001
From: Tom Edwards <109803929+TomEdwardsEnscape@users.noreply.github.com>
Date: Wed, 22 Jul 2026 21:44:32 +0200
Subject: [PATCH 105/196] Correct nested `TreeViewItem` selection behaviour on
 pointer release (#21705)

* Correct nested TreeViewItem selection behaviour on pointer release

* Add unit tests
---
 src/Avalonia.Controls/TreeViewItem.cs         |  39 ++++--
 .../TreeViewTests.cs                          | 125 +++++++++++++-----
 2 files changed, 123 insertions(+), 41 deletions(-)

diff --git a/src/Avalonia.Controls/TreeViewItem.cs b/src/Avalonia.Controls/TreeViewItem.cs
index fcfe533950..8c6a17a429 100644
--- a/src/Avalonia.Controls/TreeViewItem.cs
+++ b/src/Avalonia.Controls/TreeViewItem.cs
@@ -6,9 +6,7 @@ using Avalonia.Automation;
 using Avalonia.Automation.Peers;
 using Avalonia.Controls.Metadata;
 using Avalonia.Controls.Mixins;
-using Avalonia.Controls.Platform;
 using Avalonia.Controls.Primitives;
-using Avalonia.Controls.Selection;
 using Avalonia.Controls.Templates;
 using Avalonia.Data;
 using Avalonia.Input;
@@ -45,13 +43,13 @@ namespace Avalonia.Controls
         public static readonly DirectProperty<TreeViewItem, int> LevelProperty =
             AvaloniaProperty.RegisterDirect<TreeViewItem, int>(
                 nameof(Level), o => o.Level);
-        
+
         /// <summary>
         /// Defines the <see cref="Expanded"/> event.
         /// </summary>
         public static readonly RoutedEvent<RoutedEventArgs> ExpandedEvent =
             RoutedEvent.Register<TreeViewItem, RoutedEventArgs>(nameof(Expanded), RoutingStrategies.Bubble | RoutingStrategies.Tunnel);
-        
+
         /// <summary>
         /// Defines the <see cref="Collapsed"/> event.
         /// </summary>
@@ -67,6 +65,7 @@ namespace Avalonia.Controls
         private int _level;
         private bool _templateApplied;
         private bool _deferredBringIntoViewFlag;
+        private bool _itemsPanelPointerPressed;
 
         /// <summary>
         /// Initializes static members of the <see cref="TreeViewItem"/> class.
@@ -116,7 +115,7 @@ namespace Avalonia.Controls
             get => _level;
             private set => SetAndRaise(LevelProperty, ref _level, value);
         }
-        
+
         /// <summary>
         /// Occurs after the <see cref="TreeViewItem"/> has expanded to show its children.
         /// </summary>
@@ -125,7 +124,7 @@ namespace Avalonia.Controls
             add => AddHandler(ExpandedEvent, value);
             remove => RemoveHandler(ExpandedEvent, value);
         }
-        
+
         /// <summary>
         /// Occurs after the <see cref="TreeViewItem"/> has collapsed to hide its children.
         /// </summary>
@@ -167,9 +166,9 @@ namespace Avalonia.Controls
         protected override void OnAttachedToLogicalTree(LogicalTreeAttachmentEventArgs e)
         {
             base.OnAttachedToLogicalTree(e);
-            
+
             _treeView = this.GetLogicalAncestors().OfType<TreeView>().FirstOrDefault();
-            
+
             Level = CalculateDistanceFromLogicalParent<TreeView>(this) - 1;
 
             if (ItemTemplate == null && _treeView?.ItemTemplate != null)
@@ -313,15 +312,35 @@ namespace Avalonia.Controls
         protected override void OnPointerPressed(PointerPressedEventArgs e)
         {
             base.OnPointerPressed(e);
-            TreeViewOwner?.UpdateSelectionFromEvent(this, e);
+
+            _itemsPanelPointerPressed = IsItemsPanelEvent(e);
+
+            // Don't select if the pointer was pressed over the items panel
+            if (!_itemsPanelPointerPressed)
+            {
+                TreeViewOwner?.UpdateSelectionFromEvent(this, e);
+            }
         }
 
         protected override void OnPointerReleased(PointerReleasedEventArgs e)
         {
             base.OnPointerReleased(e);
-            TreeViewOwner?.UpdateSelectionFromEvent(this, e);
+
+            // Don't select if the gesture either started on the items panel, or ended on it
+            if (!_itemsPanelPointerPressed && !IsItemsPanelEvent(e))
+            {
+                TreeViewOwner?.UpdateSelectionFromEvent(this, e);
+            }
+
+            _itemsPanelPointerPressed = false;
         }
 
+        /// <summary>
+        /// Due to Avalonia's implicit pointer capture, the items panel receives no events if swiped onto. So we need to 
+        /// perform our own hit test to reliably determine whether the mouse event occurred over it.
+        /// </summary>
+        private bool IsItemsPanelEvent(PointerEventArgs e) => ItemsPanelRoot?.InputHitTest(e.GetPosition(ItemsPanelRoot)) != null;
+
         protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
         {
             if (_headerPresenter is InputElement previousInputMethod)
diff --git a/tests/Avalonia.Controls.UnitTests/TreeViewTests.cs b/tests/Avalonia.Controls.UnitTests/TreeViewTests.cs
index 1d678fa4f4..d0fb40cb28 100644
--- a/tests/Avalonia.Controls.UnitTests/TreeViewTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TreeViewTests.cs
@@ -4,18 +4,17 @@ using System.Collections.ObjectModel;
 using System.ComponentModel;
 using System.Linq;
 using Avalonia.Collections;
+using Avalonia.Controls.Embedding;
 using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Templates;
 using Avalonia.Data;
-using Avalonia.Data.Core;
 using Avalonia.Harfbuzz;
 using Avalonia.Headless;
 using Avalonia.Input;
-using Avalonia.Input.Platform;
-using Avalonia.Layout;
 using Avalonia.LogicalTree;
 using Avalonia.Markup.Xaml.Templates;
+using Avalonia.Media;
 using Avalonia.Platform;
 using Avalonia.Styling;
 using Avalonia.UnitTests;
@@ -294,6 +293,60 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Swiping_Onto_Child_Should_Not_Select()
+        {
+            using (ConfigureHitTestTreeView(out var target, out var parent, out var child))
+            {
+                _mouse.Down(parent);
+
+                // The pointer is captured on mouse down, so we don't want to issue a mouse up event on child itself
+                // but on parent at a position ABOVE child, which is nested within the parent.
+                _mouse.Up(parent, position: child.GetTransformedBounds()!.Value.Bounds.Center);
+
+                Assert.Null(target.SelectedItem);
+            }
+        }
+
+        [Fact]
+        public void Swiping_Onto_Parent_Should_Not_Select()
+        {
+            using (ConfigureHitTestTreeView(out var target, out var parent, out var child))
+            {
+                _mouse.Down(child);
+
+                // When swiping from a child to a parent, behaviour is a little different: first there is a PointerReleased event
+                // on the child, then on the parent. This is because the PointerPressed event went unhandled and so was seen by the parent.
+                var mouseUpPosition = parent.HeaderPresenter!.GetTransformedBounds()!.Value.Bounds.Center;
+                _mouse.Up(child, position: mouseUpPosition);
+                _mouse.Up(parent, position: mouseUpPosition);
+
+                Assert.Null(target.SelectedItem);
+            }
+        }
+
+        private static CompositorTestServices ConfigureHitTestTreeView(out TreeView target, out TreeViewItem parent, out TreeViewItem child)
+        {
+            var services = new CompositorTestServices();
+            var data = CreateTestTreeData();
+            target = CreateTarget(data, expandAll: true,
+                embeddableRoot: services.TopLevel, styles: [new(x => x.OfType<TreeViewItem>())
+            {
+                Setters =
+                {
+                    new Setter(InputElement.IsHoldingEnabledProperty, true),
+                    new Setter(InputElement.IsHoldWithMouseEnabledProperty, true),
+                },
+            }]);
+
+            services.RunJobs();
+            target.SelectedItem = null;
+
+            parent = Assert.IsType<TreeViewItem>(target.TreeContainerFromItem(data[0]));
+            child = Assert.IsType<TreeViewItem>(target.TreeContainerFromItem(data[0].Children[0]));
+            return services;
+        }
+
         [Fact]
         public void Double_Clicking_Item_Header_Should_Expand_It()
         {
@@ -1466,7 +1519,7 @@ namespace Avalonia.Controls.UnitTests
             var target = CreateTarget(
                 data: data,
                 expandAll: false,
-                itemContainerTheme: itemTheme, 
+                itemContainerTheme: itemTheme,
                 multiSelect: true);
 
             var rootContainer = Assert.IsType<TreeViewItem>(target.ContainerFromIndex(0));
@@ -1530,7 +1583,7 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(selected[0], target.SelectedItem);
             Assert.Equal(selected, target.SelectedItems);
         }
-        
+
         [Fact]
         public void CollapseEvent_Can_Be_Captured_By_TreeView_When_Collapsing_TreeViewItem()
         {
@@ -1551,7 +1604,7 @@ namespace Avalonia.Controls.UnitTests
             Assert.True(raised);
             Assert.Equal(container, source);
         }
-        
+
         [Fact]
         public void CollapseEvent_Should_Be_Raised_When_Collapsing_TreeViewItem()
         {
@@ -1578,7 +1631,8 @@ namespace Avalonia.Controls.UnitTests
             ControlTheme? itemContainerTheme = null,
             IDataTemplate? itemTemplate = null,
             bool multiSelect = false,
-            IEnumerable<Style>? styles = null)
+            IEnumerable<Style>? styles = null,
+            EmbeddableControlRoot? embeddableRoot = null)
         {
             var target = new TreeView
             {
@@ -1588,12 +1642,22 @@ namespace Avalonia.Controls.UnitTests
                 SelectionMode = multiSelect ? SelectionMode.Multiple : SelectionMode.Single,
             };
 
-            var root = CreateRoot(target);
+            if (embeddableRoot == null)
+            {
+                var root = CreateRoot(target);
 
-            if (styles is not null)
-                root.Styles.AddRange(styles);
+                if (styles is not null)
+                    root.Styles.AddRange(styles);
 
-            root.LayoutManager.ExecuteInitialLayoutPass();
+                root.LayoutManager.ExecuteInitialLayoutPass();
+            }
+            else
+            {
+                ConfigureRoot(embeddableRoot);
+                embeddableRoot.Styles.AddRange(styles ?? []);
+                embeddableRoot.Content = target;
+                embeddableRoot.LayoutManager.ExecuteInitialLayoutPass();
+            }
 
             if (expandAll)
             {
@@ -1605,29 +1669,27 @@ namespace Avalonia.Controls.UnitTests
 
         private static TestRoot CreateRoot(Control child)
         {
-            return new TestRoot
+            var root = new TestRoot();
+            ConfigureRoot(root);
+            root.Child = child;
+            return root;
+        }
+
+        private static void ConfigureRoot(Control root)
+        {
+            root.Resources.Add(typeof(TreeView), CreateTreeViewControlTheme());
+            root.Resources.Add(typeof(TreeViewItem), CreateTreeViewItemControlTheme());
+            root.DataTemplates.Add(new TreeDataTemplate
             {
-                Resources =
-                {
-                    { typeof(TreeView), CreateTreeViewControlTheme() },
-                    { typeof(TreeViewItem), CreateTreeViewItemControlTheme() },
-                },
-                DataTemplates =
-                {
-                    new TreeDataTemplate
+                DataType = typeof(Node),
+                ItemsSource = new Binding(nameof(Node.Children)),
+                Content = (IServiceProvider? _) => new TemplateResult<Control>(
+                    new TextBlock
                     {
-                        DataType = typeof(Node),
-                        ItemsSource = new Binding(nameof(Node.Children)),
-                        Content = (IServiceProvider? _) => new TemplateResult<Control>(
-                            new TextBlock
-                            {
-                                [!TextBlock.TextProperty] = new Binding(nameof(Node.Value)),
-                            },
-                            new NameScope())
+                        [!TextBlock.TextProperty] = new Binding(nameof(Node.Value)),
                     },
-                },
-                Child = child,
-            };
+                    new NameScope())
+            });
         }
 
         private static AvaloniaList<Node> CreateTestTreeData()
@@ -1702,6 +1764,7 @@ namespace Avalonia.Controls.UnitTests
                     new Border
                     {
                         Name = "PART_Header",
+                        Background = Brushes.Transparent,
                         Child = new ContentPresenter
                         {
                             Name = "PART_HeaderPresenter",

From a4826b2036380299347bf7c42b56690ceb9ae997 Mon Sep 17 00:00:00 2001
From: Dong Bin <14807942+rabbitism@users.noreply.github.com>
Date: Thu, 23 Jul 2026 18:39:32 +0800
Subject: [PATCH 106/196] Add ToolTip.ShouldUseOverlayLayer attached property
 (#21830)

* feat: add ToolTip.ShouldUseOverlayLayer attached property

Add ShouldUseOverlayLayer attached property to ToolTip, which is bound
to Popup.ShouldUseOverlayLayer when the tooltip popup is created. This
allows per-control control over whether the tooltip popup uses the
overlay layer.

* docs: add proper XML docs for GetShouldUseOverlayLayer/SetShouldUseOverlayLayer

Replace <inheritdoc/> pointing to Popup.ShouldUseOverlayLayer (a property)
with proper <summary>, <param>, and <remarks> documentation for the
getter and setter methods.
---
 src/Avalonia.Controls/ToolTip.cs | 28 +++++++++++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/ToolTip.cs b/src/Avalonia.Controls/ToolTip.cs
index 433098e3f5..7eeea5f0d4 100644
--- a/src/Avalonia.Controls/ToolTip.cs
+++ b/src/Avalonia.Controls/ToolTip.cs
@@ -81,6 +81,10 @@ namespace Avalonia.Controls
         public static readonly AttachedProperty<bool> ServiceEnabledProperty =
             AvaloniaProperty.RegisterAttached<ToolTip, Control, bool>("ServiceEnabled", defaultValue: true, inherits: true);
 
+        /// <inheritdoc cref="Popup.ShouldUseOverlayLayer"/>
+        public static readonly AttachedProperty<bool> ShouldUseOverlayLayerProperty =
+            AvaloniaProperty.RegisterAttached<ToolTip, Control, bool>("ShouldUseOverlayLayer");
+
         /// <summary>
         /// Stores the current <see cref="ToolTip"/> instance in the control.
         /// </summary>
@@ -301,6 +305,27 @@ namespace Avalonia.Controls
         public static void SetServiceEnabled(Control element, bool value) => 
             element.SetValue(ServiceEnabledProperty, value);
 
+        /// <summary>
+        /// Gets whether the tooltip popup for <paramref name="element"/> is shown in the overlay layer.
+        /// </summary>
+        /// <param name="element">The control to get the property from.</param>
+        /// <remarks>
+        /// See <see cref="Popup.ShouldUseOverlayLayer"/> for details.
+        /// </remarks>
+        public static bool GetShouldUseOverlayLayer(Control element) =>
+            element.GetValue(ShouldUseOverlayLayerProperty);
+
+        /// <summary>
+        /// Sets whether the tooltip popup for <paramref name="element"/> is shown in the overlay layer.
+        /// </summary>
+        /// <param name="element">The control to set the property on.</param>
+        /// <param name="value">Whether to show the tooltip popup in the overlay layer.</param>
+        /// <remarks>
+        /// See <see cref="Popup.ShouldUseOverlayLayer"/> for details.
+        /// </remarks>
+        public static void SetShouldUseOverlayLayer(Control element, bool value) =>
+            element.SetValue(ShouldUseOverlayLayerProperty, value);
+
         /// <summary>
         /// Adds a handler for the <see cref="ToolTipOpeningEvent"/> attached event.
         /// </summary>
@@ -421,7 +446,8 @@ namespace Avalonia.Controls
                 _popup.Bind(Popup.HorizontalOffsetProperty, control.GetBindingObservable(HorizontalOffsetProperty)),
                 _popup.Bind(Popup.VerticalOffsetProperty, control.GetBindingObservable(VerticalOffsetProperty)),
                 _popup.Bind(Popup.PlacementProperty, control.GetBindingObservable(PlacementProperty)),
-                _popup.Bind(Popup.CustomPopupPlacementCallbackProperty, control.GetBindingObservable(CustomPopupPlacementCallbackProperty))
+                _popup.Bind(Popup.CustomPopupPlacementCallbackProperty, control.GetBindingObservable(CustomPopupPlacementCallbackProperty)),
+                _popup.Bind(Popup.ShouldUseOverlayLayerProperty, control.GetBindingObservable(ShouldUseOverlayLayerProperty))
             });
 
             _popup.PlacementTarget = control;

From fb09d611062b199f70551e9c26b2316f0173ff09 Mon Sep 17 00:00:00 2001
From: Juan Valencia <113379725+iamvalenciia@users.noreply.github.com>
Date: Thu, 23 Jul 2026 09:56:32 -0500
Subject: [PATCH 107/196] Fix SimpleTheme focus adorner contrast in dark mode
 (#21753)

* Add regression test for SimpleTheme focus adorner

* Fix SimpleTheme focus adorner in dark mode

* Remove redundant focus adorner test
---
 src/Avalonia.Themes.Simple/Controls/AdornerLayer.xaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.Themes.Simple/Controls/AdornerLayer.xaml b/src/Avalonia.Themes.Simple/Controls/AdornerLayer.xaml
index 165ab44fc8..9c0b33ad49 100644
--- a/src/Avalonia.Themes.Simple/Controls/AdornerLayer.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/AdornerLayer.xaml
@@ -5,7 +5,7 @@
     <Setter Property="DefaultFocusAdorner">
       <FocusAdornerTemplate>
         <Rectangle Margin="1"
-                   Stroke="Black"
+                   Stroke="{DynamicResource ThemeForegroundBrush}"
                    StrokeDashArray="1,2"
                    StrokeThickness="1" />
       </FocusAdornerTemplate>

From e5cd8c31fbde433b7df23139b951da742777bfef Mon Sep 17 00:00:00 2001
From: Tim Miller <drasticactions@users.noreply.github.com>
Date: Fri, 24 Jul 2026 20:02:18 +0900
Subject: [PATCH 108/196] Block external roles from activating UIScene (#21844)

---
 src/iOS/Avalonia.iOS/AvaloniaSceneDelegate.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/iOS/Avalonia.iOS/AvaloniaSceneDelegate.cs b/src/iOS/Avalonia.iOS/AvaloniaSceneDelegate.cs
index e8eef65c5c..242a8221b3 100644
--- a/src/iOS/Avalonia.iOS/AvaloniaSceneDelegate.cs
+++ b/src/iOS/Avalonia.iOS/AvaloniaSceneDelegate.cs
@@ -13,7 +13,9 @@ internal sealed class AvaloniaSceneDelegate : UIResponder, IUIWindowSceneDelegat
     [Export("scene:willConnectToSession:options:")]
     public void WillConnect(UIScene scene, UISceneSession session, UISceneConnectionOptions connectionOptions)
     {
-        if (session.Configuration.Name is not null ||
+        // Protect against non-application scenes, which can be created by the system for external displays, CarPlay, etc. 
+        if (session.Role != UIWindowSceneSessionRole.Application ||
+            session.Configuration.Name is not null ||
             scene is not UIWindowScene windowScene ||
             Application.Current?.ApplicationLifetime is not SingleViewLifetime lifetime)
         {

From 81dad81a08c8a2d7ff99c640a59f5fe678deb30f Mon Sep 17 00:00:00 2001
From: Ilya Pospelov <pos777@gmail.com>
Date: Fri, 24 Jul 2026 15:26:16 +0300
Subject: [PATCH 109/196] Fix DBusPlatformSettings NullReferenceException
 (#21831)

---
 .../DBusPlatformSettings.cs                   | 29 ++++++++++---------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs b/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs
index bf17b5522e..f6d620a534 100644
--- a/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs
+++ b/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs
@@ -30,11 +30,14 @@ namespace Avalonia.FreeDesktop
 
         private async Task TryGetInitialValuesAsync()
         {
-            _themeVariant = await TryGetThemeVariantAsync();
-            _accentColor = await TryGetAccentColorAsync();
-            _lastColorValues = BuildPlatformColorValues();
-            if (_lastColorValues is not null)
-                Dispatcher.UIThread.Post(() => OnColorValuesChanged(_lastColorValues));
+            if (_settings is { } settings)
+            {
+                _themeVariant = await TryGetThemeVariantAsync(settings);
+                _accentColor = await TryGetAccentColorAsync(settings);
+                _lastColorValues = BuildPlatformColorValues();
+                if (_lastColorValues is not null)
+                    Dispatcher.UIThread.Post(() => OnColorValuesChanged(_lastColorValues));
+            }
         }
 
         internal void OnRequestDefaultThemeVariant()
@@ -42,17 +45,17 @@ namespace Avalonia.FreeDesktop
             _ = TryGetInitialValuesAsync();
         }
 
-        private async Task<PlatformThemeVariant?> TryGetThemeVariantAsync()
+        private static async Task<PlatformThemeVariant?> TryGetThemeVariantAsync(Settings settings)
         {
             try
             {
-                var version = await _settings!.GetVersionAsync();
+                var version = await settings.GetVersionAsync();
                 VariantValue value;
                 if (version >= 2)
-                    value = await _settings!.ReadOneAsync("org.freedesktop.appearance", "color-scheme");
+                    value = await settings.ReadOneAsync("org.freedesktop.appearance", "color-scheme");
                 else
                     // Unpack nested Variant
-                    value = (await _settings!.ReadAsync("org.freedesktop.appearance", "color-scheme")).GetVariantValue();
+                    value = (await settings.ReadAsync("org.freedesktop.appearance", "color-scheme")).GetVariantValue();
                 return ToColorScheme(value.GetUInt32());
             }
             catch (DBusExceptionBase)
@@ -61,16 +64,16 @@ namespace Avalonia.FreeDesktop
             }
         }
 
-        private async Task<Color?> TryGetAccentColorAsync()
+        private static async Task<Color?> TryGetAccentColorAsync(Settings settings)
         {
             try
             {
-                var version = await _settings!.GetVersionAsync();
+                var version = await settings.GetVersionAsync();
                 VariantValue value;
                 if (version >= 2)
-                    value = await _settings!.ReadOneAsync("org.freedesktop.appearance", "accent-color");
+                    value = await settings.ReadOneAsync("org.freedesktop.appearance", "accent-color");
                 else
-                    value = await _settings!.ReadAsync("org.freedesktop.appearance", "accent-color");
+                    value = await settings.ReadAsync("org.freedesktop.appearance", "accent-color");
                 return ToAccentColor(value);
             }
             catch (DBusExceptionBase)

From 7874bd6efffdf20b691638883df4ef3033abe3fb Mon Sep 17 00:00:00 2001
From: yoyo <zrt2399@163.com>
Date: Fri, 24 Jul 2026 20:35:39 +0800
Subject: [PATCH 110/196] Add :empty pseudoclass for ContentControl (#21829)

* Add :empty pseudoclass for ContentControl

* Update ToolTip tests for ContentControl :empty pseudoclass

* Update XAML class tests for ContentControl :empty pseudoclass
---
 src/Avalonia.Controls/ContentControl.cs       | 19 ++++++++++++++++---
 .../ContentControlTests.cs                    | 14 ++++++++++++++
 .../ToolTipTests.cs                           |  6 +++---
 .../Xaml/BasicTests.cs                        | 16 +++++++++-------
 4 files changed, 42 insertions(+), 13 deletions(-)

diff --git a/src/Avalonia.Controls/ContentControl.cs b/src/Avalonia.Controls/ContentControl.cs
index 0f53608bd3..42a14987e3 100644
--- a/src/Avalonia.Controls/ContentControl.cs
+++ b/src/Avalonia.Controls/ContentControl.cs
@@ -8,8 +8,6 @@ using Avalonia.Data;
 using Avalonia.Layout;
 using Avalonia.LogicalTree;
 using Avalonia.Metadata;
-using Avalonia.Platform;
-using Avalonia.Styling;
 
 namespace Avalonia.Controls
 {
@@ -17,8 +15,11 @@ namespace Avalonia.Controls
     /// Displays <see cref="Content"/> according to an <see cref="IDataTemplate"/>.
     /// </summary>
     [TemplatePart("PART_ContentPresenter", typeof(ContentPresenter))]
+    [PseudoClasses(pcEmpty)]
     public class ContentControl : TemplatedControl, IContentControl, IContentPresenterHost
     {
+        private const string pcEmpty = ":empty";
+
         /// <summary>
         /// Defines the <see cref="Content"/> property.
         /// </summary>
@@ -61,6 +62,11 @@ namespace Avalonia.Controls
             }.RegisterInNameScope(ns)));
         }
 
+        public ContentControl()
+        {
+            UpdatePseudoClasses();
+        }
+
         /// <summary>
         /// Gets or sets the content to display.
         /// </summary>
@@ -116,7 +122,7 @@ namespace Avalonia.Controls
         {
             return RegisterContentPresenter(presenter);
         }
-        
+
         protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
         {
             base.OnPropertyChanged(change);
@@ -153,6 +159,13 @@ namespace Avalonia.Controls
             {
                 LogicalChildren.Add(newChild);
             }
+
+            UpdatePseudoClasses();
+        }
+
+        private void UpdatePseudoClasses()
+        {
+            PseudoClasses.Set(pcEmpty, Content is null);
         }
 
         internal override void BuildDebugDisplay(StringBuilder builder, bool includeContent)
diff --git a/tests/Avalonia.Controls.UnitTests/ContentControlTests.cs b/tests/Avalonia.Controls.UnitTests/ContentControlTests.cs
index 87eb4ef2af..91a54e123c 100644
--- a/tests/Avalonia.Controls.UnitTests/ContentControlTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ContentControlTests.cs
@@ -17,6 +17,20 @@ namespace Avalonia.Controls.UnitTests
 {
     public class ContentControlTests : ScopedTestBase
     {
+        [Fact]
+        public void Empty_PseudoClass_Should_Track_Content()
+        {
+            var target = new ContentControl();
+
+            Assert.Contains(":empty", target.Classes);
+
+            target.Content = "Content";
+            Assert.DoesNotContain(":empty", target.Classes);
+
+            target.Content = null;
+            Assert.Contains(":empty", target.Classes);
+        }
+
         [Fact]
         public void Template_Should_Be_Instantiated()
         {
diff --git a/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs b/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs
index ad0662311b..059ffdbca4 100644
--- a/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs
@@ -215,7 +215,7 @@ namespace Avalonia.Controls.UnitTests
                 window.ApplyTemplate();
                 window.Presenter!.ApplyTemplate();
 
-                Assert.Empty(toolTip.Classes);
+                Assert.DoesNotContain(":open", toolTip.Classes);
             }
         }
 
@@ -240,7 +240,7 @@ namespace Avalonia.Controls.UnitTests
 
                 ToolTip.SetIsOpen(decorator, true);
 
-                Assert.Equal(new[] { ":open" }, toolTip.Classes);
+                Assert.Contains(":open", toolTip.Classes);
                 VerifyToolTipType(decorator);
             }
         }
@@ -271,7 +271,7 @@ namespace Avalonia.Controls.UnitTests
                 AssertToolTipOpen(decorator);
                 ToolTip.SetIsOpen(decorator, false);
 
-                Assert.Empty(toolTip.Classes);
+                Assert.DoesNotContain(":open", toolTip.Classes);
             }
         }
 
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs
index 41c349d7e4..e6260f6eec 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs
@@ -113,7 +113,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
 
             Assert.Equal("Foo", ToolTip.GetTip(target));
         }
-        
+
         [Fact]
         public void NonExistent_Property_Throws()
         {
@@ -279,7 +279,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
             Assert.Equal(expected3, grid.RowDefinitions[2].Height);
             Assert.Equal(expected4, grid.RowDefinitions[3].Height);
         }
-        
+
         [Fact]
         public void Grid_Row_Col_Definitions_Are_Parsed_Space_Delimiter()
         {
@@ -905,7 +905,8 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
             var xaml = "<Button xmlns='https://github.com/avaloniaui' Classes='foo bar'/>";
             var target = (Button)AvaloniaRuntimeXamlLoader.Load(xaml);
 
-            Assert.Equal(new[] { "foo", "bar" }, target.Classes);
+            Assert.Contains("foo", target.Classes);
+            Assert.Contains("bar", target.Classes);
         }
 
         [Fact]
@@ -921,7 +922,8 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
 </Button>";
             var target = (Button)AvaloniaRuntimeXamlLoader.Load(xaml);
 
-            Assert.Equal(new[] { "foo", "bar" }, target.Classes);
+            Assert.Contains("foo", target.Classes);
+            Assert.Contains("bar", target.Classes);
         }
 
         [Fact]
@@ -970,16 +972,16 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
             Child = child;
         }
     }
-    
+
     public class ObjectWithoutPublicCtor
     {
         public ObjectWithoutPublicCtor(string param)
         {
             Test1 = param;
         }
-        
+
         public string? Test1 { get; set; }
-        
+
         public string? Test2 { get; set; }
     }
 

From 935853ad29ebae03c4d96e1f9634977daf53b760 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakob=20Sch=C3=B8ler?=
 <35096865+JakobScholer@users.noreply.github.com>
Date: Fri, 24 Jul 2026 16:28:38 +0200
Subject: [PATCH 111/196] fix degraded activation (#21799)

---
 .../Avalonia.Native/src/OSX/WindowBaseImpl.mm | 22 +++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm b/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm
index 2a1de62b05..976e26148e 100644
--- a/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm
+++ b/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm
@@ -21,6 +21,24 @@
 
 @class AutoFitContentView;
 
+
+// Activates the app, but defers until the run loop is running if it isn't yet.
+// Windows are shown (and the app activated) from OnFrameworkInitializationCompleted,
+// which runs before -[NSApplication run]. Activating that early yields a "degraded"
+// activation: the app looks frontmost but the WindowServer never does a real
+// become-active, which leaves the out-of-process file picker unable to receive
+// clicks in its file list/sidebar until a manual app switch. Deferring makes the first
+// activation a clean transition.
+static void ActivateApplication() {
+    if ([NSApp isRunning]) {
+        [NSApp activateIgnoringOtherApps:YES];
+    } else {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [NSApp activateIgnoringOtherApps:YES];
+        });
+    }
+}
+
 WindowBaseImpl::~WindowBaseImpl() {
     View = nullptr;
     Window = nullptr;
@@ -99,7 +117,7 @@ HRESULT WindowBaseImpl::Show(bool activate, bool isDialog) {
             [Window orderFront:Window];
             [Window makeKeyAndOrderFront:Window];
             [Window makeFirstResponder:View];
-            [NSApp activateIgnoringOtherApps:YES];
+            ActivateApplication();
         } else {
             [Window orderFront:Window];
         }
@@ -177,7 +195,7 @@ HRESULT WindowBaseImpl::Activate() {
     @autoreleasepool {
         if (Window != nullptr) {
             [Window makeKeyAndOrderFront:nil];
-            [NSApp activateIgnoringOtherApps:YES];
+            ActivateApplication();
         }
     }
 

From aa1ba88e792bfe375b259cde3bfbdcdd2c48802d Mon Sep 17 00:00:00 2001
From: Mark Zielinski <mark.zielinski@tradetitan.com>
Date: Fri, 24 Jul 2026 09:44:47 -0500
Subject: [PATCH 112/196] macOS: fall back to the current event in
 BeginMoveDrag when no mouse-down was recorded (#21827)

BeginMoveDrag on macOS drags from the Avalonia view's last recorded
mouse-down. A press that begins inside an embedded native view (for
example a webview hosted through NativeControlHost) is consumed by that
view and never delivered to the Avalonia view, so lastMouseDownEvent is
nil and BeginMoveDrag silently does nothing - applications embedding
native views cannot implement custom title-bar dragging through the
managed API and must reproduce performWindowDragWithEvent: through
platform interop.

When no mouse-down was recorded, fall back to the event the application
is currently tracking, guarded to left-button press or drag events that
belong to this window. Presses recorded by the Avalonia view behave
exactly as before.
---
 native/Avalonia.Native/src/OSX/WindowBaseImpl.mm | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm b/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm
index 976e26148e..33ab1529fc 100644
--- a/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm
+++ b/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm
@@ -347,6 +347,21 @@ HRESULT WindowBaseImpl::BeginMoveDrag() {
     @autoreleasepool {
         auto lastEvent = [View lastMouseDownEvent];
 
+        if (lastEvent == nullptr) {
+            // A press that begins inside an embedded native view (for example a webview hosted
+            // through NativeControlHost) is consumed by that view and never delivered to the
+            // Avalonia view, so no mouse-down is recorded; fall back to the event the
+            // application is tracking right now, provided it is a left-button press or drag
+            // that belongs to this window.
+            auto currentEvent = [NSApp currentEvent];
+
+            if (currentEvent != nullptr && [currentEvent window] == Window &&
+                ([currentEvent type] == NSEventTypeLeftMouseDown ||
+                 [currentEvent type] == NSEventTypeLeftMouseDragged)) {
+                lastEvent = currentEvent;
+            }
+        }
+
         if (lastEvent == nullptr) {
             return S_OK;
         }

From 06fdb648ac1405048d95ffe0317ea5a66a9c8ac5 Mon Sep 17 00:00:00 2001
From: AB901 <44526542+AB901@users.noreply.github.com>
Date: Fri, 24 Jul 2026 23:20:34 +0800
Subject: [PATCH 113/196] Fix EGL surface recreation after native handle
 changes (#21816)

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 src/Avalonia.OpenGL/Egl/EglGlPlatformSurface.cs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/Avalonia.OpenGL/Egl/EglGlPlatformSurface.cs b/src/Avalonia.OpenGL/Egl/EglGlPlatformSurface.cs
index 5afe87f4a4..900edf7f58 100644
--- a/src/Avalonia.OpenGL/Egl/EglGlPlatformSurface.cs
+++ b/src/Avalonia.OpenGL/Egl/EglGlPlatformSurface.cs
@@ -40,7 +40,7 @@ namespace Avalonia.OpenGL.Egl
             private EglSurface? _glSurface;
             private readonly IEglWindowGlPlatformSurfaceInfo _info;
             private PixelSize _currentSize;
-            private readonly IntPtr _handle;
+            private IntPtr _handle;
 
             public RenderTarget(EglSurface glSurface, EglContext context, IEglWindowGlPlatformSurfaceInfo info) : base(context)
             {
@@ -58,16 +58,19 @@ namespace Avalonia.OpenGL.Egl
             public override IGlPlatformSurfaceRenderingSession BeginDrawCore(IRenderTarget.RenderTargetSceneInfo sceneInfo)
             {
                 // TODO: use expectedPixelSize
-                if (_info.Size != _currentSize 
-                    || _handle != _info.Handle
+                var handle = _info.Handle;
+                var size = _info.Size;
+                if (size != _currentSize
+                    || _handle != handle
                     || _glSurface == null)
                 {
                     _glSurface?.Dispose();
                     _glSurface = null;
-                    _glSurface = Context.Display.CreateWindowSurface(_info.Handle);
-                    _currentSize = _info.Size;
+                    _glSurface = Context.Display.CreateWindowSurface(handle);
+                    _currentSize = size;
+                    _handle = handle;
                 }
-                return base.BeginDraw(_glSurface, _info.Size, _info.Scaling);
+                return base.BeginDraw(_glSurface, size, _info.Scaling);
             }
         }
     }

From 4fc9848bbacf96c67326d6e299bacd11c5df7a5c Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Sat, 25 Jul 2026 01:59:16 +1000
Subject: [PATCH 114/196] Fix ListBox crash when scrolling after item removal
 (#21838)

* Add regression test for ListBox removal scroll crash

* Fix virtualized arrange after collection changes
---
 .../VirtualizingStackPanel.cs                 |  7 ++++++
 .../ListBoxVirtualizationIssueTests.cs        | 25 +++++++++++++++++++
 2 files changed, 32 insertions(+)

diff --git a/src/Avalonia.Controls/VirtualizingStackPanel.cs b/src/Avalonia.Controls/VirtualizingStackPanel.cs
index 669e75d81a..a8cc7b669d 100644
--- a/src/Avalonia.Controls/VirtualizingStackPanel.cs
+++ b/src/Avalonia.Controls/VirtualizingStackPanel.cs
@@ -251,6 +251,13 @@ namespace Avalonia.Controls
                 var orientation = Orientation;
                 var u = _realizedElements!.StartU;
 
+                // Collection changes before the realized range make its exact position unstable
+                // until the next measure. ScrollIntoView can intentionally defer that measure
+                // while waiting for an updated viewport, so use the same position estimate used
+                // when realizing an element instead of arranging the range at NaN.
+                if (double.IsNaN(u))
+                    u = GetOrEstimateElementU(_realizedElements.FirstIndex);
+
                 for (var i = 0; i < _realizedElements.Count; ++i)
                 {
                     var e = _realizedElements.Elements[i];
diff --git a/tests/Avalonia.Controls.UnitTests/ListBoxVirtualizationIssueTests.cs b/tests/Avalonia.Controls.UnitTests/ListBoxVirtualizationIssueTests.cs
index 54fec22e44..d725c406c9 100644
--- a/tests/Avalonia.Controls.UnitTests/ListBoxVirtualizationIssueTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ListBoxVirtualizationIssueTests.cs
@@ -11,6 +11,31 @@ namespace Avalonia.Controls.UnitTests;
 
 public class ListBoxVirtualizationIssueTests : ScopedTestBase
 {
+    [Fact]
+    public void Removing_First_Item_After_Scrolling_To_End_Should_Allow_Scrolling_To_Start()
+    {
+        using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+        {
+            var items = new ObservableCollection<int>(Enumerable.Range(0, 100));
+            var target = new ListBox
+            {
+                Template = new FuncControlTemplate(CreateListBoxTemplate),
+                ItemsSource = items,
+                ItemTemplate = new FuncDataTemplate<int>((_, _) => new TextBlock { Height = 50 }),
+                ItemsPanel = new FuncTemplate<Panel?>(() => new VirtualizingStackPanel()),
+            };
+
+            Prepare(target);
+            target.ScrollIntoView(99);
+
+            items.RemoveAt(0);
+            target.ScrollIntoView(0);
+
+            var firstContainer = Assert.IsType<ListBoxItem>(target.ContainerFromIndex(0));
+            Assert.Equal(1, firstContainer.Content);
+        }
+    }
+
     [Fact]
     public void Replaced_ItemsSource_Should_Not_Show_Old_Selected_Item_When_Scrolled_Back()
     {

From 561b9a375c48924e0aacf2544332cf358797c3f7 Mon Sep 17 00:00:00 2001
From: AlexSCcon <alex.s@ccon.au>
Date: Fri, 24 Jul 2026 18:03:14 +0200
Subject: [PATCH 115/196] Fix Android multiline TextBox IME offsets (#21680)

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../TextBoxTextInputMethodClient.cs           | 83 +++++--------------
 .../TextBoxTests.cs                           | 52 ++++++++++++
 2 files changed, 73 insertions(+), 62 deletions(-)

diff --git a/src/Avalonia.Controls/TextBoxTextInputMethodClient.cs b/src/Avalonia.Controls/TextBoxTextInputMethodClient.cs
index d94d36ef1d..8595175192 100644
--- a/src/Avalonia.Controls/TextBoxTextInputMethodClient.cs
+++ b/src/Avalonia.Controls/TextBoxTextInputMethodClient.cs
@@ -1,9 +1,7 @@
 using System;
 using Avalonia.Controls.Presenters;
 using Avalonia.Input.TextInput;
-using Avalonia.Media.TextFormatting;
 using Avalonia.Reactive;
-using Avalonia.Utilities;
 
 namespace Avalonia.Controls
 {
@@ -13,6 +11,7 @@ namespace Avalonia.Controls
         private TextPresenter? _presenter;
         private bool _selectionChanged;
         private bool _isInChange;
+        private EventHandler? _caretBoundsChangedHandler;
 
         public override Visual TextViewVisual => _presenter!;
 
@@ -20,28 +19,22 @@ namespace Avalonia.Controls
         {
             get
             {
-                if (_presenter is null || _parent is null)
+                if (_parent is null)
                 {
                     return "";
                 }
 
-                if (_parent.CaretIndex != _presenter.CaretIndex)
+                if (_presenter is not null && _parent.CaretIndex != _presenter.CaretIndex)
                 {
                     _presenter.SetCurrentValue(TextPresenter.CaretIndexProperty, _parent.CaretIndex);
                 }
 
-                if (_parent.Text != _presenter.Text)
+                if (_presenter is not null && _parent.Text != _presenter.Text)
                 {
                     _presenter.SetCurrentValue(TextPresenter.TextProperty, _parent.Text);
                 }
 
-                var lineIndex = _presenter.TextLayout.GetLineIndexFromCharacterIndex(_presenter.CaretIndex, false);
-
-                var textLine = _presenter.TextLayout.TextLines[lineIndex];
-
-                var lineText = GetTextLineText(textLine);
-
-                return lineText;
+                return _parent.Text ?? string.Empty;
             }
         }
 
@@ -69,41 +62,22 @@ namespace Avalonia.Controls
         {
             get
             {
-                if (_presenter is null || _parent is null)
+                if (_parent is null)
                 {
                     return default;
                 }
 
-                var lineIndex = _presenter.TextLayout.GetLineIndexFromCharacterIndex(_parent.CaretIndex, false);
-
-                var textLine = _presenter.TextLayout.TextLines[lineIndex];
-
-                var lineStart = textLine.FirstTextSourceIndex;
-
-                var selectionStart = Math.Max(0, _parent.SelectionStart - lineStart);
-
-                var selectionEnd = Math.Max(0, _parent.SelectionEnd - lineStart);
-
-                return new TextSelection(selectionStart, selectionEnd);
+                return new TextSelection(_parent.SelectionStart, _parent.SelectionEnd);
             }
             set
             {
-                if (_parent is null || _presenter is null)
+                if (_parent is null)
                 {
                     return;
                 }
 
-                var lineIndex = _presenter.TextLayout.GetLineIndexFromCharacterIndex(_parent.CaretIndex, false);
-
-                var textLine = _presenter.TextLayout.TextLines[lineIndex];
-
-                var lineStart = textLine.FirstTextSourceIndex;
-
-                var selectionStart = lineStart + value.Start;
-                var selectionEnd = lineStart + value.End;
-
-                _parent.SelectionStart = selectionStart;
-                _parent.SelectionEnd = selectionEnd;
+                _parent.SelectionStart = value.Start;
+                _parent.SelectionEnd = value.End;
 
                 RaiseSelectionChanged();
             }
@@ -136,7 +110,10 @@ namespace Avalonia.Controls
                 oldPresenter.CurrentImClient = null;
                 oldPresenter.ClearValue(TextPresenter.PreeditTextProperty);
 
-                oldPresenter.CaretBoundsChanged -= (s, e) => RaiseCursorRectangleChanged();
+                if (_caretBoundsChangedHandler is not null)
+                {
+                    oldPresenter.CaretBoundsChanged -= _caretBoundsChangedHandler;
+                }
             }
 
             _presenter = presenter;
@@ -145,7 +122,8 @@ namespace Avalonia.Controls
             {
 
                 _presenter.CurrentImClient = this;
-                _presenter.CaretBoundsChanged += (s, e) => RaiseCursorRectangleChanged();
+                _caretBoundsChangedHandler ??= OnPresenterCaretBoundsChanged;
+                _presenter.CaretBoundsChanged += _caretBoundsChangedHandler;
             }
 
             RaiseTextViewVisualChanged();
@@ -153,6 +131,11 @@ namespace Avalonia.Controls
             RaiseCursorRectangleChanged();
         }
 
+        private void OnPresenterCaretBoundsChanged(object? sender, EventArgs e)
+        {
+            RaiseCursorRectangleChanged();
+        }
+
         private void OnParentTapped(object? sender, Input.TappedEventArgs e)
         {
             RaiseInputPaneActivationRequested();
@@ -171,30 +154,6 @@ namespace Avalonia.Controls
             _presenter.SetCurrentValue(TextPresenter.PreeditTextCursorPositionProperty, cursorPos);
         }
 
-        private static string GetTextLineText(TextLine textLine)
-        {
-            if (textLine.Length == 0)
-            {
-                return string.Empty;
-            }
-
-            var builder = StringBuilderCache.Acquire(textLine.Length);
-
-            foreach (var run in textLine.TextRuns)
-            {
-                if (run.Length > 0)
-                {
-                    builder.Append(run.Text.Span);
-                }
-            }
-
-            var lineText = builder.ToString();
-
-            StringBuilderCache.Release(builder);
-
-            return lineText;
-        }
-
         public override void ExecuteContextMenuAction(ContextMenuAction action)
         {
             base.ExecuteContextMenuAction(action);
diff --git a/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs b/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
index 46af86b98d..1d7570c2a1 100644
--- a/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
@@ -2196,6 +2196,46 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(string.Empty, client.SurroundingText);
         }
 
+        [Fact]
+        public void InputMethodClient_SurroundingText_Uses_Full_Document_For_Multiline_Text()
+        {
+            using var _ = UnitTestApplication.Start(Services);
+
+            var textBox = new TextBox
+            {
+                Template = CreateTemplate(),
+                Text = "one\ntwo",
+                CaretIndex = 5
+            };
+            textBox.ApplyTemplate();
+
+            var client = GetInputMethodClient(textBox);
+
+            Assert.Equal("one\ntwo", client.SurroundingText);
+            Assert.Equal(new TextSelection(5, 5), client.Selection);
+        }
+
+        [Fact]
+        public void InputMethodClient_Selection_Setter_Uses_Document_Offsets_For_Multiline_Text()
+        {
+            using var _ = UnitTestApplication.Start(Services);
+
+            var textBox = new TextBox
+            {
+                Template = CreateTemplate(),
+                Text = "one\ntwo",
+                CaretIndex = 5
+            };
+            textBox.ApplyTemplate();
+
+            var client = GetInputMethodClient(textBox);
+            client.Selection = new TextSelection(0, 3);
+
+            Assert.Equal(0, textBox.SelectionStart);
+            Assert.Equal(3, textBox.SelectionEnd);
+            Assert.Equal("one", textBox.SelectedText);
+        }
+
         [Fact]
         public void Backspace_Should_Delete_Last_Character_In_Line_And_Keep_Caret_On_Same_Line()
         {
@@ -2364,6 +2404,18 @@ namespace Avalonia.Controls.UnitTests
             fontManagerImpl: new TestFontManager(),
             assetLoader: new StandardAssetLoader());
 
+        private static TextInputMethodClient GetInputMethodClient(TextBox textBox)
+        {
+            var eventArgs = new TextInputMethodClientRequestedEventArgs
+            {
+                RoutedEvent = InputElement.TextInputMethodClientRequestedEvent
+            };
+            textBox.RaiseEvent(eventArgs);
+
+            Assert.NotNull(eventArgs.Client);
+            return eventArgs.Client;
+        }
+
         internal static IControlTemplate CreateTemplate()
         {
             return new FuncControlTemplate<TextBox>((control, scope) =>

From 480ed54ec7a1584e3c096af00de78d1b219b9bda Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Sat, 25 Jul 2026 04:07:51 +1000
Subject: [PATCH 116/196] fix(text): preserve lines at rounded fractional
 heights (#21834)

* test(textblock): cover fractional layout rounding

A wrapped TextBlock with a fractional line height must retain every line when its desired height lands exactly on a fractional-scale pixel boundary.

* fix(text): preserve lines at rounded fractional heights

TextLayout treated a floating-point accumulation error as a MaxHeight overflow. Use the established tolerant comparison so a line that exactly fits its rounded layout bounds is retained.

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../Media/TextFormatting/TextLayout.cs        |  2 +-
 .../TextBlockTests.cs                         | 26 +++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs b/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs
index a72e9e875e..4fe887dcbc 100644
--- a/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs
+++ b/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs
@@ -603,7 +603,7 @@ namespace Avalonia.Media.TextFormatting
 
                     //Fulfill max height constraint
                     if (textLines.Count > 0 && !double.IsPositiveInfinity(MaxHeight)
-                        && Height + textLine.Height > MaxHeight)
+                        && MathUtilities.GreaterThan(Height + textLine.Height, MaxHeight))
                     {
                         if (previousLine?.TextLineBreak != null && _textTrimming != TextTrimming.None)
                         {
diff --git a/tests/Avalonia.Controls.UnitTests/TextBlockTests.cs b/tests/Avalonia.Controls.UnitTests/TextBlockTests.cs
index 9a3b0e205d..df2e5c78b5 100644
--- a/tests/Avalonia.Controls.UnitTests/TextBlockTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TextBlockTests.cs
@@ -536,6 +536,32 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Rect(0, 0, 27.954545454545453, 14.522727272727273), target.Bounds);
         }
 
+        [Fact]
+        public void TextBlock_With_Fractional_LineHeight_Should_Not_Cull_Last_Line_At_Fractional_Scaling()
+        {
+            using var app = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
+
+            var target = new TextBlock
+            {
+                Text = "first second third",
+                FontSize = 16,
+                LineHeight = 20.8,
+                TextWrapping = TextWrapping.Wrap,
+                Width = 50,
+                HorizontalAlignment = HorizontalAlignment.Left,
+                VerticalAlignment = VerticalAlignment.Top,
+            };
+            var root = new TestRoot(target)
+            {
+                LayoutScaling = 1.25,
+            };
+
+            root.Measure(Size.Infinity);
+            root.Arrange(new Rect(root.DesiredSize));
+
+            Assert.Equal(3, target.TextLayout.TextLines.Count);
+        }
+
         [Fact]
         public void TextBlock_With_UseLayoutRounding_False_Should_Not_Round_Padding_In_MeasureOverride()
         {

From 0ab8b2fe58aebc670d6464b3b58568ddd26a5f62 Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Sat, 25 Jul 2026 05:20:25 +1000
Subject: [PATCH 117/196] fix(grid): allow shared size groups to shrink
 (#21837)

* test(grid): reproduce shared size group shrink failure

Shared auto columns expand when grouped content becomes visible but keep the expanded width after that content is hidden. Cover the full zero, expanded, and shrunk layout sequence so the stale shared minimum cannot regress unnoticed.

* fix(grid): allow shared size groups to shrink

Shared auto definitions reused the previous group minimum while recomputing the next group minimum, so an expanded width became self-sustaining after content shrank. Aggregate each definition's intrinsic measured minimum instead, preserving the shared-size invariant and matching the canonical WPF algorithm.

* test(grid): reproduce shared size group stuck on cyclic measure path

A grid mixing an auto-column/star-row cell with a star-column/auto-row
cell measures through Grid's cyclic dependency path, which saves and
restores definition min sizes around the repeated measure. The saved
value is the effective min size, so the group minimum is folded into the
definition's own contribution and the group can never shrink below it.

* fix(grid): restore raw min sizes on the cyclic measure path

Grid.CacheMinSizes read DefinitionBase.MinSize, which already includes
the shared group's minimum, but ApplyCachedMinSizes writes it back
through SetMinSize, which assigns the definition's own _minSize. A
short-pole definition therefore adopted the group minimum as its own
intrinsic minimum, which reclassified it as a long pole on the next
validation. Long poles with a valid measure are never remeasured, so the
fabricated minimum became unreachable and pinned the group open.

Add DefinitionBase.RawMinSize, the read counterpart of SetMinSize, and
cache that instead so the save/restore pair round-trips the definition's
own contribution. Matches the WPF fix in dotnet/wpf#2270.
---
 src/Avalonia.Controls/DefinitionBase.cs       | 13 ++-
 src/Avalonia.Controls/Grid.cs                 |  4 +-
 .../Avalonia.Controls.UnitTests/GridTests.cs  | 97 +++++++++++++++++++
 3 files changed, 111 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.Controls/DefinitionBase.cs b/src/Avalonia.Controls/DefinitionBase.cs
index 90211d8328..020f6996aa 100644
--- a/src/Avalonia.Controls/DefinitionBase.cs
+++ b/src/Avalonia.Controls/DefinitionBase.cs
@@ -269,6 +269,17 @@ namespace Avalonia.Controls
             }
         }
 
+        /// <summary>
+        /// Returns min size, never taking into account shared state.
+        /// </summary>
+        /// <remarks>
+        /// This is the definition's own intrinsic contribution to its group. It is the counterpart
+        /// of <see cref="SetMinSize"/>: code that saves and restores a min size across a measure
+        /// must round-trip this value, because feeding the group minimum back into
+        /// <see cref="_minSize"/> would make the group unable to shrink.
+        /// </remarks>
+        internal double RawMinSize => _minSize;
+
         /// <summary>
         /// Offset.
         /// </summary>
@@ -626,7 +637,7 @@ namespace Avalonia.Controls
                 //  accumulate min size of all participating definitions
                 for (int i = 0, count = _registry.Count; i < count; ++i)
                 {
-                    sharedMinSize = Math.Max(sharedMinSize, _registry[i].MinSize);
+                    sharedMinSize = Math.Max(sharedMinSize, _registry[i]._minSize);
                 }
 
                 bool sharedMinSizeChanged = !MathUtilities.AreClose(_minSize, sharedMinSize);
diff --git a/src/Avalonia.Controls/Grid.cs b/src/Avalonia.Controls/Grid.cs
index 3eb4eae98d..992cc38ecc 100644
--- a/src/Avalonia.Controls/Grid.cs
+++ b/src/Avalonia.Controls/Grid.cs
@@ -946,11 +946,11 @@ namespace Avalonia.Controls
             {
                 if (isRows)
                 {
-                    minSizes[PrivateCells[i].RowIndex] = DefinitionsV[PrivateCells[i].RowIndex].MinSize;
+                    minSizes[PrivateCells[i].RowIndex] = DefinitionsV[PrivateCells[i].RowIndex].RawMinSize;
                 }
                 else
                 {
-                    minSizes[PrivateCells[i].ColumnIndex] = DefinitionsU[PrivateCells[i].ColumnIndex].MinSize;
+                    minSizes[PrivateCells[i].ColumnIndex] = DefinitionsU[PrivateCells[i].ColumnIndex].RawMinSize;
                 }
 
                 i = PrivateCells[i].Next;
diff --git a/tests/Avalonia.Controls.UnitTests/GridTests.cs b/tests/Avalonia.Controls.UnitTests/GridTests.cs
index a15b8d8c77..435bb79cf3 100644
--- a/tests/Avalonia.Controls.UnitTests/GridTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/GridTests.cs
@@ -1212,6 +1212,103 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(10, grids[1].ColumnDefinitions[0].ActualWidth);
         }
 
+        [Fact]
+        public void Shared_Size_Group_Shrinks_When_Content_Is_Hidden()
+        {
+            var grids = new[]
+            {
+                CreateGrid(("A", GridLength.Auto)),
+                CreateGrid(("A", GridLength.Auto)),
+            };
+            var content = new Border
+            {
+                Width = 50,
+                IsVisible = false,
+            };
+            grids[1].Children.Add(content);
+
+            var scope = new StackPanel
+            {
+                [Grid.IsSharedSizeScopeProperty] = true,
+                Children =
+                {
+                    grids[0],
+                    grids[1],
+                },
+            };
+            var root = new TestRoot(scope);
+            void ExecuteSharedSizeLayoutPass()
+            {
+                // Shared groups validate after layout and apply any resulting invalidation on the next pass.
+                root.LayoutManager.ExecuteLayoutPass();
+                root.LayoutManager.ExecuteLayoutPass();
+            }
+
+            root.ExecuteInitialLayoutPass();
+            Assert.All(grids, grid => Assert.Equal(0, grid.ColumnDefinitions[0].ActualWidth));
+
+            content.IsVisible = true;
+            ExecuteSharedSizeLayoutPass();
+            Assert.All(grids, grid => Assert.Equal(50, grid.ColumnDefinitions[0].ActualWidth));
+
+            content.IsVisible = false;
+            ExecuteSharedSizeLayoutPass();
+            Assert.All(grids, grid => Assert.Equal(0, grid.ColumnDefinitions[0].ActualWidth));
+        }
+
+        [Fact]
+        public void Shared_Size_Group_Shrinks_When_Participant_Uses_Cyclic_Measure_Path()
+        {
+            // A grid mixing an auto-column/star-row cell with a star-column/auto-row cell cannot
+            // resolve stars in either direction up front, so Grid measures it through its cyclic
+            // dependency path. That path saves definition min sizes before the repeated measure and
+            // restores them afterwards. Saving the effective min size folds the group minimum into
+            // the definition's own contribution, which then reclassifies it as a long pole - and
+            // long poles are deliberately never remeasured, so the group stays pinned open.
+            var cyclicGrid = CreateGrid(("A", GridLength.Auto), (null, new GridLength(1, GridUnitType.Star)));
+            cyclicGrid.Height = 100;  // star rows collapse to auto under an infinite constraint.
+            cyclicGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+            cyclicGrid.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
+
+            var autoColumnStarRowChild = new Border { Width = 10, Height = 10 };
+            Grid.SetColumn(autoColumnStarRowChild, 0);
+            Grid.SetRow(autoColumnStarRowChild, 1);
+
+            var starColumnAutoRowChild = new Border { Width = 10, Height = 10 };
+            Grid.SetColumn(starColumnAutoRowChild, 1);
+            Grid.SetRow(starColumnAutoRowChild, 0);
+
+            cyclicGrid.Children.Add(autoColumnStarRowChild);
+            cyclicGrid.Children.Add(starColumnAutoRowChild);
+
+            var plainGrid = CreateGrid(("A", GridLength.Auto), (null, new GridLength(1, GridUnitType.Star)));
+            var wideContent = new Border { Width = 50, Height = 10 };
+            plainGrid.Children.Add(wideContent);
+
+            var scope = new StackPanel
+            {
+                [Grid.IsSharedSizeScopeProperty] = true,
+                Children = { cyclicGrid, plainGrid },
+            };
+            var root = new TestRoot(scope);
+            void ExecuteSharedSizeLayoutPass()
+            {
+                // Shared groups validate after layout and apply any resulting invalidation on the next pass.
+                root.LayoutManager.ExecuteLayoutPass();
+                root.LayoutManager.ExecuteLayoutPass();
+            }
+
+            root.ExecuteInitialLayoutPass();
+            ExecuteSharedSizeLayoutPass();
+            Assert.Equal(50, cyclicGrid.ColumnDefinitions[0].ActualWidth);
+            Assert.Equal(50, plainGrid.ColumnDefinitions[0].ActualWidth);
+
+            wideContent.IsVisible = false;
+            ExecuteSharedSizeLayoutPass();
+            Assert.Equal(10, cyclicGrid.ColumnDefinitions[0].ActualWidth);
+            Assert.Equal(10, plainGrid.ColumnDefinitions[0].ActualWidth);
+        }
+
         [Fact]
         public void Collection_Changes_Are_Tracked()
         {

From 94f458da0e178fc19d7f52db45b426ece6a553c5 Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Sat, 25 Jul 2026 07:03:02 +1000
Subject: [PATCH 118/196] fix(TextBox): clear undo history on external text
 updates (#21839)

* test(TextBox): reproduce stale undo history after binding update

TwoWay-bound TextBox instances retain prior user-edit snapshots when the binding source replaces the text, allowing undo to write values from a previous model context back into the current source. Cover the external replacement and the normal TwoWay source echo separately so a fix cannot clear valid user undo history after each edit.

* fix(TextBox): reset undo history for external text updates

Binding and direct property updates currently enter the same undo timeline as user edits, so a reused TwoWay-bound TextBox can write text from a previous model back into the current source. Track TextBox-initiated mutations through synchronous source notifications, preserve those edits in the undo timeline, and establish a fresh baseline for all external updates. MaskedTextBox routes its own edits through the same boundary so its existing undo behavior remains intact.

* fix(TextBox): distinguish edits from internal synchronization in undo history

Replace the boolean text-mutation flag with a three-state TextMutationKind
(ExternalReplacement / Edit / InternalSynchronization) so MaskedTextBox's
prompt-character reformatting on focus/blur and mask-provider refreshes no
longer create undo entries, while actual keyboard edits remain undoable.
---
 src/Avalonia.Controls/MaskedTextBox.cs        |  19 ++-
 src/Avalonia.Controls/TextBox.cs              |  91 ++++++++++---
 .../MaskedTextBoxTests.cs                     | 121 ++++++++++++++++++
 .../TextBoxTests.cs                           |  67 ++++++++++
 4 files changed, 273 insertions(+), 25 deletions(-)

diff --git a/src/Avalonia.Controls/MaskedTextBox.cs b/src/Avalonia.Controls/MaskedTextBox.cs
index 22c05e7159..756eb31b12 100644
--- a/src/Avalonia.Controls/MaskedTextBox.cs
+++ b/src/Avalonia.Controls/MaskedTextBox.cs
@@ -190,7 +190,7 @@ namespace Avalonia.Controls
         {
             if (HidePromptOnLeave == true && MaskProvider != null)
             {
-                SetCurrentValue(TextProperty, MaskProvider.ToDisplayString());
+                SetTextFromInternalSynchronization(MaskProvider.ToDisplayString());
             }
             base.OnGotFocus(e);
         }
@@ -241,7 +241,7 @@ namespace Avalonia.Controls
                     }
                 }
 
-                SetCurrentValue(TextProperty, MaskProvider.ToDisplayString());
+                SetTextFromEdit(MaskProvider.ToDisplayString());
                 e.Handled = true;
                 return;
             }
@@ -291,7 +291,7 @@ namespace Avalonia.Controls
         {
             if (HidePromptOnLeave && MaskProvider != null)
             {
-                SetCurrentValue(TextProperty, MaskProvider.ToString(!HidePromptOnLeave, true));
+                SetTextFromInternalSynchronization(MaskProvider.ToString(!HidePromptOnLeave, true));
             }
             base.OnLostFocus(e);
         }
@@ -306,7 +306,7 @@ namespace Avalonia.Controls
                 {
                     MaskProvider.Set(Text);
                 }
-                RefreshText(MaskProvider, 0);
+                RefreshText(MaskProvider, 0, isEdit: false);
             }
             if (change.Property == MaskProperty)
             {
@@ -426,11 +426,18 @@ namespace Avalonia.Controls
             return startPosition;
         }
 
-        private void RefreshText(MaskedTextProvider? provider, int position)
+        private void RefreshText(MaskedTextProvider? provider, int position, bool isEdit = true)
         {
             if (provider != null)
             {
-                SetCurrentValue(TextProperty, provider.ToDisplayString());
+                if (isEdit)
+                {
+                    SetTextFromEdit(provider.ToDisplayString());
+                }
+                else
+                {
+                    SetTextFromInternalSynchronization(provider.ToDisplayString());
+                }
                 SetCurrentValue(CaretIndexProperty, position);
             }
         }
diff --git a/src/Avalonia.Controls/TextBox.cs b/src/Avalonia.Controls/TextBox.cs
index 0f2e3d51ce..408e837043 100644
--- a/src/Avalonia.Controls/TextBox.cs
+++ b/src/Avalonia.Controls/TextBox.cs
@@ -362,11 +362,21 @@ namespace Avalonia.Controls
             public override int GetHashCode() => Text?.GetHashCode() ?? 0;
         }
 
+        private enum TextMutationKind
+        {
+            ExternalReplacement,
+            Edit,
+            InternalSynchronization,
+        }
+
         private TextPresenter? _presenter;
         private ScrollViewer? _scrollViewer;
         private readonly TextBoxTextInputMethodClient _imClient = new();
         private readonly UndoRedoHelper<UndoRedoState> _undoRedoHelper;
         private bool _isUndoingRedoing;
+        private TextMutationKind _textMutationKind;
+        // Coercion runs before the new value is committed, so a snapshot taken there would capture the old text.
+        private bool _needsUndoRedoSnapshotAfterTextChange;
         private bool _canCut;
         private bool _canCopy;
         private bool _canPaste;
@@ -641,16 +651,29 @@ namespace Avalonia.Controls
         /// </remarks>
         protected virtual string? CoerceText(string? value)
         {
-            // Before #9490, snapshot here was done AFTER text change - this doesn't make sense
-            // since initial state would never be no text and you'd always have to make a text
-            // change before undo would be available
-            // The undo/redo stacks were also cleared at this point, which also doesn't make sense
-            // as it is still valid to want to undo a programmatic text set
-            // So we snapshot text now BEFORE the change so we can always revert
-            // Also don't need to check IsUndoEnabled here, that's done in SnapshotUndoRedo
             if (!_isUndoingRedoing)
             {
-                SnapshotUndoRedo();
+                switch (_textMutationKind)
+                {
+                    case TextMutationKind.Edit:
+                        SnapshotUndoRedo();
+
+                        if (!_undoRedoHelper.CanUndo &&
+                            !string.Equals(Text, value, StringComparison.Ordinal))
+                        {
+                            _needsUndoRedoSnapshotAfterTextChange = true;
+                        }
+                        break;
+
+                    case TextMutationKind.InternalSynchronization:
+                        break;
+
+                    case TextMutationKind.ExternalReplacement:
+                    default:
+                        ClearUndoRedo();
+                        _needsUndoRedoSnapshotAfterTextChange = true;
+                        break;
+                }
             }
 
             return value;
@@ -878,9 +901,7 @@ namespace Avalonia.Controls
             // from docs at
             // https://docs.microsoft.com/en-us/dotnet/api/system.windows.controls.primitives.textboxbase.isundoenabled:
             // "Setting UndoLimit clears the undo queue."
-            _undoRedoHelper.Clear();
-            _selectedTextChangesMadeSinceLastUndoSnapshot = 0;
-            _hasDoneSnapshotOnce = false;
+            ClearUndoRedo();
         }
 
         /// <summary>
@@ -1032,6 +1053,12 @@ namespace Avalonia.Controls
 
             if (change.Property == TextProperty)
             {
+                if (_needsUndoRedoSnapshotAfterTextChange)
+                {
+                    _needsUndoRedoSnapshotAfterTextChange = false;
+                    SnapshotUndoRedo();
+                }
+
                 CoerceValue(CaretIndexProperty);
                 CoerceValue(SelectionStartProperty);
                 CoerceValue(SelectionEndProperty);
@@ -1078,9 +1105,7 @@ namespace Avalonia.Controls
                 // "Setting this property to false clears the undo stack.
                 // Therefore, if you disable undo and then re-enable it, undo commands still do not work
                 // because the undo stack was emptied when you disabled undo."
-                _undoRedoHelper.Clear();
-                _selectedTextChangesMadeSinceLastUndoSnapshot = 0;
-                _hasDoneSnapshotOnce = false;
+                ClearUndoRedo();
             }
         }
 
@@ -1206,7 +1231,7 @@ namespace Avalonia.Controls
 
                 var text = StringBuilderCache.GetStringAndRelease(textBuilder);
 
-                SetCurrentValue(TextProperty, text);
+                SetTextFromEdit(text);
 
                 ClearSelection();
 
@@ -1611,7 +1636,7 @@ namespace Avalonia.Controls
                                     sb.Append(text);
                                     sb.Remove(start, end - start);
 
-                                    SetCurrentValue(TextProperty, StringBuilderCache.GetStringAndRelease(sb));
+                                    SetTextFromEdit(StringBuilderCache.GetStringAndRelease(sb));
 
                                     SetCurrentValue(CaretIndexProperty, start);
 
@@ -1650,7 +1675,7 @@ namespace Avalonia.Controls
                                     sb.Append(text);
                                     sb.Remove(start, end - start);
 
-                                    SetCurrentValue(TextProperty, StringBuilderCache.GetStringAndRelease(sb));
+                                    SetTextFromEdit(StringBuilderCache.GetStringAndRelease(sb));
                                 }
                             }
 
@@ -2139,7 +2164,7 @@ namespace Avalonia.Controls
         /// <summary>
         /// Clears the text in the TextBox
         /// </summary>
-        public void Clear() => SetCurrentValue(TextProperty, string.Empty);
+        public void Clear() => SetTextFromEdit(string.Empty);
 
         private void MoveHorizontal(int direction, bool wholeWord, bool isSelecting, bool moveCaretPosition)
         {
@@ -2396,7 +2421,7 @@ namespace Avalonia.Controls
                 textBuilder.Append(text);
                 textBuilder.Remove(start, end - start);
 
-                SetCurrentValue(TextProperty, StringBuilderCache.GetStringAndRelease(textBuilder));
+                SetTextFromEdit(StringBuilderCache.GetStringAndRelease(textBuilder));
 
                 _presenter?.MoveCaretToTextPosition(start);
 
@@ -2434,6 +2459,27 @@ namespace Avalonia.Controls
             return text.Substring(start, end - start);
         }
 
+        internal void SetTextFromEdit(string? value) => SetTextCore(value, TextMutationKind.Edit);
+
+        internal void SetTextFromInternalSynchronization(string? value) =>
+            SetTextCore(value, TextMutationKind.InternalSynchronization);
+
+        private void SetTextCore(string? value, TextMutationKind mutationKind)
+        {
+            // Stays set through the synchronous TwoWay source echo so it isn't mistaken for an external replacement.
+            var previousMutationKind = _textMutationKind;
+            _textMutationKind = mutationKind;
+
+            try
+            {
+                SetCurrentValue(TextProperty, value);
+            }
+            finally
+            {
+                _textMutationKind = previousMutationKind;
+            }
+        }
+
         /// <summary>
         /// Returns the sum of any vertical whitespace added between the <see cref="ScrollViewer"/> and <see cref="TextPresenter"/> in the control template.
         /// </summary>
@@ -2561,6 +2607,13 @@ namespace Avalonia.Controls
             }
         }
 
+        private void ClearUndoRedo()
+        {
+            _undoRedoHelper.Clear();
+            _selectedTextChangesMadeSinceLastUndoSnapshot = 0;
+            _hasDoneSnapshotOnce = false;
+        }
+
         /// <summary>
         /// Undoes the first action in the undo stack
         /// </summary>
diff --git a/tests/Avalonia.Controls.UnitTests/MaskedTextBoxTests.cs b/tests/Avalonia.Controls.UnitTests/MaskedTextBoxTests.cs
index cddac813f8..74d025920b 100644
--- a/tests/Avalonia.Controls.UnitTests/MaskedTextBoxTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/MaskedTextBoxTests.cs
@@ -921,6 +921,127 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Focusing_And_Unfocusing_Does_Not_Create_Undo_Operation()
+        {
+            using (Start(FocusServices))
+            {
+                var target = new MaskedTextBox
+                {
+                    Template = CreateTemplate(),
+                    Mask = "000",
+                    HidePromptOnLeave = true,
+                    Text = "123"
+                };
+
+                var other = new MaskedTextBox { Template = CreateTemplate() };
+
+                var sp = new StackPanel();
+                sp.Children.Add(target);
+                sp.Children.Add(other);
+
+                target.ApplyTemplate();
+                other.ApplyTemplate();
+
+                var root = new TestRoot() { Child = sp };
+
+                target.Focus();
+                other.Focus();
+
+                Assert.False(target.CanUndo);
+            }
+        }
+
+        [Fact]
+        public void Masked_Edit_Remains_Undoable()
+        {
+            using (Start(FocusServices))
+            {
+                var target = new MaskedTextBox
+                {
+                    Template = CreateTemplate(),
+                    Mask = "000",
+                    Text = "123"
+                };
+
+                target.ApplyTemplate();
+
+                var root = new TestRoot() { Child = target };
+
+                target.Focus();
+                target.CaretIndex = 3;
+
+                RaiseKeyEvent(target, Key.Back, KeyModifiers.None);
+
+                Assert.Equal("12_", target.Text);
+                Assert.True(target.CanUndo);
+
+                target.Undo();
+
+                Assert.Equal("123", target.Text);
+            }
+        }
+
+        [Fact]
+        public void External_Replacement_After_Masked_Edit_Clears_Undo_History()
+        {
+            using (Start(FocusServices))
+            {
+                var target = new MaskedTextBox
+                {
+                    Template = CreateTemplate(),
+                    Mask = "000",
+                    Text = "123"
+                };
+
+                target.ApplyTemplate();
+
+                var root = new TestRoot() { Child = target };
+
+                target.Focus();
+                target.CaretIndex = 3;
+
+                RaiseKeyEvent(target, Key.Back, KeyModifiers.None);
+
+                Assert.True(target.CanUndo);
+
+                target.Text = "456";
+
+                Assert.False(target.CanUndo);
+                Assert.False(target.CanRedo);
+            }
+        }
+
+        [Fact]
+        public void Clear_And_SelectedText_Replacement_Remain_Undoable()
+        {
+            using (Start(FocusServices))
+            {
+                var target = new MaskedTextBox
+                {
+                    Template = CreateTemplate(),
+                    Mask = "000",
+                    Text = "123"
+                };
+
+                target.ApplyTemplate();
+
+                var root = new TestRoot() { Child = target };
+
+                target.Focus();
+
+                target.Clear();
+                Assert.True(target.CanUndo);
+
+                target.Undo();
+                target.SelectionStart = 0;
+                target.SelectionEnd = 1;
+                target.SelectedText = "9";
+
+                Assert.True(target.CanUndo);
+            }
+        }
+
         private static TestServices FocusServices => TestServices.MockThreadingInterface.With(
             keyboardDevice: () => new KeyboardDevice(),
             keyboardNavigation: () => new KeyboardNavigationHandler(),
diff --git a/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs b/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
index 1d7570c2a1..39dd5efa1d 100644
--- a/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
@@ -1406,6 +1406,73 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Binding_Source_Change_Clears_Undo_History()
+        {
+            using (UnitTestApplication.Start(Services))
+            {
+                var source = new Class1 { Bar = "initial" };
+                var textBox = new TextBox
+                {
+                    Template = CreateTemplate(),
+                    DataContext = source,
+                };
+
+                textBox.Bind(TextBox.TextProperty, new Binding(nameof(Class1.Bar))
+                {
+                    Mode = BindingMode.TwoWay,
+                });
+                textBox.Measure(Size.Infinity);
+                textBox.CaretIndex = textBox.Text!.Length;
+
+                RaiseTextEvent(textBox, " edit");
+                RaiseKeyEvent(textBox, Key.Space, KeyModifiers.None);
+                RaiseTextEvent(textBox, " more");
+
+                Assert.Equal("initial edit more", source.Bar);
+                Assert.True(textBox.CanUndo);
+
+                source.Bar = "replacement";
+
+                Assert.Equal("replacement", textBox.Text);
+                Assert.False(textBox.CanUndo);
+                Assert.False(textBox.CanRedo);
+            }
+        }
+
+        [Fact]
+        public void TwoWay_Binding_Source_Echo_Does_Not_Clear_Undo_History()
+        {
+            using (UnitTestApplication.Start(Services))
+            {
+                var source = new Class1 { Bar = "initial" };
+                var textBox = new TextBox
+                {
+                    Template = CreateTemplate(),
+                    DataContext = source,
+                };
+
+                textBox.Bind(TextBox.TextProperty, new Binding(nameof(Class1.Bar))
+                {
+                    Mode = BindingMode.TwoWay,
+                });
+                textBox.Measure(Size.Infinity);
+                textBox.CaretIndex = textBox.Text!.Length;
+
+                RaiseTextEvent(textBox, " edit");
+                RaiseKeyEvent(textBox, Key.Space, KeyModifiers.None);
+                RaiseTextEvent(textBox, " more");
+
+                Assert.Equal("initial edit more", source.Bar);
+                Assert.True(textBox.CanUndo);
+
+                textBox.Undo();
+
+                Assert.Equal("initial edit", textBox.Text);
+                Assert.Equal("initial edit", source.Bar);
+            }
+        }
+
         [Fact]
         public void Setting_UndoLimit_Clears_Undo_Redo()
         {

From 1e356ab649ff0a910a8294dce73619e863288d3a Mon Sep 17 00:00:00 2001
From: the-bla <mail.rrm@pm.me>
Date: Sat, 25 Jul 2026 00:06:22 -0800
Subject: [PATCH 119/196] Update Vulkan composite alpha selection logic to
 prefer pre-multiplied mode if supported. This change ensures proper
 transparency support for popups when in Vulkan rendering mode. Upon updating
 to Nvidia driver 610.74, Popups, when in Vulkan rendering, were showing the
 classic black square around them if margin is applied. This fixes that issue
 while still falling back if pre-multiplied is unavailable. (#21802)

---
 src/Avalonia.Vulkan/Interop/VulkanDisplay.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Vulkan/Interop/VulkanDisplay.cs b/src/Avalonia.Vulkan/Interop/VulkanDisplay.cs
index ba767f7c1e..974fd1add8 100644
--- a/src/Avalonia.Vulkan/Interop/VulkanDisplay.cs
+++ b/src/Avalonia.Vulkan/Interop/VulkanDisplay.cs
@@ -119,7 +119,10 @@ internal class VulkanDisplay : IDisposable
             preTransform = supportsIdentityTransform && isRotated
                 ? VkSurfaceTransformFlagsKHR.VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR
                 : capabilities.currentTransform,
-            compositeAlpha = VkCompositeAlphaFlagsKHR.VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
+            compositeAlpha = capabilities.supportedCompositeAlpha.HasAllFlags(
+                VkCompositeAlphaFlagsKHR.VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR)
+                ? VkCompositeAlphaFlagsKHR.VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR
+                : VkCompositeAlphaFlagsKHR.VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
             presentMode = presentMode,
             clipped = 1,
             oldSwapchain = oldDisplay?._swapchain ?? default

From d6e282ba04adbd61ddb05994b0ae1eb2ba99d8c8 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Sat, 25 Jul 2026 18:17:06 +0500
Subject: [PATCH 120/196] Fix X11 active window tracking (#21846)

* Force-mark closed window as no longer active if backend didn't do it for some reason

* [X11] Speculatively mark the active closed dialog parent as active window
---
 src/Avalonia.Controls/WindowBase.cs           |  2 +
 src/Avalonia.X11/ActivityTrackingHelper.cs    | 65 +++++++++++++------
 src/Avalonia.X11/X11ActiveWindowTracker.cs    | 55 ++++++++++++++++
 src/Avalonia.X11/X11Platform.cs               |  2 +
 src/Avalonia.X11/X11Window.cs                 | 25 +++++++
 .../WindowBaseTests.cs                        | 55 ++++++++++++++++
 6 files changed, 183 insertions(+), 21 deletions(-)
 create mode 100644 src/Avalonia.X11/X11ActiveWindowTracker.cs

diff --git a/src/Avalonia.Controls/WindowBase.cs b/src/Avalonia.Controls/WindowBase.cs
index 894b7ca6e6..de882b09f4 100644
--- a/src/Avalonia.Controls/WindowBase.cs
+++ b/src/Avalonia.Controls/WindowBase.cs
@@ -239,6 +239,8 @@ namespace Avalonia.Controls
             {
                 IsVisible = false;
 
+                if (IsActive)
+                    HandleDeactivated();
                 if (this is IFocusScope scope)
                 {
                     ((FocusManager?)FocusManager)?.RemoveFocusRoot(scope);
diff --git a/src/Avalonia.X11/ActivityTrackingHelper.cs b/src/Avalonia.X11/ActivityTrackingHelper.cs
index e5b56f86bd..dd4e01ad2f 100644
--- a/src/Avalonia.X11/ActivityTrackingHelper.cs
+++ b/src/Avalonia.X11/ActivityTrackingHelper.cs
@@ -10,16 +10,23 @@ internal class WindowActivationTrackingHelper : IDisposable
     private readonly X11Window _window;
     private bool _active;
 
+    // Set when the current active state came from a speculative transfer (see SetActiveSpeculatively).
+    // Only meaningful in _NET_WM_STATE_FOCUSED mode, where the guess is re-verified against the real
+    // _NET_WM_STATE the next time the active window changes.
+    private bool _speculative;
+
     public event Action<bool>? ActivationChanged;
-    
+
     public WindowActivationTrackingHelper(AvaloniaX11Platform platform, X11Window window)
     {
         _platform = platform;
         _window = window;
-        _platform.Globals.NetActiveWindowPropertyChanged += OnNetActiveWindowChanged;
+        _platform.ActiveWindowTracker.ActiveWindowChanged += OnActiveWindowChanged;
         _platform.Globals.WindowActivationTrackingModeChanged += OnWindowActivationTrackingModeChanged;
     }
 
+    public bool IsActive => _active;
+
     void SetActive(bool active)
     {
         if (active != _active)
@@ -29,23 +36,23 @@ internal class WindowActivationTrackingHelper : IDisposable
         }
     }
 
+    private X11Globals.WindowActivationTrackingMode Mode => _platform.Globals.ActivationTrackingMode;
+
+    void RequeryNetWmState() =>
+        OnNetWmStateChanged(XLib.XGetWindowPropertyAsIntPtrArray(_platform.Display, _window.Handle.Handle,
+            _platform.Info.Atoms._NET_WM_STATE, _platform.Info.Atoms.ATOM) ?? []);
+
     void RequeryActivation()
     {
-        // Update the active state from WM-set properties
-        
-        if (Mode == X11Globals.WindowActivationTrackingMode._NET_ACTIVE_WINDOW) 
-            OnNetActiveWindowChanged();
-        
+        // The _NET_ACTIVE_WINDOW mode is driven by the shared X11ActiveWindowTracker, so only the
+        // per-window _NET_WM_STATE needs re-reading here.
         if (Mode == X11Globals.WindowActivationTrackingMode._NET_WM_STATE_FOCUSED)
-            OnNetWmStateChanged(XLib.XGetWindowPropertyAsIntPtrArray(_platform.Display, _window.Handle.Handle,
-                _platform.Info.Atoms._NET_WM_STATE, _platform.Info.Atoms.ATOM) ?? []);
+            RequeryNetWmState();
     }
 
     private void OnWindowActivationTrackingModeChanged() =>
         DispatcherTimer.RunOnce(RequeryActivation, TimeSpan.FromSeconds(1), DispatcherPriority.Input);
 
-    private X11Globals.WindowActivationTrackingMode Mode => _platform.Globals.ActivationTrackingMode;
-    
     public void OnEvent(ref XEvent ev)
     {
         if (ev.type is not XEventName.FocusIn and not XEventName.FocusOut)
@@ -63,30 +70,46 @@ internal class WindowActivationTrackingHelper : IDisposable
         
         SetActive(ev.type == XEventName.FocusIn);
     }
-    
-    private void OnNetActiveWindowChanged()
+
+    private void OnActiveWindowChanged(IntPtr activeWindow)
     {
         if (Mode == X11Globals.WindowActivationTrackingMode._NET_ACTIVE_WINDOW)
         {
-            var value = XLib.XGetWindowPropertyAsIntPtrArray(_platform.Display, _platform.Info.RootWindow,
-                _platform.Info.Atoms._NET_ACTIVE_WINDOW,
-                (IntPtr)_platform.Info.Atoms.WINDOW);
-            if (value == null || value.Length == 0)
-                SetActive(false);
-            else
-                SetActive(value[0] == _window.Handle.Handle);
+            // Authoritative in this mode — the published XID is the active window.
+            _speculative = false;
+            SetActive(activeWindow == _window.Handle.Handle);
         }
+        // In _NET_WM_STATE_FOCUSED mode the root _NET_ACTIVE_WINDOW change is only a "focus moved"
+        // pulse; use it to re-verify a speculative activation against the authoritative _NET_WM_STATE.
+        else if (Mode == X11Globals.WindowActivationTrackingMode._NET_WM_STATE_FOCUSED && _speculative)
+            RequeryNetWmState();
+    }
+
+    /// <summary>
+    /// Marks the window as active without waiting for the real activation notification. Used when
+    /// handing activation back to a dialog owner. The next active window change re-verifies the guess
+    /// (see <see cref="OnActiveWindowChanged"/>): authoritatively via the published XID in
+    /// _NET_ACTIVE_WINDOW mode, or by re-reading our own _NET_WM_STATE in _NET_WM_STATE_FOCUSED mode.
+    /// </summary>
+    public void SetActiveSpeculatively()
+    {
+        _speculative = true;
+        SetActive(true);
     }
 
     public void Dispose()
     {
-        _platform.Globals.NetActiveWindowPropertyChanged -= OnNetActiveWindowChanged;
+        _platform.ActiveWindowTracker.ActiveWindowChanged -= OnActiveWindowChanged;
         _platform.Globals.WindowActivationTrackingModeChanged -= OnWindowActivationTrackingModeChanged;
     }
 
     public void OnNetWmStateChanged(IntPtr[] atoms)
     {
         if (Mode == X11Globals.WindowActivationTrackingMode._NET_WM_STATE_FOCUSED)
+        {
+            // Authoritative signal — it overrides any speculative guess.
+            _speculative = false;
             SetActive(atoms.Contains(_platform.Info.Atoms._NET_WM_STATE_FOCUSED));
+        }
     }
 }
diff --git a/src/Avalonia.X11/X11ActiveWindowTracker.cs b/src/Avalonia.X11/X11ActiveWindowTracker.cs
new file mode 100644
index 0000000000..3202697a23
--- /dev/null
+++ b/src/Avalonia.X11/X11ActiveWindowTracker.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Linq;
+using Avalonia.Threading;
+
+namespace Avalonia.X11;
+
+/// <summary>
+/// Watches the root <c>_NET_ACTIVE_WINDOW</c> property and raises <see cref="ActiveWindowChanged"/>
+/// whenever the active window changes. This is a single, always-updated global notification that
+/// <c>_NET_WM_STATE_FOCUSED</c> mode lacks (that one only notifies the window whose own state changed),
+/// so windows use it both to track activation (in <c>_NET_ACTIVE_WINDOW</c> mode) and to re-verify a
+/// speculative activation (in <c>_NET_WM_STATE_FOCUSED</c> mode).
+/// </summary>
+internal class X11ActiveWindowTracker
+{
+    private readonly AvaloniaX11Platform _platform;
+    private IntPtr _activeWindow;
+
+    public event Action<IntPtr>? ActiveWindowChanged;
+
+    public X11ActiveWindowTracker(AvaloniaX11Platform platform)
+    {
+        _platform = platform;
+        _platform.Globals.NetActiveWindowPropertyChanged += Requery;
+        _platform.Globals.WindowActivationTrackingModeChanged += OnModeChanged;
+        _platform.Globals.NetSupportedChanged += Requery;
+        Requery();
+    }
+
+    // Whether the WM publishes root _NET_ACTIVE_WINDOW at all. Speculative activations can only be
+    // auto-corrected when it does, since that's the notification we re-verify against.
+    public bool TracksRootActiveWindow =>
+        _platform.Globals.NetSupported?.Contains(_platform.Info.Atoms._NET_ACTIVE_WINDOW) ?? false;
+
+    private void SetActiveWindow(IntPtr window)
+    {
+        if (_activeWindow != window)
+        {
+            _activeWindow = window;
+            ActiveWindowChanged?.Invoke(window);
+        }
+    }
+
+    private void Requery()
+    {
+        if (!TracksRootActiveWindow)
+            return;
+        var value = XLib.XGetWindowPropertyAsIntPtrArray(_platform.Info.Display, _platform.Info.RootWindow,
+            _platform.Info.Atoms._NET_ACTIVE_WINDOW, (IntPtr)_platform.Info.Atoms.WINDOW);
+        SetActiveWindow(value is { Length: > 0 } ? value[0] : IntPtr.Zero);
+    }
+
+    private void OnModeChanged() =>
+        DispatcherTimer.RunOnce(Requery, TimeSpan.FromSeconds(1), DispatcherPriority.Input);
+}
diff --git a/src/Avalonia.X11/X11Platform.cs b/src/Avalonia.X11/X11Platform.cs
index 408fe512ea..7276be0fb0 100644
--- a/src/Avalonia.X11/X11Platform.cs
+++ b/src/Avalonia.X11/X11Platform.cs
@@ -45,6 +45,7 @@ namespace Avalonia.X11
         public X11PlatformOptions Options { get; private set; } = null!;
         public IntPtr OrphanedWindow { get; private set; }
         public X11Globals Globals { get; private set; } = null!;
+        public X11ActiveWindowTracker ActiveWindowTracker { get; private set; } = null!;
         public XResources Resources { get; private set; } = null!;
         public ManualRawEventGrouperDispatchQueue EventGrouperDispatchQueue { get; } = new();
         public IX11PlatformDispatcher DispatcherImpl { get; private set; } = null!;
@@ -75,6 +76,7 @@ namespace Avalonia.X11
 
             Info = new X11Info(Display, DeferredDisplay, useXim);
             Globals = new X11Globals(this);
+            ActiveWindowTracker = new X11ActiveWindowTracker(this);
             Resources = new XResources(this);
 
             IRenderTimer timer = options.ShouldRenderOnUIThread
diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index cece8e8bb0..1ed61248d0 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -66,6 +66,7 @@ namespace Avalonia.X11
         private bool _disabled;
         private TransparencyHelper? _transparencyHelper;
         private WindowActivationTrackingHelper? _activationTracker;
+        private X11Window? _transientParent;
         private RawEventGrouper? _rawEventGrouper;
         private bool _useRenderWindow = false;
         private bool _useCompositorDrivenRenderWindowResize = false;
@@ -1125,6 +1126,22 @@ namespace Avalonia.X11
                     atSpiServer.RemoveWindow(atSpiPeer);
             }
 
+            // If we're closing the active window, speculatively hand activation back to its owner so an
+            // awaited ShowDialog() sees the owner as active immediately, instead of waiting for the
+            // asynchronous activation notification (auto-corrected later if the guess is wrong).
+            // Mirroring win32's BeforeCloseCleanup, the owner has to be re-enabled before it's activated:
+            // while it's still modally disabled the activation would be swallowed by
+            // ActivateTransientChildIfNeeded. The managed layer sets the final enabled state afterwards.
+            // Only speculate when there's a root _NET_ACTIVE_WINDOW notification to auto-correct against.
+            if (_handle != IntPtr.Zero
+                && _transientParent is { } parent && parent._handle != IntPtr.Zero
+                && _activationTracker?.IsActive == true
+                && _platform.ActiveWindowTracker.TracksRootActiveWindow)
+            {
+                parent.SetEnabled(true);
+                parent.SetActiveSpeculatively();
+            }
+
             // Before doing anything else notify the TopLevel that ITopLevelImpl is no longer valid
             if (_handle != IntPtr.Zero)
                 Closed?.Invoke();
@@ -1201,12 +1218,20 @@ namespace Avalonia.X11
             return false;
         }
 
+        private void SetActiveSpeculatively() => _activationTracker?.SetActiveSpeculatively();
+
         public void SetParent(IWindowImpl? parent)
         {
             if (parent == null || parent.Handle == null || parent.Handle.Handle == IntPtr.Zero)
+            {
+                _transientParent = null;
                 XDeleteProperty(_x11.Display, _handle, _x11.Atoms.WM_TRANSIENT_FOR);
+            }
             else
+            {
+                _transientParent = parent as X11Window;
                 XSetTransientForHint(_x11.Display, _handle, parent.Handle.Handle);
+            }
         }
 
         public void Show(bool activate, bool isDialog)
diff --git a/tests/Avalonia.Controls.UnitTests/WindowBaseTests.cs b/tests/Avalonia.Controls.UnitTests/WindowBaseTests.cs
index ff065130c9..8691c1d184 100644
--- a/tests/Avalonia.Controls.UnitTests/WindowBaseTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/WindowBaseTests.cs
@@ -98,6 +98,61 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Active_Window_Should_Be_Deactivated_When_Impl_Signals_Close()
+        {
+            var windowImpl = new Mock<IPopupImpl>();
+            windowImpl.Setup(x => x.Compositor).Returns(RendererMocks.CreateDummyCompositor());
+            windowImpl.Setup(x => x.DesktopScaling).Returns(1);
+            windowImpl.Setup(x => x.RenderScaling).Returns(1);
+            windowImpl.SetupProperty(x => x.Activated);
+            windowImpl.SetupProperty(x => x.Closed);
+
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var target = new TestWindowBase(windowImpl.Object);
+                var deactivated = 0;
+                target.Deactivated += (s, e) => deactivated++;
+
+                target.Show();
+                windowImpl.Object.Activated!();
+                Assert.True(target.IsActive);
+
+                // Some backends (e.g. X11) never deliver a deactivation notification on close.
+                windowImpl.Object.Closed!();
+
+                Assert.False(target.IsActive);
+                Assert.Equal(1, deactivated);
+            }
+        }
+
+        [Fact]
+        public void Inactive_Window_Should_Not_Raise_Deactivated_When_Impl_Signals_Close()
+        {
+            var windowImpl = new Mock<IPopupImpl>();
+            windowImpl.Setup(x => x.Compositor).Returns(RendererMocks.CreateDummyCompositor());
+            windowImpl.Setup(x => x.DesktopScaling).Returns(1);
+            windowImpl.Setup(x => x.RenderScaling).Returns(1);
+            windowImpl.SetupProperty(x => x.Deactivated);
+            windowImpl.SetupProperty(x => x.Closed);
+
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var target = new TestWindowBase(windowImpl.Object);
+                var deactivated = 0;
+                target.Deactivated += (s, e) => deactivated++;
+
+                target.Show();
+                Assert.False(target.IsActive);
+
+                // Backends that deactivate before closing must not produce a duplicate event.
+                windowImpl.Object.Closed!();
+
+                Assert.False(target.IsActive);
+                Assert.Equal(0, deactivated);
+            }
+        }
+
         [Fact]
         public void IsVisible_Should_Be_False_Atfer_Impl_Signals_Close()
         {

From 847de736c3b0c6e245f033060d2e82f4caa2ecba Mon Sep 17 00:00:00 2001
From: Betta_Fish <96322503+zxbmmmmmmmmm@users.noreply.github.com>
Date: Sat, 25 Jul 2026 23:47:23 +0800
Subject: [PATCH 121/196] feat: Composition brush (#20181)

* feat: Composition brush

* feat: Composition gradient brush

* feat: Add factory methods

* feat: Add composition brush samples

* fix: Cannot play animations on CompositionGradientStop separately

* chore: Move file location

* refactor: Remove code duplication in ServerRenderResource

* update api

* update sample

* fix

* support RelativeUnit

* update sample

* add ffi

* fix: this.Target cannot be tracked

* fix: register composition properties on dynamicRegistry properly

* fix: notify other expresssion animations in animation update

* fix: Vector can't be animated

* fix

* fix ExpressionVariant

* Adjust titles to avoid cropping in CompositionPage

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../Pages/CompositionPage.axaml               | 263 ++++++++++++++----
 .../Pages/CompositionPage.axaml.cs            | 179 +++++++++++-
 .../Composition/Animations/Interpolators.cs   |  27 ++
 .../Composition/Brushes/CompositionBrush.cs   |  69 +++++
 .../Brushes/ServerCompositionBrush.cs         |  84 ++++++
 .../Composition/CompositionGradientStop.cs    |  24 ++
 .../Composition/Compositor.Factories.cs       |  19 +-
 .../Drawing/RenderDataDrawingContext.cs       |   3 +-
 .../Drawing/ServerResourceHelperExtensions.cs |   2 +
 .../Expressions/BuiltInExpressionFfi.cs       |   7 +
 .../Expressions/DelegateExpressionFfi.cs      |  10 +-
 .../Expressions/ExpressionParser.cs           |   7 +-
 .../Expressions/ExpressionVariant.cs          | 177 +++++++++++-
 .../Server/ServerCompositionGradientStop.cs   |   8 +
 .../Server/ServerRenderResource.cs            | 147 +++++++---
 src/Avalonia.Base/composition-schema.xml      |  37 +++
 .../CompositionGenerator/Generator.cs         |   2 +
 17 files changed, 945 insertions(+), 120 deletions(-)
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Brushes/CompositionBrush.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Brushes/ServerCompositionBrush.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/CompositionGradientStop.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionGradientStop.cs

diff --git a/samples/ControlCatalog/Pages/CompositionPage.axaml b/samples/ControlCatalog/Pages/CompositionPage.axaml
index a3e9b047a8..0e4fcf2ab6 100644
--- a/samples/ControlCatalog/Pages/CompositionPage.axaml
+++ b/samples/ControlCatalog/Pages/CompositionPage.axaml
@@ -1,61 +1,204 @@
-<TabbedPage xmlns="https://github.com/avaloniaui"
-            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-            xmlns:pages="using:ControlCatalog.Pages"
-            Header="Composition"
-            x:Class="ControlCatalog.Pages.CompositionPage">
-  <ContentPage Theme="{StaticResource ScrollPage}" Header="Implicit animations">
-    <StackPanel>
-      <Grid ColumnDefinitions="*,10,40" Margin="0 0 40 0">
-        <ItemsControl x:Name="Items">
-          <ItemsControl.ItemsPanel>
-            <ItemsPanelTemplate>
-              <WrapPanel/>
-            </ItemsPanelTemplate>
-          </ItemsControl.ItemsPanel>
-          <ItemsControl.DataTemplates>
-            <DataTemplate DataType="pages:CompositionPageColorItem">
-              <Border
-              pages:CompositionPage.EnableAnimations="True"
-              Padding="10" BorderBrush="Gray" BorderThickness="2"
-              Background="{Binding ColorBrush}" Width="100" Height="100" Margin="10">
-                <TextBlock Text="{Binding ColorHexValue}"/>
-              </Border>
-            </DataTemplate>
-          </ItemsControl.DataTemplates>
-        </ItemsControl>
-        <GridSplitter Margin="2" BorderThickness="1" BorderBrush="Gray"
-                      Background="#e0e0e0" Grid.Column="1"
-                      ResizeDirection="Columns" ResizeBehavior="PreviousAndNext"
-                      />
-        <Border Grid.Column="2">
-          <LayoutTransformControl HorizontalAlignment="Center" MinWidth="30">
-            <LayoutTransformControl.LayoutTransform>
-              <RotateTransform Angle="90"/>
-            </LayoutTransformControl.LayoutTransform>
-            <TextBlock>Resize me</TextBlock>
-          </LayoutTransformControl>
-        </Border>
-      </Grid>
-    </StackPanel>
-  </ContentPage>
-  <ContentPage Theme="{StaticResource ScrollPage}" Header="Animation">
-    <DockPanel>
-      <Button DockPanel.Dock="Top" Margin="10" Click="ButtonThreadSleep">Thread.Sleep(10000);</Button>
-      <Control x:Name="SolidVisualHost" />
-    </DockPanel>
-  </ContentPage>
-  <ContentPage Theme="{StaticResource ScrollPage}" Header="Custom">
-    <DockPanel>
-      <StackPanel DockPanel.Dock="Top" Orientation="Horizontal">
-        <Button Margin="10" Click="ButtonThreadSleep">Thread.Sleep(10000);</Button>
-        <Button Margin="10" Click="ButtonStartCustomVisual">Start</Button>
-        <Button Margin="10" Click="ButtonStopCustomVisual">Stop</Button>
-        <CheckBox Margin="10"
-                  x:Name="PreciseDirtyRectsCheckboxCustomVisual"
-                  IsCheckedChanged="PreciseDirtyRectsCheckboxCustomVisualChanged"
-                  >Precise dirty rects</CheckBox>
-      </StackPanel>
-      <Control x:Name="CustomVisualHost" />
-    </DockPanel>
-  </ContentPage>
+<TabbedPage
+    x:Class="ControlCatalog.Pages.CompositionPage"
+    xmlns="https://github.com/avaloniaui"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:pages="using:ControlCatalog.Pages">
+    <ContentPage Header="Implicit">
+        <StackPanel>
+            <Grid Margin="0,0,40,0" ColumnDefinitions="*,10,40">
+                <ItemsControl x:Name="Items">
+                    <ItemsControl.ItemsPanel>
+                        <ItemsPanelTemplate>
+                            <WrapPanel />
+                        </ItemsPanelTemplate>
+                    </ItemsControl.ItemsPanel>
+                    <ItemsControl.DataTemplates>
+                        <DataTemplate DataType="pages:CompositionPageColorItem">
+                            <Border
+                                Width="100"
+                                Height="100"
+                                Margin="10"
+                                Padding="10"
+                                pages:CompositionPage.EnableAnimations="True"
+                                Background="{Binding ColorBrush}"
+                                BorderBrush="Gray"
+                                BorderThickness="2">
+                                <TextBlock Text="{Binding ColorHexValue}" />
+                            </Border>
+                        </DataTemplate>
+                    </ItemsControl.DataTemplates>
+                </ItemsControl>
+                <GridSplitter
+                    Grid.Column="1"
+                    Margin="2"
+                    Background="#e0e0e0"
+                    BorderBrush="Gray"
+                    BorderThickness="1"
+                    ResizeBehavior="PreviousAndNext"
+                    ResizeDirection="Columns" />
+                <Border Grid.Column="2">
+                    <LayoutTransformControl MinWidth="30" HorizontalAlignment="Center">
+                        <LayoutTransformControl.LayoutTransform>
+                            <RotateTransform Angle="90" />
+                        </LayoutTransformControl.LayoutTransform>
+                        <TextBlock>Resize me</TextBlock>
+                    </LayoutTransformControl>
+                </Border>
+            </Grid>
+        </StackPanel>
+    </ContentPage>
+    <ContentPage Header="Animations">
+        <DockPanel>
+            <Button
+                Margin="10"
+                Click="ButtonThreadSleep"
+                DockPanel.Dock="Top">
+                Thread.Sleep(10000);
+            </Button>
+            <Control x:Name="SolidVisualHost" />
+        </DockPanel>
+    </ContentPage>
+    <ContentPage Header="Custom">
+        <DockPanel>
+            <StackPanel DockPanel.Dock="Top" Orientation="Horizontal">
+                <Button Margin="10" Click="ButtonThreadSleep">Thread.Sleep(5000);</Button>
+                <Button Margin="10" Click="ButtonStartCustomVisual">Start</Button>
+                <Button Margin="10" Click="ButtonStopCustomVisual">Stop</Button>
+                <CheckBox
+                    x:Name="PreciseDirtyRectsCheckboxCustomVisual"
+                    Margin="10"
+                    IsCheckedChanged="PreciseDirtyRectsCheckboxCustomVisualChanged">
+                    Precise dirty rects
+                </CheckBox>
+            </StackPanel>
+            <Control x:Name="CustomVisualHost" />
+        </DockPanel>
+    </ContentPage>
+    <ContentPage Header="Brushes">
+        <ScrollViewer>
+            <StackPanel>
+                <StackPanel.Styles>
+                    <Style Selector="Button">
+                        <Setter Property="BorderThickness" Value="2" />
+                    </Style>
+                </StackPanel.Styles>
+                <Button Margin="10" Click="ButtonThreadSleep">
+                    Thread.Sleep(5000);
+                </Button>
+                <UniformGrid
+                    Margin="12"
+                    ColumnSpacing="12"
+                    RowSpacing="12">
+
+                    <!--  Solid Color  -->
+                    <StackPanel Spacing="6">
+                        <TextBlock
+                            FontWeight="Bold"
+                            Foreground="{Binding #SolidBrushHost.Background, Mode=OneWay}"
+                            Text="SolidColorBrush" />
+                        <Border
+                            x:Name="SolidBrushHost"
+                            Height="120"
+                            Background="Gray"
+                            BorderBrush="DarkGray"
+                            BorderThickness="1"
+                            CornerRadius="8">
+                            <TextBlock
+                                HorizontalAlignment="Center"
+                                VerticalAlignment="Center"
+                                FontSize="18"
+                                Text="Solid" />
+                        </Border>
+                        <StackPanel Orientation="Horizontal" Spacing="8">
+                            <Button
+                                BorderBrush="{Binding #SolidBrushHost.Background, Mode=OneWay}"
+                                Click="SolidBrushCreateAnimate_Click"
+                                Content="Create" />
+                        </StackPanel>
+                    </StackPanel>
+
+                    <!--  Linear Gradient  -->
+                    <StackPanel Spacing="6">
+                        <TextBlock
+                            FontWeight="Bold"
+                            Foreground="{Binding #LinearBrushHost.Background, Mode=OneWay}"
+                            Text="LinearGradientBrush" />
+                        <Border
+                            x:Name="LinearBrushHost"
+                            Height="120"
+                            Background="Gray"
+                            BorderBrush="DarkGray"
+                            BorderThickness="1"
+                            CornerRadius="8">
+                            <TextBlock
+                                HorizontalAlignment="Center"
+                                VerticalAlignment="Center"
+                                FontSize="18"
+                                Text="Linear" />
+                        </Border>
+                        <StackPanel Orientation="Horizontal" Spacing="8">
+                            <Button
+                                BorderBrush="{Binding #LinearBrushHost.Background, Mode=OneWay}"
+                                Click="LinearBrushCreateAnimate_Click"
+                                Content="Create" />
+                        </StackPanel>
+                    </StackPanel>
+
+                    <!--  Radial Gradient  -->
+                    <StackPanel Spacing="6">
+                        <TextBlock
+                            FontWeight="Bold"
+                            Foreground="{Binding #RadialBrushHost.Background, Mode=OneWay}"
+                            Text="RadialGradientBrush" />
+                        <Border
+                            x:Name="RadialBrushHost"
+                            Height="120"
+                            Background="Gray"
+                            BorderBrush="DarkGray"
+                            BorderThickness="1"
+                            CornerRadius="8">
+                            <TextBlock
+                                HorizontalAlignment="Center"
+                                VerticalAlignment="Center"
+                                FontSize="18"
+                                Text="Radial" />
+                        </Border>
+                        <StackPanel Orientation="Horizontal" Spacing="8">
+                            <Button
+                                BorderBrush="{Binding #RadialBrushHost.Background, Mode=OneWay}"
+                                Click="RadialBrushCreateAnimate_Click"
+                                Content="Create" />
+                        </StackPanel>
+                    </StackPanel>
+
+                    <!--  Conic Gradient  -->
+                    <StackPanel Spacing="6">
+                        <TextBlock
+                            FontWeight="Bold"
+                            Foreground="{Binding #ConicBrushHost.Background, Mode=OneWay}"
+                            Text="ConicGradientBrush" />
+                        <Border
+                            x:Name="ConicBrushHost"
+                            Height="120"
+                            Background="Gray"
+                            BorderBrush="DarkGray"
+                            BorderThickness="1"
+                            CornerRadius="8">
+                            <TextBlock
+                                HorizontalAlignment="Center"
+                                VerticalAlignment="Center"
+                                FontSize="18"
+                                Text="Conic" />
+                        </Border>
+                        <StackPanel Orientation="Horizontal" Spacing="8">
+                            <Button
+                                BorderBrush="{Binding #ConicBrushHost.Background, Mode=OneWay}"
+                                Click="ConicBrushCreateAnimate_Click"
+                                Content="Create" />
+                        </StackPanel>
+                    </StackPanel>
+                </UniformGrid>
+            </StackPanel>
+        </ScrollViewer>
+    </ContentPage>
 </TabbedPage>
diff --git a/samples/ControlCatalog/Pages/CompositionPage.axaml.cs b/samples/ControlCatalog/Pages/CompositionPage.axaml.cs
index 8f5d75f4ce..6bcbdf2c7e 100644
--- a/samples/ControlCatalog/Pages/CompositionPage.axaml.cs
+++ b/samples/ControlCatalog/Pages/CompositionPage.axaml.cs
@@ -315,7 +315,7 @@ public partial class CompositionPage : TabbedPage
     
     private void ButtonThreadSleep(object? sender, RoutedEventArgs e)
     {
-        Thread.Sleep(10000);
+        Thread.Sleep(5000);
     }
 
     private void ButtonStartCustomVisual(object? sender, RoutedEventArgs e)
@@ -334,6 +334,183 @@ public partial class CompositionPage : TabbedPage
             ? CustomVisualHandler.UsePreciseDirtyRects
             : CustomVisualHandler.UseNonPreciseDirtyRects);
     }
+
+    private void SolidBrushCreateAnimate_Click(object? sender, RoutedEventArgs e)
+    {
+        var visual = ElementComposition.GetElementVisual(SolidBrushHost);
+        if (visual == null)
+            return;
+
+        var compositor = visual.Compositor;
+
+        var brush = SolidBrushHost.Background as CompositionSolidColorBrush
+                    ?? compositor.CreateSolidColorBrush();
+
+        brush.Color = Color.FromRgb(168, 213, 85);
+        SolidBrushHost.Background = brush;
+
+        var animation = compositor.CreateColorKeyFrameAnimation();
+        animation.InsertKeyFrame(0f, Color.FromRgb(168, 213, 85));
+        animation.InsertKeyFrame(0.25f, Color.FromRgb(31, 167, 168));
+        animation.InsertKeyFrame(0.75f, Color.FromRgb(44, 121, 251));
+        animation.InsertKeyFrame(1f, Color.FromRgb(168, 213, 85));
+        animation.Duration = TimeSpan.FromSeconds(4);
+        animation.IterationBehavior = AnimationIterationBehavior.Forever;
+        brush.StartAnimation("Color", animation);
+    }
+
+    private void LinearBrushCreateAnimate_Click(object? sender, RoutedEventArgs e)
+    {
+        var visual = ElementComposition.GetElementVisual(LinearBrushHost);
+        if (visual == null)
+            return;
+
+        var compositor = visual.Compositor;
+
+        var brush = LinearBrushHost.Background as CompositionLinearGradientBrush
+                    ?? compositor.CreateLinearGradientBrush();
+
+        brush.GradientStops.Clear();
+        brush.GradientStops.Add(compositor.CreateGradientStop(0f, Color.FromRgb(168, 213, 85)));
+        brush.GradientStops.Add(compositor.CreateGradientStop(0.33f, Color.FromRgb(31, 167, 168)));
+        brush.GradientStops.Add(compositor.CreateGradientStop(0.66f, Color.FromRgb(44, 121, 251)));
+        brush.GradientStops.Add(compositor.CreateGradientStop(1f, Color.FromRgb(168, 213, 85)));
+        brush.StartPoint = new RelativePoint(0, 0, RelativeUnit.Relative);
+        brush.EndPoint = new RelativePoint(1, 0, RelativeUnit.Relative);
+
+        LinearBrushHost.Background = brush;
+
+        var start = compositor.CreateRelativePointKeyFrameAnimation();
+        start.Duration = TimeSpan.FromSeconds(4);
+        start.IterationBehavior = AnimationIterationBehavior.Forever;
+        start.InsertKeyFrame(0f, new RelativePoint(-1, 0, RelativeUnit.Relative));
+        start.InsertKeyFrame(0.5f, new RelativePoint(1, 0, RelativeUnit.Relative));
+        start.InsertKeyFrame(1f, new RelativePoint(-1, 0, RelativeUnit.Relative));
+
+        var end = compositor.CreateRelativePointKeyFrameAnimation();
+        end.Duration = start.Duration;
+        end.IterationBehavior = AnimationIterationBehavior.Forever;
+        end.InsertKeyFrame(0f, new RelativePoint(0, 0, RelativeUnit.Relative));
+        end.InsertKeyFrame(0.5f, new RelativePoint(2, 0, RelativeUnit.Relative));
+        end.InsertKeyFrame(1f, new RelativePoint(0, 0, RelativeUnit.Relative));
+
+        brush.StartAnimation("StartPoint", start);
+        brush.StartAnimation("EndPoint", end);
+
+        AnimateGradientStops(brush);
+    }
+
+    private void RadialBrushCreateAnimate_Click(object? sender, RoutedEventArgs e)
+    {
+        var visual = ElementComposition.GetElementVisual(RadialBrushHost);
+        if (visual == null)
+            return;
+
+        var compositor = visual.Compositor;
+
+        var brush = RadialBrushHost.Background as CompositionRadialGradientBrush
+                    ?? compositor.CreateRadialGradientBrush();
+
+        brush.GradientStops.Clear();
+        brush.GradientStops.Add(compositor.CreateGradientStop(0f, Colors.Yellow));
+        brush.GradientStops.Add(compositor.CreateGradientStop(0.6f, Colors.Orange));
+        brush.GradientStops.Add(compositor.CreateGradientStop(1f, Colors.Red));
+        brush.Center = RelativePoint.Center;
+        brush.GradientOrigin = RelativePoint.Center;
+
+        RadialBrushHost.Background = brush;
+
+        var centerAnim = compositor.CreateRelativePointKeyFrameAnimation();
+        centerAnim.Duration = TimeSpan.FromSeconds(3);
+        centerAnim.IterationBehavior = AnimationIterationBehavior.Forever;
+        centerAnim.InsertKeyFrame(0f, new RelativePoint(0.2, 0.5, RelativeUnit.Relative));
+        centerAnim.InsertKeyFrame(0.5f, new RelativePoint(0.8, 0.5, RelativeUnit.Relative));
+        centerAnim.InsertKeyFrame(1f, new RelativePoint(0.2, 0.5, RelativeUnit.Relative));
+
+        brush.StartAnimation("Center", centerAnim);
+        var radiusXExpression = compositor.CreateExpressionAnimation(
+            "RelativeScalar(Clamp(0.2 + Abs(this.Target.Center.X - 0.5) * 0.9, 0.2, 0.85), RelativeUnit.Relative)");
+        var radiusYExpression = compositor.CreateExpressionAnimation(
+            "RelativeScalar(Clamp(0.2 + Abs(this.Target.Center.Y - 0.5) * 0.9, 0.2, 0.85), RelativeUnit.Relative)");
+        brush.StartAnimation("RadiusX", radiusXExpression);
+        brush.StartAnimation("RadiusY", radiusYExpression);
+
+        AnimateGradientStops(brush);
+    }
+
+    private void ConicBrushCreateAnimate_Click(object? sender, RoutedEventArgs e)
+    {
+        var visual = ElementComposition.GetElementVisual(ConicBrushHost);
+        if (visual == null)
+            return;
+
+        var compositor = visual.Compositor;
+
+        var brush = ConicBrushHost.Background as CompositionConicGradientBrush
+                    ?? compositor.CreateConicGradientBrush();
+
+        brush.GradientStops.Clear();
+        brush.GradientStops.Add(compositor.CreateGradientStop(0f, Colors.Cyan));
+        brush.GradientStops.Add(compositor.CreateGradientStop(0.25f, Colors.Magenta));
+        brush.GradientStops.Add(compositor.CreateGradientStop(0.5f, Colors.Yellow));
+        brush.GradientStops.Add(compositor.CreateGradientStop(0.75f, Colors.Lime));
+        brush.GradientStops.Add(compositor.CreateGradientStop(1f, Colors.Cyan));
+
+        brush.Center = RelativePoint.Center;
+
+        ConicBrushHost.Background = brush;
+
+        var angleAnim = compositor.CreateScalarKeyFrameAnimation();
+        angleAnim.Duration = TimeSpan.FromSeconds(5);
+        angleAnim.IterationBehavior = AnimationIterationBehavior.Forever;
+        angleAnim.InsertKeyFrame(0f, 0f);
+        angleAnim.InsertKeyFrame(1f, 360f);
+        brush.StartAnimation("Angle", angleAnim);
+        var centerExpression = compositor.CreateExpressionAnimation(
+            "RelativePoint(Abs(Cos(ToRadians(this.Target.Angle))), Abs(Sin(ToRadians(this.Target.Angle))), RelativeUnit.Relative)");
+        brush.StartAnimation("Center", centerExpression);
+
+        AnimateGradientStops(brush, false);
+    }
+
+    private void AnimateGradientStops(CompositionGradientBrush? brush, bool animateOffsets = true)
+    {
+        if (brush == null)
+            return;
+        var compositor = brush.Compositor;
+        foreach (var stop in brush.GradientStops)
+        {
+            if (stop is not CompositionGradientStop gs)
+                continue;
+
+            var colorAnim = compositor.CreateColorKeyFrameAnimation();
+            colorAnim.Duration = TimeSpan.FromSeconds(4);
+            colorAnim.IterationBehavior = AnimationIterationBehavior.Forever;
+            colorAnim.InsertKeyFrame(0f, gs.Color);
+            colorAnim.InsertKeyFrame(0.5f, ShiftColor(gs.Color));
+            colorAnim.InsertKeyFrame(1f, gs.Color);
+            gs.StartAnimation("Color", colorAnim);
+
+            if (!animateOffsets)
+                continue;
+            var offsetAnim = compositor.CreateScalarKeyFrameAnimation();
+            offsetAnim.Duration = TimeSpan.FromSeconds(4);
+            offsetAnim.IterationBehavior = AnimationIterationBehavior.Forever;
+            var o = (float)gs.Offset;
+            var o2 = Math.Clamp(gs.Offset + 0.1, 0, 1);
+            offsetAnim.InsertKeyFrame(0f, o);
+            offsetAnim.InsertKeyFrame(0.5f, (float)o2);
+            offsetAnim.InsertKeyFrame(1f, o);
+            gs.StartAnimation("Offset", offsetAnim);
+        }
+    }
+    private static Color ShiftColor(Color c)
+    {
+        var r = (byte)Math.Min(255, (int)(c.R * 1.15) + 30);
+        var g = (byte)Math.Max(0, (int)(c.G * 0.75) - 10);
+        var b = (byte)Math.Min(255, (int)(c.B * 1.2) + 20);
+        return Color.FromArgb(c.A, r, g, b);
+    }
 }
 
 public class CompositionPageColorItem
diff --git a/src/Avalonia.Base/Rendering/Composition/Animations/Interpolators.cs b/src/Avalonia.Base/Rendering/Composition/Animations/Interpolators.cs
index 33caef5e68..f801bd1c66 100644
--- a/src/Avalonia.Base/Rendering/Composition/Animations/Interpolators.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Animations/Interpolators.cs
@@ -98,4 +98,31 @@ namespace Avalonia.Rendering.Composition.Animations
         
         public static BooleanInterpolator Instance { get; } = new BooleanInterpolator();
     }
+
+    class RelativePointInterpolator : IInterpolator<Avalonia.RelativePoint>
+    {
+        public Avalonia.RelativePoint Interpolate(Avalonia.RelativePoint @from, Avalonia.RelativePoint to, float progress)
+        {
+            if (@from.Unit != to.Unit)
+                return progress >= 0.5f ? to : @from;
+
+            var x = DoubleInterpolator.Instance.Interpolate(@from.Point.X, to.Point.X, progress);
+            var y = DoubleInterpolator.Instance.Interpolate(@from.Point.Y, to.Point.Y, progress);
+            return new Avalonia.RelativePoint(x, y, @from.Unit);
+        }
+
+        public static RelativePointInterpolator Instance { get; } = new();
+    }
+
+    class RelativeScalarInterpolator : IInterpolator<Avalonia.RelativeScalar>
+    {
+        public Avalonia.RelativeScalar Interpolate(Avalonia.RelativeScalar @from, Avalonia.RelativeScalar to, float progress)
+        {
+            if (@from.Unit != to.Unit)
+                return progress >= 0.5f ? to : @from;
+            return new RelativeScalar(@from.Scalar + (to.Scalar - @from.Scalar) * progress, from.Unit);
+        }
+
+        public static RelativeScalarInterpolator Instance { get; } = new();
+    }
 }
diff --git a/src/Avalonia.Base/Rendering/Composition/Brushes/CompositionBrush.cs b/src/Avalonia.Base/Rendering/Composition/Brushes/CompositionBrush.cs
new file mode 100644
index 0000000000..bb356bab81
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Brushes/CompositionBrush.cs
@@ -0,0 +1,69 @@
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Rendering.Composition;
+using Avalonia.Rendering.Composition.Server;
+using Avalonia.Rendering.Composition.Transport;
+using Avalonia.Styling;
+
+namespace Avalonia.Rendering.Composition;
+
+partial class CompositionBrush : IBrush
+{
+    partial void InitializeDefaultsExtra()
+    {
+        Server.Activate();
+    }
+}
+
+partial class CompositionSolidColorBrush : ISolidColorBrush
+{
+    internal CompositionSolidColorBrush(Compositor compositor, ServerCompositionSolidColorBrush server, Color color) : base(compositor, server)
+    {
+        Server = server;
+        Color = color;
+        InitializeDefaults();
+    }
+}
+
+partial class CompositionLinearGradientBrush : ILinearGradientBrush
+{
+}
+
+partial class CompositionRadialGradientBrush : IRadialGradientBrush
+{
+    public double Radius => RadiusX.Scalar;
+}
+
+partial class CompositionConicGradientBrush : IConicGradientBrush
+{
+
+}
+
+
+public abstract partial class CompositionGradientBrush : CompositionBrush, IGradientBrush
+{
+    internal new ServerCompositionGradientBrush Server { get; }
+    public List<IGradientStop> GradientStops { get; set; } = [];
+    IReadOnlyList<IGradientStop> IGradientBrush.GradientStops => GradientStops;
+    public GradientSpreadMethod SpreadMethod { get; set; }
+    partial void OnRootChanged();
+    partial void OnRootChanging();
+
+    internal CompositionGradientBrush(Compositor compositor, ServerCompositionGradientBrush server) : base(compositor, server)
+    {
+        Server = server;
+    }
+    private protected override void SerializeChangesCore(BatchStreamWriter writer)
+    {
+        base.SerializeChangesCore(writer);
+        writer.Write(SpreadMethod);
+        writer.Write(GradientStops.Count);
+        foreach (var stop in GradientStops)
+        {
+            if (stop is CompositionGradientStop comp)
+                writer.WriteObject(comp.Server);
+            else
+                writer.WriteObject(stop);
+        }
+    }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Brushes/ServerCompositionBrush.cs b/src/Avalonia.Base/Rendering/Composition/Brushes/ServerCompositionBrush.cs
new file mode 100644
index 0000000000..e537db319a
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Brushes/ServerCompositionBrush.cs
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Media.Immutable;
+using Avalonia.Rendering.Composition.Transport;
+
+namespace Avalonia.Rendering.Composition.Server;
+
+internal partial class ServerCompositionBrush : IBrush
+{
+    ITransform? IBrush.Transform => Transform;
+}
+
+internal partial class ServerCompositionGradientBrush : ServerCompositionBrush, IGradientBrush
+{
+    internal ServerCompositionGradientBrush(ServerCompositor compositor) : base(compositor)
+    {
+
+    }
+
+    internal static CompositionProperty<List<IGradientStop>> s_IdOfGradientStopsProperty = CompositionProperty.Register<ServerCompositionGradientBrush, List<IGradientStop>>("GradientStops", obj => ((ServerCompositionGradientBrush)obj)._gradientStops, (obj, v) => ((ServerCompositionGradientBrush)obj)._gradientStops = v, null);
+    private List<IGradientStop> _gradientStops = new();
+    IReadOnlyList<IGradientStop> IGradientBrush.GradientStops => GradientStops;
+    public List<IGradientStop> GradientStops
+    {
+        get
+        {
+            return _gradientStops;
+        }
+
+        set
+        {
+            var changed = false;
+            if (_gradientStops != value)
+            {
+                OnGradientStopsChanging();
+                changed = true;
+            }
+
+            SetValue(s_IdOfGradientStopsProperty, ref _gradientStops, value);
+            if (changed)
+                OnGradientStopsChanged();
+        }
+    }
+
+    partial void OnGradientStopsChanged();
+    partial void OnGradientStopsChanging();
+
+    public GradientSpreadMethod SpreadMethod { get; private set; }
+
+    protected override void DeserializeChangesCore(BatchStreamReader reader, TimeSpan committedAt)
+    {
+        base.DeserializeChangesCore(reader, committedAt);
+        SpreadMethod = reader.Read<GradientSpreadMethod>();
+        var stops = new List<IGradientStop>();
+        var count = reader.Read<int>();
+        for (var c = 0; c < count; c++)
+        {
+            var read = reader.ReadObject<IGradientStop>();
+            stops.Add(read);
+        }
+        GradientStops = stops;
+    }
+}
+
+partial class ServerCompositionConicGradientBrush : IConicGradientBrush
+{
+
+}
+
+partial class ServerCompositionLinearGradientBrush : ILinearGradientBrush
+{
+
+}
+
+partial class ServerCompositionRadialGradientBrush : IRadialGradientBrush
+{
+    public double Radius => RadiusX.Scalar;
+}
+
+partial class ServerCompositionSolidColorBrush : ISolidColorBrush
+{
+
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/CompositionGradientStop.cs b/src/Avalonia.Base/Rendering/Composition/CompositionGradientStop.cs
new file mode 100644
index 0000000000..cc14b6d176
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/CompositionGradientStop.cs
@@ -0,0 +1,24 @@
+using Avalonia.Media;
+using Avalonia.Rendering.Composition.Server;
+using Avalonia.Utilities;
+
+namespace Avalonia.Rendering.Composition;
+
+public partial class CompositionGradientStop : IGradientStop
+{
+    internal CompositionGradientStop(Compositor compositor, ServerCompositionGradientStop server, double offset, Color color) : base(compositor, server)
+    {
+        Server = server;
+        if (MathUtilities.IsZero(offset))
+        {
+            offset = 0;
+        }
+        Offset = (offset < 0) ? 0 : (offset > 1) ? 1 : offset;
+        Color = color;
+        InitializeDefaults();
+    }
+    partial void InitializeDefaultsExtra()
+    {
+        Server.Activate();
+    }
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Compositor.Factories.cs b/src/Avalonia.Base/Rendering/Composition/Compositor.Factories.cs
index b1ff53e5c8..917fa8b842 100644
--- a/src/Avalonia.Base/Rendering/Composition/Compositor.Factories.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Compositor.Factories.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Avalonia.Media;
 using Avalonia.Platform;
 using Avalonia.Platform.Surfaces;
 using Avalonia.Rendering.Composition.Animations;
@@ -18,9 +19,9 @@ public partial class Compositor
     {
         return new CompositionTarget(this, new ServerCompositionTarget(_server, surfaces));
     }
-    
+
     public CompositionContainerVisual CreateContainerVisual() => new(this, new ServerCompositionContainerVisual(_server));
-        
+
     public ExpressionAnimation CreateExpressionAnimation() => new ExpressionAnimation(this);
 
     public ExpressionAnimation CreateExpressionAnimation(string expression) => new ExpressionAnimation(this)
@@ -40,4 +41,18 @@ public partial class Compositor
     public CompositionSurfaceVisual CreateSurfaceVisual() => new(this, new ServerCompositionSurfaceVisual(_server));
 
     public CompositionDrawingSurface CreateDrawingSurface() => new(this);
+
+    public CompositionSolidColorBrush CreateSolidColorBrush() => new(this, new ServerCompositionSolidColorBrush(Server));
+
+    public CompositionSolidColorBrush CreateSolidColorBrush(Color color) => new(this, new ServerCompositionSolidColorBrush(Server), color);
+
+    public CompositionLinearGradientBrush CreateLinearGradientBrush() => new(this, new ServerCompositionLinearGradientBrush(Server));
+
+    public CompositionConicGradientBrush CreateConicGradientBrush() => new(this, new ServerCompositionConicGradientBrush(Server));
+
+    public CompositionRadialGradientBrush CreateRadialGradientBrush() => new(this, new ServerCompositionRadialGradientBrush(Server));
+
+    public CompositionGradientStop CreateGradientStop(double offset, Color color) => new(this, new ServerCompositionGradientStop(Server), offset, color);
+
+    public CompositionGradientStop CreateGradientStop() => new(this, new ServerCompositionGradientStop(Server));
 }
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs
index abe210e3c5..cc4799b439 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataDrawingContext.cs
@@ -45,7 +45,8 @@ internal class RenderDataDrawingContext : DrawingContext
         if (resource == null
             || resource is IImmutableBrush
             || resource is ImmutablePen
-            || resource is ImmutableTransform)
+            || resource is ImmutableTransform
+            || resource is CompositionBrush)
             return;
 
         if (resource is ICompositionRenderResource renderResource)
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs
index 6fb646cd23..bde92bcb94 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs
@@ -19,6 +19,8 @@ static class ServerResourceHelperExtensions
             return immutable;
         if (brush is ICompositionRenderResource<IBrush> resource)
             return resource.GetForCompositor(compositor);
+        if (brush is CompositionBrush compositionBrush)
+            return compositionBrush.Server;
         ThrowNotCompatible(brush);
         return null;
     }
diff --git a/src/Avalonia.Base/Rendering/Composition/Expressions/BuiltInExpressionFfi.cs b/src/Avalonia.Base/Rendering/Composition/Expressions/BuiltInExpressionFfi.cs
index 4164f96c30..4f6ac03971 100644
--- a/src/Avalonia.Base/Rendering/Composition/Expressions/BuiltInExpressionFfi.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Expressions/BuiltInExpressionFfi.cs
@@ -271,6 +271,13 @@ namespace Avalonia.Rendering.Composition.Expressions
                 {"Transform", (Vector2 a, Matrix3x2 b) => Vector2.Transform(a, b)},
                 {"Transform", (Vector3 a, Matrix4x4 b) => Vector3.Transform(a, b)},
 
+                {"RelativeUnit.Absolute", () => RelativeUnit.Absolute},
+                {"RelativeUnit.Relative", () => RelativeUnit.Relative},
+                {"RelativePoint", (float x, float y, RelativeUnit unit) => new RelativePoint(x, y, unit)},
+                {"RelativePoint", (double x, double y, RelativeUnit unit) => new RelativePoint(x, y, unit)},
+                {"RelativeScalar", (float value, RelativeUnit unit) => new RelativeScalar(value, unit)},
+                {"RelativeScalar", (double value, RelativeUnit unit) => new RelativeScalar(value, unit)},
+
                 {"Vector2", (float a, float b) => new Vector(a, b)},
                 {"Vector2", (double a, double b) => new Vector(a, b)},
                 {"Vector3", (float a, float b, float c) => new Vector3D(a, b, c)},
diff --git a/src/Avalonia.Base/Rendering/Composition/Expressions/DelegateExpressionFfi.cs b/src/Avalonia.Base/Rendering/Composition/Expressions/DelegateExpressionFfi.cs
index 042e7429c6..7d4bf7b8f2 100644
--- a/src/Avalonia.Base/Rendering/Composition/Expressions/DelegateExpressionFfi.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Expressions/DelegateExpressionFfi.cs
@@ -120,9 +120,17 @@ namespace Avalonia.Rendering.Composition.Expressions
             [typeof(Matrix3x2)] = VariantType.Matrix3x2,
             [typeof(Matrix4x4)] = VariantType.Matrix4x4,
             [typeof(Quaternion)] = VariantType.Quaternion,
-            [typeof(Color)] = VariantType.Color
+            [typeof(Color)] = VariantType.Color,
+            [typeof(RelativePoint)] = VariantType.RelativePoint,
+            [typeof(RelativeScalar)] = VariantType.RelativeScalar,
+            [typeof(RelativeUnit)] = VariantType.RelativeUnit
         };
 
+        public void Add(string name, Func<ExpressionVariant> cb)
+        {
+            Add(name, _ => cb());
+        }
+
         public void Add<T1>(string name, Func<T1, ExpressionVariant> cb) where T1 : struct
         {
             Add(name, args => cb(args[0].CastOrDefault<T1>()), typeof(T1));
diff --git a/src/Avalonia.Base/Rendering/Composition/Expressions/ExpressionParser.cs b/src/Avalonia.Base/Rendering/Composition/Expressions/ExpressionParser.cs
index 45e4e164c1..cb52578ee6 100644
--- a/src/Avalonia.Base/Rendering/Composition/Expressions/ExpressionParser.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Expressions/ExpressionParser.cs
@@ -39,7 +39,10 @@ namespace Avalonia.Rendering.Composition.Expressions
                 expr = new KeywordExpression(ExpressionKeyword.False);
             else if (parser.TryParseKeywordLowerCase(ExpressionKeywords.Target))
                 expr = new KeywordExpression(ExpressionKeyword.Target);
-
+            else if (parser.TryParseKeywordLowerCase("relativeunit.relative"))
+                expr = new FunctionCallExpression("RelativeUnit.Relative", []);
+            else if (parser.TryParseKeywordLowerCase("relativeunit.absolute"))
+                expr = new FunctionCallExpression("RelativeUnit.Absolute", []);
             if (expr != null)
                 return true;
 
@@ -246,7 +249,7 @@ namespace Avalonia.Rendering.Composition.Expressions
                 else if (parser.TryParseCall(out var functionName))
                 {
                     var parameterList = new List<Expression>();
-                    while (true)
+                    while (!parser.TryConsume(')'))
                     {
                         parameterList.Add(ParseTillTerminator(ref parser, ",)", false, true, out var closingToken));
                         if (closingToken == ')')
diff --git a/src/Avalonia.Base/Rendering/Composition/Expressions/ExpressionVariant.cs b/src/Avalonia.Base/Rendering/Composition/Expressions/ExpressionVariant.cs
index bbaab572d5..e43775c317 100644
--- a/src/Avalonia.Base/Rendering/Composition/Expressions/ExpressionVariant.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Expressions/ExpressionVariant.cs
@@ -20,7 +20,10 @@ namespace Avalonia.Rendering.Composition.Expressions
         Matrix3x2,
         Matrix4x4,
         Quaternion,
-        Color
+        Color,
+        RelativePoint,
+        RelativeScalar, 
+        RelativeUnit
     }
 
     /// <summary>
@@ -43,7 +46,9 @@ namespace Avalonia.Rendering.Composition.Expressions
         [FieldOffset(4)] public Matrix4x4 Matrix4x4;
         [FieldOffset(4)] public Quaternion Quaternion;
         [FieldOffset(4)] public Color Color;
-
+        [FieldOffset(4)] public RelativePoint RelativePoint;
+        [FieldOffset(4)] public RelativeScalar RelativeScalar;
+        [FieldOffset(4)] public RelativeUnit RelativeUnit;
 
         public ExpressionVariant GetProperty(string property)
         {
@@ -227,12 +232,32 @@ namespace Avalonia.Rendering.Composition.Expressions
                 return default;
             }
 
-            return default;
+            if (Type == VariantType.RelativePoint)
+            {
+                if (ReferenceEquals(property, "X"))
+                    return (float)RelativePoint.Point.X;
+                if (ReferenceEquals(property, "Y"))
+                    return (float)RelativePoint.Point.Y;
+                if (ReferenceEquals(property, "Unit"))
+                    return RelativePoint.Unit;
+                return default;
+            }
 
-            static bool IsMatch(string propertyName, string memberName) =>
-                string.Equals(propertyName, memberName, StringComparison.Ordinal);
+            if (Type == VariantType.RelativeScalar)
+            {
+                if (ReferenceEquals(property, "Scalar"))
+                    return RelativeScalar.Scalar;
+                if (ReferenceEquals(property, "Unit"))
+                    return RelativeScalar.Unit;
+                return default;
+            }
+
+            return default;
         }
 
+        static bool IsMatch(string propertyName, string memberName) =>
+            string.Equals(propertyName, memberName, StringComparison.Ordinal);
+
         public static implicit operator ExpressionVariant(bool value) =>
             new ExpressionVariant
             {
@@ -254,7 +279,7 @@ namespace Avalonia.Rendering.Composition.Expressions
                 Type = VariantType.Vector2,
                 Vector2 = value
             };
-        
+
         public static implicit operator ExpressionVariant(Vector value) =>
             new ExpressionVariant
             {
@@ -268,7 +293,7 @@ namespace Avalonia.Rendering.Composition.Expressions
                 Type = VariantType.Vector3,
                 Vector3 = value
             };
-        
+
         public static implicit operator ExpressionVariant(Vector3D value) =>
             new ExpressionVariant
             {
@@ -290,7 +315,7 @@ namespace Avalonia.Rendering.Composition.Expressions
                 Type = VariantType.Matrix3x2,
                 Matrix3x2 = value
             };
-        
+
         public static implicit operator ExpressionVariant(Matrix value) =>
             new ExpressionVariant
             {
@@ -311,7 +336,7 @@ namespace Avalonia.Rendering.Composition.Expressions
                 Type = VariantType.Quaternion,
                 Quaternion = value
             };
-        
+
         public static implicit operator ExpressionVariant(Avalonia.Media.Color value) =>
             new ExpressionVariant
             {
@@ -319,6 +344,27 @@ namespace Avalonia.Rendering.Composition.Expressions
                 Color = value
             };
 
+        public static implicit operator ExpressionVariant(RelativePoint value) =>
+            new ExpressionVariant
+            {
+                Type = VariantType.RelativePoint,
+                RelativePoint = value
+            };
+
+        public static implicit operator ExpressionVariant(RelativeScalar value) =>
+            new ExpressionVariant
+            {
+                Type = VariantType.RelativeScalar,
+                RelativeScalar = value
+            };
+
+        public static implicit operator ExpressionVariant(RelativeUnit value) =>
+            new ExpressionVariant
+            {
+                Type = VariantType.RelativeUnit,
+                RelativeUnit = value
+            };
+
         public static ExpressionVariant operator +(ExpressionVariant left, ExpressionVariant right)
         {
             if (left.Type != right.Type || left.Type == VariantType.Invalid)
@@ -351,6 +397,19 @@ namespace Avalonia.Rendering.Composition.Expressions
             if (left.Type == VariantType.Quaternion)
                 return left.Quaternion + right.Quaternion;
 
+            if (left.Type == VariantType.RelativePoint && left.RelativePoint.Unit == right.RelativePoint.Unit)
+            {
+                return new RelativePoint(
+                    left.RelativePoint.Point.X + right.RelativePoint.Point.X,
+                    left.RelativePoint.Point.Y + right.RelativePoint.Point.Y,
+                    left.RelativePoint.Unit);
+            }
+
+            if (left.Type == VariantType.RelativeScalar && left.RelativeScalar.Unit == right.RelativeScalar.Unit)
+            {
+                return new RelativeScalar(left.RelativeScalar.Scalar + right.RelativeScalar.Scalar, left.RelativeScalar.Unit);
+            }
+
             return default;
         }
 
@@ -386,6 +445,19 @@ namespace Avalonia.Rendering.Composition.Expressions
             if (left.Type == VariantType.Quaternion)
                 return left.Quaternion - right.Quaternion;
 
+            if (left.Type == VariantType.RelativePoint && left.RelativePoint.Unit == right.RelativePoint.Unit)
+            {
+                return new RelativePoint(
+                    left.RelativePoint.Point.X - right.RelativePoint.Point.X,
+                    left.RelativePoint.Point.Y - right.RelativePoint.Point.Y,
+                    left.RelativePoint.Unit);
+            }
+
+            if (left.Type == VariantType.RelativeScalar && left.RelativeScalar.Unit == right.RelativeScalar.Unit)
+            {
+                return new RelativeScalar(left.RelativeScalar.Scalar - right.RelativeScalar.Scalar, left.RelativeScalar.Unit);
+            }
+
             return default;
         }
 
@@ -422,6 +494,12 @@ namespace Avalonia.Rendering.Composition.Expressions
             if (left.Type == VariantType.Quaternion)
                 return -left.Quaternion;
 
+            if (left.Type == VariantType.RelativePoint)
+                return new RelativePoint(-left.RelativePoint.Point.X, -left.RelativePoint.Point.Y, left.RelativePoint.Unit);
+
+            if (left.Type == VariantType.RelativeScalar)
+                return new RelativeScalar(-left.RelativeScalar.Scalar, left.RelativeScalar.Unit);
+
             return default;
         }
 
@@ -484,6 +562,29 @@ namespace Avalonia.Rendering.Composition.Expressions
             if (left.Type == VariantType.Quaternion && right.Type == VariantType.Double)
                 return left.Quaternion * (float)right.Double;
 
+            if (left.Type == VariantType.RelativePoint && right.Type == VariantType.Double)
+                return new RelativePoint(left.RelativePoint.Point.X * right.Double, left.RelativePoint.Point.Y * right.Double, left.RelativePoint.Unit);
+
+            if (left.Type == VariantType.Double && right.Type == VariantType.RelativePoint)
+                return new RelativePoint(left.Double * right.RelativePoint.Point.X, left.Double * right.RelativePoint.Point.Y, right.RelativePoint.Unit);
+
+            if (left.Type == VariantType.RelativeScalar && right.Type == VariantType.Double)
+                return new RelativeScalar(left.RelativeScalar.Scalar * right.Double, left.RelativeScalar.Unit);
+
+            if (left.Type == VariantType.Double && right.Type == VariantType.RelativeScalar)
+                return new RelativeScalar(left.Double * right.RelativeScalar.Scalar, right.RelativeScalar.Unit);
+
+            if (left.Type == VariantType.RelativePoint && right.Type == VariantType.RelativePoint && left.RelativePoint.Unit == right.RelativePoint.Unit)
+            {
+                return new RelativePoint(
+                    left.RelativePoint.Point.X * right.RelativePoint.Point.X,
+                    left.RelativePoint.Point.Y * right.RelativePoint.Point.Y,
+                    left.RelativePoint.Unit);
+            }
+
+            if (left.Type == VariantType.RelativeScalar && right.Type == VariantType.RelativeScalar && left.RelativeScalar.Unit == right.RelativeScalar.Unit)
+                return new RelativeScalar(left.RelativeScalar.Scalar * right.RelativeScalar.Scalar, left.RelativeScalar.Unit);
+
             return default;
         }
 
@@ -528,6 +629,24 @@ namespace Avalonia.Rendering.Composition.Expressions
             if (left.Type == VariantType.Quaternion && right.Type == VariantType.Quaternion)
                 return left.Quaternion / right.Quaternion;
 
+            if (left.Type == VariantType.RelativePoint && right.Type == VariantType.Double)
+                return new RelativePoint(left.RelativePoint.Point.X / right.Double, left.RelativePoint.Point.Y / right.Double, left.RelativePoint.Unit);
+
+
+            if (left.Type == VariantType.RelativeScalar && right.Type == VariantType.Double)
+                return new RelativeScalar(left.RelativeScalar.Scalar / right.Double, left.RelativeScalar.Unit);
+
+            if (left.Type == VariantType.RelativePoint && right.Type == VariantType.RelativePoint && left.RelativePoint.Unit == right.RelativePoint.Unit)
+            {
+                return new RelativePoint(
+                    left.RelativePoint.Point.X / right.RelativePoint.Point.X,
+                    left.RelativePoint.Point.Y / right.RelativePoint.Point.Y,
+                    left.RelativePoint.Unit);
+            }
+
+            if (left.Type == VariantType.RelativeScalar && right.Type == VariantType.RelativeScalar && left.RelativeScalar.Unit == right.RelativeScalar.Unit)
+                return new RelativeScalar(left.RelativeScalar.Scalar / right.RelativeScalar.Scalar, left.RelativeScalar.Unit);
+
             return default;
         }
 
@@ -541,13 +660,13 @@ namespace Avalonia.Rendering.Composition.Expressions
 
             if (Type == VariantType.Vector2)
                 return Vector2 == right.Vector2;
-            
+
             if (Type == VariantType.Vector)
                 return Vector == right.Vector;
-            
+
             if (Type == VariantType.Vector3)
                 return Vector3 == right.Vector3;
-            
+
             if (Type == VariantType.Vector3D)
                 return Vector3D == right.Vector3D;
 
@@ -559,7 +678,7 @@ namespace Avalonia.Rendering.Composition.Expressions
 
             if (Type == VariantType.Matrix3x2)
                 return Matrix3x2 == right.Matrix3x2;
-            
+
             if (Type == VariantType.AvaloniaMatrix)
                 return AvaloniaMatrix == right.AvaloniaMatrix;
 
@@ -568,7 +687,16 @@ namespace Avalonia.Rendering.Composition.Expressions
 
             if (Type == VariantType.Quaternion)
                 return Quaternion == right.Quaternion;
-            
+
+            if (Type == VariantType.RelativePoint)
+                return RelativePoint == right.RelativePoint;
+
+            if (Type == VariantType.RelativeScalar)
+                return RelativeScalar == right.RelativeScalar;
+
+            if (Type == VariantType.RelativeUnit)
+                return RelativeUnit == right.RelativeUnit;
+
             return default;
         }
 
@@ -591,6 +719,8 @@ namespace Avalonia.Rendering.Composition.Expressions
         {
             if (left.Type == VariantType.Double && right.Type == VariantType.Double)
                 return left.Double % right.Double;
+            if (left.Type == VariantType.RelativeScalar && right.Type == VariantType.RelativeScalar && left.RelativeScalar.Unit == right.RelativeScalar.Unit)
+                return new RelativeScalar(left.RelativeScalar.Scalar % right.RelativeScalar.Scalar, left.RelativeScalar.Unit);
             return default;
         }
 
@@ -598,6 +728,8 @@ namespace Avalonia.Rendering.Composition.Expressions
         {
             if (left.Type == VariantType.Double && right.Type == VariantType.Double)
                 return left.Double < right.Double;
+            if (left.Type == VariantType.RelativeScalar && right.Type == VariantType.RelativeScalar && left.RelativeScalar.Unit == right.RelativeScalar.Unit)
+                return left.RelativeScalar.Scalar < right.RelativeScalar.Scalar;
             return default;
         }
 
@@ -605,6 +737,8 @@ namespace Avalonia.Rendering.Composition.Expressions
         {            
             if (left.Type == VariantType.Double && right.Type == VariantType.Double)
                 return left.Double > right.Double;
+            if (left.Type == VariantType.RelativeScalar && right.Type == VariantType.RelativeScalar && left.RelativeScalar.Unit == right.RelativeScalar.Unit)
+                return left.RelativeScalar.Scalar > right.RelativeScalar.Scalar;
             return default;
         }
 
@@ -677,6 +811,15 @@ namespace Avalonia.Rendering.Composition.Expressions
                 case Avalonia.Media.Color when Type is VariantType.Color:
                     res = (T)(object)Color;
                     return true;
+                case Avalonia.RelativePoint when Type is VariantType.RelativePoint:
+                    res = (T)(object)RelativePoint;
+                    return true;
+                case Avalonia.RelativeScalar when Type is VariantType.RelativeScalar:
+                    res = (T)(object)RelativeScalar;
+                    return true;
+                case Avalonia.RelativeUnit when Type is VariantType.RelativeUnit:
+                    res = (T)(object)RelativeUnit;
+                    return true;
                 default:
                     res = default;
                     return false;
@@ -699,6 +842,9 @@ namespace Avalonia.Rendering.Composition.Expressions
                 System.Numerics.Matrix4x4 => (Matrix4x4)(object)v,
                 System.Numerics.Quaternion => (Quaternion)(object)v,
                 Avalonia.Media.Color => (Avalonia.Media.Color)(object)v,
+                Avalonia.RelativePoint => (RelativePoint)(object)v,
+                Avalonia.RelativeScalar => (RelativeScalar)(object)v,
+                Avalonia.RelativeUnit => (RelativeUnit)(object)v,
                 _ => throw new ArgumentException("Invalid variant type: " + typeof(T))
             };
 
@@ -724,6 +870,9 @@ namespace Avalonia.Rendering.Composition.Expressions
                 VariantType.AvaloniaMatrix => AvaloniaMatrix.ToString(),
                 VariantType.Matrix4x4 => Matrix4x4.ToString(),
                 VariantType.Color => Color.ToString(),
+                VariantType.RelativePoint => RelativePoint.ToString(),
+                VariantType.RelativeScalar => RelativeScalar.ToString(),
+                VariantType.RelativeUnit => RelativeUnit.ToString(),
                 VariantType.Invalid => "Invalid",
                 _ => "Unknown"
             };
diff --git a/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionGradientStop.cs b/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionGradientStop.cs
new file mode 100644
index 0000000000..6b7cdd20a1
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/Server/ServerCompositionGradientStop.cs
@@ -0,0 +1,8 @@
+using Avalonia.Media;
+
+namespace Avalonia.Rendering.Composition.Server;
+
+partial class ServerCompositionGradientStop : IGradientStop
+{
+
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Server/ServerRenderResource.cs b/src/Avalonia.Base/Rendering/Composition/Server/ServerRenderResource.cs
index 105580e6ad..b8c99ab04c 100644
--- a/src/Avalonia.Base/Rendering/Composition/Server/ServerRenderResource.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Server/ServerRenderResource.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using Avalonia.Rendering.Composition.Transport;
@@ -18,24 +19,99 @@ internal interface IServerRenderResource : IServerRenderResourceObserver
     void QueuedInvalidate();
 }
 
-internal class SimpleServerRenderResource : SimpleServerObject, IServerRenderResource, IDisposable
+internal interface IServerRenderResourceHost : IServerRenderResource
+{
+    ServerCompositor Compositor { get; }
+    void ResourcePropertyChanged();
+}
+
+internal class SimpleServerRenderResource : SimpleServerObject, IServerRenderResourceHost, IDisposable
+{
+    private ServerRenderResourceCore _core;
+    public bool IsDisposed => _core.IsDisposed;
+
+    public SimpleServerRenderResource(ServerCompositor compositor) : base(compositor) { }
+
+    protected new void SetValue<T>(CompositionProperty prop, ref T field, T value) => SetValue(ref field, value);
+
+    protected void SetValue<T>(ref T field, T value) => _core.SetValue(this, ref field, value);
+
+    protected void Invalidated() => _core.Invalidated(this);
+
+    protected override void ValuesInvalidated()
+    {
+        Invalidated();
+        base.ValuesInvalidated();
+    }
+
+    protected void RemoveObserversFromProperty<T>(ref T field) => _core.RemoveObserversFromProperty(this, ref field);
+
+    public virtual void Dispose() => _core.Dispose();
+
+    public virtual void DependencyQueuedInvalidate(IServerRenderResource sender) => _core.DependencyQueuedInvalidate(this);
+
+    protected virtual void PropertyChanged()
+    {
+    }
+
+    public void AddObserver(IServerRenderResourceObserver observer) => _core.AddObserver(observer);
+
+    public void RemoveObserver(IServerRenderResourceObserver observer) => _core.RemoveObserver(observer);
+
+    public virtual void QueuedInvalidate() => _core.QueuedInvalidate(this);
+    void IServerRenderResourceHost.ResourcePropertyChanged() => PropertyChanged();
+}
+
+internal class ServerRenderResource : ServerObject, IServerRenderResourceHost, IDisposable
+{
+    private ServerRenderResourceCore _core;
+    public bool IsDisposed => _core.IsDisposed;
+
+    public ServerRenderResource(ServerCompositor compositor) : base(compositor) { }
+
+    protected new void SetValue<T>(CompositionProperty prop, ref T field, T value) => SetValue(ref field, value);
+
+    protected void SetValue<T>(ref T field, T value) => _core.SetValue(this, ref field, value);
+
+    protected void Invalidated() => _core.Invalidated(this);
+
+    protected override void ValuesInvalidated()
+    {
+        Invalidated();
+        base.ValuesInvalidated();
+    }
+
+    protected void RemoveObserversFromProperty<T>(ref T field) => _core.RemoveObserversFromProperty(this, ref field);
+
+    public virtual void Dispose() => _core.Dispose();
+
+    public virtual void DependencyQueuedInvalidate(IServerRenderResource sender) => _core.DependencyQueuedInvalidate(this);
+
+    protected virtual void PropertyChanged()
+    {
+    }
+
+    public void AddObserver(IServerRenderResourceObserver observer) => _core.AddObserver(observer);
+
+    public void RemoveObserver(IServerRenderResourceObserver observer) => _core.RemoveObserver(observer);
+
+    public virtual void QueuedInvalidate() => _core.QueuedInvalidate(this);
+
+    void IServerRenderResourceHost.ResourcePropertyChanged() => PropertyChanged();
+}
+
+internal struct ServerRenderResourceCore
 {
     private bool _pendingInvalidation;
     private bool _disposed;
     public bool IsDisposed => _disposed;
     private RefCountingSmallDictionary<IServerRenderResourceObserver> _observers;
-    
-    public SimpleServerRenderResource(ServerCompositor compositor) : base(compositor)
-    {
-    }
 
-    protected new void SetValue<T>(CompositionProperty prop, ref T field, T value) => SetValue(ref field, value);
-    
-    protected void SetValue<T>(ref T field, T value)
+    public void SetValue<T>(IServerRenderResourceHost self, ref T field, T value)
     {
         if (EqualityComparer<T>.Default.Equals(field, value))
             return;
-        
+
         if (_disposed)
         {
             field = value;
@@ -43,64 +119,58 @@ internal class SimpleServerRenderResource : SimpleServerObject, IServerRenderRes
         }
 
         if (field is IServerRenderResource oldChild)
-            oldChild.RemoveObserver(this);
-        else if (field is IServerRenderResource[] oldChildren)
+            oldChild.RemoveObserver(self);
+        else if (field is IEnumerable oldChildren)
         {
             foreach (var ch in oldChildren)
-                ch?.RemoveObserver(this);
+                (ch as IServerRenderResource)?.RemoveObserver(self);
         }
+
         field = value;
+
         if (field is IServerRenderResource newChild)
-            newChild.AddObserver(this);
-        else if (field is IServerRenderResource[] newChildren)
+            newChild.AddObserver(self);
+        else if (field is IEnumerable newChildren)
         {
             foreach (var ch in newChildren)
-                ch.AddObserver(this);
+                (ch as IServerRenderResource)?.AddObserver(self);
         }
-        Invalidated();
+
+        Invalidated(self);
     }
 
-    protected void Invalidated()
+    public void Invalidated(IServerRenderResourceHost self)
     {
         // This is needed to avoid triggering on multiple property changes
         if (!_pendingInvalidation)
         {
             _pendingInvalidation = true;
-            Compositor.EnqueueRenderResourceForInvalidation(this);
-            PropertyChanged();
+            self.Compositor.EnqueueRenderResourceForInvalidation(self);
+            self.ResourcePropertyChanged();
         }
     }
 
-    protected override void ValuesInvalidated()
-    {
-        Invalidated();
-        base.ValuesInvalidated();
-    }
-
-    protected void RemoveObserversFromProperty<T>(ref T field)
+    public void RemoveObserversFromProperty<T>(IServerRenderResource self, ref T field)
     {
-        (field as IServerRenderResource)?.RemoveObserver(this);
+        (field as IServerRenderResource)?.RemoveObserver(self);
     }
 
-    public virtual void Dispose()
+    public void Dispose()
     {
         _disposed = true;
         // TODO: dispose once we implement pooling
         _observers = default;
     }
 
-    public virtual void DependencyQueuedInvalidate(IServerRenderResource sender) =>
-        Compositor.EnqueueRenderResourceForInvalidation(this);
-
-    protected virtual void PropertyChanged()
+    public void DependencyQueuedInvalidate(IServerRenderResourceHost self)
     {
-        
+        self.Compositor.EnqueueRenderResourceForInvalidation(self);
     }
-    
+
     public void AddObserver(IServerRenderResourceObserver observer)
     {
         Debug.Assert(!_disposed);
-        if(_disposed)
+        if (_disposed)
             return;
         _observers.Add(observer);
     }
@@ -112,12 +182,11 @@ internal class SimpleServerRenderResource : SimpleServerObject, IServerRenderRes
         _observers.Remove(observer);
     }
 
-    public virtual void QueuedInvalidate()
+    public void QueuedInvalidate(IServerRenderResource self)
     {
         _pendingInvalidation = false;
 
         foreach (var observer in _observers)
-            observer.Key.DependencyQueuedInvalidate(this);
-
+            observer.Key.DependencyQueuedInvalidate(self);
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Base/composition-schema.xml b/src/Avalonia.Base/composition-schema.xml
index 460e402572..1256355fa4 100644
--- a/src/Avalonia.Base/composition-schema.xml
+++ b/src/Avalonia.Base/composition-schema.xml
@@ -71,6 +71,8 @@
     <KeyFrameAnimation Type="Vector3D"/>
     <KeyFrameAnimation Type="Vector4"/>
     <KeyFrameAnimation Type="Quaternion"/>
+    <KeyFrameAnimation Name="RelativePoint" Type="Avalonia.RelativePoint"/>
+    <KeyFrameAnimation Name="RelativeScalar" Type="Avalonia.RelativeScalar"/>
     <Object Name="CompositionSimpleTransform" Internal="true" ServerOnly="true" ServerBase="SimpleServerRenderResource">
         <Property Name="Value" Type="Avalonia.Matrix" />
     </Object>
@@ -123,4 +125,39 @@
         <Property Name="SnapsToDevicePixels" Type="bool" Animated="true" DefaultValue="false"/>
         <Property Name="EnableClearType" Type="bool" Animated="true" DefaultValue="false"/>
     </Object>
+    <Object Name="CompositionBrush" ServerBase="ServerRenderResource">
+        <Property Name="Opacity" Type="double" Animated="true" DefaultValue="1"/>
+        <Property Name="TransformOrigin" Type="RelativePoint" />
+        <Property Name="Transform" Type="Avalonia.Media.ITransform?" />
+    </Object>
+    <Object Name="CompositionSolidColorBrush" Inherits="CompositionBrush" ServerBase="ServerCompositionBrush">
+        <Property Name="Color" Type="Avalonia.Media.Color" Animated="true"/>
+    </Object>
+    <Manual Name="CompositionGradientBrush" />
+    <Object Name="CompositionConicGradientBrush" Inherits="CompositionGradientBrush" ServerBase="ServerCompositionGradientBrush">
+        <Property Name="Angle" Type="double" Animated="true"/>
+        <Property Name="Center" Type="Avalonia.RelativePoint"  Animated="true"/>
+    </Object>
+    <Object Name="CompositionRadialGradientBrush" Inherits="CompositionGradientBrush" ServerBase="ServerCompositionGradientBrush">
+        <Property Name="Center" Type="Avalonia.RelativePoint" Animated="true"/>
+        <Property Name="GradientOrigin" Type="Avalonia.RelativePoint"  Animated="true"/>
+        <Property Name="RadiusX" Type="Avalonia.RelativeScalar" Animated="true" DefaultValue="RelativeScalar.Middle"/>
+        <Property Name="RadiusY" Type="Avalonia.RelativeScalar" Animated="true" DefaultValue="RelativeScalar.Middle"/>
+    </Object>
+    <Object Name="CompositionLinearGradientBrush" Inherits="CompositionGradientBrush" ServerBase="ServerCompositionGradientBrush">
+        <Property Name="StartPoint" Type="Avalonia.RelativePoint" Animated="true"/>
+        <Property Name="EndPoint" Type="Avalonia.RelativePoint" Animated="true"/>
+    </Object>
+    <Object Name="CompositionTileBrush" Internal="true" ServerOnly="true" ServerBase="ServerCompositionBrush">
+        <Property Name="AlignmentX" Type="Avalonia.Media.AlignmentX" />
+        <Property Name="AlignmentY" Type="Avalonia.Media.AlignmentY" />
+        <Property Name="DestinationRect" Type="Avalonia.RelativeRect" />
+        <Property Name="SourceRect" Type="Avalonia.RelativeRect" />
+        <Property Name="Stretch" Type="Avalonia.Media.Stretch" />
+        <Property Name="TileMode" Type="Avalonia.Media.TileMode" />
+    </Object>
+    <Object Name="CompositionGradientStop" ServerBase="ServerRenderResource">
+        <Property Name="Color" Type="Avalonia.Media.Color" Animated="true"/>
+        <Property Name="Offset" Type="double" Animated="true"/>
+    </Object>
 </NComposition>
diff --git a/src/tools/DevGenerators/CompositionGenerator/Generator.cs b/src/tools/DevGenerators/CompositionGenerator/Generator.cs
index b6b7eccb78..37f5c5f850 100644
--- a/src/tools/DevGenerators/CompositionGenerator/Generator.cs
+++ b/src/tools/DevGenerators/CompositionGenerator/Generator.cs
@@ -436,6 +436,8 @@ return;
             "Quaternion",
             "Color",
             "Avalonia.Media.Color",
+            "Avalonia.RelativePoint",
+            "Avalonia.RelativeScalar",
             "Vector",
             "Vector3D"
         };

From 386be0fa0ba5545fe584cd44a03972489081c762 Mon Sep 17 00:00:00 2001
From: yoyo <zrt2399@163.com>
Date: Sun, 26 Jul 2026 16:12:29 +0800
Subject: [PATCH 122/196] fix(TextBox): initialize command states in
 constructor (#21859)

---
 src/Avalonia.Controls/TextBox.cs                  |  1 +
 tests/Avalonia.Controls.UnitTests/TextBoxTests.cs | 13 +++++++++++++
 2 files changed, 14 insertions(+)

diff --git a/src/Avalonia.Controls/TextBox.cs b/src/Avalonia.Controls/TextBox.cs
index 408e837043..c8e37c132a 100644
--- a/src/Avalonia.Controls/TextBox.cs
+++ b/src/Avalonia.Controls/TextBox.cs
@@ -431,6 +431,7 @@ namespace Avalonia.Controls
             _undoRedoHelper = new UndoRedoHelper<UndoRedoState>(this);
             _selectedTextChangesMadeSinceLastUndoSnapshot = 0;
             _hasDoneSnapshotOnce = false;
+            UpdateCommandStates();
             UpdatePseudoclasses();
         }
 
diff --git a/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs b/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
index 39dd5efa1d..b8e781840f 100644
--- a/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TextBoxTests.cs
@@ -1549,6 +1549,19 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Empty_TextBox_Initializes_Clipboard_Command_States()
+        {
+            using (UnitTestApplication.Start(Services))
+            {
+                var tb = new TextBox();
+
+                Assert.False(tb.CanCopy);
+                Assert.False(tb.CanCut);
+                Assert.True(tb.CanPaste);
+            }
+        }
+
         [Fact]
         public void Command_States_Update_When_ReadOnly_And_PasswordChar_Change()
         {

From 9e1c35bc5dfe5e76f38c7f6cc104409c9bbb3d79 Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Sun, 26 Jul 2026 23:33:01 +1000
Subject: [PATCH 123/196] fix(grid): register assigned definition collections
 with their shared size group (#21848)

* test(grid): reproduce shared size groups ignoring assigned definitions

Definitions supplied through the ColumnDefinitions or RowDefinitions
setter are already in the collection when the grid claims it, so they
never pass through the collection-changed handler that joins them to the
parent tree. They never register with their shared size group, and the
definitions they replace never unregister from it.

* fix(grid): join assigned definition collections to the parent tree

DefinitionList.SetParent assigned each definition's Parent but never
called OnEnterParentTree, which only ran from the collection-changed
handler. Assigning Parent is not sufficient: OnEnterParentTree also sets
InheritanceParent, and a definition cannot read the inherited
PrivateSharedSizeScope that registers it with its group until that link
exists. Definitions supplied through the ColumnDefinitions setter - an
object initializer, a shared resource, or ColumnDefinitions="Auto,*" -
were therefore silently absent from their shared size group.

Enter and exit the parent tree from SetParent, and release the outgoing
collection when Grid swaps one in. Without that release the replaced
definitions stay registered with the group; nothing resets their measured
minimum any more, so they pin it at whatever they last contributed.

* test(grid): cover the definition ownership contract

Removing a definition leaves it holding its old Parent and its property
inheritance link, so it still reads the grid's shared size scope and can
re-register itself into a scope it has left. Also covers moving a
definition between grids, reassigning the same collection, and row
definitions, which the assignment fix reached but nothing exercised.

* refactor(grid): centralise definition parent-tree transitions

Definition ownership was implemented twice, and the two paths disagreed:
SetParent exited a definition and cleared its Parent, while removing one
from the collection called OnExitParentTree but left Parent set. Detach
was incomplete either way, since OnEnterParentTree establishes
InheritanceParent but OnExitParentTree never cleared it - so a removed
definition kept reading the grid's inherited PrivateSharedSizeScope, and
the grid kept it alive as an inheritance child.

Route every owner change through one transition that exits the old tree,
assigns Parent, and enters the new one, and clear InheritanceParent on
exit so detach mirrors attach.

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 src/Avalonia.Controls/DefinitionBase.cs       |   4 +
 src/Avalonia.Controls/DefinitionList.cs       |  50 +++-
 src/Avalonia.Controls/Grid.cs                 |  12 +
 .../Avalonia.Controls.UnitTests/GridTests.cs  | 238 ++++++++++++++++++
 4 files changed, 292 insertions(+), 12 deletions(-)

diff --git a/src/Avalonia.Controls/DefinitionBase.cs b/src/Avalonia.Controls/DefinitionBase.cs
index 020f6996aa..b7effa6232 100644
--- a/src/Avalonia.Controls/DefinitionBase.cs
+++ b/src/Avalonia.Controls/DefinitionBase.cs
@@ -60,6 +60,10 @@ namespace Avalonia.Controls
             }
 
             Parent?.InvalidateMeasure();
+
+            //  while this link survives the definition still reads the grid's inherited
+            //  PrivateSharedSizeScope, and the grid holds it as an inheritance child.
+            InheritanceParent = null;
         }
 
         /// <summary>
diff --git a/src/Avalonia.Controls/DefinitionList.cs b/src/Avalonia.Controls/DefinitionList.cs
index 63a54731e0..aa2f4f4080 100644
--- a/src/Avalonia.Controls/DefinitionList.cs
+++ b/src/Avalonia.Controls/DefinitionList.cs
@@ -25,17 +25,53 @@ namespace Avalonia.Controls
 
         private void SetParent(Grid? value)
         {
+            if (_parent == value)
+            {
+                return;
+            }
+
             _parent = value;
 
+            //  definitions already present when the grid claims the collection never pass through
+            //  OnCollectionChanged, so they have to change trees here.
             var idx = 0;
 
             foreach (T definition in this)
             {
-                definition.Parent = value;
+                SetDefinitionParent(definition, value);
                 definition.Index = idx++;
             }
         }
 
+        /// <summary>
+        /// Moves a definition from its current parent tree to <paramref name="parent"/>. Every route
+        /// that changes a definition's owner goes through here.
+        /// </summary>
+        /// <remarks>
+        /// Ownership is more than the Parent pointer: entering a tree also establishes the property
+        /// inheritance link a definition needs to see its shared size scope, and leaving one releases
+        /// that link and its shared size registration.
+        /// </remarks>
+        private static void SetDefinitionParent(DefinitionBase definition, Grid? parent)
+        {
+            if (definition.Parent == parent)
+            {
+                return;
+            }
+
+            if (definition.Parent is not null)
+            {
+                definition.OnExitParentTree();
+            }
+
+            definition.Parent = parent;
+
+            if (parent is not null)
+            {
+                definition.OnEnterParentTree();
+            }
+        }
+
         internal void OnCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
         {
             var idx = 0;
@@ -62,17 +98,7 @@ namespace Avalonia.Controls
 
             for (var i = 0; i < count; i++)
             {
-                var definition = (DefinitionBase) items[i]!;
-
-                if (wasRemoved)
-                {
-                    definition.OnExitParentTree();
-                }
-                else
-                {
-                    definition.Parent = Parent;
-                    definition.OnEnterParentTree();                    
-                }
+                SetDefinitionParent((DefinitionBase)items[i]!, wasRemoved ? null : Parent);
             }
         }
     }
diff --git a/src/Avalonia.Controls/Grid.cs b/src/Avalonia.Controls/Grid.cs
index 992cc38ecc..2e15b07463 100644
--- a/src/Avalonia.Controls/Grid.cs
+++ b/src/Avalonia.Controls/Grid.cs
@@ -198,6 +198,12 @@ namespace Avalonia.Controls
             set
             {
                 if (_extData == null) { _extData = new ExtendedData(); }
+                //  otherwise the outgoing definitions stay registered with their shared size
+                //  group and keep contributing to its minimum.
+                if (_extData.ColumnDefinitions is { } oldDefinitions && !ReferenceEquals(oldDefinitions, value))
+                {
+                    oldDefinitions.Parent = null;
+                }
                 _extData.ColumnDefinitions = value;
                 _extData.ColumnDefinitions.Parent = this;
                 InvalidateMeasure();
@@ -220,6 +226,12 @@ namespace Avalonia.Controls
             set
             {
                 if (_extData == null) { _extData = new ExtendedData(); }
+                //  otherwise the outgoing definitions stay registered with their shared size
+                //  group and keep contributing to its minimum.
+                if (_extData.RowDefinitions is { } oldDefinitions && !ReferenceEquals(oldDefinitions, value))
+                {
+                    oldDefinitions.Parent = null;
+                }
                 _extData.RowDefinitions = value;
                 _extData.RowDefinitions.Parent = this;
                 InvalidateMeasure();
diff --git a/tests/Avalonia.Controls.UnitTests/GridTests.cs b/tests/Avalonia.Controls.UnitTests/GridTests.cs
index 435bb79cf3..3a9a8cdaee 100644
--- a/tests/Avalonia.Controls.UnitTests/GridTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/GridTests.cs
@@ -1309,6 +1309,244 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(10, plainGrid.ColumnDefinitions[0].ActualWidth);
         }
 
+        [Fact]
+        public void Shared_Size_Group_Is_Registered_For_Definitions_Assigned_As_A_Collection()
+        {
+            // Definitions supplied through the ColumnDefinitions setter - an object initializer, a
+            // shared resource, or ColumnDefinitions="Auto,*" - are already in the collection when the
+            // grid claims it, so they never pass through the collection-changed handler that joins
+            // them to the parent tree.
+            var grids = new[]
+            {
+                new Grid
+                {
+                    ColumnDefinitions = new ColumnDefinitions
+                    {
+                        new ColumnDefinition { Width = GridLength.Auto, SharedSizeGroup = "A" },
+                        new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) },
+                    },
+                },
+                new Grid
+                {
+                    ColumnDefinitions = new ColumnDefinitions
+                    {
+                        new ColumnDefinition { Width = GridLength.Auto, SharedSizeGroup = "A" },
+                        new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) },
+                    },
+                },
+            };
+            grids[0].Children.Add(new Border { Width = 50, Height = 10 });
+
+            var scope = new StackPanel
+            {
+                [Grid.IsSharedSizeScopeProperty] = true,
+                Children = { grids[0], grids[1] },
+            };
+            var root = new TestRoot(scope);
+
+            root.ExecuteInitialLayoutPass();
+            // Shared groups validate after layout and apply any resulting invalidation on the next pass.
+            root.LayoutManager.ExecuteLayoutPass();
+
+            Assert.Equal(50, grids[0].ColumnDefinitions[0].ActualWidth);
+            Assert.Equal(50, grids[1].ColumnDefinitions[0].ActualWidth);
+        }
+
+        [Fact]
+        public void Replacing_Definition_Collection_Releases_Its_Shared_Size_Group()
+        {
+            // The outgoing definitions are no longer reachable from the grid, so nothing resets their
+            // measured minimum. Left registered, they keep the group pinned at whatever size they
+            // last contributed.
+            var grid = new Grid();
+            grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto, SharedSizeGroup = "A" });
+            grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+            grid.Children.Add(new Border { Width = 50, Height = 10 });
+
+            var other = new Grid();
+            other.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto, SharedSizeGroup = "A" });
+            other.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+
+            var scope = new StackPanel
+            {
+                [Grid.IsSharedSizeScopeProperty] = true,
+                Children = { grid, other },
+            };
+            var root = new TestRoot(scope);
+
+            root.ExecuteInitialLayoutPass();
+            // Shared groups validate after layout and apply any resulting invalidation on the next pass.
+            root.LayoutManager.ExecuteLayoutPass();
+            Assert.Equal(50, other.ColumnDefinitions[0].ActualWidth);
+
+            grid.ColumnDefinitions = new ColumnDefinitions
+            {
+                new ColumnDefinition { Width = GridLength.Auto },
+                new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) },
+            };
+            root.LayoutManager.ExecuteLayoutPass();
+            root.LayoutManager.ExecuteLayoutPass();
+
+            Assert.Equal(0, other.ColumnDefinitions[0].ActualWidth);
+        }
+
+        [Fact]
+        public void Removing_Definition_Detaches_It_From_The_Grid()
+        {
+            var shared = new ColumnDefinition { Width = GridLength.Auto, SharedSizeGroup = "A" };
+            var grid = new Grid();
+            grid.ColumnDefinitions.Add(shared);
+            grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+            grid.Children.Add(new Border { Width = 50, Height = 10 });
+
+            var other = new Grid();
+            other.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto, SharedSizeGroup = "A" });
+            other.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+
+            var scope = new StackPanel
+            {
+                [Grid.IsSharedSizeScopeProperty] = true,
+                Children = { grid, other },
+            };
+            var root = new TestRoot(scope);
+
+            root.ExecuteInitialLayoutPass();
+            root.LayoutManager.ExecuteLayoutPass();
+            Assert.Equal(50, other.ColumnDefinitions[0].ActualWidth);
+
+            grid.ColumnDefinitions.Remove(shared);
+            root.LayoutManager.ExecuteLayoutPass();
+            root.LayoutManager.ExecuteLayoutPass();
+            Assert.Equal(0, other.ColumnDefinitions[0].ActualWidth);
+            Assert.Null(shared.Parent);
+
+            // A definition that has left the grid must no longer see the grid's scope.
+            shared.SharedSizeGroup = null;
+            shared.SharedSizeGroup = "A";
+            root.LayoutManager.ExecuteLayoutPass();
+            root.LayoutManager.ExecuteLayoutPass();
+            Assert.Equal(0, other.ColumnDefinitions[0].ActualWidth);
+        }
+
+        [Fact]
+        public void Moving_Definition_Between_Grids_Moves_Its_Shared_Size_Registration()
+        {
+            var shared = new ColumnDefinition { Width = GridLength.Auto, SharedSizeGroup = "A" };
+            var source = new Grid();
+            source.ColumnDefinitions.Add(shared);
+            source.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+            source.Children.Add(new Border { Width = 50, Height = 10 });
+
+            var sourcePartner = new Grid();
+            sourcePartner.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto, SharedSizeGroup = "A" });
+            sourcePartner.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+
+            var target = new Grid();
+            target.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+
+            var targetPartner = new Grid();
+            targetPartner.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto, SharedSizeGroup = "A" });
+            targetPartner.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+            targetPartner.Children.Add(new Border { Width = 20, Height = 10 });
+
+            var sourceScope = new StackPanel
+            {
+                [Grid.IsSharedSizeScopeProperty] = true,
+                Children = { source, sourcePartner },
+            };
+            var targetScope = new StackPanel
+            {
+                [Grid.IsSharedSizeScopeProperty] = true,
+                Children = { target, targetPartner },
+            };
+            var root = new TestRoot(new StackPanel { Children = { sourceScope, targetScope } });
+
+            root.ExecuteInitialLayoutPass();
+            root.LayoutManager.ExecuteLayoutPass();
+            Assert.Equal(50, sourcePartner.ColumnDefinitions[0].ActualWidth);
+            Assert.Equal(20, targetPartner.ColumnDefinitions[0].ActualWidth);
+
+            source.ColumnDefinitions.Remove(shared);
+            target.ColumnDefinitions.Insert(0, shared);
+            root.LayoutManager.ExecuteLayoutPass();
+            root.LayoutManager.ExecuteLayoutPass();
+
+            Assert.Same(target, shared.Parent);
+            Assert.Equal(0, sourcePartner.ColumnDefinitions[0].ActualWidth);
+            Assert.Equal(20, target.ColumnDefinitions[0].ActualWidth);
+        }
+
+        [Fact]
+        public void Reassigning_The_Same_Definition_Collection_Is_Inert()
+        {
+            var grid = new Grid();
+            grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto, SharedSizeGroup = "A" });
+            grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+            grid.Children.Add(new Border { Width = 50, Height = 10 });
+
+            var other = new Grid();
+            other.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto, SharedSizeGroup = "A" });
+            other.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+
+            var scope = new StackPanel
+            {
+                [Grid.IsSharedSizeScopeProperty] = true,
+                Children = { grid, other },
+            };
+            var root = new TestRoot(scope);
+
+            root.ExecuteInitialLayoutPass();
+            root.LayoutManager.ExecuteLayoutPass();
+            Assert.Equal(50, other.ColumnDefinitions[0].ActualWidth);
+
+            var definitions = grid.ColumnDefinitions;
+            grid.ColumnDefinitions = definitions;
+            root.LayoutManager.ExecuteLayoutPass();
+            root.LayoutManager.ExecuteLayoutPass();
+
+            Assert.Same(definitions, grid.ColumnDefinitions);
+            Assert.Equal(50, other.ColumnDefinitions[0].ActualWidth);
+        }
+
+        [Fact]
+        public void Shared_Size_Group_Is_Registered_For_Row_Definitions_Assigned_As_A_Collection()
+        {
+            var grids = new[]
+            {
+                new Grid
+                {
+                    RowDefinitions = new RowDefinitions
+                    {
+                        new RowDefinition { Height = GridLength.Auto, SharedSizeGroup = "A" },
+                        new RowDefinition { Height = new GridLength(1, GridUnitType.Star) },
+                    },
+                },
+                new Grid
+                {
+                    RowDefinitions = new RowDefinitions
+                    {
+                        new RowDefinition { Height = GridLength.Auto, SharedSizeGroup = "A" },
+                        new RowDefinition { Height = new GridLength(1, GridUnitType.Star) },
+                    },
+                },
+            };
+            grids[0].Children.Add(new Border { Width = 10, Height = 50 });
+
+            var scope = new StackPanel
+            {
+                Orientation = Layout.Orientation.Horizontal,
+                [Grid.IsSharedSizeScopeProperty] = true,
+                Children = { grids[0], grids[1] },
+            };
+            var root = new TestRoot(scope);
+
+            root.ExecuteInitialLayoutPass();
+            root.LayoutManager.ExecuteLayoutPass();
+
+            Assert.Equal(50, grids[0].RowDefinitions[0].ActualHeight);
+            Assert.Equal(50, grids[1].RowDefinitions[0].ActualHeight);
+        }
+
         [Fact]
         public void Collection_Changes_Are_Tracked()
         {

From 37154a5275e5b2f58db8e54acfa8f2e45d8e8b84 Mon Sep 17 00:00:00 2001
From: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Date: Tue, 28 Jul 2026 13:57:00 +0800
Subject: [PATCH 124/196] Wayland: destroy transient framebuffer SHM pools
 (#21870)

---
 .../Transient/Rendering/WaylandFramebuffer.cs | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs
index 1c971f2f7b..65d8a9c6df 100644
--- a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs
@@ -72,10 +72,21 @@ class WaylandFramebuffer(IWaylandFramebufferSurface surface) : IFramebufferPlatf
                         if (!State.IsReady)
                             return;
 
-                        using var pool = _p._surface.Globals!.WlShm.CreatePool(fd, bufferLen);
-                        var listener = new BufferListener();
-                        var buffer = pool.CreateBuffer(0, size.Width, size.Height, stride,
-                            WlShm.FormatEnum.Argb8888, listener);
+                        var pool = _p._surface.Globals!.WlShm.CreatePool(fd, bufferLen);
+                        WlBuffer buffer;
+                        try
+                        {
+                            var listener = new BufferListener();
+                            buffer = pool.CreateBuffer(0, size.Width, size.Height, stride,
+                                WlShm.FormatEnum.Argb8888, listener);
+                        }
+                        finally
+                        {
+                            // NWayland's Dispose only destroys the local proxy;
+                            // the generated method is required to marshal the
+                            // Wayland destructor request to the compositor.
+                            pool.Destroy();
+                        }
                         
                         // Stage per-frame state (frame callback +
                         // ack_configure + geometry + viewport/scale +

From b2d9e7904bde138880743ba3936ad180acadb2fb Mon Sep 17 00:00:00 2001
From: Weijie Zhao <maggch@outlook.com>
Date: Tue, 28 Jul 2026 14:32:59 +0800
Subject: [PATCH 125/196] fix(focus): infinite loop in tab stop search with
 TabNavigation=Once (#21864)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(focus): infinite loop in tab stop search with TabNavigation=Once

`FocusManager.FindNextElement(Next|Previous)` and `TryMoveFocus(Next|Previous)` never
return when the focused element sits inside a container with
`KeyboardNavigationMode.Once`. The calling thread spins at 100% CPU forever; in a
desktop app that means a hard hang of the UI thread requiring the process to be killed.

## Root cause

The upward walk in `GetNextTabStop` / `GetPreviousTabStop` advances at the end of each
iteration with `parent = GetFocusParent(parent)`. But when the walk reaches a container
whose `TabNavigation` is `Once` (or `None`, in one branch), the code resets `parent`
from `focused` instead of from `current`:

```csharp
current = parent;
parent = FocusHelpers.GetFocusParent(focused);   // focused is a loop invariant
```

`focused` never changes, so `parent` drops back down to the focused element's immediate
parent. The next iteration walks up to the same container again and takes the same
branch, so the walk oscillates between two nodes indefinitely. None of the three loop
exit conditions (`parent != null`, `!parentIsRootVisual`, `newTabStop == null`) can ever
be satisfied.

The correct form already exists a few lines below in `GetNextTabStop`, in the
structurally identical `KeyboardNavigationMode.None` branch:

```csharp
current = pIE;
parent = FocusHelpers.GetFocusParent(current);   // walks up, converges
```

This changes the three remaining occurrences to match it: one in `GetNextTabStop`, two in
`GetPreviousTabStop`. The two loop initializers outside the `while` (`FocusManager.cs:647`
and `:748`) correctly keep using `focused` and are left alone.

## Reproducing it

The focused element has to be nested **at least one level below** the `Once` container.
When it is a direct child, `GetFocusParent(focused)` happens to return that same container
and the walk terminates by accident - which is likely why this went unnoticed for so long.

Minimal shape (used by both new tests):

```
StackPanel
├── StackPanel [TabNavigation=Once]
│   └── StackPanel
│       └── Button   <- focused
└── Button           <- expected result for Next
```

Found in a production app: FluentAvalonia's `ContentDialog` calls
`FindNextElement(NavigationDirection.Next, ...)` from its `Loaded` handler to pick an
initial focus target. With focus sitting on a nested `NavigationView` item - the `Once`
container comes from the NavigationView template - opening any dialog hung the app
permanently.

## Scope

Only the programmatic focus APIs go through this code. Pressing Tab is unaffected:
`KeyboardNavigationHandler` uses the separate, WPF-derived implementation in
`Navigation/TabNavigation.cs`, which handles `Once` correctly by passing the container
itself as the new starting point.

## Verification

- Two regression tests added to `InputElement_Focus`, covering both directions.
- Confirmed they actually catch the bug: with the `FocusManager.cs` change reverted, the
  Next test ran for 90s using 89.5s of CPU and the Previous test for 60s using 59.6s
  before being killed. With the fix both return immediately.
- Full `Avalonia.Base.UnitTests` suite: 2996 tests, 0 failed (2984 passed, 12 skipped).

## Not addressed here

The `Once` branches are asymmetric: `GetPreviousTabStop` returns the container when it is
focusable (`if (FocusHelpers.IsFocusable(parent)) newTabStop = parent;`), `GetNextTabStop`
has no such check. Separately, in the Previous direction this shape ends up returning the
focused element itself via the cycle fallback in `GetTabStopCandidateElement`, rather than
the element preceding the container. Both look like genuine issues, but they are
behavioural questions independent of the hang, so the Previous test only asserts that the
call terminates. Happy to follow up in a separate PR if you would like them fixed.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(focus): previous tab stop search accepted candidates after the focused element

Follow-up to the review feedback on the Previous test: asserting the exact element
exposed that `GetPreviousTabStop` could not produce it. This turned out to be a second,
independent porting error in the same code, so this commit fixes it and tightens both
tests to exact-element assertions.

## Root cause

`GetNextOrPreviousTabStopInternal` accepts an equal-tab-index candidate for the
Previous direction with:

```csharp
if (compareIndexResult < 0 || (((foundCurrent || currentPassed) || compareCurrentForPreviousElement) && compareIndexResult == 0))
```

The WinUI implementation this code is ported from (see
`CFocusManager::GetPreviousTabStopInternal`, faithfully mirrored in Uno's
`FocusManager.mux.cs`) reads:

```cpp
if (compareIndexResult < 0 ||
    (((!bFoundCurrent && !bCurrentPassed) || bCurrentCompare) && compareIndexResult == 0))
```

The negations were lost in porting, inverting the condition: since `TabIndex` defaults
to `int.MaxValue`, sibling comparisons are almost always equal, so the Previous search
skipped every element *before* the focused one and accepted elements *after* it. The
Next direction's condition matches WinUI and is untouched.

## Impact

Not limited to the `Once` scenario from the previous commit - `FindNextElement(Previous)`
and `TryMoveFocus(Previous)` were wrong in a plain flat container: with focus on the
third of four buttons, the search returned a following element rather than the preceding
one, and where no following sibling existed it fell back to cycling, handing back the
last focusable element in scope (observed in the Once test as "returns the focused
element itself"). Keyboard Shift+Tab is unaffected as it uses the separate
`TabNavigation.cs` implementation.

## Tests

- `Can_Get_Previous_Element` (new): flat container, focus on target3, asserts target2 -
  locks both "skip candidates after the focused element" and "keep the closest
  preceding sibling" (not target1).
- `Can_Get_Previous_Element_Out_Of_Container_With_TabNavigation_Once`: now asserts the
  exact element (`before`) instead of only termination, per review.
- Verified both fail with the condition reverted and pass with it.
- Full `Avalonia.Base.UnitTests`: 2997 tests, 0 failed (2985 passed, 12 skipped).

## Also spotted, not changed here

The Previous/Cycle branch in `GetPreviousTabStop` calls `GetFirstFocusableElement`
where WinUI calls `GetLastFocusableElement` (wrapping backwards inside a Cycle scope
should land on the last element). Happy to fix that here too if you want it in this PR,
otherwise I can open a separate one.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(focus): previous tab stop wrapped to the first element of a Cycle scope

Third porting divergence found while comparing this code against the WinUI original
(all three sit in the same two functions): the Previous/Cycle branch in
`GetPreviousTabStop` called `GetFirstFocusableElement` where WinUI calls
`GetLastFocusableElement`:

```cpp
// WinUI, CFocusManager::GetPreviousTabStop
if (IsValidTabStopSearchCandidate(pCurrent) && GetTabNavigation(pCurrent) == KeyboardNavigationMode::Cycle)
{
    pNewTabStop = GetLastFocusableElement(pCurrent, pCurrent);
    break;
}
```

Wrapping backwards inside a Cycle scope must land on the LAST focusable element,
mirroring the forward wrap (last -> first). Taking the first element instead meant
that with focus on the first tab stop of a `TabNavigation=Cycle` container,
`FindNextElement(Previous)` returned the focused element itself and
`TryMoveFocus(Previous)` was a no-op - focus could neither leave the scope (by design)
nor wrap within it (the bug).

Observed against the keyboard-path reference implementation on a Cycle container
[a, b, c] with focus on `a`: `KeyboardNavigationHandler.GetNext(a, Previous)` returns
`c`, this code returned `a`. The forward direction already wrapped correctly
(`c` -> `a`) because the Next branch happens to use the correct element there.

New test `Previous_Wraps_To_Last_Element_In_Cycle_Container` asserts the wrap target;
verified it fails (returns the focused element) with the one-line change reverted.
Full `Avalonia.Base.UnitTests`: 2998 tests, 0 failed (2986 passed, 12 skipped).

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 src/Avalonia.Base/Input/FocusManager.cs       |  17 +-
 .../Input/InputElement_Focus.cs               | 151 ++++++++++++++++++
 2 files changed, 163 insertions(+), 5 deletions(-)

diff --git a/src/Avalonia.Base/Input/FocusManager.cs b/src/Avalonia.Base/Input/FocusManager.cs
index 5b046ab682..2abccd6b93 100644
--- a/src/Avalonia.Base/Input/FocusManager.cs
+++ b/src/Avalonia.Base/Input/FocusManager.cs
@@ -665,7 +665,7 @@ namespace Avalonia.Input
                     if (IsValidTabStopSearchCandidate(parent) && parent is InputElement p && KeyboardNavigation.GetTabNavigation(p) == KeyboardNavigationMode.Once)
                     {
                         current = parent;
-                        parent = FocusHelpers.GetFocusParent(focused);
+                        parent = FocusHelpers.GetFocusParent(current);
                         if (parent == null)
                             break;
                     }
@@ -752,7 +752,10 @@ namespace Avalonia.Input
                 {
                     if (IsValidTabStopSearchCandidate(current) && current is InputElement c && KeyboardNavigation.GetTabNavigation(c) == KeyboardNavigationMode.Cycle)
                     {
-                        newTabStop = GetFirstFocusableElement(current, current);
+                        // Wrapping backwards inside a Cycle scope lands on the LAST focusable
+                        // element, mirroring the forward wrap (last -> first).
+                        // Matches WinUI: GetLastFocusableElement(pCurrent, pCurrent).
+                        newTabStop = GetLastFocusableElement(current, current);
                         break;
                     }
 
@@ -765,7 +768,7 @@ namespace Avalonia.Input
                         else
                         {
                             current = parent;
-                            parent = FocusHelpers.GetFocusParent(focused);
+                            parent = FocusHelpers.GetFocusParent(current);
                             if (parent == null)
                                 break;
                         }
@@ -803,7 +806,7 @@ namespace Avalonia.Input
                             else
                             {
                                 current = parent;
-                                parent = FocusHelpers.GetFocusParent(focused);
+                                parent = FocusHelpers.GetFocusParent(current);
                                 if (parent == null)
                                     break;
                             }
@@ -928,7 +931,11 @@ namespace Avalonia.Input
                         }
                         else
                         {
-                            if (compareIndexResult < 0 || (((foundCurrent || currentPassed) || compareCurrentForPreviousElement) && compareIndexResult == 0))
+                            // A candidate with an equal tab index is "previous" only while the walk has not
+                            // passed the focused element yet; candidates from a nested container scan
+                            // (compareCurrentForPreviousElement) already enforced the ordering themselves.
+                            // Matches WinUI: (((!bFoundCurrent && !bCurrentPassed) || bCurrentCompare) && ...)
+                            if (compareIndexResult < 0 || (((!foundCurrent && !currentPassed) || compareCurrentForPreviousElement) && compareIndexResult == 0))
                             {
                                 if (newTabStop != null)
                                 {
diff --git a/tests/Avalonia.Base.UnitTests/Input/InputElement_Focus.cs b/tests/Avalonia.Base.UnitTests/Input/InputElement_Focus.cs
index dd2d77ca82..30fd19862e 100644
--- a/tests/Avalonia.Base.UnitTests/Input/InputElement_Focus.cs
+++ b/tests/Avalonia.Base.UnitTests/Input/InputElement_Focus.cs
@@ -912,6 +912,157 @@ namespace Avalonia.Base.UnitTests.Input
             }
         }
 
+        [Fact]
+        public void Can_Get_Next_Element_Out_Of_Container_With_TabNavigation_Once()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var inside = new Button { Focusable = true, Content = "inside" };
+                var after = new Button { Focusable = true, Content = "after" };
+
+                // The focused element has to sit at least one level below the Once container:
+                // GetFocusParent(focused) must resolve to something *deeper* than that container,
+                // otherwise the reset below happens to land on the correct node and the walk
+                // terminates by accident.
+                var once = new StackPanel
+                {
+                    [KeyboardNavigation.TabNavigationProperty] = KeyboardNavigationMode.Once,
+                    Children =
+                    {
+                        new StackPanel { Children = { inside } }
+                    }
+                };
+                var root = new TestRoot
+                {
+                    Child = new StackPanel
+                    {
+                        Children = { once, after }
+                    }
+                };
+
+                var focusManager = FocusManager.GetFocusManager(inside);
+                Assert.NotNull(focusManager);
+                inside.Focus();
+
+                // Before the fix this call never returned: on every Once hit the parent walk was
+                // reset to the focused element's parent, so it oscillated between the same two
+                // nodes forever and burned 100% CPU on the UI thread.
+                var next = focusManager.FindNextElement(NavigationDirection.Next);
+
+                Assert.Equal(after, next);
+            }
+        }
+
+        [Fact]
+        public void Can_Get_Previous_Element_Out_Of_Container_With_TabNavigation_Once()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var before = new Button { Name = "before", Focusable = true, Content = "before" };
+                var inside = new Button { Name = "inside", Focusable = true, Content = "inside" };
+
+                // Same shape as the Next case. The Once container itself must stay unfocusable,
+                // otherwise GetPreviousTabStop returns it before reaching the faulty branch.
+                var once = new StackPanel
+                {
+                    [KeyboardNavigation.TabNavigationProperty] = KeyboardNavigationMode.Once,
+                    Children =
+                    {
+                        new StackPanel { Children = { inside } }
+                    }
+                };
+                var root = new TestRoot
+                {
+                    Child = new StackPanel
+                    {
+                        Children = { before, once }
+                    }
+                };
+
+                var focusManager = FocusManager.GetFocusManager(inside);
+                Assert.NotNull(focusManager);
+                inside.Focus();
+
+                // Before the fixes this call never returned. The walk must leave the Once
+                // container and land on the element preceding it.
+                var previous = focusManager.FindNextElement(NavigationDirection.Previous);
+
+                Assert.Equal(before, previous);
+            }
+        }
+
+        [Fact]
+        public void Can_Get_Previous_Element()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var target1 = new Button { Focusable = true, Content = "1" };
+                var target2 = new Button { Focusable = true, Content = "2" };
+                var target3 = new Button { Focusable = true, Content = "3" };
+                var target4 = new Button { Focusable = true, Content = "4" };
+                var container = new StackPanel
+                {
+                    Children =
+                    {
+                        target1,
+                        target2,
+                        target3,
+                        target4
+                    }
+                };
+                var root = new TestRoot
+                {
+                    Child = container
+                };
+
+                var focusManager = FocusManager.GetFocusManager(container);
+                Assert.NotNull(focusManager);
+                target3.Focus();
+
+                // Must return the closest preceding sibling: not target1 (which merely comes
+                // first) and not target4 (which comes after the focused element).
+                var previous = focusManager.FindNextElement(NavigationDirection.Previous);
+
+                Assert.Equal(target2, previous);
+            }
+        }
+
+        [Fact]
+        public void Previous_Wraps_To_Last_Element_In_Cycle_Container()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var target1 = new Button { Focusable = true, Content = "1" };
+                var target2 = new Button { Focusable = true, Content = "2" };
+                var target3 = new Button { Focusable = true, Content = "3" };
+                var cycle = new StackPanel
+                {
+                    [KeyboardNavigation.TabNavigationProperty] = KeyboardNavigationMode.Cycle,
+                    Children =
+                    {
+                        target1,
+                        target2,
+                        target3
+                    }
+                };
+                var root = new TestRoot
+                {
+                    Child = cycle
+                };
+
+                var focusManager = FocusManager.GetFocusManager(target1);
+                Assert.NotNull(focusManager);
+                target1.Focus();
+
+                // Wrapping backwards inside a Cycle scope must land on the last focusable
+                // element, mirroring the forward wrap (last -> first). It used to take the
+                // FIRST element - the focused element itself - making Previous a no-op.
+                var previous = focusManager.FindNextElement(NavigationDirection.Previous);
+
+                Assert.Equal(target3, previous);
+            }
+        }
+
         [Fact]
         public void Can_Get_Next_Element_With_FocusedElement_Option()
         {

From e288beb238edd5cfd60d76d11bceb992f5070640 Mon Sep 17 00:00:00 2001
From: Dong Bin <14807942+rabbitism@users.noreply.github.com>
Date: Tue, 28 Jul 2026 14:57:47 +0800
Subject: [PATCH 126/196] chore: enable data validation in demo projects
 (#21868)

---
 samples/BindingDemo/App.xaml.cs           | 1 +
 samples/ControlCatalog.Desktop/Program.cs | 1 +
 2 files changed, 2 insertions(+)

diff --git a/samples/BindingDemo/App.xaml.cs b/samples/BindingDemo/App.xaml.cs
index d6ba950382..08ae7d183f 100644
--- a/samples/BindingDemo/App.xaml.cs
+++ b/samples/BindingDemo/App.xaml.cs
@@ -24,6 +24,7 @@ namespace BindingDemo
         public static AppBuilder BuildAvaloniaApp()
           => AppBuilder.Configure<App>()
                 .UsePlatformDetect()
+                .WithDataAnnotationsValidation()
 #if DEBUG
                 .WithDeveloperTools()
 #endif
diff --git a/samples/ControlCatalog.Desktop/Program.cs b/samples/ControlCatalog.Desktop/Program.cs
index 9be5c7ad52..7cdee5056a 100644
--- a/samples/ControlCatalog.Desktop/Program.cs
+++ b/samples/ControlCatalog.Desktop/Program.cs
@@ -142,6 +142,7 @@ namespace ControlCatalog.Desktop
         public static AppBuilder BuildAvaloniaApp()
             => AppBuilder.Configure<App>()
                 .UsePlatformDetect()
+                .WithDataAnnotationsValidation()
                 .UseWaylandWithFallback()
                 .With(new X11PlatformOptions
                 {

From 71ded23911c2c3565d40cbd424b42784b76bafbc Mon Sep 17 00:00:00 2001
From: Tim <47110241+timunie@users.noreply.github.com>
Date: Tue, 28 Jul 2026 13:01:17 +0200
Subject: [PATCH 127/196] Fix some issues on SelectingItemsControls when items
 or control changes visibility (#20798)

* Add failing test for #14718

* Fix for AutoScrollToSelectedItemIfNecessary

* fix failing CI build and move test to the right location

* add failing test for TabItem selection of invisble tab

* introduce a helper method to figure out which item to select

when nothing was selected beforehand and AlwaysSelected is true

* ensure selection works for invisible tabcontrol

* simplify conditions

* propose: Remove redundant logic from ColorView

The TabItem now handles the correct selection of only visible items

* fix test: Need to set SelectedIndex after adding items

* re-add unused method and make it obsolete

Otherwise API-diff will fail.

* Address review

* Update tests/Avalonia.Controls.UnitTests/TabControlTests.cs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update tests/Avalonia.Controls.UnitTests/TabControlTests.cs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Adress copilot review

* fix duplicate braces

* address review

* fix for failing tests on CarouselPage and TabbedPage

* address feedback

- adding more tests to avoid regressions

* Fix failing test: add UnitTestApplication.Start() to dedicated thread test

Agent-Logs-Url: https://github.com/timunie/Avalonia/sessions/fe2f1190-6d20-4982-8a03-1ae9b52ee701

Co-authored-by: timunie <47110241+timunie@users.noreply.github.com>

* Refactor SelectingItemsControl auto-scroll duplicate logic

Agent-Logs-Url: https://github.com/timunie/Avalonia/sessions/8895cb60-ef41-473c-972b-bad2483a5a77

Co-authored-by: timunie <47110241+timunie@users.noreply.github.com>

* Add new failing tests for AlwaysSelected mode

* Fix AlwaysSelected scenarios

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
---
 .../ColorView/ColorView.cs                    | 128 +------
 src/Avalonia.Controls/Page/CarouselPage.cs    |   9 +-
 src/Avalonia.Controls/Page/TabbedPage.cs      |   9 +-
 .../Primitives/SelectingItemsControl.cs       | 213 ++++++++++--
 .../Primitives/SelectingItemsControlTests.cs  |   1 +
 .../SelectingItemsControlTests_AutoSelect.cs  | 311 ++++++++++++++++++
 .../TabControlTests.cs                        |  37 +++
 7 files changed, 557 insertions(+), 151 deletions(-)

diff --git a/src/Avalonia.Controls.ColorPicker/ColorView/ColorView.cs b/src/Avalonia.Controls.ColorPicker/ColorView/ColorView.cs
index 100430d74f..36d5c6c4ae 100644
--- a/src/Avalonia.Controls.ColorPicker/ColorView/ColorView.cs
+++ b/src/Avalonia.Controls.ColorPicker/ColorView/ColorView.cs
@@ -1,10 +1,9 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Avalonia.Controls.Converters;
 using Avalonia.Controls.Metadata;
 using Avalonia.Controls.Primitives;
 using Avalonia.Media;
-using Avalonia.Threading;
 
 namespace Avalonia.Controls
 {
@@ -12,7 +11,6 @@ namespace Avalonia.Controls
     /// Presents a color for user editing using a spectrum, palette and component sliders.
     /// </summary>
     [TemplatePart("PART_HexTextBox", typeof(TextBox))]
-    [TemplatePart("PART_TabControl", typeof(TabControl))]
     public partial class ColorView : TemplatedControl
     {
         /// <summary>
@@ -22,7 +20,6 @@ namespace Avalonia.Controls
 
         // XAML template parts
         private TextBox?    _hexTextBox;
-        private TabControl? _tabControl;
 
         protected bool _ignorePropertyChanged = false;
 
@@ -70,106 +67,16 @@ namespace Avalonia.Controls
         }
 
         /// <summary>
-        /// Validates the tab/panel/page selection taking into account the visibility of each item
-        /// as well as the current selection.
+        /// <b>Obsolete. No-op.</b> This method is no longer used and will be removed in a future release.
         /// </summary>
         /// <remarks>
-        /// Derived controls may re-implement this based on their default style / control template
-        /// and any specialized selection needs.
+        /// This method does nothing and should not be overridden or relied upon. Validation is now handled by TabControl.
         /// </remarks>
+        // TODO-13: Remove this unused method 
+        [Obsolete("The necessary validation is now handled by the TabControl. This method will be removed in the next major release.")]
         protected virtual void ValidateSelection()
         {
-            if (_tabControl != null &&
-                _tabControl.Items != null)
-            {
-                // Determine the number of visible tab items
-                int numVisibleItems = 0;
-                foreach (var item in _tabControl.Items)
-                {
-                    if (item is Control control &&
-                        control.IsVisible)
-                    {
-                        numVisibleItems++;
-                    }
-                }
-
-                // Verify the selection
-                if (numVisibleItems > 0)
-                {
-                    object? selectedItem = null;
-
-                    if (_tabControl.SelectedItem == null &&
-                        _tabControl.ItemCount > 0)
-                    {
-                        // As a failsafe, forcefully select the first item
-                        foreach (var item in _tabControl.Items)
-                        {
-                            selectedItem = item;
-                            break;
-                        }
-                    }
-                    else
-                    {
-                        selectedItem = _tabControl.SelectedItem;
-                    }
-
-                    if (selectedItem is Control selectedControl &&
-                        selectedControl.IsVisible == false)
-                    {
-                        // Select the first visible item instead
-                        foreach (var item in _tabControl.Items)
-                        {
-                            if (item is Control control &&
-                                control.IsVisible)
-                            {
-                                selectedItem = item;
-                                break;
-                            }
-                        }
-                    }
-
-                    _tabControl.SelectedItem = selectedItem;
-                    _tabControl.IsVisible = true;
-                }
-                else
-                {
-                    // Special case when all items are hidden
-                    // If TabControl ever properly supports no selected item /
-                    // all items hidden this can be removed
-                    _tabControl.SelectedItem = null;
-                    _tabControl.IsVisible = false;
-                }
-
-                // Hide the "tab strip" if there is only one tab
-                // This allows, for example, to view only the palette
-                /*
-                var itemsPresenter = _tabControl.FindDescendantOfType<ItemsPresenter>();
-                if (itemsPresenter != null)
-                {
-                    if (numVisibleItems == 1)
-                    {
-                        itemsPresenter.IsVisible = false;
-                    }
-                    else
-                    {
-                        itemsPresenter.IsVisible = true;
-                    }
-                }
-                */
-
-                // Note that if externally the SelectedIndex is set to 4 or something
-                // outside the valid range, the TabControl will ignore it and replace it
-                // with a valid SelectedIndex. This however is not propagated back through
-                // the TwoWay binding in the control template so the SelectedIndex and
-                // SelectedIndex become out of sync.
-                //
-                // The work-around for this is done here where SelectedIndex is forcefully
-                // synchronized with whatever the TabControl property value is. This is
-                // possible since selection validation is already done by this method.
-                SetCurrentValue(SelectedIndexProperty, _tabControl.SelectedIndex);
-            }
-
-            return;
+            // Obsolete: no-op. Will be removed in a future release.
         }
 
         /// <inheritdoc/>
@@ -182,7 +89,6 @@ namespace Avalonia.Controls
             }
 
             _hexTextBox = e.NameScope.Find<TextBox>("PART_HexTextBox");
-            _tabControl = e.NameScope.Find<TabControl>("PART_TabControl");
 
             SetColorToHexTextBox();
 
@@ -193,7 +99,6 @@ namespace Avalonia.Controls
             }
 
             base.OnApplyTemplate(e);
-            ValidateSelection();
         }
 
         /// <inheritdoc/>
@@ -260,27 +165,6 @@ namespace Avalonia.Controls
                 // (Color will be coerced automatically if HsvColor changes)
                 SetCurrentValue(HsvColorProperty,  OnCoerceHsvColor(HsvColor));
             }
-            else if (change.Property == IsColorComponentsVisibleProperty ||
-                     change.Property == IsColorPaletteVisibleProperty ||
-                     change.Property == IsColorSpectrumVisibleProperty)
-            {
-                // When the property changed notification is received here the visibility
-                // of individual tab items has not yet been updated through the bindings.
-                // Therefore, the validation is delayed until after bindings update.
-                Dispatcher.UIThread.Post(() =>
-                {
-                    ValidateSelection();
-                }, DispatcherPriority.Background);
-            }
-            else if (change.Property == SelectedIndexProperty)
-            {
-                // Again, it is necessary to wait for the SelectedIndex value to
-                // be applied to the TabControl through binding before validation occurs.
-                Dispatcher.UIThread.Post(() =>
-                {
-                    ValidateSelection();
-                }, DispatcherPriority.Background);
-            }
 
             base.OnPropertyChanged(change);
         }
diff --git a/src/Avalonia.Controls/Page/CarouselPage.cs b/src/Avalonia.Controls/Page/CarouselPage.cs
index 1cf67c603f..67a7651236 100644
--- a/src/Avalonia.Controls/Page/CarouselPage.cs
+++ b/src/Avalonia.Controls/Page/CarouselPage.cs
@@ -129,6 +129,8 @@ namespace Avalonia.Controls
         {
             base.OnApplyTemplate(e);
 
+            var requestedIndex = SelectedIndex;
+
             if (_carousel != null)
             {
                 _carousel.SelectionChanged -= OnCarouselSelectionChanged;
@@ -139,7 +141,6 @@ namespace Avalonia.Controls
 
             if (_carousel != null)
             {
-                _carousel.SelectionChanged += OnCarouselSelectionChanged;
                 _carousel.ContainerPrepared += OnCarouselContainerPrepared;
                 _carousel.PageTransition = PageTransition;
                 _carousel.ItemsPanel = ItemsPanel;
@@ -147,11 +148,13 @@ namespace Avalonia.Controls
                 _carousel.IsSwipeEnabled = IsGestureEnabled;
                 _carousel.ItemsSource = (IEnumerable?)ItemsSource ?? Pages;
 
-                if (SelectedIndex >= 0)
+                if (requestedIndex >= 0)
                 {
-                    _carousel.SelectedIndex = SelectedIndex;
+                    _carousel.SelectedIndex = requestedIndex;
                 }
 
+                _carousel.SelectionChanged += OnCarouselSelectionChanged;
+
                 UpdateActivePage();
             }
         }
diff --git a/src/Avalonia.Controls/Page/TabbedPage.cs b/src/Avalonia.Controls/Page/TabbedPage.cs
index 81e30819b7..8b0a8f6609 100644
--- a/src/Avalonia.Controls/Page/TabbedPage.cs
+++ b/src/Avalonia.Controls/Page/TabbedPage.cs
@@ -193,6 +193,8 @@ namespace Avalonia.Controls
         {
             base.OnApplyTemplate(e);
 
+            var requestedIndex = SelectedIndex;
+
             if (_tabControl != null)
             {
                 _tabControl.SelectionChanged -= TabControl_SelectionChanged;
@@ -206,13 +208,14 @@ namespace Avalonia.Controls
 
             if (_tabControl != null)
             {
-                _tabControl.SelectionChanged += TabControl_SelectionChanged;
                 _tabControl.ContainerPrepared += OnContainerPrepared;
                 _tabControl.ContainerClearing += OnContainerClearing;
                 _tabControl.ItemsSource = (IEnumerable?)ItemsSource ?? Pages;
 
-                if (SelectedIndex >= 0)
-                    _tabControl.SelectedIndex = SelectedIndex;
+                if (requestedIndex >= 0)
+                    _tabControl.SelectedIndex = requestedIndex;
+
+                _tabControl.SelectionChanged += TabControl_SelectionChanged;
 
                 if (PageTransition != null)
                     _tabControl.PageTransition = PageTransition;
diff --git a/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs b/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
index 36a14f5b04..8272d1e8b2 100644
--- a/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
+++ b/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
@@ -5,7 +5,6 @@ using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using Avalonia.Controls.Platform;
 using Avalonia.Controls.Selection;
 using Avalonia.Controls.Utils;
 using Avalonia.Data;
@@ -153,6 +152,7 @@ namespace Avalonia.Controls.Primitives
         private bool _hasScrolledToSelectedItem;
         private BindingEvaluator<object?>? _selectedValueBindingEvaluator;
         private bool _isSelectionChangeActive;
+        private int _unverifiedSelectedIndex = -1;
 
         public SelectingItemsControl()
         {
@@ -466,7 +466,7 @@ namespace Avalonia.Controls.Primitives
 
             if (AlwaysSelected && SelectedIndex == -1 && ItemCount > 0)
             {
-                SelectedIndex = 0;
+                SelectedIndex = ChooseFirstVisibleAndEnabledIndex();
             }
         }
 
@@ -491,16 +491,13 @@ namespace Avalonia.Controls.Primitives
         {
             base.OnApplyTemplate(e);
 
-            void ExecuteScrollWhenLayoutUpdated(object? sender, EventArgs e)
-            {
-                LayoutUpdated -= ExecuteScrollWhenLayoutUpdated;
-
-                AutoScrollToSelectedItemIfNecessary(GetAnchorIndex());
-            }
-
             if (AutoScrollToSelectedItem)
             {
-                LayoutUpdated += ExecuteScrollWhenLayoutUpdated;
+                Dispatcher.UIThread.Post(static state =>
+                {
+                    var control = (SelectingItemsControl)state!;
+                    control.AutoScrollToSelectedItemIfNecessary(control.GetAnchorIndex());
+                }, this);
             }
         }
 
@@ -547,6 +544,18 @@ namespace Avalonia.Controls.Primitives
 
             if (Selection.AnchorIndex == index)
                 KeyboardNavigation.SetTabOnceActiveElement(this, container);
+
+            if (AlwaysSelected)
+            {
+                if (SelectedIndex == -1 && container is { IsVisible: true, IsEnabled: true })
+                {
+                    SelectedIndex = index;
+                }
+                else if (index == SelectedIndex && (!container.IsVisible || !container.IsEnabled))
+                {
+                    MoveSelectionToFirstVisibleAndEnabledItem();
+                }
+            }
         }
 
         /// <inheritdoc />
@@ -629,6 +638,13 @@ namespace Avalonia.Controls.Primitives
             {
                 AutoScrollToSelectedItemIfNecessary(GetAnchorIndex());
             }
+            else if (change.Property == IsVisibleProperty)
+            {
+                if (change.GetNewValue<bool>())
+                {
+                    AutoScrollToSelectedItemIfNecessary(GetAnchorIndex());
+                }
+            }
             else if (change.Property == SelectionModeProperty && _selection is object)
             {
                 var newValue = change.GetNewValue<SelectionMode>();
@@ -1036,6 +1052,8 @@ namespace Avalonia.Controls.Primitives
             _selectedItemsBeforeReset = null;
 
             RaiseSelectionChanged(e.DeselectedItems, e.SelectedItems);
+
+            VerifySelectedIndex();
         }
 
         /// <summary>
@@ -1055,7 +1073,7 @@ namespace Avalonia.Controls.Primitives
 
             if (AlwaysSelected && ItemsView.Count > 0)
             {
-                SelectedIndex = 0;
+                SelectedIndex = ChooseFirstVisibleAndEnabledIndex();
             }
         }
 
@@ -1183,20 +1201,53 @@ namespace Avalonia.Controls.Primitives
             }
         }
 
+        private int? _pendingAutoScrollAnchorIndex;
+
         private void AutoScrollToSelectedItemIfNecessary(int anchorIndex)
         {
-            if (AutoScrollToSelectedItem &&
-                !_hasScrolledToSelectedItem &&
-                Presenter is object &&
-                anchorIndex >= 0 &&
-                IsAttachedToVisualTree)
+            if (!(AutoScrollToSelectedItem && !_hasScrolledToSelectedItem && Presenter != null && anchorIndex >= 0 && IsAttachedToVisualTree))
             {
-                Dispatcher.UIThread.Post(state =>
-                {
-                    ScrollIntoView((int)state!);
-                    _hasScrolledToSelectedItem = true;
-                }, anchorIndex);
+                ClearPendingAutoScroll();
+                return;
+            }
+
+            if (!IsEffectivelyVisible)
+            {
+                // Defer scroll until the control becomes effectively visible.
+                _pendingAutoScrollAnchorIndex = anchorIndex;
+                IsEffectivelyVisibleChanged -= OnIsEffectivelyVisibleChangedForAutoScroll;
+                IsEffectivelyVisibleChanged += OnIsEffectivelyVisibleChangedForAutoScroll;
+                return;
             }
+
+            ClearPendingAutoScroll();
+            ScrollToAnchorIndex(anchorIndex);
+        }
+
+        private void OnIsEffectivelyVisibleChangedForAutoScroll(object? sender, EventArgs e)
+        {
+            if (!IsEffectivelyVisible || _pendingAutoScrollAnchorIndex is not { } anchorIndex)
+            {
+                return;
+            }
+
+            ClearPendingAutoScroll();
+            ScrollToAnchorIndex(anchorIndex);
+        }
+
+        private void ClearPendingAutoScroll()
+        {
+            _pendingAutoScrollAnchorIndex = null;
+            IsEffectivelyVisibleChanged -= OnIsEffectivelyVisibleChangedForAutoScroll;
+        }
+
+        private void ScrollToAnchorIndex(int anchorIndex)
+        {
+            Dispatcher.UIThread.Post(state =>
+            {
+                ScrollIntoView((int)state!);
+                _hasScrolledToSelectedItem = true;
+            }, anchorIndex);
         }
 
         /// <summary>
@@ -1243,6 +1294,122 @@ namespace Avalonia.Controls.Primitives
             }
         }
 
+        /// <summary>
+        /// Finds the first visible and enabled index in the ItemsSource.
+        /// </summary>
+        /// <param name="verified">
+        /// On return, true if the returned index was checked against a realized container or against
+        /// an item which is its own container; false if no container was realized for it and the item
+        /// had to be accepted without knowing its visibility and enabled state.
+        /// </param>
+        /// <returns>the index of the first visible and enabled item, or -1 if none found</returns>
+        private int GetFirstVisibleAndEnabledIndex(out bool verified)
+        {
+            verified = true;
+
+            var count = ItemCount;
+            if (count == 0)
+                return -1;
+
+            for (var i = 0; i < count; i++)
+            {
+                var container = ContainerFromIndex(i);
+                if (container is not null)
+                {
+                    if (container is { IsVisible: true, IsEnabled: true })
+                        return i;
+
+                    continue;
+                }
+
+                var item = ItemsView[i];
+                if (item is Visual v)
+                {
+                    if (v.IsVisible && (v is not Control c || c.IsEnabled))
+                        return i;
+                }
+                else if (item is not null)
+                {
+                    // The container isn't realized so its visibility/enabled state is unknown.
+                    verified = false;
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        private int ChooseFirstVisibleAndEnabledIndex()
+        {
+            var index = GetFirstVisibleAndEnabledIndex(out var verified);
+            _unverifiedSelectedIndex = verified ? -1 : index;
+            return index;
+        }
+
+        /// <summary>
+        /// Re-checks a selection which <see cref="ChooseFirstVisibleAndEnabledIndex"/> had to make before the container
+        /// of the selected item was realized.
+        /// </summary>
+        private void VerifySelectedIndex()
+        {
+            if (_unverifiedSelectedIndex == -1)
+                return;
+
+            if (!AlwaysSelected)
+            {
+                _unverifiedSelectedIndex = -1;
+                return;
+            }
+
+            // The selection has moved elsewhere in the meantime.
+            if (_unverifiedSelectedIndex != SelectedIndex)
+            {
+                _unverifiedSelectedIndex = -1;
+                return;
+            }
+
+            // Still not realized: ContainerForItemPreparedOverride will check it.
+            if (ContainerFromIndex(_unverifiedSelectedIndex) is not { } container)
+                return;
+
+            _unverifiedSelectedIndex = -1;
+
+            if (!container.IsVisible || !container.IsEnabled)
+            {
+                MoveSelectionToFirstVisibleAndEnabledItem();
+            }
+        }
+
+        /// <summary>
+        /// Moves selection to the first visible and enabled item, considering only realized (prepared)
+        /// containers. If no such container exists, selection is cleared to -1 so that the next
+        /// valid container prepared in <see cref="ContainerForItemPreparedOverride"/> can pick it up.
+        /// </summary>
+        private void MoveSelectionToFirstVisibleAndEnabledItem()
+        {
+            var index = GetFirstRealizedVisibleAndEnabledIndex();
+            if (index != SelectedIndex)
+            {
+                SelectedIndex = index;
+            }
+        }
+
+        /// <summary>
+        /// Finds the first realized (prepared) container that is both visible and enabled.
+        /// </summary>
+        /// <returns>The index of the first qualifying realized container, or -1 if none found.</returns>
+        private int GetFirstRealizedVisibleAndEnabledIndex()
+        {
+            var count = ItemCount;
+            for (var i = 0; i < count; i++)
+            {
+                var container = ContainerFromIndex(i);
+                if (container is { IsVisible: true, IsEnabled: true })
+                    return i;
+            }
+            return -1;
+        }
+
         private void UpdateContainerSelection()
         {
             if (Presenter?.Panel is { } panel)
@@ -1291,7 +1458,7 @@ namespace Avalonia.Controls.Primitives
 
             if (_updateState is null && AlwaysSelected && model.Count == 0)
             {
-                model.SelectedIndex = 0;
+                model.SelectedIndex = ChooseFirstVisibleAndEnabledIndex();
             }
 
             UpdateContainerSelection();
@@ -1398,7 +1565,7 @@ namespace Avalonia.Controls.Primitives
 
                 if (AlwaysSelected && SelectedIndex == -1 && ItemCount > 0)
                 {
-                    SelectedIndex = 0;
+                    SelectedIndex = ChooseFirstVisibleAndEnabledIndex();
                 }
             }
         }
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs
index 9fc6c93a5f..6c982417f1 100644
--- a/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs
@@ -2035,6 +2035,7 @@ namespace Avalonia.Controls.UnitTests.Primitives
             // https://github.com/xunit/xunit/issues/2222
             => ThreadRunHelper.RunOnDedicatedThread(() =>
             {
+                using var _ = UnitTestApplication.Start();
                 var target = new TestSelector
                 {
                     Template = Template(),
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests_AutoSelect.cs b/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests_AutoSelect.cs
index 0b58a5af43..c7863a92fa 100644
--- a/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests_AutoSelect.cs
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests_AutoSelect.cs
@@ -1,9 +1,12 @@
+using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Specialized;
+using System.Linq;
 using Avalonia.Collections;
 using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Templates;
+using Avalonia.Threading;
 using Avalonia.UnitTests;
 using Xunit;
 
@@ -118,6 +121,235 @@ namespace Avalonia.Controls.UnitTests.Primitives
             Assert.Equal("bar", target.SelectedItem);
         }
 
+        [Fact]
+        public void First_Visible_Item_Should_Be_Selected_When_First_Container_Is_Hidden()
+        {
+            // Uses own-container items (Controls) so that IsVisible can be set before preparation.
+            var target = new TestSelector
+            {
+                ItemsSource = new object[]
+                {
+                    new ListBoxItem { Content = "hidden", IsVisible = false },
+                    new ListBoxItem { Content = "visible" },
+                },
+                Template = Template(),
+            };
+
+            target.ApplyTemplate();
+            target.Presenter!.ApplyTemplate();
+
+            Assert.Equal(1, target.SelectedIndex);
+        }
+
+        [Fact]
+        public void First_Enabled_Item_Should_Be_Selected_When_First_Container_Is_Disabled()
+        {
+            var target = new TestSelector
+            {
+                ItemsSource = new object[]
+                {
+                    new ListBoxItem { Content = "disabled", IsEnabled = false },
+                    new ListBoxItem { Content = "enabled" },
+                },
+                Template = Template(),
+            };
+
+            target.ApplyTemplate();
+            target.Presenter!.ApplyTemplate();
+
+            Assert.Equal(1, target.SelectedIndex);
+        }
+
+        [Fact]
+        public void First_Visible_Item_Should_Be_Selected_When_Container_Becomes_Hidden_During_Preparation()
+        {
+            // Regression test for https://github.com/AvaloniaUI/Avalonia/pull/20798
+            // Simulates a MVVM scenario where container visibility is set by a binding applied
+            // during PrepareContainerForItemOverride (e.g. an ItemContainerTheme). Verifies that
+            // selection lands on the first truly visible container rather than an unrealized item.
+            var target = new AlwaysSelectedTestSelectorHidingFirstContainers(hiddenCount: 2)
+            {
+                ItemsSource = new[] { "item-0", "item-1", "item-2" },
+                Template = Template(),
+            };
+
+            target.ApplyTemplate();
+            target.Presenter!.ApplyTemplate();
+
+            Assert.Equal(2, target.SelectedIndex);
+        }
+
+        [Fact]
+        public void Selection_Should_Be_Cleared_When_All_Containers_Are_Hidden_During_Preparation()
+        {
+            // When all containers are made invisible during preparation (MVVM binding scenario),
+            // SelectedIndex must be -1 rather than the last container's index. Previously the
+            // selection would cascade to the last unrealized item and land on an invisible one.
+            var target = new AlwaysSelectedTestSelectorHidingFirstContainers(hiddenCount: 3)
+            {
+                ItemsSource = new[] { "item-0", "item-1", "item-2" },
+                Template = Template(),
+            };
+
+            target.ApplyTemplate();
+            target.Presenter!.ApplyTemplate();
+
+            Assert.Equal(-1, target.SelectedIndex);
+        }
+
+        [Fact]
+        public void First_Visible_Item_Should_Be_Selected_When_Items_Are_Added_To_A_Laid_Out_Control()
+        {
+            using var app = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
+
+            var items = new AvaloniaList<string>();
+            var target = new AlwaysSelectedTestSelectorHidingFirstContainers(hiddenCount: 1);
+            InitWithBeginEndInit(target, items);
+
+            items.Add("item-0");
+            items.Add("item-1");
+
+            Assert.Equal(1, target.SelectedIndex);
+            Assert.Equal("item-1", target.SelectedItem);
+        }
+
+        [Fact]
+        public void Selection_Should_Be_Cleared_When_A_Hidden_Item_Is_Added_To_A_Laid_Out_Control()
+        {
+            using var app = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
+
+            var items = new AvaloniaList<string>();
+            var target = new AlwaysSelectedTestSelectorHidingFirstContainers(hiddenCount: 1);
+            InitWithBeginEndInit(target, items);
+
+            items.Add("item-0");
+
+            Assert.Equal(-1, target.SelectedIndex);
+            Assert.Null(target.SelectedItem);
+        }
+
+        [Fact]
+        public void First_Enabled_Item_Should_Be_Selected_When_Items_Are_Added_To_A_Laid_Out_Control()
+        {
+            using var app = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
+
+            var items = new AvaloniaList<string>();
+            var target = new AlwaysSelectedTestSelectorDisablingFirstContainers(disabledCount: 1);
+            InitWithBeginEndInit(target, items);
+
+            items.Add("item-0");
+            items.Add("item-1");
+
+            Assert.Equal(1, target.SelectedIndex);
+            Assert.Equal("item-1", target.SelectedItem);
+        }
+
+        [Fact]
+        public void Selection_Should_Settle_On_The_Visible_Item_When_Items_Are_Added_To_A_Laid_Out_Control()
+        {
+            using var app = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
+
+            var items = new AvaloniaList<string>();
+            var target = new AlwaysSelectedTestSelectorHidingFirstContainers(hiddenCount: 1);
+            InitWithBeginEndInit(target, items);
+
+            var selectionChanges = new List<object?>();
+            target.SelectionChanged += (_, _) => selectionChanges.Add(target.SelectedItem);
+
+            items.Add("item-0");
+            items.Add("item-1");
+
+            Assert.Equal("item-1", selectionChanges.Last());
+            Assert.Equal("item-1", target.SelectedItem);
+        }
+
+        [Fact]
+        public void AutoScrollToSelectedItem_Should_Work_When_Becoming_Visible()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                var items = Enumerable.Range(0, 100).Select(i => $"Item {i}").ToList();
+
+                var target = new ListBox
+                {
+                    Template = new FuncControlTemplate(CreateListBoxTemplate),
+                    ItemsSource = items,
+                    ItemTemplate = new FuncDataTemplate<string>((_, _) => new TextBlock { Height = 50 }),
+                    Height = 100,
+                    ItemsPanel = new FuncTemplate<Panel?>(() => new VirtualizingStackPanel { CacheLength = 0 }),
+                    AutoScrollToSelectedItem = true,
+                    IsVisible = false
+                };
+
+                target.Width = target.Height = 100;
+                var root = new TestRoot(target);
+                root.LayoutManager.ExecuteInitialLayoutPass();
+
+                // Select item 50
+                target.SelectedIndex = 50;
+
+                // Make visible
+                target.IsVisible = true;
+                target.UpdateLayout();
+            
+                // Wait for dispatcher
+                Dispatcher.UIThread.RunJobs(null, TestContext.Current.CancellationToken);
+                target.UpdateLayout();
+
+                var scrollViewer = (ScrollViewer)target.VisualChildren[0];
+                var offset = scrollViewer.Offset.Y;
+
+                // Item 50 is at 50 * 50 = 2500. 
+                // ListBox height is 100, so it should be visible if offset is between 2400 and 2500.
+                Assert.InRange(offset, 2400, 2500);
+            }
+        }
+        
+        [Fact]
+        public void AutoScrollToSelectedItem_Should_Work_When_Ancestor_Becomes_Visible()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                var items = Enumerable.Range(0, 100).Select(i => $"Item {i}").ToList();
+
+                var target = new ListBox
+                {
+                    Template = new FuncControlTemplate(CreateListBoxTemplate),
+                    ItemsSource = items,
+                    ItemTemplate = new FuncDataTemplate<string>((_, _) => new TextBlock { Height = 50 }),
+                    Height = 100,
+                    ItemsPanel = new FuncTemplate<Panel?>(() => new VirtualizingStackPanel { CacheLength = 0 }),
+                    AutoScrollToSelectedItem = true,
+                };
+
+                target.Width = target.Height = 100;
+
+                var host = new StackPanel
+                {
+                    IsVisible = false,
+                    Children =
+                    {
+                        target,
+                    },
+                };
+
+                var root = new TestRoot(host);
+                root.LayoutManager.ExecuteInitialLayoutPass();
+
+                target.SelectedIndex = 50;
+                Assert.False(target.IsEffectivelyVisible);
+
+                host.IsVisible = true;
+                root.LayoutManager.ExecuteLayoutPass();
+                Dispatcher.UIThread.RunJobs(null, TestContext.Current.CancellationToken);
+                root.LayoutManager.ExecuteLayoutPass();
+
+                var scrollViewer = (ScrollViewer)target.VisualChildren[0];
+                var offset = scrollViewer.Offset.Y;
+                Assert.InRange(offset, 2400, 2500);
+            }
+        }
+        
         private static FuncControlTemplate Template()
         {
             return new FuncControlTemplate<SelectingItemsControl>((control, scope) =>
@@ -128,6 +360,21 @@ namespace Avalonia.Controls.UnitTests.Primitives
                 }.RegisterInNameScope(scope));
         }
 
+        /// <summary>
+        /// Initializes and lays out <paramref name="target"/> the way it's done in XAML.
+        /// This is important for some tests, as the selection model isn't committed yet while doing so.
+        /// </summary>
+        private static void InitWithBeginEndInit(SelectingItemsControl target, IEnumerable items)
+        {
+            target.BeginInit();
+            target.Template = Template();
+            target.ItemsSource = items;
+            target.EndInit();
+
+            var root = new TestRoot(target);
+            root.LayoutManager.ExecuteInitialLayoutPass();
+        }
+
         private class TestSelector : SelectingItemsControl
         {
             static TestSelector()
@@ -148,5 +395,69 @@ namespace Avalonia.Controls.UnitTests.Primitives
                     new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
             }
         }
+
+        /// <summary>
+        /// A selector with AlwaysSelected that hides the first N containers during preparation.
+        /// This simulates a MVVM scenario where an ItemContainerTheme binding sets IsVisible=false on some containers.
+        /// </summary>
+        private class AlwaysSelectedTestSelectorHidingFirstContainers(int hiddenCount) : SelectingItemsControl
+        {
+            static AlwaysSelectedTestSelectorHidingFirstContainers()
+            {
+                SelectionModeProperty.OverrideDefaultValue<AlwaysSelectedTestSelectorHidingFirstContainers>(SelectionMode.AlwaysSelected);
+            }
+
+            protected internal override void PrepareContainerForItemOverride(Control container, object? item, int index)
+            {
+                base.PrepareContainerForItemOverride(container, item, index);
+                if (index < hiddenCount)
+                    container.IsVisible = false;
+            }
+        }
+
+        /// <summary>
+        /// A selector with AlwaysSelected that disables the first N containers during preparation.
+        /// This simulates a MVVM scenario where an ItemContainerTheme binding sets IsEnabled=false on some containers.
+        /// </summary>
+        private class AlwaysSelectedTestSelectorDisablingFirstContainers(int disabledCount) : SelectingItemsControl
+        {
+            static AlwaysSelectedTestSelectorDisablingFirstContainers()
+            {
+                SelectionModeProperty.OverrideDefaultValue<AlwaysSelectedTestSelectorDisablingFirstContainers>(SelectionMode.AlwaysSelected);
+            }
+
+            protected internal override void PrepareContainerForItemOverride(Control container, object? item, int index)
+            {
+                base.PrepareContainerForItemOverride(container, item, index);
+                if (index < disabledCount)
+                    container.IsEnabled = false;
+            }
+        }
+
+        private Control CreateListBoxTemplate(TemplatedControl parent, INameScope scope)
+        {
+            return new ScrollViewer
+            {
+                Name = "PART_ScrollViewer",
+                Template = new FuncControlTemplate(CreateScrollViewerTemplate),
+                Content = new ItemsPresenter
+                {
+                    Name = "PART_ItemsPresenter",
+                    [~ItemsPresenter.ItemsPanelProperty] =
+                        ((ListBox)parent).GetObservable(ItemsControl.ItemsPanelProperty).ToBinding(),
+                }.RegisterInNameScope(scope)
+            }.RegisterInNameScope(scope);
+        }
+        private Control CreateScrollViewerTemplate(TemplatedControl parent, INameScope scope)
+        {
+            return new ScrollContentPresenter
+            {
+                Name = "PART_ContentPresenter",
+                [~ContentPresenter.ContentProperty] =
+                    parent.GetObservable(ContentControl.ContentProperty).ToBinding(),
+            }.RegisterInNameScope(scope);
+        }
+
+        
     }
 }
diff --git a/tests/Avalonia.Controls.UnitTests/TabControlTests.cs b/tests/Avalonia.Controls.UnitTests/TabControlTests.cs
index ea14eb5b2f..e10ec3fb64 100644
--- a/tests/Avalonia.Controls.UnitTests/TabControlTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TabControlTests.cs
@@ -1838,5 +1838,42 @@ namespace Avalonia.Controls.UnitTests
             // TabItem without a local value gets the TabControl template
             Assert.Same(tabControlTemplate, tabItems[1].IndicatorTemplate);
         }
+
+        [Fact]
+        public void Only_First_Visible_And_Enabled_Tab_Should_Be_Selected_By_Default()
+        {
+            var target = new TabControl
+            {
+                Template = TabControlTemplate(),
+                Items =
+                {
+                    new TabItem { Header = "hidden", IsVisible = false },
+                    new TabItem { Header = "visible" },
+                }
+            };
+
+            ApplyTemplate(target);
+
+            Assert.Equal(1, target.SelectedIndex);
+        }
+
+        [Fact]
+        public void Only_First_Enabled_Tab_Should_Be_Selected_By_Default()
+        {
+            var target = new TabControl
+            {
+                Template = TabControlTemplate(),
+                Items =
+                {
+                    new TabItem { Header = "disabled", IsEnabled = false },
+                    new TabItem { Header = "enabled" },
+                }
+            };
+
+            ApplyTemplate(target);
+
+            Assert.Equal(1, target.SelectedIndex);
+        }
+
     }
 }

From 06cf8efa0e01ee8645b513f251966b36505f1b1c Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Tue, 28 Jul 2026 13:44:41 +0200
Subject: [PATCH 128/196] Handle Padding correctly in ScrollContentPresenter
 (#21872)

* Add failing ScrollViewer tests

* Handle Padding correctly in ScrollContentPresenter
---
 .../Presenters/ScrollContentPresenter.cs      |  37 +++++--
 .../Presenters/ScrollContentPresenterTests.cs | 102 +++++++++++++++++-
 .../ScrollViewerTests.cs                      |  64 +++++++++++
 3 files changed, 193 insertions(+), 10 deletions(-)

diff --git a/src/Avalonia.Controls/Presenters/ScrollContentPresenter.cs b/src/Avalonia.Controls/Presenters/ScrollContentPresenter.cs
index 395c24824f..7bd32dcee4 100644
--- a/src/Avalonia.Controls/Presenters/ScrollContentPresenter.cs
+++ b/src/Avalonia.Controls/Presenters/ScrollContentPresenter.cs
@@ -403,9 +403,12 @@ namespace Avalonia.Controls.Presenters
                 return base.MeasureOverride(availableSize);
             }
 
+            var padding = GetChildPadding();
+            var deflated = availableSize.Deflate(padding);
+
             var constraint = new Size(
-                CanHorizontallyScroll ? double.PositiveInfinity : availableSize.Width,
-                CanVerticallyScroll ? double.PositiveInfinity : availableSize.Height);
+                CanHorizontallyScroll ? double.PositiveInfinity : deflated.Width,
+                CanVerticallyScroll ? double.PositiveInfinity : deflated.Height);
 
             Child.Measure(constraint);
 
@@ -415,7 +418,7 @@ namespace Avalonia.Controls.Presenters
                 UpdateSnapPoints();
             }
 
-            return Child.DesiredSize.Constrain(availableSize);
+            return Child.DesiredSize.Inflate(padding).Constrain(availableSize);
         }
 
         /// <inheritdoc/>
@@ -431,9 +434,12 @@ namespace Avalonia.Controls.Presenters
 
         private Size ArrangeWithAnchoring(Size finalSize)
         {
+            var padding = GetChildPadding();
+            var desiredSize = Child!.DesiredSize.Inflate(padding);
+
             var size = new Size(
-                CanHorizontallyScroll ? Math.Max(Child!.DesiredSize.Width, finalSize.Width) : finalSize.Width,
-                CanVerticallyScroll ? Math.Max(Child!.DesiredSize.Height, finalSize.Height) : finalSize.Height);
+                CanHorizontallyScroll ? Math.Max(desiredSize.Width, finalSize.Width) : finalSize.Width,
+                CanVerticallyScroll ? Math.Max(desiredSize.Height, finalSize.Height) : finalSize.Height);
 
             Vector TrackAnchor()
             {
@@ -501,13 +507,28 @@ namespace Avalonia.Controls.Presenters
             }
 
             Viewport = finalSize;
-            Extent = ComputeExtent(finalSize);
+            Extent = ComputeExtent(finalSize, padding);
             _isAnchorElementDirty = true;
 
             return finalSize;
         }
 
-        private Size ComputeExtent(Size viewportSize)
+        private Thickness GetChildPadding()
+        {
+            var padding = Padding;
+            var borderThickness = BorderThickness;
+
+            if (UseLayoutRounding)
+            {
+                var scale = LayoutHelper.GetLayoutScale(this);
+                padding = LayoutHelper.RoundLayoutThickness(padding, scale);
+                borderThickness = LayoutHelper.RoundLayoutThickness(borderThickness, scale);
+            }
+
+            return padding + borderThickness;
+        }
+
+        private Size ComputeExtent(Size viewportSize, Thickness padding)
         {
             var childMargin = Child!.Margin;
 
@@ -517,7 +538,7 @@ namespace Avalonia.Controls.Presenters
                 childMargin = LayoutHelper.RoundLayoutThickness(childMargin, scale);
             }
 
-            var extent = Child!.Bounds.Size.Inflate(childMargin);
+            var extent = Child!.Bounds.Size.Inflate(childMargin).Inflate(padding);
 
             if (MathUtilities.AreClose(extent.Width, viewportSize.Width, LayoutHelper.LayoutEpsilon))
                 extent = extent.WithWidth(viewportSize.Width);
diff --git a/tests/Avalonia.Controls.UnitTests/Presenters/ScrollContentPresenterTests.cs b/tests/Avalonia.Controls.UnitTests/Presenters/ScrollContentPresenterTests.cs
index 58906c1127..d616f23fa1 100644
--- a/tests/Avalonia.Controls.UnitTests/Presenters/ScrollContentPresenterTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Presenters/ScrollContentPresenterTests.cs
@@ -49,7 +49,7 @@ namespace Avalonia.Controls.UnitTests.Presenters
         }
 
         [Fact]
-        public void DesiredSize_Is_Content_Size_When_Smaller_Than_AvailableSize()
+        public void DesiredSize_Is_Content_Size_Plus_Padding_When_Smaller_Than_AvailableSize()
         {
             var target = new ScrollContentPresenter
             {
@@ -65,7 +65,7 @@ namespace Avalonia.Controls.UnitTests.Presenters
             target.Measure(new Size(100, 100));
             target.Arrange(new Rect(0, 0, 100, 100));
 
-            Assert.Equal(new Size(16, 16), target.DesiredSize);
+            Assert.Equal(new Size(36, 36), target.DesiredSize);
         }
 
         [Fact]
@@ -226,6 +226,104 @@ namespace Avalonia.Controls.UnitTests.Presenters
             Assert.Equal(100, child.Bounds.Width);
         }
 
+        [Fact]
+        public void Measure_Should_Deflate_AvailableSize_By_Padding()
+        {
+            var child = new TestControl();
+            var target = new ScrollContentPresenter
+            {
+                Padding = new Thickness(10),
+                Content = child
+            };
+
+            target.UpdateChild();
+            target.Measure(new Size(100, 100));
+
+            Assert.Equal(new Size(80, 80), child.AvailableSize);
+        }
+
+        [Fact]
+        public void Extent_Should_Include_Padding()
+        {
+            var target = new ScrollContentPresenter
+            {
+                CanHorizontallyScroll = true,
+                CanVerticallyScroll = true,
+                Padding = new Thickness(10),
+                Content = new Border
+                {
+                    Width = 100,
+                    Height = 100
+                }
+            };
+
+            target.UpdateChild();
+            target.Measure(new Size(50, 50));
+            target.Arrange(new Rect(0, 0, 50, 50));
+
+            Assert.Equal(new Size(50, 50), target.Viewport);
+            Assert.Equal(new Size(120, 120), target.Extent);
+        }
+
+        [Fact]
+        public void Content_Larger_Than_Viewport_Should_Not_Be_Squashed_By_Padding()
+        {
+            StackPanel content;
+            var target = new ScrollContentPresenter
+            {
+                CanVerticallyScroll = true,
+                Padding = new Thickness(10),
+                Content = content = new StackPanel
+                {
+                    Children =
+                    {
+                        new Border { Height = 50 },
+                        new Border { Height = 50 }
+                    }
+                },
+            };
+
+            target.UpdateChild();
+            target.Measure(new Size(50, 50));
+            target.Arrange(new Rect(0, 0, 50, 50));
+
+            Assert.Equal(new Rect(10, 10, 30, 100), content.Bounds);
+            Assert.Equal(new Size(50, 120), target.Extent);
+        }
+
+        [Fact]
+        public void Bottom_Padding_Should_Be_Visible_When_Scrolled_To_End()
+        {
+            StackPanel content;
+            var target = new ScrollContentPresenter
+            {
+                CanVerticallyScroll = true,
+                Padding = new Thickness(10),
+                Content = content = new StackPanel
+                {
+                    Children =
+                    {
+                        new Border { Height = 50 },
+                        new Border { Height = 50 }
+                    }
+                }
+            };
+
+            target.UpdateChild();
+            target.Measure(new Size(50, 50));
+            target.Arrange(new Rect(0, 0, 50, 50));
+
+            // Scroll to the end: extent (120) - viewport (50).
+            target.Offset = new Vector(0, 70);
+            target.Arrange(new Rect(0, 0, 50, 50));
+
+            Assert.Equal(new Vector(0, 70), target.Offset);
+
+            // The whole content is scrolled into view and the bottom padding is still visible.
+            Assert.Equal(-60, content.Bounds.Top);
+            Assert.Equal(40, content.Bounds.Bottom);
+        }
+
         [Fact]
         public void Extent_Should_Include_Content_Margin()
         {
diff --git a/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs b/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs
index 35e25f6538..752f2ce567 100644
--- a/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs
@@ -273,6 +273,69 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Vector(20, 20), target.Offset); 
         }
 
+        [Fact]
+        public void Padding_Should_Be_Included_In_Extent()
+        {
+            const int itemCount = 19;
+            const double itemHeight = 32;
+            const double padding = 50;
+            const double viewportHeight = 200;
+
+            var content = new StackPanel();
+
+            for (var i = 0; i < itemCount; ++i)
+            {
+                content.Children.Add(new Border { Height = itemHeight });
+            }
+
+            var target = new ScrollViewer
+            {
+                Template = new FuncControlTemplate<ScrollViewer>(CreateTemplate),
+                Padding = new Thickness(padding),
+                Height = viewportHeight,
+                Content = content
+            };
+
+            var root = new TestRoot(target);
+            root.LayoutManager.ExecuteInitialLayoutPass();
+
+            Assert.Equal(viewportHeight, target.Viewport.Height);
+            Assert.Equal(itemCount * itemHeight + 2 * padding, target.Extent.Height);
+
+            // The content is arranged below the top padding and isn't squashed by it.
+            Assert.Equal(padding, content.Bounds.Top);
+            Assert.Equal(itemCount * itemHeight, content.Bounds.Height);
+
+            target.ScrollToEnd();
+            root.LayoutManager.ExecuteLayoutPass();
+
+            Assert.Equal(itemCount * itemHeight + 2 * padding - viewportHeight, target.Offset.Y);
+
+            // Once scrolled to the end, the last item is fully visible and the bottom padding is still displayed below it.
+            Assert.Equal(viewportHeight - padding, content.Bounds.Bottom);
+        }
+
+        [Fact]
+        public void Padding_Should_Not_Make_Content_Scrollable_When_ScrollViewer_Is_Sized_To_Content()
+        {
+            var target = new ScrollViewer
+            {
+                Template = new FuncControlTemplate<ScrollViewer>(CreateTemplate),
+                Padding = new Thickness(50),
+                HorizontalAlignment = HorizontalAlignment.Left,
+                VerticalAlignment = VerticalAlignment.Top,
+                Content = new Border { Width = 100, Height = 100 },
+            };
+
+            var root = new TestRoot(target);
+            root.LayoutManager.ExecuteInitialLayoutPass();
+
+            // The padding is included in the desired size, so the content still fits exactly.
+            Assert.Equal(new Size(200, 200), target.Bounds.Size);
+            Assert.Equal(new Size(200, 200), target.Viewport);
+            Assert.Equal(new Size(200, 200), target.Extent);
+        }
+
         [Fact]
         public void Scroll_Does_Not_Jump_When_Viewport_Becomes_Smaller_While_Dragging_ScrollBar_Thumb()
         {
@@ -575,6 +638,7 @@ namespace Avalonia.Controls.UnitTests
                     new ScrollContentPresenter
                     {
                         Name = "PART_ContentPresenter",
+                        [~ScrollContentPresenter.PaddingProperty] = control[~ScrollViewer.PaddingProperty],
                     }.RegisterInNameScope(scope),
                     new ScrollBar
                     {

From 1bd786090ddb2e130b19bd34a2b4be963880e7ee Mon Sep 17 00:00:00 2001
From: Benedikt Stebner <Gillibald@users.noreply.github.com>
Date: Tue, 28 Jul 2026 14:07:37 +0200
Subject: [PATCH 129/196] CompositionBrush corrections (#21873)

* Add failing tests for composition gradient brush change tracking

Three defects in the unreleased CompositionBrush surface:

- Replacing GradientStops after the first commit never reaches the
  server: the hand-written property registers nothing for
  serialization, so the change only ships once an unrelated tracked
  property dirties the brush.
- SpreadMethod has the same gap.
- A mutable Media.GradientStop crosses the batch by reference and the
  render thread then reads a UI-thread object at replay time.
- A CompositionBrush resolves its server object for any compositor,
  so a foreign compositor ends up sharing a resource across render
  loops.

* Track composition gradient brush changes and respect compositor affinity

- GradientStops and SpreadMethod now register for serialization when
  assigned, so changes made after the first commit reach the server
  without waiting for an unrelated tracked property to dirty the
  brush. In-place list mutation stays untracked and is documented as
  requiring re-assignment.
- Non-composition gradient stops are snapshotted to
  ImmutableGradientStop at serialization time instead of crossing the
  batch by reference, since the render thread reads the server list at
  replay time.
- Resolving a CompositionBrush for a different compositor now throws
  instead of silently wiring one server resource into two render
  loops. Transient contexts without a compositor keep receiving the
  client brush unchanged.
---
 .../Composition/Brushes/CompositionBrush.cs   | 47 +++++++++-
 .../Drawing/ServerResourceHelperExtensions.cs | 11 +++
 .../Composition/CompositionBrushTests.cs      | 94 +++++++++++++++++++
 3 files changed, 149 insertions(+), 3 deletions(-)
 create mode 100644 tests/Avalonia.Base.UnitTests/Composition/CompositionBrushTests.cs

diff --git a/src/Avalonia.Base/Rendering/Composition/Brushes/CompositionBrush.cs b/src/Avalonia.Base/Rendering/Composition/Brushes/CompositionBrush.cs
index bb356bab81..4cc67b4cee 100644
--- a/src/Avalonia.Base/Rendering/Composition/Brushes/CompositionBrush.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Brushes/CompositionBrush.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using Avalonia.Media;
+using Avalonia.Media.Immutable;
 using Avalonia.Rendering.Composition;
 using Avalonia.Rendering.Composition.Server;
 using Avalonia.Rendering.Composition.Transport;
@@ -42,10 +43,47 @@ partial class CompositionConicGradientBrush : IConicGradientBrush
 
 public abstract partial class CompositionGradientBrush : CompositionBrush, IGradientBrush
 {
+    private List<IGradientStop> _gradientStops = [];
+    private GradientSpreadMethod _spreadMethod;
+
     internal new ServerCompositionGradientBrush Server { get; }
-    public List<IGradientStop> GradientStops { get; set; } = [];
+
+    /// <summary>
+    /// The gradient stops. Mutations of the list itself are not tracked - assign
+    /// the property to ship in-place edits made after a commit. Stops created via
+    /// <see cref="Compositor.CreateGradientStop(double, Media.Color)"/> stay live
+    /// on the server and animate individually; other stops are snapshotted at
+    /// serialization time.
+    /// </summary>
+    public List<IGradientStop> GradientStops
+    {
+        get => _gradientStops;
+        set
+        {
+            if (ReferenceEquals(_gradientStops, value))
+                return;
+            _gradientStops = value;
+            RegisterForSerialization();
+        }
+    }
+
     IReadOnlyList<IGradientStop> IGradientBrush.GradientStops => GradientStops;
-    public GradientSpreadMethod SpreadMethod { get; set; }
+
+    /// <summary>
+    /// How the gradient repeats outside the stop range.
+    /// </summary>
+    public GradientSpreadMethod SpreadMethod
+    {
+        get => _spreadMethod;
+        set
+        {
+            if (_spreadMethod == value)
+                return;
+            _spreadMethod = value;
+            RegisterForSerialization();
+        }
+    }
+
     partial void OnRootChanged();
     partial void OnRootChanging();
 
@@ -63,7 +101,10 @@ public abstract partial class CompositionGradientBrush : CompositionBrush, IGrad
             if (stop is CompositionGradientStop comp)
                 writer.WriteObject(comp.Server);
             else
-                writer.WriteObject(stop);
+                // A mutable UI-thread stop must not cross to the render thread
+                // by reference; ship its current values instead.
+                writer.WriteObject(stop as ImmutableGradientStop
+                    ?? new ImmutableGradientStop(stop.Offset, stop.Color));
         }
     }
 }
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs
index bde92bcb94..4cb1ec181a 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/ServerResourceHelperExtensions.cs
@@ -20,7 +20,14 @@ static class ServerResourceHelperExtensions
         if (brush is ICompositionRenderResource<IBrush> resource)
             return resource.GetForCompositor(compositor);
         if (brush is CompositionBrush compositionBrush)
+        {
+            // The server object belongs to its own compositor's render loop;
+            // handing it to another compositor would share one resource across
+            // two render threads.
+            if (compositionBrush.Compositor != compositor)
+                ThrowForeignCompositor(compositionBrush);
             return compositionBrush.Server;
+        }
         ThrowNotCompatible(brush);
         return null;
     }
@@ -42,6 +49,10 @@ static class ServerResourceHelperExtensions
     [MethodImpl(MethodImplOptions.NoInlining), DoesNotReturn]
     static void ThrowNotCompatible(object o) =>
         throw new InvalidOperationException(o.GetType() + " is not compatible with composition");
+
+    [MethodImpl(MethodImplOptions.NoInlining), DoesNotReturn]
+    static void ThrowForeignCompositor(CompositionObject o) =>
+        throw new InvalidOperationException(o.GetType() + " belongs to a different compositor");
     
     public static ITransform? GetServer(this ITransform? transform, Compositor? compositor)
     {
diff --git a/tests/Avalonia.Base.UnitTests/Composition/CompositionBrushTests.cs b/tests/Avalonia.Base.UnitTests/Composition/CompositionBrushTests.cs
new file mode 100644
index 0000000000..c26c77199c
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Composition/CompositionBrushTests.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Media;
+using Avalonia.Media.Immutable;
+using Avalonia.Rendering;
+using Avalonia.Rendering.Composition;
+using Avalonia.Rendering.Composition.Drawing;
+using Avalonia.Threading;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Composition;
+
+public class CompositionBrushTests : ScopedTestBase
+{
+    [Fact]
+    public void Replacing_The_Gradient_Stop_List_After_A_Commit_Should_Reach_The_Server()
+    {
+        using var services = new CompositorTestServices();
+        var compositor = services.Compositor;
+
+        var brush = compositor.CreateLinearGradientBrush();
+        brush.GradientStops.Add(compositor.CreateGradientStop(0, Colors.Red));
+        services.RunJobs();
+
+        Assert.Single(brush.Server.GradientStops);
+
+        brush.GradientStops = new List<IGradientStop>
+        {
+            compositor.CreateGradientStop(0, Colors.Red),
+            compositor.CreateGradientStop(1, Colors.Blue),
+        };
+        services.RunJobs();
+
+        Assert.Equal(2, brush.Server.GradientStops.Count);
+    }
+
+    [Fact]
+    public void Changing_SpreadMethod_After_A_Commit_Should_Reach_The_Server()
+    {
+        using var services = new CompositorTestServices();
+        var compositor = services.Compositor;
+
+        var brush = compositor.CreateLinearGradientBrush();
+        brush.GradientStops.Add(compositor.CreateGradientStop(0, Colors.Red));
+        services.RunJobs();
+
+        Assert.Equal(GradientSpreadMethod.Pad, brush.Server.SpreadMethod);
+
+        brush.SpreadMethod = GradientSpreadMethod.Repeat;
+        services.RunJobs();
+
+        Assert.Equal(GradientSpreadMethod.Repeat, brush.Server.SpreadMethod);
+    }
+
+    [Fact]
+    public void Mutable_Gradient_Stops_Should_Be_Snapshotted_For_The_Server()
+    {
+        using var services = new CompositorTestServices();
+        var compositor = services.Compositor;
+
+        var mutableStop = new GradientStop(Colors.Red, 0);
+        var brush = compositor.CreateLinearGradientBrush();
+        brush.GradientStops.Add(mutableStop);
+        services.RunJobs();
+
+        // The render thread reads the server list at replay time, so a mutable
+        // UI-thread stop must not cross the batch by reference.
+        var serverStop = Assert.Single(brush.Server.GradientStops);
+        Assert.NotSame(mutableStop, serverStop);
+        Assert.Equal(Colors.Red, serverStop.Color);
+        Assert.Equal(0, serverStop.Offset);
+    }
+
+    [Fact]
+    public void Using_A_Composition_Brush_With_A_Foreign_Compositor_Should_Throw()
+    {
+        using var services = new CompositorTestServices();
+
+        var brush = services.Compositor.CreateSolidColorBrush(Colors.Red);
+
+        var foreign = new Compositor(RenderLoop.FromTimer(services.Timer), null,
+            true, new DispatcherCompositorScheduler(), true, Dispatcher.UIThread);
+
+        // A composition brush's server object belongs to its own compositor's
+        // render loop; handing it to another compositor's stream would let two
+        // render threads race over one resource.
+        Assert.Throws<InvalidOperationException>(() => brush.GetServer(foreign));
+
+        // A transient context without a compositor keeps the client brush and
+        // draws its static values, so no affinity applies there.
+        Assert.Same(brush, brush.GetServer(null));
+    }
+}

From 82d9395f8797114687246f6fa59ee85fb85a90ad Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Tue, 28 Jul 2026 14:21:55 +0200
Subject: [PATCH 130/196] Report disposed WaylandEglWsiSurface render target
 (#21857)

---
 .../Rendering/WaylandEglWsiSurface.cs         | 22 ++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs
index eac37ffc37..9073d984ff 100644
--- a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs
@@ -37,16 +37,27 @@ internal sealed class WaylandEglWsiSurface : EglGlPlatformSurfaceBase, IPlatform
         private IntPtr _eglWindow;
         private EglSurface? _eglSurface;
         private PixelSize _currentSize;
+        private bool _disposed;
 
         public RenderTarget(WSurface surface, EglContext context) : base(context)
         {
             _surface = surface;
+            _surface.RegisterRenderTarget(this);
         }
-        
+
         protected override bool SkipWaits => true;
 
-        public override PlatformRenderTargetState State =>
-            IsCorrupted ? PlatformRenderTargetState.Corrupted : _surface.State;
+        public override PlatformRenderTargetState State
+        {
+            get
+            {
+                if (_disposed)
+                    return PlatformRenderTargetState.Disposed;
+                if (IsCorrupted)
+                    return PlatformRenderTargetState.Corrupted;
+                return _surface.State;
+            }
+        }
 
         public override IGlPlatformSurfaceRenderingSession BeginDrawCore(IRenderTarget.RenderTargetSceneInfo sceneInfo)
         {
@@ -89,6 +100,11 @@ internal sealed class WaylandEglWsiSurface : EglGlPlatformSurfaceBase, IPlatform
 
         public override void Dispose()
         {
+            if (_disposed)
+                return;
+
+            _disposed = true;
+            _surface.UnregisterRenderTarget(this);
             _eglSurface?.Dispose();
             _eglSurface = null;
             if (_eglWindow != IntPtr.Zero)

From 5495737014b3836dc3228da8563f6549c238e3ff Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Tue, 28 Jul 2026 15:40:40 +0200
Subject: [PATCH 131/196] Allow single parameter with any type when binding to
 method (#21867)

* Allow single parameter with any type when binding to method

* Port method binding logic to ReflectionBinding

* Don't depend on the order of methods

* Handle overrides properly

* Fix nullability warning
---
 .../Plugins/ReflectionMethodAccessorPlugin.cs | 124 +++++++--
 .../XamlIlBindingPathHelper.cs                |  97 ++++++-
 .../XamlIlTrampolineBuilder.cs                |   6 +-
 .../Data/BindingTests_Method.cs               | 225 +++++++++++++----
 .../CompiledBindingExtensionTests.cs          | 239 ++++++++++++++++--
 5 files changed, 574 insertions(+), 117 deletions(-)

diff --git a/src/Avalonia.Base/Data/Core/Plugins/ReflectionMethodAccessorPlugin.cs b/src/Avalonia.Base/Data/Core/Plugins/ReflectionMethodAccessorPlugin.cs
index d2e6f23e29..5213a2180f 100644
--- a/src/Avalonia.Base/Data/Core/Plugins/ReflectionMethodAccessorPlugin.cs
+++ b/src/Avalonia.Base/Data/Core/Plugins/ReflectionMethodAccessorPlugin.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 
@@ -10,10 +11,9 @@ namespace Avalonia.Data.Core.Plugins
     [RequiresDynamicCode(TrimmingMessages.ExpressionNodeRequiresDynamicCodeMessage)]
     internal class ReflectionMethodAccessorPlugin : IPropertyAccessorPlugin
     {
-        private readonly Dictionary<(Type, string), MethodInfo?> _methodLookup =
-            new Dictionary<(Type, string), MethodInfo?>();
+        private readonly Dictionary<(Type, string), MethodLookupResult> _methodLookup = new();
 
-        public bool Match(object obj, string methodName) => GetFirstMethodWithName(obj.GetType(), methodName) != null;
+        public bool Match(object obj, string methodName) => GetMethod(obj.GetType(), methodName).IsMatch;
 
         public IPropertyAccessor? Start(WeakReference<object?> reference, string methodName)
         {
@@ -23,63 +23,133 @@ namespace Avalonia.Data.Core.Plugins
             if (!reference.TryGetTarget(out var instance) || instance is null)
                 return null;
 
-            var method = GetFirstMethodWithName(instance.GetType(), methodName);
+            var result = GetMethod(instance.GetType(), methodName);
 
-            if (method is not null)
+            if (result.Method is { } method)
             {
                 return new Accessor(reference, method);
             }
             else
             {
-                var message = $"Could not find CLR method '{methodName}' on '{instance}'";
-                var exception = new MissingMemberException(message);
+                Exception exception = result.Error is { } error
+                    ? new AmbiguousMatchException(error)
+                    : new MissingMemberException($"Could not find CLR method '{methodName}' on '{instance}'");
                 return new PropertyError(new BindingNotification(exception, BindingErrorType.Error));
             }
         }
 
-        private MethodInfo? GetFirstMethodWithName(
+        private MethodLookupResult GetMethod(
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type type, string methodName)
         {
             var key = (type, methodName);
 
-            if (!_methodLookup.TryGetValue(key, out var methodInfo))
+            if (!_methodLookup.TryGetValue(key, out var result))
             {
-                methodInfo = TryFindAndCacheMethod(type, methodName);
+                result = FindBestCommandMethod(type, methodName);
+                _methodLookup.Add(key, result);
             }
 
-            return methodInfo;
+            return result;
         }
 
-        private MethodInfo? TryFindAndCacheMethod(
+        /// <summary>
+        /// Finds the method named <paramref name="methodName"/> which can be bound to a command.
+        /// </summary>
+        /// <remarks>
+        /// Priority:
+        ///  1. One parameter method
+        ///    1a. Object parameter (amongst several overloads)
+        ///    1b. Single method with one parameter
+        ///  2. Zero parameters method
+        /// </remarks>
+        private static MethodLookupResult FindBestCommandMethod(
             [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods)] Type type, string methodName)
         {
-            MethodInfo? found = null;
-
             const BindingFlags bindingFlags =
                 BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance;
 
-            var methods = type.GetMethods(bindingFlags);
+            List<MethodInfo>? candidates = null;
 
-            foreach (var methodInfo in methods)
+            foreach (var methodInfo in type.GetMethods(bindingFlags))
             {
                 if (methodInfo.Name == methodName)
+                    (candidates ??= []).Add(methodInfo);
+            }
+
+            if (candidates is null)
+                return default;
+
+            MethodInfo? zeroParamCandidate = null;
+            Dictionary<Type, MethodInfo>? oneParamCandidates = null;
+
+            foreach (var candidate in candidates)
+            {
+                var parameters = candidate.GetParameters();
+
+                switch (parameters.Length)
                 {
-                    var parameters = methodInfo.GetParameters();
-                    if (parameters.Length == 1 && parameters[0].ParameterType == typeof(object))
-                    {
-                        found = methodInfo;
+                    case 0:
+                        zeroParamCandidate = GetMostDerived(zeroParamCandidate, candidate);
+                        break;
+
+                    case 1:
+                        // Reflection can return several methods with the same parameter type when one hides another:
+                        // only keep the most derived one, so that overridden or hidden methods are handled properly.
+                        var parameterType = parameters[0].ParameterType;
+                        oneParamCandidates ??= new Dictionary<Type, MethodInfo>();
+                        oneParamCandidates[parameterType] = GetMostDerived(oneParamCandidates.GetValueOrDefault(parameterType), candidate);
                         break;
-                    }
-                    else if (parameters.Length == 0)
-                    {
-                        found = methodInfo;
-                    }
                 }
             }
 
-            _methodLookup.Add((type, methodName), found);
+            if (oneParamCandidates is not null)
+            {
+                // Object parameter always wins
+                if (oneParamCandidates.TryGetValue(typeof(object), out var objectParamCandidate))
+                    return new MethodLookupResult(objectParamCandidate, null);
+
+                if (oneParamCandidates.Count == 1)
+                    return new MethodLookupResult(oneParamCandidates.Values.First(), null);
+
+                var parameterTypes = oneParamCandidates.Keys
+                    .Select(t => $"'{t.FullName}'")
+                    .OrderBy(s => s, StringComparer.Ordinal)
+                    .ToArray();
+
+                return new MethodLookupResult(
+                    null,
+                    $"Unable to resolve method of name '{methodName}' on type '{type.FullName}'. " +
+                    $"Found {parameterTypes.Length} overloads accepting one parameter: {string.Join(", ", parameterTypes)}. " +
+                    "Expected either a single overload with one parameter, or an overload accepting System.Object.");
+            }
+
+            if (zeroParamCandidate is { } found)
+                return new MethodLookupResult(found, null);
+
+            return new MethodLookupResult(
+                null,
+                $"Unable to resolve method of name '{methodName}' on type '{type.FullName}'. " +
+                $"Found {candidates.Count} overloads accepting more than one parameter. " +
+                "Expected a method with zero or one parameter.");
+        }
 
-            return found;
+        private static MethodInfo GetMostDerived(MethodInfo? existing, MethodInfo candidate)
+        {
+            if (existing is null)
+                return candidate;
+
+            return existing.DeclaringType is { } existingType &&
+                   candidate.DeclaringType is { } candidateType &&
+                   existingType != candidateType && existingType.IsAssignableFrom(candidateType) ?
+                candidate :
+                existing;
+        }
+
+        private readonly struct MethodLookupResult(MethodInfo? method, string? error)
+        {
+            public MethodInfo? Method { get; } = method;
+            public string? Error { get; } = error;
+            public bool IsMatch => Method is not null || Error is not null;
         }
 
         [RequiresDynamicCode(TrimmingMessages.ExpressionNodeRequiresDynamicCodeMessage)]
diff --git a/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlBindingPathHelper.cs b/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlBindingPathHelper.cs
index 84af961431..1046658bc8 100644
--- a/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlBindingPathHelper.cs
+++ b/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlBindingPathHelper.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection.Emit;
@@ -212,23 +213,10 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                             }
                             else if (GetAllDefinedMethods(targetType)
                                          .Where(p => p.Name == propName.PropertyName)
-                                         .OrderByDescending(m => m.Parameters.Count)
                                          .ToArray()
                                      is { Length: > 0 } methodCandidates)
                             {
-                                var objType = context.Configuration.WellKnownTypes.Object;
-                                var candidate = methodCandidates
-                                    .FirstOrDefault(m => m.Parameters.Count == 0
-                                                         || (m.Parameters.Count == 1 &&
-                                                             m.Parameters[0].Equals(objType)));
-                                if (candidate is null)
-                                {
-                                    throw new XamlX.XamlTransformException(
-                                        $"Unable to resolve method of name '{propName.PropertyName}' on type '{targetType}'." +
-                                        $"Expected method with no parameters or a single object overload.",
-                                        lineInfo);
-                                }
-            
+                                var candidate = GetBestCommandMethod(methodCandidates, propName.PropertyName, targetType);
                                 nodes.Add(new XamlIlClrMethodPathElementNode(candidate, context.Configuration.WellKnownTypes.Delegate, propName.AcceptsNull));
                             }
                             else
@@ -453,6 +441,67 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                     }
                 }
             }
+
+            // Priority:
+            //  1. One parameter method
+            //    1a. Object parameter (amongst several overloads)
+            //    1b. Single method with one parameter
+            //  2. Zero parameters method
+            IXamlMethod GetBestCommandMethod(IXamlMethod[] candidates, string name, IXamlType targetType)
+            {
+                Debug.Assert(candidates.Length > 0);
+
+                IXamlMethod? zeroParamCandidate = null;
+                HashSet<IXamlMethod>? oneParamCandidates = null;
+
+                foreach (var candidate in candidates)
+                {
+                    Debug.Assert(candidate.Name == name);
+
+                    switch (candidate.Parameters.Count)
+                    {
+                        case 0:
+                            zeroParamCandidate ??= candidate;
+                            break;
+
+                        case 1:
+                            // Object parameter always wins
+                            if (candidate.Parameters[0].Is("System", "Object"))
+                                return candidate;
+
+                            // Our candidates are ordered with the most derived class first:
+                            // By adding the first candidate for a given parameter type, we automatically handle overridden or hidden methods.
+                            oneParamCandidates ??= new HashSet<IXamlMethod>(SingleParameterTypeXamlTypeComparer.Instance);
+                            oneParamCandidates.Add(candidate);
+                            break;
+                    }
+                }
+
+                if (oneParamCandidates is not null)
+                {
+                    Debug.Assert(oneParamCandidates.Count > 0);
+
+                    if (oneParamCandidates.Count == 1)
+                        return oneParamCandidates.First();
+
+                    var parameterTypes = oneParamCandidates
+                        .Select(m => $"'{m.Parameters[0].FullName}'")
+                        .OrderBy(s => s, StringComparer.Ordinal)
+                        .ToArray();
+
+                    throw new XamlTransformException(
+                        $"Unable to resolve method of name '{name}' on type '{targetType}'. " +
+                        $"Found {parameterTypes.Length} overloads accepting one parameter: {string.Join(", ", parameterTypes)}. " +
+                        "Expected either a single overload with one parameter, or an overload accepting System.Object.",
+                        lineInfo);
+                }
+
+                return zeroParamCandidate ?? throw new XamlTransformException(
+                    $"Unable to resolve method of name '{name}' on type '{targetType}'. " +
+                    $"Found {candidates.Length} overloads accepting more than one parameter. " +
+                    $"Expected a method with zero or one parameter.",
+                    lineInfo);
+            }
         }
 
         private static void EmitPropertyCall(XamlIlEmitContext context, IXamlILEmitter codeGen, bool acceptsNull)
@@ -1064,6 +1113,26 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                 }
             }
         }
+
+        private sealed class SingleParameterTypeXamlTypeComparer : IEqualityComparer<IXamlMethod>
+        {
+            public static SingleParameterTypeXamlTypeComparer Instance { get; } = new();
+
+            public bool Equals(IXamlMethod? x, IXamlMethod? y)
+            {
+                Debug.Assert(x is { Parameters.Count: 1 });
+                Debug.Assert(y is { Parameters.Count: 1 });
+
+                return x!.Parameters[0].Equals(y!.Parameters[0]);
+            }
+
+            public int GetHashCode(IXamlMethod obj)
+            {
+                Debug.Assert(obj.Parameters.Count == 1);
+
+                return obj.Parameters[0].GetHashCode();
+            }
+        }
     }
 
     interface IXamlIlBindingPathNode : IXamlAstValueNode
diff --git a/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlTrampolineBuilder.cs b/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlTrampolineBuilder.cs
index 5245fa7d3c..b0f4db068a 100644
--- a/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlTrampolineBuilder.cs
+++ b/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlTrampolineBuilder.cs
@@ -48,9 +48,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
             }
             if (executeMethod.Parameters.Count != 0)
             {
-                Debug.Assert(executeMethod.Parameters.Count == 1
-                             && executeMethod.Parameters[0] == context.Configuration.WellKnownTypes.Object);
+                Debug.Assert(executeMethod.Parameters.Count == 1);
                 gen.Ldarg(1);
+
+                if (!executeMethod.Parameters[0].Is("System", "Object"))
+                    gen.Unbox_Any(executeMethod.Parameters[0]);
             }
             gen.EmitCall(executeMethod, swallowResult: true);
             gen.Ret();
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Data/BindingTests_Method.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Data/BindingTests_Method.cs
index a1ab150366..ca5cb6eb04 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Data/BindingTests_Method.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Data/BindingTests_Method.cs
@@ -1,7 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using Avalonia.Controls;
 using Avalonia.Input;
+using Avalonia.Logging;
 using Avalonia.UnitTests;
 using Xunit;
 
@@ -33,28 +35,139 @@ namespace Avalonia.Markup.Xaml.UnitTests.Data
             }
         }
 
+        [Theory]
+        [InlineData("ObjectMethod", "<x:String>hello</x:String>", "Called ObjectMethod with hello")]
+        [InlineData("StringMethod", "<x:String>hello</x:String>", "Called StringMethod with hello")]
+        [InlineData("Int32Method", "<x:Int32>42</x:Int32>", "Called Int32Method with 42")]
+        [InlineData("Int32Method", "<x:String>42</x:String>", "Called Int32Method with 42")]
+        [InlineData("VirtualObjectMethod", "<x:String>hello</x:String>", "Called VirtualObjectMethod with hello")]
+        [InlineData("VirtualStringMethod", "<x:String>hello</x:String>", "Called VirtualStringMethod with hello")]
+        [InlineData("VirtualStringMethod", "<x:Null />", "Called VirtualStringMethod with ")]
+        [InlineData("VirtualInt32Method", "<x:Int32>42</x:Int32>", "Called VirtualInt32Method with 42")]
+        [InlineData("MethodWithNewSlot", "<x:Int32>42</x:Int32>", "Called MethodWithNewSlot with 42")]
+        public void Binding_Method_With_Parameter_To_Command_Uses_Single_Parameter_Overload(
+            string methodName,
+            string xamlParameter,
+            string expected)
+        {
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+            var window = (Window)AvaloniaRuntimeXamlLoader.Load(
+                $$"""
+                  <Window xmlns='https://github.com/avaloniaui'
+                          xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+                      <Button Name='button' Command='{Binding {{methodName}}}'>
+                        <Button.CommandParameter>
+                          {{xamlParameter}}
+                        </Button.CommandParameter>
+                      </Button>
+                  </Window>
+                  """);
+            var button = window.GetControl<Button>("button");
+            var vm = new ViewModel();
+
+            button.DataContext = vm;
+            window.ApplyTemplate();
+
+            Assert.NotNull(button.Command);
+            PerformClick(button);
+            Assert.Equal(expected, vm.Value);
+        }
+
         [Fact]
-        public void Binding_Method_With_Parameter_To_Command_Works()
+        public void Binding_Method_With_Parameter_To_Command_Prefers_Object_Overload()
         {
-            using (UnitTestApplication.Start(TestServices.StyledWindow))
-            {
-                var xaml = @"
-<Window xmlns='https://github.com/avaloniaui'
-        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
-        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.Xaml;assembly=Avalonia.Markup.Xaml.UnitTests'>
-    <Button Name='button' Command='{Binding Method1}' CommandParameter='5'/>
-</Window>";
-                var window = (Window)AvaloniaRuntimeXamlLoader.Load(xaml);
-                var button = window.GetControl<Button>("button");
-                var vm = new ViewModel();
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+            var window = (Window)AvaloniaRuntimeXamlLoader.Load(
+                """
+                <Window xmlns='https://github.com/avaloniaui'
+                        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+                    <Button Name='button' Command='{Binding MethodWithOverloads}' CommandParameter='foo' />
+                </Window>
+                """);
+            var button = window.GetControl<Button>("button");
+            var vm = new ViewModel();
+
+            button.DataContext = vm;
+            window.ApplyTemplate();
+
+            Assert.NotNull(button.Command);
+            PerformClick(button);
+            Assert.Equal("Called MethodWithOverloads with Object foo", vm.Value);
+        }
 
-                button.DataContext = vm;
-                window.ApplyTemplate();
+        [Fact]
+        public void Binding_Method_With_Parameter_To_Command_Fails_With_Multiple_Single_Parameter_Overloads_Without_Object()
+        {
+            AssertBindingFails(
+                "MethodWithOverloads2",
+                "Unable to resolve method of name 'MethodWithOverloads2' on type " +
+                "'Avalonia.Markup.Xaml.UnitTests.Data.BindingTests_Method+ViewModel'. " +
+                "Found 2 overloads accepting one parameter: 'System.Int32', 'System.String'. " +
+                "Expected either a single overload with one parameter, or an overload accepting System.Object.");
+        }
 
-                Assert.NotNull(button.Command);
-                PerformClick(button);
-                Assert.Equal("Called 5", vm.Value);
-            }
+        [Fact]
+        public void Binding_Method_With_Parameter_To_Command_Uses_Parameterless_Overload_When_No_Overloads_With_Parameter_Exist()
+        {
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+            var window = (Window)AvaloniaRuntimeXamlLoader.Load(
+                """
+                <Window xmlns='https://github.com/avaloniaui'
+                        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+                    <Button Name='button' Command='{Binding MethodWithOverloads3}' CommandParameter='foo' />
+                </Window>
+                """);
+            var button = window.GetControl<Button>("button");
+            var vm = new ViewModel();
+
+            button.DataContext = vm;
+            window.ApplyTemplate();
+
+            Assert.NotNull(button.Command);
+            PerformClick(button);
+            Assert.Equal("Called MethodWithOverloads3 without parameter", vm.Value);
+        }
+
+        [Fact]
+        public void Binding_Method_With_Parameter_To_Command_Fails_Without_Valid_Overloads()
+        {
+            AssertBindingFails(
+                "MethodWithOverloads4",
+                "Unable to resolve method of name 'MethodWithOverloads4' on type " +
+                "'Avalonia.Markup.Xaml.UnitTests.Data.BindingTests_Method+ViewModel'. " +
+                "Found 2 overloads accepting more than one parameter. " +
+                "Expected a method with zero or one parameter.");
+        }
+
+        private static void AssertBindingFails(string methodName, string expectedError)
+        {
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+            var errors = new List<string>();
+            using var logSink = TestLogSink.Start((level, area, _, template, values) =>
+            {
+                if (level >= LogEventLevel.Warning && area == LogArea.Binding)
+                    errors.Add(template + " " + string.Join(" ", values));
+            });
+
+            var window = (Window)AvaloniaRuntimeXamlLoader.Load(
+                $$"""
+                  <Window xmlns='https://github.com/avaloniaui'
+                          xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+                      <Button Name='button' Command='{Binding {{methodName}}}' CommandParameter='foo' />
+                  </Window>
+                  """);
+            var button = window.GetControl<Button>("button");
+            var vm = new ViewModel();
+
+            button.DataContext = vm;
+            window.ApplyTemplate();
+
+            Assert.Null(button.Command);
+            Assert.Contains(errors, error => error.Contains(expectedError, StringComparison.Ordinal));
         }
 
         [Fact]
@@ -141,28 +254,6 @@ namespace Avalonia.Markup.Xaml.UnitTests.Data
             }
         }
 
-        [Fact]
-        public void Binding_Method_Preserves_Correct_Order()
-        {
-            using (UnitTestApplication.Start(TestServices.StyledWindow))
-            {
-                var xaml = @"
-<Window xmlns='https://github.com/avaloniaui'
-        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
-        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.Xaml;assembly=Avalonia.Markup.Xaml.UnitTests'>
-    <Button Name='button' Command='{Binding Method3}' CommandParameter='5'/>
-</Window>";
-                var window = (Window)AvaloniaRuntimeXamlLoader.Load(xaml);
-                var button = window.GetControl<Button>("button");
-                var vm = new ViewModel();
-
-                button.DataContext = vm;
-                window.ApplyTemplate();
-                PerformClick(button);
-                Assert.Equal("Called Method with parameter of object type. Argument value is 5", vm.Value);
-            }
-        }
-
         [Fact]
         public void Binding_Method_To_Command_Collected()
         {
@@ -217,15 +308,57 @@ namespace Avalonia.Markup.Xaml.UnitTests.Data
             });
         }
 
-        private class ViewModel : INotifyPropertyChanged
+        private class ViewModelBase
+        {
+            public virtual void VirtualObjectMethod(object? i) { }
+
+            public virtual void VirtualInt32Method(int i) { }
+
+            public virtual void VirtualStringMethod(string i) { }
+
+            public void MethodWithNewSlot(int i) { }
+        }
+
+        private class ViewModel : ViewModelBase, INotifyPropertyChanged
         {
             public event PropertyChangedEventHandler? PropertyChanged;
 
-            public string Method() => Value = "Called";
-            public string Method1(object i) => Value = $"Called {i}";
-            public string Method2(int i, int j) => Value = $"Called {i},{j}";
-            public string Method3() => Value = "Called";
-            public string Method3(object obj) => Value = $"Called Method with parameter of object type. Argument value is {obj}";
+            public void Method() => Value = "Called";
+
+            public void ObjectMethod(object i) => Value = $"Called ObjectMethod with {i}";
+
+            public void Int32Method(int i) => Value = $"Called Int32Method with {i}";
+
+            public void StringMethod(string i) => Value = $"Called StringMethod with {i}";
+
+            public void MethodWithOverloads() => Value = "Called MethodWithOverloads without parameter";
+            public void MethodWithOverloads(int i) => Value = $"Called MethodWithOverloads with Int32 {i}";
+            public void MethodWithOverloads(string i) => Value = $"Called MethodWithOverloads with String {i}";
+            public void MethodWithOverloads(object i) => Value = $"Called MethodWithOverloads with Object {i}";
+
+            public void MethodWithOverloads2() => Value = "Called MethodWithOverloads2 without parameter";
+            public void MethodWithOverloads2(int i) => Value = $"Called MethodWithOverloads2 with Int32 {i}";
+            public void MethodWithOverloads2(string i) => Value = $"Called MethodWithOverloads2 with String {i}";
+
+            public void MethodWithOverloads3() => Value = "Called MethodWithOverloads3 without parameter";
+            public void MethodWithOverloads3(int a, int b) => throw new InvalidOperationException("MethodWithOverloads3 should not be called");
+            public void MethodWithOverloads3(string a, string b) => throw new InvalidOperationException("MethodWithOverloads3 should not be called");
+
+            public void MethodWithOverloads4(int a, int b) => throw new InvalidOperationException("MethodWithOverloads4 should not be called");
+            public void MethodWithOverloads4(string a, string b) => throw new InvalidOperationException("MethodWithOverloads4 should not be called");
+
+            public override void VirtualObjectMethod(object? i)
+                => Value = $"Called VirtualObjectMethod with {i}";
+
+            public override void VirtualInt32Method(int i)
+                => Value = $"Called VirtualInt32Method with {i}";
+
+            public override void VirtualStringMethod(string i)
+                => Value = $"Called VirtualStringMethod with {i}";
+
+            public new void MethodWithNewSlot(int i)
+                => Value = $"Called MethodWithNewSlot with {i}";
+
             public string Value { get; private set; } = "Not called";
 
             private object? _parameter;
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs
index d3374ce8ad..fcba9a50b9 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs
@@ -1905,31 +1905,172 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions
         }
 
         [Theory]
-        [InlineData("5")]
-        [InlineData("hello")]
-        [InlineData(null)]
-        public void Binding_Method_With_Parameter_To_Command_Works(string? parameter)
+        [InlineData("ObjectMethod", "<x:String>hello</x:String>", "Called ObjectMethod with hello")]
+        [InlineData("StringMethod", "<x:String>hello</x:String>", "Called StringMethod with hello")]
+        [InlineData("StringMethod", "<x:Null />", "Called StringMethod with ")]
+        [InlineData("Int32Method", "<x:Int32>42</x:Int32>", "Called Int32Method with 42")]
+        [InlineData("VirtualObjectMethod", "<x:String>hello</x:String>", "Called VirtualObjectMethod with hello")]
+        [InlineData("VirtualStringMethod", "<x:String>hello</x:String>", "Called VirtualStringMethod with hello")]
+        [InlineData("VirtualStringMethod", "<x:Null />", "Called VirtualStringMethod with ")]
+        [InlineData("VirtualInt32Method", "<x:Int32>42</x:Int32>", "Called VirtualInt32Method with 42")]
+        [InlineData("MethodWithNewSlot", "<x:Int32>42</x:Int32>", "Called MethodWithNewSlot with 42")]
+        public void Binding_Method_With_Parameter_To_Command_Uses_Single_Parameter_Overload(
+            string methodName,
+            string xamlParameter,
+            string expected)
+        {
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+            var window = (Window)AvaloniaRuntimeXamlLoader.Load(
+                $$"""
+                  <Window xmlns='https://github.com/avaloniaui'
+                          xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+                          xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.MarkupExtensions;assembly=Avalonia.Markup.Xaml.UnitTests'
+                          x:DataType='local:MethodAsCommandDataContext'>
+                      <Button Name='button' Command='{CompiledBinding {{methodName}}}'>
+                        <Button.CommandParameter>
+                          {{xamlParameter}}
+                        </Button.CommandParameter>
+                      </Button>
+                  </Window>
+                  """);
+            var button = window.GetControl<Button>("button");
+            var vm = new MethodAsCommandDataContext();
+
+            button.DataContext = vm;
+            window.ApplyTemplate();
+
+            Assert.NotNull(button.Command);
+            PerformClick(button);
+            Assert.Equal(expected, vm.Value);
+        }
+
+        [Theory]
+        [InlineData("Int32Method", "<x:String>hello</x:String>", typeof(InvalidCastException))]
+        [InlineData("Int32Method", "<x:Null />", typeof(NullReferenceException))]
+        [InlineData("StringMethod", "<x:Int32>42</x:Int32>", typeof(InvalidCastException))]
+        public void Binding_Method_With_Parameter_To_Command_With_Single_Parameter_Overload_Throws_At_Runtime_If_Mismatched_Types(
+            string methodName,
+            string xamlParameter,
+            Type exceptionType)
         {
-            using (UnitTestApplication.Start(TestServices.StyledWindow))
-            {
-                var xaml = $@"
-<Window xmlns='https://github.com/avaloniaui'
-        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
-        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.MarkupExtensions;assembly=Avalonia.Markup.Xaml.UnitTests'
-        x:DataType='local:MethodAsCommandDataContext'>
-    <Button Name='button' Command='{{CompiledBinding Method1}}' CommandParameter='{ parameter ?? "{x:Null}" }'/>
-</Window>";
-                var window = (Window)AvaloniaRuntimeXamlLoader.Load(xaml);
-                var button = window.GetControl<Button>("button");
-                var vm = new MethodAsCommandDataContext();
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow);
 
-                button.DataContext = vm;
-                window.ApplyTemplate();
+            var window = (Window)AvaloniaRuntimeXamlLoader.Load(
+                $$"""
+                  <Window xmlns='https://github.com/avaloniaui'
+                          xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+                          xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.MarkupExtensions;assembly=Avalonia.Markup.Xaml.UnitTests'
+                          x:DataType='local:MethodAsCommandDataContext'>
+                      <Button Name='button' Command='{CompiledBinding {{methodName}}}'>
+                        <Button.CommandParameter>
+                          {{xamlParameter}}
+                        </Button.CommandParameter>
+                      </Button>
+                  </Window>
+                  """);
+            var button = window.GetControl<Button>("button");
+            var vm = new MethodAsCommandDataContext();
 
-                Assert.NotNull(button.Command);
-                PerformClick(button);
-                Assert.Equal("Called " + parameter, vm.Value);
-            }
+            button.DataContext = vm;
+            window.ApplyTemplate();
+
+            Assert.NotNull(button.Command);
+            Assert.Throws(exceptionType, () => PerformClick(button));
+        }
+
+        [Fact]
+        public void Binding_Method_With_Parameter_To_Command_Prefers_Object_Overload()
+        {
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+            var window = (Window)AvaloniaRuntimeXamlLoader.Load(
+                """
+                <Window xmlns='https://github.com/avaloniaui'
+                        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+                        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.MarkupExtensions;assembly=Avalonia.Markup.Xaml.UnitTests'
+                        x:DataType='local:MethodAsCommandDataContext'>
+                    <Button Name='button' Command='{CompiledBinding MethodWithOverloads}' CommandParameter="foo" />
+                </Window>
+                """);
+            var button = window.GetControl<Button>("button");
+            var vm = new MethodAsCommandDataContext();
+
+            button.DataContext = vm;
+            window.ApplyTemplate();
+
+            Assert.NotNull(button.Command);
+            PerformClick(button);
+            Assert.Equal("Called MethodWithOverloads with Object foo", vm.Value);
+        }
+
+        [Fact]
+        public void Binding_Method_With_Parameter_To_Command_Fails_With_Multiple_Single_Parameter_Overloads_Without_Object()
+        {
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+            var exception = Assert.ThrowsAny<XmlException>(() => (Window)AvaloniaRuntimeXamlLoader.Load(
+                """
+                <Window xmlns='https://github.com/avaloniaui'
+                        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+                        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.MarkupExtensions;assembly=Avalonia.Markup.Xaml.UnitTests'
+                        x:DataType='local:MethodAsCommandDataContext'>
+                    <Button Name='button' Command='{CompiledBinding MethodWithOverloads2}' CommandParameter="foo" />
+                </Window>
+                """));
+
+            Assert.StartsWith(
+                "Unable to resolve method of name 'MethodWithOverloads2' on type 'Avalonia.Markup.Xaml.UnitTests.MarkupExtensions.MethodAsCommandDataContext'. " +
+                "Found 2 overloads accepting one parameter: 'System.Int32', 'System.String'. " +
+                "Expected either a single overload with one parameter, or an overload accepting System.Object.",
+                exception.Message);
+        }
+
+        [Fact]
+        public void Binding_Method_With_Parameter_To_Command_Uses_Parameterless_Overload_When_No_Overloads_With_Parameter_Exist()
+        {
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+            var window = (Window)AvaloniaRuntimeXamlLoader.Load(
+                """
+                <Window xmlns='https://github.com/avaloniaui'
+                        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+                        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.MarkupExtensions;assembly=Avalonia.Markup.Xaml.UnitTests'
+                        x:DataType='local:MethodAsCommandDataContext'>
+                    <Button Name='button' Command='{CompiledBinding MethodWithOverloads3}' CommandParameter="foo" />
+                </Window>
+                """);
+            var button = window.GetControl<Button>("button");
+            var vm = new MethodAsCommandDataContext();
+
+            button.DataContext = vm;
+            window.ApplyTemplate();
+
+            Assert.NotNull(button.Command);
+            PerformClick(button);
+            Assert.Equal("Called MethodWithOverloads3 without parameter", vm.Value);
+        }
+
+        [Fact]
+        public void Binding_Method_With_Parameter_To_Command_Fails_Without_Valid_Overloads()
+        {
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+            var exception = Assert.ThrowsAny<XmlException>(() => (Window)AvaloniaRuntimeXamlLoader.Load(
+                """
+                <Window xmlns='https://github.com/avaloniaui'
+                        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+                        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.MarkupExtensions;assembly=Avalonia.Markup.Xaml.UnitTests'
+                        x:DataType='local:MethodAsCommandDataContext'>
+                    <Button Name='button' Command='{CompiledBinding MethodWithOverloads4}' CommandParameter="foo" />
+                </Window>
+                """));
+
+            Assert.StartsWith(
+                "Unable to resolve method of name 'MethodWithOverloads4' on type 'Avalonia.Markup.Xaml.UnitTests.MarkupExtensions.MethodAsCommandDataContext'. " +
+                "Found 2 overloads accepting more than one parameter. " +
+                "Expected a method with zero or one parameter. ",
+                exception.Message);
         }
 
         [Fact]
@@ -2541,15 +2682,57 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions
         public object CustomDelegateTypeInt(object i) => i;
     }
 
-    public class MethodAsCommandDataContext : INotifyPropertyChanged
+    public class MethodAsCommandDataContextBase
+    {
+        public virtual void VirtualObjectMethod(object? i) { }
+
+        public virtual void VirtualInt32Method(int i) { }
+
+        public virtual void VirtualStringMethod(string i) { }
+
+        public void MethodWithNewSlot(int i) { }
+    }
+
+    public class MethodAsCommandDataContext : MethodAsCommandDataContextBase, INotifyPropertyChanged
     {
         public event PropertyChangedEventHandler? PropertyChanged;
 
-        public string Method() => Value = "Called";
-        public string Method1() => Value = "Called";
-        public string Method1(int i) => throw new InvalidOperationException("Binding to method with typed parameters is not supported");
-        public string Method1(object i) => Value = $"Called {i}";
-        public string Method2(int i, int j) => Value = $"Called {i},{j}";
+        public void Method() => Value = "Called";
+
+        public void ObjectMethod(object i) => Value = $"Called ObjectMethod with {i}";
+
+        public void Int32Method(int i) => Value = $"Called Int32Method with {i}";
+
+        public void StringMethod(string i) => Value = $"Called StringMethod with {i}";
+
+        public void MethodWithOverloads() => Value = "Called MethodWithOverloads without parameter";
+        public void MethodWithOverloads(int i) => Value = $"Called MethodWithOverloads with Int32 {i}";
+        public void MethodWithOverloads(string i) => Value = $"Called MethodWithOverloads with String {i}";
+        public void MethodWithOverloads(object i) => Value = $"Called MethodWithOverloads with Object {i}";
+
+        public void MethodWithOverloads2() => Value = "Called MethodWithOverloads2 without parameter";
+        public void MethodWithOverloads2(int i) => Value = $"Called MethodWithOverloads2 with Int32 {i}";
+        public void MethodWithOverloads2(string i) => Value = $"Called MethodWithOverloads2 with String {i}";
+
+        public void MethodWithOverloads3() => Value = "Called MethodWithOverloads3 without parameter";
+        public void MethodWithOverloads3(int a, int b) => throw new InvalidOperationException("MethodWithOverloads3 should not be called");
+        public void MethodWithOverloads3(string a, string b) => throw new InvalidOperationException("MethodWithOverloads3 should not be called");
+
+        public void MethodWithOverloads4(int a, int b) => throw new InvalidOperationException("MethodWithOverloads4 should not be called");
+        public void MethodWithOverloads4(string a, string b) => throw new InvalidOperationException("MethodWithOverloads4 should not be called");
+
+        public override void VirtualObjectMethod(object? i)
+            => Value = $"Called VirtualObjectMethod with {i}";
+
+        public override void VirtualInt32Method(int i)
+            => Value = $"Called VirtualInt32Method with {i}";
+
+        public override void VirtualStringMethod(string i)
+            => Value = $"Called VirtualStringMethod with {i}";
+
+        public new void MethodWithNewSlot(int i)
+            => Value = $"Called MethodWithNewSlot with {i}";
+
         public string Value { get; private set; } = "Not called";
 
         private object? _parameter;

From dbb8af90c96c3ed9262705783d84ad67d17ab86d Mon Sep 17 00:00:00 2001
From: hyunq21 <88497893+hyunq21@users.noreply.github.com>
Date: Wed, 29 Jul 2026 00:52:40 +0900
Subject: [PATCH 132/196] [macOS] IME preedit lost on focus change (#21601)

* fix(macOS): commit IME preedit when switching focus between textboxes

Fixes #19964

* remove comment

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../src/OSX/AvnTextInputMethod.mm             |  1 +
 .../src/OSX/AvnTextInputMethodDelegate.h      |  1 +
 native/Avalonia.Native/src/OSX/AvnView.mm     | 24 ++++++++++++++++++-
 3 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm b/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm
index d99fef7833..386a031336 100644
--- a/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm
+++ b/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm
@@ -29,6 +29,7 @@ HRESULT AvnTextInputMethod::SetClient(IAvnTextInputMethodClient *client) {
 }
 
 void AvnTextInputMethod::Reset() {
+    [_inputMethodDelegate resetInputMethod];
 }
 
 void AvnTextInputMethod::SetSurroundingText(char* text, int start, int end) {
diff --git a/native/Avalonia.Native/src/OSX/AvnTextInputMethodDelegate.h b/native/Avalonia.Native/src/OSX/AvnTextInputMethodDelegate.h
index 9f321ca595..f5751d93b4 100644
--- a/native/Avalonia.Native/src/OSX/AvnTextInputMethodDelegate.h
+++ b/native/Avalonia.Native/src/OSX/AvnTextInputMethodDelegate.h
@@ -14,6 +14,7 @@
 -(void) setText:(NSString* _Nonnull) text;
 -(void) setCursorRect:(AvnRect) cursorRect;
 -(void) setSelection: (int) start : (int) end;
+-(void) resetInputMethod;
 
 @end
 
diff --git a/native/Avalonia.Native/src/OSX/AvnView.mm b/native/Avalonia.Native/src/OSX/AvnView.mm
index 35c636819e..9b05566479 100644
--- a/native/Avalonia.Native/src/OSX/AvnView.mm
+++ b/native/Avalonia.Native/src/OSX/AvnView.mm
@@ -375,7 +375,15 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
             [self becomeFirstResponder];
         }
     }
-       
+
+    if([self hasMarkedText] &&
+       (type == LeftButtonDown || type == RightButtonDown || type == MiddleButtonDown ||
+        type == XButton1Down || type == XButton2Down) &&
+       [self inputContext] != nil)
+    {
+        [[self inputContext] handleEvent:event];
+    }
+
     auto parent = _parent.tryGet();
     if(parent != nullptr)
     {
@@ -1035,6 +1043,20 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
     _selectedRange = NSMakeRange(start, end - start);
 }
 
+- (void) resetInputMethod{
+    auto parent = _parent.tryGet();
+
+    if(parent != nullptr && parent->InputMethod->IsActive()){
+        parent->InputMethod->Client->SetPreeditText(nullptr);
+    }
+
+    _markedRange = NSMakeRange(_selectedRange.location, 0);
+
+    if([self inputContext]) {
+        [[self inputContext] discardMarkedText];
+    }
+}
+
 - (void) setCursorRect:(AvnRect)rect{
     NSRect cursorRect = ToNSRect(rect);
     NSRect windowRectOnScreen = [[self window] convertRectToScreen:self.frame];

From bdb0738dba61c550a6b00c5ed00350a0c7e6a931 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Thu, 30 Jul 2026 11:53:09 +0200
Subject: [PATCH 133/196] Implement a copy-on-write list for
 VisualChildren/LogicalChildren (#21884)

* Implement copy-on-write list for Visual/LogicalChildren

* Ensure that adding/removing children is valid OnAttached/OnDetached
---
 src/Avalonia.Base/Collections/AvaloniaList.cs |  34 ++-
 src/Avalonia.Base/Input/FocusHelpers.cs       |   2 +-
 src/Avalonia.Base/Input/InputElement.cs       |  11 +-
 src/Avalonia.Base/Input/KeyboardDevice.cs     |   4 +-
 .../Input/PointerOverPreProcessor.cs          |   2 +-
 src/Avalonia.Base/Layout/LayoutHelper.cs      |   7 +-
 src/Avalonia.Base/Layout/Layoutable.cs        |  26 +--
 .../Rendering/ImmediateRenderer.cs            |   4 +-
 src/Avalonia.Base/StyledElement.cs            |  79 +++----
 .../Utilities/SafeEnumerableAvaloniaList.cs   |  80 +++++++
 src/Avalonia.Base/Visual.Composition.cs       |   2 +-
 src/Avalonia.Base/Visual.cs                   |  43 ++--
 .../VisualTree/VisualExtensions.cs            |  11 +-
 .../Styling/StyledElementTests.cs             |  81 +++++++
 .../SafeEnumerableAvaloniaListTests.cs        | 212 ++++++++++++++++++
 tests/Avalonia.Base.UnitTests/VisualTests.cs  |  81 +++++++
 16 files changed, 567 insertions(+), 112 deletions(-)
 create mode 100644 src/Avalonia.Base/Utilities/SafeEnumerableAvaloniaList.cs
 create mode 100644 tests/Avalonia.Base.UnitTests/Utilities/SafeEnumerableAvaloniaListTests.cs

diff --git a/src/Avalonia.Base/Collections/AvaloniaList.cs b/src/Avalonia.Base/Collections/AvaloniaList.cs
index 324e33e5af..4af60b2cc2 100644
--- a/src/Avalonia.Base/Collections/AvaloniaList.cs
+++ b/src/Avalonia.Base/Collections/AvaloniaList.cs
@@ -49,7 +49,7 @@ namespace Avalonia.Collections
     /// </remarks>
     public class AvaloniaList<T> : IAvaloniaList<T>, IList, INotifyCollectionChangedDebug
     {
-        private readonly List<T> _inner;
+        private List<T> _inner;
         private NotifyCollectionChangedEventHandler? _collectionChanged;
 
         /// <summary>
@@ -144,6 +144,16 @@ namespace Avalonia.Collections
 
         internal IAvaloniaListItemValidator<T>? Validator { get; set; }
 
+        private protected List<T> Inner
+        {
+            get => _inner;
+            set => _inner = value;
+        }
+
+        private protected virtual void OnMutating()
+        {
+        }
+
         /// <inheritdoc/>
         bool IList.IsFixedSize => false;
 
@@ -182,6 +192,7 @@ namespace Avalonia.Collections
 
                 if (!EqualityComparer<T>.Default.Equals(old, value))
                 {
+                    OnMutating();
                     _inner[index] = value;
 
                     if (_collectionChanged != null)
@@ -224,6 +235,9 @@ namespace Avalonia.Collections
         public virtual void Add(T item)
         {
             Validator?.Validate(item);
+
+            OnMutating();
+
             int index = _inner.Count;
             _inner.Add(item);
             NotifyAdd(item, index);
@@ -242,6 +256,8 @@ namespace Avalonia.Collections
         {
             if (Count > 0)
             {
+                OnMutating();
+
                 if (_collectionChanged != null)
                 {
                     var e = ResetBehavior == ResetBehavior.Reset ?
@@ -331,6 +347,9 @@ namespace Avalonia.Collections
         public virtual void Insert(int index, T item)
         {
             Validator?.Validate(item);
+
+            OnMutating();
+
             _inner.Insert(index, item);
             NotifyAdd(item, index);
         }
@@ -351,6 +370,8 @@ namespace Avalonia.Collections
             {
                 if (list.Count > 0)
                 {
+                    OnMutating();
+
                     if (list is ICollection<T> collection)
                     {
                         if (hasValidation)
@@ -395,6 +416,8 @@ namespace Avalonia.Collections
                 {
                     if (en.MoveNext())
                     {
+                        OnMutating();
+
                         // Avoid allocating list for collection notification if there is no event subscriptions.
                         List<T>? notificationItems = willRaiseCollectionChanged ?
                             new List<T>() :
@@ -438,6 +461,9 @@ namespace Avalonia.Collections
         public void Move(int oldIndex, int newIndex)
         {
             var item = this[oldIndex];
+
+            OnMutating();
+
             _inner.RemoveAt(oldIndex);
             _inner.Insert(newIndex, item);
 
@@ -462,6 +488,9 @@ namespace Avalonia.Collections
         {
             var items = _inner.GetRange(oldIndex, count);
             var modifiedNewIndex = newIndex;
+
+            OnMutating();
+
             _inner.RemoveRange(oldIndex, count);
 
             if (newIndex > oldIndex)
@@ -515,6 +544,7 @@ namespace Avalonia.Collections
 
             if (index != -1)
             {
+                OnMutating();
                 _inner.RemoveAt(index);
                 NotifyRemove(item , index);
                 return true;
@@ -558,6 +588,7 @@ namespace Avalonia.Collections
         public virtual void RemoveAt(int index)
         {
             T item = _inner[index];
+            OnMutating();
             _inner.RemoveAt(index);
             NotifyRemove(item , index);
         }
@@ -572,6 +603,7 @@ namespace Avalonia.Collections
             if (count > 0)
             {
                 var list = _inner.GetRange(index, count);
+                OnMutating();
                 _inner.RemoveRange(index, count);
                 NotifyRemove(list, index);
             }
diff --git a/src/Avalonia.Base/Input/FocusHelpers.cs b/src/Avalonia.Base/Input/FocusHelpers.cs
index f8b75a4501..40a1c28164 100644
--- a/src/Avalonia.Base/Input/FocusHelpers.cs
+++ b/src/Avalonia.Base/Input/FocusHelpers.cs
@@ -14,7 +14,7 @@ namespace Avalonia.Input
             // TODO: add control overrides to return custom focus list from control
             if (parent is Visual visual)
             {
-                return visual.VisualChildren.OfType<IInputElement>();
+                return visual.TypedVisualChildren.OfType<IInputElement>();
             }
 
             return Array.Empty<IInputElement>();
diff --git a/src/Avalonia.Base/Input/InputElement.cs b/src/Avalonia.Base/Input/InputElement.cs
index e908e818e8..01d64f692f 100644
--- a/src/Avalonia.Base/Input/InputElement.cs
+++ b/src/Avalonia.Base/Input/InputElement.cs
@@ -1044,17 +1044,12 @@ namespace Avalonia.Input
         {
             IsEffectivelyEnabled = IsEnabledCore && (parent?.IsEffectivelyEnabled ?? true);
 
-            // PERF-SENSITIVE: This is called on entire hierarchy and using foreach or LINQ
+            // PERF-SENSITIVE: This is called on entire hierarchy and using LINQ
             // will cause extra allocations and overhead.
 
-            var children = VisualChildren;
-
-            // ReSharper disable once ForCanBeConvertedToForeach
-            for (int i = 0; i < children.Count; ++i)
+            foreach (var child in TypedVisualChildren)
             {
-                var child = children[i] as InputElement;
-
-                child?.UpdateIsEffectivelyEnabled(this);
+                (child as InputElement)?.UpdateIsEffectivelyEnabled(this);
             }
         }
 
diff --git a/src/Avalonia.Base/Input/KeyboardDevice.cs b/src/Avalonia.Base/Input/KeyboardDevice.cs
index e2b530a91a..4298695bf4 100644
--- a/src/Avalonia.Base/Input/KeyboardDevice.cs
+++ b/src/Avalonia.Base/Input/KeyboardDevice.cs
@@ -46,7 +46,7 @@ namespace Avalonia.Input
         {
             if (element is Visual v)
             {
-                foreach (var visual in v.VisualChildren)
+                foreach (var visual in v.TypedVisualChildren)
                 {
                     if (visual is IInputElement el && el.IsKeyboardFocusWithin)
                     {
@@ -112,7 +112,7 @@ namespace Avalonia.Input
         {
             if (element is Visual v)
             {
-                foreach (var visual in v.VisualChildren)
+                foreach (var visual in v.TypedVisualChildren)
                 {
                     if (visual is IInputElement el && el.IsKeyboardFocusWithin)
                     {
diff --git a/src/Avalonia.Base/Input/PointerOverPreProcessor.cs b/src/Avalonia.Base/Input/PointerOverPreProcessor.cs
index f5c9239ca3..c32f747543 100644
--- a/src/Avalonia.Base/Input/PointerOverPreProcessor.cs
+++ b/src/Avalonia.Base/Input/PointerOverPreProcessor.cs
@@ -169,7 +169,7 @@ namespace Avalonia.Input
         {
             if (element is Visual v)
             {
-                foreach (var el in v.VisualChildren)
+                foreach (var el in v.TypedVisualChildren)
                 {
                     if (el is IInputElement { IsPointerOver: true } child)
                     {
diff --git a/src/Avalonia.Base/Layout/LayoutHelper.cs b/src/Avalonia.Base/Layout/LayoutHelper.cs
index 286a79ee8a..daf0074e20 100644
--- a/src/Avalonia.Base/Layout/LayoutHelper.cs
+++ b/src/Avalonia.Base/Layout/LayoutHelper.cs
@@ -120,13 +120,8 @@ namespace Avalonia.Layout
                     targetLayoutable.InvalidateMeasure();
                 }
 
-                var visualChildren = target.VisualChildren;
-                var visualChildrenCount = visualChildren.Count;
-
-                for (int i = 0; i < visualChildrenCount; i++)
+                foreach (var child in target.TypedVisualChildren)
                 {
-                    Visual child = visualChildren[i];
-
                     InnerInvalidateMeasure(child);
                 }
             }
diff --git a/src/Avalonia.Base/Layout/Layoutable.cs b/src/Avalonia.Base/Layout/Layoutable.cs
index e0c316c60a..e526dec046 100644
--- a/src/Avalonia.Base/Layout/Layoutable.cs
+++ b/src/Avalonia.Base/Layout/Layoutable.cs
@@ -635,13 +635,8 @@ namespace Avalonia.Layout
             double width = 0;
             double height = 0;
 
-            var visualChildren = VisualChildren;
-            var visualCount = visualChildren.Count;
-
-            for (var i = 0; i < visualCount; i++)
+            foreach (var visual in TypedVisualChildren)
             {
-                Visual visual = visualChildren[i];
-
                 if (visual is Layoutable layoutable)
                 {
                     layoutable.Measure(availableSize);
@@ -761,13 +756,8 @@ namespace Avalonia.Layout
         {
             var arrangeRect = new Rect(finalSize);
 
-            var visualChildren = VisualChildren;
-            var visualCount = visualChildren.Count;
-
-            for (var i = 0; i < visualCount; i++)
+            foreach (var visual in TypedVisualChildren)
             {
-                Visual visual = visualChildren[i];
-
                 if (visual is Layoutable layoutable)
                 {
                     layoutable.Arrange(arrangeRect);
@@ -857,11 +847,9 @@ namespace Avalonia.Layout
                     // property then we can piggy-pack on that; for the moment we do this manually.
                     if (this.GetLayoutRoot() is {} layoutRoot)
                     {
-                        var count = VisualChildren.Count;
-
-                        for (var i = 0; i < count; ++i)
+                        foreach (var child in TypedVisualChildren)
                         {
-                            (VisualChildren[i] as Layoutable)?.AncestorBecameVisible(layoutRoot.LayoutManager);
+                            (child as Layoutable)?.AncestorBecameVisible(layoutRoot.LayoutManager);
                         }
                     }
                 }
@@ -904,11 +892,9 @@ namespace Avalonia.Layout
                 InvalidateVisual();
             }
 
-            var count = VisualChildren.Count;
-
-            for (var i = 0; i < count; ++i)
+            foreach (var child in TypedVisualChildren)
             {
-                (VisualChildren[i] as Layoutable)?.AncestorBecameVisible(layoutManager);
+                (child as Layoutable)?.AncestorBecameVisible(layoutManager);
             }
         }
 
diff --git a/src/Avalonia.Base/Rendering/ImmediateRenderer.cs b/src/Avalonia.Base/Rendering/ImmediateRenderer.cs
index af53dd5bd0..409e3213a8 100644
--- a/src/Avalonia.Base/Rendering/ImmediateRenderer.cs
+++ b/src/Avalonia.Base/Rendering/ImmediateRenderer.cs
@@ -75,8 +75,8 @@ internal class ImmediateRenderer
             }
 
             IEnumerable<Visual> childrenEnumerable = visual.HasNonUniformZIndexChildren
-                ? visual.VisualChildren.OrderBy(x => x, ZIndexComparer.Instance)
-                : visual.VisualChildren;
+                ? visual.TypedVisualChildren.OrderBy(x => x, ZIndexComparer.Instance)
+                : visual.TypedVisualChildren;
 
             if (visual.ClipToBounds)
             {
diff --git a/src/Avalonia.Base/StyledElement.cs b/src/Avalonia.Base/StyledElement.cs
index f511d1de2a..16feb0e803 100644
--- a/src/Avalonia.Base/StyledElement.cs
+++ b/src/Avalonia.Base/StyledElement.cs
@@ -14,6 +14,7 @@ using Avalonia.Logging;
 using Avalonia.LogicalTree;
 using Avalonia.PropertyStore;
 using Avalonia.Styling;
+using Avalonia.Utilities;
 
 namespace Avalonia
 {
@@ -81,7 +82,7 @@ namespace Avalonia
         private string? _name;
         private Classes? _classes;
         private ILogicalRoot? _logicalRoot;
-        private AvaloniaList<ILogical>? _logicalChildren;
+        private SafeEnumerableAvaloniaList<ILogical>? _logicalChildren;
         private IResourceDictionary? _resources;
         private Styles? _styles;
         private bool _stylesApplied;
@@ -92,6 +93,10 @@ namespace Avalonia
         private ControlTheme? _implicitTheme;
         private ResourcesChangedEventArgs _lastResourcesChangedEventArgs;
 
+        // True when this element has been removed from a logical children collection and not added back since:
+        // This flag avoids a costly quadratic LogicalChildren.Contains call in OnAttachedToLogicalTreeCore.
+        private bool _removedFromLogicalParent;
+
         /// <summary>
         /// Initializes static members of the <see cref="StyledElement"/> class.
         /// </summary>
@@ -259,15 +264,15 @@ namespace Avalonia
         }
 
         /// <summary>
-        /// Gets the styled element's logical children.
+        /// Gets the styled element's logical children, strongly-typed, to avoid interface calls and enumerator boxing.
         /// </summary>
-        protected internal IAvaloniaList<ILogical> LogicalChildren
+        internal SafeEnumerableAvaloniaList<ILogical> TypedLogicalChildren
         {
             get
             {
                 if (_logicalChildren == null)
                 {
-                    var list = new AvaloniaList<ILogical>
+                    var list = new SafeEnumerableAvaloniaList<ILogical>
                     {
                         ResetBehavior = ResetBehavior.Remove,
                         Validator = this
@@ -280,6 +285,11 @@ namespace Avalonia
             }
         }
 
+        /// <summary>
+        /// Gets the styled element's logical children.
+        /// </summary>
+        protected internal IAvaloniaList<ILogical> LogicalChildren => TypedLogicalChildren;
+
         /// <summary>
         /// Gets the <see cref="Classes"/> collection in a form that allows adding and removing
         /// pseudoclasses.
@@ -320,7 +330,7 @@ namespace Avalonia
         /// <summary>
         /// Gets the styled element's logical children.
         /// </summary>
-        IAvaloniaReadOnlyList<ILogical> ILogical.LogicalChildren => LogicalChildren;
+        IAvaloniaReadOnlyList<ILogical> ILogical.LogicalChildren => TypedLogicalChildren;
 
         /// <inheritdoc/>
         bool IResourceNode.HasResources => (_resources?.HasResources ?? false) ||
@@ -541,17 +551,10 @@ namespace Avalonia
         /// <param name="e">The change token.</param>
         internal virtual void NotifyChildResourcesChanged(ResourcesChangedEventArgs e)
         {
-            if (_logicalChildren is object)
+            if (_logicalChildren is not null)
             {
-                var count = _logicalChildren.Count;
-
-                if (count > 0)
-                {
-                    for (var i = 0; i < count; ++i)
-                    {
-                        _logicalChildren[i].NotifyResourcesChanged(e);
-                    }
-                }
+                foreach (var child in _logicalChildren)
+                    child.NotifyResourcesChanged(e);
             }
         }
 
@@ -712,12 +715,9 @@ namespace Avalonia
                     element._dataContextUpdating = true;
                     element.OnDataContextBeginUpdate();
 
-                    var logicalChildren = element.LogicalChildren;
-                    var logicalChildrenCount = logicalChildren.Count;
-
-                    for (var i = 0; i < logicalChildrenCount; i++)
+                    foreach (var child in element.TypedLogicalChildren)
                     {
-                        if (element.LogicalChildren[i] is StyledElement s &&
+                        if (child is StyledElement s &&
                             s.InheritanceParent == element &&
                             !s.IsSet(DataContextProperty))
                         {
@@ -871,12 +871,12 @@ namespace Avalonia
                 AttachedToLogicalTree?.Invoke(this, e);
             }
 
-            var logicalChildren = LogicalChildren;
-            var logicalChildrenCount = logicalChildren.Count;
-
-            for (var i = 0; i < logicalChildrenCount; i++)
+            foreach (var logicalChild in TypedLogicalChildren)
             {
-                if (logicalChildren[i] is StyledElement child && child._logicalRoot != e.Root) // child may already have been attached within an event handler
+                // An event handler may have modified the children while we're enumerating a snapshot of the collection.
+                if (logicalChild is StyledElement child &&
+                    child._logicalRoot != e.Root &&
+                    (child.Parent is not null || !child._removedFromLogicalParent))
                 {
                     child.OnAttachedToLogicalTreeCore(e);
                 }
@@ -892,12 +892,9 @@ namespace Avalonia
                 OnDetachedFromLogicalTree(e);
                 DetachedFromLogicalTree?.Invoke(this, e);
 
-                var logicalChildren = LogicalChildren;
-                var logicalChildrenCount = logicalChildren.Count;
-
-                for (var i = 0; i < logicalChildrenCount; i++)
+                foreach (var logicalChild in TypedLogicalChildren)
                 {
-                    if (logicalChildren[i] is StyledElement child)
+                    if (logicalChild is StyledElement child)
                     {
                         child.OnDetachedFromLogicalTreeCore(e);
                     }
@@ -927,7 +924,12 @@ namespace Avalonia
             for (var i = 0; i < count; i++)
             {
                 var logical = (ILogical) children[i]!;
-                
+
+                if (logical is StyledElement styledElement)
+                {
+                    styledElement._removedFromLogicalParent = false;
+                }
+
                 if (logical.LogicalParent is null)
                 {
                     ((ISetLogicalParent)logical).SetParent(this);
@@ -942,7 +944,12 @@ namespace Avalonia
             for (var i = 0; i < count; i++)
             {
                 var logical = (ILogical) children[i]!;
-                
+
+                if (logical is StyledElement styledElement)
+                {
+                    styledElement._removedFromLogicalParent = true;
+                }
+
                 if (logical.LogicalParent == this)
                 {
                     ((ISetLogicalParent)logical).SetParent(null);
@@ -959,12 +966,8 @@ namespace Avalonia
 
             if (_logicalChildren is not null)
             {
-                var childCount = _logicalChildren.Count;
-
-                for (var i = 0; i < childCount; ++i)
-                {
-                    (_logicalChildren[i] as StyledElement)?.DetachStyles(styles);
-                }
+                foreach (var child in _logicalChildren)
+                    (child as StyledElement)?.DetachStyles(styles);
             }
         }
 
diff --git a/src/Avalonia.Base/Utilities/SafeEnumerableAvaloniaList.cs b/src/Avalonia.Base/Utilities/SafeEnumerableAvaloniaList.cs
new file mode 100644
index 0000000000..ed616707eb
--- /dev/null
+++ b/src/Avalonia.Base/Utilities/SafeEnumerableAvaloniaList.cs
@@ -0,0 +1,80 @@
+using System.Collections;
+using System.Collections.Generic;
+using Avalonia.Collections;
+
+namespace Avalonia.Utilities;
+
+/// <summary>
+/// An <see cref="AvaloniaList{T}"/> which can be mutated while it's being enumerated.
+/// </summary>
+/// <remarks>
+/// <para>
+/// When the list is mutated while one or more enumerations are in progress, the inner list is first copied and the
+/// mutation is applied to the copy: active enumerators continue iterating over the snapshot taken when they were created.
+/// Mutations made while no enumerator is active are applied in place, at no extra cost.
+/// </para>
+/// <para>
+/// Warning! Enumerating an instance statically typed as <see cref="AvaloniaList{T}"/> uses the base,
+/// non-snapshotting enumerator: expose instances of this type as <see cref="SafeEnumerableAvaloniaList{T}"/> or
+/// <see cref="IAvaloniaList{T}"/>.
+/// </para>
+/// </remarks>
+internal sealed class SafeEnumerableAvaloniaList<T> : AvaloniaList<T>, IEnumerable<T>
+{
+    private int _generation;
+    private int _enumCount;
+
+    /// <summary>
+    /// For unit tests only!
+    /// </summary>
+    internal List<T> InnerForTests => Inner;
+
+    private protected override void OnMutating()
+    {
+        if (_enumCount > 0)
+        {
+            Inner = new List<T>(Inner);
+            ++_generation;
+            _enumCount = 0;
+        }
+    }
+
+    public new Enumerator GetEnumerator() => new(this);
+
+    IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    public new struct Enumerator : IEnumerator<T>
+    {
+        private readonly SafeEnumerableAvaloniaList<T> _owner;
+        private readonly int _generation;
+        private List<T>.Enumerator _innerEnumerator;
+
+        internal Enumerator(SafeEnumerableAvaloniaList<T> owner)
+        {
+            _owner = owner;
+            _generation = owner._generation;
+            ++owner._enumCount;
+            _innerEnumerator = owner.Inner.GetEnumerator();
+        }
+
+        public bool MoveNext()
+            => _innerEnumerator.MoveNext();
+
+        public T Current
+            => _innerEnumerator.Current;
+
+        object? IEnumerator.Current
+            => Current;
+
+        void IEnumerator.Reset()
+            => ((IEnumerator)_innerEnumerator).Reset();
+
+        public void Dispose()
+        {
+            if (_generation == _owner._generation)
+                --_owner._enumCount;
+        }
+    }
+}
diff --git a/src/Avalonia.Base/Visual.Composition.cs b/src/Avalonia.Base/Visual.Composition.cs
index be2d42782d..533cc2a746 100644
--- a/src/Avalonia.Base/Visual.Composition.cs
+++ b/src/Avalonia.Base/Visual.Composition.cs
@@ -45,7 +45,7 @@ public partial class Visual
         if(CompositionVisual == null)
             return;
         var compositionChildren = CompositionVisual.Children;
-        var visualChildren = (AvaloniaList<Visual>)VisualChildren;
+        var visualChildren = TypedVisualChildren;
         
         PooledList<(Visual visual, int index)>? sortedChildren = null;
         if (HasNonUniformZIndexChildren && visualChildren.Count > 1)
diff --git a/src/Avalonia.Base/Visual.cs b/src/Avalonia.Base/Visual.cs
index 4bd359fa78..715bb6f77c 100644
--- a/src/Avalonia.Base/Visual.cs
+++ b/src/Avalonia.Base/Visual.cs
@@ -159,11 +159,11 @@ namespace Avalonia
             // Disable transitions until we're added to the visual tree.
             DisableTransitions();
 
-            var visualChildren = new AvaloniaList<Visual>();
+            var visualChildren = new SafeEnumerableAvaloniaList<Visual>();
             visualChildren.ResetBehavior = ResetBehavior.Remove;
             visualChildren.Validator = this;
             visualChildren.CollectionChanged += VisualChildrenChanged;
-            VisualChildren = visualChildren;
+            TypedVisualChildren = visualChildren;
         }
 
         /// <summary>
@@ -228,15 +228,11 @@ namespace Avalonia
             IsEffectivelyVisible = isEffectivelyVisible;
             IsEffectivelyVisibleChanged?.Invoke(this, EventArgs.Empty);
 
-            // PERF-SENSITIVE: This is called on entire hierarchy and using foreach or LINQ
+            // PERF-SENSITIVE: This is called on entire hierarchy and using LINQ
             // will cause extra allocations and overhead.
 
-            var children = VisualChildren;
-
-            // ReSharper disable once ForCanBeConvertedToForeach
-            for (int i = 0; i < children.Count; ++i)
+            foreach (var child in TypedVisualChildren)
             {
-                var child = children[i];
                 child.UpdateIsEffectivelyVisible(isEffectivelyVisible);
             }
         }
@@ -338,9 +334,11 @@ namespace Avalonia
         }
 
         /// <summary>
-        /// Gets the control's child visuals.
+        /// /// Gets the control's child visuals, strongly-typed, to avoid interface calls and enumerator boxing.
         /// </summary>
-        protected internal IAvaloniaList<Visual> VisualChildren { get; }
+        internal SafeEnumerableAvaloniaList<Visual> TypedVisualChildren { get; }
+
+        protected internal IAvaloniaList<Visual> VisualChildren => TypedVisualChildren;
 
         /// <summary>
         /// Gets the root of the visual tree, if the control is attached to a visual tree.
@@ -512,7 +510,7 @@ namespace Avalonia
             {
                 InvalidateMirrorTransform();
 
-                foreach (var child in VisualChildren)
+                foreach (var child in TypedVisualChildren)
                 {
                     child.InvalidateMirrorTransform();
                 }
@@ -561,12 +559,11 @@ namespace Avalonia
                     _visualParent.HasNonUniformZIndexChildren = true;
             }
 
-            var visualChildren = VisualChildren;
-            var visualChildrenCount = visualChildren.Count;
-
-            for (var i = 0; i < visualChildrenCount; i++)
+            foreach (var child in TypedVisualChildren)
             {
-                if (visualChildren[i] is { } child && child.PresentationSource != e.PresentationSource) // child may already have been attached within an event handler
+                // An event handler may have modified the children: skip a child which has already been attached, or
+                // which has been removed from this visual (we're enumerating a snapshot of the collection).
+                if (child.PresentationSource != e.PresentationSource && child.VisualParent == this)
                 {
                     child.OnAttachedToVisualTreeCore(e);
                 }
@@ -599,12 +596,11 @@ namespace Avalonia
             
             PresentationSource = null;
 
-            var visualChildren = VisualChildren;
-            var visualChildrenCount = visualChildren.Count;
-
-            for (var i = 0; i < visualChildrenCount; i++)
+            foreach (var child in TypedVisualChildren)
             {
-                if (visualChildren[i] is { } child)
+                // A child removed within an event handler has already been detached by the removal itself:
+                // don't detach it a second time (we're enumerating a snapshot of the collection).
+                if (child.PresentationSource is not null)
                 {
                     child.OnDetachedFromVisualTreeCore(e);
                 }
@@ -777,12 +773,11 @@ namespace Avalonia
         {
             base.OnTemplatedParentControlThemeChanged();
 
-            var count = VisualChildren.Count;
             var templatedParent = TemplatedParent;
 
-            for (var i = 0; i < count; ++i)
+            foreach (var visualChild in TypedVisualChildren)
             {
-                if (VisualChildren[i] is StyledElement child &&
+                if (visualChild is StyledElement child &&
                     child.TemplatedParent == templatedParent)
                 {
                     child.OnTemplatedParentControlThemeChanged();
diff --git a/src/Avalonia.Base/VisualTree/VisualExtensions.cs b/src/Avalonia.Base/VisualTree/VisualExtensions.cs
index e7275cef61..2007d39f7d 100644
--- a/src/Avalonia.Base/VisualTree/VisualExtensions.cs
+++ b/src/Avalonia.Base/VisualTree/VisualExtensions.cs
@@ -391,7 +391,7 @@ namespace Avalonia.VisualTree
         /// <returns>The visual children.</returns>
         public static IEnumerable<Visual> GetVisualChildren(this Visual visual)
         {
-            return visual.VisualChildren;
+            return visual.TypedVisualChildren;
         }
 
         /// <summary>
@@ -401,7 +401,7 @@ namespace Avalonia.VisualTree
         /// <returns>The visual's ancestors.</returns>
         public static IEnumerable<Visual> GetVisualDescendants(this Visual visual)
         {
-            foreach (Visual child in visual.VisualChildren)
+            foreach (Visual child in visual.TypedVisualChildren)
             {
                 yield return child;
 
@@ -517,13 +517,8 @@ namespace Avalonia.VisualTree
 
         private static T? FindDescendantOfTypeCore<T>(Visual visual, Predicate<T>? predicate) where T : class
         {
-            var visualChildren = visual.VisualChildren;
-            var visualChildrenCount = visualChildren.Count;
-
-            for (var i = 0; i < visualChildrenCount; i++)
+            foreach (var child in visual.TypedVisualChildren)
             {
-                Visual child = visualChildren[i];
-
                 if (child is T result)
                 {
                     if (predicate == null || predicate(result))
diff --git a/tests/Avalonia.Base.UnitTests/Styling/StyledElementTests.cs b/tests/Avalonia.Base.UnitTests/Styling/StyledElementTests.cs
index 68644e10aa..f49ad1cc17 100644
--- a/tests/Avalonia.Base.UnitTests/Styling/StyledElementTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Styling/StyledElementTests.cs
@@ -229,6 +229,87 @@ namespace Avalonia.Base.UnitTests.Styling
             Assert.True(raised);
         }
 
+        [Fact]
+        public void LogicalChildren_Can_Be_Added_During_AttachedToLogicalTree()
+        {
+            var root = new TestRoot();
+            var parent = new StyledElement();
+            var child1 = new StyledElement();
+            var child2 = new StyledElement();
+
+            parent.LogicalChildren.Add(child1);
+
+            child1.AttachedToLogicalTree += (_, _) => parent.LogicalChildren.Add(child2);
+
+            root.LogicalChildren.Add(parent);
+
+            Assert.Equal([child1, child2], parent.LogicalChildren);
+            Assert.True(((ILogical)child1).IsAttachedToLogicalTree);
+            Assert.True(((ILogical)child2).IsAttachedToLogicalTree);
+        }
+
+        [Fact]
+        public void LogicalChildren_Can_Be_Removed_During_AttachedToLogicalTree()
+        {
+            var root = new TestRoot();
+            var parent = new StyledElement();
+            var child1 = new StyledElement();
+            var child2 = new StyledElement();
+
+            parent.LogicalChildren.AddRange([child1, child2]);
+
+            child1.AttachedToLogicalTree += (_, _) => parent.LogicalChildren.Remove(child2);
+
+            root.LogicalChildren.Add(parent);
+
+            Assert.Equal([child1], parent.LogicalChildren);
+            Assert.True(((ILogical)child1).IsAttachedToLogicalTree);
+            Assert.False(((ILogical)child2).IsAttachedToLogicalTree);
+        }
+
+        [Fact]
+        public void LogicalChildren_Can_Be_Added_During_DetachedFromLogicalTree()
+        {
+            var root = new TestRoot();
+            var parent = new StyledElement();
+            var child1 = new StyledElement();
+            var child2 = new StyledElement();
+
+            parent.LogicalChildren.Add(child1);
+            root.LogicalChildren.Add(parent);
+
+            child1.DetachedFromLogicalTree += (_, _) => parent.LogicalChildren.Add(child2);
+
+            root.LogicalChildren.Remove(parent);
+
+            Assert.Equal([child1, child2], parent.LogicalChildren);
+            Assert.False(((ILogical)child1).IsAttachedToLogicalTree);
+            Assert.False(((ILogical)child2).IsAttachedToLogicalTree);
+        }
+
+        [Fact]
+        public void LogicalChildren_Can_Be_Removed_During_DetachedFromLogicalTree()
+        {
+            var root = new TestRoot();
+            var parent = new StyledElement();
+            var child1 = new StyledElement();
+            var child2 = new StyledElement();
+            var child2Detached = 0;
+
+            parent.LogicalChildren.AddRange([child1, child2]);
+            root.LogicalChildren.Add(parent);
+
+            child1.DetachedFromLogicalTree += (_, _) => parent.LogicalChildren.Remove(child2);
+            child2.DetachedFromLogicalTree += (_, _) => ++child2Detached;
+
+            root.LogicalChildren.Remove(parent);
+
+            Assert.Equal([child1], parent.LogicalChildren);
+            Assert.False(((ILogical)child1).IsAttachedToLogicalTree);
+            Assert.False(((ILogical)child2).IsAttachedToLogicalTree);
+            Assert.Equal(1, child2Detached);
+        }
+
         [Fact]
         public void Parent_Should_Be_Null_When_DetachedFromLogicalTree_Called()
         {
diff --git a/tests/Avalonia.Base.UnitTests/Utilities/SafeEnumerableAvaloniaListTests.cs b/tests/Avalonia.Base.UnitTests/Utilities/SafeEnumerableAvaloniaListTests.cs
new file mode 100644
index 0000000000..832953147a
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/Utilities/SafeEnumerableAvaloniaListTests.cs
@@ -0,0 +1,212 @@
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using Avalonia.Utilities;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests.Utilities;
+
+public class SafeEnumerableAvaloniaListTests
+{
+    [Fact]
+    public void List_Is_Not_Copied_Outside_Enumeration()
+    {
+        var target = new SafeEnumerableAvaloniaList<string>();
+        var inner = target.InnerForTests;
+
+        target.Add("foo");
+        target.Add("bar");
+        target.Remove("foo");
+        target.Insert(0, "baz");
+        target[0] = "qux";
+        target.Move(0, 1);
+        target.Clear();
+
+        Assert.Same(inner, target.InnerForTests);
+    }
+
+    [Fact]
+    public void List_Is_Copied_When_Mutated_During_Enumeration()
+    {
+        var target = new SafeEnumerableAvaloniaList<string>();
+        var inner = target.InnerForTests;
+
+        target.Add("foo");
+
+        foreach (var item in target)
+        {
+            Assert.Same(inner, target.InnerForTests);
+            target.Add("bar");
+            Assert.NotSame(inner, target.InnerForTests);
+            Assert.Equal("foo", item);
+        }
+
+        Assert.Equal(["foo", "bar"], target);
+    }
+
+    [Fact]
+    public void Enumerator_Iterates_Snapshot_Taken_At_Creation()
+    {
+        var target = new SafeEnumerableAvaloniaList<string> { "foo", "bar", "baz" };
+        var seen = new List<string>();
+
+        foreach (var item in target)
+        {
+            seen.Add(item);
+            target.Remove(item);
+        }
+
+        Assert.Equal(["foo", "bar", "baz"], seen);
+        Assert.Empty(target);
+    }
+
+    [Fact]
+    public void List_Is_Not_Copied_After_Enumeration()
+    {
+        var target = new SafeEnumerableAvaloniaList<string>();
+        var inner = target.InnerForTests;
+
+        target.Add("foo");
+
+        foreach (var item in target)
+        {
+            target.Add("bar");
+            Assert.NotSame(inner, target.InnerForTests);
+            inner = target.InnerForTests;
+            Assert.Equal("foo", item);
+        }
+
+        target.Add("baz");
+        Assert.Same(inner, target.InnerForTests);
+    }
+
+    [Fact]
+    public void List_Is_Copied_Only_Once_During_Enumeration()
+    {
+        var target = new SafeEnumerableAvaloniaList<string>();
+        var inner = target.InnerForTests;
+
+        target.Add("foo");
+
+        foreach (var item in target)
+        {
+            target.Add("bar");
+            Assert.NotSame(inner, target.InnerForTests);
+            inner = target.InnerForTests;
+            target.Add("baz");
+            Assert.Same(inner, target.InnerForTests);
+        }
+    }
+
+    [Fact]
+    public void List_Is_Copied_During_Nested_Enumerations()
+    {
+        var target = new SafeEnumerableAvaloniaList<string>();
+        var initialInner = target.InnerForTests;
+        var firstItems = new List<string>();
+        var secondItems = new List<string>();
+
+        target.Add("foo");
+
+        foreach (var i in target)
+        {
+            target.Add("bar");
+
+            var firstInner = target.InnerForTests;
+            Assert.NotSame(initialInner, firstInner);
+
+            foreach (var j in target)
+            {
+                target.Add("baz");
+
+                var secondInner = target.InnerForTests;
+                Assert.NotSame(firstInner, secondInner);
+
+                secondItems.Add(j);
+            }
+
+            firstItems.Add(i);
+        }
+
+        Assert.Equal(["foo"], firstItems);
+        Assert.Equal(["foo", "bar"], secondItems);
+        Assert.Equal(["foo", "bar", "baz", "baz"], target);
+
+        var finalInner = target.InnerForTests;
+        target.Add("final");
+        Assert.Same(finalInner, target.InnerForTests);
+    }
+
+    [Fact]
+    public void Enumeration_Through_Interface_Is_Safe()
+    {
+        var target = new SafeEnumerableAvaloniaList<string> { "foo", "bar" };
+        var seen = new List<string>();
+
+        foreach (var item in (IEnumerable<string>)target)
+        {
+            seen.Add(item);
+            target.Add("baz");
+        }
+
+        Assert.Equal(["foo", "bar"], seen);
+        Assert.Equal(["foo", "bar", "baz", "baz"], target);
+    }
+
+    [Fact]
+    public void CollectionChanged_Is_Raised_For_Mutations_After_Copy()
+    {
+        var target = new SafeEnumerableAvaloniaList<string> { "foo" };
+        var events = new List<NotifyCollectionChangedEventArgs>();
+
+        target.CollectionChanged += (_, e) => events.Add(e);
+
+        foreach (var item in target)
+        {
+            target.Add("bar");
+        }
+
+        target.Add("baz");
+
+        Assert.Equal(2, events.Count);
+        Assert.All(events, e => Assert.Equal(NotifyCollectionChangedAction.Add, e.Action));
+        Assert.Equal("bar", events[0].NewItems!.Cast<string>().Single());
+        Assert.Equal("baz", events[1].NewItems!.Cast<string>().Single());
+    }
+
+    [Fact]
+    public void PropertyChanged_Is_Raised_For_Count_After_Copy()
+    {
+        var target = new SafeEnumerableAvaloniaList<string> { "foo" };
+        var countChanged = 0;
+
+        target.PropertyChanged += (_, e) =>
+        {
+            if (e.PropertyName == nameof(target.Count))
+                ++countChanged;
+        };
+
+        foreach (var i in target)
+            target.Add("bar");
+
+        target.Add("baz");
+
+        Assert.Equal(2, countChanged);
+    }
+
+    [Fact]
+    public void Validator_Is_Invoked_After_Copy()
+    {
+        var target = new SafeEnumerableAvaloniaList<string> { "foo" };
+        var validated = new List<string>();
+
+        target.Validate = validated.Add;
+
+        foreach (var item in target)
+            target.Add("bar");
+
+        target.Add("baz");
+
+        Assert.Equal(["bar", "baz"], validated);
+    }
+}
diff --git a/tests/Avalonia.Base.UnitTests/VisualTests.cs b/tests/Avalonia.Base.UnitTests/VisualTests.cs
index 24deb24938..718886c67e 100644
--- a/tests/Avalonia.Base.UnitTests/VisualTests.cs
+++ b/tests/Avalonia.Base.UnitTests/VisualTests.cs
@@ -127,6 +127,87 @@ namespace Avalonia.Base.UnitTests
             Assert.True(called2);
         }
 
+        [Fact]
+        public void VisualChildren_Can_Be_Added_During_AttachedToVisualTree()
+        {
+            var root = new TestRoot();
+            var parent = new TestVisual();
+            var child1 = new TestVisual();
+            var child2 = new TestVisual();
+
+            parent.AddChild(child1);
+
+            child1.AttachedToVisualTree += (_, _) => parent.AddChild(child2);
+
+            root.VisualChildren.Add(parent);
+
+            Assert.Equal([child1, child2], parent.VisualChildren);
+            Assert.True(child1.IsAttachedToVisualTree());
+            Assert.True(child2.IsAttachedToVisualTree());
+        }
+
+        [Fact]
+        public void VisualChildren_Can_Be_Removed_During_AttachedToVisualTree()
+        {
+            var root = new TestRoot();
+            var parent = new TestVisual();
+            var child1 = new TestVisual();
+            var child2 = new TestVisual();
+
+            parent.AddChildren([child1, child2]);
+
+            child1.AttachedToVisualTree += (_, _) => parent.RemoveChild(child2);
+
+            root.VisualChildren.Add(parent);
+
+            Assert.Equal([child1], parent.VisualChildren);
+            Assert.True(child1.IsAttachedToVisualTree());
+            Assert.False(child2.IsAttachedToVisualTree());
+        }
+
+        [Fact]
+        public void VisualChildren_Can_Be_Added_During_DetachedFromVisualTree()
+        {
+            var root = new TestRoot();
+            var parent = new TestVisual();
+            var child1 = new TestVisual();
+            var child2 = new TestVisual();
+
+            parent.AddChild(child1);
+            root.VisualChildren.Add(parent);
+
+            child1.DetachedFromVisualTree += (_, _) => parent.AddChild(child2);
+
+            root.VisualChildren.Remove(parent);
+
+            Assert.Equal([child1, child2], parent.VisualChildren);
+            Assert.False(child1.IsAttachedToVisualTree());
+            Assert.False(child2.IsAttachedToVisualTree());
+        }
+
+        [Fact]
+        public void VisualChildren_Can_Be_Removed_During_DetachedFromVisualTree()
+        {
+            var root = new TestRoot();
+            var parent = new TestVisual();
+            var child1 = new TestVisual();
+            var child2 = new TestVisual();
+            var child2Detached = 0;
+
+            parent.AddChildren([child1, child2]);
+            root.VisualChildren.Add(parent);
+
+            child1.DetachedFromVisualTree += (_, _) => parent.RemoveChild(child2);
+            child2.DetachedFromVisualTree += (_, _) => ++child2Detached;
+
+            root.VisualChildren.Remove(parent);
+
+            Assert.Equal([child1], parent.VisualChildren);
+            Assert.False(child1.IsAttachedToVisualTree());
+            Assert.False(child2.IsAttachedToVisualTree());
+            Assert.Equal(1, child2Detached);
+        }
+
         [Fact]
         public void Root_Should_Return_Self_As_VisualRoot()
         {

From af6e2e65b1762b2748160b412df1da6d3aa2b327 Mon Sep 17 00:00:00 2001
From: Max Katz <maxkatz6@outlook.com>
Date: Thu, 30 Jul 2026 02:57:24 -0700
Subject: [PATCH 134/196] Avalonia.Native: Support manually copied dylib on
 non-OSX platfroms (#21891)

---
 src/Avalonia.Native/Avalonia.Native.csproj | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/Avalonia.Native/Avalonia.Native.csproj b/src/Avalonia.Native/Avalonia.Native.csproj
index da64838fb9..38b5ad6e61 100644
--- a/src/Avalonia.Native/Avalonia.Native.csproj
+++ b/src/Avalonia.Native/Avalonia.Native.csproj
@@ -1,17 +1,22 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <PackAvaloniaNative Condition="'$(PackAvaloniaNative)' == ''">$([MSBuild]::IsOSPlatform(OSX))</PackAvaloniaNative>
-    <IsPackable>$(PackAvaloniaNative)</IsPackable>
-    <IsPackable Condition="'$([MSBuild]::IsOSPlatform(OSX))' == 'True'">true</IsPackable>
-    <IsPackable Condition="'$(ForcePackAvaloniaNative)' == 'True'">True</IsPackable>
     <TargetFrameworks>$(AvsCurrentTargetFramework);$(AvsLegacyTargetFrameworks)</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <UseMicroComGeneratorRoslyn>true</UseMicroComGeneratorRoslyn>
+
+    <!-- Include libAvaloniaNative.dylib, only if we are on macOS host or dylib was manually copied -->
+    <AvaloniaNativeDylibPath>$([System.IO.Path]::GetFullPath($(MSBuildThisFileDirectory)../../Build/Products/Release/libAvalonia.Native.OSX.dylib))</AvaloniaNativeDylibPath>
+    <IncludeAvaloniaDylib Condition="'$(IncludeAvaloniaDylib)' == '' AND Exists($(AvaloniaNativeDylibPath))">true</IncludeAvaloniaDylib>
+    <IncludeAvaloniaDylib Condition="'$(IncludeAvaloniaDylib)' == ''">$([MSBuild]::IsOSPlatform(OSX))</IncludeAvaloniaDylib>
+
+    <!-- It only makes sense to pack Avalonia.Native, if it includes dylib, of if it was enforced -->
+    <IsPackable>$(IncludeAvaloniaDylib)</IsPackable>
+    <IsPackable Condition="'$(ForcePackAvaloniaNative)' == 'True'">True</IsPackable>
   </PropertyGroup>
 
-  <ItemGroup Condition="'$(PackAvaloniaNative)' == 'true'">
-    <Content Include="../../Build/Products/Release/libAvalonia.Native.OSX.dylib">
+  <ItemGroup Condition="'$(IncludeAvaloniaDylib)' == 'true'">
+    <Content Include="$(AvaloniaNativeDylibPath)">
       <Link>libAvaloniaNative.dylib</Link>
       <PackagePath>runtimes/osx/native/libAvaloniaNative.dylib</PackagePath>
       <Pack>true</Pack>

From 9fb3fc84ec4c27475c406dfb11c6638792bb4d81 Mon Sep 17 00:00:00 2001
From: Max Katz <maxkatz6@outlook.com>
Date: Thu, 30 Jul 2026 05:17:40 -0700
Subject: [PATCH 135/196] Enable IsTrimmable+IsAotCompatible on all sample
 projects, fix warnings (#21892)

* Remove MonoMac.NetStandard

(cherry picked from commit 4aac4c4168a73496b579dd28270e8d71764497c7)

* Several AOT compat issues

(cherry picked from commit e9f0a8e6d29da140f3f255e79bd199067981b0fe)

* Add UnconditionalSuppressMessage to the DataValidationViewModel

* Suppress trimming warning on WithDataAnnotationsValidation method

* Unnecessary AvaloniaXaml

* include TrimmingEnable on all sample projects

* Add missing SelfContained to the WinUI projects

* Include TrimmingEnable on DesignerSupport only for warnings analyzer, explicitly disable IsAotCompatible

* Disable trimming warnings for WinUI projects completely

* Enable back runtime marshalling for samples

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 build/TrimmingEnable.props                    |  8 +--
 .../ControlCatalog.Desktop.csproj             |  2 -
 .../NativeControls/Mac/EmbedSample.Mac.cs     | 54 ++++++++++++++-----
 .../NativeControls/Mac/MacHelper.cs           | 38 -------------
 .../NativeControls/Mac/ObjC.cs                | 28 ++++++++++
 samples/ControlCatalog/ControlCatalog.csproj  |  6 ---
 .../Pages/NumericUpDownPage.xaml.cs           |  2 +-
 .../ViewModels/CursorPageViewModel.cs         |  3 +-
 .../ViewModels/DataValidationViewModel.cs     |  2 +
 .../ControlGallery.WinUI.csproj               |  5 +-
 samples/Directory.Build.props                 |  3 ++
 .../WinUIEmbedSample/WinUIEmbedSample.csproj  |  3 ++
 .../Diagnostics/TrimmingMessages.cs           |  4 +-
 src/Avalonia.Controls/AppBuilder.cs           |  2 +-
 .../Avalonia.DesignerSupport.csproj           |  2 +
 .../DesignWindowLoader.cs                     |  2 +
 .../Remote/FileWatcherTransport.cs            |  2 +
 .../Remote/RemoteDesignerEntryPoint.cs        |  3 ++
 18 files changed, 100 insertions(+), 69 deletions(-)
 delete mode 100644 samples/ControlCatalog.Desktop/NativeControls/Mac/MacHelper.cs
 create mode 100644 samples/ControlCatalog.Desktop/NativeControls/Mac/ObjC.cs

diff --git a/build/TrimmingEnable.props b/build/TrimmingEnable.props
index cf84ae67b4..da921eeffe 100644
--- a/build/TrimmingEnable.props
+++ b/build/TrimmingEnable.props
@@ -1,10 +1,10 @@
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 
   <PropertyGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0'))">
-    <SuppressTrimAnalysisWarnings>false</SuppressTrimAnalysisWarnings>
-    <EnableTrimAnalyzer>true</EnableTrimAnalyzer>
-    <TrimmerSingleWarn>false</TrimmerSingleWarn>
-    <IsTrimmable>true</IsTrimmable>
+    <SuppressTrimAnalysisWarnings Condition="'$(SuppressTrimAnalysisWarnings)' == ''">false</SuppressTrimAnalysisWarnings>
+    <EnableTrimAnalyzer Condition="'$(EnableTrimAnalyzer)' == ''">true</EnableTrimAnalyzer>
+    <TrimmerSingleWarn Condition="'$(TrimmerSingleWarn)' == ''">false</TrimmerSingleWarn>
+    <IsTrimmable Condition="'$(IsTrimmable)' == ''">true</IsTrimmable>
     <IsAotCompatible Condition="'$(IsAotCompatible)' == ''">true</IsAotCompatible>
     <ILLinkTreatWarningsAsErrors>$(TreatWarningsAsErrors)</ILLinkTreatWarningsAsErrors>
   </PropertyGroup>
diff --git a/samples/ControlCatalog.Desktop/ControlCatalog.Desktop.csproj b/samples/ControlCatalog.Desktop/ControlCatalog.Desktop.csproj
index 19fb2a0891..779e9b3462 100644
--- a/samples/ControlCatalog.Desktop/ControlCatalog.Desktop.csproj
+++ b/samples/ControlCatalog.Desktop/ControlCatalog.Desktop.csproj
@@ -27,8 +27,6 @@
     <ProjectReference Include="..\..\src\Linux\Avalonia.LinuxFramebuffer\Avalonia.LinuxFramebuffer.csproj" />
     <ProjectReference Include="..\ControlCatalog\ControlCatalog.csproj" />
     <ProjectReference Include="..\..\src\Avalonia.X11\Avalonia.X11.csproj" />
-    <!-- For native controls test -->
-    <PackageReference Include="MonoMac.NetStandard" />
   </ItemGroup>
 
   <PropertyGroup>
diff --git a/samples/ControlCatalog.Desktop/NativeControls/Mac/EmbedSample.Mac.cs b/samples/ControlCatalog.Desktop/NativeControls/Mac/EmbedSample.Mac.cs
index b761ce0972..cd8752825a 100644
--- a/samples/ControlCatalog.Desktop/NativeControls/Mac/EmbedSample.Mac.cs
+++ b/samples/ControlCatalog.Desktop/NativeControls/Mac/EmbedSample.Mac.cs
@@ -1,29 +1,57 @@
 using System;
+using System.Runtime.InteropServices;
 
+using Avalonia.Controls.Platform;
 using Avalonia.Platform;
-using Avalonia.Threading;
-
 using ControlCatalog.Pages;
 
-using MonoMac.Foundation;
-using MonoMac.WebKit;
-
 namespace ControlCatalog.Desktop;
 
 public class EmbedSampleMac : INativeDemoControl
 {
+    private static bool? s_webKitLoaded;
+
     public IPlatformHandle CreateControl(bool isSecond, IPlatformHandle parent, Func<IPlatformHandle> createDefault)
     {
-        // Note: We are using MonoMac for example purposes
-        // It shouldn't be used in production apps
-        MacHelper.EnsureInitialized();
+        s_webKitLoaded ??= NativeLibrary.TryLoad("/System/Library/Frameworks/WebKit.framework/WebKit", out _);
 
-        var webView = new WebView();
-        Dispatcher.UIThread.Post(() =>
+        if (s_webKitLoaded is false)
         {
-            webView.MainFrame.LoadRequest(new NSUrlRequest(new NSUrl(
-                isSecond ? "https://bing.com" : "https://google.com/")));
-        });
+            return createDefault();
+        }
+
+        // alloc
+        var webView = ObjC.MsgSend(ObjC.GetClass("WKWebView"), ObjC.GetUid("alloc"));
+        // init
+        webView = ObjC.MsgSend(webView, ObjC.GetUid("init"));
+
+        // ns url
+        var urlNsString = ObjC.CreateString(isSecond ? "https://bing.com" : "https://google.com/");
+        var url = ObjC.MsgSend(
+            ObjC.GetClass("NSURL"), ObjC.GetUid("URLWithString:"),
+            urlNsString);
+
+        // ns url request
+        var request = ObjC.MsgSend(ObjC.GetClass("NSURLRequest"), ObjC.GetUid("requestWithURL:"), url);
+
+        // load request
+        ObjC.MsgSend(webView, ObjC.GetUid("loadRequest:"), request);
+
         return new MacOSViewHandle(webView);
     }
+
+    private sealed class MacOSViewHandle(IntPtr view) : INativeControlHostDestroyableControlHandle
+    {
+        public IntPtr Handle { get; private set; } = view;
+        public string HandleDescriptor => "NSView";
+
+        public void Destroy()
+        {
+            if (Handle != IntPtr.Zero)
+            {
+                ObjC.MsgSend(Handle, ObjC.GetUid("release"));
+                Handle = IntPtr.Zero;
+            }
+        }
+    }
 }
diff --git a/samples/ControlCatalog.Desktop/NativeControls/Mac/MacHelper.cs b/samples/ControlCatalog.Desktop/NativeControls/Mac/MacHelper.cs
deleted file mode 100644
index 01325a5fa9..0000000000
--- a/samples/ControlCatalog.Desktop/NativeControls/Mac/MacHelper.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-
-using Avalonia.Controls.Platform;
-using MonoMac.AppKit;
-
-namespace ControlCatalog.Desktop;
-
-internal class MacHelper
-{
-    private static bool _isInitialized;
-
-    public static void EnsureInitialized()
-    {
-        if (_isInitialized)
-            return;
-        _isInitialized = true;
-        NSApplication.Init();
-    }
-}
-
-internal class MacOSViewHandle : INativeControlHostDestroyableControlHandle
-{
-    private NSView? _view;
-
-    public MacOSViewHandle(NSView view)
-    {
-        _view = view;
-    }
-
-    public IntPtr Handle => _view?.Handle ?? IntPtr.Zero;
-    public string HandleDescriptor => "NSView";
-
-    public void Destroy()
-    {
-        _view?.Dispose();
-        _view = null;
-    }
-}
diff --git a/samples/ControlCatalog.Desktop/NativeControls/Mac/ObjC.cs b/samples/ControlCatalog.Desktop/NativeControls/Mac/ObjC.cs
new file mode 100644
index 0000000000..3ef5c77ff7
--- /dev/null
+++ b/samples/ControlCatalog.Desktop/NativeControls/Mac/ObjC.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Runtime.InteropServices;
+using Avalonia.Platform.Interop;
+
+namespace ControlCatalog.Desktop;
+
+internal static partial class ObjC
+{
+    private const string LibObjC = "/usr/lib/libobjc.dylib";
+
+    public static IntPtr CreateString(string value)
+    {
+        using var utf8 = new Utf8Buffer(value);
+        return MsgSend(GetClass("NSString"), GetUid("stringWithUTF8String:"), utf8);
+    }
+
+    [LibraryImport(LibObjC, EntryPoint = "objc_getClass", StringMarshalling = StringMarshalling.Utf8)]
+    internal static partial IntPtr GetClass(string name);
+
+    [LibraryImport(LibObjC, EntryPoint = "sel_getUid", StringMarshalling = StringMarshalling.Utf8)]
+    internal static partial IntPtr GetUid(string selector);
+
+    [LibraryImport(LibObjC, EntryPoint = "objc_msgSend")]
+    internal static partial IntPtr MsgSend(IntPtr receiver, IntPtr selector);
+
+    [LibraryImport(LibObjC, EntryPoint = "objc_msgSend")]
+    internal static partial IntPtr MsgSend(IntPtr receiver, IntPtr selector, IntPtr arg);
+}
diff --git a/samples/ControlCatalog/ControlCatalog.csproj b/samples/ControlCatalog/ControlCatalog.csproj
index 800793ca0b..0cc232bfe2 100644
--- a/samples/ControlCatalog/ControlCatalog.csproj
+++ b/samples/ControlCatalog/ControlCatalog.csproj
@@ -41,12 +41,6 @@
     <ProjectReference Include="..\MiniMvvm\MiniMvvm.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <AvaloniaXaml Update="NavHeaderItem.xaml">
-      <Generator>MSBuild:Compile</Generator>
-    </AvaloniaXaml>
-  </ItemGroup>
-
   <Import Project="..\..\build\BuildTargets.targets" />
   <Import Project="..\..\build\SourceGenerators.props" />
   <Import Project="..\..\build\SkiaSharp.props" />
diff --git a/samples/ControlCatalog/Pages/NumericUpDownPage.xaml.cs b/samples/ControlCatalog/Pages/NumericUpDownPage.xaml.cs
index db64fba0ef..0254fbaa55 100644
--- a/samples/ControlCatalog/Pages/NumericUpDownPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/NumericUpDownPage.xaml.cs
@@ -71,7 +71,7 @@ namespace ControlCatalog.Pages
                 if (_spinnerLocations == null)
                 {
                     _spinnerLocations = new List<Location>();
-                    foreach (Location value in Enum.GetValues(typeof(Location)))
+                    foreach (var value in Enum.GetValues<Location>())
                     {
                         _spinnerLocations.Add(value);
                     }
diff --git a/samples/ControlCatalog/ViewModels/CursorPageViewModel.cs b/samples/ControlCatalog/ViewModels/CursorPageViewModel.cs
index dfcdd4361d..fc01473827 100644
--- a/samples/ControlCatalog/ViewModels/CursorPageViewModel.cs
+++ b/samples/ControlCatalog/ViewModels/CursorPageViewModel.cs
@@ -13,8 +13,7 @@ namespace ControlCatalog.ViewModels
     {
         public CursorPageViewModel()
         {
-            StandardCursors = Enum.GetValues(typeof(StandardCursorType))
-                .Cast<StandardCursorType>()
+            StandardCursors = Enum.GetValues<StandardCursorType>()
                 .Select(x => new StandardCursorModel(x))
                 .ToList();
 
diff --git a/samples/ControlCatalog/ViewModels/DataValidationViewModel.cs b/samples/ControlCatalog/ViewModels/DataValidationViewModel.cs
index 3b2c37699c..a50c9227ee 100644
--- a/samples/ControlCatalog/ViewModels/DataValidationViewModel.cs
+++ b/samples/ControlCatalog/ViewModels/DataValidationViewModel.cs
@@ -1,6 +1,7 @@
 using System;
 using System.ComponentModel;
 using System.ComponentModel.DataAnnotations;
+using System.Diagnostics.CodeAnalysis;
 using MiniMvvm;
 
 namespace ControlCatalog.ViewModels;
@@ -11,6 +12,7 @@ public class DataValidationViewModel : ViewModelBase
 
     [Required]
     [EmailAddress]
+    [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Does not apply to 'string' type.")]
     [MinLength(5)]
     public string? DataAnnotationsSample
     {
diff --git a/samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj b/samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj
index 4b3d246aaf..c500a2368a 100644
--- a/samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj
+++ b/samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj
@@ -13,6 +13,9 @@
     <EnableMsixTooling>true</EnableMsixTooling>
     <Nullable>enable</Nullable>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <SelfContained>true</SelfContained>
+    <SuppressTrimAnalysisWarnings>true</SuppressTrimAnalysisWarnings>
+    <EnableTrimAnalyzer>false</EnableTrimAnalyzer>
   </PropertyGroup>
 
   <ItemGroup>
@@ -64,4 +67,4 @@
     <PublishTrimmed Condition="'$(Configuration)' == 'Debug'">False</PublishTrimmed>
     <PublishTrimmed Condition="'$(Configuration)' != 'Debug'">True</PublishTrimmed>
   </PropertyGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/samples/Directory.Build.props b/samples/Directory.Build.props
index ae7dba55dc..0e3bbf60a0 100644
--- a/samples/Directory.Build.props
+++ b/samples/Directory.Build.props
@@ -8,10 +8,13 @@
     <LangVersion>14.0</LangVersion>
     <Nullable>enable</Nullable>
     <NoWarn>$(NoWarn);CS8002</NoWarn> <!-- ignore signing warnings for samples -->
+    <EnableRuntimeMarshalling>true</EnableRuntimeMarshalling>
   </PropertyGroup>
 
   <Import Project="..\build\SharedVersion.props"/>
   <Import Project="..\build\DevAnalyzers.props"/>
+  <Import Project="..\build\TrimmingEnable.props" />
+
   <Import Project="$(MSBuildThisFileDirectory)\..\Directory.Build.props" />
 
 </Project>
diff --git a/samples/WinUIEmbedSample/WinUIEmbedSample.csproj b/samples/WinUIEmbedSample/WinUIEmbedSample.csproj
index a19b06e24c..8a47a7860c 100644
--- a/samples/WinUIEmbedSample/WinUIEmbedSample.csproj
+++ b/samples/WinUIEmbedSample/WinUIEmbedSample.csproj
@@ -14,6 +14,9 @@
     <Nullable>enable</Nullable>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <IncludeAvaloniaGenerators>true</IncludeAvaloniaGenerators>
+    <SelfContained>true</SelfContained>
+    <SuppressTrimAnalysisWarnings>true</SuppressTrimAnalysisWarnings>
+    <EnableTrimAnalyzer>false</EnableTrimAnalyzer>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/Avalonia.Base/Diagnostics/TrimmingMessages.cs b/src/Avalonia.Base/Diagnostics/TrimmingMessages.cs
index 930ff4202b..8add7127b4 100644
--- a/src/Avalonia.Base/Diagnostics/TrimmingMessages.cs
+++ b/src/Avalonia.Base/Diagnostics/TrimmingMessages.cs
@@ -21,9 +21,11 @@ internal static class TrimmingMessages
     public const string SelectorsParseRequiresUnreferencedCodeMessage = "Selectors runtime parser might require unreferenced code. Consider using stronly typed selectors factory with 'new Style(s => s.OfType<Button>())' syntax.";
 
     public const string PropertyAccessorsRequiresUnreferencedCodeMessage = "PropertyAccessors might require unreferenced code.";
-    public const string DataValidationPluginRequiresUnreferencedCodeMessage = "DataValidationPlugin might require unreferenced code.";
     public const string StreamPluginRequiresUnreferencedCodeMessage = "StreamPlugin might require unreferenced code.";
 
+    public const string DataValidationPluginRequiresUnreferencedCodeMessage = "DataValidationPlugin might require unreferenced code.";
+    public const string DataValidationPluginSuppressUnreferencedCodeMessage = "DataValidationPlugin might require unreferenced code, but properties and attributes should be preserved by compiled bindings.";
+
     public const string StyleResourceIncludeRequiresUnreferenceCodeMessage = "StyleInclude and ResourceInclude use AvaloniaXamlLoader.Load which dynamically loads referenced assembly with Avalonia resources. Note, StyleInclude and ResourceInclude defined in XAML are resolved compile time and are safe with trimming and AOT.";
     public const string AvaloniaXamlLoaderRequiresUnreferenceCodeMessage = "AvaloniaXamlLoader.Load(uri, baseUri) dynamically loads referenced assembly with Avalonia resources.";
     public const string XamlTypeResolvedRequiresUnreferenceCodeMessage = "XamlTypeResolver might require unreferenced code.";
diff --git a/src/Avalonia.Controls/AppBuilder.cs b/src/Avalonia.Controls/AppBuilder.cs
index bc299bdbe1..ab9802a134 100644
--- a/src/Avalonia.Controls/AppBuilder.cs
+++ b/src/Avalonia.Controls/AppBuilder.cs
@@ -293,7 +293,7 @@ namespace Avalonia
         /// <summary>
         /// Adds support for validation using <c>System.ComponentModel.DataAnnotations</c>.
         /// </summary>
-        [RequiresUnreferencedCode(TrimmingMessages.PropertyAccessorsRequiresUnreferencedCodeMessage)]
+        [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = TrimmingMessages.DataValidationPluginSuppressUnreferencedCodeMessage)]
         public AppBuilder WithDataAnnotationsValidation()
         {
             if (!BindingPlugins.DataValidators.Any(x => x is DataAnnotationsValidationPlugin))
diff --git a/src/Avalonia.DesignerSupport/Avalonia.DesignerSupport.csproj b/src/Avalonia.DesignerSupport/Avalonia.DesignerSupport.csproj
index ec3f384b12..df62bd291a 100644
--- a/src/Avalonia.DesignerSupport/Avalonia.DesignerSupport.csproj
+++ b/src/Avalonia.DesignerSupport/Avalonia.DesignerSupport.csproj
@@ -10,6 +10,7 @@
     <NoWarn>$(NoWarn);CS1591</NoWarn>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <NugetPackageName>Avalonia</NugetPackageName>
+    <IsAotCompatible>false</IsAotCompatible>
     <WebAppDir>$(MSBuildThisFileDirectory)Remote/HtmlTransport/webapp</WebAppDir>
   </PropertyGroup>
   <ItemGroup>
@@ -31,4 +32,5 @@
     <Exec Command="dnx Bun.Unofficial.Tool build.js" WorkingDirectory="$(WebAppDir)" />
   </Target>
 
+  <Import Project="..\..\build\TrimmingEnable.props" />
 </Project>
diff --git a/src/Avalonia.DesignerSupport/DesignWindowLoader.cs b/src/Avalonia.DesignerSupport/DesignWindowLoader.cs
index df6d7abd4d..b6138d0ca1 100644
--- a/src/Avalonia.DesignerSupport/DesignWindowLoader.cs
+++ b/src/Avalonia.DesignerSupport/DesignWindowLoader.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -12,6 +13,7 @@ using Avalonia.Styling;
 
 namespace Avalonia.DesignerSupport
 {
+    [RequiresUnreferencedCode("Remote designer relies on reflection")]
     public class DesignWindowLoader
     {
         public static Window LoadDesignerWindow(string xaml, string assemblyPath, string xamlFileProjectPath)
diff --git a/src/Avalonia.DesignerSupport/Remote/FileWatcherTransport.cs b/src/Avalonia.DesignerSupport/Remote/FileWatcherTransport.cs
index 45a6c97954..57024c4150 100644
--- a/src/Avalonia.DesignerSupport/Remote/FileWatcherTransport.cs
+++ b/src/Avalonia.DesignerSupport/Remote/FileWatcherTransport.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Threading.Tasks;
 using Avalonia.Remote.Protocol;
@@ -25,6 +26,7 @@ namespace Avalonia.DesignerSupport.Remote
             _disposed = true;
         }
 
+        [UnconditionalSuppressMessage("Trimming", "IL2075", Justification = "Debug method")]
         void Dump(object o, string pad)
         {
             foreach (var p in o.GetType().GetProperties())
diff --git a/src/Avalonia.DesignerSupport/Remote/RemoteDesignerEntryPoint.cs b/src/Avalonia.DesignerSupport/Remote/RemoteDesignerEntryPoint.cs
index 0dfab530ea..0cd127cf52 100644
--- a/src/Avalonia.DesignerSupport/Remote/RemoteDesignerEntryPoint.cs
+++ b/src/Avalonia.DesignerSupport/Remote/RemoteDesignerEntryPoint.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Net;
 using System.Reflection;
 using System.Threading;
@@ -12,6 +13,7 @@ using Avalonia.Threading;
 
 namespace Avalonia.DesignerSupport.Remote
 {
+    [RequiresUnreferencedCode("Remote designer relies on reflection")]
     public class RemoteDesignerEntryPoint
     {
         private static ClientSupportedPixelFormatsMessage s_supportedPixelFormats;
@@ -132,6 +134,7 @@ namespace Avalonia.DesignerSupport.Remote
            IAvaloniaRemoteTransportConnection ConfigureApp(IAvaloniaRemoteTransportConnection transport, CommandLineArgs args, object obj);
         }
 
+        [RequiresUnreferencedCode("Remote designer relies on reflection")]
         class AppInitializer : IAppInitializer
         {
             public IAvaloniaRemoteTransportConnection ConfigureApp(IAvaloniaRemoteTransportConnection transport,

From c56fc3f798df56963f13d3fd59bf4517c29576ea Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Fri, 31 Jul 2026 02:32:06 +1000
Subject: [PATCH 136/196] Fix Loaded event processing after a handler throws
 (#21877)

* test: add failing test for Loaded processing after handler exception

A control whose Loaded handler throws currently breaks the static
loaded-processing machinery: remaining controls in the same dispatcher
batch are skipped and, because _isLoadedProcessing is never reset,
every control created afterwards app-wide never receives Loaded.

The test attaches a throwing control between two siblings, expects the
exception to surface from the dispatcher job, and asserts that both
siblings and a control added in a later batch still get Loaded.

Issue #18742

* fix: recover Loaded event processing after a handler throws

Previously the static loadedProcessingAction iterated the pending
controls with no exception handling. If any control's Loaded handler
or OnLoaded override threw, the batch loop aborted, so:

- _isLoadedProcessing stayed true forever, and since
  ScheduleOnLoadedCore only posts a dispatcher job when that flag is
  false, no control created afterwards, app-wide, ever received
  Loaded;
- the remaining controls in the current batch were skipped;
- the stuck processing queue retained control references (leak).

The invariant violated was that _isLoadedProcessing is true only while
a loaded-processing dispatcher job is actually scheduled or running.

Fix: process the snapshot as a drain queue (Dequeue before invoking,
because OnLoadedCore must not run twice for a control) and restore the
invariant in a finally block: requeue the unprocessed remainder, clear
the processing queue, reset the flag and post a new dispatcher job if
work remains. try/finally was chosen over catching per control so the
exception still propagates to the dispatcher as an unhandled exception
(matching WPF semantics) instead of being swallowed or aggregated,
while controls after the faulty one get Loaded on the next dispatcher
job.

Fixes #18742
---
 src/Avalonia.Controls/Control.cs              | 39 ++++++-----
 .../LoadedTests.cs                            | 67 ++++++++++++++++++-
 2 files changed, 90 insertions(+), 16 deletions(-)

diff --git a/src/Avalonia.Controls/Control.cs b/src/Avalonia.Controls/Control.cs
index 6b37e48c42..4a17b69c81 100644
--- a/src/Avalonia.Controls/Control.cs
+++ b/src/Avalonia.Controls/Control.cs
@@ -93,7 +93,7 @@ namespace Avalonia.Controls
 
         private static bool _isLoadedProcessing = false;
         private static readonly HashSet<Control> _loadedQueue = new HashSet<Control>();
-        private static readonly HashSet<Control> _loadedProcessingQueue = new HashSet<Control>();
+        private static readonly Queue<Control> _loadedProcessingQueue = new Queue<Control>();
 
         private LoadState _loadState = LoadState.Unloaded;
         private DataTemplates? _dataTemplates;
@@ -244,29 +244,38 @@ namespace Avalonia.Controls
         {
             // Copy the loaded queue for processing
             // There was a possibility of the "Collection was modified; enumeration operation may not execute."
-            // exception when only a single hash set was used. This could happen when new controls are added
-            // within the Loaded callback/event itself. To fix this, two hash sets are used and while one is
+            // exception when only a single collection was used. This could happen when new controls are added
+            // within the Loaded callback/event itself. To fix this, two collections are used and while one is
             // being processed the other accepts adding new controls to process next.
-            _loadedProcessingQueue.Clear();
             foreach (Control control in _loadedQueue)
             {
-                _loadedProcessingQueue.Add(control);
+                _loadedProcessingQueue.Enqueue(control);
             }
             _loadedQueue.Clear();
 
-            foreach (Control control in _loadedProcessingQueue)
+            try
             {
-                control.OnLoadedCore();
+                while (_loadedProcessingQueue.Count > 0)
+                {
+                    _loadedProcessingQueue.Dequeue().OnLoadedCore();
+                }
             }
-
-            _loadedProcessingQueue.Clear();
-            _isLoadedProcessing = false;
-
-            // Restart if any controls were added to the queue while processing
-            if (_loadedQueue.Count > 0)
+            finally
             {
-                _isLoadedProcessing = true;
-                Dispatcher.UIThread.Post(loadedProcessingAction!, DispatcherPriority.Loaded);
+                // An exception from OnLoadedCore (a Loaded handler or override) propagates to the
+                // dispatcher as usual, but the processing machinery must recover: controls left
+                // unprocessed are requeued and a new dispatcher job is posted for them, so a single
+                // faulty handler cannot stop Loaded from ever being raised again (see #18742).
+                _loadedQueue.UnionWith(_loadedProcessingQueue);
+                _loadedProcessingQueue.Clear();
+                _isLoadedProcessing = false;
+
+                // Restart if any controls were added to the queue while processing
+                if (_loadedQueue.Count > 0)
+                {
+                    _isLoadedProcessing = true;
+                    Dispatcher.UIThread.Post(loadedProcessingAction!, DispatcherPriority.Loaded);
+                }
             }
         };
 
diff --git a/tests/Avalonia.Controls.UnitTests/LoadedTests.cs b/tests/Avalonia.Controls.UnitTests/LoadedTests.cs
index fd70a0ed63..402b5be246 100644
--- a/tests/Avalonia.Controls.UnitTests/LoadedTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/LoadedTests.cs
@@ -1,4 +1,5 @@
-using Avalonia.Platform;
+using System;
+using Avalonia.Platform;
 using Avalonia.Threading;
 using Avalonia.UnitTests;
 using Moq;
@@ -73,6 +74,70 @@ public class LoadedTests : ScopedTestBase
         }
     }
 
+    [Fact]
+    public void Loaded_Exception_Does_Not_Prevent_Other_Controls_From_Loading()
+    {
+        // Some other tests are populating the queue and are not resetting the dispatcher, so we need to purge it
+        Control.ResetLoadedQueueForUnitTests();
+        using (UnitTestApplication.Start(TestServices.StyledWindow))
+        {
+            var window = new Window();
+            window.Show();
+            Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded, TestContext.Current.CancellationToken);
+
+            // Batch 1: a control whose Loaded handler throws, plus siblings queued in the same batch.
+            var throwing = new Button();
+            throwing.Loaded += (_, _) => throw new InvalidOperationException("Loaded handler failure");
+
+            var sibling1 = new Button();
+            var sibling2 = new Button();
+            int sibling1LoadedCount = 0, sibling2LoadedCount = 0;
+            sibling1.Loaded += (_, _) => sibling1LoadedCount++;
+            sibling2.Loaded += (_, _) => sibling2LoadedCount++;
+
+            window.Content = new StackPanel { Children = { sibling1, throwing, sibling2 } };
+
+            // The exception must surface (propagate to the dispatcher), not be swallowed.
+            PumpLoadedJobs(swallowedExceptionsAllowed: 1);
+
+            // Both siblings from the same batch must still have been loaded.
+            Assert.True(sibling1.IsLoaded);
+            Assert.True(sibling2.IsLoaded);
+            Assert.Equal(1, sibling1LoadedCount);
+            Assert.Equal(1, sibling2LoadedCount);
+
+            // Batch 2: controls loaded afterwards must still receive Loaded.
+            var later = new Button();
+            int laterLoadedCount = 0;
+            later.Loaded += (_, _) => laterLoadedCount++;
+            ((StackPanel)window.Content!).Children.Add(later);
+
+            PumpLoadedJobs(swallowedExceptionsAllowed: 0);
+
+            Assert.True(later.IsLoaded);
+            Assert.Equal(1, laterLoadedCount);
+        }
+    }
+
+    private static void PumpLoadedJobs(int swallowedExceptionsAllowed)
+    {
+        // A throwing Loaded handler propagates its exception out of the dispatcher job.
+        // Keep pumping so that any rescheduled loaded-processing jobs also run, but fail
+        // if more exceptions escape than the single expected one.
+        for (var i = 0; i <= swallowedExceptionsAllowed; i++)
+        {
+            try
+            {
+                Dispatcher.UIThread.RunJobs(DispatcherPriority.Loaded, TestContext.Current.CancellationToken);
+                return;
+            }
+            catch (InvalidOperationException) when (i < swallowedExceptionsAllowed)
+            {
+                // Expected exception from the throwing Loaded handler; continue pumping.
+            }
+        }
+    }
+
     [Fact]
     public void Loaded_Should_Not_Be_Raised_If_Detached_From_Visual_Tree()
     {

From ac4b7ac23c4b8e0d4db8b3b609c68b09d4cb5537 Mon Sep 17 00:00:00 2001
From: James Jackson-South <james_south@hotmail.com>
Date: Fri, 31 Jul 2026 03:28:30 +1000
Subject: [PATCH 137/196] Add IImageBrushSource.GetBitmap(), update build/api
 suppressions (#21638)

* Expose IRef/IImageBrushSource, update build/api suppressions

* Hide IRef from image brush source API

Internalized `IRef<T>` and removed it from the `IImageBrushSource` public surface by making `Bitmap` internal. Added a `[PrivateApi]` `GetBitmap()` helper returning `IBitmapImpl?` so internal consumers can still access the bitmap without exposing ref-count internals. Updated Skia drawing code to use `GetBitmap()` and refreshed API suppression entries accordingly.
---
 Directory.Build.props                        |  2 ++
 api/Avalonia.nupkg.xml                       | 12 ++++++++++++
 src/Avalonia.Base/Media/IImageBrush.cs       | 12 ++++++++++++
 src/Avalonia.Base/Utilities/Ref.cs           |  6 +++++-
 src/Skia/Avalonia.Skia/DrawingContextImpl.cs |  2 +-
 5 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/Directory.Build.props b/Directory.Build.props
index 400198daf9..931a386d31 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -10,6 +10,8 @@
     <LangVersion>14.0</LangVersion>
     <TreatWarningsAsErrors Condition="'$(TreatWarningsAsErrors)' == ''">$(AvnTreatWarningsAsErrors)</TreatWarningsAsErrors>
     <TreatWarningsAsErrors Condition="'$(TreatWarningsAsErrors)' == '' And '$(Configuration)' == 'Release'">true</TreatWarningsAsErrors>
+    <!-- Suppress NU1507 so local source builds do not warn about the consuming solution's package sources. -->
+    <NoWarn>$(NoWarn);NU1507</NoWarn>
     <CreateHardLinksForCopyAdditionalFilesIfPossible>true</CreateHardLinksForCopyAdditionalFilesIfPossible>
     <CreateHardLinksForCopyFilesToOutputDirectoryIfPossible>true</CreateHardLinksForCopyFilesToOutputDirectoryIfPossible>
     <CreateHardLinksForCopyLocalIfPossible>true</CreateHardLinksForCopyLocalIfPossible>
diff --git a/api/Avalonia.nupkg.xml b/api/Avalonia.nupkg.xml
index ce13834a0b..ab26c5e135 100644
--- a/api/Avalonia.nupkg.xml
+++ b/api/Avalonia.nupkg.xml
@@ -157,6 +157,12 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>P:Avalonia.Media.IImageBrushSource.Bitmap</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Controls.Platform.IWin32OptionsTopLevelImpl.SetWindowCornerPreference(Avalonia.Controls.Win32Properties.WindowCornerPreference)</Target>
@@ -181,6 +187,12 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>P:Avalonia.Media.IImageBrushSource.Bitmap</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Controls.Platform.IWin32OptionsTopLevelImpl.SetWindowCornerPreference(Avalonia.Controls.Win32Properties.WindowCornerPreference)</Target>
diff --git a/src/Avalonia.Base/Media/IImageBrush.cs b/src/Avalonia.Base/Media/IImageBrush.cs
index 439a9401d5..0852f55e8f 100644
--- a/src/Avalonia.Base/Media/IImageBrush.cs
+++ b/src/Avalonia.Base/Media/IImageBrush.cs
@@ -17,9 +17,21 @@ namespace Avalonia.Media
         IImageBrushSource? Source { get; }
     }
 
+    /// <summary>
+    /// Provides access to the image source of an <see cref="IImageBrush"/>. 
+    /// </summary>
     [NotClientImplementable]
     public interface IImageBrushSource
     {
         internal IRef<IBitmapImpl>? Bitmap { get; }
+
+        /// <summary>
+        /// Gets the bitmap implementation of the image source.
+        /// </summary>
+        /// <returns>
+        /// The <see cref="IBitmapImpl"/> instance if available; otherwise, <c>null</c>.
+        /// </returns>
+        [PrivateApi]
+        IBitmapImpl? GetBitmap() => Bitmap?.Item;
     }
 }
diff --git a/src/Avalonia.Base/Utilities/Ref.cs b/src/Avalonia.Base/Utilities/Ref.cs
index 49a7a42710..499bd1bf02 100644
--- a/src/Avalonia.Base/Utilities/Ref.cs
+++ b/src/Avalonia.Base/Utilities/Ref.cs
@@ -7,7 +7,11 @@ namespace Avalonia.Utilities
     /// <summary>
     /// A ref-counted wrapper for a disposable object.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="T">
+    /// The type of the item being ref-counted. 
+    /// Must be a reference type to avoid issues with copying value types and must be disposable
+    /// to ensure the item is cleaned up when the refcount reaches 0.
+    /// </typeparam>
     internal interface IRef<out T> : IDisposable where T : class
     {
         /// <summary>
diff --git a/src/Skia/Avalonia.Skia/DrawingContextImpl.cs b/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
index 8fd2454f33..03fa3d7686 100644
--- a/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
+++ b/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
@@ -1428,7 +1428,7 @@ namespace Avalonia.Skia
             }
             else
             {
-                tileBrushImage = (tileBrush as IImageBrush)?.Source?.Bitmap?.Item as IDrawableBitmapImpl;
+                tileBrushImage = (tileBrush as IImageBrush)?.Source?.GetBitmap() as IDrawableBitmapImpl;
             }
 
             if (tileBrush != null && tileBrushImage != null)

From f159423f691946e713f454447a780d4677d8a0d2 Mon Sep 17 00:00:00 2001
From: Benedikt Stebner <Gillibald@users.noreply.github.com>
Date: Fri, 31 Jul 2026 11:45:49 +0200
Subject: [PATCH 138/196] fix(macos): correct NSTextInputClient range and out
 parameter handling (#21885)

attributedSubstringForProposedRange:actualRange: read *actualRange on
entry and used it as the proposed range. actualRange is an out parameter
and is uninitialized on entry, so the substring was taken from an
arbitrary range. It also never wrote the out parameter. It now intersects
the requested range with the document and writes the result, or
{NSNotFound, 0} when the intersection is empty.

The same class of issue affected the rest of the protocol implementation:

- firstRectForCharacterRange:actualRange: never wrote actualRange, and
  dereferenced the parent without a null check.
- unmarkText dereferenced the parent without a null check.
- selectedRange and setSelection:: passed the managed selection through
  unclamped, so a stale or reversed selection produced a range past the
  end of the document, which AppKit then fed back into the substring
  call. Reversed pairs are now swapped and both ends clamped.
- markedRange returned {selectionLocation, 0} instead of the documented
  {NSNotFound, 0} when there is no marked text.
- The replacement ranges in setMarkedText:selectedRange:replacementRange:
  and insertText:replacementRange: are clamped before being passed to
  SelectInSurroundingText.
- setText: re-clamps the stored ranges, as replacing the document can
  strand them out of bounds.

Nil strings and nil UTF8String results are no longer passed across the
COM boundary, and SetSurroundingText no longer calls
stringWithUTF8String: on a null pointer.
---
 .../src/OSX/AvnTextInputMethod.mm             |   5 +-
 native/Avalonia.Native/src/OSX/AvnView.mm     | 145 ++++++++++++++----
 2 files changed, 115 insertions(+), 35 deletions(-)

diff --git a/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm b/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm
index 386a031336..a08f3886c8 100644
--- a/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm
+++ b/native/Avalonia.Native/src/OSX/AvnTextInputMethod.mm
@@ -33,7 +33,10 @@ void AvnTextInputMethod::Reset() {
 }
 
 void AvnTextInputMethod::SetSurroundingText(char* text, int start, int end) {
-    [_inputMethodDelegate setText:[NSString stringWithUTF8String:text]];
+    // stringWithUTF8String: throws on a null pointer and returns nil for invalid UTF-8.
+    NSString* surroundingText = text != nullptr ? [NSString stringWithUTF8String:text] : nil;
+
+    [_inputMethodDelegate setText:surroundingText != nil ? surroundingText : @""];
     [_inputMethodDelegate setSelection: start:end];
 }
 
diff --git a/native/Avalonia.Native/src/OSX/AvnView.mm b/native/Avalonia.Native/src/OSX/AvnView.mm
index 9b05566479..d4ab79bc47 100644
--- a/native/Avalonia.Native/src/OSX/AvnView.mm
+++ b/native/Avalonia.Native/src/OSX/AvnView.mm
@@ -755,25 +755,48 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
     return (AvnInputModifiers)rv;
 }
 
+// Clamps a range so that it can never be used to index outside of _text.
+// Ranges reaching us from AppKit or from the managed side are not guaranteed to be valid.
+- (NSRange)clampRangeToText:(NSRange)range
+{
+    if (range.location == NSNotFound)
+        return NSMakeRange(NSNotFound, 0);
+
+    NSUInteger length = _text.length;
+
+    if (range.location > length)
+        return NSMakeRange(length, 0);
+
+    // Avoids the overflow of location + length that a plain bounds check would have.
+    return NSMakeRange(range.location, MIN(range.length, length - range.location));
+}
+
 - (BOOL)hasMarkedText
 {
-    return _markedRange.length > 0;
+    return _markedRange.location != NSNotFound && _markedRange.length > 0;
 }
 
 - (NSRange)markedRange
 {
-    return _markedRange;
+    // From the docs: returns {NSNotFound, 0} if there is no marked range.
+    if (![self hasMarkedText])
+        return NSMakeRange(NSNotFound, 0);
+
+    // The preedit isn't necessarily part of the surrounding text we got from the managed side,
+    // so only the location is clamped here. An overlong length is handled by
+    // attributedSubstringForProposedRange:actualRange:, as the docs require.
+    return NSMakeRange(MIN(_markedRange.location, _text.length), _markedRange.length);
 }
 
 - (NSRange)selectedRange
 {
-    return _selectedRange;
+    return [self clampRangeToText:_selectedRange];
 }
 
 - (void)setMarkedText:(id)string selectedRange:(NSRange)selectedRange replacementRange:(NSRange)replacementRange
 {
     NSString* markedText;
-        
+
     if([string isKindOfClass:[NSAttributedString class]])
     {
         markedText = [string string];
@@ -782,35 +805,47 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
     {
         markedText = (NSString*) string;
     }
-    
+
+    if (markedText == nil)
+    {
+        markedText = @"";
+    }
+
     auto parent = _parent.tryGet();
 
     // Delete any replaced range
-    if (replacementRange.location != NSNotFound && parent != nullptr && parent->InputMethod->IsActive())
+    auto finalReplacementRange = [self clampRangeToText:replacementRange];
+
+    if (finalReplacementRange.location != NSNotFound && parent != nullptr && parent->InputMethod->IsActive())
     {
-        parent->InputMethod->Client->SelectInSurroundingText((int)replacementRange.location, (int)(replacementRange.location + replacementRange.length));
+        parent->InputMethod->Client->SelectInSurroundingText((int)finalReplacementRange.location, (int)(finalReplacementRange.location + finalReplacementRange.length));
         uint64_t timestamp = static_cast<uint64_t>([NSDate timeIntervalSinceReferenceDate] * 1000);
         parent->TopLevelEvents->RawKeyEvent(KeyDown, timestamp, AvnInputModifiersNone, AvnKeyBack, AvnPhysicalKeyNone, "\b");
         parent->TopLevelEvents->RawKeyEvent(KeyUp, timestamp, AvnInputModifiersNone, AvnKeyBack, AvnPhysicalKeyNone, "\b");
     }
-    
-    _markedRange = NSMakeRange(_selectedRange.location, [markedText length]);
+
+    auto markedLocation = [self selectedRange].location;
+
+    _markedRange = NSMakeRange(markedLocation == NSNotFound ? 0 : markedLocation, [markedText length]);
 
     if (parent != nullptr && parent->InputMethod->IsActive())
     {
-        parent->InputMethod->Client->SetPreeditText((char*)[markedText UTF8String]);
+        const char* utf8MarkedText = [markedText UTF8String];
+        parent->InputMethod->Client->SetPreeditText((char*)(utf8MarkedText != nullptr ? utf8MarkedText : ""));
     }
 }
 
 - (void)unmarkText
 {
     auto parent = _parent.tryGet();
-    if(parent->InputMethod->IsActive()){
+    if(parent != nullptr && parent->InputMethod->IsActive()){
         parent->InputMethod->Client->SetPreeditText(nullptr);
     }
-    
-    _markedRange = NSMakeRange(_selectedRange.location, 0);
-    
+
+    auto selectionLocation = [self selectedRange].location;
+
+    _markedRange = NSMakeRange(selectionLocation == NSNotFound ? 0 : selectionLocation, 0);
+
     if([self inputContext]) {
         [[self inputContext] discardMarkedText];
     }
@@ -823,20 +858,27 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
 
 - (NSAttributedString *)attributedSubstringForProposedRange:(NSRange)range actualRange:(NSRangePointer)actualRange
 {
-    if(actualRange){
-        range = *actualRange;
-    }
-
     // From the docs: an implementation of this method should be prepared for aRange to be out of bounds.
     // In this case, you should return the intersection of the document's range and aRange.
     // If the location of aRange is completely outside of the document's range, return nil.
-    auto finalRange = NSIntersectionRange(range, NSMakeRange(0, _text.length));
-    
+    // actualRange is an out parameter: it is uninitialized on entry and must only be written to.
+    NSRange docRange = NSMakeRange(0, _text.length);
+    NSRange finalRange = NSIntersectionRange(range, docRange);
+
     if (finalRange.length == 0)
+    {
+        if (actualRange) {
+            *actualRange = NSMakeRange(NSNotFound, 0);
+        }
+
         return nil;
-    
-    NSAttributedString* subString = [_text attributedSubstringFromRange:finalRange];
-    return subString;
+    }
+
+    if (actualRange) {
+        *actualRange = finalRange;
+    }
+
+    return [_text attributedSubstringFromRange:finalRange];
 }
 
 - (void)insertText:(id)string replacementRange:(NSRange)replacementRange
@@ -856,19 +898,28 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
     {
         text = (NSString*) string;
     }
-    
-    if (replacementRange.location != NSNotFound &&
+
+    if (text == nil)
+    {
+        text = @"";
+    }
+
+    auto finalReplacementRange = [self clampRangeToText:replacementRange];
+
+    if (finalReplacementRange.location != NSNotFound &&
         ![self hasMarkedText] &&
         parent->InputMethod->IsActive())
     {
-        parent->InputMethod->Client->SelectInSurroundingText((int)replacementRange.location, (int)(replacementRange.location + replacementRange.length));
+        parent->InputMethod->Client->SelectInSurroundingText((int)finalReplacementRange.location, (int)(finalReplacementRange.location + finalReplacementRange.length));
     }
-    
+
     [self unmarkText];
-        
+
     uint64_t timestamp = static_cast<uint64_t>([NSDate timeIntervalSinceReferenceDate] * 1000);
-        
-    parent->TopLevelEvents->RawTextInputEvent(timestamp, [text UTF8String]);
+
+    const char* utf8Text = [text UTF8String];
+
+    parent->TopLevelEvents->RawTextInputEvent(timestamp, utf8Text != nullptr ? utf8Text : "");
 }
 
 - (NSUInteger)characterIndexForPoint:(NSPoint)point
@@ -878,11 +929,17 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
 
 - (NSRect)firstRectForCharacterRange:(NSRange)range actualRange:(NSRangePointer)actualRange
 {
+    // actualRange is an out parameter: it is uninitialized on entry and must only be written to.
+    // We only ever report a single rect, so the requested range is echoed back clamped to the document.
+    if (actualRange) {
+        *actualRange = [self clampRangeToText:range];
+    }
+
     auto parent = _parent.tryGet();
-    if(!parent->InputMethod->IsActive()){
+    if(parent == nullptr || !parent->InputMethod->IsActive()){
         return NSZeroRect;
     }
-    
+
     return _cursorRect;
 }
 
@@ -1036,11 +1093,31 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
 }
 
 - (void) setText:(NSString *)text{
-    [[_text mutableString] setString:text];
+    [[_text mutableString] setString:text != nil ? text : @""];
+
+    // The document changed, so the stored ranges can now point outside of it.
+    _selectedRange = [self clampRangeToText:_selectedRange];
+
+    if (_markedRange.location != NSNotFound)
+    {
+        _markedRange = NSMakeRange(MIN(_markedRange.location, _text.length), _markedRange.length);
+    }
 }
 
 - (void) setSelection:(int)start :(int)end{
-    _selectedRange = NSMakeRange(start, end - start);
+    if (end < start)
+    {
+        auto temp = start;
+        start = end;
+        end = temp;
+    }
+
+    auto length = (int)_text.length;
+
+    start = MAX(0, MIN(start, length));
+    end = MAX(start, MIN(end, length));
+
+    _selectedRange = NSMakeRange((NSUInteger)start, (NSUInteger)(end - start));
 }
 
 - (void) resetInputMethod{

From bc04116b4bf483e93efa754448d20ebbc51a5f07 Mon Sep 17 00:00:00 2001
From: Anton Zelinsky <Anton.Zelinsky@gmail.com>
Date: Fri, 31 Jul 2026 13:56:50 +0200
Subject: [PATCH 139/196] Open a submenu when its parent menu item is clicked
 on macOS (#21890)

SetSubMenu left the item's own didSelectItem: action in place, so AppKit dispatched the click to it and dismissed the menu. Install submenuAction: as -[NSMenu setSubmenu:forItem:] does, and restore didSelectItem: when the submenu is removed, since the same NSMenuItem is reused.

Fixes #21886
---
 native/Avalonia.Native/src/OSX/menu.mm | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/native/Avalonia.Native/src/OSX/menu.mm b/native/Avalonia.Native/src/OSX/menu.mm
index a67c96a796..e664ee0ad6 100644
--- a/native/Avalonia.Native/src/OSX/menu.mm
+++ b/native/Avalonia.Native/src/OSX/menu.mm
@@ -101,20 +101,29 @@ NSMenuItem* AvnAppMenuItem::GetNative()
 HRESULT AvnAppMenuItem::SetSubMenu (IAvnMenu* menu)
 {
     START_COM_CALL;
-    
+
     @autoreleasepool
     {
         if(menu != nullptr)
         {
             auto nsMenu = dynamic_cast<AvnAppMenu*>(menu)->GetNative();
-            
+
             [_native setSubmenu: nsMenu];
+
+            // Parity with -[NSMenu setSubmenu:forItem:]: without submenuAction: a click is dispatched to
+            // didSelectItem: and dismisses the menu instead of opening the submenu.
+            [_native setTarget: nil];
+            [_native setAction: @selector(submenuAction:)];
         }
         else
         {
             [_native setSubmenu: nullptr];
+
+            // The item is reused, so put its own action back.
+            [_native setTarget: _native];
+            [_native setAction: @selector(didSelectItem:)];
         }
-        
+
         return S_OK;
     }
 }

From 49f8f055189745950b72483871be9c80dd8e4ae6 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@users.noreply.github.com>
Date: Fri, 31 Jul 2026 16:44:14 +0200
Subject: [PATCH 140/196] Expand security policy with response expectations and
 scope (#21901)

* Expand security policy with response expectations, supported versions and scope

Part of the coordinated vulnerability disclosure rollout: document
response-time commitments (acknowledge in 2 business days, timeline in
10), state the supported-versions policy (12.x), and clarify which
packages this policy covers.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
Co-authored-by: Mike James <mike@avaloniaui.net>
---
 SECURITY.md | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/SECURITY.md b/SECURITY.md
index 7b30c0cdf8..2c1637fd04 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,4 +1,5 @@
 # Security Policy
+Avalonia is free and open-source software published by AvaloniaUI OÜ. The framework is made publicly available at no charge and is not placed on the market within the meaning of the EU Cyber Resilience Act (Regulation (EU) 2024/2847). AvaloniaUI OÜ acts as the project's open-source software steward and maintains this cybersecurity policy in that capacity, in line with Article 24 of that Regulation.
 
 ## Reporting a Vulnerability
 
@@ -21,5 +22,25 @@ https://docs.github.com/en/code-security/how-tos/report-and-fix-vulnerabilities/
 ### Reporting via Email 
 Alternatively, you may report security vulnerabilities by emailing security@avaloniaui.net.
 
-### Misc 
+### What to Expect
+
+- We aim to acknowledge your report within **2 business days**.
+- We aim to confirm whether we consider it a vulnerability and to share a remediation timeline within **10 business days**.
+- We will keep you informed of progress and coordinate the disclosure date with you.
+- We will credit you in the published advisory unless you ask us not to.
+
+These timescales are the targets we work to for the open-source project; they are not contractual commitments. Organisations that require contractually binding response and remediation times can obtain them under a commercial agreement.
+
 Please note that Avalonia does not operate a bug bounty programme.
+
+## Versions Receiving Security Fixes
+| Version | Security fixes |
+|---|---|
+| 11.x and older | Not provided |
+| 12.x (current stable) | Provided |
+ 
+Security fixes are delivered at the head of the current stable series. If a vulnerability affects earlier 12.x releases, we fix it in a new release of the latest version, and the remediation path is to upgrade to that release. Security fixes for the current series are published openly and free of charge. Access to Avalonia's open-source releases, updates and security fixes is never conditional on payment.
+
+## Scope
+
+This policy covers the Avalonia framework packages published from this repository (`Avalonia` and the `Avalonia.*` platform and integration packages).

From 3c3a04d8cdec77c0ec9a5299dbd01f53d4cf4233 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Mon, 3 Aug 2026 15:58:11 +0500
Subject: [PATCH 141/196] Fix TODO entry from 2019 (#21889)

* Add non-overlay popup support to the headless platform

When AvaloniaHeadlessPlatformOptions.UsePlatformPopups is enabled,
popups are hosted in dedicated headless top-levels positioned via
ManagedPopupPositioner instead of the parent's overlay layer.
HeadlessWindowExtensions.GetOpenPopups exposes the popups open above
a given toplevel. PointToScreen/PointToClient now account for the
window position, so popup placement can be asserted in desktop
coordinates.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* Rename UsePlatformPopups to OverlayPopups for consistency with other platforms

Inverted semantics to match Win32/X11/macOS options; defaults to true
for now so existing headless test suites keep overlay popup behavior.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .../AvaloniaHeadlessPlatform.cs               |  14 +-
 .../HeadlessWindowExtensions.cs               |  13 ++
 .../Avalonia.Headless/HeadlessWindowImpl.cs   |  53 ++++-
 .../Avalonia.Headless/IHeadlessWindow.cs      |   3 +
 .../Avalonia.Headless.UnitTests/PopupTests.cs | 185 ++++++++++++++++++
 .../TestApplication.cs                        |   3 +-
 6 files changed, 258 insertions(+), 13 deletions(-)
 create mode 100644 tests/Avalonia.Headless.UnitTests/PopupTests.cs

diff --git a/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs b/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs
index 838301a6b5..9d5624d5ed 100644
--- a/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs
+++ b/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs
@@ -14,9 +14,9 @@ namespace Avalonia.Headless
         internal static Compositor? Compositor { get; private set; }
         private static IRenderTimer? s_renderTimer;
 
-        private class HeadlessWindowingPlatform(PixelFormat frameBufferFormat) : IWindowingPlatform
+        private class HeadlessWindowingPlatform(PixelFormat frameBufferFormat, bool overlayPopups) : IWindowingPlatform
         {
-            public IWindowImpl CreateWindow() => new HeadlessWindowImpl(false, frameBufferFormat);
+            public IWindowImpl CreateWindow() => new HeadlessWindowImpl(frameBufferFormat, overlayPopups);
             public ITopLevelImpl CreateEmbeddableTopLevel() => CreateEmbeddableWindow();
 
             public IWindowImpl CreateEmbeddableWindow() => throw new PlatformNotSupportedException();
@@ -49,7 +49,7 @@ namespace Avalonia.Headless
                 .Bind<IPlatformIconLoader>().ToSingleton<HeadlessIconLoaderStub>()
                 .Bind<IKeyboardDevice>().ToConstant(new KeyboardDevice())
                 .Bind<IRenderLoop>().ToConstant(Rendering.RenderLoop.FromTimer(s_renderTimer))
-                .Bind<IWindowingPlatform>().ToConstant(new HeadlessWindowingPlatform(opts.FrameBufferFormat))
+                .Bind<IWindowingPlatform>().ToConstant(new HeadlessWindowingPlatform(opts.FrameBufferFormat, opts.OverlayPopups))
                 .Bind<PlatformHotkeyConfiguration>().ToSingleton<PlatformHotkeyConfiguration>()
                 .Bind<KeyGestureFormatInfo>().ToConstant(new KeyGestureFormatInfo(new Dictionary<Key, string>() { }));
             Compositor = new Compositor( null);
@@ -115,6 +115,14 @@ namespace Avalonia.Headless
         /// Gets or sets the pixel format to be used for the headless Window framebuffers.
         /// </summary>
         public PixelFormat FrameBufferFormat { get; set; } = PixelFormat.Rgba8888;
+
+        /// <summary>
+        /// Embeds popups to the window when set to true. The default value is true.
+        /// When disabled, popups are hosted in dedicated headless top-levels that are not part of
+        /// the parent's visual tree; use <see cref="HeadlessWindowExtensions.GetOpenPopups"/> to access them.
+        /// </summary>
+        // TODO13: Change the default to false to match the other desktop platforms.
+        public bool OverlayPopups { get; set; } = true;
     }
 
     public static class AvaloniaHeadlessPlatformExtensions
diff --git a/src/Headless/Avalonia.Headless/HeadlessWindowExtensions.cs b/src/Headless/Avalonia.Headless/HeadlessWindowExtensions.cs
index 8bb3bf4f34..17fe5aa199 100644
--- a/src/Headless/Avalonia.Headless/HeadlessWindowExtensions.cs
+++ b/src/Headless/Avalonia.Headless/HeadlessWindowExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
@@ -114,6 +115,18 @@ public static class HeadlessWindowExtensions
         DragDropEffects effects, RawInputModifiers modifiers = RawInputModifiers.None) =>
         RunJobsOnImpl(topLevel, w => w.DragDrop(point, type, data, effects, modifiers));
 
+    /// <summary>
+    /// Returns the popups currently open directly above this toplevel, in z-order (bottom to top).
+    /// For popups nested in another popup, call this method on that popup's toplevel.
+    /// </summary>
+    /// <remarks>
+    /// Only popups hosted in dedicated headless top-levels are returned, which requires disabling
+    /// <see cref="AvaloniaHeadlessPlatformOptions.OverlayPopups"/>. Popups hosted in the overlay
+    /// layer are part of the parent's visual tree and are not tracked by the platform.
+    /// </remarks>
+    public static IReadOnlyList<TopLevel> GetOpenPopups(this TopLevel topLevel) =>
+        GetImpl(topLevel).GetOpenPopups();
+
     /// <summary>
     /// Changes the render scaling (DPI) of the headless window/toplevel.
     /// This simulates a DPI change, triggering scaling changed notifications and a layout pass.
diff --git a/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs b/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
index 0036288ac0..efc2c08a89 100644
--- a/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
+++ b/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
@@ -26,11 +26,14 @@ namespace Avalonia.Headless
         private WriteableBitmap? _lastRenderedFrame;
         private readonly object _sync = new object();
         private readonly PixelFormat _frameBufferFormat;
+        private readonly bool _overlayPopups;
+        private readonly HeadlessWindowImpl? _popupParent;
+        private readonly IPopupPositioner? _popupPositioner;
+        private readonly List<HeadlessWindowImpl> _openPopups = new();
         public bool IsPopup { get; }
 
-        public HeadlessWindowImpl(bool isPopup, PixelFormat frameBufferFormat)
+        public HeadlessWindowImpl(PixelFormat frameBufferFormat, bool overlayPopups)
         {
-            IsPopup = isPopup;
             Surfaces = [this];
             _keyboard = AvaloniaLocator.Current.GetRequiredService<IKeyboardDevice>();
             _screen = new HeadlessScreensStub();
@@ -38,10 +41,28 @@ namespace Avalonia.Headless
             MouseDevice = new MouseDevice(_mousePointer);
             ClientSize = new Size(1024, 768);
             _frameBufferFormat = frameBufferFormat;
+            _overlayPopups = overlayPopups;
+        }
+
+        private HeadlessWindowImpl(HeadlessWindowImpl popupParent)
+            : this(popupParent._frameBufferFormat, popupParent._overlayPopups)
+        {
+            IsPopup = true;
+            _popupParent = popupParent;
+            _popupPositioner = new ManagedPopupPositioner(
+                new ManagedPopupPositionerPopupImplHelper(popupParent, PopupMoveResize));
+        }
+
+        private void PopupMoveResize(PixelPoint position, Size size, double scaling)
+        {
+            Position = position;
+            PositionChanged?.Invoke(position);
+            DoResize(size, WindowResizeReason.Unspecified);
         }
 
         public void Dispose()
         {
+            _popupParent?._openPopups.Remove(this);
             Closed?.Invoke();
             _lastRenderedFrame?.Dispose();
             _lastRenderedFrame = null;
@@ -68,9 +89,9 @@ namespace Avalonia.Headless
 
         public IInputRoot? InputRoot { get; set; }
 
-        public Point PointToClient(PixelPoint point) => point.ToPoint(RenderScaling);
+        public Point PointToClient(PixelPoint point) => (point - Position).ToPoint(RenderScaling);
 
-        public PixelPoint PointToScreen(Point point) => PixelPoint.FromPoint(point, RenderScaling);
+        public PixelPoint PointToScreen(Point point) => PixelPoint.FromPoint(point, RenderScaling) + Position;
 
         public void SetCursor(ICursorImpl? cursor)
         {
@@ -82,6 +103,9 @@ namespace Avalonia.Headless
 
         public void Show(bool activate, bool isDialog)
         {
+            if (_popupParent != null && !_popupParent._openPopups.Contains(this))
+                _popupParent._openPopups.Add(this);
+
             if (activate)
             {
                 ZOrder = _nextGlobalZOrder++;
@@ -91,6 +115,7 @@ namespace Avalonia.Headless
 
         public void Hide()
         {
+            _popupParent?._openPopups.Remove(this);
             Dispatcher.UIThread.Post(() => Deactivated?.Invoke(), DispatcherPriority.Input);
         }
 
@@ -239,8 +264,7 @@ namespace Avalonia.Headless
 
         private ulong Timestamp => (ulong)_st.ElapsedMilliseconds;
 
-        // TODO: Hook recent Popup changes. 
-        IPopupPositioner IPopupImpl.PopupPositioner => null!;
+        IPopupPositioner IPopupImpl.PopupPositioner => _popupPositioner!;
 
         public Size MaxAutoSizeHint => new Size(1920, 1080);
 
@@ -379,10 +403,21 @@ namespace Avalonia.Headless
             PositionChanged?.Invoke(point);
         }
 
-        public IPopupImpl? CreatePopup()
+        public IPopupImpl? CreatePopup() => _overlayPopups ? null : new HeadlessWindowImpl(this);
+
+        public IReadOnlyList<TopLevel> GetOpenPopups()
         {
-            // TODO: Hook recent Popup changes. 
-            return null;
+            if (_openPopups.Count == 0)
+                return Array.Empty<TopLevel>();
+
+            var result = new List<TopLevel>(_openPopups.Count);
+            foreach (var popup in _openPopups)
+            {
+                if (popup.InputRoot is PresentationSource { FocusRoot: TopLevel topLevel })
+                    result.Add(topLevel);
+            }
+
+            return result;
         }
 
         public void SetWindowManagerAddShadowHint(bool enabled)
diff --git a/src/Headless/Avalonia.Headless/IHeadlessWindow.cs b/src/Headless/Avalonia.Headless/IHeadlessWindow.cs
index 44ac0a5ace..5e2dd6a13d 100644
--- a/src/Headless/Avalonia.Headless/IHeadlessWindow.cs
+++ b/src/Headless/Avalonia.Headless/IHeadlessWindow.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Input.Raw;
 using Avalonia.Media.Imaging;
@@ -17,5 +19,6 @@ namespace Avalonia.Headless
         void MouseWheel(Point point, Vector delta, RawInputModifiers modifiers = RawInputModifiers.None);
         void DragDrop(Point point, RawDragEventType type, IDataTransfer data, DragDropEffects effects, RawInputModifiers modifiers = RawInputModifiers.None);
         void SetRenderScaling(double scaling);
+        IReadOnlyList<TopLevel> GetOpenPopups();
     }
 }
diff --git a/tests/Avalonia.Headless.UnitTests/PopupTests.cs b/tests/Avalonia.Headless.UnitTests/PopupTests.cs
new file mode 100644
index 0000000000..2a1536ce50
--- /dev/null
+++ b/tests/Avalonia.Headless.UnitTests/PopupTests.cs
@@ -0,0 +1,185 @@
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Threading;
+
+namespace Avalonia.Headless.UnitTests;
+
+public class PopupTests
+{
+#if NUNIT
+    [AvaloniaTest]
+#elif XUNIT
+    [AvaloniaFact]
+#endif
+    public void Point_To_Screen_Respects_Window_Position()
+    {
+        var window = new Window { Width = 100, Height = 100 };
+        window.Position = new PixelPoint(100, 200);
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+
+        AssertHelper.Equal(new PixelPoint(110, 220), window.PointToScreen(new Point(10, 20)));
+        AssertHelper.Equal(new Point(10, 20), window.PointToClient(new PixelPoint(110, 220)));
+
+        window.Close();
+    }
+
+#if NUNIT
+    [AvaloniaTest]
+#elif XUNIT
+    [AvaloniaFact]
+#endif
+    public void Popup_Uses_Dedicated_TopLevel_And_Is_Discoverable()
+    {
+        var target = new Border { Background = Brushes.Red };
+        var popup = new Popup
+        {
+            PlacementTarget = target,
+            Child = new Border { Width = 20, Height = 20 }
+        };
+        var window = new Window
+        {
+            Width = 100,
+            Height = 100,
+            Content = new Panel { Children = { target, popup } }
+        };
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+
+        AssertHelper.Equal(0, window.GetOpenPopups().Count);
+
+        popup.Open();
+        Dispatcher.UIThread.RunJobs();
+
+        AssertHelper.True(popup.IsOpen);
+        AssertHelper.False(popup.IsUsingOverlayLayer);
+        AssertHelper.Equal(1, window.GetOpenPopups().Count);
+        AssertHelper.True(window.GetOpenPopups()[0] is PopupRoot);
+
+        popup.Close();
+        Dispatcher.UIThread.RunJobs();
+
+        AssertHelper.Equal(0, window.GetOpenPopups().Count);
+
+        window.Close();
+    }
+
+#if NUNIT
+    [AvaloniaTest]
+#elif XUNIT
+    [AvaloniaFact]
+#endif
+    public void Can_Click_Button_Inside_Platform_Popup()
+    {
+        var clickCount = 0;
+        var button = new Button { Width = 80, Height = 30 };
+        button.Click += (_, _) => clickCount++;
+
+        var target = new Border { Background = Brushes.Red };
+        var popup = new Popup { PlacementTarget = target, Child = button };
+        var window = new Window
+        {
+            Width = 100,
+            Height = 100,
+            Content = new Panel { Children = { target, popup } }
+        };
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+
+        popup.Open();
+        Dispatcher.UIThread.RunJobs();
+
+        var popupRoot = window.GetOpenPopups()[0];
+        popupRoot.MouseDown(new Point(40, 15), MouseButton.Left);
+        popupRoot.MouseUp(new Point(40, 15), MouseButton.Left);
+
+        AssertHelper.Equal(1, clickCount);
+
+        window.Close();
+    }
+
+#if NUNIT
+    [AvaloniaTest]
+#elif XUNIT
+    [AvaloniaFact]
+#endif
+    public void Popup_Placement_Respects_Window_Position()
+    {
+        var target = new Border
+        {
+            Width = 20,
+            Height = 20,
+            HorizontalAlignment = HorizontalAlignment.Left,
+            VerticalAlignment = VerticalAlignment.Top,
+            Background = Brushes.Red
+        };
+        var popup = new Popup
+        {
+            PlacementTarget = target,
+            Placement = PlacementMode.Bottom,
+            Child = new Border { Width = 20, Height = 20 }
+        };
+        var window = new Window
+        {
+            Width = 100,
+            Height = 100,
+            Content = new Panel { Children = { target, popup } }
+        };
+        window.Position = new PixelPoint(100, 200);
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+
+        popup.Open();
+        Dispatcher.UIThread.RunJobs();
+
+        var popupRoot = window.GetOpenPopups()[0];
+        var expected = target.PointToScreen(new Point(0, target.Bounds.Height));
+        AssertHelper.Equal(expected, popupRoot.PointToScreen(default));
+
+        window.Close();
+    }
+
+#if NUNIT
+    [AvaloniaTest]
+#elif XUNIT
+    [AvaloniaFact]
+#endif
+    public void Nested_Popup_Is_Child_Of_Popup_Root()
+    {
+        var nestedTarget = new Border { Width = 20, Height = 20, Background = Brushes.Green };
+        var nestedPopup = new Popup
+        {
+            PlacementTarget = nestedTarget,
+            Child = new Border { Width = 10, Height = 10 }
+        };
+        var target = new Border { Background = Brushes.Red };
+        var popup = new Popup
+        {
+            PlacementTarget = target,
+            Child = new Panel { Children = { nestedTarget, nestedPopup } }
+        };
+        var window = new Window
+        {
+            Width = 100,
+            Height = 100,
+            Content = new Panel { Children = { target, popup } }
+        };
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+
+        popup.Open();
+        Dispatcher.UIThread.RunJobs();
+        nestedPopup.Open();
+        Dispatcher.UIThread.RunJobs();
+
+        var popupRoot = window.GetOpenPopups()[0];
+        AssertHelper.Equal(1, window.GetOpenPopups().Count);
+        AssertHelper.Equal(1, popupRoot.GetOpenPopups().Count);
+        AssertHelper.True(popupRoot.GetOpenPopups()[0] is PopupRoot);
+
+        window.Close();
+    }
+}
diff --git a/tests/Avalonia.Headless.UnitTests/TestApplication.cs b/tests/Avalonia.Headless.UnitTests/TestApplication.cs
index db23c521d4..4899292110 100644
--- a/tests/Avalonia.Headless.UnitTests/TestApplication.cs
+++ b/tests/Avalonia.Headless.UnitTests/TestApplication.cs
@@ -14,6 +14,7 @@ public class TestApplication : Application
         .UseSkia()
         .UseHeadless(new AvaloniaHeadlessPlatformOptions
         {
-            UseHeadlessDrawing = false
+            UseHeadlessDrawing = false,
+            OverlayPopups = false
         });
 }

From e8692155e8c3c4f58b218b423789886d2540e73f Mon Sep 17 00:00:00 2001
From: Melissa <melissa@nimble.tools>
Date: Mon, 3 Aug 2026 17:26:50 +0200
Subject: [PATCH 142/196] Added arrow key scroll navigation to ScrollViewer
 control (#20482)

* Added arrow key scroll navigation to ScrollViewer control

* Check event source before handling Left/Right/Up/Down keys

* Handle right-to-left flow direction in ScrollViewer keys

* Added ScrollViewer test

* Added ScrollBar test

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 src/Avalonia.Controls/Primitives/ScrollBar.cs | 38 +++++++++++---
 src/Avalonia.Controls/ScrollViewer.cs         | 30 +++++++++++
 .../Primitives/ScrollBarTests.cs              | 49 ++++++++++++++++++
 .../ScrollViewerTests.cs                      | 50 +++++++++++++++++++
 4 files changed, 161 insertions(+), 6 deletions(-)

diff --git a/src/Avalonia.Controls/Primitives/ScrollBar.cs b/src/Avalonia.Controls/Primitives/ScrollBar.cs
index b4971a405c..70c78a3ad0 100644
--- a/src/Avalonia.Controls/Primitives/ScrollBar.cs
+++ b/src/Avalonia.Controls/Primitives/ScrollBar.cs
@@ -250,15 +250,41 @@ namespace Avalonia.Controls.Primitives
 
         protected override void OnKeyDown(KeyEventArgs e)
         {
-            if (e.Key == Key.PageUp)
+            if (Orientation == Orientation.Vertical)
             {
-                LargeDecrement();
-                e.Handled = true;
+                if (e.Key == Key.PageUp)
+                {
+                    LargeDecrement();
+                    e.Handled = true;
+                }
+                else if (e.Key == Key.PageDown)
+                {
+                    LargeIncrement();
+                    e.Handled = true;
+                }
+                else if (e.Key == Key.Up)
+                {
+                    SmallDecrement();
+                    e.Handled = true;
+                }
+                else if (e.Key == Key.Down)
+                {
+                    SmallIncrement();
+                    e.Handled = true;
+                }
             }
-            else if (e.Key == Key.PageDown)
+            else if (Orientation == Orientation.Horizontal)
             {
-                LargeIncrement();
-                e.Handled = true;
+                if (e.Key == Key.Left)
+                {
+                    SmallDecrement();
+                    e.Handled = true;
+                }
+                else if (e.Key == Key.Right)
+                {
+                    SmallIncrement();
+                    e.Handled = true;
+                }
             }
         }
 
diff --git a/src/Avalonia.Controls/ScrollViewer.cs b/src/Avalonia.Controls/ScrollViewer.cs
index 57b6664440..3026ba8455 100644
--- a/src/Avalonia.Controls/ScrollViewer.cs
+++ b/src/Avalonia.Controls/ScrollViewer.cs
@@ -806,6 +806,36 @@ namespace Avalonia.Controls
                 PageDown();
                 e.Handled = true;
             }
+            else if (e.Source == this)
+            {
+                bool rtl = FlowDirection == Media.FlowDirection.RightToLeft;
+                if (e.Key == Key.Left)
+                {
+                    if (rtl)
+                        LineRight();
+                    else
+                        LineLeft();
+                    e.Handled = true;
+                }
+                else if (e.Key == Key.Right)
+                {
+                    if (rtl)
+                        LineLeft();
+                    else
+                        LineRight();
+                    e.Handled = true;
+                }
+                else if (e.Key == Key.Up)
+                {
+                    LineUp();
+                    e.Handled = true;
+                }
+                else if (e.Key == Key.Down)
+                {
+                    LineDown();
+                    e.Handled = true;
+                }
+            }
         }
 
         /// <summary>
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs
index f6aff58cee..794652078e 100644
--- a/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/ScrollBarTests.cs
@@ -379,6 +379,55 @@ namespace Avalonia.Controls.UnitTests.Primitives
             Assert.False(args.Handled);
         }
 
+        [Fact]
+        public void Focus_KeyInput_Should_Scroll()
+        {
+            // Vertical scrollbar
+            var target = CreateScrollBar(Orientation.Vertical);
+
+            // Page down and page up
+            KeyDown(target, Key.PageDown);
+            Assert.Equal(target.LargeChange, target.Value);
+            KeyDown(target, Key.PageUp);
+            Assert.Equal(0, target.Value);
+
+            // Small scrolling with arrow keys
+            KeyDown(target, Key.Down);
+            Assert.Equal(target.SmallChange, target.Value);
+            KeyDown(target, Key.Up);
+            Assert.Equal(0, target.Value);
+
+            // Vertical scrollbars shouldn't scroll for left and right keys
+            KeyDown(target, Key.Right);
+            Assert.Equal(0, target.Value);
+            KeyDown(target, Key.Left);
+            Assert.Equal(0, target.Value);
+
+            // Horizontal scrollbar
+            target = CreateScrollBar(Orientation.Horizontal);
+
+            // Small scrolling with arrow keys
+            KeyDown(target, Key.Right);
+            Assert.Equal(target.SmallChange, target.Value);
+            KeyDown(target, Key.Left);
+            Assert.Equal(0, target.Value);
+
+            // Horizontal scrollbars shouldn't scroll for up and down keys
+            KeyDown(target, Key.Down);
+            Assert.Equal(0, target.Value);
+            KeyDown(target, Key.Up);
+            Assert.Equal(0, target.Value);
+        }
+
+        private static void KeyDown(IInputElement target, Key key)
+        {
+            target.RaiseEvent(new KeyEventArgs
+            {
+                RoutedEvent = InputElement.KeyDownEvent,
+                Key = key,
+            });
+        }
+
         private static ContextRequestedEventArgs CreateContextRequested(ScrollBar target, PointerType pointerType)
         {
             var pointer = new Pointer(Pointer.GetNextFreeId(), pointerType, true);
diff --git a/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs b/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs
index 752f2ce567..a3aa2f8b92 100644
--- a/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ScrollViewerTests.cs
@@ -4,6 +4,7 @@ using System.Linq;
 using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Templates;
+using Avalonia.Input;
 using Avalonia.Layout;
 using Avalonia.Media;
 using Avalonia.UnitTests;
@@ -583,6 +584,55 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(1, panel.ArrangeOverrideCalls);
         }
 
+        [Fact]
+        public void Focus_KeyInput_Should_Scroll()
+        {
+            var panel = new Panel
+            {
+                Width = 100_000,
+                Height = 100_000,
+            };
+            var target = new ScrollViewer
+            {
+                Content = panel,
+                Template = new FuncControlTemplate<ScrollViewer>(CreateTemplate),
+            };
+            var root = new TestRoot(target);
+            root.LayoutManager.ExecuteInitialLayoutPass();
+
+            // Page down and page up
+            KeyDown(target, Key.PageDown);
+            Assert.Equal(new(0, target.Viewport.Height), target.Offset);
+            KeyDown(target, Key.PageUp);
+            Assert.Equal(new(0, 0), target.Offset);
+
+            // Per-line scrolling in all directions with arrow keys
+            KeyDown(target, Key.Down);
+            Assert.Equal(new(0, target.SmallChange.Height), target.Offset);
+            KeyDown(target, Key.Right);
+            Assert.Equal(new(target.SmallChange.Width, target.SmallChange.Height), target.Offset);
+            KeyDown(target, Key.Up);
+            Assert.Equal(new(ScrollViewer.DefaultSmallChange, 0), target.Offset);
+            KeyDown(target, Key.Left);
+            Assert.Equal(new(0, 0), target.Offset);
+
+            // Scrolling horizontally with a right-to-left flow direction
+            target.FlowDirection = FlowDirection.RightToLeft;
+            KeyDown(target, Key.Left);
+            Assert.Equal(new(target.SmallChange.Width, 0), target.Offset);
+            KeyDown(target, Key.Right);
+            Assert.Equal(new(0, 0), target.Offset);
+        }
+
+        private static void KeyDown(IInputElement target, Key key)
+        {
+            target.RaiseEvent(new KeyEventArgs
+            {
+                RoutedEvent = InputElement.KeyDownEvent,
+                Key = key,
+            });
+        }
+
         public class TestPanel : Panel
         {
             public int DesiredWidth { get; set; }

From e36b803256c0ad805433bf84991071bd18e5aae0 Mon Sep 17 00:00:00 2001
From: Yoyo <zrt2399@163.com>
Date: Tue, 4 Aug 2026 01:15:54 +0800
Subject: [PATCH 143/196] Fix SelectableTextBlock selection when text content
 changes (#21894)

* Fix SelectableTextBlock selection when text content changes

* Clean up
---
 src/Avalonia.Controls/SelectableTextBlock.cs  | 43 ++++++++--
 src/Avalonia.Controls/TextBox.cs              |  5 +-
 .../SelectableTextBlockTests.cs               | 86 +++++++++++++++++++
 3 files changed, 124 insertions(+), 10 deletions(-)

diff --git a/src/Avalonia.Controls/SelectableTextBlock.cs b/src/Avalonia.Controls/SelectableTextBlock.cs
index 493c1631d4..1b8935cf1f 100644
--- a/src/Avalonia.Controls/SelectableTextBlock.cs
+++ b/src/Avalonia.Controls/SelectableTextBlock.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
-using System.Data;
 using System.Linq;
+using Avalonia.Collections;
 using Avalonia.Controls.Documents;
 using Avalonia.Controls.Utils;
 using Avalonia.Input;
@@ -9,7 +9,6 @@ using Avalonia.Input.Platform;
 using Avalonia.Interactivity;
 using Avalonia.Media;
 using Avalonia.Media.TextFormatting;
-using Avalonia.Platform;
 using Avalonia.Utilities;
 
 namespace Avalonia.Controls
@@ -20,10 +19,10 @@ namespace Avalonia.Controls
     public class SelectableTextBlock : TextBlock, IInlineHost
     {
         public static readonly StyledProperty<int> SelectionStartProperty =
-            TextBox.SelectionStartProperty.AddOwner<SelectableTextBlock>();
+            TextBox.SelectionStartProperty.AddOwner<SelectableTextBlock>(new(coerce: TextBox.CoerceCaretIndex));
 
         public static readonly StyledProperty<int> SelectionEndProperty =
-            TextBox.SelectionEndProperty.AddOwner<SelectableTextBlock>();
+            TextBox.SelectionEndProperty.AddOwner<SelectableTextBlock>(new(coerce: TextBox.CoerceCaretIndex));
 
         public static readonly DirectProperty<SelectableTextBlock, string> SelectedTextProperty =
             AvaloniaProperty.RegisterDirect<SelectableTextBlock, string>(
@@ -48,7 +47,7 @@ namespace Avalonia.Controls
 
         static SelectableTextBlock()
         {
-            FocusableProperty.OverrideDefaultValue(typeof(SelectableTextBlock), true);
+            FocusableProperty.OverrideDefaultValue<SelectableTextBlock>(true);
             AffectsRender<SelectableTextBlock>(SelectionStartProperty, SelectionEndProperty, SelectionBrushProperty);
         }
 
@@ -331,15 +330,31 @@ namespace Avalonia.Controls
         {
             base.OnPropertyChanged(change);
 
-            if (change.Property == SelectionStartProperty || 
-                change.Property == SelectionEndProperty)
+            if (change.Property == InlinesProperty)
+            {
+                if (change.OldValue is InlineCollection oldInlines)
+                {
+                    oldInlines.Invalidated -= OnInlinesInvalidated;
+                }
+
+                if (change.NewValue is InlineCollection newInlines)
+                {
+                    newInlines.Invalidated += OnInlinesInvalidated;
+                }
+
+                OnTextOrInlinesChanged();
+            }
+            else if (change.Property == TextProperty)
+            {
+                OnTextOrInlinesChanged();
+            }
+            else if (change.Property == SelectionStartProperty || change.Property == SelectionEndProperty)
             {
                 RaisePropertyChanged(SelectedTextProperty, "", "");
                 UpdateCommandStates();
                 InvalidateTextLayout();
             }
-
-            if(change.Property == SelectionForegroundBrushProperty)
+            else if (change.Property == SelectionForegroundBrushProperty)
             {
                 InvalidateTextLayout();
             }
@@ -505,6 +520,16 @@ namespace Avalonia.Controls
             e.Pointer.Capture(null);
         }
 
+        private void OnInlinesInvalidated(object? sender, EventArgs e) => OnTextOrInlinesChanged();
+
+        private void OnTextOrInlinesChanged()
+        {
+            CoerceValue(SelectionStartProperty);
+            CoerceValue(SelectionEndProperty);
+            RaisePropertyChanged(SelectedTextProperty, "", "");
+            UpdateCommandStates();
+        }
+
         private void UpdateCommandStates()
         {
             var text = GetSelection();
diff --git a/src/Avalonia.Controls/TextBox.cs b/src/Avalonia.Controls/TextBox.cs
index c8e37c132a..0126d62f27 100644
--- a/src/Avalonia.Controls/TextBox.cs
+++ b/src/Avalonia.Controls/TextBox.cs
@@ -2136,7 +2136,10 @@ namespace Avalonia.Controls
 
         internal static int CoerceCaretIndex(AvaloniaObject sender, int value)
         {
-            var text = sender.GetValue(TextProperty); // method also used by TextPresenter and SelectableTextBlock
+            // method also used by TextPresenter and SelectableTextBlock
+            var text = sender is SelectableTextBlock { HasComplexContent: true } textBlock
+                ? textBlock.Inlines?.Text
+                : sender.GetValue(TextProperty);
 
             if (text == null)
             {
diff --git a/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs b/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs
index 58b9654e61..e360694b69 100644
--- a/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs
@@ -95,5 +95,91 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Inlines_Changes_Should_Update_Selection()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                var target = new SelectableTextBlock();
+                target.Inlines!.Add(new Run("foo"));
+                target.SelectionEnd = 3;
+
+                var selectedTextChanged = false;
+                target.PropertyChanged += (_, e) =>
+                {
+                    if (e.Property == SelectableTextBlock.SelectedTextProperty)
+                    {
+                        selectedTextChanged = true;
+                    }
+                };
+
+                target.Inlines.Add(new Run("bar"));
+
+                Assert.True(selectedTextChanged);
+
+                target.SelectionStart = 6;
+                target.SelectionEnd = 0;
+                target.Inlines.RemoveAt(1);
+
+                Assert.Equal(3, target.SelectionStart);
+                Assert.Equal(0, target.SelectionEnd);
+
+                target.SelectionStart = 0;
+                target.SelectionEnd = 3;
+
+                target.Inlines[0] = new Run("a");
+
+                Assert.Equal(0, target.SelectionStart);
+                Assert.Equal(1, target.SelectionEnd);
+                Assert.Equal("a", target.SelectedText);
+            }
+        }
+
+        [Fact]
+        public void Text_Changes_Should_Update_Selection()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                var target = new SelectableTextBlock
+                {
+                    Text = "foo",
+                    SelectionEnd = 3
+                };
+
+                var selectedTextChanged = false;
+                target.PropertyChanged += (_, e) =>
+                {
+                    if (e.Property == SelectableTextBlock.SelectedTextProperty)
+                    {
+                        selectedTextChanged = true;
+                    }
+                };
+
+                target.Text = "a";
+
+                Assert.Equal(0, target.SelectionStart);
+                Assert.Equal(1, target.SelectionEnd);
+                Assert.True(selectedTextChanged);
+            }
+        }
+
+        [Fact]
+        public void CoerceCaretIndex_OnTextChanged()
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                var target = new SelectableTextBlock
+                {
+                    Text = "foo",
+                    SelectionStart = 3,
+                    SelectionEnd = 3
+                };
+
+                target.Text = "a";
+
+                Assert.Equal(1, target.SelectionStart);
+                Assert.Equal(1, target.SelectionEnd);
+            }
+        }
     }
 }

From 9aed2da66954eb91bbb3e9e5a8a8e295f875509d Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Mon, 3 Aug 2026 22:57:46 +0500
Subject: [PATCH 144/196] Propagate Popup.IsHitTestVisible to IPopupImpl to
 skip hit-testing popups on the OS level if available (#21916)

* Propagate Popup.IsHitTestVisible to IPopupImpl to skip hit-testing popups on the OS level if available

* I hate our api diff system
---
 api/Avalonia.nupkg.xml                        | 16 ++++-
 native/Avalonia.Native/src/OSX/PopupImpl.mm   | 11 +++
 src/Avalonia.Controls/Platform/IPopupImpl.cs  |  7 ++
 .../Primitives/IPopupHost.cs                  |  5 ++
 src/Avalonia.Controls/Primitives/Popup.cs     |  6 +-
 src/Avalonia.Controls/Primitives/PopupRoot.cs |  5 ++
 src/Avalonia.DesignerSupport/Remote/Stubs.cs  |  2 +
 src/Avalonia.Native/PopupImpl.cs              |  8 ++-
 src/Avalonia.Native/avn.idl                   |  2 +-
 src/Avalonia.Wayland/PopupImpl.Sink.cs        |  4 ++
 src/Avalonia.Wayland/PopupImpl.cs             |  7 ++
 .../Server/Persistent/IWSurface.cs            |  8 +++
 .../Server/Persistent/WSurface.cs             | 71 +++++++++++++++++++
 src/Avalonia.X11/X11Enums.cs                  | 11 +++
 src/Avalonia.X11/X11Info.cs                   | 17 +++++
 src/Avalonia.X11/X11Window.cs                 | 28 ++++++++
 src/Avalonia.X11/XLib.cs                      | 18 +++++
 .../Avalonia.Headless/HeadlessWindowImpl.cs   |  6 +-
 src/Windows/Avalonia.Win32/PopupImpl.cs       |  8 +++
 .../Primitives/PopupRootTests.cs              | 27 +++++++
 .../Primitives/PopupTests.cs                  | 42 +++++++++++
 21 files changed, 303 insertions(+), 6 deletions(-)

diff --git a/api/Avalonia.nupkg.xml b/api/Avalonia.nupkg.xml
index ab26c5e135..cf7ef0deca 100644
--- a/api/Avalonia.nupkg.xml
+++ b/api/Avalonia.nupkg.xml
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <!-- https://learn.microsoft.com/dotnet/fundamentals/package-validation/diagnostic-ids -->
 <Suppressions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
   <Suppression>
@@ -169,6 +169,12 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Controls.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Controls.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.IPopupImpl.SetHitTestVisible(System.Boolean)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Controls.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Controls.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Platform.ITopLevelImpl.SetFrameThemeVariant(System.Nullable{Avalonia.Platform.PlatformThemeVariant})</Target>
@@ -199,10 +205,16 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.Controls.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.Controls.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.IPopupImpl.SetHitTestVisible(System.Boolean)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Controls.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Controls.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Platform.ITopLevelImpl.SetFrameThemeVariant(System.Nullable{Avalonia.Platform.PlatformThemeVariant})</Target>
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.Controls.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.Controls.dll</Right>
   </Suppression>
-</Suppressions>
+</Suppressions>
\ No newline at end of file
diff --git a/native/Avalonia.Native/src/OSX/PopupImpl.mm b/native/Avalonia.Native/src/OSX/PopupImpl.mm
index 13131bf91e..8a188c89b3 100644
--- a/native/Avalonia.Native/src/OSX/PopupImpl.mm
+++ b/native/Avalonia.Native/src/OSX/PopupImpl.mm
@@ -43,6 +43,17 @@ public:
         return WindowBaseImpl::Show(activate, true);
     }
     
+    virtual HRESULT SetHitTestVisible(bool value) override
+    {
+        START_COM_CALL;
+
+        @autoreleasepool
+        {
+            [Window setIgnoresMouseEvents:!value];
+            return S_OK;
+        }
+    }
+
     virtual bool ShouldTakeFocusOnShow() override
     {
         auto parent = Parent.tryGet();
diff --git a/src/Avalonia.Controls/Platform/IPopupImpl.cs b/src/Avalonia.Controls/Platform/IPopupImpl.cs
index 388c447243..58bb164426 100644
--- a/src/Avalonia.Controls/Platform/IPopupImpl.cs
+++ b/src/Avalonia.Controls/Platform/IPopupImpl.cs
@@ -13,5 +13,12 @@ namespace Avalonia.Platform
 
         void SetWindowManagerAddShadowHint(bool enabled);
         void TakeFocus();
+
+        /// <summary>
+        /// Sets whether the popup window takes part in pointer hit testing. When false, the
+        /// native window is made input-transparent so that pointer input passes through to
+        /// whatever is behind it.
+        /// </summary>
+        void SetHitTestVisible(bool isHitTestVisible);
     }
 }
diff --git a/src/Avalonia.Controls/Primitives/IPopupHost.cs b/src/Avalonia.Controls/Primitives/IPopupHost.cs
index 3e9967f235..df6b325558 100644
--- a/src/Avalonia.Controls/Primitives/IPopupHost.cs
+++ b/src/Avalonia.Controls/Primitives/IPopupHost.cs
@@ -57,6 +57,11 @@ namespace Avalonia.Controls.Primitives
         /// </summary>
         bool Topmost { get; set; }
 
+        /// <summary>
+        /// Gets or sets whether the popup takes part in pointer hit testing.
+        /// </summary>
+        bool IsHitTestVisible { get; set; }
+
         /// <summary>
         /// Gets or sets a transform that will be applied to the popup.
         /// </summary>
diff --git a/src/Avalonia.Controls/Primitives/Popup.cs b/src/Avalonia.Controls/Primitives/Popup.cs
index 86d4fb746e..75dd723fe3 100644
--- a/src/Avalonia.Controls/Primitives/Popup.cs
+++ b/src/Avalonia.Controls/Primitives/Popup.cs
@@ -159,7 +159,6 @@ namespace Avalonia.Controls.Primitives
         /// </summary>
         static Popup()
         {
-            IsHitTestVisibleProperty.OverrideDefaultValue<Popup>(false);
             ChildProperty.Changed.AddClassHandler<Popup>((x, e) => x.ChildChanged(e));
             IsOpenProperty.Changed.AddClassHandler<Popup>((x, e) => x.IsOpenChanged((AvaloniaPropertyChangedEventArgs<bool>)e));
         }
@@ -451,6 +450,7 @@ namespace Avalonia.Controls.Primitives
 
             UpdateHostSizing(popupHost, topLevel, placementTarget);
             popupHost.Topmost = Topmost;
+            popupHost.IsHitTestVisible = IsHitTestVisible;
             popupHost.SetChild(Child);
             ((ISetLogicalParent)popupHost).SetParent(this);
 
@@ -691,6 +691,10 @@ namespace Avalonia.Controls.Primitives
                 {
                     _openState.PopupHost.Topmost = change.GetNewValue<bool>();
                 }
+                else if (change.Property == IsHitTestVisibleProperty)
+                {
+                    _openState.PopupHost.IsHitTestVisible = change.GetNewValue<bool>();
+                }
             }
         }
 
diff --git a/src/Avalonia.Controls/Primitives/PopupRoot.cs b/src/Avalonia.Controls/Primitives/PopupRoot.cs
index d1fd1317f8..93a30b06a3 100644
--- a/src/Avalonia.Controls/Primitives/PopupRoot.cs
+++ b/src/Avalonia.Controls/Primitives/PopupRoot.cs
@@ -62,6 +62,7 @@ namespace Avalonia.Controls.Primitives
         {
             ParentTopLevel = parent;
             impl.SetWindowManagerAddShadowHint(WindowManagerAddShadowHint);
+            impl.SetHitTestVisible(IsHitTestVisible);
         }
 
         /// <summary>
@@ -219,6 +220,10 @@ namespace Avalonia.Controls.Primitives
             {
                 PlatformImpl?.SetTopmost(change.GetNewValue<bool>());
             }
+            else if (change.Property == IsHitTestVisibleProperty)
+            {
+                PlatformImpl?.SetHitTestVisible(change.GetNewValue<bool>());
+            }
         }
     }
 }
diff --git a/src/Avalonia.DesignerSupport/Remote/Stubs.cs b/src/Avalonia.DesignerSupport/Remote/Stubs.cs
index 97fda7d8d1..6843911df4 100644
--- a/src/Avalonia.DesignerSupport/Remote/Stubs.cs
+++ b/src/Avalonia.DesignerSupport/Remote/Stubs.cs
@@ -215,6 +215,8 @@ namespace Avalonia.DesignerSupport.Remote
             return null;
         }
         public void TakeFocus() { }
+
+        public void SetHitTestVisible(bool isHitTestVisible) { }
     }
 
     class ClipboardStub : IClipboard
diff --git a/src/Avalonia.Native/PopupImpl.cs b/src/Avalonia.Native/PopupImpl.cs
index 222fa63497..ffee48d3ad 100644
--- a/src/Avalonia.Native/PopupImpl.cs
+++ b/src/Avalonia.Native/PopupImpl.cs
@@ -8,6 +8,7 @@ namespace Avalonia.Native
     class PopupImpl : WindowBaseImpl, IPopupImpl
     {
         private readonly ITopLevelImpl _parent;
+        private readonly IAvnPopup _native;
 
         public PopupImpl(IAvaloniaNativeFactory factory,
             ITopLevelImpl parent) : base(factory)
@@ -16,7 +17,7 @@ namespace Avalonia.Native
             
             using (var e = new PopupEvents(this))
             {
-                Init(new MacOSTopLevelHandle(factory.CreatePopup(e)));
+                Init(new MacOSTopLevelHandle(_native = factory.CreatePopup(e)));
             }
             
             PopupPositioner = new ManagedPopupPositioner(new ManagedPopupPositionerPopupImplHelper(parent, MoveResize));
@@ -87,6 +88,11 @@ namespace Avalonia.Native
         {
         }
 
+        public void SetHitTestVisible(bool isHitTestVisible)
+        {
+            _native.SetHitTestVisible(isHitTestVisible.AsComBool());
+        }
+
         public void TakeFocus()
         {
             var parent = _parent;
diff --git a/src/Avalonia.Native/avn.idl b/src/Avalonia.Native/avn.idl
index 32d3f4286e..91a252c020 100644
--- a/src/Avalonia.Native/avn.idl
+++ b/src/Avalonia.Native/avn.idl
@@ -791,7 +791,7 @@ interface IAvnWindowBase : IAvnTopLevel
 [uuid(83e588f3-6981-4e48-9ea0-e1e569f79a91), cpp-virtual-inherits]
 interface IAvnPopup : IAvnWindowBase
 {
-    
+     HRESULT SetHitTestVisible(bool value);
 }
 
 [uuid(cab661de-49d6-4ead-b59c-eac9b2b6c28d), cpp-virtual-inherits]
diff --git a/src/Avalonia.Wayland/PopupImpl.Sink.cs b/src/Avalonia.Wayland/PopupImpl.Sink.cs
index 8576f2ba60..2e1e8eb746 100644
--- a/src/Avalonia.Wayland/PopupImpl.Sink.cs
+++ b/src/Avalonia.Wayland/PopupImpl.Sink.cs
@@ -43,6 +43,10 @@ partial class PopupImpl
             // Re-apply cursor (defaults to Arrow on a fresh worker WSurface).
             if (Parent.CurrentCursor is not null)
                 Parent.ApplyCurrentCursor(_surfaceProxy);
+
+            // A fresh worker WSurface starts hit-test visible.
+            if (!Parent._isHitTestVisible)
+                _surfaceProxy.SetHitTestVisible(false);
         }
 
         protected override void DisconnectFromSurface()
diff --git a/src/Avalonia.Wayland/PopupImpl.cs b/src/Avalonia.Wayland/PopupImpl.cs
index 0edd318f1b..e0cfb75ddc 100644
--- a/src/Avalonia.Wayland/PopupImpl.cs
+++ b/src/Avalonia.Wayland/PopupImpl.cs
@@ -33,6 +33,7 @@ internal partial class PopupImpl : WindowBaseImpl, IPopupImpl
     private WaylandSurfaceCreateResult<WXdgPopupProxy>? _handle;
     private WXdgPopupProxy? _surfaceProxy;
     private XdgPopupPositionerParams? _lastPositioner;
+    private bool _isHitTestVisible = true;
 
     public PopupImpl(WaylandWorkerClient client, WindowBaseImpl parent) : base(client)
     {
@@ -108,6 +109,12 @@ internal partial class PopupImpl : WindowBaseImpl, IPopupImpl
     {
     }
 
+    public void SetHitTestVisible(bool isHitTestVisible)
+    {
+        _isHitTestVisible = isHitTestVisible;
+        _surfaceProxy?.SetHitTestVisible(isHitTestVisible);
+    }
+
     /// <summary>
     /// Bridges Avalonia's positioner contract to <see cref="UpdatePositioner"/>.
     /// </summary>
diff --git a/src/Avalonia.Wayland/Server/Persistent/IWSurface.cs b/src/Avalonia.Wayland/Server/Persistent/IWSurface.cs
index 94a6d1b009..8783db836e 100644
--- a/src/Avalonia.Wayland/Server/Persistent/IWSurface.cs
+++ b/src/Avalonia.Wayland/Server/Persistent/IWSurface.cs
@@ -58,4 +58,12 @@ internal interface IWSurface
 
     /// <summary>Resets the IME state (clears any pending preedit/commit).</summary>
     void ResetTextInput();
+
+    /// <summary>
+    /// Sets whether the surface takes part in pointer/touch hit testing. When
+    /// false an empty wl_region is installed as the input region, so the
+    /// compositor routes input to whatever is behind. Cached and re-applied on
+    /// reconnect.
+    /// </summary>
+    void SetHitTestVisible(bool value);
 }
diff --git a/src/Avalonia.Wayland/Server/Persistent/WSurface.cs b/src/Avalonia.Wayland/Server/Persistent/WSurface.cs
index 0fd1745864..1db7515b74 100644
--- a/src/Avalonia.Wayland/Server/Persistent/WSurface.cs
+++ b/src/Avalonia.Wayland/Server/Persistent/WSurface.cs
@@ -29,6 +29,7 @@ class WSurface : IPersistentWaylandObject, IWSurface, IWaylandFramebufferSurface
     protected double? PreferredFractionalScale { get; private set; }
     protected List<WaylandOutputsTracker.Output> Outputs  { get; } = new();
     private WlCallback? _frameCallback;
+    private bool _hitTestVisible = true;
     private double _currentScale = 1;
     private const double ScaleEpsilon = 1e-6;
     private readonly List<IDisposable> _activeRenderTargets = new();
@@ -115,6 +116,65 @@ class WSurface : IPersistentWaylandObject, IWSurface, IWaylandFramebufferSurface
 
     public virtual void ResetTextInput() => TextInputV3?.Reset(this);
 
+    public void SetHitTestVisible(bool value)
+    {
+        if (_hitTestVisible == value)
+            return;
+        _hitTestVisible = value;
+        // No-op while disconnected; OnConnected replays the cached value.
+        if (WlSurface == null)
+            return;
+        ApplyInputRegion();
+        // Toggling hit-test visibility changes nothing about what's drawn, so an
+        // idle surface may never attach another buffer. Commit out of band to
+        // promote the region — a commit without an attach is well-defined.
+        if (CanCommitOutOfBand)
+            WlSurface.Commit();
+    }
+
+    /// <summary>
+    /// Whether committing this surface outside of a buffer attach is legal right
+    /// now. When it isn't, staged double-buffered state stays pending and is
+    /// promoted by the surface's own next commit.
+    /// </summary>
+    /// <remarks>
+    /// Such a commit can't promote another frame's half-staged state: UI→worker
+    /// proxy calls land as compositor server jobs, which ServerCompositor.RenderCore
+    /// drains before it renders any target, while the per-frame staging
+    /// (<see cref="OnBeforeNewBufferAttached"/>) and the attach+commit that
+    /// promotes it are one synchronous block inside the render pass.
+    /// </remarks>
+    protected virtual bool CanCommitOutOfBand => true;
+
+    /// <summary>
+    /// Installs the input region matching the cached hit-test state. An empty
+    /// region makes the compositor route pointer/touch input to whatever is
+    /// behind this surface.
+    /// </summary>
+    private void ApplyInputRegion()
+    {
+        if (WlSurface == null)
+            return;
+
+        if (_hitTestVisible)
+        {
+            // null is the protocol default: an infinite input region.
+            WlSurface.SetInputRegion(null!);
+            return;
+        }
+
+        var region = Globals!.WlCompositor.CreateRegion();
+        try
+        {
+            WlSurface.SetInputRegion(region);
+        }
+        finally
+        {
+            region.Destroy();
+            region.Dispose();
+        }
+    }
+
     public virtual void OnConnected(WaylandConnection connection, WaylandGlobals globals)
     {
         Connection = connection;
@@ -127,6 +187,11 @@ class WSurface : IPersistentWaylandObject, IWSurface, IWaylandFramebufferSurface
                 WlSurface, new FractionalScaleListener(this), connection.Queue);
             Viewport = globals.Viewporter!.GetViewport(WlSurface);
         }
+
+        // Re-apply the cached input region on (re)connect. It's double-buffered
+        // state, promoted by the next commit — which happens before the surface
+        // can receive any input.
+        ApplyInputRegion();
     }
 
     private IPlatformRenderSurface[]? _renderSurfaces;
@@ -346,6 +411,12 @@ class WXdgShellSurface : WSurface, IWXdgShellSurface
     /// <summary>True iff this surface is currently mapped (xdg-shell sense).</summary>
     internal bool IsMapped => _mapped;
 
+    // Committing an xdg_surface before it has a role, or before its initial
+    // configure has been acked, is a protocol error. Until we're mapped, staged
+    // state rides along on the commit that assigns the role (TryAttachToParent)
+    // or on the first buffer attach.
+    protected override bool CanCommitOutOfBand => _mapped;
+
     internal void RegisterPendingChildPopup(WXdgPopup popup) => _pendingChildPopups.Add(popup);
     internal void UnregisterPendingChildPopup(WXdgPopup popup) => _pendingChildPopups.Remove(popup);
 
diff --git a/src/Avalonia.X11/X11Enums.cs b/src/Avalonia.X11/X11Enums.cs
index 9d671ae6d2..3325984966 100644
--- a/src/Avalonia.X11/X11Enums.cs
+++ b/src/Avalonia.X11/X11Enums.cs
@@ -107,4 +107,15 @@ namespace Avalonia.X11
         CWColormap = (1 << 13),
         CWCursor = (1 << 14),
     }
+
+    /// <summary>
+    /// Shape kinds from the X Nonrectangular Window Shape extension, as accepted by
+    /// XFixesSetWindowShapeRegion.
+    /// </summary>
+    internal enum ShapeKind
+    {
+        ShapeBounding = 0,
+        ShapeClip = 1,
+        ShapeInput = 2,
+    }
 }
diff --git a/src/Avalonia.X11/X11Info.cs b/src/Avalonia.X11/X11Info.cs
index cc4ec67a3a..67abadc0e3 100644
--- a/src/Avalonia.X11/X11Info.cs
+++ b/src/Avalonia.X11/X11Info.cs
@@ -32,6 +32,11 @@ namespace Avalonia.X11
         public bool HasXim { get; }
         public bool HasXSync { get; }
 
+        /// <summary>
+        /// Whether XFixes is usable, which is what window input shapes are set through.
+        /// </summary>
+        public bool HasXFixes { get; }
+
         public IntPtr DefaultFontSet { get; }
 
         public bool HasXkb { get; }
@@ -126,6 +131,18 @@ namespace Avalonia.X11
                 //Ignore, XSync is not supported
             }
 
+            try
+            {
+                // Input shapes need XFixes 2.0 or newer.
+                HasXFixes = XFixesQueryExtension(display, out _, out _) != 0
+                            && XFixesQueryVersion(display, out var fixesMajor, out _) != 0
+                            && fixesMajor >= 2;
+            }
+            catch
+            {
+                //Ignore, XFixes is not supported
+            }
+
             try
             {
                 var xkbMajor = 1;
diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index 1ed61248d0..5337e99a4e 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -1679,6 +1679,34 @@ namespace Avalonia.X11
         {
         }
 
+        public void SetHitTestVisible(bool isHitTestVisible)
+        {
+            if (!_x11.HasXFixes)
+                return;
+
+            // An empty input region makes the server route pointer input to whatever is behind
+            // the window. None (0) restores the default input shape, i.e. the whole window.
+            var region = IntPtr.Zero;
+            if (!isHitTestVisible)
+            {
+                var rect = default(XRectangle);
+                region = XFixesCreateRegion(_x11.Display, &rect, 0);
+            }
+
+            XFixesSetWindowShapeRegion(_x11.Display, _handle, ShapeKind.ShapeInput, 0, 0, region);
+
+            // The render window is a child of _handle when a GPU backend is in use. Shaping the
+            // parent alone doesn't take the child out of the input hierarchy, so it would keep
+            // capturing the pointer.
+            if (_renderHandle != _handle)
+                XFixesSetWindowShapeRegion(_x11.Display, _renderHandle, ShapeKind.ShapeInput, 0, 0, region);
+
+            if (region != IntPtr.Zero)
+                XFixesDestroyRegion(_x11.Display, region);
+
+            XFlush(_x11.Display);
+        }
+
         public WindowTransparencyLevel TransparencyLevel =>
             _transparencyHelper?.CurrentLevel ?? WindowTransparencyLevel.None;
 
diff --git a/src/Avalonia.X11/XLib.cs b/src/Avalonia.X11/XLib.cs
index 108ae257c4..0e56bcea5e 100644
--- a/src/Avalonia.X11/XLib.cs
+++ b/src/Avalonia.X11/XLib.cs
@@ -21,6 +21,7 @@ namespace Avalonia.X11
         private const string libX11Ext = "libXext.so.6";
         private const string libXInput = "libXi.so.6";
         private const string libXCursor = "libXcursor.so.1";
+        private const string libXFixes = "libXfixes.so.3";
 
         public const IntPtr AnyPropertyType = 0;
 
@@ -610,6 +611,23 @@ namespace Avalonia.X11
         [DllImport(libX11Ext)]
         public static extern int XSyncSetCounter(IntPtr dpy, IntPtr counter, XSyncValue value);
 
+        [DllImport(libXFixes)]
+        public static extern int XFixesQueryExtension(IntPtr dpy, out int event_base_return, out int error_base_return);
+
+        [DllImport(libXFixes)]
+        public static extern int XFixesQueryVersion(IntPtr dpy, out int major_version_return,
+            out int minor_version_return);
+
+        [DllImport(libXFixes)]
+        public static extern IntPtr XFixesCreateRegion(IntPtr dpy, XRectangle* rectangles, int nrectangles);
+
+        [DllImport(libXFixes)]
+        public static extern void XFixesSetWindowShapeRegion(IntPtr dpy, IntPtr win, ShapeKind shape_kind,
+            int x_off, int y_off, IntPtr region);
+
+        [DllImport(libXFixes)]
+        public static extern void XFixesDestroyRegion(IntPtr dpy, IntPtr region);
+
         [DllImport(libX11Randr)]
         public static extern int XRRQueryVersion(IntPtr dpy,
             out int major_version_return,
diff --git a/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs b/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
index efc2c08a89..b3a6bb16cc 100644
--- a/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
+++ b/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
@@ -478,7 +478,11 @@ namespace Avalonia.Headless
             
         }
 
-        public void TakeFocus() 
+        public void TakeFocus()
+        {
+        }
+
+        public void SetHitTestVisible(bool isHitTestVisible)
         {
         }
     }
diff --git a/src/Windows/Avalonia.Win32/PopupImpl.cs b/src/Windows/Avalonia.Win32/PopupImpl.cs
index ee2feedffc..0e3a40f12a 100644
--- a/src/Windows/Avalonia.Win32/PopupImpl.cs
+++ b/src/Windows/Avalonia.Win32/PopupImpl.cs
@@ -13,6 +13,7 @@ namespace Avalonia.Win32
     {
         private readonly IWindowBaseImpl? _parent;
         private bool _dropShadowHint = true;
+        private bool _isHitTestVisible = true;
         private Size? _maxAutoSize;
 
 
@@ -87,6 +88,8 @@ namespace Avalonia.Win32
                     goto default;
                 case UnmanagedMethods.WindowsMessage.WM_MOUSEACTIVATE:
                     return (IntPtr)UnmanagedMethods.MouseActivate.MA_NOACTIVATE;
+                case UnmanagedMethods.WindowsMessage.WM_NCHITTEST when !_isHitTestVisible:
+                    return (IntPtr)UnmanagedMethods.HitTestValues.HTTRANSPARENT;
                 default:
                     return base.WndProc(hWnd, msg, wParam, lParam);
             }
@@ -152,6 +155,11 @@ namespace Avalonia.Win32
             EnableBoxShadow(Handle.Handle, enabled);
         }
 
+        public void SetHitTestVisible(bool isHitTestVisible)
+        {
+            _isHitTestVisible = isHitTestVisible;
+        }
+
         public void TakeFocus()
         {
             var parent = _parent;
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/PopupRootTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/PopupRootTests.cs
index ee051649cd..c73c188627 100644
--- a/tests/Avalonia.Controls.UnitTests/Primitives/PopupRootTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/PopupRootTests.cs
@@ -42,6 +42,33 @@ namespace Avalonia.Controls.UnitTests.Primitives
             }
         }
 
+        [Fact]
+        public void PopupRoot_Forwards_Initial_IsHitTestVisible_To_Impl()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var impl = MockWindowingPlatform.CreatePopupMock(new Mock<IWindowBaseImpl>().Object);
+
+                CreateTarget(new Window(), impl.Object);
+
+                impl.Verify(x => x.SetHitTestVisible(true));
+            }
+        }
+
+        [Fact]
+        public void PopupRoot_Forwards_IsHitTestVisible_Changes_To_Impl()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var impl = MockWindowingPlatform.CreatePopupMock(new Mock<IWindowBaseImpl>().Object);
+                var target = CreateTarget(new Window(), impl.Object);
+
+                target.IsHitTestVisible = false;
+
+                impl.Verify(x => x.SetHitTestVisible(false));
+            }
+        }
+
         [Fact]
         public void PopupRoot_StylingParent_Is_Popup()
         {
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/PopupTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/PopupTests.cs
index dcf9b6f653..3cca86d3b4 100644
--- a/tests/Avalonia.Controls.UnitTests/Primitives/PopupTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/PopupTests.cs
@@ -1318,6 +1318,48 @@ namespace Avalonia.Controls.UnitTests.Primitives
             return result;
         }
 
+        [Fact]
+        public void Popup_IsHitTestVisible_Defaults_To_True()
+        {
+            using (CreateServices())
+            {
+                Assert.True(new Popup().IsHitTestVisible);
+            }
+        }
+
+        [Fact]
+        public void Popup_Forwards_IsHitTestVisible_To_Host_On_Open()
+        {
+            using (CreateServices())
+            {
+                var target = new Popup { IsHitTestVisible = false };
+                var window = PreparedWindow(target);
+                window.Show();
+
+                target.Open();
+
+                Assert.False(target.Host!.IsHitTestVisible);
+            }
+        }
+
+        [Fact]
+        public void Popup_Forwards_IsHitTestVisible_Changes_To_Open_Host()
+        {
+            using (CreateServices())
+            {
+                var target = new Popup();
+                var window = PreparedWindow(target);
+                window.Show();
+
+                target.Open();
+                Assert.True(target.Host!.IsHitTestVisible);
+
+                target.IsHitTestVisible = false;
+
+                Assert.False(target.Host!.IsHitTestVisible);
+            }
+        }
+
         [Fact]
         public void Popup_Open_With_Correct_IsUsingOverlayLayer_And_Disabled_OverlayLayer()
         {

From 064b84a982d1537c8cb88ff88ccab2af92ee4ef6 Mon Sep 17 00:00:00 2001
From: timiimit-tam <204727649+timiimit-tam@users.noreply.github.com>
Date: Mon, 3 Aug 2026 21:06:30 +0200
Subject: [PATCH 145/196] Preserve current `Animation` progress if `SpeedRatio`
 or `PlaybackDirection` changes (#19830)

* Add AnimationSpeedPage to RenderDemo

* Add tests

* Implement fix

* Minor improvements

Remove leftover vars/params
Replace some `if`s with terniary assignment
Improve comments
Unduplicate `playbackReversed` code

* Add unit test

DelayBetweenIterations_Behind_Initial_Point_Is_In_Front_Of_Iterations

* Add animation time precision

* Add missing check for negative `DelayBetweenIterations`

* Fix zero duration regression

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 samples/RenderDemo/MainWindow.xaml            |   3 +
 .../RenderDemo/Pages/AnimationSpeedPage.xaml  | 117 ++++
 .../Pages/AnimationSpeedPage.xaml.cs          |  23 +
 .../ViewModels/AnimationSpeedPageViewModel.cs | 103 ++++
 .../Animation/AnimationInstance`1.cs          | 395 +++++++++----
 .../Animation/AnimatableTests.cs              | 527 ++++++++++++++++++
 6 files changed, 1059 insertions(+), 109 deletions(-)
 create mode 100644 samples/RenderDemo/Pages/AnimationSpeedPage.xaml
 create mode 100644 samples/RenderDemo/Pages/AnimationSpeedPage.xaml.cs
 create mode 100644 samples/RenderDemo/ViewModels/AnimationSpeedPageViewModel.cs

diff --git a/samples/RenderDemo/MainWindow.xaml b/samples/RenderDemo/MainWindow.xaml
index 058cc14278..aedd9f95cf 100644
--- a/samples/RenderDemo/MainWindow.xaml
+++ b/samples/RenderDemo/MainWindow.xaml
@@ -51,6 +51,9 @@
     <TabItem Header="Animations">
       <pages:AnimationsPage />
     </TabItem>
+    <TabItem Header="Animation Speed">
+      <pages:AnimationSpeedPage />
+    </TabItem>
     <TabItem Header="Transitions">
       <pages:TransitionsPage />
     </TabItem>
diff --git a/samples/RenderDemo/Pages/AnimationSpeedPage.xaml b/samples/RenderDemo/Pages/AnimationSpeedPage.xaml
new file mode 100644
index 0000000000..08e88e53e7
--- /dev/null
+++ b/samples/RenderDemo/Pages/AnimationSpeedPage.xaml
@@ -0,0 +1,117 @@
+<UserControl 
+  xmlns="https://github.com/avaloniaui" 
+  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+  xmlns:viewModels="using:RenderDemo.ViewModels"
+  x:Class="RenderDemo.Pages.AnimationSpeedPage"
+  x:DataType="viewModels:AnimationSpeedPageViewModel"
+  MaxWidth="600">
+  <UserControl.Styles>
+    <Style Selector="TextBlock.rotatorNINF">
+      <Style.Animations>
+        <Animation Duration="0:0:1" IterationCount="INFINITE"
+                   Delay="{Binding Delay, Mode=OneWay}"
+                   DelayBetweenIterations="{Binding DelayIters, Mode=OneWay}"
+                   PlaybackDirection="{Binding PlaybackDirection, Mode=OneWay}"
+                   SpeedRatio="{Binding SpeedRatio, Mode=OneWay}">
+          <KeyFrame Cue="0%">
+            <Setter Property="RotateTransform.Angle" Value="0.0" />
+          </KeyFrame>
+          <KeyFrame Cue="100%">
+            <Setter Property="RotateTransform.Angle" Value="360.0" />
+          </KeyFrame>
+        </Animation>
+      </Style.Animations>
+    </Style>
+    <Style Selector="TextBlock.rotatorN10">
+      <Style.Animations>
+        <Animation Duration="0:0:1" IterationCount="10"
+                   Delay="{Binding Delay, Mode=OneWay}"
+                   DelayBetweenIterations="{Binding DelayIters, Mode=OneWay}"
+                   PlaybackDirection="{Binding PlaybackDirection, Mode=OneWay}"
+                   SpeedRatio="{Binding SpeedRatio, Mode=OneWay}">
+          <KeyFrame Cue="0%">
+            <Setter Property="RotateTransform.Angle" Value="0.0" />
+          </KeyFrame>
+          <KeyFrame Cue="100%">
+            <Setter Property="RotateTransform.Angle" Value="360.0" />
+          </KeyFrame>
+        </Animation>
+      </Style.Animations>
+    </Style>
+    <Style Selector="TextBlock.rotatorRINF">
+      <Style.Animations>
+        <Animation Duration="0:0:1" IterationCount="INFINITE"
+                   Delay="{Binding Delay, Mode=OneWay}"
+                   DelayBetweenIterations="{Binding DelayIters, Mode=OneWay}"
+                   PlaybackDirection="{Binding PlaybackDirectionOpposite, Mode=OneWay}"
+                   SpeedRatio="{Binding SpeedRatio, Mode=OneWay}">
+          <KeyFrame Cue="0%">
+            <Setter Property="RotateTransform.Angle" Value="0.0" />
+          </KeyFrame>
+          <KeyFrame Cue="100%">
+            <Setter Property="RotateTransform.Angle" Value="360.0" />
+          </KeyFrame>
+        </Animation>
+      </Style.Animations>
+    </Style>
+    <Style Selector="TextBlock.rotatorR10">
+      <Style.Animations>
+        <Animation Duration="0:0:1" IterationCount="10"
+                   Delay="{Binding Delay, Mode=OneWay}"
+                   DelayBetweenIterations="{Binding DelayIters, Mode=OneWay}"
+                   PlaybackDirection="{Binding PlaybackDirectionOpposite, Mode=OneWay}"
+                   SpeedRatio="{Binding SpeedRatio, Mode=OneWay}">
+          <KeyFrame Cue="0%">
+            <Setter Property="RotateTransform.Angle" Value="0.0" />
+          </KeyFrame>
+          <KeyFrame Cue="100%">
+            <Setter Property="RotateTransform.Angle" Value="360.0" />
+          </KeyFrame>
+        </Animation>
+      </Style.Animations>
+    </Style>
+  </UserControl.Styles>
+  <ScrollViewer>
+    <StackPanel Orientation="Vertical">
+      <Grid RowDefinitions="Auto,Auto,Auto,1*" ColumnDefinitions="Auto,5*,Auto">
+        <TextBlock  Grid.Row="0" Grid.Column="0" Text="SpeedRatio:" />
+        <Slider Grid.Row="0" Grid.Column="1"
+                Value="{Binding SpeedRatio, Mode=OneWayToSource}"
+                Minimum="0" Maximum="2" />
+
+        <TextBlock Grid.Row="1" Grid.Column="0" Text="Delay:" />
+        <Slider Grid.Row="1" Grid.Column="1"
+                Value="{Binding DelayInput, Mode=OneWayToSource}"
+                Minimum="0" Maximum="10" />
+
+        <TextBlock Grid.Row="2" Grid.Column="0" Text="DelayIters:" />
+        <Slider Grid.Row="2" Grid.Column="1"
+                Value="{Binding DelayItersInput, Mode=OneWayToSource}"
+                Minimum="0" Maximum="10" />
+
+        <ComboBox Grid.Row="0" Grid.RowSpan="3" Grid.Column="2"
+                  ItemsSource="{Binding PlaybackDirections}"
+                  SelectedValue="{Binding PlaybackDirection, Mode=OneWayToSource}" />
+      </Grid>
+      <Grid RowDefinitions="Auto,1*,Auto,1*" ColumnDefinitions="Auto,Auto"
+            Grid.Row="3" Grid.ColumnSpan="3" Height="400">
+        <TextBlock Grid.Row="0" Grid.Column="0" Text="PlayDir=AsSelected; Iters=INF" />
+        <TextBlock Grid.Row="1" Grid.Column="0" Text="Rotate me" Classes="rotatorNINF"
+                   HorizontalAlignment="Center" VerticalAlignment="Center" />
+
+        <TextBlock Grid.Row="2" Grid.Column="0" Text="PlayDir=AsSelected; Iters=10" />
+        <TextBlock Grid.Row="3" Grid.Column="0" Text="Rotate me" Classes="rotatorN10"
+                   HorizontalAlignment="Center" VerticalAlignment="Center" />
+
+        <TextBlock Grid.Row="0" Grid.Column="1" Text="PlayDir=Opposite; Iters=INF" />
+        <TextBlock Grid.Row="1" Grid.Column="1" Text="Rotate me" Classes="rotatorRINF"
+                   HorizontalAlignment="Center" VerticalAlignment="Center" />
+
+        <TextBlock Grid.Row="2" Grid.Column="1" Text="PlayDir=Opposite; Iters=10" />
+        <TextBlock Grid.Row="3" Grid.Column="1" Text="Rotate me" Classes="rotatorR10"
+                   HorizontalAlignment="Center" VerticalAlignment="Center" />
+      </Grid>
+
+    </StackPanel>
+  </ScrollViewer>
+</UserControl>
diff --git a/samples/RenderDemo/Pages/AnimationSpeedPage.xaml.cs b/samples/RenderDemo/Pages/AnimationSpeedPage.xaml.cs
new file mode 100644
index 0000000000..00dce1d055
--- /dev/null
+++ b/samples/RenderDemo/Pages/AnimationSpeedPage.xaml.cs
@@ -0,0 +1,23 @@
+using System.Reactive.Linq;
+using Avalonia;
+using Avalonia.Animation;
+using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
+using Avalonia.Markup.Xaml;
+using RenderDemo.ViewModels;
+
+namespace RenderDemo.Pages;
+
+public class AnimationSpeedPage : UserControl
+{
+    public AnimationSpeedPage()
+    {
+        InitializeComponent();
+        this.DataContext = new AnimationSpeedPageViewModel();
+    }
+
+    private void InitializeComponent()
+    {
+        AvaloniaXamlLoader.Load(this);
+    }
+}
diff --git a/samples/RenderDemo/ViewModels/AnimationSpeedPageViewModel.cs b/samples/RenderDemo/ViewModels/AnimationSpeedPageViewModel.cs
new file mode 100644
index 0000000000..3fd45639da
--- /dev/null
+++ b/samples/RenderDemo/ViewModels/AnimationSpeedPageViewModel.cs
@@ -0,0 +1,103 @@
+using System;
+using System.Collections;
+using Avalonia.Animation;
+using MiniMvvm;
+
+namespace RenderDemo.ViewModels;
+
+public class AnimationSpeedPageViewModel : ViewModelBase
+{
+    private double _speedRatio;
+    public double SpeedRatio
+    {
+        get => _speedRatio;
+        set => RaiseAndSetIfChanged(ref _speedRatio, value);
+    }
+
+    private static readonly PlaybackDirection[] s_playbackDirections = [
+        PlaybackDirection.Normal,
+        PlaybackDirection.Reverse,
+        PlaybackDirection.Alternate,
+        PlaybackDirection.AlternateReverse
+    ];
+    public PlaybackDirection[] PlaybackDirections
+    {
+        get => s_playbackDirections;
+    }
+
+    private PlaybackDirection GetOppositePlaybackDirection(PlaybackDirection value)
+    {
+        switch (value)
+        {
+            case PlaybackDirection.Normal:
+                return PlaybackDirection.Reverse;
+            case PlaybackDirection.Reverse:
+                return PlaybackDirection.Normal;
+            case PlaybackDirection.Alternate:
+                return PlaybackDirection.AlternateReverse;
+            case PlaybackDirection.AlternateReverse:
+                return PlaybackDirection.Alternate;
+        }
+        throw new ArgumentOutOfRangeException();
+    }
+
+    private PlaybackDirection _playbackDirection;
+    public PlaybackDirection PlaybackDirection
+    {
+        get => _playbackDirection;
+        set
+        {
+            _playbackDirection = value;
+            RaisePropertyChanged(nameof(PlaybackDirection));
+            _playbackDirectionOpposite = GetOppositePlaybackDirection(value);
+            RaisePropertyChanged(nameof(PlaybackDirectionOpposite));
+        }
+    }
+
+    private PlaybackDirection _playbackDirectionOpposite;
+    public PlaybackDirection PlaybackDirectionOpposite
+    {
+        get => _playbackDirectionOpposite;
+        set
+        {
+            _playbackDirectionOpposite = value;
+            RaisePropertyChanged(nameof(PlaybackDirectionOpposite));
+            _playbackDirection = GetOppositePlaybackDirection(value);
+            RaisePropertyChanged(nameof(PlaybackDirection));
+        }
+    }
+
+    private TimeSpan _delay;
+    public TimeSpan Delay
+    {
+        get => _delay;
+        set => RaiseAndSetIfChanged(ref _delay, value);
+    }
+
+    public double DelayInput
+    {
+        get => _delay.TotalSeconds;
+        set => Delay = TimeSpan.FromSeconds(value);
+    }
+
+    private TimeSpan _delayIters;
+    public TimeSpan DelayIters
+    {
+        get => _delayIters;
+        set => RaiseAndSetIfChanged(ref _delayIters, value);
+    }
+
+    public double DelayItersInput
+    {
+        get => _delayIters.TotalSeconds;
+        set => DelayIters = TimeSpan.FromSeconds(value);
+    }
+
+    public AnimationSpeedPageViewModel()
+    {
+        SpeedRatio = 1;
+        PlaybackDirection = PlaybackDirection.Normal;
+        DelayInput = 0;
+        DelayItersInput = 0;
+    }
+}
diff --git a/src/Avalonia.Base/Animation/AnimationInstance`1.cs b/src/Avalonia.Base/Animation/AnimationInstance`1.cs
index 757e5f8987..f1b0a937a4 100644
--- a/src/Avalonia.Base/Animation/AnimationInstance`1.cs
+++ b/src/Avalonia.Base/Animation/AnimationInstance`1.cs
@@ -12,73 +12,106 @@ namespace Avalonia.Animation
     /// </summary>
     internal class AnimationInstance<T> : SingleSubscriberObservableBase<T>
     {
-        private T _lastInterpValue;
-        private T _firstKFValue;
-        private ulong? _iterationCount;
-        private ulong _currentIteration;
-        private bool _gotFirstKFValue;
-        private bool _playbackReversed;
-        private FillMode _fillMode;
-        private PlaybackDirection _playbackDirection;
         private readonly Animator<T> _animator;
         private readonly Animation _animation;
         private readonly Animatable _targetControl;
-        private T _neutralValue;
-        private double _speedRatioConv;
-        private TimeSpan _initialDelay;
-        private TimeSpan _iterationDelay;
-        private TimeSpan _duration;
-        private Easings.Easing? _easeFunc;
         private readonly Action? _onCompleteAction;
-        private readonly Func<double, T, T> _interpolator;
         private IDisposable? _timerSub;
-        private readonly IClock _baseClock;
-        private IClock? _clock;
         private EventHandler<AvaloniaPropertyChangedEventArgs>? _propertyChangedDelegate;
         private EventHandler? _visibilityChangedHandler;
         private EventHandler<VisualTreeAttachmentEventArgs>? _detachedHandler;
 
+        private readonly IClock _baseClock;
+        private IClock? _clock;
+
+        private Easings.Easing? _easeFunc;
+        private readonly Func<double, T, T> _interpolator;
+
+        private T _neutralValue;
+        private FillMode _fillMode;
+
+        private bool _isFirstFrame;
+        private bool _isInFirstInitialDelay;
+        private T _lastInterpValue;
+        private T _initialKFValue;
+        private long? _iterationCount;
+        private TimeSpan _initialDelay;
+        private TimeSpan _iterationDelay;
+        private TimeSpan _duration;
+        private TimeSpan _timePrev;
+        private double _animTimePrev;
+
+        private PlaybackDirection _playbackDirection;
+        private PlaybackDirection _playbackDirectionPrev;
+        private double _speedRatio;
+        private double _speedRatioPrev;
+        private bool _timeMovesBackwards;
+
+        private TimeSpan _timeOfLastChange;
+        private double _animTimeOfLastChange;
+
+        /// <summary>
+        /// Animation's smallest unit of time in terms of TimeSpan Ticks. This can be used
+        /// to increase possible runtime of animation before reaching over/under-flow.
+        /// </summary>
+        /// <remarks>
+        /// Value to use here can be found with <code>TimeSpan.FromMilliseconds(x).Ticks</code>
+        /// </remarks>
+        private const long PRECISION_IN_TICKS = 10_000;
+
         private readonly bool _shouldPauseOnInvisible;
 
         public AnimationInstance(Animation animation, Animatable control, Animator<T> animator, IClock baseClock, Action? OnComplete, Func<double, T, T> Interpolator, bool shouldPauseOnInvisible)
         {
+            _lastInterpValue = default!;
             _animator = animator;
             _animation = animation;
             _targetControl = control;
             _onCompleteAction = OnComplete;
             _interpolator = Interpolator;
             _baseClock = baseClock;
-            _lastInterpValue = default!;
-            _firstKFValue = default!;
+            _initialKFValue = default!;
             _neutralValue = default!;
             _shouldPauseOnInvisible = shouldPauseOnInvisible;
+            _isFirstFrame = true;
+            _isInFirstInitialDelay = true;
+            _speedRatio = 1;
             FetchProperties();
         }
 
         private void FetchProperties()
         {
-            if (_animation.SpeedRatio < 0d)
-                throw new InvalidOperationException("SpeedRatio value should not be negative.");
-
-            if (_animation.Duration < TimeSpan.Zero)
-                throw new InvalidOperationException("Duration value cannot be negative.");
-
-            if (_animation.Delay < TimeSpan.Zero)
-                throw new InvalidOperationException("Delay value cannot be negative.");
-
             _easeFunc = _animation.Easing;
 
-            _speedRatioConv = 1d / _animation.SpeedRatio;
+            _speedRatioPrev = _speedRatio;
+            _speedRatio = _animation.SpeedRatio;
+            if (_speedRatio < 0d)
+                throw new InvalidOperationException("SpeedRatio value cannot be negative.");
 
             _initialDelay = _animation.Delay;
+            if (_initialDelay < TimeSpan.Zero)
+                throw new InvalidOperationException("Delay value cannot be negative.");
+
             _duration = _animation.Duration;
+            if (_duration < TimeSpan.Zero)
+                throw new InvalidOperationException("Duration value cannot be negative.");
+
             _iterationDelay = _animation.DelayBetweenIterations;
+            if (_iterationDelay < TimeSpan.Zero)
+                throw new InvalidOperationException("DelayBetweenIterations value cannot be negative.");
 
             if (_animation.IterationCount.RepeatType == IterationType.Many)
-                _iterationCount = _animation.IterationCount.Value;
+            {
+                if (_animation.IterationCount.Value > long.MaxValue)
+                    throw new InvalidOperationException("IterationCount value cannot be larger than long.MaxValue.");
+                _iterationCount = (long)_animation.IterationCount.Value;
+            }
             else
+            {
                 _iterationCount = null;
+            }
 
+            _playbackDirectionPrev = _playbackDirection;
             _playbackDirection = _animation.PlaybackDirection;
             _fillMode = _animation.FillMode;
         }
@@ -93,7 +126,8 @@ namespace Avalonia.Animation
                 return;
 
             // Animation may have been stopped before it has finished.
-            ApplyFinalFill();
+            if (CanApplyFinalFill())
+                ApplyFinalFill(_lastInterpValue);
 
             _targetControl.PropertyChanged -= _propertyChangedDelegate;
             timerSub.Dispose();
@@ -148,11 +182,7 @@ namespace Avalonia.Animation
                 }
 
                 // Stop and dispose the animation when detached from the visual tree.
-                _detachedHandler = (_, _) =>
-                {
-                    SetFinalValue();
-                    DoComplete();
-                };
+                _detachedHandler = (_, _) => DoComplete(false);
                 visual.DetachedFromVisualTree += _detachedHandler;
             }
 
@@ -167,8 +197,8 @@ namespace Avalonia.Animation
             {
                 if (_clock?.PlayState == PlayState.Pause)
                     return;
-                
-                InternalStep(frameTick); 
+
+                InternalStep(frameTick);
             }
             catch (Exception e)
             {
@@ -176,127 +206,274 @@ namespace Avalonia.Animation
             }
         }
 
-        private void SetFinalValue()
+        private bool CanApplyFinalFill()
         {
-            var easedTime = _easeFunc!.Ease(_playbackReversed ? 0.0 : 1.0);
-            _lastInterpValue = _interpolator(easedTime, _neutralValue);
+            return _fillMode is FillMode.Forward or FillMode.Both;
         }
 
-        private void ApplyFinalFill()
+        private void ApplyFinalFill(T interpolatedValue)
         {
             if (_animator.Property is null)
                 throw new InvalidOperationException("Animator has no property specified.");
-            if (_fillMode is FillMode.Forward or FillMode.Both)
-                _targetControl.SetValue(_animator.Property, _lastInterpValue);
+            _targetControl.SetValue(_animator.Property, interpolatedValue);
         }
 
-        private void DoComplete()
+        private void DoComplete(bool stopAsIs)
         {
-            ApplyFinalFill();
+            if (!stopAsIs)
+            {
+                // Update _lastInterpValue because PublishCompleted might perform final fill
+                // and we should ensure that filled value is snapped to last value that animation would
+                // reach if it was left running in current state.
+                var isIterationReversed = IsIterationReversed(IsAlternatingPlaybackDirection(), _iterationCount + 1);
+                _lastInterpValue = FindEdgeValue(IsAnimTimeGoingBackwards(), isIterationReversed);
+            }
             _onCompleteAction?.Invoke();
             PublishCompleted();
         }
 
-        private void DoDelay()
+        private void DoInitialDelay()
+        {
+            if (_isInFirstInitialDelay)
+            {
+                if (_fillMode is not (FillMode.Backward or FillMode.Both))
+                    return;
+            }
+
+            PublishNext(_initialKFValue);
+        }
+
+        private void DoIterationDelay(bool isIterationReversed)
         {
-            if (_fillMode is not (FillMode.Backward or FillMode.Both)) return;
-            PublishNext(_currentIteration == 0 ? _firstKFValue : _lastInterpValue);
+            _lastInterpValue = FindEdgeValue(false, isIterationReversed);
+            PublishNext(_lastInterpValue);
         }
 
         private void DoPlayStates()
         {
             if (_clock!.PlayState == PlayState.Stop || _baseClock.PlayState == PlayState.Stop)
-                DoComplete();
+                DoComplete(true);
+
+            if (_isFirstFrame)
+            {
+                // In first frame of animation we determine the expected direction of time.
+                _timeMovesBackwards =
+                    _animation.PlaybackDirection == PlaybackDirection.Reverse ||
+                    _animation.PlaybackDirection == PlaybackDirection.AlternateReverse;
+
+                var initialKeyFrame = _timeMovesBackwards ? _animator.Last() : _animator.First();
+                _initialKFValue = initialKeyFrame.Value is T initialValue ? initialValue : _neutralValue;
+
+                _isFirstFrame = false;
+            }
+        }
+
+        private static bool IsIterationReversed(bool isAlternatingPlaybackDirection, long? iterationIndex)
+        {
+            if (isAlternatingPlaybackDirection)
+                return (iterationIndex & 1) != 0;
+            else
+                return false;
+        }
+
+        private T FindEdgeValue(bool isAnimTimeGoingBackwards, bool isIterationReversed)
+        {
+            double finalEaseValue = isAnimTimeGoingBackwards ^ isIterationReversed ? 0.0 : 1.0;
+
+            var easedTime = _easeFunc!.Ease(finalEaseValue);
+            return _interpolator(easedTime, _neutralValue);
+        }
+
+        private bool IsAnimTimeGoingBackwards()
+        {
+            return
+                _playbackDirection == PlaybackDirection.Reverse ||
+                _playbackDirection == PlaybackDirection.AlternateReverse;
+        }
+
+        private bool IsAlternatingPlaybackDirection()
+        {
+            return
+                _playbackDirection == PlaybackDirection.Alternate ||
+                _playbackDirection == PlaybackDirection.AlternateReverse;
+        }
+
+        private bool ApplyInitialDelay(ref long animTime)
+        {
+            // Handle all possible cases of applying initial delay and clamping.
+            long delay = _initialDelay.Ticks / PRECISION_IN_TICKS;
+            if (_iterationCount.HasValue)
+            {
+                animTime -= delay;
+                if (animTime <= 0)
+                {
+                    if (animTime < -delay)
+                        animTime = -delay;
+                    return true;
+                }
+            }
+            else
+            {
+                // Determine the interval of initial delay.
+                long low = -delay;
+                long high = 0;
+
+                // Handle all 3 location cases based on above interval.
+                if (animTime < low)
+                {
+                    animTime += delay;
+                    if (animTime > 0)
+                    {
+                        animTime = 0;
+                        return true;
+                    }
+                }
+                else if (animTime > high)
+                {
+                    animTime -= delay;
+                    if (animTime < 0)
+                    {
+                        animTime = 0;
+                        return true;
+                    }
+                }
+                else // if (animTime >= low && animTime <= high)
+                {
+                    animTime = 0;
+                    return true;
+                }
+            }
+            return false;
+        }
 
-            if (!_gotFirstKFValue)
+        private void ApplyLimitedClamp(ref double animTime)
+        {
+            if (_timeMovesBackwards)
+            {
+                if (animTime > 0)
+                    animTime = 0;
+            }
+            else
             {
-                var firstKeyFrame = _animator.First();
-                _firstKFValue = firstKeyFrame.Value is T value ? value : _neutralValue;
-                _gotFirstKFValue = true;
+                if (animTime < 0)
+                    animTime = 0;
             }
         }
 
         private void InternalStep(TimeSpan time)
         {
             DoPlayStates();
-
             FetchProperties();
 
-            // Scale timebases according to speedratio.
-            var indexTime = time.Ticks;
-            var iterDuration = _duration.Ticks * _speedRatioConv;
-            var iterDelay = _iterationDelay.Ticks * _speedRatioConv;
-            var initDelay = _initialDelay.Ticks * _speedRatioConv;
+            if (_speedRatio != _speedRatioPrev || _playbackDirection != _playbackDirectionPrev)
+            {
+                // Remember the time when speed changed.
+                // All we can know is that it changed some time between current and prev frame.
+                // We assume that this happened exactly at prev frame.
+                _timeOfLastChange = _timePrev;
+                _animTimeOfLastChange = _animTimePrev;
+            }
+
+            bool isAnimTimeGoingBackwards = IsAnimTimeGoingBackwards();
 
-            // This conditional checks if the time given is the very start/zero
-            // and when we have an active delay time.
-            if (initDelay > 0 && indexTime <= initDelay)
+            // Combine SpeedRatio and PlaybackDirection into a single signed speed ratio.
+            double speedRatio = isAnimTimeGoingBackwards ? -_speedRatio : _speedRatio;
+
+            // Calculate animation time. That's time that has passed inside
+            // the animation since its beginning.
+            var timeSinceLastChange = time - _timeOfLastChange;
+            var animTimeSinceLastChange = timeSinceLastChange.Ticks * speedRatio / PRECISION_IN_TICKS;
+            var animTimeExact = _animTimeOfLastChange + animTimeSinceLastChange;
+
+            if (_iterationCount.HasValue)
             {
-                DoDelay();
-                return;
+                // Make sure animation time is inside a valid interval.
+                ApplyLimitedClamp(ref animTimeExact);
             }
 
-            // Calculate timebases.
-            var iterationTime = iterDuration + iterDelay;
-            var opsTime = indexTime - initDelay;
-            var playbackTime = opsTime % iterationTime;
+            _timePrev = time;
+            _animTimePrev = animTimeExact;
+
+            var animTime = (long)animTimeExact;
+
+            // Get animation time oriented in the direction of time. Animation running in
+            // same direction as it was on first frame will always increase this variable.
+            long animTimePositive = _timeMovesBackwards ? -animTime : animTime;
+
+            if (_initialDelay > TimeSpan.Zero)
+            {
+                bool isCurrentlyInsideDelay = ApplyInitialDelay(ref animTimePositive);
+                if (isCurrentlyInsideDelay)
+                {
+                    DoInitialDelay();
+                    return;
+                }
+
+                _isInFirstInitialDelay = false;
+            }
 
-            _currentIteration = (ulong)(opsTime / iterationTime);
+            var iterDuration = _duration.Ticks / PRECISION_IN_TICKS;
+            var iterDelay = _iterationDelay.Ticks / PRECISION_IN_TICKS;
+            var iterDurationTotal = iterDuration + iterDelay;
 
-            // Stop animation when the current iteration is beyond the iteration count or
-            // when the duration is set to zero while animating and snap to the last iterated value.
-            if (_currentIteration + 1 > _iterationCount || _duration == TimeSpan.Zero)
+            // An iteration with no duration can't be interpolated, no matter how long the
+            // delay between iterations is: end the animation and snap to its final value.
+            if (iterDuration <= 0)
             {
-                SetFinalValue();
-                DoComplete();
+                DoComplete(false);
                 return;
             }
 
-            if (playbackTime <= iterDuration)
+            // Calculate current iteration info.
+            var iterIndex = animTimePositive / iterDurationTotal;
+            var iterTime = animTimePositive % iterDurationTotal;
+
+            bool playbackReversed = animTimePositive < 0;
+            if (playbackReversed)
             {
-                // Normalize time for interpolation.
-                var normalizedTime = playbackTime / iterDuration;
+                // Animation time is behind the starting point of animation.
+
+                // First negative iteration has index -1, first positive iteration has index 0.
+                iterIndex--;
+
+                // Move iteration delay to the front of iteration, which is (when moving
+                // backwards through animation time) effectively at the end of iteration.
+                iterTime = -iterTime;
+            }
+            playbackReversed ^= _timeMovesBackwards ^ IsIterationReversed(IsAlternatingPlaybackDirection(), iterIndex);
 
-                // Check if normalized time needs to be reversed according to PlaybackDirection
+            var itersUntilEnd = _iterationCount - iterIndex;
+
+            // End animation when limit is reached.
+            if (itersUntilEnd <= 0)
+            {
+                DoComplete(false);
+                return;
+            }
 
-                switch (_playbackDirection)
+            if (iterTime > iterDuration && iterTime <= iterDurationTotal && iterDelay > 0)
+            {
+                // The last iteration's trailing delay should be skipped.
+                if (_iterationCount.HasValue && itersUntilEnd <= 1)
                 {
-                    case PlaybackDirection.Normal:
-                        _playbackReversed = false;
-                        break;
-                    case PlaybackDirection.Reverse:
-                        _playbackReversed = true;
-                        break;
-                    case PlaybackDirection.Alternate:
-                        _playbackReversed = _currentIteration % 2 != 0;
-                        break;
-                    case PlaybackDirection.AlternateReverse:
-                        _playbackReversed = _currentIteration % 2 == 0;
-                        break;
-                    default:
-                        throw new InvalidOperationException(
-                            $"Animation direction value is unknown: {_playbackDirection}");
+                    DoComplete(false);
+                    return;
                 }
 
-                if (_playbackReversed)
-                    normalizedTime = 1 - normalizedTime;
+                DoIterationDelay(playbackReversed);
+            }
+            else if (iterTime <= iterDuration)
+            {
+                // Ease and interpolate.
+                var normalized = iterTime / (double)iterDuration;
+                if (playbackReversed)
+                    normalized = 1 - normalized;
 
-                // Ease and interpolate
-                var easedTime = _easeFunc!.Ease(normalizedTime);
+                var easedTime = _easeFunc!.Ease(normalized);
                 _lastInterpValue = _interpolator(easedTime, _neutralValue);
 
                 PublishNext(_lastInterpValue);
             }
-            else if (playbackTime > iterDuration &&
-                     playbackTime <= iterationTime &&
-                     iterDelay > 0)
-            {
-                // The last iteration's trailing delay should be skipped.
-                if (_currentIteration + 1 < _iterationCount)
-                    DoDelay();
-                else
-                    DoComplete();
-            }
         }
 
         private void UpdateNeutralValue()
diff --git a/tests/Avalonia.Base.UnitTests/Animation/AnimatableTests.cs b/tests/Avalonia.Base.UnitTests/Animation/AnimatableTests.cs
index 339eff1302..c13ebbfb9b 100644
--- a/tests/Avalonia.Base.UnitTests/Animation/AnimatableTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Animation/AnimatableTests.cs
@@ -654,6 +654,533 @@ namespace Avalonia.Base.UnitTests.Animation
             }
         }
 
+        [Fact]
+        public void Changing_SpeedRatio_Keeps_Playback_Time_Constant()
+        {
+            using (Start())
+            {
+                var keyframe1 = new KeyFrame()
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 0d), },
+                    KeyTime = TimeSpan.FromSeconds(0)
+                };
+
+                var keyframe2 = new KeyFrame()
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 1d), },
+                    KeyTime = TimeSpan.FromSeconds(1)
+                };
+
+                var animation = new Avalonia.Animation.Animation()
+                {
+                    Duration = TimeSpan.FromSeconds(1),
+                    Children = { keyframe1, keyframe2 },
+                };
+
+                Border target;
+                var clock = new TestClock();
+                var root = new TestRoot
+                {
+                    Clock = clock,
+                    Styles = { new Style(x => x.OfType<Border>()) { Animations = { animation }, } },
+                    Child = target = new Border { Background = Brushes.Red, }
+                };
+
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                clock.Step(TimeSpan.FromSeconds(0));
+                clock.Step(TimeSpan.FromSeconds(0.25));
+
+                animation.SpeedRatio = 2;
+                Assert.Equal(0.25, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(0.25));
+                Assert.Equal(0.25, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.25 + 0.125));
+                Assert.Equal(0.5, target.Opacity);
+
+                animation.SpeedRatio = 0.5;
+                Assert.Equal(0.5, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(0.25 + 0.125));
+                Assert.Equal(0.5, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(0.25 + 0.125 + 0.5));
+                Assert.Equal(0.75, target.Opacity);
+
+                animation.SpeedRatio = 1;
+                Assert.Equal(0.75, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(0.25 + 0.125 + 0.5));
+                Assert.Equal(0.75, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.25 + 0.125 + 0.5 + 0.25));
+                Assert.Equal(1, target.Opacity);
+            }
+        }
+
+        [Fact]
+        public void Changing_PlaybackDirection_Keeps_Playback_Time_Constant()
+        {
+            using (Start())
+            {
+                var keyframe1 = new KeyFrame()
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 0d), },
+                    KeyTime = TimeSpan.FromSeconds(0)
+                };
+
+                var keyframe2 = new KeyFrame()
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 1d), },
+                    KeyTime = TimeSpan.FromSeconds(1)
+                };
+
+                var animation = new Avalonia.Animation.Animation()
+                {
+                    Duration = TimeSpan.FromSeconds(1),
+                    Children = { keyframe1, keyframe2 },
+                    PlaybackDirection = PlaybackDirection.Normal
+                };
+
+                Border target;
+                var clock = new TestClock();
+                var root = new TestRoot
+                {
+                    Clock = clock,
+                    Styles = { new Style(x => x.OfType<Border>()) { Animations = { animation }, } },
+                    Child = target = new Border { Background = Brushes.Red, }
+                };
+
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                clock.Step(TimeSpan.FromSeconds(0));
+
+                clock.Step(TimeSpan.FromSeconds(0.25));
+                Assert.Equal(0.25, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.3));
+                Assert.Equal(0.3, target.Opacity);
+                animation.PlaybackDirection = PlaybackDirection.Reverse;
+                clock.Step(TimeSpan.FromSeconds(0.3));
+                Assert.Equal(0.3, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.35));
+                Assert.Equal(0.25, target.Opacity);
+            }
+        }
+
+        [Fact]
+        public void Reversing_Direction_Past_Initial_Point_Clamps_To_Initial_Point()
+        {
+            using (Start())
+            {
+                var keyframe1 = new KeyFrame()
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 0d), },
+                    KeyTime = TimeSpan.FromSeconds(0)
+                };
+
+                var keyframe2 = new KeyFrame()
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 1d), },
+                    KeyTime = TimeSpan.FromSeconds(1)
+                };
+
+                var animation = new Avalonia.Animation.Animation()
+                {
+                    Duration = TimeSpan.FromSeconds(1),
+                    Delay = TimeSpan.FromSeconds(0.5),
+                    Children = { keyframe1, keyframe2 },
+                    PlaybackDirection = PlaybackDirection.Normal
+                };
+
+                Border target;
+                var clock = new TestClock();
+                var root = new TestRoot
+                {
+                    Clock = clock,
+                    Styles = { new Style(x => x.OfType<Border>()) { Animations = { animation }, } },
+                    Child = target = new Border { Background = Brushes.Red, }
+                };
+
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                clock.Step(TimeSpan.FromSeconds(0));
+                Assert.Equal(1, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.5));
+                Assert.Equal(1, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(1));
+                Assert.Equal(0.5, target.Opacity);
+                animation.PlaybackDirection = PlaybackDirection.Reverse;
+                clock.Step(TimeSpan.FromSeconds(1));
+                Assert.Equal(0.5, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(1.2));
+                Assert.Equal(0.3, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(1.5));
+                Assert.Equal(0, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(2));
+                Assert.Equal(0, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(3));
+                Assert.Equal(0, target.Opacity);
+                animation.PlaybackDirection = PlaybackDirection.Normal;
+                clock.Step(TimeSpan.FromSeconds(3));
+                Assert.Equal(0, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(3.5));
+                Assert.Equal(0, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(4));
+                Assert.Equal(0.5, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(4.5));
+                Assert.Equal(1, target.Opacity);
+            }
+        }
+
+        [Fact]
+        public void DelayBetweenIterations_Behind_Initial_Point_Is_In_Front_Of_Iterations()
+        {
+            using (Start())
+            {
+                var keyframe1 = new KeyFrame()
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 0d), },
+                    KeyTime = TimeSpan.FromSeconds(0)
+                };
+
+                var keyframe2 = new KeyFrame()
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 1d), },
+                    KeyTime = TimeSpan.FromSeconds(1)
+                };
+
+                var animation = new Avalonia.Animation.Animation()
+                {
+                    Duration = TimeSpan.FromSeconds(1),
+                    DelayBetweenIterations = TimeSpan.FromSeconds(0.5),
+                    Children = { keyframe1, keyframe2 },
+                    IterationCount = IterationCount.Infinite,
+                    PlaybackDirection = PlaybackDirection.Normal
+                };
+
+                Border target;
+                var clock = new TestClock();
+                var root = new TestRoot
+                {
+                    Clock = clock,
+                    Styles = { new Style(x => x.OfType<Border>()) { Animations = { animation }, } },
+                    Child = target = new Border { Background = Brushes.Red, }
+                };
+
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                clock.Step(TimeSpan.FromSeconds(0));
+                Assert.Equal(0, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.1));
+                Assert.Equal(0.1, target.Opacity);
+                animation.PlaybackDirection = PlaybackDirection.Reverse;
+                clock.Step(TimeSpan.FromSeconds(0.1));
+                Assert.Equal(0.1, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.2));
+                Assert.Equal(0, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.2 + 0.1));
+                Assert.Equal(0.9, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.2 + 0.9));
+                Assert.Equal(0.1, target.Opacity, 0.000001);
+
+                clock.Step(TimeSpan.FromSeconds(0.2 + 1));
+                Assert.Equal(0, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.2 + 1 + 0.25));
+                Assert.Equal(0, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.2 + 1 + 0.499));
+                Assert.Equal(0, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.2 + 1 + 0.5));
+                Assert.Equal(1, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(0.2 + 1 + 0.5 + 0.1));
+                Assert.Equal(0.9, target.Opacity);
+            }
+        }
+
+        [Fact]
+        public void Zero_Duration_With_DelayBetweenIterations_Should_Finish_Animation()
+        {
+            using (Start())
+            {
+                var keyframe1 = new KeyFrame
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 0d) }, Cue = new Cue(0d)
+                };
+
+                var keyframe2 = new KeyFrame
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 1d) }, Cue = new Cue(1d)
+                };
+
+                var animation = new Avalonia.Animation.Animation
+                {
+                    Duration = TimeSpan.Zero,
+                    DelayBetweenIterations = TimeSpan.FromSeconds(0.5),
+                    IterationCount = IterationCount.Infinite,
+                    Children = { keyframe1, keyframe2 }
+                };
+
+                Border target;
+                var clock = new TestClock();
+                var root = new TestRoot
+                {
+                    Clock = clock,
+                    Styles = { new Style(x => x.OfType<Border>()) { Animations = { animation } } },
+                    Child = target = new Border { Background = Brushes.Red }
+                };
+
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                clock.Step(TimeSpan.FromSeconds(0));
+                Assert.False(double.IsNaN(target.Opacity));
+                Assert.Equal(1, target.Opacity);
+                Assert.False(target.IsAnimating(Visual.OpacityProperty));
+
+                clock.Step(TimeSpan.FromSeconds(0.5));
+                Assert.False(double.IsNaN(target.Opacity));
+            }
+        }
+
+        [Fact]
+        public void Setting_Duration_To_Zero_With_DelayBetweenIterations_Should_Finish_Animation()
+        {
+            using (Start())
+            {
+                var keyframe1 = new KeyFrame
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 0d) }, KeyTime = TimeSpan.FromSeconds(0)
+                };
+
+                var keyframe2 = new KeyFrame
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 1d) }, KeyTime = TimeSpan.FromSeconds(1)
+                };
+
+                var animation = new Avalonia.Animation.Animation
+                {
+                    Duration = TimeSpan.FromSeconds(1),
+                    DelayBetweenIterations = TimeSpan.FromSeconds(0.5),
+                    IterationCount = IterationCount.Infinite,
+                    Children = { keyframe1, keyframe2 }
+                };
+
+                Border target;
+                var clock = new TestClock();
+                var root = new TestRoot
+                {
+                    Clock = clock,
+                    Styles = { new Style(x => x.OfType<Border>()) { Animations = { animation } } },
+                    Child = target = new Border { Background = Brushes.Red }
+                };
+
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                clock.Step(TimeSpan.FromSeconds(0));
+                clock.Step(TimeSpan.FromSeconds(0.5));
+                Assert.Equal(0.5, target.Opacity);
+
+                animation.Duration = TimeSpan.Zero;
+
+                clock.Step(TimeSpan.FromSeconds(1));
+                Assert.False(double.IsNaN(target.Opacity));
+                Assert.Equal(1, target.Opacity);
+                Assert.False(target.IsAnimating(Visual.OpacityProperty));
+            }
+        }
+
+        [Fact]
+        public void Reversing_Direction_Past_Initial_Point_Parks_Animation_Until_Resumed()
+        {
+            var keyframe1 = new KeyFrame
+            {
+                Setters = { new Setter(Visual.OpacityProperty, 0d) }, KeyTime = TimeSpan.FromSeconds(0)
+            };
+
+            var keyframe2 = new KeyFrame
+            {
+                Setters = { new Setter(Visual.OpacityProperty, 1d) }, KeyTime = TimeSpan.FromSeconds(1)
+            };
+
+            var animation = new Avalonia.Animation.Animation
+            {
+                Duration = TimeSpan.FromSeconds(1),
+                Children = { keyframe1, keyframe2 }
+            };
+
+            var target = new Border { Background = Brushes.Red };
+
+            var clock = new TestClock();
+            var animationRun = animation.RunAsync(target, clock, TestContext.Current.CancellationToken);
+
+            clock.Step(TimeSpan.FromSeconds(0));
+            clock.Step(TimeSpan.FromSeconds(0.5));
+            Assert.Equal(0.5, target.Opacity);
+
+            // Reverse the animation so that it runs back to its initial point, where a limited
+            // number of iterations clamps it. The animation is parked rather than finished: it
+            // stays subscribed, and so RunAsync stays pending, because playback can still be
+            // resumed by changing the direction back.
+            animation.PlaybackDirection = PlaybackDirection.Reverse;
+            clock.Step(TimeSpan.FromSeconds(0.5));
+            clock.Step(TimeSpan.FromSeconds(1));
+            clock.Step(TimeSpan.FromSeconds(10));
+
+            Assert.Equal(0, target.Opacity);
+            Assert.False(animationRun.IsCompleted);
+
+            // Resuming from the parked state runs the animation to its end and completes it.
+            animation.PlaybackDirection = PlaybackDirection.Normal;
+            clock.Step(TimeSpan.FromSeconds(10));
+            clock.Step(TimeSpan.FromSeconds(10.5));
+            Assert.Equal(0.5, target.Opacity);
+
+            clock.Step(TimeSpan.FromSeconds(11));
+            Assert.Equal(1, target.Opacity);
+            Assert.True(animationRun.IsCompleted);
+        }
+
+        [Fact]
+        public void Changing_SpeedRatio_Every_Frame_Should_Not_Lose_Playback_Time()
+        {
+            using (Start())
+            {
+                var keyframe1 = new KeyFrame
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 0d) }, KeyTime = TimeSpan.FromSeconds(0)
+                };
+
+                var keyframe2 = new KeyFrame
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 1d) }, KeyTime = TimeSpan.FromSeconds(10)
+                };
+
+                var animation = new Avalonia.Animation.Animation
+                {
+                    Duration = TimeSpan.FromSeconds(10),
+                    IterationCount = IterationCount.Infinite,
+                    Children = { keyframe1, keyframe2 }
+                };
+
+                Border target;
+                var clock = new TestClock();
+                var root = new TestRoot
+                {
+                    Clock = clock,
+                    Styles = { new Style(x => x.OfType<Border>()) { Animations = { animation } } },
+                    Child = target = new Border { Background = Brushes.Red }
+                };
+
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                clock.Step(TimeSpan.FromSeconds(0));
+
+                // 60 frames of 1/60th of a second: one second of playback out of a ten second
+                // animation. SpeedRatio stays effectively 1 but is written on every frame, as it
+                // would be when bound to a slider being dragged. Re-anchoring playback time on
+                // each change must not accumulate rounding errors.
+                var frame = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 60);
+                var time = TimeSpan.Zero;
+
+                for (var i = 0; i < 60; i++)
+                {
+                    time += frame;
+                    animation.SpeedRatio = 1d + i * 1e-9;
+                    clock.Step(time);
+                }
+
+                Assert.Equal(0.1, target.Opacity, 0.001);
+            }
+        }
+
+        [Fact]
+        public void Reversing_Infinite_Animation_Past_Initial_Point_Replays_Previous_Iterations()
+        {
+            using (Start())
+            {
+                var keyframe1 = new KeyFrame
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 0d) }, KeyTime = TimeSpan.FromSeconds(0)
+                };
+
+                var keyframe2 = new KeyFrame
+                {
+                    Setters = { new Setter(Visual.OpacityProperty, 1d) }, KeyTime = TimeSpan.FromSeconds(1)
+                };
+
+                var animation = new Avalonia.Animation.Animation
+                {
+                    Duration = TimeSpan.FromSeconds(1),
+                    Delay = TimeSpan.FromSeconds(0.5),
+                    IterationCount = IterationCount.Infinite,
+                    FillMode = FillMode.Both,
+                    Children = { keyframe1, keyframe2 }
+                };
+
+                Border target;
+                var clock = new TestClock();
+                var root = new TestRoot
+                {
+                    Clock = clock,
+                    Styles = { new Style(x => x.OfType<Border>()) { Animations = { animation } } },
+                    Child = target = new Border { Background = Brushes.Red }
+                };
+
+                root.Measure(Size.Infinity);
+                root.Arrange(new Rect(root.DesiredSize));
+
+                clock.Step(TimeSpan.FromSeconds(0));
+                Assert.Equal(0, target.Opacity);
+
+                // Initial delay, then half of the first iteration.
+                clock.Step(TimeSpan.FromSeconds(1));
+                Assert.Equal(0.5, target.Opacity);
+
+                animation.PlaybackDirection = PlaybackDirection.Reverse;
+                clock.Step(TimeSpan.FromSeconds(1));
+                Assert.Equal(0.5, target.Opacity);
+
+                clock.Step(TimeSpan.FromSeconds(1.25));
+                Assert.Equal(0.25, target.Opacity);
+
+                // Back at the initial point.
+                clock.Step(TimeSpan.FromSeconds(1.5));
+                Assert.Equal(0, target.Opacity);
+
+                // The initial delay is mirrored around the initial point, so crossing it while
+                // reversed takes twice the Delay. Note that a finite animation behaves
+                // differently: it clamps at the initial point instead, and only ever spends
+                // Delay there. See Reversing_Direction_Past_Initial_Point_Clamps_To_Initial_Point.
+                clock.Step(TimeSpan.FromSeconds(2));
+                Assert.Equal(0, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(2.5));
+                Assert.Equal(0, target.Opacity);
+
+                // Past the delay, the iteration before the initial one plays backwards.
+                clock.Step(TimeSpan.FromSeconds(2.75));
+                Assert.Equal(0.75, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(3));
+                Assert.Equal(0.5, target.Opacity);
+                clock.Step(TimeSpan.FromSeconds(3.5));
+                Assert.Equal(1, target.Opacity);
+            }
+        }
+
         private static IDisposable Start()
         {
             var clock = new MockGlobalClock();

From 4c58afee88530c7c6dd0db56c1490773e502cc80 Mon Sep 17 00:00:00 2001
From: kerams <kerams@users.noreply.github.com>
Date: Thu, 6 Aug 2026 10:35:36 +0200
Subject: [PATCH 146/196] Add TextInputOptions.HintLocales (#21528)

* Add TextInputOptions.HintLocales

* Address review

* Address review

* Address review
---
 .../Platform/Input/AndroidInputMethod.cs      |  7 +++-
 .../Input/TextInput/TextInputOptions.cs       | 36 +++++++++++++++++++
 src/iOS/Avalonia.iOS/TextInputResponder.cs    | 17 +++++++++
 3 files changed, 59 insertions(+), 1 deletion(-)

diff --git a/src/Android/Avalonia.Android/Platform/Input/AndroidInputMethod.cs b/src/Android/Avalonia.Android/Platform/Input/AndroidInputMethod.cs
index 2e8e145ef8..668c433600 100644
--- a/src/Android/Avalonia.Android/Platform/Input/AndroidInputMethod.cs
+++ b/src/Android/Avalonia.Android/Platform/Input/AndroidInputMethod.cs
@@ -1,6 +1,8 @@
-using System;
+using System;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Android.Content;
+using Android.OS;
 using Android.Runtime;
 using Android.Text;
 using Android.Views;
@@ -206,6 +208,9 @@ namespace Avalonia.Android.Platform.Input
 
                 outAttrs.ImeOptions |= ImeFlags.NoFullscreen | ImeFlags.NoExtractUi;
 
+                if (options.LocaleHints?.Count > 0)
+                    outAttrs.HintLocales = new LocaleList(options.LocaleHints.Select(Java.Util.Locale.ForLanguageTag).ToArray());
+
                 return _inputConnection;
             });
         }
diff --git a/src/Avalonia.Base/Input/TextInput/TextInputOptions.cs b/src/Avalonia.Base/Input/TextInput/TextInputOptions.cs
index deed705ef4..f9c902c341 100644
--- a/src/Avalonia.Base/Input/TextInput/TextInputOptions.cs
+++ b/src/Avalonia.Base/Input/TextInput/TextInputOptions.cs
@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 namespace Avalonia.Input.TextInput;
 
 public class TextInputOptions
@@ -14,6 +16,7 @@ public class TextInputOptions
             Lowercase = GetLowercase(avaloniaObject),
             Uppercase = GetUppercase(avaloniaObject),
             ShowSuggestions = GetShowSuggestions(avaloniaObject),
+            LocaleHints = GetLocaleHints(avaloniaObject),
         };
 
         return result;
@@ -287,4 +290,37 @@ public class TextInputOptions
     /// Show virtual keyboard suggestions
     /// </summary>
     public bool? ShowSuggestions { get; set; }
+
+    /// <summary>
+    /// Defines the <see cref="LocaleHints"/> property.
+    /// </summary>
+    public static readonly AttachedProperty<IReadOnlyList<string>?> LocaleHintsProperty =
+        AvaloniaProperty.RegisterAttached<TextInputOptions, StyledElement, IReadOnlyList<string>?>(
+            "LocaleHints",
+            inherits: true);
+
+    /// <summary>
+    /// Sets the value of the attached <see cref="LocaleHintsProperty"/> on a control.
+    /// </summary>
+    /// <param name="avaloniaObject">The control.</param>
+    /// <param name="value">The property value to set.</param>
+    public static void SetLocaleHints(StyledElement avaloniaObject, IReadOnlyList<string>? value)
+    {
+        avaloniaObject.SetValue(LocaleHintsProperty, value);
+    }
+
+    /// <summary>
+    /// Gets the value of the attached <see cref="LocaleHintsProperty"/>.
+    /// </summary>
+    /// <param name="avaloniaObject">The target.</param>
+    /// <returns>BCP47 locale values</returns>
+    public static IReadOnlyList<string>? GetLocaleHints(StyledElement avaloniaObject)
+    {
+        return avaloniaObject.GetValue(LocaleHintsProperty);
+    }
+
+    /// <summary>
+    /// Gets or sets the locale hints, using BCP47 values.
+    /// </summary>
+    public IReadOnlyList<string>? LocaleHints { get; set; }
 }
diff --git a/src/iOS/Avalonia.iOS/TextInputResponder.cs b/src/iOS/Avalonia.iOS/TextInputResponder.cs
index b2c1d1700c..90d704db45 100644
--- a/src/iOS/Avalonia.iOS/TextInputResponder.cs
+++ b/src/iOS/Avalonia.iOS/TextInputResponder.cs
@@ -102,6 +102,23 @@ partial class AvaloniaView
         {
             get
             {
+                var localeHints = _view._options?.LocaleHints;
+
+                if (localeHints?.Count > 0)
+                {
+                    foreach (var locale in localeHints)
+                    {
+                        foreach (var inputMode in UITextInputMode.ActiveInputModes)
+                        {
+                            var lang = inputMode.PrimaryLanguage;
+                            if (lang != null && (lang.Equals(locale, StringComparison.OrdinalIgnoreCase) || lang.StartsWith(locale + "-", StringComparison.OrdinalIgnoreCase)))
+                            {
+                                return inputMode;
+                            }
+                        }
+                    }
+                }
+
                 UITextInputMode? mode = null;
 #if !TVOS
 #pragma warning disable CA1422

From 043047889469e59ca611441b9b3f523f983fb18b Mon Sep 17 00:00:00 2001
From: Illustar0 <me@illustar0.com>
Date: Thu, 6 Aug 2026 17:39:22 +0800
Subject: [PATCH 147/196] fix(LinuxFramebuffer): free native DRM resources
 after enumeration (#21924)

---
 .../Output/DrmBindings.cs                     | 41 +++++++++++--------
 1 file changed, 25 insertions(+), 16 deletions(-)

diff --git a/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmBindings.cs b/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmBindings.cs
index 7da96cdb70..b80976e540 100644
--- a/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmBindings.cs
+++ b/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmBindings.cs
@@ -93,26 +93,35 @@ namespace Avalonia.LinuxFramebuffer.Output
             if (res == null)
                 throw new Win32Exception("drmModeGetResources failed");
 
-            var crtcs = new drmModeCrtc[res->count_crtcs];
-            for (var c = 0; c < res->count_crtcs; c++)
+            try
             {
-                var crtc = drmModeGetCrtc(fd, res->crtcs[c]);
-                crtcs[c] = *crtc;
-                drmModeFreeCrtc(crtc);
-            }
+                var crtcs = new drmModeCrtc[res->count_crtcs];
+                for (var c = 0; c < res->count_crtcs; c++)
+                {
+                    var crtc = drmModeGetCrtc(fd, res->crtcs[c]);
+                    crtcs[c] = *crtc;
+                    drmModeFreeCrtc(crtc);
+                }
 
-            for (var c = 0; c < res->count_encoders; c++)
-            {
-                var enc = drmModeGetEncoder(fd, res->encoders[c]);
-                Encoders[res->encoders[c]] = new DrmEncoder(*enc, crtcs);
-                drmModeFreeEncoder(enc);
-            }
+                for (var c = 0; c < res->count_encoders; c++)
+                {
+                    var enc = drmModeGetEncoder(fd, res->encoders[c]);
+                    Encoders[res->encoders[c]] = new DrmEncoder(*enc, crtcs);
+                    drmModeFreeEncoder(enc);
+                }
 
-            for (var c = 0; c < res->count_connectors; c++)
+                for (var c = 0; c < res->count_connectors; c++)
+                {
+                    var conn = connectorsForceProbe ?
+                        drmModeGetConnector(fd, res->connectors[c]) :
+                        drmModeGetConnectorCurrent(fd, res->connectors[c]);
+                    Connectors.Add(new DrmConnector(conn));
+                    drmModeFreeConnector(conn);
+                }
+            }
+            finally
             {
-                var conn = connectorsForceProbe ? drmModeGetConnector(fd, res->connectors[c]) : drmModeGetConnectorCurrent(fd, res->connectors[c]);
-                Connectors.Add(new DrmConnector(conn));
-                drmModeFreeConnector(conn);
+                drmModeFreeResources(res);
             }
         }
 

From 0e9b853787f0d7a6d263a0563d7e8d71ff99b6c9 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Thu, 6 Aug 2026 16:00:40 +0200
Subject: [PATCH 148/196] Add some AI guidelines to CONTRIBUTING.md (#21931)

* Add some AI guidelines to CONTRIBUTING.md

* Ask for the obvious
---
 CONTRIBUTING.md | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8351fc2ea6..de3c6e4782 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,6 +2,8 @@
 
 PRs are always welcomed from everyone. Following this guide will help us get your PR reviewed and merged as quickly as possible.
 
+If you're an AI agent or a human using some AI assistance to open a PR, ensure you have read the [AI Guidelines](#ai-guidelines) section below.
+
 For this guide we're going to split PRs into two types: bug fixes and features; the requirements for each are slightly different.
 
 ## Bug Fixes
@@ -27,8 +29,6 @@ In this way the reviewer can check out the commit with the failing test and conf
 
 Features should always include unit tests or integration tests where possible.
 
-> One exception to this is features related to DevTools which has no tests currently
-
 Features that introduce new controls should consider the following:
 
 - Ideally the control should be exposed to the operating system's automation/accessibility APIs by writing an `AutomationPeer`
@@ -85,6 +85,21 @@ Render tests should describe what the produced image is:
     void Rectangle_2px_Stroke_Filled()
 ```
 
+## AI Guidelines
+
+Avalonia accepts AI-assisted contributions.  
+However, if you're an autonomous AI agent, please stop right there. We want a human to read and respond to the various review comments.
+
+When opening an AI-authored or AI-assisted PR, please make sure that:
+- As a human, you have fully read and completely understood all the changes your AI agent made.
+- As a human, you have read the PR description your AI agent made. If you've only skimmed through it because it's way too long considering the relative simplicity of the associated fix, it probably needs changes. Please respect the maintainers' time, who will have to read it.
+- Code comments are succinct and straight to the point. While commenting code is necessary, LLMs tend to be overly verbose, describing the behavior of the code preceding the change. Explaining what the current code does when it isn't obvious and referring to existing issues are fine. A ten-line comment about why the previous code was wrong isn't. Again, be succinct.
+- In the same way, keep the PR description short and to the point, especially if the modification is simple. Do NOT re-explain every single line of change in plain English; the maintainers can read code. Don't repeat the same things three times with some slight rephrasing.
+- Format the PR description properly: don't add arbitrary line breaks everywhere. We aren't in a terminal.
+ 
+
+AI-assisted pull requests that don't follow these guidelines will be closed.
+
 ## Code of Conduct
 
 This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behavior in our community.

From 6cd0867bb8e1b0d91ee301f559a7027591fbec67 Mon Sep 17 00:00:00 2001
From: Illustar0 <me@illustar0.com>
Date: Thu, 6 Aug 2026 21:59:50 +0800
Subject: [PATCH 149/196] fix(LinuxFramebuffer): select a KMS-capable DRM card
 automatically (#21923)

* fix(LinuxFramebuffer): select a KMS-capable DRM card automatically

* fix(LinuxFramebuffer): use invariant culture for DRM card number parsing
---
 .../Output/DrmBindings.cs                     | 34 ++++++++++++++-----
 1 file changed, 25 insertions(+), 9 deletions(-)

diff --git a/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmBindings.cs b/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmBindings.cs
index b80976e540..0ecb231b7b 100644
--- a/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmBindings.cs
+++ b/src/Linux/Avalonia.LinuxFramebuffer/Output/DrmBindings.cs
@@ -2,9 +2,9 @@ using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Globalization;
 using System.IO;
 using System.Runtime.InteropServices;
-using System.Text.RegularExpressions;
 using static Avalonia.LinuxFramebuffer.NativeUnsafeMethods;
 using static Avalonia.LinuxFramebuffer.Output.LibDrm;
 
@@ -149,23 +149,37 @@ namespace Avalonia.LinuxFramebuffer.Output
 
     public unsafe class DrmCard : IDisposable
     {
-        public int Fd { get; private set; }
+        public int Fd { get; private set; } = -1;
         public DrmCard(string? path = null)
         {
             if (path == null)
             {
-                var files = Directory.GetFiles("/dev/dri/");
+                var files = new SortedDictionary<int, string>();
+                foreach (var file in Directory.GetFiles("/dev/dri/", "card*"))
+                {
+                    if (int.TryParse(Path.GetFileName(file).AsSpan(4), NumberStyles.None, CultureInfo.InvariantCulture,
+                            out var cardNumber))
+                        files[cardNumber] = file;
+                }
 
-                foreach (var file in files)
+                foreach (var file in files.Values)
                 {
-                    var match = Regex.Match(file, "card[0-9]+");
+                    var fd = open(file, 2, 0);
+                    if (fd == -1)
+                        continue;
 
-                    if (match.Success)
+                    var resources = drmModeGetResources(fd);
+                    if (resources != null && resources->count_crtcs > 0 && resources->count_encoders > 0 &&
+                        resources->count_connectors > 0)
                     {
-                        Fd = open(file, 2, 0);
-                        if (Fd != -1)
-                            break;
+                        drmModeFreeResources(resources);
+                        Fd = fd;
+                        break;
                     }
+
+                    if (resources != null)
+                        drmModeFreeResources(resources);
+                    close(fd);
                 }
 
                 if (Fd == -1)
@@ -187,6 +201,8 @@ namespace Avalonia.LinuxFramebuffer.Output
         public DrmResources GetResources(bool connectorsForceProbe = false) => new DrmResources(Fd, connectorsForceProbe);
         public void Dispose()
         {
+            if (Fd == -1)
+                return;
             close(Fd);
             Fd = -1;
         }

From 17885d01637322618e8ba9ed7d741249bbf67fae Mon Sep 17 00:00:00 2001
From: Poker <poker_sang@outlook.com>
Date: Fri, 7 Aug 2026 00:06:21 +0800
Subject: [PATCH 150/196] feat: [WrapPanel] Add Justify & Stretch alignment
 (#20549)

* add Justify & Stretch enum

* fix xmldoc

* add unittest

* Modify the behavior of the last line of Stretch

* add UnitTest

* remove ScrollOrientation

* fix float error in Arrange

* Fix alignment documentation

* Restore WrapPanel UV layout

* Preserve alignment precision

* Add StretchAll alignment

* Handle zero-size stretch lines

* Remove invalid layout assertion

* Fix alignment exception name

* Simplify vertical layout tests

* Test Justify item spacing

* Add WrapPanel sample to ControlCatalog

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../ControlCatalog/Pages/WrapPanelPage.axaml  | 120 +++++++++++++++++
 .../Pages/WrapPanelPage.axaml.cs              |  13 ++
 .../MainWindowViewModel_PageList.cs           |   1 +
 .../ViewModels/WrapPanelPageViewModel.cs      | 105 +++++++++++++++
 src/Avalonia.Controls/WrapPanel.cs            | 120 +++++++++++++----
 .../WrapPanelTests.cs                         | 127 +++++++++++++++---
 6 files changed, 441 insertions(+), 45 deletions(-)
 create mode 100644 samples/ControlCatalog/Pages/WrapPanelPage.axaml
 create mode 100644 samples/ControlCatalog/Pages/WrapPanelPage.axaml.cs
 create mode 100644 samples/ControlCatalog/ViewModels/WrapPanelPageViewModel.cs

diff --git a/samples/ControlCatalog/Pages/WrapPanelPage.axaml b/samples/ControlCatalog/Pages/WrapPanelPage.axaml
new file mode 100644
index 0000000000..a10d6106f0
--- /dev/null
+++ b/samples/ControlCatalog/Pages/WrapPanelPage.axaml
@@ -0,0 +1,120 @@
+<ContentPage xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:viewModels="using:ControlCatalog.ViewModels"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+             x:Class="ControlCatalog.Pages.WrapPanelPage"
+             x:DataType="viewModels:WrapPanelPageViewModel"
+             Header="WrapPanel">
+
+  <ContentPage.Styles>
+    <Style Selector="Border.item">
+      <Setter Property="Background" Value="#4C8BF5" />
+      <Setter Property="BorderBrush" Value="#1A4FB8" />
+      <Setter Property="BorderThickness" Value="1" />
+      <Setter Property="CornerRadius" Value="3" />
+    </Style>
+    <Style Selector="Border.item > TextBlock">
+      <Setter Property="Foreground" Value="White" />
+      <Setter Property="FontWeight" Value="Bold" />
+      <Setter Property="HorizontalAlignment" Value="Center" />
+      <Setter Property="VerticalAlignment" Value="Center" />
+    </Style>
+  </ContentPage.Styles>
+
+  <DockPanel>
+
+    <TextBlock Text="A panel which lays out its children in lines, wrapping to a new line when the current one is full."
+               Classes="h2"
+               DockPanel.Dock="Top" />
+
+    <Grid ColumnDefinitions="*,Auto">
+      <Border BorderBrush="{DynamicResource CatalogBaseLowColor}"
+              BorderThickness="1"
+              Margin="0,10,10,10"
+              Grid.Column="0">
+        <ItemsControl ItemsSource="{Binding Items}">
+          <ItemsControl.ItemsPanel>
+            <ItemsPanelTemplate>
+              <WrapPanel ItemsAlignment="{Binding ItemsAlignment}"
+                         Orientation="{Binding Orientation}"
+                         ItemWidth="{Binding EffectiveItemWidth}"
+                         ItemHeight="{Binding EffectiveItemHeight}"
+                         ItemSpacing="{Binding ItemSpacing}"
+                         LineSpacing="{Binding LineSpacing}" />
+            </ItemsPanelTemplate>
+          </ItemsControl.ItemsPanel>
+          <ItemsControl.ItemTemplate>
+            <DataTemplate>
+              <Border Classes="item" Padding="{Binding Padding}">
+                <TextBlock Text="{Binding Number}" />
+              </Border>
+            </DataTemplate>
+          </ItemsControl.ItemTemplate>
+        </ItemsControl>
+      </Border>
+
+      <StackPanel Width="220"
+                  Margin="0,10,0,0"
+                  Spacing="4"
+                  VerticalAlignment="Top"
+                  Grid.Column="1">
+
+        <TextBlock Text="ItemsAlignment" />
+        <ComboBox Name="ItemsAlignmentSelector"
+                  HorizontalAlignment="Stretch"
+                  ItemsSource="{Binding ItemsAlignments}"
+                  SelectedItem="{Binding ItemsAlignment}" />
+
+        <TextBlock Text="Orientation" Margin="0,8,0,0" />
+        <ComboBox Name="OrientationSelector"
+                  HorizontalAlignment="Stretch"
+                  ItemsSource="{Binding Orientations}"
+                  SelectedItem="{Binding Orientation}" />
+
+        <TextBlock Text="{Binding ItemSpacing, StringFormat='{}ItemSpacing: {0:F0}'}"
+                   Margin="0,8,0,0" />
+        <Slider Name="ItemSpacingSlider"
+                Minimum="0"
+                Maximum="40"
+                TickFrequency="5"
+                IsSnapToTickEnabled="True"
+                Value="{Binding ItemSpacing}" />
+
+        <TextBlock Text="{Binding LineSpacing, StringFormat='{}LineSpacing: {0:F0}'}" />
+        <Slider Name="LineSpacingSlider"
+                Minimum="0"
+                Maximum="40"
+                TickFrequency="5"
+                IsSnapToTickEnabled="True"
+                Value="{Binding LineSpacing}" />
+
+        <CheckBox Name="ItemWidthCheckBox" Margin="0,8,0,0"
+                  IsChecked="{Binding IsItemWidthEnabled}"
+                  Content="{Binding ItemWidthValue, StringFormat='{}ItemWidth: {0:F0}'}" />
+        <Slider Name="ItemWidthSlider"
+                Minimum="20"
+                Maximum="250"
+                TickFrequency="10"
+                IsSnapToTickEnabled="True"
+                Value="{Binding ItemWidthValue}"
+                IsEnabled="{Binding IsItemWidthEnabled}" />
+
+        <CheckBox Name="ItemHeightCheckBox"
+                  IsChecked="{Binding IsItemHeightEnabled}"
+                  Content="{Binding ItemHeightValue, StringFormat='{}ItemHeight: {0:F0}'}" />
+        <Slider Name="ItemHeightSlider"
+                Minimum="20"
+                Maximum="250"
+                TickFrequency="10"
+                IsSnapToTickEnabled="True"
+                Value="{Binding ItemHeightValue}"
+                IsEnabled="{Binding IsItemHeightEnabled}" />
+
+      </StackPanel>
+
+    </Grid>
+
+  </DockPanel>
+</ContentPage>
diff --git a/samples/ControlCatalog/Pages/WrapPanelPage.axaml.cs b/samples/ControlCatalog/Pages/WrapPanelPage.axaml.cs
new file mode 100644
index 0000000000..802b10b672
--- /dev/null
+++ b/samples/ControlCatalog/Pages/WrapPanelPage.axaml.cs
@@ -0,0 +1,13 @@
+using Avalonia.Controls;
+using ControlCatalog.ViewModels;
+
+namespace ControlCatalog.Pages;
+
+public partial class WrapPanelPage : ContentPage
+{
+    public WrapPanelPage()
+    {
+        InitializeComponent();
+        DataContext = new WrapPanelPageViewModel();
+    }
+}
diff --git a/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs b/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
index 89d20de6fe..250b1358b5 100644
--- a/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
+++ b/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
@@ -92,6 +92,7 @@ namespace ControlCatalog.ViewModels
             new PageItem("TransitioningContentControl",() => new TransitioningContentControlPage(), Icons.Transition),
             new PageItem("TreeView",() => new TreeViewPage(), Icons.Tree),
             new PageItem("Viewbox",() => new ViewboxPage(), Icons.Viewbox),
+            new PageItem("WrapPanel",() => new WrapPanelPage(), Icons.Layout),
             new PageItem("Native Embed",() => new NativeEmbedPage(), Icons.Puzzle),
             new PageItem("Window Customizations",() => new WindowCustomizationsPage(), Icons.Window),
             new PageItem("HeaderedContentControl",() => new HeaderedContentPage(), Icons.Header),
diff --git a/samples/ControlCatalog/ViewModels/WrapPanelPageViewModel.cs b/samples/ControlCatalog/ViewModels/WrapPanelPageViewModel.cs
new file mode 100644
index 0000000000..a2b36fcef0
--- /dev/null
+++ b/samples/ControlCatalog/ViewModels/WrapPanelPageViewModel.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using MiniMvvm;
+
+namespace ControlCatalog.ViewModels;
+
+public class WrapPanelPageViewModel : ViewModelBase
+{
+    public WrapPanelItemsAlignment[] ItemsAlignments { get; } = Enum.GetValues<WrapPanelItemsAlignment>();
+
+    public Orientation[] Orientations { get; } = Enum.GetValues<Orientation>();
+
+    public IReadOnlyList<WrapPanelItemViewModel> Items { get; } = CreateItems();
+
+    public WrapPanelItemsAlignment ItemsAlignment
+    {
+        get;
+        set => RaiseAndSetIfChanged(ref field, value);
+    } = WrapPanelItemsAlignment.Start;
+
+    public Orientation Orientation
+    {
+        get;
+        set => RaiseAndSetIfChanged(ref field, value);
+    } = Orientation.Horizontal;
+
+    public double ItemSpacing
+    {
+        get;
+        set => RaiseAndSetIfChanged(ref field, value);
+    } = 5;
+
+    public double LineSpacing
+    {
+        get;
+        set => RaiseAndSetIfChanged(ref field, value);
+    } = 5;
+
+    public bool IsItemWidthEnabled
+    {
+        get;
+        set
+        {
+            if (RaiseAndSetIfChanged(ref field, value))
+                RaisePropertyChanged(nameof(EffectiveItemWidth));
+        }
+    }
+
+    public double ItemWidthValue
+    {
+        get;
+        set
+        {
+            if (RaiseAndSetIfChanged(ref field, value))
+                RaisePropertyChanged(nameof(EffectiveItemWidth));
+        }
+    } = 140;
+
+    public bool IsItemHeightEnabled
+    {
+        get;
+        set
+        {
+            if (RaiseAndSetIfChanged(ref field, value))
+                RaisePropertyChanged(nameof(EffectiveItemHeight));
+        }
+    }
+
+    public double ItemHeightValue
+    {
+        get;
+        set
+        {
+            if (RaiseAndSetIfChanged(ref field, value))
+                RaisePropertyChanged(nameof(EffectiveItemHeight));
+        }
+    } = 90;
+
+    public double EffectiveItemWidth
+        => IsItemWidthEnabled ? ItemWidthValue : double.NaN;
+
+    public double EffectiveItemHeight
+        => IsItemHeightEnabled ? ItemHeightValue : double.NaN;
+
+    private static WrapPanelItemViewModel[] CreateItems()
+    {
+        var random = new Random(42);
+        var items = new WrapPanelItemViewModel[50];
+
+        for (var i = 0; i < items.Length; ++i)
+            items[i] = new WrapPanelItemViewModel(i + 1, new Thickness(random.Next(15, 56), random.Next(8, 31)));
+
+        return items;
+    }
+}
+
+public class WrapPanelItemViewModel(int number, Thickness padding)
+{
+    public int Number { get; } = number;
+
+    public Thickness Padding { get; } = padding;
+}
diff --git a/src/Avalonia.Controls/WrapPanel.cs b/src/Avalonia.Controls/WrapPanel.cs
index a08695874e..ec5bdd57c3 100644
--- a/src/Avalonia.Controls/WrapPanel.cs
+++ b/src/Avalonia.Controls/WrapPanel.cs
@@ -28,6 +28,30 @@ namespace Avalonia.Controls
         /// Items are laid out so the last one in each column/row touches the bottom/right of the panel.
         /// </summary>
         End,
+
+        /// <summary>
+        /// Items are laid out with equal spacing between them within each column/row.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="WrapPanel.ItemSpacing"/> becomes the minimum spacing between items.
+        /// </remarks>
+        Justify,
+
+        /// <summary>
+        /// Items are stretched evenly to fill the entire height/width of each column/row (last column/row excluded).
+        /// </summary>
+        /// <remarks>
+        /// <see cref="WrapPanel.ItemWidth"/> or <see cref="WrapPanel.ItemHeight"/> becomes the minimum size of items.
+        /// </remarks>
+        Stretch,
+
+        /// <summary>
+        /// Items are stretched evenly to fill the entire height/width of each column/row.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="WrapPanel.ItemWidth"/> or <see cref="WrapPanel.ItemHeight"/> becomes the minimum size of items.
+        /// </remarks>
+        StretchAll
     }
 
     /// <summary>
@@ -183,10 +207,8 @@ namespace Avalonia.Controls
             {
                 return children[index];
             }
-            else
-            {
-                return null;
-            }
+
+            return null;
         }
 
         /// <inheritdoc/>
@@ -205,6 +227,13 @@ namespace Avalonia.Controls
             bool itemHeightSet = !double.IsNaN(itemHeight);
             bool itemExists = false;
             bool lineExists = false;
+            var itemsAlignment = ItemsAlignment;
+            // If we have infinite space on the U axis, we always use Start alignment to avoid strange behavior
+            if (uvConstraint.U is double.PositiveInfinity)
+                itemsAlignment = WrapPanelItemsAlignment.Start;
+            // Justify/StretchAll need to measure with the full constraint on the U axis
+            if (itemsAlignment is WrapPanelItemsAlignment.Justify or WrapPanelItemsAlignment.StretchAll)
+                panelSize.U = uvConstraint.U;
 
             var childConstraint = new Size(
                 itemWidthSet ? itemWidth : constraint.Width,
@@ -216,8 +245,7 @@ namespace Avalonia.Controls
                 // Flow passes its own constraint to children
                 child.Measure(childConstraint);
 
-                // This is the size of the child in UV space
-                UVSize childSize = new UVSize(orientation,
+                var childSize = new UVSize(orientation,
                     itemWidthSet ? itemWidth : child.DesiredSize.Width,
                     itemHeightSet ? itemHeight : child.DesiredSize.Height);
 
@@ -235,16 +263,19 @@ namespace Avalonia.Controls
                 {
                     curLineSize.U += childSize.U + nextSpacing;
                     curLineSize.V = Max(childSize.V, curLineSize.V);
-                    
+
                     itemExists |= child.IsVisible; // keep true
                 }
             }
 
+            // Stretch needs to measure with the full constraint on the U axis if there are multiple lines
+            if (lineExists && itemsAlignment is WrapPanelItemsAlignment.Stretch)
+                panelSize.U = uvConstraint.U;
+
             // The last line size, if any should be added
             panelSize.U = Max(curLineSize.U, panelSize.U);
             panelSize.V += curLineSize.V + (lineExists ? lineSpacing : 0);
 
-            // Go from UV space to W/H space
             return new Size(panelSize.Width, panelSize.Height);
         }
 
@@ -267,6 +298,10 @@ namespace Avalonia.Controls
             bool itemHeightSet = !double.IsNaN(itemHeight);
             bool itemExists = false;
             bool lineExists = false;
+            var itemsAlignment = ItemsAlignment;
+            // If we have infinite space on the U axis, we always use Start alignment to avoid strange behavior
+            if (uvFinalSize.U is double.PositiveInfinity)
+                itemsAlignment = WrapPanelItemsAlignment.Start;
 
             for (int i = 0; i < children.Count; ++i)
             {
@@ -306,32 +341,65 @@ namespace Avalonia.Controls
 
             return finalSize;
 
-            void ArrangeLine(double lineV, int start, int end)
+            void ArrangeLine(double lineV, int start, int endExcluded)
             {
                 bool useItemU = isHorizontal ? itemWidthSet : itemHeightSet;
-                double u = 0;
-                if (ItemsAlignment != WrapPanelItemsAlignment.Start)
+                double u = 0d;
+                var spacing = itemSpacing;
+                // Count of spacings between items
+                var spacingCount = -1;
+                double totalU = 0d;
+                double stretchRatio = 1d;
+                var lineItemsAlignment = itemsAlignment;
+                if (itemsAlignment is WrapPanelItemsAlignment.Stretch && endExcluded == children.Count)
+                    // Don't stretch the last line
+                    lineItemsAlignment = WrapPanelItemsAlignment.Start;
+
+                if (lineItemsAlignment is not WrapPanelItemsAlignment.Start)
                 {
-                    double totalU = -itemSpacing;
-                    for (int i = start; i < end; ++i)
+                    for (int i = start; i < endExcluded; ++i)
                     {
-                        totalU += GetChildU(i) + (!children[i].IsVisible ? 0 : itemSpacing);
+                        totalU += GetChildU(i);
+                        if (children[i].IsVisible)
+                            ++spacingCount;
                     }
+                }
 
-                    u = ItemsAlignment switch
-                    {
-                        WrapPanelItemsAlignment.Center => (uvFinalSize.U - totalU) / 2,
-                        WrapPanelItemsAlignment.End => uvFinalSize.U - totalU,
-                        WrapPanelItemsAlignment.Start => 0,
-                        _ => throw new ArgumentOutOfRangeException(nameof(ItemsAlignment), ItemsAlignment, null),
-                    };
+                switch (lineItemsAlignment)
+                {
+                    case WrapPanelItemsAlignment.Start:
+                        break;
+                    case WrapPanelItemsAlignment.Center:
+                        totalU += spacing * spacingCount;
+                        u = (uvFinalSize.U - totalU) / 2;
+                        break;
+                    case WrapPanelItemsAlignment.End:
+                        totalU += spacing * spacingCount;
+                        u = uvFinalSize.U - totalU;
+                        break;
+                    case WrapPanelItemsAlignment.Justify:
+                        var totalSpacing = Max(uvFinalSize.U - totalU, 0);
+                        if (spacingCount > 0)
+                            spacing = totalSpacing / spacingCount;
+                        break;
+                    case WrapPanelItemsAlignment.Stretch or WrapPanelItemsAlignment.StretchAll:
+                        if (!MathUtilities.IsZero(totalU))
+                        {
+                            var finalUWithoutSpacing = Max(uvFinalSize.U - spacing * spacingCount, 0);
+                            stretchRatio = finalUWithoutSpacing / totalU;
+                        }
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(ItemsAlignment), itemsAlignment, null);
                 }
 
-                for (int i = start; i < end; ++i)
+                for (int i = start; i < endExcluded; ++i)
                 {
-                    double layoutSlotU = GetChildU(i);
-                    children[i].Arrange(isHorizontal ? new(u, accumulatedV, layoutSlotU, lineV) : new(accumulatedV, u, lineV, layoutSlotU));
-                    u += layoutSlotU + (!children[i].IsVisible ? 0 : itemSpacing);
+                    double layoutSlotU = GetChildU(i) * stretchRatio;
+                    children[i].Arrange(isHorizontal ?
+                        new Rect(u, accumulatedV, layoutSlotU, lineV) :
+                        new Rect(accumulatedV, u, lineV, layoutSlotU));
+                    u += layoutSlotU + (children[i].IsVisible ? spacing : 0);
                 }
 
                 return;
@@ -365,11 +433,13 @@ namespace Avalonia.Controls
                 get => _orientation == Orientation.Horizontal ? U : V;
                 set { if (_orientation == Orientation.Horizontal) U = value; else V = value; }
             }
+
             internal double Height
             {
                 get => _orientation == Orientation.Horizontal ? V : U;
                 set { if (_orientation == Orientation.Horizontal) V = value; else U = value; }
             }
         }
+
     }
 }
diff --git a/tests/Avalonia.Controls.UnitTests/WrapPanelTests.cs b/tests/Avalonia.Controls.UnitTests/WrapPanelTests.cs
index 530d7a4956..0e76bfc73e 100644
--- a/tests/Avalonia.Controls.UnitTests/WrapPanelTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/WrapPanelTests.cs
@@ -65,42 +65,129 @@ namespace Avalonia.Controls.UnitTests
         [Theory, MemberData(nameof(GetItemsAlignmentValues))]
         public void Lays_Out_With_Items_Alignment(Orientation orientation, WrapPanelItemsAlignment itemsAlignment)
         {
-            var target = new WrapPanel()
+            var lineHeight = 50d;
+            var target = new WrapPanel
             {
                 Width = 200,
                 Height = 200,
                 Orientation = orientation,
                 ItemsAlignment = itemsAlignment,
-                Children =
-                {
-                    new Border { Height = 50, Width = 50 },
-                    new Border { Height = 50, Width = 50 },
-                }
+                UseLayoutRounding = false
             };
 
+            if (orientation is Orientation.Horizontal)
+            {
+                target.ItemHeight = lineHeight;
+                target.Children.Add(new Border { MinWidth = 50 });
+                target.Children.Add(new Border { MinWidth = 100 });
+                target.Children.Add(new Border { MinWidth = 150 });
+            }
+            else
+            {
+                target.ItemWidth = lineHeight;
+                target.Children.Add(new Border { MinHeight = 50 });
+                target.Children.Add(new Border { MinHeight = 100 });
+                target.Children.Add(new Border { MinHeight = 150 });
+            }
+
             target.Measure(Size.Infinity);
             target.Arrange(new Rect(target.DesiredSize));
 
             Assert.Equal(new Size(200, 200), target.Bounds.Size);
 
-            var rowBounds = target.Children[0].Bounds.Union(target.Children[1].Bounds);
+            var row1Bounds = target.Children[0].Bounds.Union(target.Children[1].Bounds);
+            var row2Bounds = target.Children[2].Bounds;
+
+            row1Bounds = new Rect(
+                Math.Round(row1Bounds.X),
+                Math.Round(row1Bounds.Y),
+                Math.Round(row1Bounds.Width),
+                Math.Round(row1Bounds.Height));
+
+            if (orientation is Orientation.Vertical)
+            {
+                row1Bounds = new Rect(row1Bounds.Y, row1Bounds.X, row1Bounds.Height, row1Bounds.Width);
+                row2Bounds = new Rect(row2Bounds.Y, row2Bounds.X, row2Bounds.Height, row2Bounds.Width);
+            }
+
+            Assert.Equal(itemsAlignment switch
+            {
+                WrapPanelItemsAlignment.Stretch or WrapPanelItemsAlignment.StretchAll or WrapPanelItemsAlignment.Justify => new(0, 0, 200, lineHeight),
+                WrapPanelItemsAlignment.Center => new(25, 0, 150, lineHeight),
+                WrapPanelItemsAlignment.End => new(50, 0, 150, lineHeight),
+                _ => new(0, 0, 150, lineHeight)
+            }, row1Bounds);
 
-            Assert.Equal(orientation switch
+            Assert.Equal(itemsAlignment switch
             {
-                Orientation.Horizontal => new(100, 50),
-                Orientation.Vertical => new(50, 100),
-                _ => throw new NotImplementedException()
-            }, rowBounds.Size);
+                WrapPanelItemsAlignment.StretchAll => new(0, lineHeight, 200, lineHeight),
+                WrapPanelItemsAlignment.Center => new(25, lineHeight, 150, lineHeight),
+                WrapPanelItemsAlignment.End => new(50, lineHeight, 150, lineHeight),
+                _ => new(0, 50, 150, 50)
+            }, row2Bounds);
+        }
 
-            Assert.Equal((orientation, itemsAlignment) switch
+        [Theory]
+        [InlineData(Orientation.Horizontal)]
+        [InlineData(Orientation.Vertical)]
+        public void Justify_Positions_Unequal_Items(Orientation orientation)
+        {
+            var target = new WrapPanel
             {
-                (_, WrapPanelItemsAlignment.Start) => new(0, 0),
-                (Orientation.Horizontal, WrapPanelItemsAlignment.Center) => new(50, 0),
-                (Orientation.Vertical, WrapPanelItemsAlignment.Center) => new(0, 50),
-                (Orientation.Horizontal, WrapPanelItemsAlignment.End) => new(100, 0),
-                (Orientation.Vertical, WrapPanelItemsAlignment.End) => new(0, 100),
-                _ => throw new NotImplementedException(),
-            }, rowBounds.Position);
+                Width = 100,
+                Height = 100,
+                Orientation = orientation,
+                ItemsAlignment = WrapPanelItemsAlignment.Justify,
+                UseLayoutRounding = false,
+            };
+
+            if (orientation is Orientation.Horizontal)
+            {
+                target.Children.Add(new Border { Width = 40, Height = 50 });
+                target.Children.Add(new Border { Width = 20, Height = 50 });
+            }
+            else
+            {
+                target.Children.Add(new Border { Width = 50, Height = 40 });
+                target.Children.Add(new Border { Width = 50, Height = 20 });
+            }
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            var firstBounds = target.Children[0].Bounds;
+            var secondBounds = target.Children[1].Bounds;
+            if (orientation is Orientation.Vertical)
+            {
+                firstBounds = new Rect(firstBounds.Y, firstBounds.X, firstBounds.Height, firstBounds.Width);
+                secondBounds = new Rect(secondBounds.Y, secondBounds.X, secondBounds.Height, secondBounds.Width);
+            }
+
+            Assert.Equal(new Rect(0, 0, 40, 50), firstBounds);
+            Assert.Equal(new Rect(80, 0, 20, 50), secondBounds);
+            Assert.Equal(40, secondBounds.X - firstBounds.Right);
+        }
+
+        [Fact]
+        public void Stretch_Handles_A_Zero_Width_Line()
+        {
+            var target = new WrapPanel
+            {
+                Width = 100,
+                ItemSpacing = 1,
+                ItemsAlignment = WrapPanelItemsAlignment.Stretch,
+                Children =
+                {
+                    new Border { Width = 0, Height = 50 },
+                    new Border { Width = 100, Height = 50 },
+                }
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Rect(0, 0, 0, 50), target.Children[0].Bounds);
+            Assert.Equal(new Rect(0, 50, 100, 50), target.Children[1].Bounds);
         }
 
         [Fact]

From c338a16d54bdb20198143b5608d797af9e35c1ea Mon Sep 17 00:00:00 2001
From: Jakob Hellermann <jakob.hellermann@protonmail.com>
Date: Thu, 6 Aug 2026 18:12:56 +0200
Subject: [PATCH 151/196] Enable viewing file packages as folder on macOS
 (#21925)

The native `NSSavePanel` does not let you pick file packges like
`Application.app`-bundles by default.

Since the file picker does not return these bundles either,
picking these bundles is currently impossible.
By enabling `treatsFilePackagesAsDirectories` users can select
a bundle and pick it as a folder, and also select the contents of that
package.
---
 native/Avalonia.Native/src/OSX/StorageProvider.mm | 1 +
 1 file changed, 1 insertion(+)

diff --git a/native/Avalonia.Native/src/OSX/StorageProvider.mm b/native/Avalonia.Native/src/OSX/StorageProvider.mm
index 7f9f622171..8e3ad185de 100644
--- a/native/Avalonia.Native/src/OSX/StorageProvider.mm
+++ b/native/Avalonia.Native/src/OSX/StorageProvider.mm
@@ -192,6 +192,7 @@ public:
             panel.canChooseDirectories = true;
             panel.canCreateDirectories = true;
             panel.canChooseFiles = false;
+            panel.treatsFilePackagesAsDirectories = true;
             
             if(title != nullptr)
             {

From 92ea5b7a7dea234edfdc6a61d5e8f7912911cd43 Mon Sep 17 00:00:00 2001
From: Autumn <80438149+AutumnYuanc@users.noreply.github.com>
Date: Fri, 7 Aug 2026 17:50:41 +0800
Subject: [PATCH 152/196] fix(input): fix AccessKeyHandler when no descendant
 control has focus (#21920)

* fix(input): fix AccessKeyHandler when no descendant control has focus

- Update IsFocusWithinOwner to use routed event's Source instead of re-querying KeyboardDevice.Instance.FocusedElement
- Allow access keys (Alt/mnemonics) to work immediately after Window opens when FocusedElement is null or owner itself
- Update shared test helpers in AccessKeyHandlerTests to populate event Source

Fixes #21806

* fix(input): address review feedback on AccessKeyHandler focus fix

- Type IsFocusWithinOwner's owner parameter as InputElement (matching
  _owner) and drop the now-redundant `is Visual` check
- Fix indentation in IsFocusWithinOwner
- Add Should_Raise_AccessKey_When_Focus_Is_On_Descendant, covering the
  IsVisualAncestorOf branch by raising KeyDown/KeyUp on a descendant
  control instead of the owner
- Revert the no-op Source assignment in the KeyDown/KeyUp test helpers
- Shorten the comment in Should_Raise_Key_Events_For_Registered_Access_Key

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 src/Avalonia.Base/Input/AccessKeyHandler.cs   | 23 +++--
 .../Input/AccessKeyHandlerTests.cs            | 96 ++++++++++++++++++-
 2 files changed, 105 insertions(+), 14 deletions(-)

diff --git a/src/Avalonia.Base/Input/AccessKeyHandler.cs b/src/Avalonia.Base/Input/AccessKeyHandler.cs
index 97d08b5620..739ff72e51 100644
--- a/src/Avalonia.Base/Input/AccessKeyHandler.cs
+++ b/src/Avalonia.Base/Input/AccessKeyHandler.cs
@@ -176,9 +176,9 @@ namespace Avalonia.Input
         /// <param name="e">The event args.</param>
         protected virtual void OnPreviewKeyDown(object? sender, KeyEventArgs e)
         {
-            // if the owner (IInputRoot) does not have the keyboard focus, ignore all keyboard events
+            // if the event did not originate from within the owner (IInputRoot), ignore all keyboard events
             // KeyboardDevice.IsKeyboardFocusWithin in case of a PopupRoot seems to only work once, so we created our own
-            var isFocusWithinOwner = IsFocusWithinOwner(_owner!);
+            var isFocusWithinOwner = IsFocusWithinOwner(_owner!, e.Source as IInputElement);
             if (!isFocusWithinOwner)
                 return;
 
@@ -226,9 +226,9 @@ namespace Avalonia.Input
         /// <param name="e">The event args.</param>
         protected virtual void OnKeyDown(object? sender, KeyEventArgs e)
         {
-            // if the owner (IInputRoot) does not have the keyboard focus, ignore all keyboard events
+            // if the event did not originate from within the owner (IInputRoot), ignore all keyboard events
             // KeyboardDevice.IsKeyboardFocusWithin in case of a PopupRoot seems to only work once, so we created our own
-            var isFocusWithinOwner = IsFocusWithinOwner(_owner!);
+            var isFocusWithinOwner = IsFocusWithinOwner(_owner!, e.Source as IInputElement);
             if (!isFocusWithinOwner)
                 return;
 
@@ -450,18 +450,17 @@ namespace Avalonia.Input
         }
 
         /// <summary>
-        /// Checks if the focused element is a descendent of the owner.
+        /// Checks if the event's source is the owner itself, or a descendant of it.
         /// </summary>
         /// <param name="owner">The owner to check.</param>
-        /// <returns>If focused element is decendant of owner <c>true</c>, otherwise <c>false</c>. </returns>
-        private static bool IsFocusWithinOwner(IInputElement owner)
+        /// <param name="source">The source of the key event, representing the effective focused element.</param>
+        /// <returns>If <paramref name="source"/> is <paramref name="owner"/> or a descendant of it, <c>true</c>, otherwise <c>false</c>.</returns>
+        private static bool IsFocusWithinOwner(InputElement owner, IInputElement? source)
         {
-            var focusedElement = KeyboardDevice.Instance?.FocusedElement;
-            if (focusedElement is not InputElement inputElement)
+            if (source is not Visual sourceVisual) 
                 return false;
-
-            var isAncestorOf = owner is Visual root && root.IsVisualAncestorOf(inputElement);
-            return isAncestorOf;
+            
+            return ReferenceEquals(sourceVisual, owner) || owner.IsVisualAncestorOf(sourceVisual);
         }
 
         /// <summary>
diff --git a/tests/Avalonia.Base.UnitTests/Input/AccessKeyHandlerTests.cs b/tests/Avalonia.Base.UnitTests/Input/AccessKeyHandlerTests.cs
index 166b777ba1..557459d9af 100644
--- a/tests/Avalonia.Base.UnitTests/Input/AccessKeyHandlerTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Input/AccessKeyHandlerTests.cs
@@ -131,11 +131,12 @@ namespace Avalonia.Base.UnitTests.Input
             KeyUp(root, Key.A, "a", KeyModifiers.Alt);
             KeyUp(root, Key.LeftAlt);
 
-            // This differs from WPF which doesn't raise the `A` key event, but matches UWP.
+            // AccessKeyHandler marks the Alt+A KeyDown as Handled once it matches a registered
+            // access key, so a plain KeyDown subscriber doesn't see it. KeyUp is unaffected: only
+            // KeyUp for the Alt key itself is handled, not arbitrary registered access keys.
             Assert.Equal(new[]
             {
                 "KeyDown LeftAlt",
-                "KeyDown A",
                 "KeyUp A",
                 "KeyUp LeftAlt",
             }, events);
@@ -283,6 +284,97 @@ namespace Avalonia.Base.UnitTests.Input
             }
         }
 
+        [Fact]
+        public void Should_Raise_AccessKey_When_Nothing_Is_Focused()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var button = new Button();
+                var root = new TestRoot(button);
+                var target = new AccessKeyHandler();
+                var raised = 0;
+
+                Assert.Null(KeyboardDevice.Instance?.FocusedElement);
+
+                target.SetOwner(root);
+                target.Register("A", button);
+                button.AddHandler(AccessKeyHandler.AccessKeyEvent, (s, e) => ++raised);
+
+                KeyDown(root, Key.LeftAlt);
+                KeyDown(root, Key.A, "a", KeyModifiers.Alt);
+
+                Assert.Equal(1, raised);
+            }
+        }
+
+        [Fact]
+        public void Should_Raise_AccessKey_When_Owner_Itself_Is_Focused()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var button = new Button();
+                var root = new TestRoot(button);
+                var target = new AccessKeyHandler();
+                var raised = 0;
+
+                KeyboardDevice.Instance?.SetFocusedElement(root, NavigationMethod.Unspecified, KeyModifiers.None);
+
+                target.SetOwner(root);
+                target.Register("A", button);
+                button.AddHandler(AccessKeyHandler.AccessKeyEvent, (s, e) => ++raised);
+
+                KeyDown(root, Key.LeftAlt);
+                KeyDown(root, Key.A, "a", KeyModifiers.Alt);
+
+                Assert.Equal(1, raised);
+            }
+        }
+
+        [Fact]
+        public void Should_Open_MainMenu_On_Alt_KeyUp_When_Nothing_Is_Focused()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var target = new AccessKeyHandler();
+                var menu = new FakeMenu();
+                var root = new TestRoot(menu);
+
+                Assert.Null(KeyboardDevice.Instance?.FocusedElement);
+
+                target.SetOwner(root);
+                target.MainMenu = menu;
+
+                KeyDown(root, Key.LeftAlt);
+                Assert.Equal(0, menu.TimesOpenCalled);
+
+                KeyUp(root, Key.LeftAlt);
+                Assert.Equal(1, menu.TimesOpenCalled);
+            }
+        }
+        
+        [Fact]
+        public void Should_Raise_AccessKey_When_Focus_Is_On_Descendant()
+        {
+            using (UnitTestApplication.Start(TestServices.RealFocus))
+            {
+                var button = new Button();
+                var root = new TestRoot(button);
+                var target = new AccessKeyHandler();
+                var raised = 0;
+
+                KeyboardDevice.Instance?.SetFocusedElement(button, NavigationMethod.Unspecified, KeyModifiers.None);
+
+                target.SetOwner(root);
+                target.Register("A", button);
+                button.AddHandler(AccessKeyHandler.AccessKeyEvent, (s, e) => ++raised);
+
+                KeyDown(button, Key.LeftAlt);
+                KeyDown(button, Key.A, "a", KeyModifiers.Alt);
+
+                Assert.Equal(1, raised);
+            }
+        }
+
         private static void KeyDown(IInputElement target, Key key, string? keySymbol = null, KeyModifiers modifiers = KeyModifiers.None)
         {
             target.RaiseEvent(new KeyEventArgs

From faf7137b2a5b6522c1abd23b057b1c819d311fc3 Mon Sep 17 00:00:00 2001
From: Yoyo <zrt2399@163.com>
Date: Fri, 7 Aug 2026 23:44:14 +0800
Subject: [PATCH 153/196] fix(SelectableTextBlock): fix SelectableTextBlock
 selection for centered and right-aligned text (#21369)

* fix(SelectableTextBlock): fix SelectableTextBlock selection for centered and right-aligned text

* Fix failing unit tests

* Let TextLayout handle out-of-bounds hit testing

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../ControlCatalog/Pages/TextBlockPage.xaml   | 23 ++++++----
 src/Avalonia.Controls/SelectableTextBlock.cs  |  4 --
 .../SelectableTextBlockTests.cs               | 43 ++++++++++++++++++-
 3 files changed, 56 insertions(+), 14 deletions(-)

diff --git a/samples/ControlCatalog/Pages/TextBlockPage.xaml b/samples/ControlCatalog/Pages/TextBlockPage.xaml
index 3418cffe74..5993f65b53 100644
--- a/samples/ControlCatalog/Pages/TextBlockPage.xaml
+++ b/samples/ControlCatalog/Pages/TextBlockPage.xaml
@@ -119,15 +119,20 @@
         </StackPanel>
       </Border>
       <Border>
-        <SelectableTextBlock Margin="10" TextWrapping="Wrap">
-          This <Span FontWeight="Bold">is</Span> a
-          <Span Background="Silver" Foreground="Maroon">TextBlock</Span>
-          with <Span TextDecorations="Underline">several</Span>
-          <Span FontStyle="Italic">Span</Span> elements,
-          <Span Foreground="Blue">
-            using a <Bold>variety</Bold> of <Italic>styles</Italic>
-          </Span>.
-        </SelectableTextBlock>
+        <StackPanel Spacing="8">
+          <SelectableTextBlock Margin="10" TextWrapping="Wrap">
+            This <Span FontWeight="Bold">is</Span> a
+            <Span Background="Silver" Foreground="Maroon">TextBlock</Span>
+            with <Span TextDecorations="Underline">several</Span>
+            <Span FontStyle="Italic">Span</Span> elements,
+            <Span Foreground="Blue">
+              using a <Bold>variety</Bold> of <Italic>styles</Italic>
+            </Span>.
+          </SelectableTextBlock>
+          <SelectableTextBlock Text="Left aligned text" TextAlignment="Left" />
+          <SelectableTextBlock Text="Center aligned text" TextAlignment="Center" />
+          <SelectableTextBlock Text="Right aligned text and wrap text" TextAlignment="Right" TextWrapping="Wrap" />
+        </StackPanel>
       </Border>
       <Border>
         <TextBlock FontFamily="Times New Roman">
diff --git a/src/Avalonia.Controls/SelectableTextBlock.cs b/src/Avalonia.Controls/SelectableTextBlock.cs
index 1b8935cf1f..a218eb0356 100644
--- a/src/Avalonia.Controls/SelectableTextBlock.cs
+++ b/src/Avalonia.Controls/SelectableTextBlock.cs
@@ -451,10 +451,6 @@ namespace Avalonia.Controls
 
                 var point = e.GetPosition(this) - new Point(padding.Left, padding.Top);
 
-                point = new Point(
-                    MathUtilities.Clamp(point.X, 0, Math.Max(TextLayout.WidthIncludingTrailingWhitespace, 0)),
-                    MathUtilities.Clamp(point.Y, 0, Math.Max(TextLayout.Height, 0)));
-
                 var hit = TextLayout.HitTestPoint(point);
                 var textPosition = hit.TextPosition;
 
diff --git a/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs b/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs
index e360694b69..2583f1011e 100644
--- a/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/SelectableTextBlockTests.cs
@@ -1,4 +1,5 @@
-using System.Linq;
+using System;
+using System.Linq;
 using Avalonia.Controls.Documents;
 using Avalonia.Media;
 using Avalonia.Media.TextFormatting;
@@ -49,6 +50,46 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Theory]
+        [InlineData(TextAlignment.Center)]
+        [InlineData(TextAlignment.Right)]
+        public void Dragging_Selection_Should_Reach_End_Of_Text_When_Text_Is_Aligned(TextAlignment textAlignment)
+        {
+            using (UnitTestApplication.Start(TestServices.MockPlatformRenderInterface))
+            {
+                var target = new SelectableTextBlock
+                {
+                    Width = 200,
+                    Text = "Aligned text",
+                    TextAlignment = textAlignment
+                };
+
+                var root = new TestRoot(target)
+                {
+                    ClientSize = new Size(300, 100)
+                };
+
+                root.Measure(root.ClientSize);
+                root.Arrange(new Rect(root.ClientSize));
+                root.ExecuteInitialLayoutPass();
+
+                var firstCharacterBounds = target.TextLayout.HitTestTextPosition(0);
+                var lastCharacterBounds = target.TextLayout.HitTestTextPosition(target.Text!.Length - 1);
+                var mouse = new MouseTestHelper();
+                var startPoint = new Point(
+                    firstCharacterBounds.X + firstCharacterBounds.Width / 2,
+                    firstCharacterBounds.Y + firstCharacterBounds.Height / 2);
+                var endPoint = new Point(
+                    Math.Min(target.Bounds.Width - 1, lastCharacterBounds.Right + 10),
+                    lastCharacterBounds.Y + lastCharacterBounds.Height / 2);
+
+                mouse.Down(target, position: target.TranslatePoint(startPoint, root));
+                mouse.Move(target, position: target.TranslatePoint(endPoint, root).GetValueOrDefault());
+
+                Assert.Equal(target.Text!.Length, Math.Max(target.SelectionStart, target.SelectionEnd));
+            }
+        }
+
         [Fact]
         public void SelectionForeground_Should_Not_Reset_Run_Typeface_And_Style()
         {

From 43c597eff9757116414c6119fe1cef1fd80d1bc1 Mon Sep 17 00:00:00 2001
From: dimension-zero <127850950+dimension-zero@users.noreply.github.com>
Date: Fri, 7 Aug 2026 17:04:41 +0100
Subject: [PATCH 154/196] [Fluent] Convert ControlTheme dimension setters to
 DynamicResource (#21403)

* [Automation] Fire property-changed events when AutomationId changes at runtime

  AutomationElementIdentifiers.AutomationIdProperty was missing, so
  runtime changes to AutomationProperties.AutomationId never raised
  UIA_AutomationPropertyChangedEventId on Windows (or the equivalent
  on macOS). UIA clients that subscribe to property changes would
  silently receive stale automation IDs.

  - Add AutomationIdProperty sentinel to AutomationElementIdentifiers
  - Raise the event in ControlAutomationPeer.OwnerPropertyChanged
    when AutomationProperties.AutomationIdProperty changes
  - Add AutomationIdProperty -> UiaPropertyId.AutomationId to the Win32
    AutomationNode.s_propertyMap
  - Add AutomationPeer_AutomationId to AvnAutomationProperty (avn.idl)
    and wire it in AvnAutomationPeer.s_propertyMap and automation.mm
  - Add unit tests covering runtime AutomationId change notifications

* refactor: extract hardcoded dimensions to theme resources

Move hardcoded padding, margin, width, height, and border thickness values from individual control themes into centralized theme resources in BaseResources.xaml. This enables better theme customization and density style support while reducing duplication across control definitions.

* Rename Internal to Inner

---------

Co-authored-by: dimension-zero <info@ditech.ai>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../Accents/BaseResources.xaml                | 63 +++++++++++++++++++
 .../Controls/ButtonSpinner.xaml               |  4 +-
 .../Controls/Calendar.xaml                    |  2 +-
 .../Controls/CalendarButton.xaml              |  6 +-
 .../Controls/CalendarDatePicker.xaml          |  4 +-
 .../Controls/CalendarDayButton.xaml           |  6 +-
 .../Controls/CheckBox.xaml                    |  2 +-
 .../Controls/CommandBar.xaml                  | 40 ++++++------
 .../Controls/DatePicker.xaml                  |  6 +-
 .../Controls/DateTimePickerShared.xaml        |  6 +-
 .../Controls/GridSplitter.xaml                |  4 +-
 .../Controls/HeaderedContentControl.xaml      |  2 +-
 .../Controls/Label.xaml                       |  2 +-
 .../Controls/ManagedFileChooser.xaml          | 14 ++---
 .../Controls/NavigationPage.xaml              |  6 +-
 .../Controls/NotificationCard.xaml            |  2 +-
 .../Controls/PipsPager.xaml                   | 30 ++++-----
 .../Controls/RadioButton.xaml                 |  2 +-
 .../Controls/TextBox.xaml                     |  2 +-
 .../Controls/TimePicker.xaml                  |  4 +-
 .../DensityStyles/Compact.xaml                | 14 +++++
 21 files changed, 149 insertions(+), 72 deletions(-)

diff --git a/src/Avalonia.Themes.Fluent/Accents/BaseResources.xaml b/src/Avalonia.Themes.Fluent/Accents/BaseResources.xaml
index 5328a71b3c..33c4409ce2 100644
--- a/src/Avalonia.Themes.Fluent/Accents/BaseResources.xaml
+++ b/src/Avalonia.Themes.Fluent/Accents/BaseResources.xaml
@@ -15,6 +15,69 @@
   <sys:Double x:Key="IconElementThemeWidth">20</sys:Double>
   <sys:Double x:Key="RefreshVisualizerIndicatorSize">24</sys:Double>
   <Thickness x:Key="ButtonPadding">8,5,8,6</Thickness>
+  <Thickness x:Key="CheckBoxPadding">8,0,0,0</Thickness>
+  <Thickness x:Key="RadioButtonPadding">8,0,0,0</Thickness>
+  <Thickness x:Key="ButtonSpinnerPadding">10,0</Thickness>
+  <Thickness x:Key="LabelPadding">3</Thickness>
+  <Thickness x:Key="HeaderedContentControlPadding">3</Thickness>
+  <Thickness x:Key="CalendarDatePickerPadding">4</Thickness>
+  <Thickness x:Key="CommandBarButtonPadding">8,4</Thickness>
+  <Thickness x:Key="CommandBarToggleButtonPadding">8,4</Thickness>
+  <Thickness x:Key="CommandBarSeparatorMargin">8,4</Thickness>
+  <Thickness x:Key="CommandBarSeparatorOverflowMargin">4,4</Thickness>
+  <Thickness x:Key="CommandBarPadding">4,0</Thickness>
+  <Thickness x:Key="CommandBarOverflowButtonPadding">12,0</Thickness>
+  <Thickness x:Key="ManagedFileChooserQuickLinksPadding">0,20</Thickness>
+  <Thickness x:Key="ManagedFileChooserQuickLinksItemPadding">30,6</Thickness>
+  <Thickness x:Key="NavigationPageCommandBarButtonPadding">8,0</Thickness>
+
+  <!-- Calendar cell sizes -->
+  <x:Double x:Key="CalendarButtonMinWidth">40</x:Double>
+  <x:Double x:Key="CalendarButtonMinHeight">40</x:Double>
+  <Thickness x:Key="CalendarButtonBorderThickness">2</Thickness>
+  <Thickness x:Key="CalendarBorderThickness">1</Thickness>
+  <x:Double x:Key="CalendarDatePickerDropDownButtonWidth">20</x:Double>
+
+  <!-- CommandBar dimensions -->
+  <x:Double x:Key="CommandBarButtonWidth">68</x:Double>
+  <x:Double x:Key="CommandBarButtonCompactWidth">40</x:Double>
+  <x:Double x:Key="CommandBarButtonLabelRightMinWidth">40</x:Double>
+  <x:Double x:Key="CommandBarButtonMinHeight">40</x:Double>
+  <x:Double x:Key="CommandBarButtonIsInOverflowMinHeight">36</x:Double>
+  <x:Double x:Key="CommandBarSeparatorWidth">1</x:Double>
+  <x:Double x:Key="CommandBarSeparatorOverflowHeight">1</x:Double>
+  <x:Double x:Key="CommandBarSeparatorMinHeight">24</x:Double>
+  <x:Double x:Key="CommandBarMinHeight">48</x:Double>
+
+  <!-- DatePicker / TimePicker -->
+  <Thickness x:Key="DatePickerBorderThickness">1</Thickness>
+  <x:Double x:Key="DatePickerPresenterWidth">296</x:Double>
+  <x:Double x:Key="TimePickerPresenterWidth">242</x:Double>
+  <x:Double x:Key="DateTimePickerButtonHeight">22</x:Double>
+
+  <!-- GridSplitter -->
+  <x:Double x:Key="GridSplitterThickness">6</x:Double>
+
+  <!-- ManagedFileChooser -->
+  <x:Double x:Key="ManagedFileChooserOverwritePromptMinWidth">270</x:Double>
+  <x:Double x:Key="ManagedFileChooserQuickLinksWidth">240</x:Double>
+  <x:Double x:Key="ManagedFileChooserQuickLinksItemHeight">32</x:Double>
+  <x:Double x:Key="ManagedFileChooserNavBarControlHeight">30</x:Double>
+  <x:Double x:Key="ManagedFileChooserNavBarButtonWidth">40</x:Double>
+
+  <!-- NotificationCard -->
+  <x:Double x:Key="NotificationCardWidth">350</x:Double>
+
+  <!-- PipsPager -->
+  <x:Double x:Key="PipsPagerNavigationButtonSize">24</x:Double>
+  <Thickness x:Key="PipsPagerNavigationButtonBorderThickness">1</Thickness>
+  <x:Double x:Key="PipsPagerItemWidth">12</x:Double>
+  <x:Double x:Key="PipsPagerItemHeight">24</x:Double>
+  <x:Double x:Key="PipsPagerItemDotSize">4</x:Double>
+  <x:Double x:Key="PipsPagerItemDotSizeActive">6</x:Double>
+
+  <!-- Inner text-control buttons (TextBox clear/reveal, ButtonSpinner arrows) -->
+  <x:Double x:Key="TextControlInnerButtonMinWidth">34</x:Double>
 
   <!-- Override system shape defaults -->
   <CornerRadius x:Key="ControlCornerRadius">3</CornerRadius>
diff --git a/src/Avalonia.Themes.Fluent/Controls/ButtonSpinner.xaml b/src/Avalonia.Themes.Fluent/Controls/ButtonSpinner.xaml
index 2e6c08a2f0..7ef89b7139 100644
--- a/src/Avalonia.Themes.Fluent/Controls/ButtonSpinner.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/ButtonSpinner.xaml
@@ -42,7 +42,7 @@
   <StreamGeometry x:Key="ButtonSpinnerDecreaseButtonIcon">M0,1 L10,10 20,1 19,0 10,8 1,0 z</StreamGeometry>
 
   <ControlTheme x:Key="FluentButtonSpinnerRepeatButton" TargetType="RepeatButton">
-    <Setter Property="MinWidth" Value="34" />
+    <Setter Property="MinWidth" Value="{DynamicResource TextControlInnerButtonMinWidth}" />
     <Setter Property="Template">
       <ControlTemplate>
         <ContentPresenter x:Name="PART_ContentPresenter"
@@ -72,7 +72,7 @@
 
   <ControlTheme x:Key="{x:Type ButtonSpinner}" TargetType="ButtonSpinner">
     <Setter Property="Foreground" Value="{DynamicResource TextControlForeground}" />
-    <Setter Property="Padding" Value="10, 0" />
+    <Setter Property="Padding" Value="{DynamicResource ButtonSpinnerPadding}" />
     <Setter Property="Background" Value="{DynamicResource TextControlBackground}" />
     <Setter Property="BorderBrush" Value="{DynamicResource TextControlBorderBrush}" />
     <Setter Property="BorderThickness" Value="{DynamicResource TextControlBorderThemeThickness}" />
diff --git a/src/Avalonia.Themes.Fluent/Controls/Calendar.xaml b/src/Avalonia.Themes.Fluent/Controls/Calendar.xaml
index 713bff0091..ba3534161c 100644
--- a/src/Avalonia.Themes.Fluent/Controls/Calendar.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/Calendar.xaml
@@ -18,7 +18,7 @@
     <Setter Property="Foreground" Value="{DynamicResource CalendarViewForeground}" />
     <Setter Property="Background" Value="{DynamicResource CalendarViewBackground}" />
     <Setter Property="BorderBrush" Value="{DynamicResource CalendarViewBorderBrush}" />
-    <Setter Property="BorderThickness" Value="1" />
+    <Setter Property="BorderThickness" Value="{DynamicResource CalendarBorderThickness}" />
     <Setter Property="HorizontalAlignment" Value="Left" />
     <Setter Property="VerticalAlignment" Value="Center" />
     <Setter Property="FontSize" Value="{DynamicResource CalendarFontSize}" />
diff --git a/src/Avalonia.Themes.Fluent/Controls/CalendarButton.xaml b/src/Avalonia.Themes.Fluent/Controls/CalendarButton.xaml
index 829871253b..b9b1d59aec 100644
--- a/src/Avalonia.Themes.Fluent/Controls/CalendarButton.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/CalendarButton.xaml
@@ -17,15 +17,15 @@
 
   <ControlTheme x:Key="{x:Type CalendarButton}" TargetType="CalendarButton">
     <Setter Property="ClickMode" Value="Release" />
-    <Setter Property="MinWidth" Value="40" />
-    <Setter Property="MinHeight" Value="40" />
+    <Setter Property="MinWidth" Value="{DynamicResource CalendarButtonMinWidth}" />
+    <Setter Property="MinHeight" Value="{DynamicResource CalendarButtonMinHeight}" />
     <Setter Property="Margin" Value="1" />
     <Setter Property="Padding" Value="0,0,0,0" />
     <!--These are actually set on the CalendarView in WinUI-->
     <Setter Property="Foreground" Value="{DynamicResource CalendarViewCalendarItemForeground}" />
     <Setter Property="Background" Value="{DynamicResource CalendarViewCalendarItemRevealBackground}" />
     <Setter Property="BorderBrush" Value="{DynamicResource CalendarViewCalendarItemRevealBorderBrush}" />
-    <Setter Property="BorderThickness" Value="2" />
+    <Setter Property="BorderThickness" Value="{DynamicResource CalendarButtonBorderThickness}" />
     <Setter Property="ClipToBounds" Value="False" />
     <Setter Property="HorizontalContentAlignment" Value="Center" />
     <Setter Property="VerticalContentAlignment" Value="Center" />
diff --git a/src/Avalonia.Themes.Fluent/Controls/CalendarDatePicker.xaml b/src/Avalonia.Themes.Fluent/Controls/CalendarDatePicker.xaml
index 395e2d514f..2718733419 100644
--- a/src/Avalonia.Themes.Fluent/Controls/CalendarDatePicker.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/CalendarDatePicker.xaml
@@ -14,7 +14,7 @@
   <ControlTheme x:Key="FluentCalendarDatePickerButton" TargetType="Button">
     <Setter Property="TextElement.Foreground" Value="{DynamicResource CalendarDatePickerCalendarGlyphForeground}" />
     <Setter Property="Margin" Value="2,0,4,0" />
-    <Setter Property="Width" Value="20" />
+    <Setter Property="Width" Value="{DynamicResource CalendarDatePickerDropDownButtonWidth}" />
     <Setter Property="Template">
       <ControlTemplate>
         <Grid Height="24"
@@ -72,7 +72,7 @@
     <Setter Property="VerticalAlignment" Value="Center" />
     <Setter Property="HorizontalContentAlignment" Value="Left" />
     <Setter Property="VerticalContentAlignment" Value="Center" />
-    <Setter Property="Padding" Value="4" />
+    <Setter Property="Padding" Value="{DynamicResource CalendarDatePickerPadding}" />
     <Setter Property="Template">
       <ControlTemplate>
         <DataValidationErrors>
diff --git a/src/Avalonia.Themes.Fluent/Controls/CalendarDayButton.xaml b/src/Avalonia.Themes.Fluent/Controls/CalendarDayButton.xaml
index 6c419e4cc9..dd5e93620a 100644
--- a/src/Avalonia.Themes.Fluent/Controls/CalendarDayButton.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/CalendarDayButton.xaml
@@ -17,15 +17,15 @@
 
   <ControlTheme x:Key="{x:Type CalendarDayButton}" TargetType="CalendarDayButton">
     <Setter Property="ClickMode" Value="Release" />
-    <Setter Property="MinWidth" Value="40" />
-    <Setter Property="MinHeight" Value="40" />
+    <Setter Property="MinWidth" Value="{DynamicResource CalendarButtonMinWidth}" />
+    <Setter Property="MinHeight" Value="{DynamicResource CalendarButtonMinHeight}" />
     <Setter Property="Margin" Value="1" />
     <Setter Property="Padding" Value="0,0,0,0" />
     <!--These are actually set on the CalendarView in WinUI-->
     <Setter Property="Foreground" Value="{DynamicResource CalendarViewCalendarItemForeground}" />
     <Setter Property="Background" Value="{DynamicResource CalendarViewCalendarItemRevealBackground}" />
     <Setter Property="BorderBrush" Value="{DynamicResource CalendarViewCalendarItemRevealBorderBrush}" />
-    <Setter Property="BorderThickness" Value="2" />
+    <Setter Property="BorderThickness" Value="{DynamicResource CalendarButtonBorderThickness}" />
     <Setter Property="ClipToBounds" Value="False" />
     <Setter Property="HorizontalContentAlignment" Value="Center" />
     <Setter Property="VerticalContentAlignment" Value="Center" />
diff --git a/src/Avalonia.Themes.Fluent/Controls/CheckBox.xaml b/src/Avalonia.Themes.Fluent/Controls/CheckBox.xaml
index d12dfd6149..13aecb0046 100644
--- a/src/Avalonia.Themes.Fluent/Controls/CheckBox.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/CheckBox.xaml
@@ -16,7 +16,7 @@
   <x:Double x:Key="CheckBoxMinHeight">32</x:Double> 
   
   <ControlTheme x:Key="{x:Type CheckBox}" TargetType="CheckBox">
-    <Setter Property="Padding" Value="8,0,0,0" />
+    <Setter Property="Padding" Value="{DynamicResource CheckBoxPadding}" />
     <Setter Property="HorizontalAlignment" Value="Left" />
     <Setter Property="VerticalAlignment" Value="Center" />
     <Setter Property="HorizontalContentAlignment" Value="Left" />
diff --git a/src/Avalonia.Themes.Fluent/Controls/CommandBar.xaml b/src/Avalonia.Themes.Fluent/Controls/CommandBar.xaml
index c1f8c16a2d..14c61f6f70 100644
--- a/src/Avalonia.Themes.Fluent/Controls/CommandBar.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/CommandBar.xaml
@@ -31,9 +31,9 @@
     <Setter Property="Background" Value="Transparent" />
     <Setter Property="BorderBrush" Value="Transparent" />
     <Setter Property="BorderThickness" Value="0" />
-    <Setter Property="Padding" Value="8,4" />
-    <Setter Property="Width" Value="68" />
-    <Setter Property="MinHeight" Value="40" />
+    <Setter Property="Padding" Value="{DynamicResource CommandBarButtonPadding}" />
+    <Setter Property="Width" Value="{DynamicResource CommandBarButtonWidth}" />
+    <Setter Property="MinHeight" Value="{DynamicResource CommandBarButtonMinHeight}" />
     <Setter Property="HorizontalContentAlignment" Value="Center" />
     <Setter Property="VerticalContentAlignment" Value="Center" />
     <Setter Property="Template">
@@ -75,7 +75,7 @@
 
     <!-- Compact: hide label, reduce width -->
     <Style Selector="^[IsCompact=True]">
-      <Setter Property="Width" Value="40" />
+      <Setter Property="Width" Value="{DynamicResource CommandBarButtonCompactWidth}" />
     </Style>
     <Style Selector="^[IsCompact=True] /template/ TextBlock#PART_Label">
       <Setter Property="IsVisible" Value="False" />
@@ -84,7 +84,7 @@
     <!-- LabelPosition=Right: horizontal layout, auto-width -->
     <Style Selector="^[LabelPosition=Right]">
       <Setter Property="Width" Value="NaN" />
-      <Setter Property="MinWidth" Value="40" />
+      <Setter Property="MinWidth" Value="{DynamicResource CommandBarButtonLabelRightMinWidth}" />
     </Style>
     <Style Selector="^[LabelPosition=Right] /template/ StackPanel#PART_LayoutRoot">
       <Setter Property="Orientation" Value="Horizontal" />
@@ -101,7 +101,7 @@
       <Setter Property="HorizontalAlignment" Value="Stretch" />
       <Setter Property="HorizontalContentAlignment" Value="Left" />
       <Setter Property="Width" Value="NaN" />
-      <Setter Property="MinHeight" Value="36" />
+      <Setter Property="MinHeight" Value="{DynamicResource CommandBarButtonIsInOverflowMinHeight}" />
     </Style>
     <Style Selector="^[IsInOverflow=True] /template/ StackPanel#PART_LayoutRoot">
       <Setter Property="HorizontalAlignment" Value="Left" />
@@ -127,9 +127,9 @@
     <Setter Property="Background" Value="Transparent" />
     <Setter Property="BorderBrush" Value="Transparent" />
     <Setter Property="BorderThickness" Value="0" />
-    <Setter Property="Padding" Value="8,4" />
-    <Setter Property="Width" Value="68" />
-    <Setter Property="MinHeight" Value="40" />
+    <Setter Property="Padding" Value="{DynamicResource CommandBarToggleButtonPadding}" />
+    <Setter Property="Width" Value="{DynamicResource CommandBarButtonWidth}" />
+    <Setter Property="MinHeight" Value="{DynamicResource CommandBarButtonMinHeight}" />
     <Setter Property="HorizontalContentAlignment" Value="Center" />
     <Setter Property="VerticalContentAlignment" Value="Center" />
     <Setter Property="Template">
@@ -176,7 +176,7 @@
 
     <!-- Compact: hide label, reduce width -->
     <Style Selector="^[IsCompact=True]">
-      <Setter Property="Width" Value="40" />
+      <Setter Property="Width" Value="{DynamicResource CommandBarButtonCompactWidth}" />
     </Style>
     <Style Selector="^[IsCompact=True] /template/ TextBlock#PART_Label">
       <Setter Property="IsVisible" Value="False" />
@@ -185,7 +185,7 @@
     <!-- LabelPosition=Right: horizontal layout, auto-width -->
     <Style Selector="^[LabelPosition=Right]">
       <Setter Property="Width" Value="NaN" />
-      <Setter Property="MinWidth" Value="40" />
+      <Setter Property="MinWidth" Value="{DynamicResource CommandBarButtonLabelRightMinWidth}" />
     </Style>
     <Style Selector="^[LabelPosition=Right] /template/ StackPanel#PART_LayoutRoot">
       <Setter Property="Orientation" Value="Horizontal" />
@@ -202,7 +202,7 @@
       <Setter Property="HorizontalAlignment" Value="Stretch" />
       <Setter Property="HorizontalContentAlignment" Value="Left" />
       <Setter Property="Width" Value="NaN" />
-      <Setter Property="MinHeight" Value="36" />
+      <Setter Property="MinHeight" Value="{DynamicResource CommandBarButtonIsInOverflowMinHeight}" />
     </Style>
     <Style Selector="^[IsInOverflow=True] /template/ StackPanel#PART_LayoutRoot">
       <Setter Property="HorizontalAlignment" Value="Left" />
@@ -225,9 +225,9 @@
 
   <!-- CommandBarSeparator ControlTheme -->
   <ControlTheme x:Key="{x:Type CommandBarSeparator}" TargetType="CommandBarSeparator">
-    <Setter Property="Width" Value="1" />
-    <Setter Property="MinHeight" Value="24" />
-    <Setter Property="Margin" Value="8,4" />
+    <Setter Property="Width" Value="{DynamicResource CommandBarSeparatorWidth}" />
+    <Setter Property="MinHeight" Value="{DynamicResource CommandBarSeparatorMinHeight}" />
+    <Setter Property="Margin" Value="{DynamicResource CommandBarSeparatorMargin}" />
     <Setter Property="Template">
       <ControlTemplate>
         <Border Background="{DynamicResource SystemControlForegroundBaseMediumLowBrush}"
@@ -241,9 +241,9 @@
     <Style Selector="^[IsInOverflow=True]">
       <Setter Property="HorizontalAlignment" Value="Stretch" />
       <Setter Property="Width" Value="NaN" />
-      <Setter Property="Height" Value="1" />
+      <Setter Property="Height" Value="{DynamicResource CommandBarSeparatorOverflowHeight}" />
       <Setter Property="MinHeight" Value="0" />
-      <Setter Property="Margin" Value="4,4" />
+      <Setter Property="Margin" Value="{DynamicResource CommandBarSeparatorOverflowMargin}" />
     </Style>
   </ControlTheme>
 
@@ -251,8 +251,8 @@
   <ControlTheme x:Key="{x:Type CommandBar}" TargetType="CommandBar">
     <Setter Property="HorizontalAlignment" Value="Stretch" />
     <Setter Property="Background" Value="{DynamicResource SystemControlBackgroundChromeMediumBrush}" />
-    <Setter Property="MinHeight" Value="48" />
-    <Setter Property="Padding" Value="4,0" />
+    <Setter Property="MinHeight" Value="{DynamicResource CommandBarMinHeight}" />
+    <Setter Property="Padding" Value="{DynamicResource CommandBarPadding}" />
     <Setter Property="ItemWidthBottom" Value="70" />
     <Setter Property="ItemWidthRight" Value="102" />
     <Setter Property="ItemWidthCollapsed" Value="42" />
@@ -271,7 +271,7 @@
                       DockPanel.Dock="Right"
                       Background="Transparent"
                       BorderThickness="0"
-                      Padding="12,0"
+                      Padding="{DynamicResource CommandBarOverflowButtonPadding}"
                       MinWidth="40"
                       VerticalAlignment="Stretch"
                       FontSize="16"
diff --git a/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml b/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml
index 1acb160a17..b38187cd60 100644
--- a/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml
@@ -75,7 +75,7 @@
     <Setter Property="Foreground" Value="{DynamicResource DatePickerButtonForeground}" />
     <Setter Property="Background" Value="{DynamicResource DatePickerButtonBackground}"/>
     <Setter Property="BorderBrush" Value="{DynamicResource DatePickerButtonBorderBrush}"/>
-    <Setter Property="BorderThickness" Value="1"/>
+    <Setter Property="BorderThickness" Value="{DynamicResource DatePickerBorderThickness}"/>
     <Setter Property="CornerRadius" Value="{DynamicResource ControlCornerRadius}" />
     <Setter Property="HorizontalAlignment" Value="Left" />
     <Setter Property="VerticalAlignment" Value="Center" />
@@ -145,8 +145,8 @@
 
   <!--WinUI: DatePickerFlyoutPresenter-->
   <ControlTheme x:Key="{x:Type DatePickerPresenter}" TargetType="DatePickerPresenter">
-    <Setter Property="Width" Value="296" />
-    <Setter Property="MinWidth" Value="296" />
+    <Setter Property="Width" Value="{DynamicResource DatePickerPresenterWidth}" />
+    <Setter Property="MinWidth" Value="{DynamicResource DatePickerPresenterWidth}" />
     <Setter Property="MaxHeight" Value="398" />
     <Setter Property="Background" Value="{DynamicResource DatePickerFlyoutPresenterBackground}" />
     <Setter Property="BorderBrush" Value="{DynamicResource DatePickerFlyoutPresenterBorderBrush}" />
diff --git a/src/Avalonia.Themes.Fluent/Controls/DateTimePickerShared.xaml b/src/Avalonia.Themes.Fluent/Controls/DateTimePickerShared.xaml
index 23082f143e..41b9710a86 100644
--- a/src/Avalonia.Themes.Fluent/Controls/DateTimePickerShared.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/DateTimePickerShared.xaml
@@ -45,7 +45,7 @@
   <!-- This is used for both the accept/dismiss & repeatbuttons in the presenter-->
   <ControlTheme x:Key="FluentDateTimePickerButton" TargetType="Button">
     <Setter Property="Background" Value="{DynamicResource DateTimePickerFlyoutButtonBackground}" />
-    <Setter Property="Height" Value="22" />
+    <Setter Property="Height" Value="{DynamicResource DateTimePickerButtonHeight}" />
     <Setter Property="HorizontalContentAlignment" Value="Center"/>
     <Setter Property="VerticalContentAlignment" Value="Center"/>
     <Setter Property="Template">
@@ -85,7 +85,7 @@
 
   <ControlTheme x:Key="FluentDateTimePickerUpButton" TargetType="RepeatButton" BasedOn="{StaticResource FluentDateTimePickerButton}">
     <Setter Property="VerticalAlignment" Value="Top"/>
-    <Setter Property="Height" Value="22" />
+    <Setter Property="Height" Value="{DynamicResource DateTimePickerButtonHeight}" />
     <Setter Property="HorizontalAlignment" Value="Stretch" />
     <Setter Property="Focusable" Value="False" />
     <Setter Property="Background" Value="{DynamicResource SystemControlBackgroundChromeMediumLowBrush}" />
@@ -101,7 +101,7 @@
 
   <ControlTheme x:Key="FluentDateTimePickerDownButton" TargetType="RepeatButton" BasedOn="{StaticResource FluentDateTimePickerButton}">
     <Setter Property="VerticalAlignment" Value="Bottom"/>
-    <Setter Property="Height" Value="22" />
+    <Setter Property="Height" Value="{DynamicResource DateTimePickerButtonHeight}" />
     <Setter Property="HorizontalAlignment" Value="Stretch" />
     <Setter Property="Focusable" Value="False" />
     <Setter Property="Background" Value="{DynamicResource SystemControlBackgroundChromeMediumLowBrush}" />
diff --git a/src/Avalonia.Themes.Fluent/Controls/GridSplitter.xaml b/src/Avalonia.Themes.Fluent/Controls/GridSplitter.xaml
index fc08d6b0b6..bf867be6fd 100644
--- a/src/Avalonia.Themes.Fluent/Controls/GridSplitter.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/GridSplitter.xaml
@@ -3,8 +3,8 @@
                     x:ClassModifier="internal">
     <ControlTheme x:Key="{x:Type GridSplitter}" TargetType="GridSplitter">
       <Setter Property="Focusable" Value="True" />
-      <Setter Property="MinWidth" Value="6" />
-      <Setter Property="MinHeight" Value="6" />
+      <Setter Property="MinWidth" Value="{DynamicResource GridSplitterThickness}" />
+      <Setter Property="MinHeight" Value="{DynamicResource GridSplitterThickness}" />
       <Setter Property="Background" Value="{DynamicResource SystemAltMediumLowColor}" />
       <Setter Property="PreviewContent">
         <Template>
diff --git a/src/Avalonia.Themes.Fluent/Controls/HeaderedContentControl.xaml b/src/Avalonia.Themes.Fluent/Controls/HeaderedContentControl.xaml
index 4474ac07ab..716dd1d859 100644
--- a/src/Avalonia.Themes.Fluent/Controls/HeaderedContentControl.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/HeaderedContentControl.xaml
@@ -4,7 +4,7 @@
   <ControlTheme x:Key="{x:Type HeaderedContentControl}"
                 TargetType="HeaderedContentControl">
 
-    <Setter Property="Padding" Value="3" />
+    <Setter Property="Padding" Value="{DynamicResource HeaderedContentControlPadding}" />
     <Setter Property="Template">
       <ControlTemplate>
         <Border BorderBrush="{TemplateBinding BorderBrush}"
diff --git a/src/Avalonia.Themes.Fluent/Controls/Label.xaml b/src/Avalonia.Themes.Fluent/Controls/Label.xaml
index daf38c2829..27633bb97b 100644
--- a/src/Avalonia.Themes.Fluent/Controls/Label.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/Label.xaml
@@ -3,7 +3,7 @@
                     x:ClassModifier="internal">
 
   <ControlTheme x:Key="{x:Type Label}" TargetType="Label">
-    <Setter Property="Padding" Value="3"/>
+    <Setter Property="Padding" Value="{DynamicResource LabelPadding}"/>
     <Setter Property="Template">
       <ControlTemplate>
         <ContentPresenter Name="PART_ContentPresenter"
diff --git a/src/Avalonia.Themes.Fluent/Controls/ManagedFileChooser.xaml b/src/Avalonia.Themes.Fluent/Controls/ManagedFileChooser.xaml
index c980135eca..00fb56e0dc 100644
--- a/src/Avalonia.Themes.Fluent/Controls/ManagedFileChooser.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/ManagedFileChooser.xaml
@@ -279,8 +279,8 @@
       <Setter Property="Margin" Value="0"/>
       <Setter Property="Background" Value="{DynamicResource SystemControlBackgroundChromeMediumBrush}"/>
       <Setter Property="BorderThickness" Value="0"/>
-      <Setter Property="Width" Value="240"/>
-      <Setter Property="Padding" Value="0,20"/>
+      <Setter Property="Width" Value="{DynamicResource ManagedFileChooserQuickLinksWidth}"/>
+      <Setter Property="Padding" Value="{DynamicResource ManagedFileChooserQuickLinksPadding}"/>
       <Setter Property="Template">
         <ControlTemplate>
           <Border Name="border" BoxShadow="inset -6 0 3 -3 #20000000" Background="{TemplateBinding Background}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="{TemplateBinding BorderThickness}">
@@ -294,8 +294,8 @@
       </Setter>
       <Setter Property="ItemContainerTheme">
         <ControlTheme TargetType="ListBoxItem">
-          <Setter Property="Height" Value="32"/>
-          <Setter Property="Padding" Value="30,6"/>
+          <Setter Property="Height" Value="{DynamicResource ManagedFileChooserQuickLinksItemHeight}"/>
+          <Setter Property="Padding" Value="{DynamicResource ManagedFileChooserQuickLinksItemPadding}"/>
           <Setter Property="Template">
             <ControlTemplate>
               <Border x:Name="LayoutRoot" CornerRadius="2" Margin="10,0">
@@ -327,11 +327,11 @@
     </Style>
 
     <Style Selector="^ /template/ DockPanel#NavBar Button, ^ /template/ DockPanel#NavBar TextBox">
-      <Setter Property="Height" Value="30"/>
+      <Setter Property="Height" Value="{DynamicResource ManagedFileChooserNavBarControlHeight}"/>
     </Style>
     <Style Selector="^ /template/ DockPanel#NavBar Button">
       <Setter Property="VerticalAlignment" Value="Stretch"/>
-      <Setter Property="Width" Value="40"/>
+      <Setter Property="Width" Value="{DynamicResource ManagedFileChooserNavBarButtonWidth}"/>
       <Setter Property="BorderThickness" Value="0"/>
     </Style>
     <Style Selector="^ /template/ DockPanel#NavBar Button:not(:pointerover):not(:pressed)">
@@ -346,7 +346,7 @@
   </ControlTheme>
 
   <ControlTheme x:Key="{x:Type dialogs:ManagedFileChooserOverwritePrompt}" TargetType="dialogs:ManagedFileChooserOverwritePrompt">
-    <Setter Property="MinWidth" Value="270" />
+    <Setter Property="MinWidth" Value="{DynamicResource ManagedFileChooserOverwritePromptMinWidth}" />
     <Setter Property="MaxWidth" Value="400" />
     <Setter Property="Template">
       <ControlTemplate>
diff --git a/src/Avalonia.Themes.Fluent/Controls/NavigationPage.xaml b/src/Avalonia.Themes.Fluent/Controls/NavigationPage.xaml
index cedf788e36..9dc97bae23 100644
--- a/src/Avalonia.Themes.Fluent/Controls/NavigationPage.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/NavigationPage.xaml
@@ -161,15 +161,15 @@
                   </Style>
                   <Style Selector="CommandBarButton">
                     <Setter Property="MinHeight" Value="0" />
-                    <Setter Property="Padding" Value="8,0" />
+                    <Setter Property="Padding" Value="{DynamicResource NavigationPageCommandBarButtonPadding}" />
                   </Style>
                   <Style Selector="CommandBarToggleButton">
                     <Setter Property="MinHeight" Value="0" />
-                    <Setter Property="Padding" Value="8,0" />
+                    <Setter Property="Padding" Value="{DynamicResource NavigationPageCommandBarButtonPadding}" />
                   </Style>
                   <Style Selector="Button#PART_OverflowButton">
                     <Setter Property="MinHeight" Value="0" />
-                    <Setter Property="Padding" Value="8,0" />
+                    <Setter Property="Padding" Value="{DynamicResource NavigationPageCommandBarButtonPadding}" />
                   </Style>
                 </ContentPresenter.Styles>
               </ContentPresenter>
diff --git a/src/Avalonia.Themes.Fluent/Controls/NotificationCard.xaml b/src/Avalonia.Themes.Fluent/Controls/NotificationCard.xaml
index 6e9277df09..bb8011b9cf 100644
--- a/src/Avalonia.Themes.Fluent/Controls/NotificationCard.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/NotificationCard.xaml
@@ -8,7 +8,7 @@
   </Design.PreviewWith>
   <ControlTheme x:Key="{x:Type NotificationCard}" TargetType="NotificationCard">
     <Setter Property="UseLayoutRounding" Value="True"/>
-    <Setter Property="Width" Value="350"/>
+    <Setter Property="Width" Value="{DynamicResource NotificationCardWidth}"/>
     <Setter Property="Foreground" Value="{DynamicResource NotificationCardForegroundBrush}"/>
     <Setter Property="RenderTransformOrigin" Value="50%,75%"/>
     <Setter Property="BorderThickness" Value="0" />
diff --git a/src/Avalonia.Themes.Fluent/Controls/PipsPager.xaml b/src/Avalonia.Themes.Fluent/Controls/PipsPager.xaml
index a331b63977..58247288f6 100644
--- a/src/Avalonia.Themes.Fluent/Controls/PipsPager.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/PipsPager.xaml
@@ -18,9 +18,9 @@
     <Setter Property="Background" Value="{DynamicResource PipsPagerNavigationButtonBackground}" />
     <Setter Property="Foreground" Value="{DynamicResource PipsPagerNavigationButtonForeground}" />
     <Setter Property="BorderBrush" Value="{DynamicResource PipsPagerNavigationButtonBorderBrush}" />
-    <Setter Property="BorderThickness" Value="1" />
-    <Setter Property="Width" Value="24" />
-    <Setter Property="Height" Value="24" />
+    <Setter Property="BorderThickness" Value="{DynamicResource PipsPagerNavigationButtonBorderThickness}" />
+    <Setter Property="Width" Value="{DynamicResource PipsPagerNavigationButtonSize}" />
+    <Setter Property="Height" Value="{DynamicResource PipsPagerNavigationButtonSize}" />
     <Setter Property="Padding" Value="0" />
     <Setter Property="HorizontalContentAlignment" Value="Center" />
     <Setter Property="VerticalContentAlignment" Value="Center" />
@@ -66,8 +66,8 @@
   <ControlTheme x:Key="PipsPagerNextButtonTheme" TargetType="Button" BasedOn="{StaticResource PipsPagerNavigationButtonTheme}" />
 
   <ControlTheme x:Key="PipsPagerItemTheme" TargetType="ListBoxItem">
-    <Setter Property="Width" Value="12" />
-    <Setter Property="Height" Value="24" />
+    <Setter Property="Width" Value="{DynamicResource PipsPagerItemWidth}" />
+    <Setter Property="Height" Value="{DynamicResource PipsPagerItemHeight}" />
     <Setter Property="Padding" Value="0" />
     <Setter Property="Margin" Value="0" />
     <Setter Property="MinWidth" Value="0" />
@@ -111,8 +111,8 @@
     </Setter>
 
     <Style Selector="^:pointerover /template/ Ellipse#Pip">
-      <Setter Property="Width" Value="6" />
-      <Setter Property="Height" Value="6" />
+      <Setter Property="Width" Value="{DynamicResource PipsPagerItemDotSizeActive}" />
+      <Setter Property="Height" Value="{DynamicResource PipsPagerItemDotSizeActive}" />
       <Setter Property="Fill" Value="{DynamicResource PipsPagerSelectionIndicatorForegroundPointerOver}" />
     </Style>
     <Style Selector="^:pointerover /template/ Ellipse#PipBackground">
@@ -120,8 +120,8 @@
       <Setter Property="Stroke" Value="{DynamicResource PipsPagerSelectionIndicatorBorderBrushPointerOver}" />
     </Style>
     <Style Selector="^:pressed /template/ Ellipse#Pip">
-      <Setter Property="Width" Value="4" />
-      <Setter Property="Height" Value="4" />
+      <Setter Property="Width" Value="{DynamicResource PipsPagerItemDotSize}" />
+      <Setter Property="Height" Value="{DynamicResource PipsPagerItemDotSize}" />
       <Setter Property="Fill" Value="{DynamicResource PipsPagerSelectionIndicatorForegroundPressed}" />
     </Style>
     <Style Selector="^:pressed /template/ Ellipse#PipBackground">
@@ -130,8 +130,8 @@
     </Style>
 
     <Style Selector="^:selected /template/ Ellipse#Pip">
-      <Setter Property="Width" Value="6" />
-      <Setter Property="Height" Value="6" />
+      <Setter Property="Width" Value="{DynamicResource PipsPagerItemDotSizeActive}" />
+      <Setter Property="Height" Value="{DynamicResource PipsPagerItemDotSizeActive}" />
       <Setter Property="Fill" Value="{DynamicResource PipsPagerSelectionIndicatorForegroundSelected}" />
     </Style>
     <Style Selector="^:selected /template/ Ellipse#PipBackground">
@@ -139,8 +139,8 @@
       <Setter Property="Stroke" Value="{DynamicResource PipsPagerSelectionIndicatorBorderBrushSelected}" />
     </Style>
     <Style Selector="^:selected:pointerover /template/ Ellipse#Pip">
-      <Setter Property="Width" Value="6" />
-      <Setter Property="Height" Value="6" />
+      <Setter Property="Width" Value="{DynamicResource PipsPagerItemDotSizeActive}" />
+      <Setter Property="Height" Value="{DynamicResource PipsPagerItemDotSizeActive}" />
       <Setter Property="Fill" Value="{DynamicResource PipsPagerSelectionIndicatorForegroundPointerOver}" />
     </Style>
     <Style Selector="^:selected:pointerover /template/ Ellipse#PipBackground">
@@ -223,8 +223,8 @@
     </Style>
 
     <Style Selector="^:vertical /template/ ListBox ListBoxItem">
-      <Setter Property="Width" Value="24" />
-      <Setter Property="Height" Value="12" />
+      <Setter Property="Width" Value="{DynamicResource PipsPagerItemHeight}" />
+      <Setter Property="Height" Value="{DynamicResource PipsPagerItemWidth}" />
     </Style>
 
     <Style Selector="^:vertical /template/ StackPanel#PART_RootPanel">
diff --git a/src/Avalonia.Themes.Fluent/Controls/RadioButton.xaml b/src/Avalonia.Themes.Fluent/Controls/RadioButton.xaml
index e1609f5cc3..3194d2134e 100644
--- a/src/Avalonia.Themes.Fluent/Controls/RadioButton.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/RadioButton.xaml
@@ -18,7 +18,7 @@
     <Setter Property="Foreground" Value="{DynamicResource RadioButtonForeground}" />
     <Setter Property="BorderBrush" Value="{DynamicResource RadioButtonBorderBrush}" />
     <Setter Property="CornerRadius" Value="{DynamicResource ControlCornerRadius}" />
-    <Setter Property="Padding" Value="8,0,0,0" />
+    <Setter Property="Padding" Value="{DynamicResource RadioButtonPadding}" />
     <Setter Property="HorizontalAlignment" Value="Left" />
     <Setter Property="VerticalAlignment" Value="Center" />
     <Setter Property="HorizontalContentAlignment" Value="Left" />
diff --git a/src/Avalonia.Themes.Fluent/Controls/TextBox.xaml b/src/Avalonia.Themes.Fluent/Controls/TextBox.xaml
index da70caa5c6..3aa9568bab 100644
--- a/src/Avalonia.Themes.Fluent/Controls/TextBox.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/TextBox.xaml
@@ -36,7 +36,7 @@
     <Setter Property="Background" Value="{DynamicResource TextControlButtonBackground}" />
     <Setter Property="BorderBrush" Value="{DynamicResource TextControlButtonBorderBrush}" />
     <Setter Property="Focusable" Value="False"/>
-    <Setter Property="MinWidth" Value="34" />
+    <Setter Property="MinWidth" Value="{DynamicResource TextControlInnerButtonMinWidth}" />
     <Setter Property="Padding" Value="{DynamicResource ButtonPadding}" />
     <Setter Property="Width" Value="{Binding $self.Bounds.Height}"/>
     <Setter Property="TextElement.Foreground" Value="{DynamicResource TextControlButtonForeground}"/>
diff --git a/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml b/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
index 28544638d1..0b4f6852bf 100644
--- a/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
@@ -185,8 +185,8 @@
   </ControlTheme>
 
   <ControlTheme x:Key="{x:Type TimePickerPresenter}" TargetType="TimePickerPresenter">
-    <Setter Property="Width" Value="242" />
-    <Setter Property="MinWidth" Value="242" />
+    <Setter Property="Width" Value="{DynamicResource TimePickerPresenterWidth}" />
+    <Setter Property="MinWidth" Value="{DynamicResource TimePickerPresenterWidth}" />
     <Setter Property="MaxHeight" Value="398" />
     <Setter Property="Background" Value="{DynamicResource TimePickerFlyoutPresenterBackground}" />
     <Setter Property="BorderBrush" Value="{DynamicResource TimePickerFlyoutPresenterBorderBrush}" />
diff --git a/src/Avalonia.Themes.Fluent/DensityStyles/Compact.xaml b/src/Avalonia.Themes.Fluent/DensityStyles/Compact.xaml
index 6c67196063..d980982f9b 100644
--- a/src/Avalonia.Themes.Fluent/DensityStyles/Compact.xaml
+++ b/src/Avalonia.Themes.Fluent/DensityStyles/Compact.xaml
@@ -26,4 +26,18 @@
   <Thickness x:Key="ButtonPadding">6,4</Thickness>
   <x:Double x:Key="CheckBoxMinHeight">24</x:Double>
   <x:Double x:Key="RadioButtonMinHeight">24</x:Double>
+  <Thickness x:Key="CheckBoxPadding">4,0,0,0</Thickness>
+  <Thickness x:Key="RadioButtonPadding">4,0,0,0</Thickness>
+  <Thickness x:Key="ButtonSpinnerPadding">6,0</Thickness>
+  <Thickness x:Key="CommandBarButtonPadding">6,2</Thickness>
+  <Thickness x:Key="CommandBarToggleButtonPadding">6,2</Thickness>
+  <Thickness x:Key="CommandBarPadding">2,0</Thickness>
+  <x:Double x:Key="CalendarButtonMinWidth">32</x:Double>
+  <x:Double x:Key="CalendarButtonMinHeight">32</x:Double>
+  <x:Double x:Key="CommandBarButtonWidth">52</x:Double>
+  <x:Double x:Key="CommandBarButtonMinHeight">32</x:Double>
+  <x:Double x:Key="CommandBarButtonIsInOverflowMinHeight">28</x:Double>
+  <x:Double x:Key="CommandBarSeparatorMinHeight">20</x:Double>
+  <x:Double x:Key="CommandBarMinHeight">40</x:Double>
+  <x:Double x:Key="PipsPagerNavigationButtonSize">20</x:Double>
 </ResourceDictionary>

From 3de977f23258d093405d10977c9f55eca7612d2e Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Mon, 10 Aug 2026 14:44:37 +0000
Subject: [PATCH 155/196] add  TextInputOptions.Multiline to sample multiline
 textbox (#21953)

---
 samples/ControlCatalog/Pages/TextBoxPage.xaml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/samples/ControlCatalog/Pages/TextBoxPage.xaml b/samples/ControlCatalog/Pages/TextBoxPage.xaml
index 9b5a412f86..f09095c2fb 100644
--- a/samples/ControlCatalog/Pages/TextBoxPage.xaml
+++ b/samples/ControlCatalog/Pages/TextBoxPage.xaml
@@ -57,9 +57,9 @@
       </StackPanel>
 
       <StackPanel Orientation="Vertical" Spacing="8" Margin="8">
-        <TextBox AcceptsReturn="True" TextWrapping="Wrap" Width="200" Height="125"
+        <TextBox AcceptsReturn="True" TextWrapping="Wrap" Width="200" Height="125" TextInputOptions.Multiline="True"
                  Text="Multiline TextBox with TextWrapping.&#xD;&#xD;Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus magna. Cras in mi at felis aliquet congue. Ut a est eget ligula molestie gravida. Curabitur massa. Donec eleifend, libero at sagittis mollis, tellus est malesuada tellus, at luctus turpis elit sit amet quam. Vivamus pretium ornare est." />
-        <TextBox AcceptsReturn="True" Width="200" Height="125"
+        <TextBox AcceptsReturn="True" Width="200" Height="125" TextInputOptions.Multiline="True"
                  Text="Multiline TextBox with no TextWrapping.&#xD;&#xD;Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus magna. Cras in mi at felis aliquet congue. Ut a est eget ligula molestie gravida. Curabitur massa. Donec eleifend, libero at sagittis mollis, tellus est malesuada tellus, at luctus turpis elit sit amet quam. Vivamus pretium ornare est." />
 
         <TextBox Classes="clearButton" Text="Clear Content" Width="200" FontWeight="Normal" FontStyle="Normal" PlaceholderText="Placeholder" FontFamily="avares://ControlCatalog/Assets/Fonts#Source Sans Pro"/>
@@ -80,6 +80,7 @@
                  Width="200"
                  Height="125"
                  LineHeight="32"
+                 TextInputOptions.Multiline="True"
                  Text="Multiline TextBox with TextWrapping and increased LineHeight.&#xD;&#xD;Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus magna. Cras in mi at felis aliquet congue. Ut a est eget ligula molestie gravida. Curabitur massa. Donec eleifend, libero at sagittis mollis, tellus est malesuada tellus, at luctus turpis elit sit amet quam. Vivamus pretium ornare est." />
       </StackPanel>
       <StackPanel Orientation="Vertical" Spacing="8" Margin="8">

From f9c5e1df03e63e64e41a32ce7b1c2fbe1bba9091 Mon Sep 17 00:00:00 2001
From: Max Katz <maxkatz6@outlook.com>
Date: Tue, 11 Aug 2026 04:39:10 -0700
Subject: [PATCH 156/196] Remove project reference to Avalonia.Remote.Protocol
 in ColorPicker (#21959)

---
 .../Avalonia.Controls.ColorPicker.csproj                         | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Avalonia.Controls.ColorPicker/Avalonia.Controls.ColorPicker.csproj b/src/Avalonia.Controls.ColorPicker/Avalonia.Controls.ColorPicker.csproj
index 473190fe59..c79c0e5bf2 100644
--- a/src/Avalonia.Controls.ColorPicker/Avalonia.Controls.ColorPicker.csproj
+++ b/src/Avalonia.Controls.ColorPicker/Avalonia.Controls.ColorPicker.csproj
@@ -8,7 +8,6 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Avalonia.Base\Avalonia.Base.csproj" />
-    <ProjectReference Include="..\Avalonia.Remote.Protocol\Avalonia.Remote.Protocol.csproj" />
     <ProjectReference Include="..\Markup\Avalonia.Markup.Xaml\Avalonia.Markup.Xaml.csproj" />
     <ProjectReference Include="..\Markup\Avalonia.Markup\Avalonia.Markup.csproj" />    
     <ProjectReference Include="..\Avalonia.Controls\Avalonia.Controls.csproj" />

From 50eb2d75c3b61cde8ba83353c799aae5d08a02fd Mon Sep 17 00:00:00 2001
From: Zeljko Predjeskovic
 <44953551+Zeljko-Predjeskovic@users.noreply.github.com>
Date: Tue, 11 Aug 2026 16:44:26 +0200
Subject: [PATCH 157/196] [Android] Fix multiline TextBox caret staying on
 previous line after autocorrect + Enter (#21900)

On Android, composing/autocorrect text is written as live text while only a
composition region is tracked. IME edit operations (commitText,
finishComposingText) are queued and flushed on EndBatchEdit, but SendKeyEvent
dispatched the key immediately, bypassing the queue.
When a soft keyboard batched "commit autocorrect + press Enter", the newline was
inserted before the queued commit flushed. The commit then applied with stale
pre-newline composition indices and reset the caret to the end of the committed
word, leaving it on the previous line instead of the new one.
Route SendKeyEvent through the command queue via a new KeyEventCommand so key
events apply in FIFO order with the queued edit commands, honoring Android's
InputConnection batch-edit ordering contract. The autocorrect now commits first,
then the newline is inserted, leaving the caret on the new line. Outside a batch
edit the key is still dispatched immediately, preserving existing behavior;
hardware key input uses a separate path and is unaffected.
Fixes #21895

Co-authored-by: Emmanuel Hansen <emmausssss@gmail.com>
---
 .../Platform/Input/AvaloniaInputConnection.cs    |  2 +-
 .../Platform/Input/EditCommand.cs                | 16 ++++++++++++++++
 .../Platform/Input/TextEditBuffer.cs             |  6 ++++++
 3 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/src/Android/Avalonia.Android/Platform/Input/AvaloniaInputConnection.cs b/src/Android/Avalonia.Android/Platform/Input/AvaloniaInputConnection.cs
index a93803db09..b79043db32 100644
--- a/src/Android/Avalonia.Android/Platform/Input/AvaloniaInputConnection.cs
+++ b/src/Android/Avalonia.Android/Platform/Input/AvaloniaInputConnection.cs
@@ -311,7 +311,7 @@ namespace Avalonia.Android.Platform.Input
 
         public bool SendKeyEvent(KeyEvent? e)
         {
-            _inputMethod.View.DispatchKeyEvent(e);
+            QueueCommand(new KeyEventCommand(e));
 
             return true;
         }
diff --git a/src/Android/Avalonia.Android/Platform/Input/EditCommand.cs b/src/Android/Avalonia.Android/Platform/Input/EditCommand.cs
index c110807dd9..33d4449725 100644
--- a/src/Android/Avalonia.Android/Platform/Input/EditCommand.cs
+++ b/src/Android/Avalonia.Android/Platform/Input/EditCommand.cs
@@ -1,4 +1,5 @@
 using System;
+using Android.Views;
 using Avalonia.Input.TextInput;
 
 namespace Avalonia.Android.Platform.Input
@@ -177,4 +178,19 @@ namespace Avalonia.Android.Platform.Input
             buffer.Composition = default;
         }
     }
+
+    internal class KeyEventCommand : EditCommand
+    {
+        private readonly KeyEvent? _keyEvent;
+
+        public KeyEventCommand(KeyEvent? keyEvent)
+        {
+            _keyEvent = keyEvent;
+        }
+
+        public override void Apply(TextEditBuffer buffer)
+        {
+            buffer.DispatchKeyEvent(_keyEvent);
+        }
+    }
 }
diff --git a/src/Android/Avalonia.Android/Platform/Input/TextEditBuffer.cs b/src/Android/Avalonia.Android/Platform/Input/TextEditBuffer.cs
index 9cbefab24a..3c25772d72 100644
--- a/src/Android/Avalonia.Android/Platform/Input/TextEditBuffer.cs
+++ b/src/Android/Avalonia.Android/Platform/Input/TextEditBuffer.cs
@@ -131,5 +131,11 @@ namespace Avalonia.Android.Platform.Input
                 Composition = null;
             }
         }
+
+
+        internal void DispatchKeyEvent(KeyEvent? keyEvent)
+        {
+            _textInputMethod?.View.DispatchKeyEvent(keyEvent);
+        }
     }
 }

From 253354fe2432318e3b0ad5b15e7eb460eeaca7b4 Mon Sep 17 00:00:00 2001
From: Yoyo <zrt2399@163.com>
Date: Wed, 12 Aug 2026 21:03:35 +0800
Subject: [PATCH 158/196] Fix WrapPanel layout jitter with LineSpacing (#21942)

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 src/Avalonia.Controls/WrapPanel.cs            | 13 ++++-
 .../WrapPanelTests.cs                         | 52 ++++++++++++++++++-
 2 files changed, 62 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.Controls/WrapPanel.cs b/src/Avalonia.Controls/WrapPanel.cs
index ec5bdd57c3..2ebfd2f001 100644
--- a/src/Avalonia.Controls/WrapPanel.cs
+++ b/src/Avalonia.Controls/WrapPanel.cs
@@ -228,6 +228,7 @@ namespace Avalonia.Controls
             bool itemExists = false;
             bool lineExists = false;
             var itemsAlignment = ItemsAlignment;
+            var useLayoutRounding = UseLayoutRounding;
             // If we have infinite space on the U axis, we always use Start alignment to avoid strange behavior
             if (uvConstraint.U is double.PositiveInfinity)
                 itemsAlignment = WrapPanelItemsAlignment.Start;
@@ -250,7 +251,7 @@ namespace Avalonia.Controls
                     itemHeightSet ? itemHeight : child.DesiredSize.Height);
 
                 var nextSpacing = itemExists && child.IsVisible ? itemSpacing : 0;
-                if (MathUtilities.GreaterThan(curLineSize.U + childSize.U + nextSpacing, uvConstraint.U)) // Need to switch to another line
+                if (GreaterThan(useLayoutRounding, curLineSize.U + childSize.U + nextSpacing, uvConstraint.U)) // Need to switch to another line
                 {
                     panelSize.U = Max(curLineSize.U, panelSize.U);
                     panelSize.V += curLineSize.V + (lineExists ? lineSpacing : 0);
@@ -299,6 +300,7 @@ namespace Avalonia.Controls
             bool itemExists = false;
             bool lineExists = false;
             var itemsAlignment = ItemsAlignment;
+            var useLayoutRounding = UseLayoutRounding;
             // If we have infinite space on the U axis, we always use Start alignment to avoid strange behavior
             if (uvFinalSize.U is double.PositiveInfinity)
                 itemsAlignment = WrapPanelItemsAlignment.Start;
@@ -311,7 +313,7 @@ namespace Avalonia.Controls
                     itemHeightSet ? itemHeight : child.DesiredSize.Height);
 
                 var nextSpacing = itemExists && child.IsVisible ? itemSpacing : 0;
-                if (MathUtilities.GreaterThan(curLineSize.U + childSize.U + nextSpacing, uvFinalSize.U)) // Need to switch to another line
+                if (GreaterThan(useLayoutRounding, curLineSize.U + childSize.U + nextSpacing, uvFinalSize.U)) // Need to switch to another line
                 {
                     accumulatedV += lineExists ? lineSpacing : 0; // add spacing to arrange line first
                     ArrangeLine(curLineSize.V, firstInLine, i);
@@ -408,6 +410,13 @@ namespace Avalonia.Controls
             }
         }
 
+        private static bool GreaterThan(bool useLayoutRounding, double value1, double value2)
+        {
+            return useLayoutRounding
+                ? value1 > value2 && value1 - value2 > LayoutHelper.LayoutEpsilon
+                : MathUtilities.GreaterThan(value1, value2);
+        }
+
         private struct UVSize
         {
             internal UVSize(Orientation orientation, double width, double height)
diff --git a/tests/Avalonia.Controls.UnitTests/WrapPanelTests.cs b/tests/Avalonia.Controls.UnitTests/WrapPanelTests.cs
index 0e76bfc73e..020d6f61d4 100644
--- a/tests/Avalonia.Controls.UnitTests/WrapPanelTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/WrapPanelTests.cs
@@ -261,6 +261,56 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Rect(0, 140, 30, 50), target.Children[3].Bounds);
         }
 
+        [Theory]
+        [InlineData(true, 50)]
+        [InlineData(false, 110)]
+        public void Measure_Respects_Layout_Rounding_At_Wrap_Boundary(bool useLayoutRounding, double expectedHeight)
+        {
+            var target = new WrapPanel
+            {
+                UseLayoutRounding = useLayoutRounding,
+                ItemSpacing = 10,
+                LineSpacing = 10,
+                Children =
+                {
+                    new Border { Width = 45, Height = 50 },
+                    new Border { Width = 45, Height = 50 },
+                }
+            };
+
+            target.Measure(new Size(100 - LayoutHelper.LayoutEpsilon / 2, double.PositiveInfinity));
+
+            Assert.Equal(expectedHeight, target.DesiredSize.Height);
+        }
+
+        [Theory]
+        [InlineData(true, 0)]
+        [InlineData(false, 60)]
+        public void Arrange_Respects_Layout_Rounding_At_Wrap_Boundary(bool useLayoutRounding, double expectedSecondChildY)
+        {
+            var target = new WrapPanel
+            {
+                UseLayoutRounding = useLayoutRounding,
+                ItemSpacing = 10,
+                LineSpacing = 10,
+                Children =
+                {
+                    new Border { Width = 45, Height = 50, UseLayoutRounding = false },
+                    new Border
+                    {
+                        Width = 45 + LayoutHelper.LayoutEpsilon / 2,
+                        Height = 50,
+                        UseLayoutRounding = false,
+                    },
+                }
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(0, 0, 100, 110));
+
+            Assert.Equal(expectedSecondChildY, target.Children[1].Bounds.Y);
+        }
+
         [Fact]
         public void Lays_Out_Horizontally_On_Separate_Lines_With_Spacing_Invisible()
         {
@@ -350,7 +400,7 @@ namespace Avalonia.Controls.UnitTests
                     new Border // line 1
                     {
                         Width = 50,
-                        Height = 50 
+                        Height = 50
                     },
                 }
             };

From 2e7da1ddc7de09a54b923ee8f6b431f059009a89 Mon Sep 17 00:00:00 2001
From: Reina_Sakiria <99442371+ReinaS-64892@users.noreply.github.com>
Date: Wed, 12 Aug 2026 22:14:29 +0900
Subject: [PATCH 159/196] fix: wrong escaping on xdg-open (linux) (#21936)

---
 .../Platform/Storage/FileIO/BclLauncher.cs    | 37 +++++--------------
 1 file changed, 10 insertions(+), 27 deletions(-)

diff --git a/src/Avalonia.Base/Platform/Storage/FileIO/BclLauncher.cs b/src/Avalonia.Base/Platform/Storage/FileIO/BclLauncher.cs
index a380be57e2..54e1424640 100644
--- a/src/Avalonia.Base/Platform/Storage/FileIO/BclLauncher.cs
+++ b/src/Avalonia.Base/Platform/Storage/FileIO/BclLauncher.cs
@@ -45,8 +45,16 @@ internal class BclLauncher : ILauncher
             {
                 // If no associated application/json MimeType is found xdg-open opens return error
                 // but it tries to open it anyway using the console editor (nano, vim, other..)
-                var args = EscapeForShell(urlOrFile);
-                ShellExecRaw($"xdg-open \\\"{args}\\\"", waitForExit: false);
+                var info = new ProcessStartInfo
+                {
+                    FileName = "xdg-open",
+                    CreateNoWindow = true,
+                    UseShellExecute = false,
+                };
+                // Using ArgumentList.Add() avoid escaping! 
+                // This is similar to the following code for macos.
+                info.ArgumentList.Add(urlOrFile);
+                using var process = Process.Start(info);
                 return true;
             }
             else if (OperatingSystem.IsWindows() || OperatingSystem.IsMacOS())
@@ -76,29 +84,4 @@ internal class BclLauncher : ILauncher
             return false;
         }
     }
-    
-    private static string EscapeForShell(string input) => Regex
-        .Replace(input, "(?=[`~!#&*()|;'<>])", "\\")
-        .Replace("\"", "\\\\\\\"");
-    
-    private static void ShellExecRaw(string cmd, bool waitForExit = true)
-    {
-        using (var process = Process.Start(
-                   new ProcessStartInfo
-                   {
-                       FileName = "/bin/sh",
-                       Arguments = $"-c \"{cmd}\"",
-                       RedirectStandardOutput = true,
-                       UseShellExecute = false,
-                       CreateNoWindow = true,
-                       WindowStyle = ProcessWindowStyle.Hidden
-                   }
-               ))
-        {
-            if (waitForExit)
-            {
-                process?.WaitForExit();
-            }
-        }
-    }
 }

From 566c37405dfe4646a62646891e53b2751dc65f00 Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Wed, 12 Aug 2026 16:42:37 +0000
Subject: [PATCH 160/196] Avoid boxing booleans in compiled binding getters
 (#21878)

* Add failing test for boxed booleans in compiled binding getters

Compiled-binding getters for bool properties emit 'box' on every read,
allocating a fresh object each time (#21065 reports ~300K allocations in
a real app). Add BooleanBoxes with two cached boxed values and a test
asserting that a compiled binding to a bool property produces the cached
box instances. BooleanBoxes must be public because compiled XAML IL is
emitted into user assemblies, which need to reference its fields.

* Reuse cached boxed booleans in compiled binding getters

Instead of emitting 'box bool' in the generated property-info getter,
emit a branch that returns BooleanBoxes.True or BooleanBoxes.False, so
reads of bool properties through compiled bindings no longer allocate.
Other value types keep the existing box. Applies to both the build-time
XAML compiler and the runtime XAML loader, which share this emitter.

Fixes #21065

* fix: emit cached boolean boxes into the generated per-assembly helper

The cached boxed booleans used by compiled-binding bool getters were
exposed as a new public BooleanBoxes class in Avalonia.Base, adding
public API surface that is useful only to compiled XAML. Review asked
for the boxes to stay an implementation detail instead.

Define two private static fields and a static constructor on the
XamlIlHelpers type the XAML compiler already generates into each user
assembly, and point the getter IL at those. The fields are shared by
all XAML files in the assembly, so allocation behaviour is unchanged
while no public API is added. The test now asserts box identity across
repeated reads instead of referencing the removed class.
---
 .../XamlIlClrPropertyInfoHelper.cs            | 46 +++++++++++++++++--
 .../CompiledBindingExtensionTests.cs          | 31 +++++++++++++
 2 files changed, 74 insertions(+), 3 deletions(-)

diff --git a/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlClrPropertyInfoHelper.cs b/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlClrPropertyInfoHelper.cs
index fb7b017956..da27d4a59b 100644
--- a/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlClrPropertyInfoHelper.cs
+++ b/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/XamlIlClrPropertyInfoHelper.cs
@@ -15,12 +15,41 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
 
         private Dictionary<string, List<(IXamlProperty prop, IXamlMethod get)>> _fields
             = new Dictionary<string, List<(IXamlProperty prop, IXamlMethod get)>>();
-        
+
+        private IXamlField? _boxedTrue;
+        private IXamlField? _boxedFalse;
+
         public XamlIlClrPropertyInfoEmitter(IXamlTypeBuilder<IXamlILEmitter> builder)
         {
             _builder = builder;
         }
 
+        /// <summary>
+        /// Defines two cached boxed booleans on the generated per-assembly helper type, shared by
+        /// all bool property getters in the assembly, so they don't allocate on every read (#21065).
+        /// </summary>
+        private IXamlField GetBooleanBoxField(bool value, XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context)
+        {
+            if (_boxedTrue is null || _boxedFalse is null)
+            {
+                var wellKnownTypes = context.Configuration.WellKnownTypes;
+                _boxedTrue = _builder.DefineField(wellKnownTypes.Object, "BooleanBox!True", XamlVisibility.Private, true);
+                _boxedFalse = _builder.DefineField(wellKnownTypes.Object, "BooleanBox!False", XamlVisibility.Private, true);
+
+                var cctor = _builder.DefineConstructor(true);
+                cctor.Generator
+                    .Ldc_I4(1)
+                    .Box(wellKnownTypes.Boolean)
+                    .Stsfld(_boxedTrue)
+                    .Ldc_I4(0)
+                    .Box(wellKnownTypes.Boolean)
+                    .Stsfld(_boxedFalse)
+                    .Ret();
+            }
+
+            return value ? _boxedTrue : _boxedFalse;
+        }
+
         static string GetKey(IXamlProperty property, string? indexerArgumentsKey)
         {
             var declaringType = (property.Getter ?? property.Setter)?.DeclaringType
@@ -93,8 +122,19 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                     Load(property.Getter!, getter.Generator, !property.Getter!.IsStatic);
                     
                     getter.Generator.EmitCall(property.Getter);
-                    if (property.Getter.ReturnType.IsValueType)
-                        getter.Generator.Box(property.Getter.ReturnType);
+                    var returnType = property.Getter.ReturnType;
+                    if (returnType.Equals(context.Configuration.WellKnownTypes.Boolean))
+                    {
+                        var whenTrue = getter.Generator.DefineLabel();
+                        getter.Generator
+                            .Brtrue(whenTrue)
+                            .Ldsfld(GetBooleanBoxField(false, context))
+                            .Ret()
+                            .MarkLabel(whenTrue)
+                            .Ldsfld(GetBooleanBoxField(true, context));
+                    }
+                    else if (returnType.IsValueType)
+                        getter.Generator.Box(returnType);
                     getter.Generator.Ret();
                 }
 
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs
index fcba9a50b9..16e4dc6623 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs
@@ -1284,6 +1284,37 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions
             }
         }
 
+        [Fact]
+        public void BoolPropertyGetterUsesCachedBoxes()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+        xmlns:local='clr-namespace:Avalonia.Markup.Xaml.UnitTests.MarkupExtensions;assembly=Avalonia.Markup.Xaml.UnitTests'
+        x:DataType='local:TestDataContext'>
+    <TextBlock Tag='{CompiledBinding BoolProperty}' Name='textBlock' />
+</Window>";
+                var window = (Window)AvaloniaRuntimeXamlLoader.Load(xaml);
+                var textBlock = window.GetControl<TextBlock>("textBlock");
+
+                window.DataContext = new TestDataContext { BoolProperty = true };
+                var boxedTrue = textBlock.Tag;
+                window.DataContext = new TestDataContext { BoolProperty = false };
+                var boxedFalse = textBlock.Tag;
+
+                Assert.Equal(true, boxedTrue);
+                Assert.Equal(false, boxedFalse);
+
+                // The getter must return the cached boxes instead of allocating a new box per read.
+                window.DataContext = new TestDataContext { BoolProperty = true };
+                Assert.Same(boxedTrue, textBlock.Tag);
+                window.DataContext = new TestDataContext { BoolProperty = false };
+                Assert.Same(boxedFalse, textBlock.Tag);
+            }
+        }
+
         [Fact]
         public void ThrowsOnInvalidBindingPathOnCompiledBindingEnabledViaDirective()
         {

From 11c542726898ae954a1ef668c65ec79ec92ab17d Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Thu, 13 Aug 2026 07:39:10 +0000
Subject: [PATCH 161/196] Fix tooltip flickering (#21965)

* Add failing tooltip tests

* Fix tooltip flickering

* X11: generate raw pointer move on enter

* Tooltip: handle LeaveWindow before Move
---
 src/Avalonia.Controls/ToolTipService.cs       |  94 ++++++++++++--
 src/Avalonia.X11/X11Window.cs                 |  10 ++
 src/Avalonia.X11/XI2Manager.cs                |  40 ++++--
 .../ToolTipTests.cs                           | 121 +++++++++++++++---
 4 files changed, 218 insertions(+), 47 deletions(-)

diff --git a/src/Avalonia.Controls/ToolTipService.cs b/src/Avalonia.Controls/ToolTipService.cs
index 6f95e69af8..75ca3aef23 100644
--- a/src/Avalonia.Controls/ToolTipService.cs
+++ b/src/Avalonia.Controls/ToolTipService.cs
@@ -14,10 +14,11 @@ namespace Avalonia.Controls
         private readonly IDisposable _subscriptions;
 
         private Control? _tipControl;
+        private bool _pointerOverTip;
+        private bool _pointerOverOwner;
+        private int _pendingCloseId;
         private long _lastTipCloseTime;
         private DispatcherTimer? _timer;
-        private ulong _lastTipEventTime;
-        private ulong _lastWindowEventTime;
 
         public ToolTipService(IInputManager inputManager)
         {
@@ -30,6 +31,7 @@ namespace Avalonia.Controls
         public void Dispose()
         {
             StopTimer();
+            CancelPendingClose();
             _subscriptions.Dispose();
         }
 
@@ -37,15 +39,35 @@ namespace Avalonia.Controls
         {
             if (e is RawPointerEventArgs pointerEvent)
             {
-                bool isTooltipEvent = false;
-                if (_tipControl?.GetValue(ToolTip.ToolTipProperty) is { } currentTip && e.Root == (currentTip.PopupHost as Visual)?.GetInputRoot())
-                {
-                    isTooltipEvent = true;
-                    _lastTipEventTime = pointerEvent.Timestamp;
-                }
-                else if (e.Root.RootElement == _tipControl?.VisualRoot)
+                var currentTip = _tipControl?.GetValue(ToolTip.ToolTipProperty);
+
+                // The input root of the tip itself, for popup windows only, not overlays.
+                var tipPopupInputRoot = (currentTip?.PopupHost as Visual)?.GetInputRoot() is { } root &&
+                                   root.RootElement != _tipControl?.VisualRoot ?
+                    root :
+                    null;
+
+                var isTipEvent = tipPopupInputRoot is not null && e.Root == tipPopupInputRoot;
+                var isTipOwnerWindowEvent = e.Root.RootElement == _tipControl?.VisualRoot;
+
+                if (isTipEvent || isTipOwnerWindowEvent)
                 {
-                    _lastWindowEventTime = pointerEvent.Timestamp;
+                    // The pointer is on one of the two windows (tip or owner) involved: remember which one, and cancel any
+                    // close scheduled by a previous LeaveWindow on the other one.
+                    if (pointerEvent.Type != RawPointerEventType.LeaveWindow)
+                    {
+                        _pointerOverTip = isTipEvent;
+                        _pointerOverOwner = isTipOwnerWindowEvent;
+                        CancelPendingClose();
+                    }
+                    else if (isTipEvent)
+                    {
+                        _pointerOverTip = false;
+                    }
+                    else
+                    {
+                        _pointerOverOwner = false;
+                    }
                 }
 
                 switch (pointerEvent.Type)
@@ -53,10 +75,24 @@ namespace Avalonia.Controls
                     case RawPointerEventType.Move:
                         Update(pointerEvent.Root, pointerEvent.InputHitTestResult.element as Visual);
                         break;
-                    case RawPointerEventType.LeaveWindow when (e.Root.RootElement == _tipControl?.VisualRoot && _lastTipEventTime != e.Timestamp) || (isTooltipEvent && _lastWindowEventTime != e.Timestamp):
-                        ClearTip();
-                        _tipControl = null;
+
+                    case RawPointerEventType.LeaveWindow:
+                        if ((isTipEvent && !_pointerOverOwner) || (isTipOwnerWindowEvent && !_pointerOverTip))
+                        {
+                            if (tipPopupInputRoot is not null)
+                            {
+                                // The pointer is leaving one of the two windows, but there's a chance it's going to
+                                // the other one. Schedule a close and cancel it if we receive another event.
+                                SchedulePendingClose();
+                            }
+                            else
+                            {
+                                CloseCurrentTip();
+                            }
+                        }
+
                         break;
+
                     case RawPointerEventType.LeftButtonDown:
                     case RawPointerEventType.RightButtonDown:
                     case RawPointerEventType.MiddleButtonDown:
@@ -70,6 +106,7 @@ namespace Avalonia.Controls
                 {
                     StopTimer();
                     _tipControl?.ClearValue(ToolTip.IsOpenProperty);
+                    _pointerOverTip = false;
                 }
             }
         }
@@ -78,7 +115,7 @@ namespace Avalonia.Controls
         {
             var currentToolTip = _tipControl?.GetValue(ToolTip.ToolTipProperty);
 
-            if (root == currentToolTip?.PopupHost?.HostedVisualTreeRoot)
+            if (root == currentToolTip?.PopupHost?.HostedVisualTreeRoot?.GetInputRoot())
             {
                 // Don't update while the pointer is over a tooltip
                 return;
@@ -110,6 +147,35 @@ namespace Avalonia.Controls
 
             OnTipControlChanged(_tipControl, newControl);
             _tipControl = newControl;
+            _pointerOverTip = false;
+            _pointerOverOwner = false;
+        }
+
+        private void SchedulePendingClose()
+        {
+            var control = _tipControl;
+            var closeId = ++_pendingCloseId;
+
+            // Post below input priority: any pointer event is processed before this callback and gets a chance to cancel it.
+            Dispatcher.UIThread.Post(
+                () =>
+                {
+                    if (_pendingCloseId == closeId && _tipControl == control)
+                        CloseCurrentTip();
+                },
+                DispatcherPriority.Background);
+        }
+
+        private void CancelPendingClose()
+            => ++_pendingCloseId;
+
+        private void CloseCurrentTip()
+        {
+            StopTimer();
+            _tipControl?.ClearValue(ToolTip.IsOpenProperty);
+            _tipControl = null;
+            _pointerOverTip = false;
+            _pointerOverOwner = false;
         }
 
         private void ServiceEnabledChanged(AvaloniaPropertyChangedEventArgs<bool> args)
diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index 5337e99a4e..0ae2880499 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -596,6 +596,16 @@ namespace Avalonia.X11
                 MouseEvent(RawPointerEventType.Move, ref ev, ev.MotionEvent.state);
             else if (ev.type == XEventName.LeaveNotify)
                 MouseEvent(RawPointerEventType.LeaveWindow, ref ev, ev.CrossingEvent.state);
+            else if (ev.type == XEventName.EnterNotify)
+            {
+                if (ev.CrossingEvent.detail is
+                    NotifyDetail.NotifyNonlinear or
+                    NotifyDetail.NotifyNonlinearVirtual or
+                    NotifyDetail.NotifyVirtual)
+                {
+                    MouseEvent(RawPointerEventType.Move, ref ev, ev.CrossingEvent.state);
+                }
+            }
             else if (ev.type == XEventName.PropertyNotify)
             {
                 OnPropertyChange(ev.PropertyEvent.atom, ev.PropertyEvent.state == 0);
diff --git a/src/Avalonia.X11/XI2Manager.cs b/src/Avalonia.X11/XI2Manager.cs
index 7b74f63501..5751ee2c51 100644
--- a/src/Avalonia.X11/XI2Manager.cs
+++ b/src/Avalonia.X11/XI2Manager.cs
@@ -293,24 +293,36 @@ namespace Avalonia.X11
 
         private void OnEnterLeaveEvent(IXI2Client client, ref XIEnterLeaveEvent ev)
         {
+            var detail = ev.detail;
+            if (detail != XiEnterLeaveDetail.XINotifyNonlinearVirtual &&
+                detail != XiEnterLeaveDetail.XINotifyNonlinear &&
+                detail != XiEnterLeaveDetail.XINotifyVirtual)
+                return;
+
+            var buttons = ParsedDeviceEvent.ParseButtonState(ev.buttons.MaskLen, ev.buttons.Mask);
+            if (buttons != default)
+                return;
+
             if (ev.evtype == XiEventType.XI_Leave)
             {
-                var buttons = ParsedDeviceEvent.ParseButtonState(ev.buttons.MaskLen, ev.buttons.Mask);
-                var detail = ev.detail;
-                if ((detail == XiEnterLeaveDetail.XINotifyNonlinearVirtual ||
-                     detail == XiEnterLeaveDetail.XINotifyNonlinear ||
-                     detail == XiEnterLeaveDetail.XINotifyVirtual)
-                    && buttons == default)
+                foreach (var scroller in _pointerDevice.Scrollers)
                 {
-                    foreach (var scroller in _pointerDevice.Scrollers)
-                    {
-                        _pointerDevice.Valuators[scroller.Number].Value = 0;
-                    }
-
-                    client.ScheduleXI2Input(new RawPointerEventArgs(client.MouseDevice, (ulong)ev.time.ToInt64(),
-                        client.InputRoot,
-                        RawPointerEventType.LeaveWindow, new Point(ev.event_x, ev.event_y), buttons));
+                    _pointerDevice.Valuators[scroller.Number].Value = 0;
                 }
+
+                client.ScheduleXI2Input(new RawPointerEventArgs(client.MouseDevice, (ulong)ev.time.ToInt64(),
+                    client.InputRoot,
+                    RawPointerEventType.LeaveWindow, new Point(ev.event_x, ev.event_y), buttons));
+            }
+            else if (ev.evtype == XiEventType.XI_Enter)
+            {
+                client.ScheduleXI2Input(new RawPointerEventArgs(
+                    client.MouseDevice,
+                    (ulong)ev.time.ToInt64(),
+                    client.InputRoot,
+                    RawPointerEventType.Move,
+                    new Point(ev.event_x, ev.event_y),
+                    ((XModifierMask)ev.mods.Effective).ToRawInputModifiers()));
             }
         }
 
diff --git a/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs b/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs
index 059ffdbca4..8047bb3b3e 100644
--- a/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ToolTipTests.cs
@@ -28,6 +28,54 @@ namespace Avalonia.Controls.UnitTests
             Assert.IsType<PopupRoot>(toolTip.PopupHost);
             Assert.Same(TopLevel.GetTopLevel(toolTip), toolTip.PopupHost);
         }
+
+        [Fact]
+        public void Should_Not_Close_When_Pointer_Is_Over_ToolTip_Window_Without_Hit_Test_Result()
+        {
+            using var app = UnitTestApplication.Start(ConfigureServices(TestServices.FocusableWindow));
+
+            var target = new Decorator
+            {
+                [ToolTip.TipProperty] = "Tip",
+                [ToolTip.ShowDelayProperty] = 0
+            };
+
+            var scope = SetupWindow(target);
+
+            scope.MouseEnter(target);
+            AssertToolTipOpen(target);
+
+            var toolTip = Assert.IsType<ToolTip>(target.GetValue(ToolTip.ToolTipProperty));
+            var toolTipRoot = Assert.IsType<PopupRoot>(toolTip.PopupHost).GetInputRoot();
+            Assert.NotNull(toolTipRoot);
+
+            scope.SendRawPointerEvent(RawPointerEventType.Move, toolTipRoot, scope.GetPointerPosition(null));
+
+            AssertToolTipOpen(target);
+        }
+
+        [Fact]
+        public void Should_Not_Close_When_Leaving_Window_Right_After_ToolTip_Opened_Under_Pointer()
+        {
+            using var app = UnitTestApplication.Start(ConfigureServices(TestServices.FocusableWindow));
+
+            var target = new Decorator
+            {
+                [ToolTip.TipProperty] = "Tip",
+                [ToolTip.ShowDelayProperty] = 0
+            };
+
+            var scope = SetupWindow(target);
+
+            scope.MouseEnter(target);
+            AssertToolTipOpen(target);
+
+            // The pointer is still over the adorned control: this leave event is only caused by the tooltip window
+            // being displayed on top of it (macOS case).
+            scope.SendRawPointerEvent(RawPointerEventType.LeaveWindow, scope.Window.InputRoot, scope.GetPointerPosition(target));
+
+            AssertToolTipOpen(target);
+        }
     }
 
     public class ToolTipTests_Overlay : ToolTipTests, IDisposable
@@ -74,7 +122,7 @@ namespace Avalonia.Controls.UnitTests
 
         protected abstract void VerifyToolTipType(Control control);
 
-        private void AssertToolTipOpen(Control control)
+        protected void AssertToolTipOpen(Control control)
         {
             Assert.True(ToolTip.GetIsOpen(control));
             VerifyToolTipType(control);
@@ -505,7 +553,7 @@ namespace Avalonia.Controls.UnitTests
             target[ToolTip.TipProperty] = null;
 
             Assert.False(ToolTip.GetIsOpen(target));
-		}
+        }
 
         [Fact]
         public void Should_Close_When_Pointer_Leaves_Window()
@@ -527,11 +575,13 @@ namespace Avalonia.Controls.UnitTests
                 topLevel!.PlatformImpl!.Input!(new RawPointerEventArgs(s_mouseDevice, (ulong)DateTime.Now.Ticks, topLevel.InputRoot,
                     RawPointerEventType.LeaveWindow, default(RawPointerPoint), RawInputModifiers.None));
 
+                Dispatcher.UIThread.RunJobs(null, TestContext.Current.CancellationToken);
+
                 Assert.False(ToolTip.GetIsOpen(target));
             }
         }
 
-        private Action<Control?> SetupWindowAndGetMouseEnterAction(Control windowContent, [CallerMemberName] string? testName = null)
+        protected ToolTipTestScope SetupWindow(Control windowContent, [CallerMemberName] string? testName = null)
         {
             var windowImpl = MockWindowingPlatform.CreateWindowMock();
             SetupWindowMock(windowImpl);
@@ -554,10 +604,31 @@ namespace Avalonia.Controls.UnitTests
             Assert.True(windowContent.IsMeasureValid);
             Assert.True(windowContent.IsVisible);
 
-            var controlIds = new Dictionary<Control, int>();
-            IInputRoot? lastRoot = null;
+            return new ToolTipTestScope(
+                window,
+                windowImpl,
+                (point, control) => hitTesterMock
+                    .Setup(m => m.HitTestFirst(point, It.IsAny<Visual>(), It.IsAny<Func<Visual, bool>>()))
+                    .Returns(control));
+        }
 
-            return control =>
+        private Action<Control?> SetupWindowAndGetMouseEnterAction(Control windowContent, [CallerMemberName] string? testName = null)
+            => SetupWindow(windowContent, testName).MouseEnter;
+
+        private void SetupWindowAndActivateToolTip(Control windowContent, Control? targetOverride = null, [CallerMemberName] string? testName = null)
+            => SetupWindowAndGetMouseEnterAction(windowContent, testName)(targetOverride ?? windowContent);
+
+        protected sealed class ToolTipTestScope(Window window, Mock<IWindowImpl> windowImpl, Action<Point, Control?> setupHitTest)
+        {
+            private readonly Dictionary<Control, int> _controlIds = new();
+            private IInputRoot? _lastRoot;
+
+            public Window Window { get; } = window;
+
+            /// <summary>
+            /// Returns a pointer position which hit tests to <paramref name="control"/>, or to nothing when it's null.
+            /// </summary>
+            public Point GetPointerPosition(Control? control)
             {
                 Point point;
 
@@ -567,36 +638,48 @@ namespace Avalonia.Controls.UnitTests
                 }
                 else
                 {
-                    if (!controlIds.TryGetValue(control, out int id))
+                    if (!_controlIds.TryGetValue(control, out int id))
                     {
-                        id = controlIds[control] = controlIds.Count;
+                        id = _controlIds[control] = _controlIds.Count;
                     }
                     point = new Point(id, int.MaxValue);
                 }
 
-                hitTesterMock.Setup(m => m.HitTestFirst(point, It.IsAny<Visual>(), It.IsAny<Func<Visual, bool>>()))
-                    .Returns(control);
+                setupHitTest(point, control);
+
+                return point;
+            }
 
-                var root = control?.GetInputRoot() ?? window.InputRoot;
+            /// <summary>
+            /// Moves the pointer over <paramref name="control"/>, leaving the previous root if it changed.
+            /// </summary>
+            public void MouseEnter(Control? control)
+            {
+                var point = GetPointerPosition(control);
+                var root = control?.GetInputRoot() ?? Window.InputRoot;
                 var timestamp = (ulong)DateTime.Now.Ticks;
 
                 windowImpl.Object.Input!(new RawPointerEventArgs(s_mouseDevice, timestamp, root,
                         RawPointerEventType.Move, point, RawInputModifiers.None));
 
-                if (lastRoot != null && lastRoot != root)
+                if (_lastRoot != null && _lastRoot != root)
                 {
-                    ((PresentationSource)lastRoot)?.PlatformImpl?.Input?.Invoke(new RawPointerEventArgs(s_mouseDevice, timestamp,
-                        lastRoot, RawPointerEventType.LeaveWindow, new Point(-1,-1), RawInputModifiers.None));
+                    ((PresentationSource)_lastRoot)?.PlatformImpl?.Input?.Invoke(new RawPointerEventArgs(s_mouseDevice, timestamp,
+                        _lastRoot, RawPointerEventType.LeaveWindow, new Point(-1,-1), RawInputModifiers.None));
                 }
 
-                lastRoot = root;
+                _lastRoot = root;
 
                 Assert.True(control == null || control.IsPointerOver);
-            };
-        }
+            }
 
-        private void SetupWindowAndActivateToolTip(Control windowContent, Control? targetOverride = null, [CallerMemberName] string? testName = null) =>
-            SetupWindowAndGetMouseEnterAction(windowContent, testName)(targetOverride ?? windowContent);
+            /// <summary>
+            /// Sends a raw pointer event, as a platform backend would do.
+            /// </summary>
+            public void SendRawPointerEvent(RawPointerEventType type, IInputRoot root, Point position)
+                => windowImpl.Object.Input!(new RawPointerEventArgs(
+                    s_mouseDevice, (ulong)DateTime.Now.Ticks, root, type, position, RawInputModifiers.None));
+        }
     }
 
     internal class ToolTipViewModel

From 77c9c25ef38d67281702fb2067d3a982dc859fdc Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Thu, 13 Aug 2026 11:45:48 +0000
Subject: [PATCH 162/196] Fix Nuke build warnings (#21967)

* Fix Nuke build warnings

* Remove PublishProfile from WinUI projects
---
 Directory.Packages.props                                 | 6 ++----
 nukebuild/ApiDiffHelper.cs                               | 6 +++++-
 nukebuild/_build.csproj                                  | 3 +--
 samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj | 1 -
 samples/WinUIEmbedSample/WinUIEmbedSample.csproj         | 1 -
 5 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 941451d635..d38cb33b28 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -2,7 +2,6 @@
   <PropertyGroup>
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
   </PropertyGroup>
-
   <ItemGroup>
     <PackageVersion Include="Appium.WebDriver" Version="5.2.0" />
     <PackageVersion Include="Avalonia.Angle.Windows.Natives" Version="2.1.27548.20260419" />
@@ -37,7 +36,7 @@
     <PackageVersion Include="MonoMac.NetStandard" Version="0.0.4" />
     <PackageVersion Include="Moq" Version="4.20.72" />
     <PackageVersion Include="Nito.AsyncEx.Context" Version="5.1.2" />
-    <PackageVersion Include="NuGet.Protocol" Version="7.0.1" />
+    <PackageVersion Include="NuGet.Protocol" Version="7.9.0" />
     <PackageVersion Include="Nuke.Common" Version="10.1.0" />
     <PackageVersion Include="Numerge" Version="1.0.0" />
     <PackageVersion Include="NUnit" Version="4.5.1" />
@@ -76,8 +75,7 @@
     <PackageVersion Include="xunit.v3.extensibility.core" Version="3.2.2" />
     <PackageVersion Include="xunit.v3.mtp-v2" Version="3.2.2" />
   </ItemGroup>
-
   <ItemGroup>
     <GlobalPackageReference Include="Microsoft.VisualStudio.SlnGen" Version="8.5.17" PrivateAssets="all" />
   </ItemGroup>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/nukebuild/ApiDiffHelper.cs b/nukebuild/ApiDiffHelper.cs
index d16495969e..8325ca41f4 100644
--- a/nukebuild/ApiDiffHelper.cs
+++ b/nukebuild/ApiDiffHelper.cs
@@ -399,7 +399,11 @@ public static class ApiDiffHelper
     {
         var packageSource = new PackageSource(NightlyFeedUri) { ProtocolVersion = 3 };
         var repository = Repository.Factory.GetCoreV3(packageSource);
-        var findPackageByIdResource = await repository.GetResourceAsync<FindPackageByIdResource>();
+
+        var findPackageByIdResource =
+            await repository.GetResourceAsync<FindPackageByIdResource>() ??
+            throw new InvalidOperationException($"{nameof(FindPackageByIdResource)} not found on {packageSource}");
+
         return new NuGetDownloadContext(packageSource, findPackageByIdResource);
     }
 
diff --git a/nukebuild/_build.csproj b/nukebuild/_build.csproj
index bf31a5f9a2..045f652291 100644
--- a/nukebuild/_build.csproj
+++ b/nukebuild/_build.csproj
@@ -13,10 +13,9 @@
   <ItemGroup>
     <PackageReference Include="Nuke.Common" />
     <PackageReference Include="Numerge" />
-    <!-- Keep in sync with Avalonia.Build.Tasks -->
     <PackageReference Include="Mono.Cecil" />
-    <PackageReference Include="Microsoft.Build.Framework" PrivateAssets="All" />
     <PackageReference Include="NuGet.Protocol" />
+    <PackageReference Include="System.Security.Cryptography.Xml" VersionOverride="10.0.11" /> <!-- Local override to avoid security warnings --> 
     <PackageDownload Include="Microsoft.DotNet.ApiCompat.Tool" Version="[10.0.100]" />
     <PackageDownload Include="Microsoft.DotNet.ApiDiff.Tool" Version="[10.0.100-rtm.25531.102]" />
     <PackageDownload Include="dotnet-ilrepack" Version="[2.0.44]" />
diff --git a/samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj b/samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj
index c500a2368a..49c2e6b8c3 100644
--- a/samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj
+++ b/samples/ControlGallery.WinUI/ControlGallery.WinUI.csproj
@@ -7,7 +7,6 @@
     <ApplicationManifest>app.manifest</ApplicationManifest>
     <Platforms>x86;x64;ARM64</Platforms>
     <RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
-    <PublishProfile>win-$(Platform).pubxml</PublishProfile>
     <UseWinUI>true</UseWinUI>
     <WinUISDKReferences>false</WinUISDKReferences>
     <EnableMsixTooling>true</EnableMsixTooling>
diff --git a/samples/WinUIEmbedSample/WinUIEmbedSample.csproj b/samples/WinUIEmbedSample/WinUIEmbedSample.csproj
index 8a47a7860c..3c7a711cbf 100644
--- a/samples/WinUIEmbedSample/WinUIEmbedSample.csproj
+++ b/samples/WinUIEmbedSample/WinUIEmbedSample.csproj
@@ -7,7 +7,6 @@
     <ApplicationManifest>app.manifest</ApplicationManifest>
     <Platforms>x86;x64;ARM64</Platforms>
     <RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
-    <PublishProfile>win-$(Platform).pubxml</PublishProfile>
     <UseWinUI>true</UseWinUI>
     <WinUISDKReferences>false</WinUISDKReferences>
     <EnableMsixTooling>true</EnableMsixTooling>

From fa122d77358796a080772ea39d4b93efa3d2dff4 Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Thu, 13 Aug 2026 13:40:00 +0000
Subject: [PATCH 163/196] Implement visual geometry hit testing (#21768)

* Implement visual geometry hit testing

* fix xml comment

* fix xml comment

* update api diff

* Introduced ICompositionHitTester to avoid duplicated hit test code between point and geometry

* Add geometry hit testing page to RenderDemo

* fix geometry hit testing not including stroke

* fix test

* update api and tests

* update api diff

* Update GeometryHitTestingPage with new API

* addressed reviews.

* remove nullability in GeometryHitTestResult Visual hit

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 api/Avalonia.nupkg.xml                        |  24 +
 samples/RenderDemo/MainWindow.xaml            |   3 +
 .../Pages/GeometryHitTestingPage.axaml        |  77 ++
 .../Pages/GeometryHitTestingPage.axaml.cs     | 109 ++
 samples/RenderDemo/Pages/HitTestingPage.cs    |  93 +-
 src/Avalonia.Base/Input/InputExtensions.cs    |  62 +-
 src/Avalonia.Base/Media/Geometry.cs           |  12 +-
 .../Media/GeometryHitTestResult.cs            |   9 +
 src/Avalonia.Base/Media/IntersectionResult.cs |  33 +
 src/Avalonia.Base/Platform/IGeometryImpl.cs   |   7 +
 src/Avalonia.Base/Platform/LtrbRect.cs        |   2 +-
 .../Composition/CompositingRenderer.cs        |  41 +-
 .../Composition/CompositionDrawListVisual.cs  |  14 +
 .../Composition/CompositionTarget.cs          | 109 +-
 .../Rendering/Composition/ContainerVisual.cs  |  20 +-
 .../Drawing/CompositionRenderData.cs          |   3 +
 .../Drawing/RenderDataStream.HitTest.cs       | 215 +++-
 .../CompositionHitTestAabbTree.cs             |  33 +-
 .../GeometryCompositionHitTester.cs           |  33 +
 .../HitTesting/ICompositionHitTester.cs       |  17 +
 .../HitTesting/PointCompositionHitTester.cs   |  22 +
 .../Rendering/Composition/Visual.cs           |   4 +-
 src/Avalonia.Base/Rendering/ICustomHitTest.cs |  18 +-
 src/Avalonia.Base/Rendering/IRenderer.cs      |  24 +
 .../SceneGraph/CustomDrawOperation.cs         |  16 +-
 .../VisualTree/VisualExtensions.cs            |  81 +-
 .../HeadlessPlatformRenderInterface.cs        | 171 +++-
 src/Skia/Avalonia.Skia/GeometryImpl.cs        |  23 +-
 .../Rendering/CompositorHitTestingTests.cs    | 933 +++++++++++++++++-
 .../Rendering/CustomHitTestBorder.cs          |   6 +
 .../SceneGraph/DrawOperationTests.cs          |   2 +-
 .../VisualExtensions_GetVisualsAt.cs          |  38 +
 tests/Avalonia.RenderTests/TestRenderRoot.cs  |   8 +-
 .../CompositorTestServices.cs                 |  15 +
 tests/Avalonia.UnitTests/TestRoot.cs          |   7 +-
 35 files changed, 2116 insertions(+), 168 deletions(-)
 create mode 100644 samples/RenderDemo/Pages/GeometryHitTestingPage.axaml
 create mode 100644 samples/RenderDemo/Pages/GeometryHitTestingPage.axaml.cs
 create mode 100644 src/Avalonia.Base/Media/GeometryHitTestResult.cs
 create mode 100644 src/Avalonia.Base/Media/IntersectionResult.cs
 rename src/Avalonia.Base/Rendering/Composition/{ => HitTesting}/CompositionHitTestAabbTree.cs (95%)
 create mode 100644 src/Avalonia.Base/Rendering/Composition/HitTesting/GeometryCompositionHitTester.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/HitTesting/ICompositionHitTester.cs
 create mode 100644 src/Avalonia.Base/Rendering/Composition/HitTesting/PointCompositionHitTester.cs

diff --git a/api/Avalonia.nupkg.xml b/api/Avalonia.nupkg.xml
index cf7ef0deca..5c720c9413 100644
--- a/api/Avalonia.nupkg.xml
+++ b/api/Avalonia.nupkg.xml
@@ -151,6 +151,18 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.IGeometryImpl.FillContains(Avalonia.Platform.IGeometryImpl)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.IGeometryImpl.GetFillIntersectionResult(Avalonia.Platform.IGeometryImpl)</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Platform.Storage.IStorageProvider.OpenFilePickerWithResultAsync(Avalonia.Platform.Storage.FilePickerOpenOptions)</Target>
@@ -187,6 +199,18 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.IGeometryImpl.FillContains(Avalonia.Platform.IGeometryImpl)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>M:Avalonia.Platform.IGeometryImpl.GetFillIntersectionResult(Avalonia.Platform.IGeometryImpl)</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Platform.Storage.IStorageProvider.OpenFilePickerWithResultAsync(Avalonia.Platform.Storage.FilePickerOpenOptions)</Target>
diff --git a/samples/RenderDemo/MainWindow.xaml b/samples/RenderDemo/MainWindow.xaml
index aedd9f95cf..e463578709 100644
--- a/samples/RenderDemo/MainWindow.xaml
+++ b/samples/RenderDemo/MainWindow.xaml
@@ -72,6 +72,9 @@
     <TabItem Header="Hit Testing">
       <pages:HitTestingPage />
     </TabItem>
+    <TabItem Header="Geometry Hit Testing">
+      <pages:GeometryHitTestingPage />
+    </TabItem>
     <TabItem Header="SkCanvas">
       <pages:CustomSkiaPage />
     </TabItem>
diff --git a/samples/RenderDemo/Pages/GeometryHitTestingPage.axaml b/samples/RenderDemo/Pages/GeometryHitTestingPage.axaml
new file mode 100644
index 0000000000..f5c7c2cf23
--- /dev/null
+++ b/samples/RenderDemo/Pages/GeometryHitTestingPage.axaml
@@ -0,0 +1,77 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+             x:Class="RenderDemo.Pages.GeometryHitTestingPage">
+  <DockPanel>
+
+    <StackPanel DockPanel.Dock="Top"
+                Margin="16"
+                Spacing="4">
+      <TextBlock x:Name="Status" />
+      <StackPanel Orientation="Horizontal"
+                  Spacing="8">
+        <TextBlock Text="Stroke thickness:"
+                   VerticalAlignment="Center" />
+        <Slider x:Name="StrokeThickness"
+                Width="240"
+                Minimum="1"
+                Maximum="40"
+                Value="12"
+                TickFrequency="1"
+                IsSnapToTickEnabled="True" />
+        <TextBlock Text="{Binding #StrokeThickness.Value}"
+                   VerticalAlignment="Center" />
+      </StackPanel>
+    </StackPanel>
+
+    <Grid x:Name="Scene"
+          Background="Transparent"
+          Cursor="None">
+      <Ellipse x:Name="Ellipse"
+               Margin="80,50,0,0"
+               HorizontalAlignment="Left"
+               VerticalAlignment="Top"
+               Width="180"
+               Height="120"
+               Fill="#3B82F6"
+               Stroke="#1E3A8A"
+               StrokeThickness="{Binding #StrokeThickness.Value}" />
+
+      <Rectangle x:Name="Rectangle"
+                 Margin="0,60,50,0"
+                 HorizontalAlignment="Right"
+                 VerticalAlignment="Top"
+                 Width="180"
+                 Height="120"
+                 RadiusX="12"
+                 RadiusY="12"
+                 Fill="#22C55E"
+                 Stroke="#14532D"
+                 StrokeThickness="{Binding #StrokeThickness.Value}" />
+
+      <Path x:Name="Star"
+            Margin="0,0,50,50"
+            HorizontalAlignment="Right"
+            VerticalAlignment="Bottom"
+            Width="180"
+            Height="180"
+            Stretch="Uniform"
+            Data="M 50,0 L 61,35 L 98,35 L 68,57 L 79,91 L 50,70 L 21,91 L 32,57 L 2,35 L 39,35 Z"
+            Fill="#F43F5E"
+            Stroke="#7F1D1D"
+            StrokeThickness="{Binding #StrokeThickness.Value}" />
+
+      <Path x:Name="Probe"
+            Stretch="None"
+            IsVisible="False"
+            IsHitTestVisible="False"
+            Fill="#66FACC15"
+            Stroke="#CA8A04"
+            StrokeThickness="3" />
+    </Grid>
+  </DockPanel>
+
+</UserControl>
+
diff --git a/samples/RenderDemo/Pages/GeometryHitTestingPage.axaml.cs b/samples/RenderDemo/Pages/GeometryHitTestingPage.axaml.cs
new file mode 100644
index 0000000000..854a5957a4
--- /dev/null
+++ b/samples/RenderDemo/Pages/GeometryHitTestingPage.axaml.cs
@@ -0,0 +1,109 @@
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
+using Avalonia.Input;
+using Avalonia.Markup.Xaml;
+using Avalonia.Media;
+
+namespace RenderDemo.Pages;
+
+public class GeometryHitTestingPage : UserControl
+{
+    private readonly IBrush _hitStroke = Brushes.Yellow;
+    private readonly TranslateTransform _probePosition = new();
+    private readonly Dictionary<Shape, IBrush?> _strokes = new();
+    private readonly List<(Shape Shape, IntersectionResult Intersection)> _hits = new();
+    private readonly Geometry _probeGeometry;
+    private readonly Panel _scene;
+    private readonly Path _probe;
+    private readonly TextBlock _status;
+
+    public GeometryHitTestingPage()
+    {
+        InitializeComponent();
+
+        _scene = this.Get<Panel>("Scene");
+        _probe = this.Get<Path>("Probe");
+        _status = this.Get<TextBlock>("Status");
+
+        _probeGeometry = CreateProbeGeometry();
+        _probeGeometry.Transform = _probePosition;
+        _probe.Data = _probeGeometry;
+
+        foreach (var shape in _scene.Children.OfType<Shape>())
+        {
+            if (shape != _probe)
+                _strokes.Add(shape, shape.Stroke);
+        }
+
+        _scene.PointerEntered += SceneOnPointerMoved;
+        _scene.PointerMoved += SceneOnPointerMoved;
+        _scene.PointerExited += SceneOnPointerExited;
+
+        UpdateStatus();
+    }
+
+    private void InitializeComponent()
+    {
+        AvaloniaXamlLoader.Load(this);
+    }
+
+    private Geometry CreateProbeGeometry()
+        => new PolylineGeometry([new(0, -42), new(38, 26), new(-38, 26)], true);
+
+    private void SceneOnPointerMoved(object? sender, PointerEventArgs e)
+    {
+        _probe.IsVisible = true;
+        MoveProbe(e.GetPosition(_scene));
+    }
+
+    private void MoveProbe(Point position)
+    {
+        _probePosition.X = position.X;
+        _probePosition.Y = position.Y;
+
+        ClearHits();
+
+        foreach (var result in _scene.GetInputElementsAt(_probeGeometry))
+        {
+            if (result?.VisualHit is Shape shape && _strokes.ContainsKey(shape))
+            {
+                shape.Stroke = _hitStroke;
+                _hits.Add((shape, result.IntersectionResult));
+            }
+        }
+
+        UpdateStatus();
+    }
+
+    private void SceneOnPointerExited(object? sender, PointerEventArgs e)
+    {
+        _probe.IsVisible = false;
+        ClearHits();
+        UpdateStatus();
+    }
+
+    private void ClearHits()
+    {
+        foreach (var hit in _hits)
+        {
+            hit.Shape.Stroke = _strokes[hit.Shape];
+        }
+
+        _hits.Clear();
+    }
+
+    private void UpdateStatus()
+    {
+        if (_hits.Count == 0)
+        {
+            _status.Text = "No intersection";
+            return;
+        }
+
+        _status.Text = "Intersecting, " + string.Join(", ", _hits.Select(hit => $"{hit.Shape.Name} ({hit.Intersection})"));
+    }
+}
+
diff --git a/samples/RenderDemo/Pages/HitTestingPage.cs b/samples/RenderDemo/Pages/HitTestingPage.cs
index f7b2e454b2..621b4dbf1c 100644
--- a/samples/RenderDemo/Pages/HitTestingPage.cs
+++ b/samples/RenderDemo/Pages/HitTestingPage.cs
@@ -1,10 +1,13 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
 using System.Numerics;
 using Avalonia;
 using Avalonia.Animation;
 using Avalonia.Animation.Easings;
 using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
 using Avalonia.Input;
 using Avalonia.Media;
 using Avalonia.Rendering.Composition;
@@ -15,6 +18,7 @@ namespace RenderDemo.Pages
 {
     public class HitTestingPage : UserControl
     {
+        private const int RegionSize = 80;
         private const int GroupColumns = 8;
         private const int GroupRows = 5;
         private const int CellsPerGroupSide = 10;
@@ -44,6 +48,9 @@ namespace RenderDemo.Pages
         private bool _animationsStarted;
         private Cell? _lastHitCell;
         private Cell? _lastClickedCell;
+        private bool _regionSelection;
+        private Ellipse _region;
+        private List<Cell> _regionHits = new List<Cell>();
 
         public HitTestingPage()
         {
@@ -54,6 +61,9 @@ namespace RenderDemo.Pages
                 Background = Brushes.Transparent
             };
 
+            _scene.PointerMoved += Scene_PointerMoved;
+            _scene.PointerPressed += Scene_PointerPressed;
+
             _stats = new TextBlock
             {
                 HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Center,
@@ -65,6 +75,31 @@ namespace RenderDemo.Pages
                 IsHitTestVisible = false
             };
 
+            var regionSelection = new CheckBox()
+            {
+                Content = "Region Selection"
+            };
+
+            _region = new Ellipse()
+            {
+                Width = RegionSize * 2,
+                Height = RegionSize,
+                Fill = Brushes.Transparent,
+                StrokeThickness = 2,
+                Stroke = Brushes.Green,
+                IsVisible = false,
+                IsHitTestVisible = false
+            };
+
+            regionSelection.IsCheckedChanged += (s, e) =>
+            {
+                _regionSelection = !_regionSelection;
+
+                _region.IsVisible = _regionSelection;
+
+                ClearRegionHighlights();
+            };
+
             var numberOfHitTests = new NumericUpDown
             {
                 Minimum = 0,
@@ -92,7 +127,8 @@ namespace RenderDemo.Pages
                 Children =
                 {
                     new TextBlock { Text = "Hit tests per update:" },
-                    numberOfHitTests
+                    numberOfHitTests,
+                    regionSelection
                 }
             };
 
@@ -119,6 +155,57 @@ namespace RenderDemo.Pages
             ResetState();
         }
 
+        private void ClearRegionHighlights()
+        {
+            _lastClickedCell?.ClearHighlight();
+            _lastClickedCell = null;
+            foreach (var cell in _regionHits)
+            {
+                cell.ClearHighlight();
+            }
+            _regionHits.Clear();
+        }
+
+        private void Scene_PointerPressed(object? sender, PointerPressedEventArgs e)
+        {
+            if(_regionSelection)
+            {
+                var bounds = _region.Bounds;
+
+                ClearRegionHighlights();
+
+                var geometry = new EllipseGeometry(bounds);
+
+                var cells = _scene.GetVisualsAt(geometry);
+
+                if (cells == null)
+                    return;
+
+                foreach (var cell in cells)
+                {
+                    if(cell?.VisualHit is Cell c)
+                    {
+                        c.IsLatestClick = true;
+                        c.UpdateHighlight();
+                        _regionHits.Add(c);
+                    }
+                }
+            }
+        }
+
+        private void Scene_PointerMoved(object? sender, PointerEventArgs e)
+        {
+            if(_regionSelection)
+            {
+                var point = e.GetPosition(_scene);
+
+                var rect = new Rect(point, new Size()).Inflate(new Thickness(_region.Bounds.Width / 2, _region.Bounds.Height / 2));
+
+                Canvas.SetLeft(_region, rect.X);
+                Canvas.SetTop(_region, rect.Y);
+            }
+        }
+
         protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
         {
             base.OnAttachedToVisualTree(e);
@@ -177,6 +264,8 @@ namespace RenderDemo.Pages
                     }
                 }
             }
+
+            _scene.Children.Add(_region);
         }
 
         private void OnCompositionUpdate()
@@ -337,7 +426,7 @@ namespace RenderDemo.Pages
 
         private void OnCellPointerPressed(object? sender, PointerPressedEventArgs e)
         {
-            if (sender is not Cell cell)
+            if (sender is not Cell cell || _regionSelection)
                 return;
 
             SetLastClickedCell(cell);
diff --git a/src/Avalonia.Base/Input/InputExtensions.cs b/src/Avalonia.Base/Input/InputExtensions.cs
index a5107588c9..2533a174a4 100644
--- a/src/Avalonia.Base/Input/InputExtensions.cs
+++ b/src/Avalonia.Base/Input/InputExtensions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Avalonia.Media;
 using Avalonia.VisualTree;
 
 #nullable enable
@@ -31,10 +32,29 @@ namespace Avalonia.Input
             return (element as Visual)?.GetVisualsAt(p, enabledElementsOnly ? s_hitTestEnabledOnlyDelegate : s_hitTestDelegate).Cast<IInputElement>() ??
                 Enumerable.Empty<IInputElement>();
         }
-        
+
         /// <inheritdoc cref="GetInputElementsAt(IInputElement, Point, bool)"/>
         public static IEnumerable<IInputElement> GetInputElementsAt(this IInputElement element, Point p) => GetInputElementsAt(element, p, true);
 
+        /// <summary>
+        /// Returns the active input elements intersecting a geometry on an <see cref="IInputElement"/>.
+        /// </summary>
+        /// <param name="element">The element to test.</param>
+        /// <param name="geometry">The geometry on <paramref name="element"/>.</param>
+        /// <param name="enabledElementsOnly">Whether to only return elements for which <see cref="IInputElement.IsEffectivelyEnabled"/> is true.</param>
+        /// <returns>
+        /// The active input elements found intersecting the geometry, with intersection details, ordered topmost first.
+        /// </returns>
+        public static IEnumerable<GeometryHitTestResult> GetInputElementsAt(this IInputElement element, Geometry geometry, bool enabledElementsOnly = true)
+        {
+            element = element ?? throw new ArgumentNullException(nameof(element));
+
+            return (element as Visual)?.GetVisualsAt(geometry, enabledElementsOnly ? s_hitTestEnabledOnlyDelegate : s_hitTestDelegate)
+                .Where(x => x.VisualHit is IInputElement)
+                .Select(x => new GeometryHitTestResult(x.VisualHit, x.IntersectionResult)) ??
+                Enumerable.Empty<GeometryHitTestResult>();
+        }
+
         /// <summary>
         /// Returns the topmost active input element at a point on an <see cref="IInputElement"/>.
         /// </summary>
@@ -52,6 +72,22 @@ namespace Avalonia.Input
         /// <inheritdoc cref="InputHitTest(IInputElement, Point, bool)"/>
         public static IInputElement? InputHitTest(this IInputElement element, Point p) => InputHitTest(element, p, true);
 
+        /// <summary>
+        /// Returns the topmost active input element intersecting a geometry on an <see cref="IInputElement"/>.
+        /// </summary>
+        /// <param name="element">The element to test.</param>
+        /// <param name="geometry">The geometry on <paramref name="element"/>.</param>
+        /// <param name="enabledElementsOnly">Whether to only return elements for which <see cref="IInputElement.IsEffectivelyEnabled"/> is true.</param>
+        /// <returns>A <see cref="GeometryHitTestResult"/> containing the topmost <see cref="IInputElement"/> intersecting the specified geometry and intersection details, or null if no element intersects.</returns>
+        public static GeometryHitTestResult? InputHitTest(this IInputElement element, Geometry geometry, bool enabledElementsOnly = true)
+        {
+            element = element ?? throw new ArgumentNullException(nameof(element));
+
+            var hitTest = (element as Visual)?.GetVisualAt(geometry, enabledElementsOnly ? s_hitTestEnabledOnlyDelegate : s_hitTestDelegate);
+
+            return hitTest?.VisualHit is IInputElement inputElement ? hitTest : null;
+        }
+
         /// <summary>
         /// Returns the topmost active input element at a point on an <see cref="IInputElement"/>.
         /// </summary>
@@ -79,6 +115,30 @@ namespace Avalonia.Input
         /// <inheritdoc cref="InputHitTest(IInputElement, Point, Func{Visual, bool}, bool)"/>
         public static IInputElement? InputHitTest(this IInputElement element, Point p, Func<Visual, bool> filter) => InputHitTest(element, p, filter, true);
 
+        /// <summary>
+        /// Returns the topmost active input element intersecting a geometry on an <see cref="IInputElement"/>.
+        /// </summary>
+        /// <param name="element">The element to test.</param>
+        /// <param name="geometry">The geometry on <paramref name="element"/>.</param>
+        /// <param name="filter">
+        /// A filter predicate. If the predicate returns false then the visual and all its
+        /// children will be excluded from the results.
+        /// </param>
+        /// <param name="enabledElementsOnly">Whether to only return elements for which <see cref="IInputElement.IsEffectivelyEnabled"/> is true.</param>
+        /// <returns>A <see cref="GeometryHitTestResult"/> containing the topmost <see cref="IInputElement"/> intersecting the specified geometry and intersection details, or null if no element intersects.</returns>
+        public static IInputElement? InputHitTest(
+            this IInputElement element,
+            Geometry geometry,
+            Func<Visual, bool> filter,
+            bool enabledElementsOnly = true)
+        {
+            element = element ?? throw new ArgumentNullException(nameof(element));
+            filter = filter ?? throw new ArgumentNullException(nameof(filter));
+            var hitTestDelegate = enabledElementsOnly ? s_hitTestEnabledOnlyDelegate : s_hitTestDelegate;
+
+            return (element as Visual)?.GetVisualAt(geometry, x => hitTestDelegate(x) && filter(x)) as IInputElement;
+        }
+
         private static bool IsHitTestVisible(Visual visual) => visual is { IsVisible: true, IsAttachedToVisualTree: true } and IInputElement { IsHitTestVisible: true };
 
         private static bool IsHitTestVisible_EnabledOnly(Visual visual) => IsHitTestVisible(visual) && visual is IInputElement { IsEffectivelyEnabled: true };
diff --git a/src/Avalonia.Base/Media/Geometry.cs b/src/Avalonia.Base/Media/Geometry.cs
index 8082c2e71a..1499816122 100644
--- a/src/Avalonia.Base/Media/Geometry.cs
+++ b/src/Avalonia.Base/Media/Geometry.cs
@@ -1,8 +1,8 @@
 using System;
-using Avalonia.Platform;
 using System.ComponentModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
+using Avalonia.Platform;
 using Avalonia.Reactive;
 using Avalonia.Rendering.Composition;
 using Avalonia.Rendering.Composition.Drawing;
@@ -120,6 +120,16 @@ namespace Avalonia.Media
             return PlatformImpl?.FillContains(point) == true;
         }
 
+        /// <summary>
+        /// Returns a value that describes the intersection between the current geometry and the specified geometry
+        /// </summary>
+        /// <param name="geometry">The geometry to test for containment.</param>
+        /// <returns>The <see cref="IntersectionResult"/> describing the intersection between the geometries</returns>
+        public IntersectionResult? GetFillIntersectionResult(Geometry geometry)
+        {
+            return geometry.PlatformImpl == null ? IntersectionResult.Empty : PlatformImpl?.GetFillIntersectionResult(geometry.PlatformImpl);
+        }
+
         /// <summary>
         /// Indicates whether the geometry's stroke contains the specified point.
         /// </summary>
diff --git a/src/Avalonia.Base/Media/GeometryHitTestResult.cs b/src/Avalonia.Base/Media/GeometryHitTestResult.cs
new file mode 100644
index 0000000000..c43574a385
--- /dev/null
+++ b/src/Avalonia.Base/Media/GeometryHitTestResult.cs
@@ -0,0 +1,9 @@
+namespace Avalonia.Media
+{
+    /// <summary>
+    /// Returns the results of a hit test that uses a <see cref="Geometry"/> as a hit test parameter.
+    /// </summary>
+    /// <param name="VisualHit">Gets the <see cref="Visual"/> that is returned from a hit test result.</param>
+    /// <param name="IntersectionResult">Gets the <see cref="IntersectionResult"/> value of the hit test.</param>
+    public record class GeometryHitTestResult(Visual VisualHit, IntersectionResult IntersectionResult);
+}
diff --git a/src/Avalonia.Base/Media/IntersectionResult.cs b/src/Avalonia.Base/Media/IntersectionResult.cs
new file mode 100644
index 0000000000..cab4c70d0d
--- /dev/null
+++ b/src/Avalonia.Base/Media/IntersectionResult.cs
@@ -0,0 +1,33 @@
+namespace Avalonia.Media
+{
+    /// <summary>
+    /// Provides information about the intersection between a hit geometry and a target geometry or visual.
+    /// </summary>
+    public enum IntersectionResult
+    {
+        /// <summary>
+        /// The IntersectionDetail value is not calculated.
+        /// </summary>
+        NotCalculated = 0,
+
+        /// <summary>
+        /// The <see cref="Geometry"/> hit test parameter and the target visual, or geometry, do not intersect.
+        /// </summary>
+        Empty = 1,
+
+        /// <summary>
+        /// The target geometry or visual is fully inside the hit test <see cref="Geometry"/>.
+        /// </summary>
+        FullyInside = 2,
+
+        /// <summary>
+        /// The <see cref="Geometry"/> hit test parameter is fully contained within the boundary of the target visual or geometry.
+        /// </summary>
+        FullyContains = 3,
+
+        /// <summary>
+        /// The <see cref="Geometry"/> hit test parameter and the target visual, or geometry, intersect. This means that the two elements overlap, but neither element contains the other.
+        /// </summary>
+        Intersects = 4
+    }
+}
diff --git a/src/Avalonia.Base/Platform/IGeometryImpl.cs b/src/Avalonia.Base/Platform/IGeometryImpl.cs
index 0e74f1e4c5..ae8eb6d765 100644
--- a/src/Avalonia.Base/Platform/IGeometryImpl.cs
+++ b/src/Avalonia.Base/Platform/IGeometryImpl.cs
@@ -46,6 +46,13 @@ namespace Avalonia.Platform
         /// <returns><c>true</c> if the geometry contains the point; otherwise, <c>false</c>.</returns>
         bool FillContains(Point point);
 
+        /// <summary>
+        /// Returns a value that describes the intersection between the current geometry and the specified geometry
+        /// </summary>
+        /// <param name="geometry">The geometry to test for containment.</param>
+        /// <returns>The <see cref="IntersectionResult"/> describing the intersection between the geometries</returns>
+        IntersectionResult GetFillIntersectionResult(IGeometryImpl geometry);
+
         /// <summary>
         /// Intersects the geometry with another geometry.
         /// </summary>
diff --git a/src/Avalonia.Base/Platform/LtrbRect.cs b/src/Avalonia.Base/Platform/LtrbRect.cs
index 97cbec0ab2..37615b8205 100644
--- a/src/Avalonia.Base/Platform/LtrbRect.cs
+++ b/src/Avalonia.Base/Platform/LtrbRect.cs
@@ -301,4 +301,4 @@ public struct LtrbPixelRect
     internal static LtrbPixelRect FromRectUnscaled(LtrbRect rect) =>
         new((int)rect.Left, (int)rect.Top, (int)Math.Ceiling(rect.Right),
             (int)Math.Ceiling(rect.Bottom));
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/CompositingRenderer.cs b/src/Avalonia.Base/Rendering/Composition/CompositingRenderer.cs
index cef5eb62de..6cb4021713 100644
--- a/src/Avalonia.Base/Rendering/Composition/CompositingRenderer.cs
+++ b/src/Avalonia.Base/Rendering/Composition/CompositingRenderer.cs
@@ -4,9 +4,10 @@ using System.ComponentModel;
 using System.Threading;
 using System.Threading.Tasks;
 using Avalonia.Diagnostics;
-using Avalonia.Platform.Surfaces;
 using Avalonia.Media;
+using Avalonia.Platform.Surfaces;
 using Avalonia.Rendering.Composition.Drawing;
+using Avalonia.Rendering.Composition.HitTesting;
 using Avalonia.Threading;
 
 namespace Avalonia.Rendering.Composition;
@@ -92,6 +93,14 @@ internal class CompositingRenderer : IRendererWithCompositor, IHitTester
 
     /// <inheritdoc/>
     public IEnumerable<Visual> HitTest(Point p, Visual? root, Func<Visual, bool>? filter)
+        => HitTest<PointCompositionHitTester, Point, Visual>(p, root, filter, (visual, _) => visual);
+
+    public IEnumerable<GeometryHitTestResult> HitTest(Geometry geometry, Visual? root, Func<Visual, bool>? filter)
+        => HitTest<GeometryCompositionHitTester, Geometry, GeometryHitTestResult>(geometry, root, filter, (visual, intersection) => new GeometryHitTestResult(visual, intersection));
+
+    private IEnumerable<TResult> HitTest<THitTester, T, TResult>(T input, Visual? root, Func<Visual, bool>? filter, Func<Visual, IntersectionResult, TResult> resultSelector)
+        where THitTester : struct, ICompositionHitTester<T>
+        where TResult : class
     {
         using var _ = Diagnostic.PerformingHitTest();
 
@@ -102,7 +111,7 @@ internal class CompositingRenderer : IRendererWithCompositor, IHitTester
                 yield break;
             rootVisual = root.CompositionVisual;
         }
-        
+
         Func<CompositionVisual, bool>? f = null;
         if (filter != null)
             f = v =>
@@ -112,22 +121,37 @@ internal class CompositingRenderer : IRendererWithCompositor, IHitTester
                 return true;
             };
 
-        using var res = CompositionTarget.TryHitTest(p, rootVisual, f);
-        if(res == null)
+        using var res = CompositionTarget.TryHitTest<THitTester, T>(input, rootVisual, f);
+        if (res == null)
             yield break;
-        foreach(var v in res)
+
+        foreach (var v in res)
         {
-            if (v is CompositionDrawListVisual dv)
+            if (v.Item2 is CompositionDrawListVisual dv)
             {
                 if (filter == null || filter(dv.Visual))
-                    yield return dv.Visual;
+                    yield return resultSelector(dv.Visual, v.Item1);
             }
         }
     }
 
     /// <inheritdoc/>
     public Visual? HitTestFirst(Point p, Visual root, Func<Visual, bool>? filter)
+        => HitTestFirst<PointCompositionHitTester, Point>(p, root, filter, out _);
+
+    /// <inheritdoc/>
+    public GeometryHitTestResult? HitTestFirst(Geometry geometry, Visual root, Func<Visual, bool>? filter)
     {
+        var visual = HitTestFirst<GeometryCompositionHitTester, Geometry>(geometry, root, filter, out var intersectionResult);
+
+        return visual != null ? new GeometryHitTestResult(visual, intersectionResult) : null;
+    }
+
+    private Visual? HitTestFirst<THitTester, T>(T input, Visual root, Func<Visual, bool>? filter, out IntersectionResult intersectionResult)
+        where THitTester : struct, ICompositionHitTester<T>
+    {
+        intersectionResult = IntersectionResult.NotCalculated;
+
         using var _ = Diagnostic.PerformingHitTest();
 
         if (root.CompositionVisual == null)
@@ -137,7 +161,8 @@ internal class CompositingRenderer : IRendererWithCompositor, IHitTester
             ? null :
             v => v is not CompositionDrawListVisual dlv || filter(dlv.Visual);
 
-        return CompositionTarget.TryHitTestFirst(p, root.CompositionVisual, f, static v => v is CompositionDrawListVisual) is CompositionDrawListVisual dv ? dv.Visual : null;
+        return CompositionTarget.TryHitTestFirst<THitTester, T>(input, root.CompositionVisual, f, static v => v is CompositionDrawListVisual, out intersectionResult)
+            is CompositionDrawListVisual dv ? dv.Visual : null;
     }
 
     /// <inheritdoc/>
diff --git a/src/Avalonia.Base/Rendering/Composition/CompositionDrawListVisual.cs b/src/Avalonia.Base/Rendering/Composition/CompositionDrawListVisual.cs
index 6f4bb3b882..c7bf13e6ff 100644
--- a/src/Avalonia.Base/Rendering/Composition/CompositionDrawListVisual.cs
+++ b/src/Avalonia.Base/Rendering/Composition/CompositionDrawListVisual.cs
@@ -1,3 +1,4 @@
+using Avalonia.Media;
 using Avalonia.Rendering.Composition.Drawing;
 using Avalonia.Rendering.Composition.Server;
 using Avalonia.Rendering.Composition.Transport;
@@ -65,4 +66,17 @@ internal class CompositionDrawListVisual : CompositionContainerVisual
 
         return DrawList?.HitTest(pt) ?? false;
     }
+
+    internal override IntersectionResult HitTest(Geometry geometry)
+    {
+        var custom = Visual as ICustomHitTest;
+        if (DrawList == null && custom == null)
+            return IntersectionResult.Empty;
+        if (custom != null)
+        {
+            return custom.HitTest(geometry);
+        }
+
+        return DrawList?.HitTest(geometry) ?? IntersectionResult.Empty;
+    }
 }
diff --git a/src/Avalonia.Base/Rendering/Composition/CompositionTarget.cs b/src/Avalonia.Base/Rendering/Composition/CompositionTarget.cs
index 8b418211b8..0e9607dafa 100644
--- a/src/Avalonia.Base/Rendering/Composition/CompositionTarget.cs
+++ b/src/Avalonia.Base/Rendering/Composition/CompositionTarget.cs
@@ -1,7 +1,9 @@
 using System;
-using System.Numerics;
+using System.Diagnostics.CodeAnalysis;
 using Avalonia.Collections.Pooled;
-using Avalonia.VisualTree;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Rendering.Composition.HitTesting;
 
 namespace Avalonia.Rendering.Composition
 {
@@ -24,12 +26,16 @@ namespace Avalonia.Rendering.Composition
             if (Root != null)
                 Root.Root = null;
         }
-        
+
         /// <summary>
-        /// Attempts to perform a hit-tst
+        /// Attempts to perform a hit-test.
         /// </summary>
-        /// <returns></returns>
-        public PooledList<CompositionVisual>? TryHitTest(Point point, CompositionVisual? root, Func<CompositionVisual, bool>? filter)
+        /// <returns>A list of visuals hit during the test.</returns>
+        public PooledList<(IntersectionResult, CompositionVisual)>? TryHitTest<THitTester, T>(
+            T input,
+            CompositionVisual? root,
+            Func<CompositionVisual, bool>? filter)
+            where THitTester : struct, ICompositionHitTester<T>
         {
             Server.Compositor.Readback.NextRead();
 
@@ -43,10 +49,11 @@ namespace Avalonia.Rendering.Composition
             var readback = root.TryGetValidReadback();
             if (readback == null)
                 return null;
-            point = point.Transform(readback.Matrix);
 
-            var res = new PooledList<CompositionVisual>();
-            HitTestCore(root, point, res, filter);
+            var parentInput = THitTester.Transform(input, in readback.Matrix);
+
+            var res = new PooledList<(IntersectionResult, CompositionVisual)>();
+            HitTestCore<THitTester, T>(root, parentInput, res, filter);
             return res;
         }
 
@@ -77,31 +84,37 @@ namespace Avalonia.Rendering.Composition
             }
         }
 
-        private void HitTestCore(CompositionVisual visual, Point parentPoint, PooledList<CompositionVisual> result, Func<CompositionVisual, bool>? filter)
+        private void HitTestCore<THitTester, T>(
+            CompositionVisual visual,
+            T parentInput,
+            PooledList<(IntersectionResult, CompositionVisual)> result,
+            Func<CompositionVisual, bool>? filter)
+            where THitTester : struct, ICompositionHitTester<T>
         {
-            if (!HitTestVisual(visual, parentPoint, filter, out var point))
+            if (!HitTestVisual<THitTester, T>(visual, parentInput, filter, out var input))
                 return;
 
             // Inspect children
             if (visual is CompositionContainerVisual cv)
-                HitTestChildren(cv, point, result, filter);
-            
+                HitTestChildren<THitTester, T>(cv, input, result, filter);
+
             // Hit-test the current node
-            if (visual.HitTest(point))
-                result.Add(visual);
+            if (THitTester.HitTest(visual, input) is IntersectionResult intersectionResult && intersectionResult > IntersectionResult.Empty)
+                result.Add((intersectionResult, visual));
         }
 
-        private void HitTestChildren(CompositionContainerVisual visual, Point point, PooledList<CompositionVisual> result, Func<CompositionVisual, bool>? filter)
+        private void HitTestChildren<THitTester, T>(CompositionContainerVisual visual, T input, PooledList<(IntersectionResult, CompositionVisual)> result, Func<CompositionVisual, bool>? filter)
+            where THitTester : struct, ICompositionHitTester<T>
         {
             if (visual.Children.Count >= CompositionContainerVisual.HitTestAabbTreeThreshold)
             {
                 var candidates = RentHitTestChildCandidates(out var releaseToField);
                 try
                 {
-                    if (visual.TryQueryHitTestChildren(point, candidates))
+                    if (visual.TryQueryHitTestChildren<THitTester, T>(input, candidates))
                     {
                         foreach (var child in candidates)
-                            HitTestCore(child, point, result, filter);
+                            HitTestCore<THitTester, T>(child, input, result, filter);
                         return;
                     }
                 }
@@ -112,47 +125,58 @@ namespace Avalonia.Rendering.Composition
             }
 
             for (var c = visual.Children.Count - 1; c >= 0; c--)
-                HitTestCore(visual.Children[c], point, result, filter);
+                HitTestCore<THitTester, T>(visual.Children[c], input, result, filter);
         }
 
-        private static bool HitTestVisual(CompositionVisual visual, Point parentPoint, Func<CompositionVisual, bool>? filter, out Point point)
+        private static bool HitTestVisual<THitTester, T>(
+            CompositionVisual visual,
+            T parentInput,
+            Func<CompositionVisual, bool>? filter,
+            [MaybeNullWhen(false)] out T input)
+            where THitTester : struct, ICompositionHitTester<T>
         {
-            point = default;
+            input = default;
 
-            if (visual.Visible == false)
+            if (!visual.Visible)
                 return false;
 
             if (filter != null && !filter(visual))
                 return false;
 
             var readback = visual.TryGetValidReadback();
-            if(readback == null)
+            if (readback == null)
                 return false;
 
             if (!visual.DisableSubTreeBoundsHitTestOptimization &&
-                (readback.TransformedSubtreeBounds == null ||
-                 !readback.TransformedSubtreeBounds.Value.Contains(parentPoint)))
+                (readback.TransformedSubtreeBounds is not { } transformedSubtreeBounds ||
+                 !THitTester.TransformedSubTreeBoundsMatch(transformedSubtreeBounds, parentInput)))
                 return false;
 
-            if(!readback.Matrix.TryInvert(out var invMatrix))
+            if (!readback.Matrix.TryInvert(out var invMatrix))
                 return false;
 
-            point = parentPoint.Transform(invMatrix);
+            input = THitTester.Transform(parentInput, in invMatrix);
 
-            if (visual.ClipToBounds
-                && (point.X < 0 || point.Y < 0 || point.X > visual.Size.X || point.Y > visual.Size.Y))
+            if (visual.ClipToBounds && !THitTester.ClippedBoundsMatch(visual, input))
                 return false;
 
-            if (visual.Clip?.FillContains(point) == false)
+            if (visual.Clip is { } clip && !THitTester.ClipMatches(clip, input))
                 return false;
 
             return true;
         }
 
-        public CompositionVisual? TryHitTestFirst(Point point, CompositionVisual? root, Func<CompositionVisual, bool>? filter, Func<CompositionVisual, bool>? resultFilter)
+        public CompositionVisual? TryHitTestFirst<THitTester, T>(
+            T input,
+            CompositionVisual? root,
+            Func<CompositionVisual, bool>? filter,
+            Func<CompositionVisual, bool>? resultFilter, out IntersectionResult intersectionResult)
+            where THitTester : struct, ICompositionHitTester<T>
         {
             Server.Compositor.Readback.NextRead();
 
+            intersectionResult = IntersectionResult.NotCalculated;
+
             root ??= Root;
             if (root == null)
                 return null;
@@ -164,12 +188,21 @@ namespace Avalonia.Rendering.Composition
             if (readback == null)
                 return null;
 
-            return HitTestFirstCore(root, point.Transform(readback.Matrix), filter, resultFilter);
+            var parentInput = THitTester.Transform(input, in readback.Matrix);
+
+            return HitTestFirstCore<THitTester, T>(root, parentInput, filter, resultFilter, out intersectionResult);
         }
 
-        internal CompositionVisual? HitTestFirstCore(CompositionVisual visual, Point parentPoint, Func<CompositionVisual, bool>? filter, Func<CompositionVisual, bool>? resultFilter)
+        internal CompositionVisual? HitTestFirstCore<THitTester, T>(
+            CompositionVisual visual,
+            T parentInput,
+            Func<CompositionVisual, bool>? filter,
+            Func<CompositionVisual, bool>? resultFilter, out IntersectionResult intersectionResult)
+            where THitTester : struct, ICompositionHitTester<T>
         {
-            if (!HitTestVisual(visual, parentPoint, filter, out var point))
+            intersectionResult = IntersectionResult.NotCalculated;
+
+            if (!HitTestVisual<THitTester, T>(visual, parentInput, filter, out var input))
                 return null;
 
             if (visual is CompositionContainerVisual cv)
@@ -177,7 +210,7 @@ namespace Avalonia.Rendering.Composition
                 var queriedIndexedChildren = false;
                 if (cv.Children.Count >= CompositionContainerVisual.HitTestAabbTreeThreshold)
                 {
-                    if (cv.TryQueryFirstHitTestChild(this, point, filter, resultFilter, out var hit))
+                    if (cv.TryQueryFirstHitTestChild<THitTester, T>(this, input, filter, resultFilter, out var hit, out intersectionResult))
                     {
                         queriedIndexedChildren = true;
                         if (hit != null)
@@ -189,14 +222,16 @@ namespace Avalonia.Rendering.Composition
                 {
                     for (var c = cv.Children.Count - 1; c >= 0; c--)
                     {
-                        var hit = HitTestFirstCore(cv.Children[c], point, filter, resultFilter);
+                        var hit = HitTestFirstCore<THitTester, T>(cv.Children[c], input, filter, resultFilter, out intersectionResult);
                         if (hit != null)
                             return hit;
                     }
                 }
             }
 
-            return visual.HitTest(point) && (resultFilter == null || resultFilter(visual)) ? visual : null;
+            intersectionResult = THitTester.HitTest(visual, input);
+
+            return intersectionResult > IntersectionResult.Empty && (resultFilter == null || resultFilter(visual)) ? visual : null;
         }
 
         /// <summary>
diff --git a/src/Avalonia.Base/Rendering/Composition/ContainerVisual.cs b/src/Avalonia.Base/Rendering/Composition/ContainerVisual.cs
index ceaf18ee0c..04dedb041d 100644
--- a/src/Avalonia.Base/Rendering/Composition/ContainerVisual.cs
+++ b/src/Avalonia.Base/Rendering/Composition/ContainerVisual.cs
@@ -1,6 +1,7 @@
 using System;
 using Avalonia.Collections.Pooled;
-using Avalonia.Rendering.Composition.Server;
+using Avalonia.Media;
+using Avalonia.Rendering.Composition.HitTesting;
 
 namespace Avalonia.Rendering.Composition
 {
@@ -53,7 +54,8 @@ namespace Avalonia.Rendering.Composition
             _hitTestChildren?.Clear();
         }
 
-        internal bool TryQueryHitTestChildren(Point point, PooledList<CompositionVisual> results)
+        internal bool TryQueryHitTestChildren<THitTester, T>(T input, PooledList<CompositionVisual> results)
+            where THitTester : struct, ICompositionHitTester<T>
         {
             if (Children.Count < HitTestAabbTreeThreshold)
             {
@@ -63,22 +65,30 @@ namespace Avalonia.Rendering.Composition
 
             _hitTestChildren ??= new CompositionHitTestAabbTree(Children);
 
-            _hitTestChildren.Query(point, results, Server.Compositor.Readback.ReadRevision);
+            _hitTestChildren.Query<THitTester, T>(input, results, Server.Compositor.Readback.ReadRevision);
             return true;
         }
 
-        internal bool TryQueryFirstHitTestChild(CompositionTarget target, Point point, Func<CompositionVisual, bool>? filter, Func<CompositionVisual, bool>? resultFilter, out CompositionVisual? hit)
+        internal bool TryQueryFirstHitTestChild<THitTester, T>(
+            CompositionTarget target,
+            T input,
+            Func<CompositionVisual, bool>? filter,
+            Func<CompositionVisual, bool>? resultFilter,
+            out CompositionVisual? hit,
+            out IntersectionResult intersectionResult)
+            where THitTester : struct, ICompositionHitTester<T>
         {
             if (Children.Count < HitTestAabbTreeThreshold)
             {
                 _hitTestChildren = null;
                 hit = null;
+                intersectionResult = IntersectionResult.Empty;
                 return false;
             }
 
             _hitTestChildren ??= new CompositionHitTestAabbTree(Children);
 
-            hit = _hitTestChildren.QueryFirst(target, point, filter, resultFilter, Server.Compositor.Readback.ReadRevision);
+            hit = _hitTestChildren.QueryFirst<THitTester, T>(target, input, filter, resultFilter, Server.Compositor.Readback.ReadRevision, out intersectionResult);
             return true;
         }
 
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/CompositionRenderData.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/CompositionRenderData.cs
index feb0a93f61..79a41f6452 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/CompositionRenderData.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/CompositionRenderData.cs
@@ -1,4 +1,5 @@
 using System;
+using Avalonia.Media;
 using Avalonia.Rendering.Composition.Server;
 using Avalonia.Rendering.Composition.Transport;
 using Avalonia.Utilities;
@@ -47,4 +48,6 @@ internal class CompositionRenderData : ICompositorSerializable, IDisposable
     }
 
     public bool HitTest(Point pt) => _stream.HitTest(pt);
+
+    public IntersectionResult HitTest(Geometry geometry) => _stream.HitTest(geometry);
 }
diff --git a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.HitTest.cs b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.HitTest.cs
index 38b39053f9..289fc831fd 100644
--- a/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.HitTest.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Drawing/RenderDataStream.HitTest.cs
@@ -1,6 +1,6 @@
 using System;
+using System.Collections.Generic;
 using Avalonia.Media;
-using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 using Avalonia.Rendering.SceneGraph;
 using Avalonia.Utilities;
@@ -13,88 +13,189 @@ internal partial class RenderDataStream
     {
         public bool SavedLive;
         public bool RestorePoint;
-        public Point SavedPoint;
+        public Point? SavedPoint;
     }
 
     internal struct HitTestVisitor : IRenderDataVisitor<HitTestScope>
     {
         public bool StopVisiting { get; private set; }
+        public Geometry? CurrentGeometry
+        {
+            get => _currentGeometry;
+            set
+            {
+                _currentGeometry = value;
+                _renderedGeometry = GetRenderedGeometry(value, s_defaultStokePen);
+            }
+        }
+
         public bool HitFound;
-        public Point Current;
+        public IntersectionResult HitResult;
+        private Geometry? _currentGeometry;
+        private Geometry? _renderedGeometry;
+        public Point? CurrentPoint;
         public bool Live;
 
-        public HitTestVisitor(Point point)
+        private Stack<Geometry>? _savedGeometries = null;
+
+        public HitTestVisitor()
         {
             StopVisiting = false;
-            HitFound = false;
-            Current = point;
             Live = true;
         }
 
+        public HitTestVisitor(Geometry geometry) : this()
+        {
+            HitResult = IntersectionResult.NotCalculated;
+            CurrentGeometry = geometry;
+            _savedGeometries = new Stack<Geometry>();
+        }
+
+        public HitTestVisitor(Point point) : this()
+        {
+            HitResult = IntersectionResult.NotCalculated;
+            CurrentPoint = point;
+        }
+
         private void Hit()
         {
             HitFound = true;
             StopVisiting = true;
         }
 
+        private void Hit(IntersectionResult result)
+        {
+            HitResult = result;
+            StopVisiting = true;
+        }
+
         public void OnDrawLine(IPen? serverPen, IPen? clientPen, Point p1, Point p2)
         {
-            if (Live && HitTestLine(clientPen, p1, p2, Current))
+            if (!Live)
+                return;
+
+            if (CurrentPoint is { } point && HitTestLine(clientPen, p1, p2, point))
                 Hit();
+
+            else if (_renderedGeometry is { } geometry && HitTestLine(clientPen, p1, p2, geometry) is { } intersectionDetail)
+                Hit(intersectionDetail);
         }
 
         public void OnDrawRectangle(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, RoundedRect rect,
             BoxShadows boxShadows)
         {
-            if (Live && HitTestRectangle(serverBrush, clientPen, rect, Current))
+            if (!Live)
+                return;
+
+            if (CurrentPoint is { } point && HitTestRectangle(serverBrush, clientPen, rect, point))
                 Hit();
+
+            else if (_renderedGeometry is { } geometry && HitTestRectangle(serverBrush, clientPen, rect, geometry) is { } intersectionDetail)
+                Hit(intersectionDetail);
         }
 
         public void OnDrawEllipse(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, Rect rect)
         {
-            if (Live && HitTestEllipse(serverBrush, clientPen, rect, Current))
+            if (!Live)
+                return;
+
+            if (CurrentPoint is { } point && HitTestEllipse(serverBrush, clientPen, rect, point))
                 Hit();
+
+            else if (_renderedGeometry is { } geometry && HitTestEllipse(serverBrush, clientPen, rect, geometry) is { } intersectionDetail)
+                Hit(intersectionDetail);
         }
 
         public void OnDrawGeometry(IBrush? serverBrush, IPen? serverPen, IPen? clientPen, IGeometryImpl? geometry)
         {
-            if (Live && geometry != null &&
-                ((serverBrush != null && geometry.FillContains(Current)) ||
-                 (clientPen != null && geometry.StrokeContains(clientPen, Current))))
+            if (!Live || geometry == null)
+                return;
+
+            if (CurrentPoint is { } point &&
+                ((serverBrush != null && geometry.FillContains(point)) ||
+                 (clientPen != null && geometry.StrokeContains(clientPen, point))))
                 Hit();
+
+            else if (_renderedGeometry is { } currentGeometry &&
+                serverBrush != null && currentGeometry.PlatformImpl != null &&
+                GetRenderedGeometry(geometry, clientPen) is { } renderedGeometry &&
+                renderedGeometry.GetFillIntersectionResult(currentGeometry.PlatformImpl) is { } intersectionDetail)
+                Hit(intersectionDetail);
         }
 
         public void OnDrawGlyphRun(IBrush? serverBrush, IRef<IGlyphRunImpl>? glyphRun)
         {
-            if (Live && glyphRun != null && glyphRun.Item.Bounds.ContainsExclusive(Current))
+            if (!Live || glyphRun == null)
+                return;
+
+            if (CurrentPoint is { } point && glyphRun.Item.Bounds.ContainsExclusive(point))
                 Hit();
+
+            else if (_renderedGeometry is { } geometry && GetIntersectionDetail(glyphRun.Item.Bounds, geometry.Bounds) is { } intersectionDetail)
+                Hit(intersectionDetail);
         }
 
         public void OnDrawBitmap(IRef<IBitmapImpl>? bitmap, double opacity, Rect sourceRect, Rect destRect)
         {
-            if (Live && destRect.Contains(Current))
+            if (!Live)
+                return;
+
+            if (CurrentPoint is { } point && destRect.Contains(point))
                 Hit();
+
+            else if (_renderedGeometry is { } geometry && GetIntersectionDetail(destRect, geometry.Bounds) is { } intersectionDetail)
+                Hit(intersectionDetail);
         }
 
         public void OnDrawCustom(ICustomDrawOperation? operation)
         {
-            if (Live && operation != null && operation.HitTest(Current))
+            if (!Live)
+                return;
+
+            if (CurrentPoint is { } point && operation != null && operation.HitTest(point))
                 Hit();
+
+            else if (_renderedGeometry is { } geometry && operation != null && operation.HitTest(geometry) is { } intersectionDetail)
+                Hit(intersectionDetail);
+        }
+
+        private IntersectionResult GetIntersectionDetail(Rect firstRect, Rect secondRect)
+        {
+            if (firstRect.Contains(secondRect))
+                return IntersectionResult.FullyContains;
+
+            if (secondRect.Contains(secondRect))
+                return IntersectionResult.FullyInside;
+
+            if (firstRect.Intersects(secondRect))
+                return IntersectionResult.Intersects;
+
+            return IntersectionResult.Empty;
         }
 
         public HitTestScope OnPushClip(RoundedRect clip)
         {
             var scope = new HitTestScope { SavedLive = Live };
-            if (Live && !clip.Rect.Contains(Current))
-                Live = false;
+
+            if (Live)
+            {
+                if ((CurrentPoint is { } point && !clip.Rect.Contains(point)) ||
+                    (_renderedGeometry is { } geometry && !clip.Rect.Contains(geometry.Bounds)))
+                    Live = false;
+            }
+
             return scope;
         }
 
         public HitTestScope OnPushGeometryClip(IGeometryImpl? geometry)
         {
             var scope = new HitTestScope { SavedLive = Live };
-            if (Live && geometry != null && !geometry.FillContains(Current))
-                Live = false;
+            if (Live && geometry != null)
+            {
+                if ((CurrentPoint is { } point && !geometry.FillContains(point)) || (_renderedGeometry is { } currentGeometry && currentGeometry.PlatformImpl != null &&
+                geometry.GetFillIntersectionResult(currentGeometry.PlatformImpl) > IntersectionResult.Empty))
+                    Live = false;
+            }
             return scope;
         }
 
@@ -112,8 +213,18 @@ internal partial class RenderDataStream
                 if (matrix.TryInvert(out var inverted))
                 {
                     scope.RestorePoint = true;
-                    scope.SavedPoint = Current;
-                    Current = Current.Transform(inverted);
+                    if (CurrentPoint is { } point)
+                    {
+                        scope.SavedPoint = point;
+                        CurrentPoint = point.Transform(inverted);
+                    }
+                    else if (CurrentGeometry != null)
+                    {
+                        _savedGeometries?.Push(CurrentGeometry);
+                        CurrentGeometry = CurrentGeometry.Clone();
+                        CurrentGeometry.Transform = new MatrixTransform((CurrentGeometry.Transform?.Value ?? Matrix.Identity) * inverted);
+                        _renderedGeometry?.Transform = CurrentGeometry.Transform;
+                    }
                 }
                 else
                     Live = false;
@@ -134,7 +245,10 @@ internal partial class RenderDataStream
         {
             Live = scope.SavedLive;
             if (scope.RestorePoint)
-                Current = scope.SavedPoint;
+            {
+                CurrentPoint = scope.SavedPoint;
+                CurrentGeometry = _savedGeometries?.Pop();
+            }
         }
     }
 
@@ -145,6 +259,13 @@ internal partial class RenderDataStream
         return visitor.HitFound;
     }
 
+    public IntersectionResult HitTest(Geometry geometry)
+    {
+        var visitor = new HitTestVisitor(geometry);
+        Visit<HitTestVisitor, HitTestScope>(ref visitor);
+        return visitor.HitResult;
+    }
+
     private static bool HitTestLine(IPen? clientPen, Point p1, Point p2, Point p)
     {
         if (clientPen == null)
@@ -176,6 +297,14 @@ internal partial class RenderDataStream
         return Math.Abs(distance) <= halfThickness;
     }
 
+    private static IntersectionResult? HitTestLine(IPen? clientPen, Point p1, Point p2, Geometry geometry)
+    {
+        if (clientPen == null)
+            return IntersectionResult.NotCalculated;
+
+        return geometry.GetFillIntersectionResult(new LineGeometry(p1, p2));
+    }
+
     private static bool HitTestRectangle(IBrush? serverBrush, IPen? clientPen, RoundedRect rect, Point p)
     {
         var strokeThicknessAdjustment = (clientPen?.Thickness / 2) ?? 0;
@@ -208,6 +337,35 @@ internal partial class RenderDataStream
         return false;
     }
 
+    private static IntersectionResult? HitTestRectangle(IBrush? serverBrush, IPen? clientPen, RoundedRect rect, Geometry geometry)
+    {
+        var strokeThicknessAdjustment = (clientPen?.Thickness / 2) ?? 0;
+
+        if (rect.IsRounded)
+        {
+            var outer = rect.Inflate(strokeThicknessAdjustment, strokeThicknessAdjustment);
+            return new RectangleGeometry(outer.Rect, outer.RadiiTopLeft.X, outer.RadiiTopLeft.Y).GetFillIntersectionResult(geometry);
+        }
+        else
+        {
+            var outer = rect.Rect.Inflate(strokeThicknessAdjustment);
+            return new RectangleGeometry(outer).GetFillIntersectionResult(geometry);
+        }
+    }
+
+    private static readonly IPen s_defaultStokePen = new Pen();
+
+    private static Geometry? GetRenderedGeometry(Geometry? geometry, IPen? pen)
+    {
+        return geometry == null ? null : new CombinedGeometry(geometry.GetWidenedGeometry(pen ?? s_defaultStokePen), geometry);
+    }
+
+    private static IGeometryImpl? GetRenderedGeometry(IGeometryImpl? geometry, IPen? pen)
+    {
+        return geometry == null ? null : new CombinedGeometry(new ImmutableGeometry(geometry.GetWidenedGeometry(pen ?? s_defaultStokePen)), 
+            new ImmutableGeometry(geometry)).PlatformImpl;
+    }
+
     private static bool HitTestEllipse(IBrush? serverBrush, IPen? clientPen, Rect rect, Point p)
     {
         var center = rect.Center;
@@ -240,6 +398,19 @@ internal partial class RenderDataStream
         return false;
     }
 
+    private static IntersectionResult? HitTestEllipse(IBrush? serverBrush, IPen? clientPen, Rect rect, Geometry geometry)
+    {
+        var center = rect.Center;
+        var strokeThickness = clientPen?.Thickness ?? 0;
+
+        var rx = rect.Width / 2 + strokeThickness / 2;
+        var ry = rect.Height / 2 + strokeThickness / 2;
+
+        var ellipse = new EllipseGeometry(rect);
+
+        return ellipse.GetFillIntersectionResult(geometry);
+    }
+
     private static bool EllipseContains(double dx, double dy, double radiusX, double radiusY)
     {
         var rx2 = radiusX * radiusX;
diff --git a/src/Avalonia.Base/Rendering/Composition/CompositionHitTestAabbTree.cs b/src/Avalonia.Base/Rendering/Composition/HitTesting/CompositionHitTestAabbTree.cs
similarity index 95%
rename from src/Avalonia.Base/Rendering/Composition/CompositionHitTestAabbTree.cs
rename to src/Avalonia.Base/Rendering/Composition/HitTesting/CompositionHitTestAabbTree.cs
index f42c46a4a7..2cf6ff6e02 100644
--- a/src/Avalonia.Base/Rendering/Composition/CompositionHitTestAabbTree.cs
+++ b/src/Avalonia.Base/Rendering/Composition/HitTesting/CompositionHitTestAabbTree.cs
@@ -4,9 +4,10 @@ using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Avalonia.Collections.Pooled;
+using Avalonia.Media;
 using Avalonia.Platform;
 
-namespace Avalonia.Rendering.Composition;
+namespace Avalonia.Rendering.Composition.HitTesting;
 
 internal sealed class CompositionHitTestAabbTree
 {
@@ -104,7 +105,8 @@ internal sealed class CompositionHitTestAabbTree
             RemoveBucketIfEmpty(oldBucket);
     }
 
-    public void Query(Point point, PooledList<CompositionVisual> results, ulong readbackRevision)
+    public void Query<THitTester, T>(T input, PooledList<CompositionVisual> results, ulong readbackRevision)
+        where THitTester : struct, ICompositionHitTester<T>
     {
         var candidates = ArrayPool<Candidate>.Shared.Rent(OrderBucketSize);
         var stack = ArrayPool<int>.Shared.Rent(16);
@@ -122,7 +124,7 @@ internal sealed class CompositionHitTestAabbTree
 
                 candidateCount = 0;
                 var stackCount = 0;
-                QueryBucket(bucket, point, ref candidates, ref candidateCount, ref stack, ref stackCount);
+                QueryBucket<THitTester, T>(bucket, input, ref candidates, ref candidateCount, ref stack, ref stackCount);
                 candidates.AsSpan(0, candidateCount).Sort(s_candidateComparer);
 
                 for (var j = 0; j < candidateCount; j++)
@@ -139,8 +141,16 @@ internal sealed class CompositionHitTestAabbTree
         }
     }
 
-    public CompositionVisual? QueryFirst(CompositionTarget target, Point point, Func<CompositionVisual, bool>? filter, Func<CompositionVisual, bool>? resultFilter, ulong readbackRevision)
+    public CompositionVisual? QueryFirst<THitTester, T>(
+        CompositionTarget target,
+        T input,
+        Func<CompositionVisual, bool>? filter,
+        Func<CompositionVisual, bool>? resultFilter,
+        ulong readbackRevision,
+        out IntersectionResult intersectionResult)
+        where THitTester : struct, ICompositionHitTester<T>
     {
+        intersectionResult = IntersectionResult.NotCalculated;
         var candidates = ArrayPool<Candidate>.Shared.Rent(OrderBucketSize);
         var stack = ArrayPool<int>.Shared.Rent(16);
         var candidateCount = 0;
@@ -157,12 +167,12 @@ internal sealed class CompositionHitTestAabbTree
 
                 candidateCount = 0;
                 var stackCount = 0;
-                QueryBucket(bucket, point, ref candidates, ref candidateCount, ref stack, ref stackCount);
+                QueryBucket<THitTester, T>(bucket, input, ref candidates, ref candidateCount, ref stack, ref stackCount);
                 candidates.AsSpan(0, candidateCount).Sort(s_candidateComparer);
 
                 for (var j = 0; j < candidateCount; j++)
                 {
-                    var hit = target.HitTestFirstCore(candidates[j].Visual, point, filter, resultFilter);
+                    var hit = target.HitTestFirstCore<THitTester, T>(candidates[j].Visual, input, filter, resultFilter, out intersectionResult);
                     if (hit != null)
                         return hit;
                 }
@@ -241,7 +251,14 @@ internal sealed class CompositionHitTestAabbTree
             AddUnbounded(visual, entry.Order, ref entry);
     }
 
-    private void QueryBucket(Bucket bucket, Point point, ref Candidate[] candidates, ref int candidateCount, ref int[] stack, ref int stackCount)
+    private void QueryBucket<THitTester, T>(
+        Bucket bucket,
+        T input,
+        ref Candidate[] candidates,
+        ref int candidateCount,
+        ref int[] stack,
+        ref int stackCount)
+        where THitTester : struct, ICompositionHitTester<T>
     {
         PushQueryNode(ref stack, ref stackCount, bucket.Root);
 
@@ -250,7 +267,7 @@ internal sealed class CompositionHitTestAabbTree
             var nodeIndex = stack[--stackCount];
             var node = _nodes[nodeIndex];
 
-            if (!node.Bounds.Contains(point))
+            if (!THitTester.TransformedSubTreeBoundsMatch(node.Bounds, input))
                 continue;
 
             if (node.IsLeaf)
diff --git a/src/Avalonia.Base/Rendering/Composition/HitTesting/GeometryCompositionHitTester.cs b/src/Avalonia.Base/Rendering/Composition/HitTesting/GeometryCompositionHitTester.cs
new file mode 100644
index 0000000000..a851c06fe6
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/HitTesting/GeometryCompositionHitTester.cs
@@ -0,0 +1,33 @@
+using Avalonia.Media;
+using Avalonia.Platform;
+
+namespace Avalonia.Rendering.Composition.HitTesting;
+
+internal struct GeometryCompositionHitTester : ICompositionHitTester<Geometry>
+{
+    public static Geometry Transform(Geometry input, in Matrix matrix)
+    {
+        var result = input.Clone();
+        result.Transform = new MatrixTransform((input.Transform?.Value ?? Matrix.Identity) * matrix);
+        return result;
+    }
+
+    public static IntersectionResult HitTest(CompositionVisual visual, Geometry input)
+        => visual.HitTest(input);
+
+    public static bool TransformedSubTreeBoundsMatch(LtrbRect bounds, Geometry input)
+    {
+        var geometryRenderBounds = input.Bounds;
+        return bounds.Intersects(new LtrbRect(geometryRenderBounds));
+    }
+
+    public static bool ClippedBoundsMatch(CompositionVisual visual, Geometry input)
+    {
+        var bounds = input.Bounds;
+        return bounds.Width > 0 && bounds.Height > 0 && bounds.Intersects(new Rect(new Size(visual.Size.X, visual.Size.Y)));
+    }
+
+    public static bool ClipMatches(IGeometryImpl clip, Geometry input)
+        => input.PlatformImpl is { } geometryImpl &&
+           clip.GetFillIntersectionResult(geometryImpl) > IntersectionResult.Empty;
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/HitTesting/ICompositionHitTester.cs b/src/Avalonia.Base/Rendering/Composition/HitTesting/ICompositionHitTester.cs
new file mode 100644
index 0000000000..91818923ea
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/HitTesting/ICompositionHitTester.cs
@@ -0,0 +1,17 @@
+using Avalonia.Media;
+using Avalonia.Platform;
+
+namespace Avalonia.Rendering.Composition.HitTesting;
+
+internal interface ICompositionHitTester<T>
+{
+    static abstract T Transform(T input, in Matrix matrix);
+
+    static abstract IntersectionResult HitTest(CompositionVisual visual, T input);
+
+    static abstract bool TransformedSubTreeBoundsMatch(LtrbRect bounds, T input);
+
+    static abstract bool ClippedBoundsMatch(CompositionVisual visual, T input);
+
+    static abstract bool ClipMatches(IGeometryImpl clip, T input);
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/HitTesting/PointCompositionHitTester.cs b/src/Avalonia.Base/Rendering/Composition/HitTesting/PointCompositionHitTester.cs
new file mode 100644
index 0000000000..7a4be96419
--- /dev/null
+++ b/src/Avalonia.Base/Rendering/Composition/HitTesting/PointCompositionHitTester.cs
@@ -0,0 +1,22 @@
+using Avalonia.Media;
+using Avalonia.Platform;
+
+namespace Avalonia.Rendering.Composition.HitTesting;
+
+internal struct PointCompositionHitTester : ICompositionHitTester<Point>
+{
+    public static Point Transform(Point input, in Matrix matrix)
+        => input.Transform(matrix);
+
+    public static IntersectionResult HitTest(CompositionVisual visual, Point input)
+        => visual.HitTest(input) ? IntersectionResult.FullyContains : IntersectionResult.Empty;
+
+    public static bool TransformedSubTreeBoundsMatch(LtrbRect bounds, Point input)
+        => bounds.Contains(input);
+
+    public static bool ClippedBoundsMatch(CompositionVisual visual, Point input)
+        => input.X >= 0 && input.Y >= 0 && input.X <= visual.Size.X && input.Y <= visual.Size.Y;
+
+    public static bool ClipMatches(IGeometryImpl clip, Point input)
+        => clip.FillContains(input);
+}
diff --git a/src/Avalonia.Base/Rendering/Composition/Visual.cs b/src/Avalonia.Base/Rendering/Composition/Visual.cs
index 6134d48220..b67adcc800 100644
--- a/src/Avalonia.Base/Rendering/Composition/Visual.cs
+++ b/src/Avalonia.Base/Rendering/Composition/Visual.cs
@@ -1,9 +1,6 @@
-using System;
-using System.Numerics;
 using Avalonia.Media;
 using Avalonia.Rendering.Composition.Drawing;
 using Avalonia.Rendering.Composition.Server;
-using Avalonia.VisualTree;
 
 namespace Avalonia.Rendering.Composition
 {
@@ -102,5 +99,6 @@ namespace Avalonia.Rendering.Composition
         internal object? Tag { get; set; }
 
         internal virtual bool HitTest(Point point) => true;
+        internal virtual IntersectionResult HitTest(Geometry geometry) => IntersectionResult.Intersects;
     }
 }
diff --git a/src/Avalonia.Base/Rendering/ICustomHitTest.cs b/src/Avalonia.Base/Rendering/ICustomHitTest.cs
index 65bb24b4b3..003576606a 100644
--- a/src/Avalonia.Base/Rendering/ICustomHitTest.cs
+++ b/src/Avalonia.Base/Rendering/ICustomHitTest.cs
@@ -1,6 +1,4 @@
-using System.Collections.Generic;
-using System.Linq;
-using Avalonia.VisualTree;
+using Avalonia.Media;
 
 namespace Avalonia.Rendering
 {
@@ -12,5 +10,19 @@ namespace Avalonia.Rendering
     {
         /// <param name="point">The point to hit test in global coordinate space.</param>
         bool HitTest(Point point);
+
+        /// <summary>
+        /// Hit test the geometry in this node.
+        /// </summary>
+        /// <param name="geometry">The geometry in global coordinates.</param>
+        /// <returns>The <see cref="IntersectionResult"/> describing the intersecting between the hit geometry and the node's geometry.</returns>
+        /// <remarks>
+        /// This method does not recurse to childs, if you want
+        /// to hit test children they must be hit tested manually.
+        /// </remarks>
+        IntersectionResult HitTest(Geometry geometry)
+        {
+            return IntersectionResult.Empty;
+        }
     }
 }
diff --git a/src/Avalonia.Base/Rendering/IRenderer.cs b/src/Avalonia.Base/Rendering/IRenderer.cs
index bc69f90aa5..4948e06f5a 100644
--- a/src/Avalonia.Base/Rendering/IRenderer.cs
+++ b/src/Avalonia.Base/Rendering/IRenderer.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using Avalonia.Media;
 using Avalonia.Metadata;
 using Avalonia.Rendering.Composition;
 
@@ -93,11 +94,34 @@ namespace Avalonia.Rendering
         /// <returns>The visuals at the specified point, topmost first.</returns>
         IEnumerable<Visual> HitTest(Point p, Visual root, Func<Visual, bool>? filter);
 
+        /// <summary>
+        /// Hit tests a geometry to find the visuals intersecting a region.
+        /// </summary>
+        /// <remarks>
+        /// <para>⚠️ This method is low-level and <b>DOES NOT respect <see cref="Input.InputElement.IsHitTestVisible"/></b>.</para>
+        /// <para>Use  <see cref="Input.InputExtensions"/> to perform input hit testing, or provide your own <paramref name="filter"/> function.</para>
+        /// </remarks>
+        /// <param name="geometry">The geometry, in coordinates relative to<paramref name="root"/></param>
+        /// <param name="root">The root of the subtree to search.</param>
+        /// <param name="filter">
+        /// A filter predicate. If the predicate returns false then the visual and all its
+        /// children will be excluded from the results.
+        /// </param>
+        /// <returns>The visuals intersecting the specified geometry, topmost first.</returns>
+        IEnumerable<GeometryHitTestResult> HitTest(Geometry geometry, Visual root, Func<Visual, bool> filter);
+
         /// <summary>
         /// Hit tests a location to find first visual at the specified point.
         /// </summary>
         /// <inheritdoc cref="HitTest(Point, Visual, Func{Visual, bool}?)"/>
         /// <returns>The visual at the specified point, topmost first.</returns>
         Visual? HitTestFirst(Point p, Visual root, Func<Visual, bool>? filter);
+
+        /// <summary>
+        /// Hit tests a geometry to find the visuals intersecting a region.
+        /// </summary>
+        /// <inheritdoc cref="HitTest(Geometry, Visual, Func{Visual, bool}?)"/>
+        /// <returns>The visuals intersecting the specified geometry, topmost first.</returns>
+        GeometryHitTestResult? HitTestFirst(Geometry geometry, Visual root, Func<Visual, bool>? filter);
     }
 }
diff --git a/src/Avalonia.Base/Rendering/SceneGraph/CustomDrawOperation.cs b/src/Avalonia.Base/Rendering/SceneGraph/CustomDrawOperation.cs
index a3ee957bbe..60714bdcc8 100644
--- a/src/Avalonia.Base/Rendering/SceneGraph/CustomDrawOperation.cs
+++ b/src/Avalonia.Base/Rendering/SceneGraph/CustomDrawOperation.cs
@@ -1,7 +1,5 @@
 using System;
-using Avalonia.Logging;
 using Avalonia.Media;
-using Avalonia.Platform;
 
 namespace Avalonia.Rendering.SceneGraph
 {
@@ -23,6 +21,20 @@ namespace Avalonia.Rendering.SceneGraph
         /// </remarks>
         bool HitTest(Point p);
 
+        /// <summary>
+        /// Hit test the geometry in this node.
+        /// </summary>
+        /// <param name="geometry">The geometry in global coordinates.</param>
+        /// <returns>The <see cref="IntersectionResult"/> describing the intersecting between the hit geometry and the node's geometry.</returns>
+        /// <remarks>
+        /// This method does not recurse to childs, if you want
+        /// to hit test children they must be hit tested manually.
+        /// </remarks>
+        IntersectionResult HitTest(Geometry geometry)
+        {
+            return IntersectionResult.Empty;
+        }
+
         /// <summary>
         /// Renders the node to a drawing context.
         /// </summary>
diff --git a/src/Avalonia.Base/VisualTree/VisualExtensions.cs b/src/Avalonia.Base/VisualTree/VisualExtensions.cs
index 2007d39f7d..9cc1d9e673 100644
--- a/src/Avalonia.Base/VisualTree/VisualExtensions.cs
+++ b/src/Avalonia.Base/VisualTree/VisualExtensions.cs
@@ -1,9 +1,8 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using Avalonia.Layout;
+using Avalonia.Media;
 using Avalonia.Platform;
 using Avalonia.Rendering;
 using Avalonia.Utilities;
@@ -319,6 +318,19 @@ namespace Avalonia.VisualTree
             return visual.GetVisualAt(p, x => x.IsVisible);
         }
 
+        /// <summary>
+        /// Gets the first visual in the visual tree whose bounds intersects a geometry.
+        /// </summary>
+        /// <param name="visual">The root visual to test.</param>
+        /// <param name="geometry">The geometry.</param>
+        /// <returns>A <see cref="GeometryHitTestResult"/> containing the visual intersecting the requested geometry and intersection details, or null if no intersection.</returns>
+        public static GeometryHitTestResult? GetVisualAt(this Visual visual, Geometry geometry)
+        {
+            ThrowHelper.ThrowIfNull(visual, nameof(visual));
+
+            return visual.GetVisualAt(geometry, x => x.IsVisible);
+        }
+
         /// <summary>
         /// Gets the first visual in the visual tree whose bounds contain a point.
         /// </summary>
@@ -342,6 +354,29 @@ namespace Avalonia.VisualTree
             return source.HitTester.HitTestFirst(p, visual, filter);
         }
 
+        /// <summary>
+        /// Gets the first visual in the visual tree whose bounds intersects a geometry.
+        /// </summary>
+        /// <param name="visual">The root visual to test.</param>
+        /// <param name="geometry">The geometry.</param>
+        /// <param name="filter">
+        /// A filter predicate. If the predicate returns false then the visual and all its
+        /// children will be excluded from the results.
+        /// </param>
+        /// <returns>A <see cref="GeometryHitTestResult"/> containing the visual intersecting the requested geometry and intersection details, or null if no intersection.</returns>
+        public static GeometryHitTestResult? GetVisualAt(this Visual visual, Geometry geometry, Func<Visual, bool> filter)
+        {
+            ThrowHelper.ThrowIfNull(visual, nameof(visual));
+
+            var source = visual.GetPresentationSource();
+            if (source is null)
+            {
+                return null;
+            }
+
+            return source.HitTester.HitTestFirst(geometry, visual, filter);
+        }
+
         /// <summary>
         /// Enumerates the visible visuals in the visual tree whose bounds contain a point.
         /// </summary>
@@ -357,6 +392,21 @@ namespace Avalonia.VisualTree
             return visual.GetVisualsAt(p, x => x.IsVisible);
         }
 
+        /// <summary>
+        /// Enumerates the visible visuals in the visual tree whose bounds intersects a geometry.
+        /// </summary>
+        /// <param name="visual">The root visual to test.</param>
+        /// <param name="geometry">The geometry.</param>
+        /// <returns>The visuals intersecting the requested geometry with intersection details.</returns>
+        public static IEnumerable<GeometryHitTestResult> GetVisualsAt(
+            this Visual visual,
+            Geometry geometry)
+        {
+            ThrowHelper.ThrowIfNull(visual, nameof(visual));
+
+            return visual.GetVisualsAt(geometry, x => x.IsVisible);
+        }
+
         /// <summary>
         /// Enumerates the visuals in the visual tree whose bounds contain a point.
         /// </summary>
@@ -384,6 +434,33 @@ namespace Avalonia.VisualTree
             return source.HitTester.HitTest(p, visual, filter);
         }
 
+        /// <summary>
+        /// Enumerates the visible visuals in the visual tree whose bounds intersects a geometry.
+        /// </summary>
+        /// <param name="visual">The root visual to test.</param>
+        /// <param name="geometry">The geometry.</param>
+        /// <param name="filter">
+        /// A filter predicate. If the predicate returns false then the visual and all its
+        /// children will be excluded from the results.
+        /// </param>
+        /// <returns>The visuals intersecting the requested geometry with intersection details.</returns>
+        public static IEnumerable<GeometryHitTestResult> GetVisualsAt(
+            this Visual visual,
+            Geometry geometry,
+            Func<Visual, bool> filter)
+        {
+            ThrowHelper.ThrowIfNull(visual, nameof(visual));
+
+            var source = visual.GetPresentationSource();
+
+            if (source is null)
+            {
+                return Array.Empty<GeometryHitTestResult>();
+            }
+
+            return source.HitTester.HitTest(geometry, visual, filter);
+        }
+
         /// <summary>
         /// Enumerates the children of an <see cref="Visual"/> in the visual tree.
         /// </summary>
diff --git a/src/Headless/Avalonia.Headless/HeadlessPlatformRenderInterface.cs b/src/Headless/Avalonia.Headless/HeadlessPlatformRenderInterface.cs
index 0d8114f7f5..9ea479d48d 100644
--- a/src/Headless/Avalonia.Headless/HeadlessPlatformRenderInterface.cs
+++ b/src/Headless/Avalonia.Headless/HeadlessPlatformRenderInterface.cs
@@ -4,6 +4,7 @@ using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
+using Avalonia.Layout;
 using Avalonia.Media;
 using Avalonia.Media.Imaging;
 using Avalonia.Media.TextFormatting;
@@ -43,7 +44,7 @@ namespace Avalonia.Headless
 
         public IGeometryImpl CreateRectangleGeometry(Rect rect)
         {
-            return new HeadlessGeometryStub(rect);
+            return new HeadlessRectangleGeometryContextStub(rect);
         }
 
         public IStreamGeometryImpl CreateStreamGeometry() => new HeadlessStreamingGeometryStub();
@@ -224,10 +225,32 @@ namespace Avalonia.Headless
                 segmentGeometry = null;
                 return false;
             }
+
+            public virtual IntersectionResult GetFillIntersectionResult(IGeometryImpl geometry)
+            {
+                var intersection = Intersect(geometry);
+
+                if (intersection?.Bounds.Size != new Size())
+                {
+                    var bounds = GetRenderBounds(null);
+                    var otherBounds = geometry.GetRenderBounds(null);
+
+                    if (bounds.Contains(otherBounds))
+                        return IntersectionResult.FullyContains;
+
+                    if (otherBounds.Contains(bounds))
+                        return IntersectionResult.FullyInside;
+
+                    return IntersectionResult.Intersects;
+                }
+
+                return IntersectionResult.Empty;
+            }
         }
 
-        private class HeadlessTransformedGeometryStub : HeadlessGeometryStub, ITransformedGeometryImpl
+        private class HeadlessTransformedGeometryStub : HeadlessGeometryStub, ITransformedGeometryImpl, IHeadlessGeometryWithEdges
         {
+            private List<Point>? _points;
             public HeadlessTransformedGeometryStub(IGeometryImpl b, Matrix transform) : this(Fix(b, transform))
             {
 
@@ -253,12 +276,103 @@ namespace Avalonia.Headless
 
             public IGeometryImpl SourceGeometry { get; }
             public Matrix Transform { get; }
+
+            public List<Point> Points
+            {
+                get
+                {
+                    if (SourceGeometry is IHeadlessGeometryWithEdges geometryWithEdges)
+                    {
+                        return _points ??= geometryWithEdges.Points.Select(x => x.Transform(Transform)).ToList();
+                    }
+
+                    return [];
+                }
+            }
+        }
+
+        private class HeadlessRectangleGeometryContextStub : HeadlessGeometryStub, IHeadlessGeometryWithEdges
+        {
+            private List<Point> _points = new List<Point>();
+            public HeadlessRectangleGeometryContextStub(Rect bounds) : base(bounds)
+            {
+                _points.Add(bounds.TopLeft);
+                _points.Add(bounds.TopRight);
+                _points.Add(bounds.BottomLeft);
+                _points.Add(bounds.BottomRight);
+            }
+
+            public List<Point> Points => _points;
+
+            public override IntersectionResult GetFillIntersectionResult(IGeometryImpl geometry)
+            {
+                if (geometry is IHeadlessGeometryWithEdges stub)
+                {
+                    var axes = (this as IHeadlessGeometryWithEdges).GetAxes();
+                    axes.AddRange(stub.GetAxes());
+
+                    foreach (var axis in axes)
+                    {
+                        var (min, max) = (this as IHeadlessGeometryWithEdges).ProjectionOnAxis(axis);
+                        var projection2 = stub.ProjectionOnAxis(axis);
+
+                        if (max < projection2.min || projection2.max < min)
+                            return IntersectionResult.Empty;
+                    }
+
+                    return IntersectionResult.Intersects;
+                }
+
+                return base.GetFillIntersectionResult(geometry);
+            }
+        }
+
+        internal interface IHeadlessGeometryWithEdges
+        {
+            List<Point> Points { get; }
+
+            public (double min, double max) ProjectionOnAxis(Vector axis)
+            {
+                double min = double.PositiveInfinity, max = double.NegativeInfinity;
+
+                foreach (var point in Points)
+                {
+                    var p = Vector.Dot(axis, new Vector(point.X, point.Y));
+
+                    if (p < min)
+                    {
+                        min = p;
+                    }
+
+                    if (p > max)
+                    {
+                        max = p;
+                    }
+                }
+
+                return (min, max);
+            }
+
+            public List<Vector> GetAxes()
+            {
+                List<Vector> axes = new List<Vector>();
+
+                for (var i = 0; i < Points.Count; i++)
+                {
+                    var point = Points[i];
+                    var otherPoint = Points[(i + i) % Points.Count];
+                    var edge = new Vector(point.X - otherPoint.X, point.Y - otherPoint.Y);
+                    axes.Add(new Vector(-edge.Y, edge.X));
+                }
+
+                return axes;
+            }
         }
 
         private class HeadlessStreamingGeometryStub : HeadlessGeometryStub, IStreamGeometryImpl
         {
             private HeadlessStreamingGeometryContextStub _context;
-            
+
             public HeadlessStreamingGeometryStub() : base(default)
             {
                 _context = new HeadlessStreamingGeometryContextStub(this);
@@ -279,10 +393,21 @@ namespace Avalonia.Headless
                 return _context.FillContains(point);
             }
 
-            private class HeadlessStreamingGeometryContextStub : IStreamGeometryContextImpl
+            public override IntersectionResult GetFillIntersectionResult(IGeometryImpl geometry)
+            {
+                if (geometry is IHeadlessGeometryWithEdges stub)
+                    return _context.FillContains(stub);
+
+                return base.GetFillIntersectionResult(geometry);
+            }
+
+            private class HeadlessStreamingGeometryContextStub : IStreamGeometryContextImpl, IHeadlessGeometryWithEdges
             {
                 private readonly HeadlessStreamingGeometryStub _parent;
-                private List<Point> points = new List<Point>();
+                private List<Point> _points = new List<Point>();
+
+                public List<Point> Points => _points;
+
                 public HeadlessStreamingGeometryContextStub(HeadlessStreamingGeometryStub parent)
                 {
                     _parent = parent;
@@ -290,7 +415,7 @@ namespace Avalonia.Headless
 
                 private void Track(Point pt)
                 {
-                    points.Add(pt);
+                    _points.Add(pt);
                 }
 
                 public Rect CalculateBounds()
@@ -300,7 +425,7 @@ namespace Avalonia.Headless
                     var top = double.MaxValue;
                     var bottom = double.MinValue;
 
-                    foreach (var p in points)
+                    foreach (var p in _points)
                     {
                         left = Math.Min(p.X, left);
                         right = Math.Max(p.X, right);
@@ -310,7 +435,7 @@ namespace Avalonia.Headless
 
                     return new Rect(new Point(left, top), new Point(right, bottom));
                 }
-                
+
                 public void Dispose()
                 {
                     _parent.Bounds = CalculateBounds();
@@ -345,16 +470,16 @@ namespace Avalonia.Headless
                 {
 
                 }
-                
+
                 public bool FillContains(Point point)
                 {
                     // Use the algorithm from https://www.blackpawn.com/texts/pointinpoly/default.html
                     // to determine if the point is in the geometry (since it will always be convex in this situation)
-                    for (int i = 0; i < points.Count; i++)
+                    for (int i = 0; i < _points.Count; i++)
                     {
-                        var a = points[i];
-                        var b = points[(i + 1) % points.Count];
-                        var c = points[(i + 2) % points.Count];
+                        var a = _points[i];
+                        var b = _points[(i + 1) % _points.Count];
+                        var c = _points[(i + 2) % _points.Count];
 
                         Vector v0 = c - a;
                         Vector v1 = b - a;
@@ -370,10 +495,28 @@ namespace Avalonia.Headless
                         var invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
                         var u = (dot11 * dot02 - dot01 * dot12) * invDenom;
                         var v = (dot00 * dot12 - dot01 * dot02) * invDenom;
-                        if ((u >= 0) && (v >= 0) && (u + v < 1)) return true;
+                        if ((u >= 0) && (v >= 0) && (u + v < 1))
+                            return true;
                     }
                     return false;
                 }
+
+                public IntersectionResult FillContains(IHeadlessGeometryWithEdges geometry)
+                {
+                    var axes = (this as IHeadlessGeometryWithEdges).GetAxes();
+                    axes.AddRange(geometry.GetAxes());
+
+                    foreach (var axis in axes)
+                    {
+                        var (min, max) = (this as IHeadlessGeometryWithEdges).ProjectionOnAxis(axis);
+                        var projection2 = geometry.ProjectionOnAxis(axis);
+
+                        if (max < projection2.min || projection2.max < min)
+                            return IntersectionResult.Empty;
+                    }
+
+                    return IntersectionResult.Intersects;
+                }
             }
         }
 
diff --git a/src/Skia/Avalonia.Skia/GeometryImpl.cs b/src/Skia/Avalonia.Skia/GeometryImpl.cs
index 7412ed72a7..c7c971911c 100644
--- a/src/Skia/Avalonia.Skia/GeometryImpl.cs
+++ b/src/Skia/Avalonia.Skia/GeometryImpl.cs
@@ -3,7 +3,6 @@ using System.Diagnostics.CodeAnalysis;
 using Avalonia.Media;
 using Avalonia.Platform;
 using Avalonia.Skia.Helpers;
-using Avalonia.Utilities;
 using SkiaSharp;
 
 namespace Avalonia.Skia
@@ -171,6 +170,28 @@ namespace Avalonia.Skia
             }
         }
 
+        /// <inheritdoc />
+        public IntersectionResult GetFillIntersectionResult(IGeometryImpl geometry)
+        {
+            var other = geometry as GeometryImpl;
+            if (other == null || FillPath == null || other.FillPath == null)
+                return IntersectionResult.Empty;
+
+            var region = new SKRegion(FillPath);
+            var otherRegion = new SKRegion(other.FillPath);
+
+            if(region.Contains(otherRegion))
+                return IntersectionResult.FullyInside;
+
+            if (otherRegion.Contains(region))
+                return IntersectionResult.FullyContains;
+
+            if (region.Intersects(otherRegion))
+                return IntersectionResult.Intersects;
+
+            return IntersectionResult.Empty;
+        }
+
         private struct PathCache : IDisposable
         {
             private int _penHash;
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/CompositorHitTestingTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/CompositorHitTestingTests.cs
index 9dbb446bdc..99827bbce3 100644
--- a/tests/Avalonia.Base.UnitTests/Rendering/CompositorHitTestingTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Rendering/CompositorHitTestingTests.cs
@@ -1,24 +1,18 @@
 using System;
 using System.Linq;
-using Avalonia.Base.UnitTests.VisualTree;
 using Avalonia.Controls;
 using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Shapes;
 using Avalonia.Layout;
 using Avalonia.Media;
-using Avalonia.Platform;
-using Avalonia.Rendering;
 using Avalonia.Rendering.Composition;
 using Avalonia.UnitTests;
-using Avalonia.VisualTree;
-using Moq;
 using Xunit;
 
 namespace Avalonia.Base.UnitTests.Rendering;
 
 public class CompositorHitTestingTests : CompositorTestsBase
 {
-
     [Fact]
     public void HitTest_Should_Find_Controls_At_Point()
     {
@@ -34,11 +28,31 @@ public class CompositorHitTestingTests : CompositorTestsBase
             };
 
             s.TopLevel.Content = border;
-            
+
             s.AssertHitTest(new Point(100, 100), null, border);
         }
     }
 
+    [Fact]
+    public void HitTest_Should_Find_Controls_At_Geometry()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            var border = new Border
+            {
+                Width = 100,
+                Height = 100,
+                Background = Brushes.Red,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center
+            };
+
+            s.TopLevel.Content = border;
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(100, 100, 50, 50)), null, new GeometryHitTestResult(border, IntersectionResult.FullyContains));
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Not_Find_Empty_Controls_At_Point()
     {
@@ -58,6 +72,25 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
 
+    [Fact]
+    public void HitTest_Should_Not_Find_Empty_Controls_At_Geometry()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            var border = new Border
+            {
+                Width = 100,
+                Height = 100,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center
+            };
+
+            s.TopLevel.Content = border;
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(100, 100, 50, 50)), null);
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Not_Find_Invisible_Controls_At_Point()
     {
@@ -83,7 +116,33 @@ public class CompositorHitTestingTests : CompositorTestsBase
             s.AssertHitTest(new Point(100, 100), null);
         }
     }
-    
+
+    [Fact]
+    public void HitTest_Should_Not_Find_Invisible_Controls_At_Geometry()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Border visible, border;
+            s.TopLevel.Content = border = new Border
+            {
+                Width = 100,
+                Height = 100,
+                Background = Brushes.Red,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center,
+                IsVisible = false,
+                Child = visible = new Border
+                {
+                    Background = Brushes.Red,
+                    HorizontalAlignment = HorizontalAlignment.Stretch,
+                    VerticalAlignment = VerticalAlignment.Stretch,
+                }
+            };
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(100, 100, 50, 50)), null);
+        }
+    }
+
     [Theory,
         InlineData(false, false),
         InlineData(true, false),
@@ -92,7 +151,7 @@ public class CompositorHitTestingTests : CompositorTestsBase
     ]
     public void HitTest_Should_Find_Zero_Opacity_Controls_At_Point(bool parent, bool child)
     {
-        
+
         using (var s = new CompositorTestServices(new Size(200, 200)))
         {
             Border visible, border;
@@ -116,7 +175,42 @@ public class CompositorHitTestingTests : CompositorTestsBase
             s.AssertHitTest(new Point(100, 100), null, visible, border);
         }
     }
-    
+
+    [Theory,
+        InlineData(false, false),
+        InlineData(true, false),
+        InlineData(false, true),
+        InlineData(true, true),
+    ]
+    public void HitTest_Should_Find_Zero_Opacity_Controls_At_Geometry(bool parent, bool child)
+    {
+
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Border visible, border;
+            s.TopLevel.Content = border = new Border
+            {
+                Width = 100,
+                Height = 100,
+                Background = Brushes.Red,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center,
+                Opacity = parent ? 0 : 1,
+                Child = visible = new Border
+                {
+                    Opacity = child ? 0 : 1,
+                    Background = Brushes.Red,
+                    HorizontalAlignment = HorizontalAlignment.Stretch,
+                    VerticalAlignment = VerticalAlignment.Stretch,
+                }
+            };
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(100, 100, 50, 50)), null,
+                new GeometryHitTestResult(visible, IntersectionResult.FullyContains),
+                new GeometryHitTestResult(border, IntersectionResult.FullyContains));
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Not_Find_Control_Outside_Point()
     {
@@ -137,6 +231,26 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
 
+    [Fact]
+    public void HitTest_Should_Not_Find_Control_Outside_Geometry()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            var border = new Border
+            {
+                Width = 100,
+                Height = 100,
+                Background = Brushes.Red,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center
+
+            };
+            s.TopLevel.Content = border;
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(10, 10, 10, 10)), null);
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Return_Top_Controls_First()
     {
@@ -172,6 +286,43 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
 
+    [Fact]
+    public void HitTest_Geometry_Should_Return_Top_Controls_First()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Panel container = new Panel
+            {
+                Width = 200,
+                Height = 200,
+                Children =
+                {
+                    new Border
+                    {
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Red,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        VerticalAlignment = VerticalAlignment.Center
+                    },
+                    new Border
+                    {
+                        Width = 50,
+                        Height = 50,
+                        Background = Brushes.Blue,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        VerticalAlignment = VerticalAlignment.Center
+                    }
+                }
+            };
+            s.TopLevel.Content = container;
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(100, 100, 50, 50)), null,
+                new GeometryHitTestResult(container.Children[1], IntersectionResult.Intersects),
+                new GeometryHitTestResult(container.Children[0], IntersectionResult.FullyContains));
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Return_Top_Controls_First_With_ZIndex()
     {
@@ -218,6 +369,54 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
 
+    [Fact]
+    public void HitTest_Geometry_Should_Return_Top_Controls_First_With_ZIndex()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Panel container = new Panel
+            {
+                Width = 200,
+                Height = 200,
+                Children =
+                {
+                    new Border
+                    {
+                        Width = 100,
+                        Height = 100,
+                        ZIndex = 1,
+                        Background = Brushes.Red,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        VerticalAlignment = VerticalAlignment.Center
+                    },
+                    new Border
+                    {
+                        Width = 50,
+                        Height = 50,
+                        Background = Brushes.Red,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        VerticalAlignment = VerticalAlignment.Center
+                    },
+                    new Border
+                    {
+                        Width = 75,
+                        Height = 75,
+                        ZIndex = 2,
+                        Background = Brushes.Red,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        VerticalAlignment = VerticalAlignment.Center
+                    }
+                }
+
+            };
+            s.TopLevel.Content = container;
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(100, 100, 50, 50)), null, new GeometryHitTestResult(container.Children[2], IntersectionResult.Intersects),
+                new GeometryHitTestResult(container.Children[0], IntersectionResult.FullyContains),
+                new GeometryHitTestResult(container.Children[1], IntersectionResult.Intersects));
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Find_Control_Translated_Outside_Parent_Bounds()
     {
@@ -258,6 +457,47 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
 
+    [Fact]
+    public void HitTest_Geometry_Find_Control_Translated_Outside_Parent_Bounds()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Border target;
+            Panel container = new Panel
+            {
+                Width = 200,
+                Height = 200,
+                Background = Brushes.Red,
+                ClipToBounds = false,
+                Children =
+                {
+                    new Border
+                    {
+                        Width = 100,
+                        Height = 100,
+                        ZIndex = 1,
+                        Background = Brushes.Red,
+                        HorizontalAlignment = HorizontalAlignment.Left,
+                        VerticalAlignment = VerticalAlignment.Top,
+                        Child = target = new Border
+                        {
+                            Width = 50,
+                            Height = 50,
+                            Background = Brushes.Red,
+                            HorizontalAlignment = HorizontalAlignment.Left,
+                            VerticalAlignment = VerticalAlignment.Top,
+                            RenderTransform = new TranslateTransform(110, 110),
+                        }
+                    },
+                }
+            };
+            s.TopLevel.Content = container;
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(120, 120, 50, 50)), null, new GeometryHitTestResult(target, IntersectionResult.Intersects),
+                new GeometryHitTestResult(container, IntersectionResult.FullyContains));
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Not_Find_Control_Outside_Parent_Bounds_When_Clipped()
     {
@@ -299,14 +539,11 @@ public class CompositorHitTestingTests : CompositorTestsBase
     }
 
     [Fact]
-    public void HitTest_Should_Not_Find_Control_Outside_Scroll_Viewport()
+    public void HitTest_Geometry_Should_Not_Find_Control_Outside_Parent_Bounds_When_Clipped()
     {
-        using (var s = new CompositorTestServices(new Size(100, 200)))
+        using (var s = new CompositorTestServices(new Size(200, 200)))
         {
             Border target;
-            Border item1;
-            Border item2;
-            ScrollContentPresenter scroll;
             Panel container = new Panel
             {
                 Width = 100,
@@ -314,30 +551,73 @@ public class CompositorHitTestingTests : CompositorTestsBase
                 Background = Brushes.Red,
                 Children =
                 {
-                    (target = new Border()
-                    {
-                        Name = "b1",
-                        Width = 100,
-                        Height = 100,
-                        Background = Brushes.Red,
-                    }),
-                    new Border()
+                    new Panel()
                     {
-                        Name = "b2",
                         Width = 100,
                         Height = 100,
                         Background = Brushes.Red,
                         Margin = new Thickness(0, 100, 0, 0),
-                        Child = scroll = new ScrollContentPresenter()
+                        ClipToBounds = true,
+                        Children =
                         {
-                            CanHorizontallyScroll = true,
-                            CanVerticallyScroll = true,
-                            Content = new StackPanel()
+                            (target = new Border()
                             {
-                                Children =
-                                {
-                                    (item1 = new Border()
-                                    {
+                                Width = 100,
+                                Height = 100,
+                                Background = Brushes.Red,
+                                Margin = new Thickness(0, -100, 0, 0)
+                            })
+                        }
+                    }
+                }
+
+            };
+            s.TopLevel.Content = container;
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(50, 50, 50, 50)), null, new GeometryHitTestResult(container, IntersectionResult.FullyContains));
+        }
+    }
+
+    [Fact]
+    public void HitTest_Should_Not_Find_Control_Outside_Scroll_Viewport()
+    {
+        using (var s = new CompositorTestServices(new Size(100, 200)))
+        {
+            Border target;
+            Border item1;
+            Border item2;
+            ScrollContentPresenter scroll;
+            Panel container = new Panel
+            {
+                Width = 100,
+                Height = 200,
+                Background = Brushes.Red,
+                Children =
+                {
+                    (target = new Border()
+                    {
+                        Name = "b1",
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Red,
+                    }),
+                    new Border()
+                    {
+                        Name = "b2",
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Red,
+                        Margin = new Thickness(0, 100, 0, 0),
+                        Child = scroll = new ScrollContentPresenter()
+                        {
+                            CanHorizontallyScroll = true,
+                            CanVerticallyScroll = true,
+                            Content = new StackPanel()
+                            {
+                                Children =
+                                {
+                                    (item1 = new Border()
+                                    {
                                         Name = "b3",
                                         Width = 100,
                                         Height = 100,
@@ -359,16 +639,90 @@ public class CompositorHitTestingTests : CompositorTestsBase
             s.TopLevel.Content = container;
 
             scroll.UpdateChild();
-            
+
             s.AssertHitTestFirst(new Point(50, 150), null, item1);
 
-            s.AssertHitTestFirst(new Point(50,50), null, target);
-            
+            s.AssertHitTestFirst(new Point(50, 50), null, target);
+
             scroll.Offset = new Vector(0, 100);
 
             s.AssertHitTestFirst(new Point(50, 150), null, item2);
-            
-            s.AssertHitTestFirst(new Point(50,50), null, target);
+
+            s.AssertHitTestFirst(new Point(50, 50), null, target);
+        }
+    }
+
+    [Fact]
+    public void HitTest_Geometry_Should_Not_Find_Control_Outside_Scroll_Viewport()
+    {
+        using (var s = new CompositorTestServices(new Size(100, 200)))
+        {
+            Border target;
+            Border item1;
+            Border item2;
+            ScrollContentPresenter scroll;
+            Panel container = new Panel
+            {
+                Width = 100,
+                Height = 200,
+                Background = Brushes.Red,
+                Children =
+                {
+                    (target = new Border()
+                    {
+                        Name = "b1",
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Red,
+                    }),
+                    new Border()
+                    {
+                        Name = "b2",
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Red,
+                        Margin = new Thickness(0, 100, 0, 0),
+                        Child = scroll = new ScrollContentPresenter()
+                        {
+                            CanHorizontallyScroll = true,
+                            CanVerticallyScroll = true,
+                            Content = new StackPanel()
+                            {
+                                Children =
+                                {
+                                    (item1 = new Border()
+                                    {
+                                        Name = "b3",
+                                        Width = 100,
+                                        Height = 100,
+                                        Background = Brushes.Red,
+                                    }),
+                                    (item2 = new Border()
+                                    {
+                                        Name = "b4",
+                                        Width = 100,
+                                        Height = 100,
+                                        Background = Brushes.Red,
+                                    }),
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+            s.TopLevel.Content = container;
+
+            scroll.UpdateChild();
+
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(50, 150, 50, 50)), null, item1);
+
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(50, 50, 50, 50)), null, target);
+
+            scroll.Offset = new Vector(0, 100);
+
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(50, 150, 50, 50)), null, item2);
+
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(50, 50, 50, 50)), null, target);
         }
     }
 
@@ -391,6 +745,25 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
 
+    [Fact]
+    public void HitTest_Geometry_Should_Not_Find_Path_When_Outside_Fill()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Path path = new Path
+            {
+                Width = 200,
+                Height = 200,
+                Fill = Brushes.Red,
+                Data = new RectangleGeometry(new Rect(50, 50, 100, 100))
+            };
+            s.TopLevel.Content = path;
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(95, 95, 50, 50)), null, new GeometryHitTestResult(path, IntersectionResult.FullyContains));
+            s.AssertHitTest(new RectangleGeometry(new Rect(0, 0, 10, 10)), null);
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Respect_Geometry_Clip()
     {
@@ -415,12 +788,43 @@ public class CompositorHitTestingTests : CompositorTestsBase
             s.RunJobs();
             Assert.Equal(new Rect(100, 100, 200, 200), border.Bounds);
 
-            s.AssertHitTest(new Point(200,200), null, canvas, border);
+            s.AssertHitTest(new Point(200, 200), null, canvas, border);
 
             s.AssertHitTest(new Point(110, 110), null);
         }
     }
 
+    [Fact]
+    public void HitTest_Geometry_Should_Respect_Geometry_Clip()
+    {
+        using (var s = new CompositorTestServices(new Size(400, 400)))
+        {
+            Canvas canvas;
+            Border border = new Border
+            {
+                Background = Brushes.Red,
+                Clip = StreamGeometry.Parse("M100,0 L0,100 100,100"),
+                Width = 200,
+                Height = 200,
+                Child = canvas = new Canvas
+                {
+                    Background = Brushes.Yellow,
+                    Margin = new Thickness(10),
+                }
+
+            };
+            s.TopLevel.Content = border;
+
+            s.RunJobs();
+            Assert.Equal(new Rect(100, 100, 200, 200), border.Bounds);
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(195, 195, 10, 10)), null, new GeometryHitTestResult(canvas, IntersectionResult.FullyContains),
+                new GeometryHitTestResult(border, IntersectionResult.FullyContains));
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(110, 110, 10, 10)), null);
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Accommodate_ICustomHitTest()
     {
@@ -437,13 +841,36 @@ public class CompositorHitTestingTests : CompositorTestsBase
             };
 
             s.TopLevel.Content = border;
-            
+
             s.AssertHitTest(75, 100, null, border);
             s.AssertHitTest(125, 100, null, border);
             s.AssertHitTest(175, 100, null);
         }
     }
-    
+
+    [Fact]
+    public void HitTest_Geometry_Should_Accommodate_ICustomHitTest()
+    {
+        using (var s = new CompositorTestServices(new Size(300, 200)))
+        {
+            Border border = new CustomHitTestBorder
+            {
+                ClipToBounds = false,
+                Width = 100,
+                Height = 100,
+                Background = Brushes.Red,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center
+            };
+
+            s.TopLevel.Content = border;
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(75, 100, 10, 10)), null, new GeometryHitTestResult(border, IntersectionResult.Intersects));
+            s.AssertHitTest(new RectangleGeometry(new Rect(125, 100, 10, 10)), null, new GeometryHitTestResult(border, IntersectionResult.Intersects));
+            s.AssertHitTest(new RectangleGeometry(new Rect(175, 100, 10, 10)), null);
+        }
+    }
+
     [Fact]
     public void Removing_ICustomHitTest_Child_Should_Restore_SubTree_Bounds_Optimization()
     {
@@ -499,12 +926,35 @@ public class CompositorHitTestingTests : CompositorTestsBase
             };
 
             s.TopLevel.Content = stackPanel;
-            
+
             s.AssertHitTest(new Point(5, 10), null, targetRectangle);
         }
     }
-    
-    
+
+    [Fact]
+    public void HitTest_Geometry_Should_Not_Hit_Controls_Next_Pixel()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Border targetRectangle;
+
+            var stackPanel = new StackPanel
+            {
+                Orientation = Orientation.Vertical,
+                HorizontalAlignment = HorizontalAlignment.Left,
+                Children =
+                {
+                    new Border { Width = 10, Height = 10, Background= Brushes.Red},
+                    { targetRectangle = new Border { Width = 10, Height = 10, Background = Brushes.Green, Name = "Target"} }
+                }
+            };
+
+            s.TopLevel.Content = stackPanel;
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(5, 10, 10, 10)), null, new GeometryHitTestResult(targetRectangle, IntersectionResult.Intersects));
+        }
+    }
+
     [Fact]
     public void HitTest_Filter_Should_Filter_Out_Children()
     {
@@ -531,6 +981,33 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
 
+    [Fact]
+    public void HitTest_Geometry_Filter_Should_Filter_Out_Children()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Border child, parent;
+            s.TopLevel.Content = parent = new Border
+            {
+                Width = 100,
+                Height = 100,
+                Background = Brushes.Red,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center,
+                Child = child = new Border
+                {
+                    Background = Brushes.Red,
+                    HorizontalAlignment = HorizontalAlignment.Stretch,
+                    VerticalAlignment = VerticalAlignment.Stretch,
+                }
+            };
+
+            s.AssertHitTest(new RectangleGeometry(new Rect(100, 100, 10, 10)), null, new GeometryHitTestResult(child, IntersectionResult.FullyContains),
+                new GeometryHitTestResult(parent, IntersectionResult.FullyContains));
+            s.AssertHitTest(new RectangleGeometry(new Rect(100, 100, 10, 10)), v => v != parent);
+        }
+    }
+
     [Fact]
     public void HitTestFirst_Should_Skip_Element_Child_Composition_Visual()
     {
@@ -556,18 +1033,42 @@ public class CompositorHitTestingTests : CompositorTestsBase
     }
 
     [Fact]
-    public void HitTest_Should_Find_Control_With_Many_Siblings()
+    public void HitTestFirst_Geometry_Should_Skip_Element_Child_Composition_Visual()
     {
-        using (var s = new CompositorTestServices(new Size(1000, 200)))
+        using (var s = new CompositorTestServices(new Size(200, 200)))
         {
-            Border target = null!;
-            var canvas = new Canvas { Width = 1000, Height = 200 };
-
-            for (var i = 0; i < 70; i++)
+            var target = new Border
             {
-                var child = new Border { Width = 8, Height = 8, Background = Brushes.Red };
-                Canvas.SetLeft(child, i * 12);
-                canvas.Children.Add(child);
+                Width = 200,
+                Height = 200,
+                Background = Brushes.Red
+            };
+
+            s.TopLevel.Content = target;
+            s.RunJobs();
+
+            var childVisual = s.Compositor.CreateSolidColorVisual();
+            childVisual.Size = new Vector(200, 200);
+            childVisual.Color = Colors.Blue;
+            ElementComposition.SetElementChildVisual(target, childVisual);
+
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(100, 100, 10, 10)), null, target);
+        }
+    }
+
+    [Fact]
+    public void HitTest_Should_Find_Control_With_Many_Siblings()
+    {
+        using (var s = new CompositorTestServices(new Size(1000, 200)))
+        {
+            Border target = null!;
+            var canvas = new Canvas { Width = 1000, Height = 200 };
+
+            for (var i = 0; i < 70; i++)
+            {
+                var child = new Border { Width = 8, Height = 8, Background = Brushes.Red };
+                Canvas.SetLeft(child, i * 12);
+                canvas.Children.Add(child);
 
                 if (i == 0)
                     target = child;
@@ -578,6 +1079,29 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
 
+    [Fact]
+    public void HitTest_Geometry_Should_Find_Control_With_Many_Siblings()
+    {
+        using (var s = new CompositorTestServices(new Size(1000, 200)))
+        {
+            Border target = null!;
+            var canvas = new Canvas { Width = 1000, Height = 200 };
+
+            for (var i = 0; i < 70; i++)
+            {
+                var child = new Border { Width = 8, Height = 8, Background = Brushes.Red, Name = $"{i}" };
+                Canvas.SetLeft(child, i * 12);
+                canvas.Children.Add(child);
+
+                if (i == 0)
+                    target = child;
+            }
+
+            s.TopLevel.Content = canvas;
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(4, 4, 2, 2)), null, target);
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Return_Top_Controls_First_With_Many_Overlapping_Siblings()
     {
@@ -603,6 +1127,31 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
 
+    [Fact]
+    public void HitTest_Geometry_Should_Return_Top_Controls_First_With_Many_Overlapping_Siblings()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Border top = null!;
+            var canvas = new Canvas { Width = 200, Height = 200 };
+
+            for (var i = 0; i < 70; i++)
+            {
+                var child = new Border { Width = 100, Height = 100, Background = Brushes.Red };
+                Canvas.SetLeft(child, 50);
+                Canvas.SetTop(child, 50);
+                canvas.Children.Add(child);
+
+                if (i == 69)
+                    top = child;
+            }
+
+            s.TopLevel.Content = canvas;
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(100, 100, 10, 10)), null, top);
+            s.AssertHitTest(new RectangleGeometry(new Rect(100, 100, 10, 10)), null, canvas.Children.Cast<Visual>().Reverse().Select(x => new GeometryHitTestResult(x, IntersectionResult.FullyContains)).ToArray());
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Update_Many_Sibling_Index_When_Child_Moves()
     {
@@ -630,6 +1179,33 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
 
+    [Fact]
+    public void HitTest_Geometry_Should_Update_Many_Sibling_Index_When_Child_Moves()
+    {
+        using (var s = new CompositorTestServices(new Size(1000, 200)))
+        {
+            Border moving = null!;
+            var canvas = new Canvas { Width = 1000, Height = 200 };
+
+            for (var i = 0; i < 70; i++)
+            {
+                var child = new Border { Width = 8, Height = 8, Background = Brushes.Red };
+                Canvas.SetLeft(child, i * 12);
+                canvas.Children.Add(child);
+
+                if (i == 69)
+                    moving = child;
+            }
+
+            s.TopLevel.Content = canvas;
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(69 * 12 + 4, 4, 2, 2)), null, moving);
+
+            Canvas.SetLeft(moving, 10);
+            Canvas.SetTop(moving, 100);
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(14, 104, 2, 2)), null, moving);
+        }
+    }
+
     [Fact]
     public void HitTest_Should_Update_Many_Sibling_Index_When_Child_Is_Added_And_Removed()
     {
@@ -664,9 +1240,258 @@ public class CompositorHitTestingTests : CompositorTestsBase
         }
     }
 
-    private static IDisposable TestApplication()
+    [Fact]
+    public void HitTest_Geometry_Should_Update_Many_Sibling_Index_When_Child_Is_Added_And_Removed()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Border top = null!;
+            var canvas = new Canvas { Width = 200, Height = 200 };
+
+            for (var i = 0; i < 70; i++)
+            {
+                var child = new Border { Width = 100, Height = 100, Background = Brushes.Red };
+                Canvas.SetLeft(child, 50);
+                Canvas.SetTop(child, 50);
+                canvas.Children.Add(child);
+
+                if (i == 69)
+                    top = child;
+            }
+
+            s.TopLevel.Content = canvas;
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(100, 100, 10, 10)), null, top);
+
+            var added = new Border { Width = 100, Height = 100, Background = Brushes.Blue };
+            Canvas.SetLeft(added, 50);
+            Canvas.SetTop(added, 50);
+            canvas.Children.Add(added);
+
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(100, 100, 10, 10)), null, added);
+
+            canvas.Children.Remove(added);
+            s.AssertHitTestFirst(new RectangleGeometry(new Rect(100, 100, 10, 10)), null, top);
+        }
+    }
+
+    [Fact]
+    public void HitTest_Geometry_Should_Find_Control_Within_Geometry_Bounds()
     {
-        return UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            var border = new Border
+            {
+                Width = 100,
+                Height = 100,
+                Background = Brushes.Red,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center
+            };
+
+            s.TopLevel.Content = border;
+            s.RunJobs();
+
+            var geometry = new RectangleGeometry { Rect = new Rect(80, 80, 40, 40) };
+            s.AssertHitTestFirst(geometry, null, border);
+        }
     }
 
+    [Fact]
+    public void HitTest_Geometry_Should_Not_Find_Control_Outside_Geometry_Bounds()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            var border = new Border
+            {
+                Width = 100,
+                Height = 100,
+                Background = Brushes.Red,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center
+            };
+
+            s.TopLevel.Content = border;
+            s.RunJobs();
+
+            var geometry = new RectangleGeometry { Rect = new Rect(10, 10, 30, 30) };
+            s.AssertHitTestFirst(geometry, null, null);
+        }
+    }
+
+    [Fact]
+    public void HitTest_Geometry_Should_Find_Multiple_Controls_Within_Bounds()
+    {
+        using (var s = new CompositorTestServices(new Size(300, 200)))
+        {
+            Panel container = new Panel
+            {
+                Width = 300,
+                Height = 200,
+                Children =
+                {
+                    new Border
+                    {
+                        Name = "border1",
+                        Width = 50,
+                        Height = 50,
+                        Background = Brushes.Red,
+                        HorizontalAlignment = HorizontalAlignment.Left,
+                        VerticalAlignment = VerticalAlignment.Top,
+                    },
+                    new Border
+                    {
+                        Name = "border2",
+                        Width = 50,
+                        Height = 50,
+                        Background = Brushes.Blue,
+                        HorizontalAlignment = HorizontalAlignment.Left,
+                        VerticalAlignment = VerticalAlignment.Center,
+                    }
+                }
+            };
+            s.TopLevel.Content = container;
+            s.RunJobs();
+
+            var geometry = new RectangleGeometry { Rect = new Rect(0, 0, 100, 200) };
+            s.AssertHitTestFirst(geometry, null, container.Children[1]);
+        }
+    }
+
+    [Fact]
+    public void HitTest_Geometry_Should_Respect_Control_Visibility()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            var border = new Border
+            {
+                Width = 100,
+                Height = 100,
+                Background = Brushes.Red,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center,
+                Child = new Border
+                {
+                    Background = Brushes.Blue,
+                    HorizontalAlignment = HorizontalAlignment.Stretch,
+                    VerticalAlignment = VerticalAlignment.Stretch,
+                    IsVisible = false
+                }
+            };
+            s.TopLevel.Content = border;
+
+            s.RunJobs();
+
+            var geometry = new RectangleGeometry { Rect = new Rect(50, 50, 100, 100) };
+            s.AssertHitTestFirst(geometry, null, border);
+        }
+    }
+
+    [Fact]
+    public void HitTest_Geometry_Should_Find_Top_Control_With_ZIndex()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Panel container = new Panel
+            {
+                Width = 200,
+                Height = 200,
+                Children =
+                {
+                    new Border
+                    {
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Red,
+                        ZIndex = 1,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        VerticalAlignment = VerticalAlignment.Center
+                    },
+                    new Border
+                    {
+                        Width = 100,
+                        Height = 100,
+                        Background = Brushes.Blue,
+                        ZIndex = 2,
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        VerticalAlignment = VerticalAlignment.Center,
+                        Margin = new Thickness(10)
+                    }
+                }
+            };
+            s.TopLevel.Content = container;
+            s.RunJobs();
+
+            var geometry = new RectangleGeometry { Rect = new Rect(50, 50, 100, 100) };
+            s.AssertHitTestFirst(geometry, null, container.Children[1]);
+        }
+    }
+
+    [Fact]
+    public void HitTest_Geometry_Should_Filter_Results()
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            Border parent, child;
+            s.TopLevel.Content = parent = new Border
+            {
+                Width = 100,
+                Height = 100,
+                Background = Brushes.Red,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center,
+                Child = child = new Border
+                {
+                    Background = Brushes.Blue,
+                    HorizontalAlignment = HorizontalAlignment.Stretch,
+                    VerticalAlignment = VerticalAlignment.Stretch,
+                }
+            };
+            s.RunJobs();
+
+            var geometry = new RectangleGeometry { Rect = new Rect(50, 50, 100, 100) };
+
+            s.AssertHitTestFirst(geometry, null, child);
+            s.AssertHitTestFirst(geometry, v => v != parent, null);
+            s.AssertHitTestFirst(geometry, v => v != child, parent);
+        }
+    }
+
+    [Theory]
+    [InlineData(50, 50, 100, 100, 50, 50, IntersectionResult.FullyInside)]
+    [InlineData(80, 80, 100, 100, 50, 50, IntersectionResult.Intersects)]
+    [InlineData(95, 95, 40, 40, 80, 80, IntersectionResult.FullyContains)]
+    [InlineData(0, 0, 10, 10, 50, 50, IntersectionResult.Empty)]
+    public void HitTest_Geometry_Should_Return_Correct_IntersectionResult(
+        double geomX, double geomY, double geomWidth, double geomHeight,
+        double elemWidth, double elemHeight, IntersectionResult expectedResult)
+    {
+        using (var s = new CompositorTestServices(new Size(200, 200)))
+        {
+            var border = new Border
+            {
+                Width = elemWidth,
+                Height = elemHeight,
+                Background = Brushes.Red,
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment = VerticalAlignment.Center
+            };
+
+            s.TopLevel.Content = border;
+            s.RunJobs();
+
+            var geometry = new RectangleGeometry(new Rect(geomX, geomY, geomWidth, geomHeight));
+            
+            if (expectedResult == IntersectionResult.Empty)
+            {
+                // Geometry doesn't intersect element
+                s.AssertHitTest(geometry, null);
+            }
+            else
+            {
+                // Geometry intersects element
+                s.AssertHitTest(geometry, null, 
+                    new GeometryHitTestResult(border, expectedResult));
+            }
+        }
+    }
 }
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/CustomHitTestBorder.cs b/tests/Avalonia.Base.UnitTests/Rendering/CustomHitTestBorder.cs
index d65df992be..1998a9c661 100644
--- a/tests/Avalonia.Base.UnitTests/Rendering/CustomHitTestBorder.cs
+++ b/tests/Avalonia.Base.UnitTests/Rendering/CustomHitTestBorder.cs
@@ -1,4 +1,5 @@
 using Avalonia.Controls;
+using Avalonia.Media;
 using Avalonia.Rendering;
 
 namespace Avalonia.Base.UnitTests.Rendering
@@ -11,5 +12,10 @@ namespace Avalonia.Base.UnitTests.Rendering
             return new Rect( -Bounds.Width / 2,0, Bounds.Width, Bounds.Height)
                 .Contains(point);
         }
+
+         public IntersectionResult HitTest(Geometry geometry)
+        {
+            return new RectangleGeometry(new Rect(-Bounds.Width / 2, 0, Bounds.Width, Bounds.Height)).GetFillIntersectionResult(geometry) ?? IntersectionResult.Empty;
+        }
     }
 }
diff --git a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
index a0ff9f2134..bcd4fdebd6 100644
--- a/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
@@ -126,7 +126,7 @@ namespace Avalonia.Base.UnitTests.Rendering.SceneGraph
                 ctx.Context.DrawGeometry(Brushes.Black, null, geometry.Object);
             }
 
-            Assert.False(ctx.Context.GetRenderResults()!.HitTest(default));
+            Assert.False(ctx.Context.GetRenderResults()!.HitTest(default(Point)));
         }
 
         [Fact]
diff --git a/tests/Avalonia.Base.UnitTests/VisualTree/VisualExtensions_GetVisualsAt.cs b/tests/Avalonia.Base.UnitTests/VisualTree/VisualExtensions_GetVisualsAt.cs
index 3f5cb9dd01..c6919cae10 100644
--- a/tests/Avalonia.Base.UnitTests/VisualTree/VisualExtensions_GetVisualsAt.cs
+++ b/tests/Avalonia.Base.UnitTests/VisualTree/VisualExtensions_GetVisualsAt.cs
@@ -50,6 +50,44 @@ namespace Avalonia.Base.UnitTests.VisualTree
 
         }
 
+        [Fact]
+        public void Should_Find_Control_With_Geometry()
+        {
+            Border target;
+            using var services = new CompositorTestServices(new Size(200, 200))
+            {
+                TopLevel =
+                {
+                    Content = new StackPanel
+                    {
+                        Background = null,
+                        Children =
+                        {
+                            (target = new Border
+                            {
+                                Width = 100,
+                                Height = 200,
+                                Background = Brushes.Red,
+                            }),
+                            new Border
+                            {
+                                Width = 100,
+                                Height = 200,
+                                Background = Brushes.Green,
+                            }
+                        },
+                        Orientation = Orientation.Horizontal,
+                    }
+                }
+            };
+
+            services.RunJobs();
+            var geo = new RectangleGeometry(target.Bounds);
+            var result = target.GetVisualsAt(geo);
+
+            Assert.Equal(new GeometryHitTestResult(target, IntersectionResult.FullyContains), result.Single());
+        }
+
         [Fact]
         public void Should_Not_Find_Sibling_Control()
         {
diff --git a/tests/Avalonia.RenderTests/TestRenderRoot.cs b/tests/Avalonia.RenderTests/TestRenderRoot.cs
index f4a0815e8a..6f63770647 100644
--- a/tests/Avalonia.RenderTests/TestRenderRoot.cs
+++ b/tests/Avalonia.RenderTests/TestRenderRoot.cs
@@ -1,5 +1,3 @@
-using Avalonia.Rendering;
-using System.Threading.Tasks;
 using System;
 using System.Collections.Generic;
 using Avalonia.Controls;
@@ -7,7 +5,9 @@ using Avalonia.Input;
 using Avalonia.Input.TextInput;
 using Avalonia.Layout;
 using Avalonia.LogicalTree;
+using Avalonia.Media;
 using Avalonia.Platform;
+using Avalonia.Rendering;
 using Avalonia.Rendering.Composition;
 
 
@@ -45,7 +45,11 @@ namespace Avalonia.Skia.RenderTests
         {
             public IEnumerable<Visual> HitTest(Point p, Visual root, Func<Visual, bool>? filter) => Array.Empty<Visual>();
 
+            public IEnumerable<GeometryHitTestResult> HitTest(Geometry geometry, Visual root, Func<Visual, bool> filter) => Array.Empty<GeometryHitTestResult>();
+
             public Visual? HitTestFirst(Point p, Visual root, Func<Visual, bool>? filter) => null;
+
+            public GeometryHitTestResult? HitTestFirst(Geometry geometry, Visual root, Func<Visual, bool>? filter) => null;
         }
 
         internal void Initialize(CompositingRenderer renderer, Control child)
diff --git a/tests/Avalonia.UnitTests/CompositorTestServices.cs b/tests/Avalonia.UnitTests/CompositorTestServices.cs
index 1ba03f5974..281c8d0cd2 100644
--- a/tests/Avalonia.UnitTests/CompositorTestServices.cs
+++ b/tests/Avalonia.UnitTests/CompositorTestServices.cs
@@ -9,6 +9,7 @@ using Avalonia.Controls.Templates;
 using Avalonia.Data;
 using Avalonia.Input;
 using Avalonia.Input.Raw;
+using Avalonia.Media;
 using Avalonia.Platform;
 using Avalonia.Platform.Surfaces;
 using Avalonia.Rendering;
@@ -107,6 +108,13 @@ public class CompositorTestServices : IDisposable
         Assert.Equal(expected, tested);
     }
 
+    public void AssertHitTest(Geometry geometry, Func<Visual, bool>? filter, params GeometryHitTestResult[] expected)
+    {
+        RunJobs();
+        var tested = Renderer.HitTest(geometry, TopLevel, filter);
+        Assert.Equal(expected, tested);
+    }
+
     public void AssertHitTestFirst(Point pt, Func<Visual, bool>? filter, Visual? expected)
     {
         RunJobs();
@@ -114,6 +122,13 @@ public class CompositorTestServices : IDisposable
         Assert.Equal(expected, tested);
     }
 
+    public void AssertHitTestFirst(Geometry geometry, Func<Visual, bool>? filter, Visual? expected)
+    {
+        RunJobs();
+        var tested = Renderer.HitTestFirst(geometry, TopLevel, filter);
+        Assert.Equal(expected, tested?.VisualHit);
+    }
+
     public class DebugEvents : ICompositionTargetDebugEvents
     {
         public List<Rect> Rects = new();
diff --git a/tests/Avalonia.UnitTests/TestRoot.cs b/tests/Avalonia.UnitTests/TestRoot.cs
index 18edafed0a..547d5f6c22 100644
--- a/tests/Avalonia.UnitTests/TestRoot.cs
+++ b/tests/Avalonia.UnitTests/TestRoot.cs
@@ -7,6 +7,7 @@ using Avalonia.Input;
 using Avalonia.Input.TextInput;
 using Avalonia.Layout;
 using Avalonia.LogicalTree;
+using Avalonia.Media;
 using Avalonia.Platform;
 using Avalonia.Rendering;
 using Avalonia.Styling;
@@ -30,11 +31,15 @@ namespace Avalonia.UnitTests
             SetPresentationSourceForRootVisual(this);
         }
 
-        class NullHitTester : IHitTester
+        class NullHitTester :  IHitTester
         {
             public IEnumerable<Visual> HitTest(Point p, Visual root, Func<Visual, bool>? filter) => Array.Empty<Visual>();
 
+            public IEnumerable<GeometryHitTestResult> HitTest(Geometry geometry, Visual root, Func<Visual, bool> filter) => Array.Empty<GeometryHitTestResult>();
+
             public Visual? HitTestFirst(Point p, Visual root, Func<Visual, bool>? filter) => null;
+
+            public GeometryHitTestResult? HitTestFirst(Geometry geometry, Visual root, Func<Visual, bool>? filter) => null;
         }
 
         public TestRoot(Control? child)

From 845b81d79433915a3acb469225824ba79a99297a Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Thu, 13 Aug 2026 17:58:48 +0000
Subject: [PATCH 164/196] remove legacy mono android trace debugging files
 (#21968)

---
 .../ControlCatalog.Android.csproj                      | 10 ----------
 samples/ControlCatalog.Android/environment.device.txt  |  1 -
 .../ControlCatalog.Android/environment.emulator.txt    |  1 -
 3 files changed, 12 deletions(-)
 delete mode 100644 samples/ControlCatalog.Android/environment.device.txt
 delete mode 100644 samples/ControlCatalog.Android/environment.emulator.txt

diff --git a/samples/ControlCatalog.Android/ControlCatalog.Android.csproj b/samples/ControlCatalog.Android/ControlCatalog.Android.csproj
index a630799c05..978eb361c4 100644
--- a/samples/ControlCatalog.Android/ControlCatalog.Android.csproj
+++ b/samples/ControlCatalog.Android/ControlCatalog.Android.csproj
@@ -14,16 +14,6 @@
     </AndroidResource>
   </ItemGroup>
 
-  <PropertyGroup Condition="'$(AndroidEnableProfiler)'=='True'">
-    <IsEmulator Condition="'$(IsEmulator)' == ''">True</IsEmulator>
-    <DebugSymbols>True</DebugSymbols>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <AndroidEnvironment Condition="'$(IsEmulator)'=='True'" Include="environment.emulator.txt" />
-    <AndroidEnvironment Condition="'$(IsEmulator)'!='True'" Include="environment.device.txt" />
-  </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="Xamarin.AndroidX.Core.SplashScreen" />
   </ItemGroup>
diff --git a/samples/ControlCatalog.Android/environment.device.txt b/samples/ControlCatalog.Android/environment.device.txt
deleted file mode 100644
index 107d68ca1b..0000000000
--- a/samples/ControlCatalog.Android/environment.device.txt
+++ /dev/null
@@ -1 +0,0 @@
-DOTNET_DiagnosticPorts=127.0.0.1:9000,suspend
diff --git a/samples/ControlCatalog.Android/environment.emulator.txt b/samples/ControlCatalog.Android/environment.emulator.txt
deleted file mode 100644
index 299a0ec30b..0000000000
--- a/samples/ControlCatalog.Android/environment.emulator.txt
+++ /dev/null
@@ -1 +0,0 @@
-DOTNET_DiagnosticPorts=10.0.2.2:9001,suspend

From fc61f42e3871ef01b8fb0553ad09ba841b4bff34 Mon Sep 17 00:00:00 2001
From: jp2masa <jp2masa@users.noreply.github.com>
Date: Fri, 14 Aug 2026 15:20:00 +0000
Subject: [PATCH 165/196] Improve StorageBookmarkHelper.TryDecodeBookmark.
 (#21977)

---
 .../Storage/FileIO/StorageBookmarkHelper.cs   | 21 +++++++++----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/Avalonia.Base/Platform/Storage/FileIO/StorageBookmarkHelper.cs b/src/Avalonia.Base/Platform/Storage/FileIO/StorageBookmarkHelper.cs
index 4c43331803..cafbfdfa25 100644
--- a/src/Avalonia.Base/Platform/Storage/FileIO/StorageBookmarkHelper.cs
+++ b/src/Avalonia.Base/Platform/Storage/FileIO/StorageBookmarkHelper.cs
@@ -86,20 +86,19 @@ internal static class StorageBookmarkHelper
 
         Span<byte> decodedBookmark;
 
-        // Each base64 character represents 6 bits, but to be safe, 
-        var arrayPool = ArrayPool<byte>.Shared.Rent(HeaderLength + base64bookmark.Length * 6);
-        if (Convert.TryFromBase64Chars(base64bookmark, arrayPool, out int bytesWritten))
-        {
-            decodedBookmark = arrayPool.AsSpan().Slice(0, bytesWritten);
-        }
-        else
-        {
-            nativeBookmark = null;
-            return DecodeResult.InvalidFormat;
-        }
+        var arrayPool = ArrayPool<byte>.Shared.Rent(HeaderLength + base64bookmark.Length / 4 * 3);
 
         try
         {
+            // Each base64 character represents 6 bits, but to be safe, 
+            if (!Convert.TryFromBase64Chars(base64bookmark, arrayPool, out int bytesWritten))
+            {
+                nativeBookmark = null;
+                return DecodeResult.InvalidFormat;
+            }
+
+            decodedBookmark = arrayPool.AsSpan(..bytesWritten);
+
             if (decodedBookmark.Length < HeaderLength
                 // Check if decoded string starts with the correct prefix, checking v1 at the same time.
                 && !AvaHeaderPrefix.SequenceEqual(decodedBookmark.Slice(0, AvaHeaderPrefix.Length)))

From 13f272d92816783a8c71df1bdb47889da756e05f Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Mon, 17 Aug 2026 07:30:35 +0000
Subject: [PATCH 166/196] Implement WindowDrawnDecorations.TitleBarDecorations
 (#21969)

* Implement WindowDrawnDecorations.TitleBarDecorations

* Add TitleBarDecorations sample to ControlCatalog
---
 samples/ControlCatalog/MainWindow.xaml        |  1 +
 .../Pages/WindowCustomizationsPage.xaml       | 59 +++++++++---
 samples/ControlCatalog/ScrollPage.xaml        |  2 +-
 .../ViewModels/MainWindowViewModel.cs         | 52 +++++++++++
 .../Chrome/TitleBarDecorations.cs             | 45 +++++++++
 .../Chrome/WindowDrawnDecorations.cs          | 59 ++++++++++--
 .../Controls/WindowDrawnDecorations.xaml      | 18 +++-
 .../Controls/WindowDrawnDecorations.xaml      | 18 +++-
 .../WindowTests.cs                            | 92 +++++++++++++++++++
 9 files changed, 320 insertions(+), 26 deletions(-)
 create mode 100644 src/Avalonia.Controls/Chrome/TitleBarDecorations.cs

diff --git a/samples/ControlCatalog/MainWindow.xaml b/samples/ControlCatalog/MainWindow.xaml
index d839689db7..308b29c572 100644
--- a/samples/ControlCatalog/MainWindow.xaml
+++ b/samples/ControlCatalog/MainWindow.xaml
@@ -12,6 +12,7 @@
         CanResize="{Binding CanResize}"
         CanMinimize="{Binding CanMinimize}"
         CanMaximize="{Binding CanMaximize}"
+        WindowDrawnDecorations.TitleBarDecorations="{Binding TitleBarDecorations}"
         Win32Properties.WindowCornerPreference="{Binding Win32WindowCornerPreference}"
         x:Class="ControlCatalog.MainWindow" WindowState="{Binding WindowState, Mode=TwoWay}"
         x:DataType="vm:MainWindowViewModel">
diff --git a/samples/ControlCatalog/Pages/WindowCustomizationsPage.xaml b/samples/ControlCatalog/Pages/WindowCustomizationsPage.xaml
index 5114dd16e9..f304f78898 100644
--- a/samples/ControlCatalog/Pages/WindowCustomizationsPage.xaml
+++ b/samples/ControlCatalog/Pages/WindowCustomizationsPage.xaml
@@ -9,28 +9,58 @@
              x:DataType="viewModels:MainWindowViewModel"
              x:CompileBindings="True"
              DataContext="{Binding $parent[Window].DataContext}">
-  <StackPanel>
+  <StackPanel Spacing="20">
 
     <StackPanel
-      Spacing="10"
-      Margin="25"
       IsEnabled="{OnFormFactor false, Desktop=true}">
 
-      <TextBlock Classes="h2"
+      <TextBlock Classes="h1"
                  Text="Desktop properties"
                  Margin="4" />
 
       <CheckBox Content="Extend Client Area to Decorations"
                 IsChecked="{Binding ExtendClientAreaEnabled}" />
 
-      <DockPanel IsEnabled="{Binding ExtendClientAreaEnabled}">
+      <StackPanel IsVisible="{Binding ExtendClientAreaEnabled}"
+                  Margin="28,0,0,0">
 
-        <Slider Minimum="-1"
-                Maximum="200"
-                Value="{Binding TitleBarHeight}"
-                Margin="8,-10" />
+        <Grid ColumnDefinitions="Auto,*,Auto">
 
-      </DockPanel>
+          <TextBlock Text="Height:"
+                     VerticalAlignment="Center"
+                     Grid.Column="0" />
+
+          <Slider Minimum="-1"
+                  Maximum="200"
+                  Value="{Binding TitleBarHeight}"
+                  TickFrequency="1"
+                  IsSnapToTickEnabled="True"
+                  Margin="8,-10"
+                  Grid.Column="1" />
+
+          <TextBlock Text="{Binding TitleBarHeight, StringFormat=F0}"
+                     MinWidth="50"
+                     VerticalAlignment="Center"
+                     Grid.Column="2" />
+
+        </Grid>
+
+        <CheckBox Content="Title"
+                  IsChecked="{Binding ShowTitle}" />
+
+        <CheckBox Content="Full Screen Button"
+                  IsChecked="{Binding ShowFullScreenButton}" />
+
+        <CheckBox Content="Minimize Button"
+                  IsChecked="{Binding ShowMinimizeButton}" />
+
+        <CheckBox Content="Maximize Button"
+                  IsChecked="{Binding ShowMaximizeButton}" />
+
+        <CheckBox Content="Close Button"
+                  IsChecked="{Binding ShowCloseButton}" />
+
+      </StackPanel>
 
       <CheckBox Content="Can Resize"
                 IsChecked="{Binding CanResize}" />
@@ -45,7 +75,7 @@
       <DockPanel>
 
         <Label Content="Corner Preference (Windows 11+): "
-               Margin="4"
+               Margin="0,4"
                DockPanel.Dock="Left" />
 
         <ComboBox ItemsSource="{Binding Win32WindowCornerPreferences}"
@@ -57,11 +87,12 @@
 
     </StackPanel>
 
-    <StackPanel Spacing="10" Margin="25" IsEnabled="{OnFormFactor false, Mobile=true}">
-      <TextBlock Classes="h2" Text="Mobile properties" Margin="4" />
+    <StackPanel IsEnabled="{OnFormFactor false, Mobile=true}">
+      <TextBlock Classes="h1" Text="Mobile properties" Margin="4" />
       <CheckBox Content="Is System Bar Visible" IsChecked="{Binding IsSystemBarVisible}" />
       <CheckBox Content="Display Edge To Edge" IsChecked="{Binding DisplayEdgeToEdge}" />
-      <TextBlock Text="{Binding SafeAreaPadding, StringFormat='Safe Area Padding: {0}'}" />
+      <TextBlock Text="{Binding SafeAreaPadding, StringFormat='Safe Area Padding: {0}'}"
+                 Margin="0,4" />
     </StackPanel>
 
   </StackPanel>
diff --git a/samples/ControlCatalog/ScrollPage.xaml b/samples/ControlCatalog/ScrollPage.xaml
index 6d5ecb815e..8c6157018f 100644
--- a/samples/ControlCatalog/ScrollPage.xaml
+++ b/samples/ControlCatalog/ScrollPage.xaml
@@ -15,7 +15,7 @@
                             HorizontalContentAlignment="Stretch"
                             IsVisible="False" />
 
-          <ScrollViewer Margin="20,20,5,0"
+          <ScrollViewer Padding="20"
             HorizontalScrollBarVisibility="Disabled">
             <ContentPresenter Name="PART_ContentPresenter"
                             HorizontalContentAlignment="{TemplateBinding HorizontalContentAlignment}"
diff --git a/samples/ControlCatalog/ViewModels/MainWindowViewModel.cs b/samples/ControlCatalog/ViewModels/MainWindowViewModel.cs
index 5d14cca1ee..445261950e 100644
--- a/samples/ControlCatalog/ViewModels/MainWindowViewModel.cs
+++ b/samples/ControlCatalog/ViewModels/MainWindowViewModel.cs
@@ -1,8 +1,10 @@
 using Avalonia.Controls;
 using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Controls.Chrome;
 using Avalonia.Dialogs;
 using System;
 using System.ComponentModel.DataAnnotations;
+using System.Runtime.CompilerServices;
 using Avalonia;
 using MiniMvvm;
 
@@ -122,6 +124,56 @@ namespace ControlCatalog.ViewModels
             set { RaiseAndSetIfChanged(ref _selectedDecorationIndex, value); }
         }
 
+        public TitleBarDecorations TitleBarDecorations
+        {
+            get;
+            set { RaiseAndSetIfChanged(ref field, value); }
+        } = TitleBarDecorations.All;
+
+        public bool ShowTitle
+        {
+            get => HasTitleBarDecoration(TitleBarDecorations.Title);
+            set => SetTitleBarDecoration(TitleBarDecorations.Title, value);
+        }
+
+        public bool ShowFullScreenButton
+        {
+            get => HasTitleBarDecoration(TitleBarDecorations.FullScreenButton);
+            set => SetTitleBarDecoration(TitleBarDecorations.FullScreenButton, value);
+        }
+
+        public bool ShowMinimizeButton
+        {
+            get => HasTitleBarDecoration(TitleBarDecorations.MinimizeButton);
+            set => SetTitleBarDecoration(TitleBarDecorations.MinimizeButton, value);
+        }
+
+        public bool ShowMaximizeButton
+        {
+            get => HasTitleBarDecoration(TitleBarDecorations.MaximizeButton);
+            set => SetTitleBarDecoration(TitleBarDecorations.MaximizeButton, value);
+        }
+
+        public bool ShowCloseButton
+        {
+            get => HasTitleBarDecoration(TitleBarDecorations.CloseButton);
+            set => SetTitleBarDecoration(TitleBarDecorations.CloseButton, value);
+        }
+
+        private bool HasTitleBarDecoration(TitleBarDecorations decoration)
+            => (TitleBarDecorations & decoration) != 0;
+
+        private void SetTitleBarDecoration(TitleBarDecorations decoration, bool value, [CallerMemberName] string? propertyName = null)
+        {
+            var newDecorations = value ? TitleBarDecorations | decoration : TitleBarDecorations & ~decoration;
+            if (newDecorations == TitleBarDecorations)
+                return;
+
+            TitleBarDecorations = newDecorations;
+            RaisePropertyChanged(propertyName);
+            RaisePropertyChanged(nameof(TitleBarDecorations));
+        }
+
         public MiniCommand AboutCommand { get; }
 
         public MiniCommand ExitCommand { get; }
diff --git a/src/Avalonia.Controls/Chrome/TitleBarDecorations.cs b/src/Avalonia.Controls/Chrome/TitleBarDecorations.cs
new file mode 100644
index 0000000000..dffa8c23d0
--- /dev/null
+++ b/src/Avalonia.Controls/Chrome/TitleBarDecorations.cs
@@ -0,0 +1,45 @@
+using System;
+
+namespace Avalonia.Controls.Chrome;
+
+/// <summary>
+/// Flags specifying which elements are displayed in a drawn window title bar of <see cref="WindowDrawnDecorations"/>.
+/// </summary>
+[Flags]
+public enum TitleBarDecorations
+{
+    /// <summary>
+    /// No title bar element is displayed.
+    /// </summary>
+    None = 0,
+
+    /// <summary>
+    /// The window title is displayed.
+    /// </summary>
+    Title = 1 << 0,
+
+    /// <summary>
+    /// The minimize button is displayed.
+    /// </summary>
+    MinimizeButton = 1 << 1,
+
+    /// <summary>
+    /// The maximize button is displayed.
+    /// </summary>
+    MaximizeButton = 1 << 2,
+
+    /// <summary>
+    /// The close button is displayed.
+    /// </summary>
+    CloseButton = 1 << 3,
+
+    /// <summary>
+    /// The full screen button is displayed.
+    /// </summary>
+    FullScreenButton = 1 << 4,
+
+    /// <summary>
+    /// All title bar elements are displayed.
+    /// </summary>
+    All = Title | MinimizeButton | MaximizeButton | CloseButton | FullScreenButton
+}
diff --git a/src/Avalonia.Controls/Chrome/WindowDrawnDecorations.cs b/src/Avalonia.Controls/Chrome/WindowDrawnDecorations.cs
index 26dffa8f5d..6cb17e59b9 100644
--- a/src/Avalonia.Controls/Chrome/WindowDrawnDecorations.cs
+++ b/src/Avalonia.Controls/Chrome/WindowDrawnDecorations.cs
@@ -17,7 +17,7 @@ namespace Avalonia.Controls.Chrome;
 /// and inserts them into its own visual tree.
 /// </summary>
 [PseudoClasses(pcNormal, pcMaximized, pcFullscreen, pcHasShadow, pcHasBorder, pcHasTitlebar,
-    pcHasMaximize, pcHasFullscreen, pcHasMinimize)]
+    pcHasMaximize, pcHasFullscreen, pcHasMinimize, pcHasClose, pcHasTitle)]
 [TemplatePart(PART_CloseButton, typeof(Button))]
 [TemplatePart(PART_MinimizeButton, typeof(Button))]
 [TemplatePart(PART_MaximizeButton, typeof(Button))]
@@ -36,6 +36,8 @@ public class WindowDrawnDecorations : StyledElement
     internal const string pcHasMaximize = ":has-maximize";
     internal const string pcHasFullscreen = ":has-fullscreen";
     internal const string pcHasMinimize = ":has-minimize";
+    internal const string pcHasClose = ":has-close";
+    internal const string pcHasTitle = ":has-title";
 
     // Template part names for caption buttons
     internal const string PART_CloseButton = "PART_CloseButton";
@@ -126,6 +128,13 @@ public class WindowDrawnDecorations : StyledElement
     public static readonly StyledProperty<string?> TitleProperty =
         AvaloniaProperty.Register<WindowDrawnDecorations, string?>(nameof(Title));
 
+    /// <summary>
+    /// Defines the TitleBarDecorations attached property.
+    /// </summary>
+    public static readonly AttachedProperty<TitleBarDecorations> TitleBarDecorationsProperty =
+        AvaloniaProperty.RegisterAttached<WindowDrawnDecorations, StyledElement, TitleBarDecorations>(
+            "TitleBarDecorations", TitleBarDecorations.All);
+
     /// <summary>
     /// Defines the <see cref="EnabledParts"/> property.
     /// </summary>
@@ -244,6 +253,7 @@ public class WindowDrawnDecorations : StyledElement
 
     /// <summary>
     /// Gets or sets the window title displayed in the decorations.
+    /// Mirrors the value set on the host <see cref="Window"/>.
     /// </summary>
     public string? Title
     {
@@ -251,6 +261,31 @@ public class WindowDrawnDecorations : StyledElement
         set => SetValue(TitleProperty, value);
     }
 
+    /// <summary>
+    /// Gets which title bar elements to display.
+    /// </summary>
+    public static TitleBarDecorations GetTitleBarDecorations(StyledElement element)
+        => element.GetValue(TitleBarDecorationsProperty);
+
+    /// <summary>
+    /// Sets which title bar elements to display.
+    /// </summary>
+    /// <remarks>
+    /// Set this property on a <see cref="Window"/> to control the elements displayed in its drawn title bar.
+    /// </remarks>
+    public static void SetTitleBarDecorations(StyledElement element, TitleBarDecorations value)
+        => element.SetValue(TitleBarDecorationsProperty, value);
+
+    /// <summary>
+    /// Gets or sets which title bar elements are requested to be displayed.
+    /// Mirrors the value set on the host <see cref="Window"/>.
+    /// </summary>
+    public TitleBarDecorations TitleBarDecorations
+    {
+        get => GetValue(TitleBarDecorationsProperty);
+        set => SetValue(TitleBarDecorationsProperty, value);
+    }
+
     /// <summary>
     /// Gets or sets which decoration parts are enabled.
     /// Set by Window based on platform capabilities and user preferences.
@@ -334,6 +369,7 @@ public class WindowDrawnDecorations : StyledElement
             x.UpdateEffectiveGeometry();
         });
 
+        TitleBarDecorationsProperty.Changed.AddClassHandler<WindowDrawnDecorations>((x, _) => x.UpdateTitleBarDecorationsPseudoClasses());
         DefaultTitleBarHeightProperty.Changed.AddClassHandler<WindowDrawnDecorations>((x, _) => x.UpdateEffectiveGeometry());
         DefaultFrameThicknessProperty.Changed.AddClassHandler<WindowDrawnDecorations>((x, _) => x.UpdateEffectiveGeometry());
         DefaultShadowThicknessProperty.Changed.AddClassHandler<WindowDrawnDecorations>((x, _) => x.UpdateEffectiveGeometry());
@@ -395,6 +431,8 @@ public class WindowDrawnDecorations : StyledElement
             Disposable.Create(() => window.AllowedWindowActionsChanged -= OnAllowedWindowActionsChanged),
             window.GetObservable(Window.TitleProperty)
                 .Subscribe(title => SetCurrentValue(TitleProperty, title)),
+            window.GetObservable(TitleBarDecorationsProperty)
+                .Subscribe(hints => SetCurrentValue(TitleBarDecorationsProperty, hints)),
             window.GetObservable(Window.CanMaximizeProperty)
                 .Subscribe(_ =>
                 {
@@ -415,7 +453,7 @@ public class WindowDrawnDecorations : StyledElement
                 }),
         };
 
-        UpdateAllowedActionsPseudoClasses();
+        UpdateTitleBarDecorationsPseudoClasses();
         UpdateMaximizeButtonState();
         UpdateMinimizeButtonState();
         UpdateFullScreenButtonState();
@@ -592,18 +630,25 @@ public class WindowDrawnDecorations : StyledElement
 
     private void OnAllowedWindowActionsChanged(PlatformAllowedWindowActions actions)
     {
-        UpdateAllowedActionsPseudoClasses();
+        UpdateTitleBarDecorationsPseudoClasses();
         UpdateMaximizeButtonState();
         UpdateMinimizeButtonState();
         UpdateFullScreenButtonState();
     }
 
-    private void UpdateAllowedActionsPseudoClasses()
+    private void UpdateTitleBarDecorationsPseudoClasses()
     {
         var actions = EffectiveAllowedActions;
-        PseudoClasses.Set(pcHasMaximize, actions.HasFlag(PlatformAllowedWindowActions.Maximize));
-        PseudoClasses.Set(pcHasFullscreen, actions.HasFlag(PlatformAllowedWindowActions.Fullscreen));
-        PseudoClasses.Set(pcHasMinimize, actions.HasFlag(PlatformAllowedWindowActions.Minimize));
+        var hints = TitleBarDecorations;
+
+        PseudoClasses.Set(pcHasMaximize, actions.HasFlag(PlatformAllowedWindowActions.Maximize)
+                                         && hints.HasFlag(TitleBarDecorations.MaximizeButton));
+        PseudoClasses.Set(pcHasFullscreen, actions.HasFlag(PlatformAllowedWindowActions.Fullscreen)
+                                           && hints.HasFlag(TitleBarDecorations.FullScreenButton));
+        PseudoClasses.Set(pcHasMinimize, actions.HasFlag(PlatformAllowedWindowActions.Minimize)
+                                         && hints.HasFlag(TitleBarDecorations.MinimizeButton));
+        PseudoClasses.Set(pcHasClose, hints.HasFlag(TitleBarDecorations.CloseButton));
+        PseudoClasses.Set(pcHasTitle, hints.HasFlag(TitleBarDecorations.Title));
     }
 
     private void UpdateEffectiveGeometry()
diff --git a/src/Avalonia.Themes.Fluent/Controls/WindowDrawnDecorations.xaml b/src/Avalonia.Themes.Fluent/Controls/WindowDrawnDecorations.xaml
index d9af9faf79..2c4969f212 100644
--- a/src/Avalonia.Themes.Fluent/Controls/WindowDrawnDecorations.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/WindowDrawnDecorations.xaml
@@ -128,7 +128,8 @@
                    VerticalAlignment="Top"
                    Background="{DynamicResource SystemControlBackgroundChromeMediumLowBrush}"
                    WindowDecorationProperties.ElementRole="TitleBar">
-              <TextBlock Text="{TemplateBinding Title}"
+              <TextBlock x:Name="PART_PopoverTitleText"
+                         Text="{TemplateBinding Title}"
                          VerticalAlignment="Center"
                          Margin="12,0,0,0"
                          FontSize="12" />
@@ -196,7 +197,8 @@
       <Setter Property="Opacity" Value="0.2"/>
     </Style>
 
-    <!-- Hide caption buttons when the platform does not support the action -->
+    <!-- Hide title bar elements when the platform does not support the action
+         or when they aren't requested by WindowDrawnDecorations.TitleBarDecorationHints -->
     <Style Selector="^:not(:has-minimize) /template/ Button#PART_MinimizeButton">
       <Setter Property="IsVisible" Value="False"/>
     </Style>
@@ -209,6 +211,18 @@
     <Style Selector="^:not(:has-fullscreen) /template/ Button#PART_PopoverFullScreenButton">
       <Setter Property="IsVisible" Value="False"/>
     </Style>
+    <Style Selector="^:not(:has-close) /template/ Button#PART_CloseButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:not(:has-close) /template/ Button#PART_PopoverCloseButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:not(:has-title) /template/ Panel#PART_TitleTextPanel">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:not(:has-title) /template/ TextBlock#PART_PopoverTitleText">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
 
     <!-- Fullscreen: hide overlay and titlebar (popover takes over) -->
     <Style Selector="^:fullscreen /template/ Panel#PART_TitleTextPanel">
diff --git a/src/Avalonia.Themes.Simple/Controls/WindowDrawnDecorations.xaml b/src/Avalonia.Themes.Simple/Controls/WindowDrawnDecorations.xaml
index 3d76f8b277..acfba2e23e 100644
--- a/src/Avalonia.Themes.Simple/Controls/WindowDrawnDecorations.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/WindowDrawnDecorations.xaml
@@ -131,7 +131,8 @@
                    VerticalAlignment="Top"
                    Background="{DynamicResource ThemeAccentBrush}"
                    WindowDecorationProperties.ElementRole="TitleBar">
-              <TextBlock Text="{TemplateBinding Title}"
+              <TextBlock x:Name="PART_PopoverTitleText"
+                         Text="{TemplateBinding Title}"
                          VerticalAlignment="Center"
                          Foreground="White"
                          Margin="12,0,0,0"
@@ -202,7 +203,8 @@
       <Setter Property="Opacity" Value="0.2"/>
     </Style>
 
-    <!-- Hide caption buttons when the platform does not support the action -->
+    <!-- Hide title bar elements when the platform does not support the action
+         or when they aren't requested by WindowDrawnDecorations.TitleBarDecorationHints -->
     <Style Selector="^:not(:has-minimize) /template/ Button#PART_MinimizeButton">
       <Setter Property="IsVisible" Value="False"/>
     </Style>
@@ -215,6 +217,18 @@
     <Style Selector="^:not(:has-fullscreen) /template/ Button#PART_PopoverFullScreenButton">
       <Setter Property="IsVisible" Value="False"/>
     </Style>
+    <Style Selector="^:not(:has-close) /template/ Button#PART_CloseButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:not(:has-close) /template/ Button#PART_PopoverCloseButton">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:not(:has-title) /template/ Panel#PART_TitleTextPanel">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
+    <Style Selector="^:not(:has-title) /template/ TextBlock#PART_PopoverTitleText">
+      <Setter Property="IsVisible" Value="False"/>
+    </Style>
 
     <!-- Fullscreen: hide overlay and titlebar (popover takes over) -->
     <Style Selector="^:fullscreen /template/ Panel#PART_TitleTextPanel">
diff --git a/tests/Avalonia.Controls.UnitTests/WindowTests.cs b/tests/Avalonia.Controls.UnitTests/WindowTests.cs
index 646dad30ec..ebd07d2596 100644
--- a/tests/Avalonia.Controls.UnitTests/WindowTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/WindowTests.cs
@@ -1642,6 +1642,98 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        public class TitleBarDecorationsTests : ScopedTestBase
+        {
+            private static Window CreateWindowWithDrawnDecorations(PlatformAllowedWindowActions allowedActions = PlatformAllowedWindowActions.All)
+            {
+                var windowImpl = MockWindowingPlatform.CreateWindowMock();
+                windowImpl.Setup(x => x.NeedsManagedDecorations).Returns(true);
+                windowImpl.Setup(x => x.RequestedDrawnDecorations).Returns(
+                    PlatformRequestedDrawnDecoration.TitleBar | PlatformRequestedDrawnDecoration.Border);
+                windowImpl.Setup(x => x.AllowedWindowActions).Returns(allowedActions);
+
+                return new Window(windowImpl.Object);
+            }
+
+            private static void AssertClassDecorations(WindowDrawnDecorations drawnDecorations, TitleBarDecorations expected)
+            {
+                AssertClassDecoration(TitleBarDecorations.Title, ":has-title");
+                AssertClassDecoration(TitleBarDecorations.MinimizeButton, ":has-minimize");
+                AssertClassDecoration(TitleBarDecorations.MaximizeButton, ":has-maximize");
+                AssertClassDecoration(TitleBarDecorations.CloseButton, ":has-close");
+                AssertClassDecoration(TitleBarDecorations.FullScreenButton, ":has-fullscreen");
+
+                void AssertClassDecoration(TitleBarDecorations decoration, string className)
+                    => Assert.Equal(expected.HasFlag(decoration), drawnDecorations.Classes.Contains(className));
+            }
+
+            [Fact]
+            public void All_Decorations_Should_Be_Visible_By_Default()
+            {
+                using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+                var window = CreateWindowWithDrawnDecorations();
+                window.Show();
+
+                var decorations = window.TopLevelHost.Decorations;
+                Assert.NotNull(decorations);
+                Assert.Equal(TitleBarDecorations.All, decorations.TitleBarDecorations);
+                AssertClassDecorations(decorations, TitleBarDecorations.All);
+            }
+
+            [Fact]
+            public void Decorations_Set_Before_Show_Should_Apply_Correct_Classes()
+            {
+                using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+                const TitleBarDecorations decorations = TitleBarDecorations.Title | TitleBarDecorations.CloseButton;
+
+                var window = CreateWindowWithDrawnDecorations();
+                WindowDrawnDecorations.SetTitleBarDecorations(window, decorations);
+                window.Show();
+
+                var drawnDecorations = window.TopLevelHost.Decorations;
+                Assert.NotNull(drawnDecorations);
+                Assert.Equal(decorations, drawnDecorations.TitleBarDecorations);
+                AssertClassDecorations(drawnDecorations, decorations);
+            }
+
+            [Fact]
+            public void Decorations_Set_After_Show_Should_Apply_Correct_Classes()
+            {
+                using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+                var window = CreateWindowWithDrawnDecorations();
+                window.Show();
+
+                var drawnDecorations = window.TopLevelHost.Decorations;
+                Assert.NotNull(drawnDecorations);
+
+                WindowDrawnDecorations.SetTitleBarDecorations(window, TitleBarDecorations.None);
+                AssertClassDecorations(drawnDecorations, TitleBarDecorations.None);
+
+                WindowDrawnDecorations.SetTitleBarDecorations(window, TitleBarDecorations.MinimizeButton);
+                AssertClassDecorations(drawnDecorations, TitleBarDecorations.MinimizeButton);
+            }
+
+            [Fact]
+            public void Decorations_Should_Not_Show_Buttons_Unsupported_By_The_Platform()
+            {
+                using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+                var window = CreateWindowWithDrawnDecorations(PlatformAllowedWindowActions.Minimize);
+                window.Show();
+
+                var decorations = window.TopLevelHost.Decorations;
+                Assert.NotNull(decorations);
+
+                // Maximize and fullscreen are requested, but not allowed by the platform.
+                AssertClassDecorations(
+                    decorations,
+                    TitleBarDecorations.Title | TitleBarDecorations.MinimizeButton | TitleBarDecorations.CloseButton);
+            }
+        }
+
         private class TopmostWindow : Window
         {
             static TopmostWindow()

From fdd1c09bfd37947b41cb00dab17fba56658cb582 Mon Sep 17 00:00:00 2001
From: "smaicas (@cdcsharp)" <86880991+smaicas@users.noreply.github.com>
Date: Mon, 17 Aug 2026 08:03:15 +0000
Subject: [PATCH 167/196] Update TabbedPage.xaml color resources (#21994)

---
 src/Avalonia.Themes.Simple/Controls/TabbedPage.xaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Avalonia.Themes.Simple/Controls/TabbedPage.xaml b/src/Avalonia.Themes.Simple/Controls/TabbedPage.xaml
index c18e57581c..578dc46986 100644
--- a/src/Avalonia.Themes.Simple/Controls/TabbedPage.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/TabbedPage.xaml
@@ -15,9 +15,9 @@
 
   <SolidColorBrush x:Key="TabbedPageTabItemHeaderBackgroundUnselected" Color="Transparent" />
   <SolidColorBrush x:Key="TabbedPageTabItemHeaderBackgroundSelected" Color="Transparent" />
-  <SolidColorBrush x:Key="TabbedPageTabItemHeaderBackgroundUnselectedPointerOver" Color="{DynamicResource ThemeControlMidBrush}" />
+  <SolidColorBrush x:Key="TabbedPageTabItemHeaderBackgroundUnselectedPointerOver" Color="{DynamicResource ThemeControlMidColor}" />
   <SolidColorBrush x:Key="TabbedPageTabItemHeaderBackgroundSelectedPointerOver" Color="Transparent" />
-  <SolidColorBrush x:Key="TabbedPageTabItemHeaderBackgroundUnselectedPressed" Color="{DynamicResource ThemeControlHighlightMidBrush}" />
+  <SolidColorBrush x:Key="TabbedPageTabItemHeaderBackgroundUnselectedPressed" Color="{DynamicResource ThemeControlHighlightMidColor}" />
   <SolidColorBrush x:Key="TabbedPageTabItemHeaderBackgroundSelectedPressed" Color="Transparent" />
   <SolidColorBrush x:Key="TabbedPageTabItemHeaderBackgroundDisabled" Color="Transparent" />
 

From f04cdabd1ea0cf255ddb583775ce19f84e642ab2 Mon Sep 17 00:00:00 2001
From: Juster Zhu <zhuzhen723723@163.com>
Date: Mon, 17 Aug 2026 09:25:32 +0000
Subject: [PATCH 168/196] Fix malformed markdown link for Avalonia XPF in
 readme (#21995)

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 9ed6c59f90..e291498703 100644
--- a/readme.md
+++ b/readme.md
@@ -10,7 +10,7 @@
 
 Considered by many to be the spiritual successor to WPF, Avalonia UI provides a familiar, modern development experience for XAML developers creating cross-platform applications. While Avalonia UI is [similar to WPF](https://docs.avaloniaui.net/docs/next/get-started/wpf/), it isn't a 1:1 copy, and you'll find plenty of improvements. 
 
-For those seeking a cross-platform WPF, we have created [Avalonia XPF]([https://avaloniaui.net/xpf](https://avaloniaui.net/xpf?utm_source=github&utm_medium=referral&utm_content=readme_link)), enabling WPF applications to run on macOS and Linux with little to no code changes. Avalonia XPF is a commercial product and is licensed per-app, per-platform. 
+For those seeking a cross-platform WPF, we have created [Avalonia XPF](https://avaloniaui.net/xpf?utm_source=github&utm_medium=referral&utm_content=readme_link), enabling WPF applications to run on macOS and Linux with little to no code changes. Avalonia XPF is a commercial product and is licensed per-app, per-platform. 
 
 ### Blog
 To see the latest announcements and read about the state of Avalonia, check out the [Avalonia UI Blog](https://www.avaloniaui.net/blog?utm_source=github&utm_medium=referral&utm_content=readme_link).

From 652131ce0dbe2b7e2257cf2c623167f1dfff2379 Mon Sep 17 00:00:00 2001
From: lfeng <lfeng1420@hotmail.com>
Date: Mon, 17 Aug 2026 10:00:23 +0000
Subject: [PATCH 169/196] [Android] Fix
 TryGetFileFromPathAsync/TryGetFolderFromPathAsync returning null for
 content:// URI (#21986)

* [Android] Fix TryGetFileFromPathAsync/TryGetFolderFromPathAsync returning null for content:// URI

* [Android] Add URI scheme constants in AndroidStorageProvider
---
 Directory.Packages.props                      |  1 +
 .../Avalonia.Android/Avalonia.Android.csproj  |  1 +
 .../Storage/AndroidStorageProvider.cs         | 67 +++++++++++++++++--
 3 files changed, 63 insertions(+), 6 deletions(-)

diff --git a/Directory.Packages.props b/Directory.Packages.props
index d38cb33b28..983d369fab 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -69,6 +69,7 @@
     <PackageVersion Include="Tmds.DBus.Generator" Version="0.94.1" />
     <PackageVersion Include="Xamarin.AndroidX.AppCompat" Version="1.7.1.3" />
     <PackageVersion Include="Xamarin.AndroidX.Core.SplashScreen" Version="1.2.0.2" />
+    <PackageVersion Include="Xamarin.AndroidX.DocumentFile" Version="1.1.0.3" />
     <PackageVersion Include="Xamarin.AndroidX.Window" Version="1.5.1.2" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
     <PackageVersion Include="Xunit.StaFact" Version="3.0.13" />
diff --git a/src/Android/Avalonia.Android/Avalonia.Android.csproj b/src/Android/Avalonia.Android/Avalonia.Android.csproj
index befdcbcd5e..e22990d18c 100644
--- a/src/Android/Avalonia.Android/Avalonia.Android.csproj
+++ b/src/Android/Avalonia.Android/Avalonia.Android.csproj
@@ -12,6 +12,7 @@
     <ProjectReference Include="..\..\..\packages\Avalonia\Avalonia.csproj" />
     <PackageReference Include="Xamarin.AndroidX.AppCompat" />
     <PackageReference Include="Xamarin.AndroidX.Window" />
+    <PackageReference Include="Xamarin.AndroidX.DocumentFile" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\Avalonia.Base\Avalonia.Base.csproj" />
diff --git a/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs b/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
index e55689f93d..66e56f3d6b 100644
--- a/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
+++ b/src/Android/Avalonia.Android/Platform/Storage/AndroidStorageProvider.cs
@@ -7,6 +7,7 @@ using Android;
 using Android.App;
 using Android.Content;
 using Android.Provider;
+using AndroidX.DocumentFile.Provider;
 using Avalonia.Platform.Storage;
 using Avalonia.Platform.Storage.FileIO;
 using AndroidUri = Android.Net.Uri;
@@ -18,6 +19,8 @@ namespace Avalonia.Android.Platform.Storage;
 internal class AndroidStorageProvider : IStorageProvider
 {
     public static ReadOnlySpan<byte> AndroidKey => "android"u8;
+    private const string ContentUriScheme = "content";
+    private const string FileUriScheme = "file";
     private readonly Activity _activity;
 
     public AndroidStorageProvider(Activity activity)
@@ -62,10 +65,29 @@ internal class AndroidStorageProvider : IStorageProvider
         //     to read or write files in your application-specific directories [...]"
         // Consequently, we don't try to check for that permission here anymore.
 
-        var javaFile = new JavaFile(androidUriPath);
-        if (javaFile.Exists() && javaFile.IsFile)
+        if (filePath.Scheme == FileUriScheme && androidUri.Path is not null)
         {
-            return new BclStorageFile(new System.IO.FileInfo(javaFile.AbsolutePath));
+            var javaFile = new JavaFile(androidUri.Path);
+            if (javaFile.Exists() && javaFile.IsFile)
+            {
+                return new BclStorageFile(new System.IO.FileInfo(javaFile.AbsolutePath));
+            }
+            return null;
+        }
+        else if (filePath.Scheme == ContentUriScheme && _activity.ContentResolver is not null)
+        {
+            try
+            {
+                using var stream = _activity.ContentResolver.OpenInputStream(androidUri);
+                if (stream is not null)
+                {
+                    return new AndroidStorageFile(_activity, androidUri);
+                }
+            }
+            catch (Exception)
+            {
+                return null;
+            }
         }
 
         return null;
@@ -89,10 +111,43 @@ internal class AndroidStorageProvider : IStorageProvider
             return null;
         }
 
-        var javaFile = new JavaFile(androidUriPath);
-        if (javaFile.Exists() && javaFile.IsDirectory)
+        if (folderPath.Scheme == FileUriScheme && androidUri.Path is not null)
+        {
+            var javaFile = new JavaFile(androidUri.Path);
+            if (javaFile.Exists() && javaFile.IsDirectory)
+            {
+                return new BclStorageFolder(new System.IO.DirectoryInfo(javaFile.AbsolutePath));
+            }
+            return null;
+        }
+        else if (folderPath.Scheme == ContentUriScheme)
         {
-            return new BclStorageFolder(new System.IO.DirectoryInfo(javaFile.AbsolutePath));
+            try
+            {
+                if (OperatingSystem.IsAndroidVersionAtLeast(21))
+                {
+                    if (DocumentsContract.IsTreeUri(androidUri))
+                    {
+                        var docId = DocumentsContract.GetTreeDocumentId(androidUri);
+                        if (!string.IsNullOrEmpty(docId))
+                        {
+                            return new AndroidStorageFolder(_activity, androidUri, false);
+                        }
+                    }
+                    else
+                    {
+                        var documentFile = DocumentFile.FromSingleUri(_activity, androidUri);
+                        if (documentFile is not null && documentFile.Exists() && documentFile.IsDirectory)
+                        {
+                            return new AndroidStorageFolder(_activity, androidUri, false);
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                return null;
+            }
         }
 
         return null;

From 8bec8ace1ffb9ae475df526150a6f1b45c5a06ea Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Tue, 18 Aug 2026 12:37:00 +0000
Subject: [PATCH 170/196] Headless: Use Avalonia.Input.MouseDevice.Primary for
 consistency with desktop platforms (configurable) (#22008)

---
 src/Avalonia.Base/Input/MouseDevice.cs        |  2 +
 .../AvaloniaHeadlessPlatform.cs               | 17 +++-
 .../Avalonia.Headless/HeadlessWindowImpl.cs   | 20 ++---
 ...ia.Headless.NUnit.PerTest.UnitTests.csproj |  2 +-
 .../AssertHelper.cs                           |  9 ++
 .../MouseDeviceTests.cs                       | 90 +++++++++++++++++++
 .../TestApplication.cs                        | 13 ++-
 ...ia.Headless.XUnit.PerTest.UnitTests.csproj |  2 +-
 8 files changed, 138 insertions(+), 17 deletions(-)
 create mode 100644 tests/Avalonia.Headless.UnitTests/MouseDeviceTests.cs

diff --git a/src/Avalonia.Base/Input/MouseDevice.cs b/src/Avalonia.Base/Input/MouseDevice.cs
index 0acc043eec..6bb5733a19 100644
--- a/src/Avalonia.Base/Input/MouseDevice.cs
+++ b/src/Avalonia.Base/Input/MouseDevice.cs
@@ -18,6 +18,8 @@ namespace Avalonia.Input
         private static MouseDevice? _primary;
         internal static MouseDevice Primary => _primary ??= new MouseDevice();
 
+        internal static void ResetPrimaryForUnitTests() => _primary = null;
+
         private int _clickCount;
         private Rect _lastClickRect;
         private ulong _lastClickTime;
diff --git a/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs b/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs
index 9d5624d5ed..4e14dc0f0b 100644
--- a/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs
+++ b/src/Headless/Avalonia.Headless/AvaloniaHeadlessPlatform.cs
@@ -14,9 +14,9 @@ namespace Avalonia.Headless
         internal static Compositor? Compositor { get; private set; }
         private static IRenderTimer? s_renderTimer;
 
-        private class HeadlessWindowingPlatform(PixelFormat frameBufferFormat, bool overlayPopups) : IWindowingPlatform
+        private class HeadlessWindowingPlatform(AvaloniaHeadlessPlatformOptions options) : IWindowingPlatform
         {
-            public IWindowImpl CreateWindow() => new HeadlessWindowImpl(frameBufferFormat, overlayPopups);
+            public IWindowImpl CreateWindow() => new HeadlessWindowImpl(options);
             public ITopLevelImpl CreateEmbeddableTopLevel() => CreateEmbeddableWindow();
 
             public IWindowImpl CreateEmbeddableWindow() => throw new PlatformNotSupportedException();
@@ -34,6 +34,9 @@ namespace Avalonia.Headless
 
         internal static void Initialize(AvaloniaHeadlessPlatformOptions opts)
         {
+            if (opts.UseSharedMouseDevice == true)
+                MouseDevice.ResetPrimaryForUnitTests();
+
             var clipboardImpl = new HeadlessClipboardImplStub();
             var clipboard = new Clipboard(clipboardImpl);
 
@@ -49,7 +52,7 @@ namespace Avalonia.Headless
                 .Bind<IPlatformIconLoader>().ToSingleton<HeadlessIconLoaderStub>()
                 .Bind<IKeyboardDevice>().ToConstant(new KeyboardDevice())
                 .Bind<IRenderLoop>().ToConstant(Rendering.RenderLoop.FromTimer(s_renderTimer))
-                .Bind<IWindowingPlatform>().ToConstant(new HeadlessWindowingPlatform(opts.FrameBufferFormat, opts.OverlayPopups))
+                .Bind<IWindowingPlatform>().ToConstant(new HeadlessWindowingPlatform(opts))
                 .Bind<PlatformHotkeyConfiguration>().ToSingleton<PlatformHotkeyConfiguration>()
                 .Bind<KeyGestureFormatInfo>().ToConstant(new KeyGestureFormatInfo(new Dictionary<Key, string>() { }));
             Compositor = new Compositor( null);
@@ -123,6 +126,14 @@ namespace Avalonia.Headless
         /// </summary>
         // TODO13: Change the default to false to match the other desktop platforms.
         public bool OverlayPopups { get; set; } = true;
+
+        /// <summary>
+        /// Shares a single mouse device between all top-levels when set to true, so that pointer capture
+        /// and click counting are global rather than per-window, as they are on the other platforms.
+        /// When null or false, every top-level gets its own mouse device.
+        /// </summary>
+        // TODO13: Change the default to true to match the other platforms.
+        public bool? UseSharedMouseDevice { get; set; }
     }
 
     public static class AvaloniaHeadlessPlatformExtensions
diff --git a/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs b/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
index b3a6bb16cc..97a24d66b0 100644
--- a/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
+++ b/src/Headless/Avalonia.Headless/HeadlessWindowImpl.cs
@@ -22,30 +22,28 @@ namespace Avalonia.Headless
         private readonly IKeyboardDevice _keyboard;
         private readonly IScreenImpl _screen;
         private readonly Stopwatch _st = Stopwatch.StartNew();
-        private readonly Pointer _mousePointer;
         private WriteableBitmap? _lastRenderedFrame;
         private readonly object _sync = new object();
-        private readonly PixelFormat _frameBufferFormat;
-        private readonly bool _overlayPopups;
+        private readonly AvaloniaHeadlessPlatformOptions _options;
         private readonly HeadlessWindowImpl? _popupParent;
         private readonly IPopupPositioner? _popupPositioner;
         private readonly List<HeadlessWindowImpl> _openPopups = new();
         public bool IsPopup { get; }
 
-        public HeadlessWindowImpl(PixelFormat frameBufferFormat, bool overlayPopups)
+        public HeadlessWindowImpl(AvaloniaHeadlessPlatformOptions options)
         {
             Surfaces = [this];
             _keyboard = AvaloniaLocator.Current.GetRequiredService<IKeyboardDevice>();
             _screen = new HeadlessScreensStub();
-            _mousePointer = new Pointer(Pointer.GetNextFreeId(), PointerType.Mouse, true);
-            MouseDevice = new MouseDevice(_mousePointer);
+            MouseDevice = options.UseSharedMouseDevice == true
+                ? Avalonia.Input.MouseDevice.Primary
+                : new MouseDevice(new Pointer(Pointer.GetNextFreeId(), PointerType.Mouse, true));
             ClientSize = new Size(1024, 768);
-            _frameBufferFormat = frameBufferFormat;
-            _overlayPopups = overlayPopups;
+            _options = options;
         }
 
         private HeadlessWindowImpl(HeadlessWindowImpl popupParent)
-            : this(popupParent._frameBufferFormat, popupParent._overlayPopups)
+            : this(popupParent._options)
         {
             IsPopup = true;
             _popupParent = popupParent;
@@ -233,7 +231,7 @@ namespace Avalonia.Headless
 
         public ILockedFramebuffer Lock()
         {
-            var bmp = new WriteableBitmap(PixelSize.FromSize(ClientSize, RenderScaling), new Vector(96, 96) * RenderScaling, _frameBufferFormat, AlphaFormat.Premul);
+            var bmp = new WriteableBitmap(PixelSize.FromSize(ClientSize, RenderScaling), new Vector(96, 96) * RenderScaling, _options.FrameBufferFormat, AlphaFormat.Premul);
             var fb = bmp.Lock();
             return new FramebufferProxy(fb, () =>
             {
@@ -403,7 +401,7 @@ namespace Avalonia.Headless
             PositionChanged?.Invoke(point);
         }
 
-        public IPopupImpl? CreatePopup() => _overlayPopups ? null : new HeadlessWindowImpl(this);
+        public IPopupImpl? CreatePopup() => _options.OverlayPopups ? null : new HeadlessWindowImpl(this);
 
         public IReadOnlyList<TopLevel> GetOpenPopups()
         {
diff --git a/tests/Avalonia.Headless.NUnit.PerTest.UnitTests/Avalonia.Headless.NUnit.PerTest.UnitTests.csproj b/tests/Avalonia.Headless.NUnit.PerTest.UnitTests/Avalonia.Headless.NUnit.PerTest.UnitTests.csproj
index 9eff9a967d..24d7575c7c 100644
--- a/tests/Avalonia.Headless.NUnit.PerTest.UnitTests/Avalonia.Headless.NUnit.PerTest.UnitTests.csproj
+++ b/tests/Avalonia.Headless.NUnit.PerTest.UnitTests/Avalonia.Headless.NUnit.PerTest.UnitTests.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <TargetFramework>$(AvsCurrentTargetFramework)</TargetFramework>
     <IsTestProject>true</IsTestProject>
-    <DefineConstants>$(DefineConstants);NUNIT</DefineConstants>
+    <DefineConstants>$(DefineConstants);NUNIT;PERTEST</DefineConstants>
     <EnableNUnitRunner>true</EnableNUnitRunner>
     <OutputType>Exe</OutputType>
   </PropertyGroup>
diff --git a/tests/Avalonia.Headless.UnitTests/AssertHelper.cs b/tests/Avalonia.Headless.UnitTests/AssertHelper.cs
index a3443492b0..1c98afcb9a 100644
--- a/tests/Avalonia.Headless.UnitTests/AssertHelper.cs
+++ b/tests/Avalonia.Headless.UnitTests/AssertHelper.cs
@@ -49,4 +49,13 @@ internal static class AssertHelper
 #endif
     }
 
+    public static void NotSame(object? expected, object? actual)
+    {
+#if NUNIT
+        Assert.That(expected, Is.Not.SameAs(actual));
+#elif XUNIT
+        Assert.NotSame(expected, actual);
+#endif
+    }
+
 }
diff --git a/tests/Avalonia.Headless.UnitTests/MouseDeviceTests.cs b/tests/Avalonia.Headless.UnitTests/MouseDeviceTests.cs
new file mode 100644
index 0000000000..d501635fbe
--- /dev/null
+++ b/tests/Avalonia.Headless.UnitTests/MouseDeviceTests.cs
@@ -0,0 +1,90 @@
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Input;
+using Avalonia.Media;
+using Avalonia.Threading;
+
+namespace Avalonia.Headless.UnitTests;
+
+public class MouseDeviceTests
+{
+#if NUNIT
+    [AvaloniaTest]
+#elif XUNIT
+    [AvaloniaFact]
+#endif
+    public void Pointer_Is_Shared_Between_Windows_When_Requested()
+    {
+        var firstWindow = CreateWindow(out var firstTarget);
+        var secondWindow = CreateWindow(out var secondTarget);
+
+        IPointer firstPointer = null, secondPointer = null;
+        firstTarget.PointerPressed += (_, e) => firstPointer = e.Pointer;
+        secondTarget.PointerPressed += (_, e) => secondPointer = e.Pointer;
+
+        Click(firstWindow);
+        Click(secondWindow);
+
+        AssertHelper.NotNull(firstPointer);
+        AssertHelper.NotNull(secondPointer);
+
+        if (TestApplication.UsesSharedMouseDevice)
+            AssertHelper.Same(firstPointer, secondPointer);
+        else
+            AssertHelper.NotSame(firstPointer, secondPointer);
+
+        firstWindow.Close();
+        secondWindow.Close();
+    }
+
+#if NUNIT
+    [AvaloniaTest]
+#elif XUNIT
+    [AvaloniaFact]
+#endif
+    public void Pointer_Capture_Crosses_TopLevels_When_Device_Is_Shared()
+    {
+        var popupChild = new Border { Width = 80, Height = 30, Background = Brushes.Blue };
+        var target = new Border { Background = Brushes.Red };
+        var popup = new Popup { PlacementTarget = target, Child = popupChild };
+        var window = new Window
+        {
+            Width = 100,
+            Height = 100,
+            Content = new Panel { Children = { target, popup } }
+        };
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+
+        popup.Open();
+        Dispatcher.UIThread.RunJobs();
+
+        object moveTarget = null;
+        target.PointerMoved += (s, _) => moveTarget = s;
+        popupChild.PointerMoved += (s, _) => moveTarget = s;
+
+        // Pressing captures the pointer implicitly on the window's border.
+        window.MouseDown(new Point(50, 50), MouseButton.Left);
+        window.GetOpenPopups()[0].MouseMove(new Point(40, 15));
+
+        AssertHelper.Same(TestApplication.UsesSharedMouseDevice ? target : popupChild, moveTarget);
+
+        window.MouseUp(new Point(50, 50), MouseButton.Left);
+        window.Close();
+    }
+
+    private static Window CreateWindow(out Border target)
+    {
+        target = new Border { Background = Brushes.Red };
+        var window = new Window { Width = 100, Height = 100, Content = target };
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+        return window;
+    }
+
+    private static void Click(Window window)
+    {
+        window.MouseDown(new Point(50, 50), MouseButton.Left);
+        window.MouseUp(new Point(50, 50), MouseButton.Left);
+    }
+}
diff --git a/tests/Avalonia.Headless.UnitTests/TestApplication.cs b/tests/Avalonia.Headless.UnitTests/TestApplication.cs
index 4899292110..8b560aaf72 100644
--- a/tests/Avalonia.Headless.UnitTests/TestApplication.cs
+++ b/tests/Avalonia.Headless.UnitTests/TestApplication.cs
@@ -9,12 +9,23 @@ public class TestApplication : Application
         Styles.Add(new SimpleTheme());
     }
 
+    /// <summary>
+    /// Enabled by the PerTest projects only, so that both mouse device modes are covered.
+    /// </summary>
+    public static bool UsesSharedMouseDevice =>
+#if PERTEST
+        true;
+#else
+        false;
+#endif
+
     public static AppBuilder BuildAvaloniaApp() => AppBuilder.Configure<TestApplication>()
         .UseHarfBuzz()
         .UseSkia()
         .UseHeadless(new AvaloniaHeadlessPlatformOptions
         {
             UseHeadlessDrawing = false,
-            OverlayPopups = false
+            OverlayPopups = false,
+            UseSharedMouseDevice = UsesSharedMouseDevice
         });
 }
diff --git a/tests/Avalonia.Headless.XUnit.PerTest.UnitTests/Avalonia.Headless.XUnit.PerTest.UnitTests.csproj b/tests/Avalonia.Headless.XUnit.PerTest.UnitTests/Avalonia.Headless.XUnit.PerTest.UnitTests.csproj
index 28cf0b8495..c243547461 100644
--- a/tests/Avalonia.Headless.XUnit.PerTest.UnitTests/Avalonia.Headless.XUnit.PerTest.UnitTests.csproj
+++ b/tests/Avalonia.Headless.XUnit.PerTest.UnitTests/Avalonia.Headless.XUnit.PerTest.UnitTests.csproj
@@ -3,7 +3,7 @@
     <TargetFramework>$(AvsCurrentTargetFramework)</TargetFramework>
     <OutputType>Exe</OutputType>
     <IsTestProject>true</IsTestProject>
-    <DefineConstants>$(DefineConstants);XUNIT</DefineConstants>
+    <DefineConstants>$(DefineConstants);XUNIT;PERTEST</DefineConstants>
   </PropertyGroup>
 
   <Import Project="..\..\build\UnitTests.NetCore.targets" />

From a56f8c131f9ae7afc701307c542ee1ab14755e7e Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Tue, 18 Aug 2026 13:39:45 +0000
Subject: [PATCH 171/196] Ensure that ActualThemeVariant always has a proper
 value (#21930)

* Correctly set ActualThemeVariant

* Don't call OnColorValuesChanged unnecessarily on Win32

* Don't call OnColorValuesChanged unnecessarily on macOS

* Change iOS PlatformSettings to match other platforms

* Don't call OnColorValuesChanged unnecessarily on Android

* Android: set theme using SetLocalNightMode

* Don't call OnColorValuesChanged unnecessarily on X11/Wayland

* Don't call OnColorValuesChanged unnecessarily on Browser

* Fix timer Start order

* Remove dead code in DBusPlatformSettings
---
 src/Android/Avalonia.Android/AvaloniaView.cs  |   5 +-
 .../Platform/AndroidPlatformSettings.cs       | 110 ++++++---
 .../Platform/SkiaPlatform/TopLevelImpl.cs     |  25 +--
 src/Avalonia.Base/StyledElement.cs            |   7 -
 .../Styling/IThemeVariantRoot.cs              |  12 +
 src/Avalonia.Base/Styling/ThemeVariant.cs     |  45 +++-
 src/Avalonia.Controls/Application.cs          |  35 +--
 src/Avalonia.Controls/TopLevel.cs             |  17 +-
 .../DBusPlatformSettings.cs                   |  59 ++---
 src/Avalonia.Native/NativePlatformSettings.cs |  13 +-
 src/Avalonia.Native/WindowImplBase.cs         |   6 -
 src/Avalonia.Wayland/WindowImplBase.cs        |   6 +-
 src/Avalonia.X11/X11Window.cs                 |   6 +-
 .../BrowserPlatformSettings.cs                |  37 ++-
 .../Avalonia.Browser/BrowserTopLevelImpl.cs   |   5 -
 .../Avalonia.Win32/Win32PlatformSettings.cs   |  25 ++-
 src/Windows/Avalonia.Win32/WindowImpl.cs      |   2 -
 src/iOS/Avalonia.iOS/AvaloniaView.cs          |   5 -
 src/iOS/Avalonia.iOS/PlatformSettings.cs      |  22 +-
 .../ThemeVariantTests.cs                      | 211 ++++++++++++++++++
 .../TestPlatformSettings.cs                   |  23 ++
 tests/Avalonia.UnitTests/TestServices.cs      |   5 +
 .../Avalonia.UnitTests/UnitTestApplication.cs |   6 +-
 23 files changed, 509 insertions(+), 178 deletions(-)
 create mode 100644 src/Avalonia.Base/Styling/IThemeVariantRoot.cs
 create mode 100644 tests/Avalonia.Controls.UnitTests/ThemeVariantTests.cs
 create mode 100644 tests/Avalonia.UnitTests/TestPlatformSettings.cs

diff --git a/src/Android/Avalonia.Android/AvaloniaView.cs b/src/Android/Avalonia.Android/AvaloniaView.cs
index a5a45be61a..b2decd5fa2 100644
--- a/src/Android/Avalonia.Android/AvaloniaView.cs
+++ b/src/Android/Avalonia.Android/AvaloniaView.cs
@@ -137,11 +137,8 @@ namespace Avalonia.Android
         private void SendConfigurationChanged(Configuration? newConfig)
         {
             _view.InsetsManager?.SetDefaultSystemLightMode(!(newConfig?.UiMode.HasFlag(UiMode.NightYes) ?? false));
-            if (Context is { } context && newConfig is { } config)
+            if (Context is not null && newConfig is not null)
             {
-                var settings =
-                    AvaloniaLocator.Current.GetRequiredService<IPlatformSettings>() as AndroidPlatformSettings;
-                settings?.OnViewConfigurationChanged(context, config);
                 ((AndroidScreens)_view.TryGetFeature<IScreenImpl>()!).OnChanged();
             }
         }
diff --git a/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs b/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs
index 5da78439e2..83b2ab51e3 100644
--- a/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs
+++ b/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs
@@ -3,16 +3,17 @@ using Android.Content;
 using Android.Content.Res;
 using Android.Provider;
 using Android.Views;
+using AndroidX.Core.Content;
 using Avalonia.Input;
 using Avalonia.Platform;
+using Avalonia.Threading;
 using Color = Avalonia.Media.Color;
 
 namespace Avalonia.Android.Platform;
 
-// TODO: ideally should be created per view/activity.
 internal class AndroidPlatformSettings : DefaultPlatformSettings
 {
-    private PlatformColorValues _latestValues;
+    private PlatformColorValues _colorValues;
     private TimeSpan _holdWaitDuration = TimeSpan.FromMilliseconds(300);
     private TimeSpan _doubleTapTime = TimeSpan.FromMilliseconds(500);
     private Size _doubleTapSize = new Size(16,16);
@@ -20,16 +21,24 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
 
     public AndroidPlatformSettings()
     {
-        _latestValues = base.GetColorValues();
         if (global::Android.App.Application.Context is { } context)
         {
-            GetInputConfigValues(context);
+            UpdateInputConfigValues(context);
+            _colorValues = GetColorValuesFromContext(context);
+
+            ContextCompat.RegisterReceiver(
+                context,
+                new ConfigurationChangedReceiver(this),
+                new IntentFilter(Intent.ActionConfigurationChanged),
+                ContextCompat.ReceiverNotExported);
         }
+        else
+            _colorValues = base.GetColorValues();
     }
 
     public override PlatformColorValues GetColorValues()
     {
-        return _latestValues;
+        return _colorValues;
     }
 
     public override TimeSpan GetDoubleTapTime(PointerType type)
@@ -49,50 +58,57 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
 
     public override TimeSpan HoldWaitDuration => _holdWaitDuration;
 
-    internal void OnViewConfigurationChanged(Context context, Configuration configuration)
+    private void UpdateColorValues(Context context)
     {
-        if (context.Resources is null)
+        var oldColorValues = _colorValues;
+        var colorValues = GetColorValuesFromContext(context);
+
+        if (oldColorValues != colorValues)
         {
-            return;
+            _colorValues = colorValues;
+            OnColorValuesChanged(colorValues);
         }
+    }
 
-        PlatformThemeVariant systemTheme = (configuration.UiMode & UiMode.NightMask) switch
-        {
-            UiMode.NightYes => PlatformThemeVariant.Dark,
-            UiMode.NightNo => PlatformThemeVariant.Light,
-            _ => throw new ArgumentOutOfRangeException()
-        };
+    private static PlatformColorValues GetColorValuesFromContext(Context context)
+    {
+        var uiMode = context.Resources?.Configuration?.UiMode & UiMode.NightMask ?? UiMode.NightNo;
+        var systemTheme = uiMode == UiMode.NightYes ? PlatformThemeVariant.Dark : PlatformThemeVariant.Light;
+        var contrastPreference = IsHighContrast(context);
 
         if (OperatingSystem.IsAndroidVersionAtLeast(31))
         {
-            // See https://developer.android.com/reference/android/R.color
-            var accent1 = context.Resources.GetColor(17170494, context.Theme); // Resource.Color.SystemAccent1500
-            var accent2 = context.Resources.GetColor(17170507, context.Theme); // Resource.Color.SystemAccent2500
-            var accent3 = context.Resources.GetColor(17170520, context.Theme); // Resource.Color.SystemAccent3500
-
-            _latestValues = new PlatformColorValues
+            if (context.Resources is { } resources)
             {
-                ThemeVariant = systemTheme,
-                ContrastPreference = IsHighContrast(context),
-                AccentColor1 = new Color(accent1.A, accent1.R, accent1.G, accent1.B),
-                AccentColor2 = new Color(accent2.A, accent2.R, accent2.G, accent2.B),
-                AccentColor3 = new Color(accent3.A, accent3.R, accent3.G, accent3.B),
-            };
+                // See https://developer.android.com/reference/android/R.color
+                var accent1 = resources.GetColor(17170494, context.Theme); // Resource.Color.SystemAccent1500
+                var accent2 = resources.GetColor(17170507, context.Theme); // Resource.Color.SystemAccent2500
+                var accent3 = resources.GetColor(17170520, context.Theme); // Resource.Color.SystemAccent3500
+
+                return new PlatformColorValues
+                {
+                    ThemeVariant = systemTheme,
+                    ContrastPreference = contrastPreference,
+                    AccentColor1 = new Color(accent1.A, accent1.R, accent1.G, accent1.B),
+                    AccentColor2 = new Color(accent2.A, accent2.R, accent2.G, accent2.B),
+                    AccentColor3 = new Color(accent3.A, accent3.R, accent3.G, accent3.B),
+                };
+            }
         }
         else if (OperatingSystem.IsAndroidVersionAtLeast(23))
         {
             // See https://developer.android.com/reference/android/R.attr
-            var array = context.Theme?.ObtainStyledAttributes(new[] { 16843829 }); // Resource.Attribute.ColorAccent
+            var array = context.Theme?.ObtainStyledAttributes([16843829]); // Resource.Attribute.ColorAccent
             if (array is not null)
             {
                 try
                 {
                     var accent = array.GetColor(0, 0);
 
-                    _latestValues = new PlatformColorValues
+                    return new PlatformColorValues
                     {
                         ThemeVariant = systemTheme,
-                        ContrastPreference = IsHighContrast(context),
+                        ContrastPreference = contrastPreference,
                         AccentColor1 = new Color(accent.A, accent.R, accent.G, accent.B)
                     };
                 }
@@ -102,17 +118,15 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
                 }
             }
         }
-        else
-        {
-            _latestValues = _latestValues with { ThemeVariant = systemTheme };
-        }
 
-        GetInputConfigValues(context);
-
-        OnColorValuesChanged(_latestValues);
+        return new PlatformColorValues
+        {
+            ThemeVariant = systemTheme,
+            ContrastPreference = contrastPreference
+        };
     }
 
-    private void GetInputConfigValues(Context context)
+    private void UpdateInputConfigValues(Context context)
     {
         _holdWaitDuration = TimeSpan.FromMilliseconds(ViewConfiguration.LongPressTimeout);
 
@@ -143,4 +157,26 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
             return ColorContrastPreference.NoPreference;
         }
     }
+
+    private sealed class ConfigurationChangedReceiver(AndroidPlatformSettings settings) : BroadcastReceiver
+    {
+        public override void OnReceive(Context? context, Intent? intent)
+        {
+            if (context is null)
+                return;
+
+            // The context might still have the old values at this point because they haven't been processed yet.
+            // Postpone the update 100ms arbitrarily. Not an ideal solution, but sufficient.
+            var timer = new DispatcherTimer(TimeSpan.FromMilliseconds(100), DispatcherPriority.Normal, Dispatcher.UIThread);
+
+            timer.Tick += (_, _) =>
+            {
+                timer.Stop();
+                settings.UpdateInputConfigValues(context);
+                settings.UpdateColorValues(context);
+            };
+
+            timer.Start();
+        }
+    }
 }
diff --git a/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs b/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs
index a732e90689..6209301146 100644
--- a/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs
+++ b/src/Android/Avalonia.Android/Platform/SkiaPlatform/TopLevelImpl.cs
@@ -30,6 +30,7 @@ namespace Avalonia.Android.Platform.SkiaPlatform
 {
     class TopLevelImpl : ITopLevelImpl, EglGlPlatformSurface.IEglWindowGlPlatformSurfaceInfoWithWaitPolicy
     {
+        private readonly Context _context;
         private readonly AndroidKeyboardEventsHelper<TopLevelImpl> _keyboardHelper;
         private readonly AndroidMotionEventsHelper _pointerHelper;
         private readonly AndroidInputMethod<AvaloniaView> _textInputMethod;
@@ -51,6 +52,7 @@ namespace Avalonia.Android.Platform.SkiaPlatform
                 throw new ArgumentException("AvaloniaView.Context must not be null");
             }
 
+            _context = context;
             _view = new SurfaceViewImpl(context, this, placeOnTop);
             _textInputMethod = new AndroidInputMethod<AvaloniaView>(avaloniaView);
             _keyboardHelper = new AndroidKeyboardEventsHelper<TopLevelImpl>(this);
@@ -245,22 +247,15 @@ namespace Avalonia.Android.Platform.SkiaPlatform
                 };
             }
 
-            // Sets the default app NightMode to AppCompatDelegate.ModeNightFollowSystem when themeVariant is null. This
-            // allows app to follow the current OS night mode. Using either ModeNightNo or ModeNightYes will force the app
-            // to use one night mode, ignoring the system's configuration and preventing us from detecting system theme changes
-            // in View.OnConfigurationChanged. In this case, only Activity.OnConfigurationChanged is called when system theme is
-            // changed, but we don't have access to that method if the toplevel view is embedded in a custom activity
-            var nightMode = themeVariant == null ? AppCompatDelegate.ModeNightFollowSystem :
-                themeVariant == PlatformThemeVariant.Light ? AppCompatDelegate.ModeNightNo : AppCompatDelegate.ModeNightYes;
-
-            AppCompatDelegate.DefaultNightMode = nightMode;
-
-            if (nightMode == AppCompatDelegate.ModeNightFollowSystem && _view?.Context is { } context
-                && context.Resources?.Configuration is { } config)
+            if (_context is AppCompatActivity activity)
             {
-                var settings =
-                    AvaloniaLocator.Current.GetRequiredService<IPlatformSettings>() as AndroidPlatformSettings;
-                settings?.OnViewConfigurationChanged(context, config);
+                var nightMode = themeVariant == PlatformThemeVariant.Dark ?
+                    AppCompatDelegate.ModeNightYes :
+                    AppCompatDelegate.ModeNightNo;
+
+                // Don't use AppCompatDelegate.DefaultNightMode: doing so will force the app to use one night mode,
+                // ignoring the system's configuration and preventing us from detecting system theme changes.
+                activity.Delegate.SetLocalNightMode(nightMode);
             }
         }
 
diff --git a/src/Avalonia.Base/StyledElement.cs b/src/Avalonia.Base/StyledElement.cs
index 16feb0e803..80d8689772 100644
--- a/src/Avalonia.Base/StyledElement.cs
+++ b/src/Avalonia.Base/StyledElement.cs
@@ -612,13 +612,6 @@ namespace Avalonia
             {
                 OnControlThemeChanged();
             }
-            else if (change.Property == ThemeVariant.RequestedThemeVariantProperty)
-            {
-                if (change.GetNewValue<ThemeVariant>() is {} themeVariant && themeVariant != ThemeVariant.Default)
-                    SetValue(ThemeVariant.ActualThemeVariantProperty, themeVariant);
-                else
-                    ClearValue(ThemeVariant.ActualThemeVariantProperty);
-            }
             else if (change.Property == ThemeVariant.ActualThemeVariantProperty)
             {
                 ActualThemeVariantChanged?.Invoke(this, EventArgs.Empty);
diff --git a/src/Avalonia.Base/Styling/IThemeVariantRoot.cs b/src/Avalonia.Base/Styling/IThemeVariantRoot.cs
new file mode 100644
index 0000000000..c16f93f1ac
--- /dev/null
+++ b/src/Avalonia.Base/Styling/IThemeVariantRoot.cs
@@ -0,0 +1,12 @@
+namespace Avalonia.Styling;
+
+/// <summary>
+/// Implemented by objects which resolve a <see cref="ThemeVariant.Default"/> requested theme variant from the platform.
+/// </summary>
+internal interface IThemeVariantRoot
+{
+    /// <summary>
+    /// Gets whether this object currently acts as a theme variant root (it has no parent).
+    /// </summary>
+    bool IsThemeVariantRoot { get; }
+}
diff --git a/src/Avalonia.Base/Styling/ThemeVariant.cs b/src/Avalonia.Base/Styling/ThemeVariant.cs
index b469ea5b28..7af270a3a1 100644
--- a/src/Avalonia.Base/Styling/ThemeVariant.cs
+++ b/src/Avalonia.Base/Styling/ThemeVariant.cs
@@ -1,6 +1,6 @@
 using System;
 using System.ComponentModel;
-using System.Text;
+using Avalonia.Logging;
 using Avalonia.Platform;
 
 namespace Avalonia.Styling;
@@ -45,7 +45,12 @@ public sealed record ThemeVariant
     internal static readonly StyledProperty<ThemeVariant?> RequestedThemeVariantProperty =
         AvaloniaProperty.Register<StyledElement, ThemeVariant?>(
             "RequestedThemeVariant", defaultValue: Default);
-    
+
+    static ThemeVariant()
+    {
+        RequestedThemeVariantProperty.Changed.AddClassHandler<AvaloniaObject>((x, _) => UpdateActualThemeVariant(x));
+    }
+
     /// <summary>
     /// Creates a new instance of the <see cref="ThemeVariant"/>
     /// </summary>
@@ -79,6 +84,42 @@ public sealed record ThemeVariant
     /// </summary>
     public ThemeVariant? InheritVariant { get; }
 
+    internal static void UpdateActualThemeVariant(AvaloniaObject target)
+    {
+        var requested = target.GetValue(RequestedThemeVariantProperty) ?? Default;
+
+        if (requested != Default)
+        {
+            target.SetValue(ActualThemeVariantProperty, requested);
+            return;
+        }
+
+        if (target is IThemeVariantRoot { IsThemeVariantRoot: true })
+        {
+            var actual = GetPlatformThemeVariant();
+
+            Logger.TryGet(LogEventLevel.Debug, LogArea.Platform)
+                ?.Log(target, "Requested Default theme variant, used {ActualThemeVariant} platform variant", actual);
+
+            target.SetValue(ActualThemeVariantProperty, actual);
+        }
+        else
+        {
+            Logger.TryGet(LogEventLevel.Debug, LogArea.Platform)
+                ?.Log(target, "Requested Default theme variant, inheriting from parent");
+
+            target.ClearValue(ActualThemeVariantProperty);
+        }
+    }
+
+    private static ThemeVariant GetPlatformThemeVariant()
+    {
+        var variant = AvaloniaLocator.Current.GetService<IPlatformSettings>()?.GetColorValues().ThemeVariant ??
+                      PlatformThemeVariant.Light;
+
+        return (ThemeVariant)variant;
+    }
+
     public override string ToString()
     {
         return Key.ToString() ?? $"ThemeVariant {{ Key = {Key} }}";
diff --git a/src/Avalonia.Controls/Application.cs b/src/Avalonia.Controls/Application.cs
index 0b1e20c395..769ab39377 100644
--- a/src/Avalonia.Controls/Application.cs
+++ b/src/Avalonia.Controls/Application.cs
@@ -30,7 +30,7 @@ namespace Avalonia
     /// method.
     /// - Tracks the lifetime of the application.
     /// </remarks>
-    public class Application : AvaloniaObject, IDataContextProvider, IGlobalDataTemplates, IGlobalStyles, IThemeVariantHost, IResourceHost, IOptionalFeatureProvider
+    public class Application : AvaloniaObject, IDataContextProvider, IGlobalDataTemplates, IGlobalStyles, IThemeVariantHost, IThemeVariantRoot, IResourceHost, IOptionalFeatureProvider
     {
         /// <summary>
         /// The application-global data templates.
@@ -97,6 +97,8 @@ namespace Avalonia
         [System.Diagnostics.CodeAnalysis.SuppressMessage("AvaloniaProperty", "AVP1030", Justification = "False positive.")]
         public ThemeVariant ActualThemeVariant => GetValue(ActualThemeVariantProperty);
 
+        bool IThemeVariantRoot.IsThemeVariantRoot => true;
+
         /// <summary>
         /// Gets the current instance of the <see cref="Application"/> class.
         /// </summary>
@@ -250,11 +252,7 @@ namespace Avalonia
             AvaloniaSynchronizationContext.InstallIfNeeded();
             InputManager = new InputManager();
 
-            if (PlatformSettings is { } settings)
-            {
-                settings.ColorValuesChanged += OnColorValuesChanged;
-                OnColorValuesChanged(settings, settings.GetColorValues());
-            }
+            InitializeThemeVariant();
 
             AvaloniaLocator.CurrentMutable
                 .Bind<IAccessKeyHandler>().ToTransient<AccessKeyHandler>()
@@ -328,21 +326,7 @@ namespace Avalonia
         {
             base.OnPropertyChanged(change);
 
-            if (change.Property == RequestedThemeVariantProperty)
-            {
-                if (change.GetNewValue<ThemeVariant>() is { } themeVariant)
-                {
-                    if (themeVariant == ThemeVariant.Default)
-                    {
-                        ClearValue(ActualThemeVariantProperty);
-                    }
-                    else
-                    {
-                        SetValue(ActualThemeVariantProperty, themeVariant);
-                    }
-                }
-            }
-            else if (change.Property == ActualThemeVariantProperty)
+            if (change.Property == ActualThemeVariantProperty)
             {
                 ActualThemeVariantChanged?.Invoke(this, EventArgs.Empty);
             }
@@ -350,8 +334,13 @@ namespace Avalonia
 
         private void OnColorValuesChanged(object? sender, PlatformColorValues e)
         {
-            if ((RequestedThemeVariant ?? ThemeVariant.Default) == ThemeVariant.Default)
-                SetValue(ActualThemeVariantProperty, (ThemeVariant)e.ThemeVariant);
+            ThemeVariant.UpdateActualThemeVariant(this);
+        }
+
+        internal void InitializeThemeVariant()
+        {
+            PlatformSettings?.ColorValuesChanged += OnColorValuesChanged;
+            ThemeVariant.UpdateActualThemeVariant(this);
         }
     }
 }
diff --git a/src/Avalonia.Controls/TopLevel.cs b/src/Avalonia.Controls/TopLevel.cs
index eeb6ae3488..ac5f6693e8 100644
--- a/src/Avalonia.Controls/TopLevel.cs
+++ b/src/Avalonia.Controls/TopLevel.cs
@@ -42,7 +42,8 @@ namespace Avalonia.Controls
     public abstract class TopLevel : ContentControl,
         ICloseable,
         IStyleHost,
-        ILogicalRoot
+        ILogicalRoot,
+        IThemeVariantRoot
     {
         /// <summary>
         /// Defines the <see cref="ClientSize"/> property.
@@ -248,19 +249,19 @@ namespace Avalonia.Controls
                 _globalStyles.GlobalStylesAdded += ((IStyleHost)this).StylesAdded;
                 _globalStyles.GlobalStylesRemoved += ((IStyleHost)this).StylesRemoved;
             }
+
             if (_applicationThemeHost is { })
             {
                 SetValue(ActualThemeVariantProperty, _applicationThemeHost.ActualThemeVariant, BindingPriority.Template);
                 _applicationThemeHost.ActualThemeVariantChanged += GlobalActualThemeVariantChanged;
             }
+            else
+            {
+                ThemeVariant.UpdateActualThemeVariant(this);
+            }
+
             CreatePlatformImplBinding(ActualThemeVariantProperty, variant =>
             {
-                if(_applicationThemeHost is AvaloniaObject element)
-                {
-                    if (element.GetValue(ThemeVariantScope.RequestedThemeVariantProperty) is { } requestedThemeVariant)
-                        variant = requestedThemeVariant == ThemeVariant.Default ? ThemeVariant.Default : variant;
-                }
-                variant ??= ThemeVariant.Default;
                 PlatformImpl?.SetFrameThemeVariant((PlatformThemeVariant?)variant);
             });
 
@@ -400,6 +401,8 @@ namespace Avalonia.Controls
             set => SetValue(RequestedThemeVariantProperty, value);
         }
 
+        bool IThemeVariantRoot.IsThemeVariantRoot => _applicationThemeHost is null;
+
         /// <summary>
         /// Occurs when physical Back Button is pressed or a back navigation has been requested.
         /// </summary>
diff --git a/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs b/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs
index f6d620a534..2cc25a9dde 100644
--- a/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs
+++ b/src/Avalonia.FreeDesktop/DBusPlatformSettings.cs
@@ -1,8 +1,6 @@
-using System;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Avalonia.Media;
 using Avalonia.Platform;
-using Avalonia.Threading;
 using Tmds.DBus.Protocol;
 using Avalonia.FreeDesktop.DBus;
 
@@ -12,12 +10,14 @@ namespace Avalonia.FreeDesktop
     {
         private readonly Settings? _settings;
 
-        private PlatformColorValues? _lastColorValues;
+        private PlatformColorValues _colorValues;
         private PlatformThemeVariant? _themeVariant;
         private Color? _accentColor;
 
         public DBusPlatformSettings()
         {
+            _colorValues = base.GetColorValues();
+
             if (DBusHelper.DefaultConnection is not { } conn)
                 return;
 
@@ -26,7 +26,7 @@ namespace Avalonia.FreeDesktop
             _ = TryGetInitialValuesAsync();
         }
 
-        public override PlatformColorValues GetColorValues() => _lastColorValues ?? base.GetColorValues();
+        public override PlatformColorValues GetColorValues() => _colorValues;
 
         private async Task TryGetInitialValuesAsync()
         {
@@ -34,17 +34,10 @@ namespace Avalonia.FreeDesktop
             {
                 _themeVariant = await TryGetThemeVariantAsync(settings);
                 _accentColor = await TryGetAccentColorAsync(settings);
-                _lastColorValues = BuildPlatformColorValues();
-                if (_lastColorValues is not null)
-                    Dispatcher.UIThread.Post(() => OnColorValuesChanged(_lastColorValues));
+                UpdateColorValues();
             }
         }
 
-        internal void OnRequestDefaultThemeVariant()
-        {
-            _ = TryGetInitialValuesAsync();
-        }
-
         private static async Task<PlatformThemeVariant?> TryGetThemeVariantAsync(Settings settings)
         {
             try
@@ -82,32 +75,48 @@ namespace Avalonia.FreeDesktop
             }
         }
 
+        private void UpdateColorValues()
+        {
+            var oldColorValues = _colorValues;
+            var colorValues = BuildPlatformColorValues(_themeVariant, _accentColor);
+
+            if (oldColorValues != colorValues)
+            {
+                _colorValues = colorValues;
+                OnColorValuesChanged(colorValues);
+            }
+        }
+
         private void SettingsChangedHandler((string Namespace, string Key, VariantValue Value) tuple)
         {
             switch (tuple)
             {
                 case ("org.freedesktop.appearance", "color-scheme", var colorScheme):
                     _themeVariant = ToColorScheme(colorScheme.GetUInt32());
-                    _lastColorValues = BuildPlatformColorValues();
-                    OnColorValuesChanged(_lastColorValues!);
+                    UpdateColorValues();
                     break;
                 case ("org.freedesktop.appearance", "accent-color", var accentColor):
                     _accentColor = ToAccentColor(accentColor);
-                    _lastColorValues = BuildPlatformColorValues();
-                    OnColorValuesChanged(_lastColorValues!);
+                    UpdateColorValues();
                     break;
             }
         }
 
-        private PlatformColorValues? BuildPlatformColorValues()
+        private static PlatformColorValues BuildPlatformColorValues(
+            PlatformThemeVariant? nullableThemeVariant,
+            Color? nullableAccentColor)
         {
-            if (_themeVariant is { } themeVariant && _accentColor is { } accentColor)
-                return new PlatformColorValues { ThemeVariant = themeVariant, AccentColor1 = accentColor };
-            if (_themeVariant is { } themeVariant1)
-                return new PlatformColorValues { ThemeVariant = themeVariant1 };
-            if (_accentColor is { } accentColor1)
-                return new PlatformColorValues { AccentColor1 = accentColor1 };
-            return null;
+            return (nullableThemeVariant, nullableAccentColor) switch
+            {
+                ({ } themeVariant, { } accentColor)
+                    => new PlatformColorValues { ThemeVariant = themeVariant, AccentColor1 = accentColor },
+                ({ } themeVariant, null)
+                    => new PlatformColorValues { ThemeVariant = themeVariant },
+                (null, { } accentColor)
+                    => new PlatformColorValues { AccentColor1 = accentColor },
+                (null, null)
+                    => new PlatformColorValues { ThemeVariant = PlatformThemeVariant.Light }
+            };
         }
 
         private static PlatformThemeVariant ToColorScheme(uint value)
diff --git a/src/Avalonia.Native/NativePlatformSettings.cs b/src/Avalonia.Native/NativePlatformSettings.cs
index b95d9a9439..63fc4e64af 100644
--- a/src/Avalonia.Native/NativePlatformSettings.cs
+++ b/src/Avalonia.Native/NativePlatformSettings.cs
@@ -8,6 +8,7 @@ namespace Avalonia.Native;
 internal class NativePlatformSettings : DefaultPlatformSettings
 {
     private readonly IAvnPlatformSettings _platformSettings;
+    private PlatformColorValues? _colorValues;
 
     public NativePlatformSettings(IAvnPlatformSettings platformSettings)
     {
@@ -16,6 +17,9 @@ internal class NativePlatformSettings : DefaultPlatformSettings
     }
 
     public override PlatformColorValues GetColorValues()
+        => _colorValues ??= GetUncachedColorValues();
+
+    private PlatformColorValues GetUncachedColorValues()
     {
         var (theme, contrast) = _platformSettings.PlatformTheme switch
         {
@@ -48,7 +52,14 @@ internal class NativePlatformSettings : DefaultPlatformSettings
 
     public void OnColorValuesChanged()
     {
-        OnColorValuesChanged(GetColorValues());
+        var oldColorValues = _colorValues;
+        var colorValues = GetUncachedColorValues();
+
+        if (oldColorValues != colorValues)
+        {
+            _colorValues = colorValues;
+            OnColorValuesChanged(colorValues);
+        }
     }
 
     private class ColorsChangeCallback : NativeCallbackBase, IAvnActionCallback
diff --git a/src/Avalonia.Native/WindowImplBase.cs b/src/Avalonia.Native/WindowImplBase.cs
index 4c5652c03e..8d7270dede 100644
--- a/src/Avalonia.Native/WindowImplBase.cs
+++ b/src/Avalonia.Native/WindowImplBase.cs
@@ -71,12 +71,6 @@ namespace Avalonia.Native
         public override void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
         {
             var settings = AvaloniaLocator.Current.GetService<IPlatformSettings>();
-
-            if (themeVariant is null && settings is NativePlatformSettings typedSettings)
-            {
-                typedSettings.OnColorValuesChanged();
-            }
-
             themeVariant ??= settings?.GetColorValues().ThemeVariant ?? PlatformThemeVariant.Light;
             Native?.SetFrameThemeVariant((AvnPlatformThemeVariant)themeVariant);
         }
diff --git a/src/Avalonia.Wayland/WindowImplBase.cs b/src/Avalonia.Wayland/WindowImplBase.cs
index 8fe854feb5..60125386fc 100644
--- a/src/Avalonia.Wayland/WindowImplBase.cs
+++ b/src/Avalonia.Wayland/WindowImplBase.cs
@@ -78,12 +78,8 @@ internal abstract partial class WindowBaseImpl : IWindowBaseImpl
     public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } = default;
     public void SetTransparencyLevelHint(IReadOnlyList<WindowTransparencyLevel> transparencyLevels) { }
 
-    public async void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
+    public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
     {
-        if (themeVariant == null && AvaloniaLocator.Current.GetService<IPlatformSettings>() is DBusPlatformSettings platformSettings)
-        {
-            platformSettings.OnRequestDefaultThemeVariant();
-        }
     }
 
     public Action? Closed { get; set; }
diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index 0ae2880499..c8a85b30ba 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -1720,12 +1720,8 @@ namespace Avalonia.X11
         public WindowTransparencyLevel TransparencyLevel =>
             _transparencyHelper?.CurrentLevel ?? WindowTransparencyLevel.None;
 
-        public async void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
+        public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
         {
-            if (themeVariant == null && AvaloniaLocator.Current.GetService<IPlatformSettings>() is DBusPlatformSettings platformSettings)
-            {
-                platformSettings.OnRequestDefaultThemeVariant();
-            }
         }
 
         public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } = new AcrylicPlatformCompensationLevels(1, 0.8, 0.8);
diff --git a/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs b/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs
index 5d9f18d993..ceaece821b 100644
--- a/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs
+++ b/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs
@@ -9,6 +9,7 @@ internal class BrowserPlatformSettings : DefaultPlatformSettings
     private bool _isDarkMode;
     private bool _isHighContrast;
     private bool _isInitialized;
+    private PlatformColorValues? _colorValues;
 
     public override event EventHandler<PlatformColorValues>? ColorValuesChanged
     {
@@ -22,25 +23,27 @@ internal class BrowserPlatformSettings : DefaultPlatformSettings
 
     public override PlatformColorValues GetColorValues()
     {
-        EnsureBackend();
+        if (_colorValues is null)
+        {
+            EnsureBackend();
+            _colorValues = BuildPlatformColorValues(_isDarkMode, _isHighContrast);
+        }
+
+        return _colorValues;
+    }
 
-        return base.GetColorValues() with
+    private static PlatformColorValues BuildPlatformColorValues(bool isDarkMode, bool isHighContrast)
+        => new()
         {
-            ThemeVariant = _isDarkMode ? PlatformThemeVariant.Dark : PlatformThemeVariant.Light,
-            ContrastPreference = _isHighContrast ? ColorContrastPreference.High : ColorContrastPreference.NoPreference
+            ThemeVariant = isDarkMode ? PlatformThemeVariant.Dark : PlatformThemeVariant.Light,
+            ContrastPreference = isHighContrast ? ColorContrastPreference.High : ColorContrastPreference.NoPreference
         };
-    }
 
     public void OnValuesChanged(bool isDarkMode, bool isHighContrast)
     {
         _isDarkMode = isDarkMode;
         _isHighContrast = isHighContrast;
-        OnColorValuesChanged(GetColorValues());
-    }
-
-    public void OnValuesChanged()
-    {
-        OnColorValuesChanged(GetColorValues());
+        UpdateColorValues();
     }
     
     private void EnsureBackend()
@@ -57,4 +60,16 @@ internal class BrowserPlatformSettings : DefaultPlatformSettings
             }
         }
     }
+
+    private void UpdateColorValues()
+    {
+        var oldColorValues = _colorValues;
+        var colorValues = BuildPlatformColorValues(_isDarkMode, _isHighContrast);
+
+        if (oldColorValues != colorValues)
+        {
+            _colorValues = colorValues;
+            OnColorValuesChanged(colorValues);
+        }
+    }
 }
diff --git a/src/Browser/Avalonia.Browser/BrowserTopLevelImpl.cs b/src/Browser/Avalonia.Browser/BrowserTopLevelImpl.cs
index 67773a6d5c..b4a85a6c9d 100644
--- a/src/Browser/Avalonia.Browser/BrowserTopLevelImpl.cs
+++ b/src/Browser/Avalonia.Browser/BrowserTopLevelImpl.cs
@@ -146,11 +146,6 @@ namespace Avalonia.Browser
 
         public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
         {
-            // not in the standard, but we potentially can use "apple-mobile-web-app-status-bar-style" for iOS and "theme-color" for android.
-            if (themeVariant == null && AvaloniaLocator.Current.GetService<IPlatformSettings>() is BrowserPlatformSettings platformSettings)
-            {
-                platformSettings.OnValuesChanged();
-            }
         }
 
         public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; }
diff --git a/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs b/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
index efcdb32458..480eee9e67 100644
--- a/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
+++ b/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
@@ -12,6 +12,8 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
         WinRTApiInformation.IsTypePresent("Windows.UI.ViewManagement.UISettings")
         && WinRTApiInformation.IsTypePresent("Windows.UI.ViewManagement.AccessibilitySettings"));
 
+    private PlatformColorValues? _colorValues;
+
     public override Size GetTapSize(PointerType type)
     {
         return type switch
@@ -33,10 +35,16 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
     public override TimeSpan GetDoubleTapTime(PointerType type) => TimeSpan.FromMilliseconds(GetDoubleClickTime());
     
     public override PlatformColorValues GetColorValues()
+        => _colorValues ??= GetUncachedColorValues();
+
+    private PlatformColorValues GetUncachedColorValues()
     {
         if (!s_uiSettingsSupported.Value)
         {
-            return base.GetColorValues();
+            return new PlatformColorValues
+            {
+                ThemeVariant = PlatformThemeVariant.Light
+            };
         }
 
         var uiSettings = NativeWinRTMethods.CreateInstance<IUISettings3>("Windows.UI.ViewManagement.UISettings");
@@ -50,7 +58,7 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
             // - Desert - High Contrast White
             // - Dusk - High Contrast #1
             // - Night sky - High Contrast #2
-            // Only "Desert" one can be considered a "light" preference. 
+            // Only "Desert" one can be considered a "light" preference.
             using var highContrastScheme = new HStringInterop(accessibilitySettings.HighContrastScheme);
             return new PlatformColorValues
             {
@@ -72,12 +80,19 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
                     PlatformThemeVariant.Light,
                 ContrastPreference = ColorContrastPreference.NoPreference,
                 AccentColor1 = accent
-            };   
+            };
         }
     }
-    
+
     internal void OnColorValuesChanged()
     {
-        OnColorValuesChanged(GetColorValues());
+        var oldColorValues = _colorValues;
+        var colorValues = GetUncachedColorValues();
+
+        if (oldColorValues != colorValues)
+        {
+            _colorValues = colorValues;
+            OnColorValuesChanged(colorValues);
+        }
     }
 }
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs
index e07454a8ee..31be8012cf 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -964,8 +964,6 @@ namespace Avalonia.Win32
                     SetTransparencyMica();
                 }
             }
-
-            (Win32Platform.Instance.PlatformSettings as Win32PlatformSettings)?.OnColorValuesChanged();
         }
 
         protected virtual IntPtr CreateWindowOverride(ushort atom)
diff --git a/src/iOS/Avalonia.iOS/AvaloniaView.cs b/src/iOS/Avalonia.iOS/AvaloniaView.cs
index 566f210529..98c4d1ff2f 100644
--- a/src/iOS/Avalonia.iOS/AvaloniaView.cs
+++ b/src/iOS/Avalonia.iOS/AvaloniaView.cs
@@ -256,11 +256,6 @@ namespace Avalonia.iOS
 
             public void SetFrameThemeVariant(PlatformThemeVariant? themeVariant)
             {
-                if (themeVariant is null && AvaloniaLocator.Current.GetService<IPlatformSettings>() is PlatformSettings settings)
-                {
-                    settings.OnColorValuesChanged();
-                }
-
 #if !TVOS
                 // TODO adjust status bar depending on full screen mode.
                 if ((OperatingSystem.IsIOSVersionAtLeast(13)
diff --git a/src/iOS/Avalonia.iOS/PlatformSettings.cs b/src/iOS/Avalonia.iOS/PlatformSettings.cs
index bf371d82c1..e355a1bdf6 100644
--- a/src/iOS/Avalonia.iOS/PlatformSettings.cs
+++ b/src/iOS/Avalonia.iOS/PlatformSettings.cs
@@ -8,9 +8,12 @@ namespace Avalonia.iOS;
 // TODO: ideally should be created per view/activity.
 internal class PlatformSettings : DefaultPlatformSettings
 {
-    private PlatformColorValues? _lastColorValues;
+    private PlatformColorValues? _colorValues;
 
     public override PlatformColorValues GetColorValues()
+        => _colorValues ??= GetUncachedColorValues();
+
+    private static PlatformColorValues GetUncachedColorValues()
     {
         var themeVariant = UITraitCollection.CurrentTraitCollection.UserInterfaceStyle == UIUserInterfaceStyle.Dark ?
             PlatformThemeVariant.Dark :
@@ -32,7 +35,7 @@ internal class PlatformSettings : DefaultPlatformSettings
             tintColor.GetRGBA(out var red, out var green, out var blue, out var alpha);
             if (red != 0 && green != 0 && blue != 0 && alpha != 0)
             {
-                return _lastColorValues = new PlatformColorValues
+                return new PlatformColorValues
                 {
                     ThemeVariant = themeVariant,
                     ContrastPreference = contrastPreference,
@@ -45,25 +48,22 @@ internal class PlatformSettings : DefaultPlatformSettings
             }
         }
 
-        return _lastColorValues = new PlatformColorValues
+        return new PlatformColorValues
         {
-            ThemeVariant = themeVariant, ContrastPreference = contrastPreference
+            ThemeVariant = themeVariant,
+            ContrastPreference = contrastPreference
         };
     }
 
     public void TraitCollectionDidChange()
     {
-        var oldColorValues = _lastColorValues;
-        var colorValues = GetColorValues();
+        var oldColorValues = _colorValues;
+        var colorValues = GetUncachedColorValues();
 
         if (oldColorValues != colorValues)
         {
+            _colorValues = colorValues;
             OnColorValuesChanged(colorValues);
         }
     }
-
-    internal void OnColorValuesChanged()
-    {
-        OnColorValuesChanged(GetColorValues());
-    }
 }
diff --git a/tests/Avalonia.Controls.UnitTests/ThemeVariantTests.cs b/tests/Avalonia.Controls.UnitTests/ThemeVariantTests.cs
new file mode 100644
index 0000000000..1848571ec2
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/ThemeVariantTests.cs
@@ -0,0 +1,211 @@
+using System;
+using Avalonia.Platform;
+using Avalonia.Styling;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests;
+
+public class ThemeVariantTests : ScopedTestBase
+{
+    [Fact]
+    public void Application_ActualThemeVariant_Falls_Back_To_Light_Without_Platform_Settings()
+    {
+        var application = new Application();
+        application.InitializeThemeVariant();
+
+        Assert.Equal(ThemeVariant.Light, application.ActualThemeVariant);
+    }
+
+    [Theory]
+    [InlineData(PlatformThemeVariant.Light)]
+    [InlineData(PlatformThemeVariant.Dark)]
+    public void Application_ActualThemeVariant_Is_Initialized_From_Platform_Settings(
+        PlatformThemeVariant platformThemeVariant)
+    {
+        using var app = StartApplication(new TestPlatformSettings(platformThemeVariant));
+
+        Assert.Equal((ThemeVariant)platformThemeVariant, Application.Current!.ActualThemeVariant);
+    }
+
+    [Fact]
+    public void Application_ActualThemeVariant_Follows_Platform_Settings_Changes()
+    {
+        var platformSettings = new TestPlatformSettings(PlatformThemeVariant.Light);
+        using var app = StartApplication(platformSettings);
+        var application = Application.Current!;
+
+        var raised = 0;
+        application.ActualThemeVariantChanged += (_, _) => ++raised;
+
+        platformSettings.ThemeVariant = PlatformThemeVariant.Dark;
+
+        Assert.Equal(ThemeVariant.Dark, application.ActualThemeVariant);
+        Assert.Equal(1, raised);
+    }
+
+    [Fact]
+    public void Application_RequestedThemeVariant_Overrides_Platform_Settings()
+    {
+        var platformSettings = new TestPlatformSettings(PlatformThemeVariant.Light);
+        using var app = StartApplication(platformSettings);
+        var application = Application.Current!;
+
+        application.RequestedThemeVariant = ThemeVariant.Dark;
+
+        Assert.Equal(ThemeVariant.Dark, application.ActualThemeVariant);
+
+        platformSettings.ThemeVariant = PlatformThemeVariant.Light;
+        Assert.Equal(ThemeVariant.Dark, application.ActualThemeVariant);
+    }
+
+    [Fact]
+    public void Application_ActualThemeVariant_Reverts_To_Platform_Settings_When_Requesting_Default()
+    {
+        var platformSettings = new TestPlatformSettings(PlatformThemeVariant.Dark);
+        using var app = StartApplication(platformSettings);
+        var application = Application.Current!;
+
+        application.RequestedThemeVariant = ThemeVariant.Light;
+        Assert.Equal(ThemeVariant.Light, application.ActualThemeVariant);
+
+        application.RequestedThemeVariant = ThemeVariant.Default;
+        Assert.Equal(ThemeVariant.Dark, application.ActualThemeVariant);
+    }
+
+    [Fact]
+    public void Application_ActualThemeVariant_Reverts_To_Platform_Settings_When_Requesting_Null()
+    {
+        var platformSettings = new TestPlatformSettings(PlatformThemeVariant.Dark);
+        using var app = StartApplication(platformSettings);
+        var application = Application.Current!;
+
+        application.RequestedThemeVariant = ThemeVariant.Light;
+        Assert.Equal(ThemeVariant.Light, application.ActualThemeVariant);
+
+        application.RequestedThemeVariant = null;
+        Assert.Equal(ThemeVariant.Dark, application.ActualThemeVariant);
+    }
+
+    [Fact]
+    public void Application_Custom_ThemeVariant_Is_Used_As_Is()
+    {
+        var custom = new ThemeVariant("Custom", ThemeVariant.Dark);
+        using var app = StartApplication(new TestPlatformSettings(PlatformThemeVariant.Light));
+        var application = Application.Current!;
+
+        application.RequestedThemeVariant = custom;
+
+        Assert.Equal(custom, application.ActualThemeVariant);
+    }
+
+    [Fact]
+    public void TopLevel_ActualThemeVariant_Is_Initialized_From_Application()
+    {
+        using var app = StartApplication(new TestPlatformSettings(PlatformThemeVariant.Light));
+
+        BindApplicationAsThemeVariantHost();
+        Application.Current!.RequestedThemeVariant = ThemeVariant.Dark;
+
+        var window = new Window();
+
+        Assert.Equal(ThemeVariant.Dark, window.ActualThemeVariant);
+    }
+
+    [Fact]
+    public void TopLevel_ActualThemeVariant_Is_Initialized_From_Platform_Settings_Without_ThemeVariantHost()
+    {
+        using var app = StartApplication(new TestPlatformSettings(PlatformThemeVariant.Dark));
+
+        var window = new Window();
+
+        Assert.Equal(ThemeVariant.Dark, window.ActualThemeVariant);
+    }
+
+    [Fact]
+    public void TopLevel_ActualThemeVariant_Follows_Application()
+    {
+        var platformSettings = new TestPlatformSettings(PlatformThemeVariant.Light);
+        using var app = StartApplication(platformSettings);
+        var application = Application.Current!;
+
+        BindApplicationAsThemeVariantHost();
+
+        var window = new Window();
+        Assert.Equal(ThemeVariant.Light, window.ActualThemeVariant);
+
+        application.RequestedThemeVariant = ThemeVariant.Dark;
+        Assert.Equal(ThemeVariant.Dark, window.ActualThemeVariant);
+
+        application.RequestedThemeVariant = ThemeVariant.Default;
+        Assert.Equal(ThemeVariant.Light, window.ActualThemeVariant);
+
+        platformSettings.ThemeVariant = PlatformThemeVariant.Dark;
+        Assert.Equal(ThemeVariant.Dark, window.ActualThemeVariant);
+    }
+
+    [Fact]
+    public void TopLevel_RequestedThemeVariant_Overrides_Application_And_Is_Sent_To_Platform_Impl()
+    {
+        using var app = StartApplication(new TestPlatformSettings(PlatformThemeVariant.Dark));
+
+        BindApplicationAsThemeVariantHost();
+
+        var window = new Window { RequestedThemeVariant = ThemeVariant.Light };
+
+        Assert.Equal(ThemeVariant.Dark, Application.Current!.ActualThemeVariant);
+        Assert.Equal(ThemeVariant.Light, window.ActualThemeVariant);
+    }
+
+    [Fact]
+    public void TopLevel_ActualThemeVariant_Is_Inherited_By_Children()
+    {
+        using var app = StartApplication(new TestPlatformSettings(PlatformThemeVariant.Dark));
+
+        BindApplicationAsThemeVariantHost();
+
+        var child = new Border();
+        var scope = new ThemeVariantScope { Child = child };
+        var window = new Window { Content = scope };
+        window.Show();
+
+        Assert.Equal(ThemeVariant.Dark, scope.ActualThemeVariant);
+        Assert.Equal(ThemeVariant.Dark, child.ActualThemeVariant);
+
+        scope.RequestedThemeVariant = ThemeVariant.Light;
+
+        Assert.Equal(ThemeVariant.Dark, window.ActualThemeVariant);
+        Assert.Equal(ThemeVariant.Light, scope.ActualThemeVariant);
+        Assert.Equal(ThemeVariant.Light, child.ActualThemeVariant);
+    }
+
+    [Fact]
+    public void ThemeVariantScope_Requesting_Default_Reinherits_From_Parent()
+    {
+        using var app = StartApplication(new TestPlatformSettings(PlatformThemeVariant.Light));
+
+        BindApplicationAsThemeVariantHost();
+        Application.Current!.RequestedThemeVariant = ThemeVariant.Dark;
+
+        var child = new Border();
+        var scope = new ThemeVariantScope { Child = child };
+        var window = new Window { Content = scope };
+        window.Show();
+
+        scope.RequestedThemeVariant = ThemeVariant.Light;
+        Assert.Equal(ThemeVariant.Light, scope.ActualThemeVariant);
+        Assert.Equal(ThemeVariant.Light, child.ActualThemeVariant);
+
+        scope.RequestedThemeVariant = ThemeVariant.Default;
+        Assert.Equal(ThemeVariant.Dark, scope.ActualThemeVariant);
+        Assert.Equal(ThemeVariant.Dark, child.ActualThemeVariant);
+    }
+
+    private static IDisposable StartApplication(TestPlatformSettings platformSettings)
+        => UnitTestApplication.Start(TestServices.StyledWindow.With(
+            platformSettings: platformSettings,
+            windowingPlatform: new MockWindowingPlatform()));
+
+    private static void BindApplicationAsThemeVariantHost()
+        => AvaloniaLocator.CurrentMutable.Bind<IThemeVariantHost>().ToConstant(Application.Current!);
+}
diff --git a/tests/Avalonia.UnitTests/TestPlatformSettings.cs b/tests/Avalonia.UnitTests/TestPlatformSettings.cs
new file mode 100644
index 0000000000..cb667f2ee0
--- /dev/null
+++ b/tests/Avalonia.UnitTests/TestPlatformSettings.cs
@@ -0,0 +1,23 @@
+using Avalonia.Platform;
+
+namespace Avalonia.UnitTests;
+
+public class TestPlatformSettings(PlatformThemeVariant themeVariant)
+    : DefaultPlatformSettings
+{
+    private PlatformColorValues _colorValues = new() { ThemeVariant = themeVariant };
+
+    public override PlatformColorValues GetColorValues() => _colorValues;
+
+    public PlatformThemeVariant ThemeVariant
+    {
+        get => _colorValues.ThemeVariant;
+        set => SetColorValues(_colorValues with { ThemeVariant = value });
+    }
+
+    public void SetColorValues(PlatformColorValues colorValues)
+    {
+        _colorValues = colorValues;
+        OnColorValuesChanged(colorValues);
+    }
+}
diff --git a/tests/Avalonia.UnitTests/TestServices.cs b/tests/Avalonia.UnitTests/TestServices.cs
index 5c8cd6d776..07152a3d42 100644
--- a/tests/Avalonia.UnitTests/TestServices.cs
+++ b/tests/Avalonia.UnitTests/TestServices.cs
@@ -77,6 +77,7 @@ namespace Avalonia.UnitTests
             Func<IMouseDevice?>? mouseDevice = null,
             IRuntimePlatform? platform = null,
             IPlatformRenderInterface? renderInterface = null,
+            IPlatformSettings? platformSettings = null,
             ICursorFactory? standardCursorFactory = null,
             Func<IStyle>? theme = null,
             IFontManagerImpl? fontManagerImpl = null,
@@ -94,6 +95,7 @@ namespace Avalonia.UnitTests
             MouseDevice = mouseDevice;
             Platform = platform;
             RenderInterface = renderInterface;
+            PlatformSettings = platformSettings;
             FontManagerImpl = fontManagerImpl;
             TextShaperImpl = textShaperImpl;
             StandardCursorFactory = standardCursorFactory;
@@ -111,6 +113,7 @@ namespace Avalonia.UnitTests
         public Func<IMouseDevice?>? MouseDevice { get; }
         public IRuntimePlatform? Platform { get; }
         public IPlatformRenderInterface? RenderInterface { get; }
+        public IPlatformSettings? PlatformSettings { get; }
         public IFontManagerImpl? FontManagerImpl { get; }
         public ITextShaperImpl? TextShaperImpl { get; }
         public ICursorFactory? StandardCursorFactory { get; }
@@ -128,6 +131,7 @@ namespace Avalonia.UnitTests
             Func<IMouseDevice?>? mouseDevice = null,
             IRuntimePlatform? platform = null,
             IPlatformRenderInterface? renderInterface = null,
+            IPlatformSettings? platformSettings = null,
             IRenderTimer? renderLoop = null,
             IScheduler? scheduler = null,
             ICursorFactory? standardCursorFactory = null,
@@ -147,6 +151,7 @@ namespace Avalonia.UnitTests
                 mouseDevice: mouseDevice ?? MouseDevice,
                 platform: platform ?? Platform,
                 renderInterface: renderInterface ?? RenderInterface,
+                platformSettings: platformSettings ?? PlatformSettings,
                 fontManagerImpl: fontManagerImpl ?? FontManagerImpl,
                 textShaperImpl: textShaperImpl ?? TextShaperImpl,
                 standardCursorFactory: standardCursorFactory ?? StandardCursorFactory,
diff --git a/tests/Avalonia.UnitTests/UnitTestApplication.cs b/tests/Avalonia.UnitTests/UnitTestApplication.cs
index e2bfc9e86c..f2b1b47b6e 100644
--- a/tests/Avalonia.UnitTests/UnitTestApplication.cs
+++ b/tests/Avalonia.UnitTests/UnitTestApplication.cs
@@ -88,9 +88,11 @@ namespace Avalonia.UnitTests
                 .Bind<ICursorFactory?>().ToConstant(Services.StandardCursorFactory)
                 .Bind<IWindowingPlatform?>().ToConstant(Services.WindowingPlatform)
                 .Bind<PlatformHotkeyConfiguration>().ToSingleton<PlatformHotkeyConfiguration>()
-                .Bind<IPlatformSettings>().ToSingleton<DefaultPlatformSettings>()
+                .Bind<IPlatformSettings>().ToConstant(Services.PlatformSettings ?? new DefaultPlatformSettings())
                 .Bind<IAccessKeyHandler?>().ToFunc(Services.AccessKeyHandler ?? (() => null));
-            
+
+            InitializeThemeVariant();
+
             // This is a hack to make tests work, we need to refactor the way font manager is registered
             // See https://github.com/AvaloniaUI/Avalonia/issues/10081
             AvaloniaLocator.CurrentMutable.Bind<FontManager>().ToConstant((FontManager)null!);

From bedb2ecf477b7aaa3e9b3af4950437cc90d74870 Mon Sep 17 00:00:00 2001
From: Unrealiter <visualstudio13@outlook.de>
Date: Tue, 18 Aug 2026 15:44:29 +0000
Subject: [PATCH 172/196] add support for CreateSourceInfo in design window
 loader (#21972)

* feat: add support for CreateSourceInfo in design window loader

* Move XAML SourceInfo default to RuntimeXamlLoaderConfiguration

Applies to all designer/runtime load paths now; newer VS and VS Code designers do not use DesignWindowLoader.

---------

Co-authored-by: Kim Henrik <KimHenrik@outlook.de>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../XamlCompilerTaskExecutor.cs               |  6 +++++
 .../RuntimeXamlLoaderConfiguration.cs         | 25 +++++++++++++++++--
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.cs b/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.cs
index acf90179b1..d11fd08343 100644
--- a/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.cs
+++ b/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.cs
@@ -157,6 +157,12 @@ namespace Avalonia.Build.Tasks
                 var arg1 = new CustomAttributeArgument(strType, "AvaloniaUseCompiledBindingsByDefault");
                 var arg2 = new CustomAttributeArgument(strType, defaultCompileBindings.ToString());
                 asm.CustomAttributes.Add(new CustomAttribute(ctor) { ConstructorArguments = { arg1, arg2 } });
+                if (createSourceInfo)
+                {
+                    var arg3 = new CustomAttributeArgument(strType, "AvaloniaXamlCreateSourceInfo");
+                    var arg4 = new CustomAttributeArgument(strType, createSourceInfo.ToString());
+                    asm.CustomAttributes.Add(new CustomAttribute(ctor) { ConstructorArguments = { arg3, arg4 } });
+                }
             }
 
             TypeDefinition AddClass(string name, TypeAttributes extraAttributes = 0)
diff --git a/src/Markup/Avalonia.Markup.Xaml/RuntimeXamlLoaderConfiguration.cs b/src/Markup/Avalonia.Markup.Xaml/RuntimeXamlLoaderConfiguration.cs
index c9c421b766..73713e5d5b 100644
--- a/src/Markup/Avalonia.Markup.Xaml/RuntimeXamlLoaderConfiguration.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/RuntimeXamlLoaderConfiguration.cs
@@ -1,10 +1,16 @@
 using System;
+using System.Linq;
 using System.Reflection;
 
 namespace Avalonia.Markup.Xaml;
 
 public class RuntimeXamlLoaderConfiguration
 {
+    /// <summary>
+    /// When enabled, the XAML compiler embeds SourceInfo metadata (file path, line, and column) into generated code.
+    /// </summary>
+    private bool? _createSourceInfo = null;
+
     /// <summary>
     /// Default assembly for clr-namespace:.
     /// </summary>
@@ -24,9 +30,24 @@ public class RuntimeXamlLoaderConfiguration
 
     /// <summary>
     /// When enabled, the XAML compiler embeds SourceInfo metadata (file path, line, and column) into generated code.
-    /// Default is 'false'.
+    /// When not explicitly set, the 'AvaloniaXamlCreateSourceInfo' from the LocalAssembly will be used to determine the value.
     /// </summary>
-    public bool CreateSourceInfo { get; set; } = false;
+    public bool CreateSourceInfo 
+    { 
+        get {
+            if(_createSourceInfo == null)
+            {
+                if(LocalAssembly is {} asm)
+                {
+                    var createSourceInfo = asm.GetCustomAttributes<AssemblyMetadataAttribute>()
+                        .FirstOrDefault(a => a.Key == "AvaloniaXamlCreateSourceInfo")?.Value;
+                    return bool.TryParse(createSourceInfo, out var parsedCreateSourceInfo) && parsedCreateSourceInfo;
+                }
+            }   
+            return _createSourceInfo ?? false;
+        }
+        set => _createSourceInfo = value; 
+    }
 
     /// <summary>
     /// XAML diagnostics handler.

From 7f369787ab798b724462333b999c07bc703a6cce Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Tue, 18 Aug 2026 18:41:28 +0000
Subject: [PATCH 173/196] Add Input Pane Awareness. (#21566)

* Add InputPaneAwareDecorator

* remove redundant coerse
---
 samples/SafeAreaDemo/Views/MainView.xaml      | 129 ++++++++------
 .../InputPaneAwareBehavior.cs                 |  23 +++
 .../InputPaneAwareDecorator.cs                | 142 +++++++++++++++
 .../Platform/InputPaneTests.cs                | 166 ++++++++++++++++++
 4 files changed, 402 insertions(+), 58 deletions(-)
 create mode 100644 src/Avalonia.Controls/InputPaneAwareBehavior.cs
 create mode 100644 src/Avalonia.Controls/InputPaneAwareDecorator.cs
 create mode 100644 tests/Avalonia.Controls.UnitTests/Platform/InputPaneTests.cs

diff --git a/samples/SafeAreaDemo/Views/MainView.xaml b/samples/SafeAreaDemo/Views/MainView.xaml
index c62410aa83..1a33683ab6 100644
--- a/samples/SafeAreaDemo/Views/MainView.xaml
+++ b/samples/SafeAreaDemo/Views/MainView.xaml
@@ -9,64 +9,77 @@
              x:Class="SafeAreaDemo.Views.MainView"
              x:DataType="vm:MainViewModel"
              TopLevel.AutoSafeAreaPadding="{Binding AutoSafeAreaPadding, Mode=TwoWay}">
-    <Grid HorizontalAlignment="Stretch"
-          VerticalAlignment="Stretch"
-          Bounds="{Binding CanvasSize, Mode=OneWayToSource}">
-      <Border BorderBrush="Red"
-              Margin="{Binding ViewPadding}"
-              BorderThickness="1">
+  <Grid HorizontalAlignment="Stretch"
+        VerticalAlignment="Stretch"
+        Bounds="{Binding CanvasSize, Mode=OneWayToSource}">
+    <Border BorderBrush="Red"
+            Margin="{Binding ViewPadding}"
+            BorderThickness="1">
+      <Grid>
+        <Label Margin="5"
+               Foreground="Red"
+               HorizontalAlignment="Stretch"
+               HorizontalContentAlignment="Right">View Bounds</Label>
+        <Label Margin="5"
+               Foreground="Red"
+               VerticalAlignment="Bottom"
+               HorizontalContentAlignment="Right">View Bounds</Label>
+      </Grid>
+    </Border>
+    <Border BorderBrush="LimeGreen"
+            Margin="{Binding SafeAreaPadding}"
+            BorderThickness="1">
+      <Grid>
+        <Label Margin="5"
+               Foreground="LimeGreen"
+               VerticalAlignment="Bottom"
+               HorizontalAlignment="Stretch"
+               HorizontalContentAlignment="Left" >Safe Area</Label>
+        <InputPaneAwareDecorator Behavior="Pan">
+          <Border  BorderBrush="Blue"
+                   BorderThickness="1">
             <Grid>
-            <Label Margin="5"
-                   Foreground="Red"
-                   HorizontalAlignment="Stretch"
-                   HorizontalContentAlignment="Right">View Bounds</Label>
-            <Label Margin="5"
-                   Foreground="Red"
-                   VerticalAlignment="Bottom"
-                   HorizontalContentAlignment="Right">View Bounds</Label>
+              <Label Margin="5"
+                     Foreground="Blue"
+                     HorizontalAlignment="Center"
+                     VerticalAlignment="Bottom"
+                     HorizontalContentAlignment="Center" >Input Pane Aware Area</Label>
+              <Grid DockPanel.Dock="Bottom"
+                    HorizontalAlignment="Stretch"
+                    VerticalAlignment="Stretch">
+                <StackPanel Orientation="Vertical"
+                            Spacing="5"
+                            HorizontalAlignment="Center"
+                            VerticalAlignment="Center">
+                  <Label HorizontalAlignment="Left">Options:</Label>
+                  <CheckBox IsChecked="{Binding DisplayEdgeToEdge}">Display Edge To Edge</CheckBox>
+                  <CheckBox IsChecked="{Binding UseSafeArea}" IsEnabled="{Binding !AutoSafeAreaPadding}">Use Safe Area</CheckBox>
+                  <CheckBox IsChecked="{Binding AutoSafeAreaPadding}">Automatic Paddings</CheckBox>
+                  <CheckBox IsChecked="{Binding HideSystemBars}">Hide System Bars</CheckBox>
+                  <TextBox Width="200" PlaceholderText="Tap to Show Keyboard"/>
+                  <StackPanel Orientation="Horizontal" Spacing="10">
+                    <Button Command="{Binding SetLight}">Light</Button>
+                    <Button Command="{Binding SetDark}">Dark</Button>
+                    <Button Command="{Binding SetDefault}">Default</Button>
+                  </StackPanel>
+                </StackPanel>
+              </Grid>
             </Grid>
-        </Border>
-        <Border BorderBrush="LimeGreen"
-                Margin="{Binding SafeAreaPadding}"
-                BorderThickness="1">
-            <DockPanel>
-                <Label Margin="5"
-                       Foreground="LimeGreen"
-                       DockPanel.Dock="Bottom"
-                       HorizontalAlignment="Stretch"
-                       HorizontalContentAlignment="Left" >Safe Area</Label>
-                <Grid DockPanel.Dock="Bottom"
-                      HorizontalAlignment="Stretch"
-                      VerticalAlignment="Stretch">
-                    <StackPanel Orientation="Vertical"
-                                Spacing="5"
-                                HorizontalAlignment="Center"
-                                VerticalAlignment="Center">
-                        <Label HorizontalAlignment="Left">Options:</Label>
-                        <CheckBox IsChecked="{Binding DisplayEdgeToEdge}">Display Edge To Edge</CheckBox>
-                        <CheckBox IsChecked="{Binding UseSafeArea}" IsEnabled="{Binding !AutoSafeAreaPadding}">Use Safe Area</CheckBox>
-                        <CheckBox IsChecked="{Binding AutoSafeAreaPadding}">Automatic Paddings</CheckBox>
-                        <CheckBox IsChecked="{Binding HideSystemBars}">Hide System Bars</CheckBox>
-                        <TextBox Width="200" PlaceholderText="Tap to Show Keyboard"/>
-                        <StackPanel Orientation="Horizontal" Spacing="10">
-                          <Button Command="{Binding SetLight}">Light</Button>
-                          <Button Command="{Binding SetDark}">Dark</Button>
-                          <Button Command="{Binding SetDefault}">Default</Button>
-                        </StackPanel>
-                    </StackPanel>
-                </Grid>
-            </DockPanel>
-        </Border>
-        <Button Margin="{Binding InputPaneMarkerMargin}"
-                VerticalAlignment="Bottom"
-                Content="X">
-          <Button.Transitions>
-            <Transitions>
-              <ThicknessTransition Property="Margin"
-                                   Duration="{Binding InputPaneDuration}"
-                                   Easing="{Binding InputPaneEasing}"/>
-            </Transitions>
-          </Button.Transitions>
-        </Button>
-    </Grid>
+          </Border>
+        </InputPaneAwareDecorator>
+
+      </Grid>
+    </Border>
+    <Button Margin="{Binding InputPaneMarkerMargin}"
+            VerticalAlignment="Bottom"
+            Content="X">
+      <Button.Transitions>
+        <Transitions>
+          <ThicknessTransition Property="Margin"
+                               Duration="{Binding InputPaneDuration}"
+                               Easing="{Binding InputPaneEasing}"/>
+        </Transitions>
+      </Button.Transitions>
+    </Button>
+  </Grid>
 </UserControl>
diff --git a/src/Avalonia.Controls/InputPaneAwareBehavior.cs b/src/Avalonia.Controls/InputPaneAwareBehavior.cs
new file mode 100644
index 0000000000..19bff0ff11
--- /dev/null
+++ b/src/Avalonia.Controls/InputPaneAwareBehavior.cs
@@ -0,0 +1,23 @@
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Specifies the behavior <see cref="InputPaneAwareDecorator"/> takes when input pane state changes.
+    /// </summary>
+    public enum InputPaneAwareBehavior
+    {
+        /// <summary>
+        /// The view doesn't resize or move the content when input pane state changes.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// The view moves the content vertically when input pane states changes. The content is not resized.
+        /// </summary>
+        Pan,
+
+        /// <summary>
+        /// The view resizes the content when input pane state changes.
+        /// </summary>
+        Resize
+    }
+}
diff --git a/src/Avalonia.Controls/InputPaneAwareDecorator.cs b/src/Avalonia.Controls/InputPaneAwareDecorator.cs
new file mode 100644
index 0000000000..fdcb59b25f
--- /dev/null
+++ b/src/Avalonia.Controls/InputPaneAwareDecorator.cs
@@ -0,0 +1,142 @@
+using System.Diagnostics.CodeAnalysis;
+using Avalonia.Animation;
+using Avalonia.Animation.Easings;
+using Avalonia.Controls.Platform;
+
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// A control that automatically adjusts its child position or height based on the input pane's height to ensure the content is visible.
+    /// </summary>
+    public class InputPaneAwareDecorator : Decorator
+    {
+        private InputPaneAwareBehavior _behavior;
+        private IInputPane? _inputPane;
+        private bool _firstLayoutDone;
+
+        /// <summary>
+        /// Defines the <see cref="Behavior"/> property.
+        /// </summary>
+        public static readonly DirectProperty<InputPaneAwareDecorator, InputPaneAwareBehavior> BehaviorProperty = AvaloniaProperty.RegisterDirect<InputPaneAwareDecorator, InputPaneAwareBehavior>(
+            nameof(Behavior),
+            o => o.Behavior,
+            (o, x) => o.Behavior = x);
+
+        private static readonly StyledProperty<double> CurrentInputPanePaddingProperty = AvaloniaProperty.Register<InputPaneAwareDecorator, double>(
+            nameof(CurrentInputPanePadding));
+
+        /// <summary>
+        /// Gets or sets how the view reacts to the input pane state. 
+        /// </summary>
+        public InputPaneAwareBehavior Behavior
+        {
+            get => _behavior;
+            set => SetAndRaise(BehaviorProperty, ref _behavior, value);
+        }
+
+        private double CurrentInputPanePadding
+        {
+            get => GetValue(CurrentInputPanePaddingProperty);
+            set => SetValue(CurrentInputPanePaddingProperty, value);
+        }
+
+        static InputPaneAwareDecorator()
+        {
+            AffectsMeasure<InputPaneAwareDecorator>(BehaviorProperty, CurrentInputPanePaddingProperty);
+            AffectsArrange<InputPaneAwareDecorator>(CurrentInputPanePaddingProperty);
+        }
+
+        protected override Size MeasureOverride(Size availableSize)
+        {
+            if (_inputPane != null && _firstLayoutDone && VisualRoot is { } root && Behavior == InputPaneAwareBehavior.Resize)
+            {
+                SetCurrentValue(PaddingProperty, new Thickness(0, 0, 0, CurrentInputPanePadding));
+            }
+            return base.MeasureOverride(availableSize);
+        }
+
+        protected override Size ArrangeOverride(Size finalSize)
+        {
+            _firstLayoutDone = true;
+
+            if (Behavior == InputPaneAwareBehavior.Pan)
+            {
+                Child?.Arrange(new Rect(new Point(0, -CurrentInputPanePadding), finalSize));
+
+                return finalSize;
+            }
+            else
+                return base.ArrangeOverride(finalSize);
+        }
+
+        protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+        {
+            base.OnAttachedToVisualTree(e);
+
+            _inputPane = TopLevel.GetTopLevel(this)?.InputPane;
+            _inputPane?.StateChanged += InputPaneAwareView_StateChanged;
+            EnsureInputPanePaddingApplied();
+        }
+
+        [UnconditionalSuppressMessage("AvaloniaProperty", "AVP1012")]
+        protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
+        {
+            base.OnDetachedFromVisualTree(e);
+            _inputPane?.StateChanged -= InputPaneAwareView_StateChanged;
+            _inputPane = null;
+            SetCurrentValue(PaddingProperty, default);
+            CurrentInputPanePadding = 0;
+        }
+
+        [UnconditionalSuppressMessage("AvaloniaProperty", "AVP1012")]
+        private void EnsureInputPanePaddingApplied()
+        {
+            SetCurrentValue(PaddingProperty, default);
+
+            if (_inputPane != null && _firstLayoutDone && this.VisualRoot is { } root && Behavior != InputPaneAwareBehavior.None)
+            {
+                var occludedRect = _inputPane.OccludedRect;
+
+                var transformMatrix = this.TransformToVisual(root) ?? Matrix.Identity;
+
+                var translatedRect = Bounds.TransformToAABB(transformMatrix);
+
+                var intersect = occludedRect.Intersect(translatedRect);
+                CurrentInputPanePadding = intersect.Height;
+            }
+            else
+            {
+                CurrentInputPanePadding = 0;
+            }
+        }
+
+        private void InputPaneAwareView_StateChanged(object? sender, InputPaneStateEventArgs e)
+        {
+            var transition = new DoubleTransition()
+            {
+                Property = CurrentInputPanePaddingProperty,
+                Duration = e.AnimationDuration,
+                Easing = e.Easing as Easing ?? new LinearEasing()
+            };
+
+            Transitions =
+            [
+                transition
+            ];
+
+            EnsureInputPanePaddingApplied();
+
+            InvalidateMeasure();
+        }
+
+        protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+        {
+            base.OnPropertyChanged(change);
+
+            if(change.Property == BehaviorProperty)
+            {
+                EnsureInputPanePaddingApplied();
+            }
+        }
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/Platform/InputPaneTests.cs b/tests/Avalonia.Controls.UnitTests/Platform/InputPaneTests.cs
new file mode 100644
index 0000000000..5d6c632065
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/Platform/InputPaneTests.cs
@@ -0,0 +1,166 @@
+using System;
+using Avalonia.Controls.Platform;
+using Avalonia.Controls.Presenters;
+using Avalonia.Controls.Templates;
+using Avalonia.Platform;
+using Avalonia.Threading;
+using Avalonia.UnitTests;
+using Moq;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests.Platform
+{
+    public class InputPaneTests : ScopedTestBase
+    {
+        [Fact]
+        public void InputPaneAwareView_Resizes_Content_When_Behavior_Resize()
+        {
+            var clock = new MockGlobalClock();
+            using (UnitTestApplication.Start(TestServices.RealFocus.
+                With(globalClock: clock)))
+            {
+                var inputPane = new TestInputPane(new Rect(0, 200, 200, 200));
+
+                var border = new Border();
+
+                var paneView = new InputPaneAwareDecorator()
+                {
+                    Child = border,
+                    Height = 500,
+                    Width = 200,
+                    Behavior = InputPaneAwareBehavior.Resize
+                };
+
+                var impl = CreateMockTopLevelImpl(inputPane);
+                var topLevel = new TestTopLevel(impl.Object)
+                {
+                    Template = CreateTopLevelTemplate(),
+                    Content = paneView
+                };
+
+                topLevel.LayoutManager.ExecuteInitialLayoutPass();
+
+                Assert.Equal(500, border.Bounds.Height);
+
+                inputPane.Open();
+
+                clock.Pulse(TimeSpan.FromSeconds(5));
+
+                topLevel.LayoutManager.ExecuteLayoutPass();
+
+                Assert.Equal(300, border.Bounds.Height);
+            }
+        }
+
+        [Fact]
+        public void InputPaneAwareView_Resizes_Content_When_Behavior_Pan()
+        {
+            var clock = new MockGlobalClock();
+            using (UnitTestApplication.Start(TestServices.RealFocus.
+                With(globalClock: clock)))
+            {
+                var inputPane = new TestInputPane(new Rect(0, 200, 200, 200));
+
+                var border = new Border();
+
+                var paneView = new InputPaneAwareDecorator()
+                {
+                    Child = border,
+                    Height = 500,
+                    Width = 200,
+                    Behavior = InputPaneAwareBehavior.Pan
+                };
+
+                var impl = CreateMockTopLevelImpl(inputPane);
+                var topLevel = new TestTopLevel(impl.Object)
+                {
+                    Template = CreateTopLevelTemplate(),
+                    Content = paneView
+                };
+
+                topLevel.LayoutManager.ExecuteInitialLayoutPass();
+
+                Assert.Equal(0, border.Bounds.Top);
+
+                inputPane.Open();
+
+                clock.Pulse(TimeSpan.FromSeconds(5));
+
+                topLevel.LayoutManager.ExecuteLayoutPass();
+
+                Assert.Equal(-200, border.Bounds.Top);
+            }
+        }
+
+        internal static Control CreateScrollViewerTemplate(ScrollViewer control, INameScope scope)
+        {
+            return new Grid
+            {
+                Children =
+                {
+                    new Decorator()
+                    {
+                        Name = "PART_KeyboardAwareDecorator",
+                        Child  = new ScrollContentPresenter
+                        {
+                            Name = "PART_ContentPresenter",
+                        }.RegisterInNameScope(scope)
+                    }.RegisterInNameScope(scope),
+                },
+            };
+        }
+
+        static Mock<ITopLevelImpl> CreateMockTopLevelImpl(TestInputPane inputPane)
+        {
+            var topLevel = new Mock<ITopLevelImpl>();
+            topLevel.Setup(x => x.RenderScaling).Returns(1);
+            topLevel.Setup(x => x.Compositor).Returns(RendererMocks.CreateDummyCompositor());
+            topLevel.Setup(x => x.TryGetFeature(typeof(IInputPane))).Returns(inputPane);
+            return topLevel;
+        }
+
+        private static FuncControlTemplate<TestTopLevel> CreateTopLevelTemplate()
+        {
+            return new FuncControlTemplate<TestTopLevel>((x, scope) =>
+                new ContentPresenter
+                {
+                    Name = "PART_ContentPresenter",
+                    [!ContentPresenter.ContentProperty] = x[!ContentControl.ContentProperty],
+                }.RegisterInNameScope(scope));
+        }
+
+        private class TestInputPane(Rect openRect) : IInputPane
+        {
+            public InputPaneState State { get; private set; }
+
+            public Rect OccludedRect { get; private set; }
+
+            public event EventHandler<InputPaneStateEventArgs>? StateChanged;
+
+            public void Open()
+            {
+                var oldRect = OccludedRect;
+                OccludedRect = openRect;
+
+                State = InputPaneState.Open;
+
+                StateChanged?.Invoke(this, new InputPaneStateEventArgs(State, oldRect, OccludedRect));
+            }
+
+            public void Close()
+            {
+                var oldRect = OccludedRect;
+                OccludedRect = default;
+
+                State = InputPaneState.Closed;
+
+                StateChanged?.Invoke(this, new InputPaneStateEventArgs(State, oldRect, OccludedRect));
+            }
+        }
+
+        private class TestTopLevel(ITopLevelImpl impl) : TopLevel(impl)
+        {
+
+        }
+    }
+}

From f61bcc32d4db27d73222233b8cef8a851cde59cd Mon Sep 17 00:00:00 2001
From: Yoyo <zrt2399@163.com>
Date: Tue, 18 Aug 2026 19:10:38 +0000
Subject: [PATCH 174/196] Add Content attribute to ContentPresenter (#21997)

* Add Content attribute to ContentPresenter

* Add ContentPresenter default content property test
---
 src/Avalonia.Controls/Presenters/ContentPresenter.cs  |  1 +
 .../Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs | 11 +++++++++++
 2 files changed, 12 insertions(+)

diff --git a/src/Avalonia.Controls/Presenters/ContentPresenter.cs b/src/Avalonia.Controls/Presenters/ContentPresenter.cs
index 183882ca50..0628e0c0b9 100644
--- a/src/Avalonia.Controls/Presenters/ContentPresenter.cs
+++ b/src/Avalonia.Controls/Presenters/ContentPresenter.cs
@@ -364,6 +364,7 @@ namespace Avalonia.Controls.Presenters
         /// <summary>
         /// Gets or sets the content to be displayed by the presenter.
         /// </summary>
+        [Content]
         [DependsOn(nameof(ContentTemplate))]
         public object? Content
         {
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs
index e6260f6eec..3c6f895ea8 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BasicTests.cs
@@ -42,6 +42,17 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
             Assert.Equal("Foo", target.Content);
         }
 
+        [Fact]
+        public void ContentPresenter_Default_Content_Property_Is_Set()
+        {
+            var xaml = @"<ContentPresenter xmlns='https://github.com/avaloniaui'>Foo</ContentPresenter>";
+
+            var target = AvaloniaRuntimeXamlLoader.Parse<ContentPresenter>(xaml);
+
+            Assert.NotNull(target);
+            Assert.Equal("Foo", target.Content);
+        }
+
         [Fact]
         public void Attached_Property_Is_Set()
         {

From c01e1e1fb02a9de3b5cf6d540321ea2c2d84029c Mon Sep 17 00:00:00 2001
From: Max Katz <maxkatz6@outlook.com>
Date: Wed, 19 Aug 2026 08:09:02 +0000
Subject: [PATCH 175/196] IPlatformSettings.PreferredApplicationLanguage API
 (#20108)

* Add new IPlatformSettings APIs

* Add control catalog PlatformSettingsPage

* Windows PreferredApplicationLanguage implementation

* Browser PreferredApplicationLanguage implementation

* Run API suppressions for the IPlatformSettings

* Rebase PlatformSettingsPage on new ContentPage

* Return CultureInfo.InstalledUICulture instead of CultureInfo.CurrentUICulture for default PreferredApplicationLanguage implementation

* Android PreferredApplicationLanguage implementation

* iOS PreferredApplicationLanguage implementation

* Use GetUserPreferredUILanguages for Win32 implementation instead of GetUserDefaultLocaleName

* MacOS implementation of PreferredApplicationLanguage

* Use GlobalizationPreferences for WIn32 prefered language, GetUserPreferredUILanguages doesn't work as expected with Windows settigns

* Avoid AvaloniaLocator in control catalog

* Remove unused method

* Add value/remarks XML docs on the PreferredApplicationLanguage
---
 api/Avalonia.nupkg.xml                        |  28 +++-
 .../src/OSX/PlatformSettings.mm               |  46 ++++++
 .../Pages/PlatformSettingsPage.xaml           | 136 ++++++++++++++++++
 .../Pages/PlatformSettingsPage.xaml.cs        |  30 ++++
 .../MainWindowViewModel_PageList.cs           |   1 +
 .../ViewModels/PlatformSettingsViewModel.cs   |  80 +++++++++++
 .../Platform/AndroidPlatformSettings.cs       |  23 +++
 .../Platform/DefaultPlatformSettings.cs       |  11 ++
 .../Platform/IPlatformSettings.cs             |  23 ++-
 src/Avalonia.Native/NativePlatformSettings.cs |  37 +++++
 src/Avalonia.Native/avn.idl                   |   2 +
 .../BrowserPlatformSettings.cs                |  44 +++++-
 .../Avalonia.Browser/Interop/DomHelper.cs     |  12 +-
 .../webapp/modules/avalonia/dom.ts            |   8 ++
 src/Windows/Avalonia.Win32/Win32Platform.cs   |   4 +
 .../Avalonia.Win32/Win32PlatformSettings.cs   |  46 +++++-
 src/Windows/Avalonia.Win32/WinRT/winrt.idl    |  18 +++
 src/iOS/Avalonia.iOS/PlatformSettings.cs      |  26 ++++
 18 files changed, 561 insertions(+), 14 deletions(-)
 create mode 100644 samples/ControlCatalog/Pages/PlatformSettingsPage.xaml
 create mode 100644 samples/ControlCatalog/Pages/PlatformSettingsPage.xaml.cs
 create mode 100644 samples/ControlCatalog/ViewModels/PlatformSettingsViewModel.cs

diff --git a/api/Avalonia.nupkg.xml b/api/Avalonia.nupkg.xml
index 5c720c9413..1dda132a59 100644
--- a/api/Avalonia.nupkg.xml
+++ b/api/Avalonia.nupkg.xml
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <!-- https://learn.microsoft.com/dotnet/fundamentals/package-validation/diagnostic-ids -->
 <Suppressions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
   <Suppression>
@@ -145,6 +145,12 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.OpenGL.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>E:Avalonia.Platform.IPlatformSettings.PreferredApplicationLanguageChanged</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Platform.IBitmapImpl.Save(System.IO.Stream,Avalonia.Media.Imaging.BitmapEncoderOptions)</Target>
@@ -175,6 +181,12 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>P:Avalonia.Platform.IPlatformSettings.PreferredApplicationLanguage</Target>
+    <Left>baseline/Avalonia/lib/net10.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net10.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Controls.Platform.IWin32OptionsTopLevelImpl.SetWindowCornerPreference(Avalonia.Controls.Win32Properties.WindowCornerPreference)</Target>
@@ -193,6 +205,12 @@
     <Left>baseline/Avalonia/lib/net10.0/Avalonia.Controls.dll</Left>
     <Right>current/Avalonia/lib/net10.0/Avalonia.Controls.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>E:Avalonia.Platform.IPlatformSettings.PreferredApplicationLanguageChanged</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Platform.IBitmapImpl.Save(System.IO.Stream,Avalonia.Media.Imaging.BitmapEncoderOptions)</Target>
@@ -223,6 +241,12 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
   </Suppression>
+  <Suppression>
+    <DiagnosticId>CP0006</DiagnosticId>
+    <Target>P:Avalonia.Platform.IPlatformSettings.PreferredApplicationLanguage</Target>
+    <Left>baseline/Avalonia/lib/net8.0/Avalonia.Base.dll</Left>
+    <Right>current/Avalonia/lib/net8.0/Avalonia.Base.dll</Right>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Avalonia.Controls.Platform.IWin32OptionsTopLevelImpl.SetWindowCornerPreference(Avalonia.Controls.Win32Properties.WindowCornerPreference)</Target>
@@ -241,4 +265,4 @@
     <Left>baseline/Avalonia/lib/net8.0/Avalonia.Controls.dll</Left>
     <Right>current/Avalonia/lib/net8.0/Avalonia.Controls.dll</Right>
   </Suppression>
-</Suppressions>
\ No newline at end of file
+</Suppressions>
diff --git a/native/Avalonia.Native/src/OSX/PlatformSettings.mm b/native/Avalonia.Native/src/OSX/PlatformSettings.mm
index 34ceb93186..d30d55e2ec 100644
--- a/native/Avalonia.Native/src/OSX/PlatformSettings.mm
+++ b/native/Avalonia.Native/src/OSX/PlatformSettings.mm
@@ -1,12 +1,19 @@
 #include "common.h"
+#include "AvnString.h"
 
 @interface CocoaThemeObserver : NSObject
 -(id)initWithCallback:(IAvnActionCallback *)callback;
 @end
 
+@interface CocoaLocaleObserver : NSObject
+-(id)initWithCallback:(IAvnActionCallback *)callback;
+-(void)localeDidChange:(NSNotification *)notification;
+@end
+
 class PlatformSettings : public ComSingleObject<IAvnPlatformSettings, &IID_IAvnPlatformSettings>
 {
     CocoaThemeObserver* observer;
+    CocoaLocaleObserver* localeObserver;
 
 public:
     FORWARD_IUNKNOWN()
@@ -58,6 +65,28 @@ public:
             [[NSApplication sharedApplication] addObserver:observer forKeyPath:@"effectiveAppearance" options:NSKeyValueObservingOptionNew context:nil];
         }
     }
+
+    virtual HRESULT GetPreferredLanguage(IAvnString** ret) override
+    {
+        @autoreleasepool
+        {
+            if (ret == nullptr)
+                return E_POINTER;
+
+            auto language = [[NSLocale preferredLanguages] firstObject];
+            *ret = language == nil ? nullptr : CreateAvnString(language);
+            return S_OK;
+        }
+    }
+
+    virtual void RegisterLanguageChange(IAvnActionCallback *callback) override
+    {
+        localeObserver = [[CocoaLocaleObserver alloc] initWithCallback: callback];
+        [[NSNotificationCenter defaultCenter] addObserver:localeObserver
+                                                 selector:@selector(localeDidChange:)
+                                                     name:NSCurrentLocaleDidChangeNotification
+                                                   object:nil];
+    }
     
 private:
     unsigned int to_argb(NSColor* color)
@@ -107,6 +136,23 @@ private:
 }
 @end
 
+@implementation CocoaLocaleObserver
+{
+    ComPtr<IAvnActionCallback> _callback;
+}
+- (id) initWithCallback:(IAvnActionCallback *)callback {
+    self = [super init];
+    if (self) {
+        _callback = callback;
+    }
+    return self;
+}
+
+- (void)localeDidChange:(NSNotification *)notification {
+    _callback->Run();
+}
+@end
+
 extern IAvnPlatformSettings* CreatePlatformSettings()
 {
     return new PlatformSettings();
diff --git a/samples/ControlCatalog/Pages/PlatformSettingsPage.xaml b/samples/ControlCatalog/Pages/PlatformSettingsPage.xaml
new file mode 100644
index 0000000000..a6213558cb
--- /dev/null
+++ b/samples/ControlCatalog/Pages/PlatformSettingsPage.xaml
@@ -0,0 +1,136 @@
+<ContentPage Theme="{StaticResource ScrollPage}" x:Class="ControlCatalog.Pages.PlatformSettingsPage"
+             xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:viewModels="using:ControlCatalog.ViewModels"
+             d:DesignHeight="800"
+             d:DesignWidth="600"
+             mc:Ignorable="d"
+             Header="Platform Settings"
+             x:DataType="viewModels:PlatformSettingsViewModel">
+
+  <StackPanel Spacing="20">
+
+    <TextBlock Text="This page displays IPlatformSettings values which may change at runtime based on system settings."
+               TextWrapping="Wrap"
+               Opacity="0.7" />
+
+    <GroupBox Header="System Color Values">
+      <StackPanel Spacing="15">
+        <Grid ColumnDefinitions="180,*" RowDefinitions="Auto,Auto">
+          <TextBlock Grid.Column="0" Grid.Row="0" Text="Theme Variant:" VerticalAlignment="Center" />
+          <TextBlock Grid.Column="1" Grid.Row="0" Text="{Binding ThemeVariant}" FontWeight="Bold" VerticalAlignment="Center" />
+
+          <TextBlock Grid.Column="0" Grid.Row="1" Text="Contrast Preference:" VerticalAlignment="Center" Margin="0,10,0,0" />
+          <TextBlock Grid.Column="1" Grid.Row="1" Text="{Binding ContrastPreference}" FontWeight="Bold" VerticalAlignment="Center" Margin="0,10,0,0" />
+        </Grid>
+
+        <StackPanel Spacing="10">
+          <Grid ColumnDefinitions="180,120,*">
+            <TextBlock Grid.Column="0" Text="Accent Color 1:" VerticalAlignment="Center" />
+            <Border Grid.Column="1"
+                    Width="100"
+                    Height="40"
+                    BorderBrush="Black"
+                    BorderThickness="1"
+                    CornerRadius="4"
+                    HorizontalAlignment="Left">
+              <Border.Background>
+                <SolidColorBrush Color="{Binding AccentColor1}" />
+              </Border.Background>
+            </Border>
+            <TextBlock Grid.Column="2"
+                       Text="{Binding AccentColor1}"
+                       VerticalAlignment="Center"
+                       Margin="10,0,0,0" />
+          </Grid>
+
+          <Grid ColumnDefinitions="180,120,*">
+            <TextBlock Grid.Column="0" Text="Accent Color 2:" VerticalAlignment="Center" />
+            <Border Grid.Column="1"
+                    Width="100"
+                    Height="40"
+                    BorderBrush="Black"
+                    BorderThickness="1"
+                    CornerRadius="4"
+                    HorizontalAlignment="Left">
+              <Border.Background>
+                <SolidColorBrush Color="{Binding AccentColor2}" />
+              </Border.Background>
+            </Border>
+            <TextBlock Grid.Column="2"
+                       Text="{Binding AccentColor2}"
+                       VerticalAlignment="Center"
+                       Margin="10,0,0,0" />
+          </Grid>
+
+          <Grid ColumnDefinitions="180,120,*">
+            <TextBlock Grid.Column="0" Text="Accent Color 3:" VerticalAlignment="Center" />
+            <Border Grid.Column="1"
+                    Width="100"
+                    Height="40"
+                    BorderBrush="Black"
+                    BorderThickness="1"
+                    CornerRadius="4"
+                    HorizontalAlignment="Left">
+              <Border.Background>
+                <SolidColorBrush Color="{Binding AccentColor3}" />
+              </Border.Background>
+            </Border>
+            <TextBlock Grid.Column="2"
+                       Text="{Binding AccentColor3}"
+                       VerticalAlignment="Center"
+                       Margin="10,0,0,0" />
+          </Grid>
+        </StackPanel>
+      </StackPanel>
+    </GroupBox>
+
+    <GroupBox Header="Language Settings">
+      <StackPanel Spacing="10">
+        <TextBlock Text="This reflects the preferred application language as specified in OS settings."
+                   TextWrapping="Wrap"
+                   Opacity="0.7"
+                   FontSize="12" />
+        <Grid ColumnDefinitions="180,*">
+          <TextBlock Grid.Column="0" Text="Preferred Language:" VerticalAlignment="Center" />
+          <TextBlock Grid.Column="1" Text="{Binding PreferredLanguage}" FontWeight="Bold" VerticalAlignment="Center" />
+        </Grid>
+      </StackPanel>
+    </GroupBox>
+
+    <GroupBox Header="Other Platform Settings">
+      <StackPanel Spacing="10">
+        <TextBlock Text="These settings are less commonly changed and are platform-specific."
+                   TextWrapping="Wrap"
+                   Opacity="0.7"
+                   FontSize="12" />
+
+        <Grid ColumnDefinitions="180,*" RowDefinitions="Auto,Auto,Auto,Auto,Auto,Auto,Auto">
+          <TextBlock Grid.Column="0" Grid.Row="0" Text="Hold Wait Duration:" VerticalAlignment="Center" />
+          <TextBlock Grid.Column="1" Grid.Row="0" Text="{Binding HoldWaitDuration}" VerticalAlignment="Center" />
+
+          <TextBlock Grid.Column="0" Grid.Row="1" Text="Tap Size (Touch):" VerticalAlignment="Center" Margin="0,5,0,0" />
+          <TextBlock Grid.Column="1" Grid.Row="1" Text="{Binding TapSizeTouch}" VerticalAlignment="Center" Margin="0,5,0,0" />
+
+          <TextBlock Grid.Column="0" Grid.Row="2" Text="Tap Size (Mouse):" VerticalAlignment="Center" Margin="0,5,0,0" />
+          <TextBlock Grid.Column="1" Grid.Row="2" Text="{Binding TapSizeMouse}" VerticalAlignment="Center" Margin="0,5,0,0" />
+
+          <TextBlock Grid.Column="0" Grid.Row="3" Text="Double-Tap Size (Touch):" VerticalAlignment="Center" Margin="0,5,0,0" />
+          <TextBlock Grid.Column="1" Grid.Row="3" Text="{Binding DoubleTapSizeTouch}" VerticalAlignment="Center" Margin="0,5,0,0" />
+
+          <TextBlock Grid.Column="0" Grid.Row="4" Text="Double-Tap Size (Mouse):" VerticalAlignment="Center" Margin="0,5,0,0" />
+          <TextBlock Grid.Column="1" Grid.Row="4" Text="{Binding DoubleTapSizeMouse}" VerticalAlignment="Center" Margin="0,5,0,0" />
+
+          <TextBlock Grid.Column="0" Grid.Row="5" Text="Double-Tap Time (Touch):" VerticalAlignment="Center" Margin="0,5,0,0" />
+          <TextBlock Grid.Column="1" Grid.Row="5" Text="{Binding DoubleTapTimeTouch}" VerticalAlignment="Center" Margin="0,5,0,0" />
+
+          <TextBlock Grid.Column="0" Grid.Row="6" Text="Double-Tap Time (Mouse):" VerticalAlignment="Center" Margin="0,5,0,0" />
+          <TextBlock Grid.Column="1" Grid.Row="6" Text="{Binding DoubleTapTimeMouse}" VerticalAlignment="Center" Margin="0,5,0,0" />
+        </Grid>
+      </StackPanel>
+    </GroupBox>
+
+  </StackPanel>
+</ContentPage>
diff --git a/samples/ControlCatalog/Pages/PlatformSettingsPage.xaml.cs b/samples/ControlCatalog/Pages/PlatformSettingsPage.xaml.cs
new file mode 100644
index 0000000000..8f3e6f4b48
--- /dev/null
+++ b/samples/ControlCatalog/Pages/PlatformSettingsPage.xaml.cs
@@ -0,0 +1,30 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.VisualTree;
+using ControlCatalog.ViewModels;
+
+namespace ControlCatalog.Pages
+{
+    public partial class PlatformSettingsPage : ContentPage
+    {
+        private readonly PlatformSettingsViewModel _viewModel = new();
+
+        public PlatformSettingsPage()
+        {
+            InitializeComponent();
+            DataContext = _viewModel;
+        }
+
+        protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+        {
+            base.OnAttachedToVisualTree(e);
+            _viewModel.Subscribe(this.GetPlatformSettings() ?? Application.Current?.PlatformSettings);
+        }
+
+        protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
+        {
+            _viewModel.Unsubscribe();
+            base.OnDetachedFromVisualTree(e);
+        }
+    }
+}
diff --git a/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs b/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
index 250b1358b5..61476a0407 100644
--- a/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
+++ b/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
@@ -72,6 +72,7 @@ namespace ControlCatalog.ViewModels
             new PageItem("OpenGL Lease",() => new OpenGlLeasePage(), Icons.Cube3D),
             new PageItem("PipsPager",() => new PipsPagerPage(), Icons.HorizontalDots),
             new PageItem("Platform Information",() => new PlatformInfoPage(), Icons.Info),
+            new PageItem("Platform Settings",() => new PlatformSettingsPage(), Icons.Tune),
             new PageItem("Pointers",() => new PointersPage(), Icons.Cursor),
             new PageItem("ProgressBar",() => new ProgressBarPage(), Icons.Progress),
             new PageItem("RadioButton",() => new RadioButtonPage(), Icons.Radio),
diff --git a/samples/ControlCatalog/ViewModels/PlatformSettingsViewModel.cs b/samples/ControlCatalog/ViewModels/PlatformSettingsViewModel.cs
new file mode 100644
index 0000000000..070a486f07
--- /dev/null
+++ b/samples/ControlCatalog/ViewModels/PlatformSettingsViewModel.cs
@@ -0,0 +1,80 @@
+using System;
+using Avalonia.Input;
+using Avalonia.Media;
+using Avalonia.Platform;
+using MiniMvvm;
+
+namespace ControlCatalog.ViewModels;
+
+public class PlatformSettingsViewModel : ViewModelBase
+{
+    private IPlatformSettings? _platformSettings;
+    private PlatformColorValues? _colorValues;
+    private string? _preferredLanguage;
+
+    public void Subscribe(IPlatformSettings? platformSettings)
+    {
+        _platformSettings = platformSettings;
+
+        if (platformSettings is not null)
+        {
+            OnColorValuesChanged(platformSettings, platformSettings.GetColorValues());
+            OnPreferredLanguageChanged(platformSettings, EventArgs.Empty);
+
+            platformSettings?.ColorValuesChanged += OnColorValuesChanged;
+            platformSettings?.PreferredApplicationLanguageChanged += OnPreferredLanguageChanged;
+        }
+    }
+
+    public void Unsubscribe()
+    {
+        if (_platformSettings != null)
+        {
+            _platformSettings.ColorValuesChanged -= OnColorValuesChanged;
+            _platformSettings.PreferredApplicationLanguageChanged -= OnPreferredLanguageChanged;
+            _platformSettings = null;
+        }
+    }
+
+    private void OnColorValuesChanged(object? sender, PlatformColorValues e)
+    {
+        _colorValues = e;
+        RaisePropertyChanged(nameof(ThemeVariant));
+        RaisePropertyChanged(nameof(ContrastPreference));
+        RaisePropertyChanged(nameof(AccentColor1));
+        RaisePropertyChanged(nameof(AccentColor2));
+        RaisePropertyChanged(nameof(AccentColor3));
+    }
+
+    private void OnPreferredLanguageChanged(object? sender, EventArgs e)
+    {
+        _preferredLanguage = ((IPlatformSettings)sender!).PreferredApplicationLanguage;
+        RaisePropertyChanged(nameof(PreferredLanguage));
+    }
+
+    public string PreferredLanguage => _preferredLanguage ?? "Not available";
+
+    public string ThemeVariant => _colorValues?.ThemeVariant.ToString() ?? "Not available";
+
+    public string ContrastPreference => _colorValues?.ContrastPreference.ToString() ?? "Not available";
+
+    public Color AccentColor1 => _colorValues?.AccentColor1 ?? Colors.Gray;
+
+    public Color AccentColor2 => _colorValues?.AccentColor2 ?? Colors.Gray;
+
+    public Color AccentColor3 => _colorValues?.AccentColor3 ?? Colors.Gray;
+
+    public string HoldWaitDuration => _platformSettings?.HoldWaitDuration.ToString() ?? "Not available";
+
+    public string TapSizeTouch => _platformSettings?.GetTapSize(PointerType.Touch).ToString() ?? "Not available";
+
+    public string TapSizeMouse => _platformSettings?.GetTapSize(PointerType.Mouse).ToString() ?? "Not available";
+
+    public string DoubleTapSizeTouch => _platformSettings?.GetDoubleTapSize(PointerType.Touch).ToString() ?? "Not available";
+
+    public string DoubleTapSizeMouse => _platformSettings?.GetDoubleTapSize(PointerType.Mouse).ToString() ?? "Not available";
+
+    public string DoubleTapTimeTouch => _platformSettings?.GetDoubleTapTime(PointerType.Touch).ToString() ?? "Not available";
+
+    public string DoubleTapTimeMouse => _platformSettings?.GetDoubleTapTime(PointerType.Mouse).ToString() ?? "Not available";
+}
diff --git a/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs b/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs
index 83b2ab51e3..c89619749c 100644
--- a/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs
+++ b/src/Android/Avalonia.Android/Platform/AndroidPlatformSettings.cs
@@ -18,6 +18,7 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
     private TimeSpan _doubleTapTime = TimeSpan.FromMilliseconds(500);
     private Size _doubleTapSize = new Size(16,16);
     private Size _tapSize = new Size(10,10);
+    private string? _latestLanguage;
 
     public AndroidPlatformSettings()
     {
@@ -25,6 +26,7 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
         {
             UpdateInputConfigValues(context);
             _colorValues = GetColorValuesFromContext(context);
+            _latestLanguage = QueryPreferredApplicationLanguage(context);
 
             ContextCompat.RegisterReceiver(
                 context,
@@ -41,6 +43,8 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
         return _colorValues;
     }
 
+    public override string PreferredApplicationLanguage => _latestLanguage ?? base.PreferredApplicationLanguage;
+
     public override TimeSpan GetDoubleTapTime(PointerType type)
     {
         return type == PointerType.Mouse ? base.GetDoubleTapTime(type) : _doubleTapTime;
@@ -70,6 +74,18 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
         }
     }
 
+    private void UpdatePreferredApplicationLanguage(Context context)
+    {
+        var oldLanguage = _latestLanguage;
+        var language = QueryPreferredApplicationLanguage(context);
+
+        if (oldLanguage != language)
+        {
+            _latestLanguage = language;
+            OnPreferredApplicationLanguageChanged();
+        }
+    }
+
     private static PlatformColorValues GetColorValuesFromContext(Context context)
     {
         var uiMode = context.Resources?.Configuration?.UiMode & UiMode.NightMask ?? UiMode.NightNo;
@@ -145,6 +161,12 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
         }
     }
 
+    private string? QueryPreferredApplicationLanguage(Context? context)
+    {
+        var locale = context?.Resources?.Configuration?.Locales?.Get(0);
+        return locale?.ToLanguageTag() is { Length: > 0 } tag ? tag : null;
+    }
+
     private static ColorContrastPreference IsHighContrast(Context context)
     {
         try
@@ -174,6 +196,7 @@ internal class AndroidPlatformSettings : DefaultPlatformSettings
                 timer.Stop();
                 settings.UpdateInputConfigValues(context);
                 settings.UpdateColorValues(context);
+                settings.UpdatePreferredApplicationLanguage(context);
             };
 
             timer.Start();
diff --git a/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs b/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs
index cce11db12d..cd8f1f3f21 100644
--- a/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs
+++ b/src/Avalonia.Base/Platform/DefaultPlatformSettings.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Globalization;
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Media;
@@ -41,6 +42,9 @@ namespace Avalonia.Platform
         public PlatformHotkeyConfiguration HotkeyConfiguration =>
             AvaloniaLocator.Current.GetRequiredService<PlatformHotkeyConfiguration>();
 
+        public virtual string PreferredApplicationLanguage =>
+            CultureInfo.InstalledUICulture.Name;
+
         public virtual PlatformColorValues GetColorValues()
         {
             return new PlatformColorValues
@@ -50,11 +54,18 @@ namespace Avalonia.Platform
         }
 
         public virtual event EventHandler<PlatformColorValues>? ColorValuesChanged;
+        public virtual event EventHandler? PreferredApplicationLanguageChanged;
 
         protected void OnColorValuesChanged(PlatformColorValues colorValues)
         {
             Dispatcher.UIThread.Send(
                 _ => ColorValuesChanged?.Invoke(this, colorValues));
         }
+
+        protected void OnPreferredApplicationLanguageChanged()
+        {
+            Dispatcher.UIThread.Send(
+                _ => PreferredApplicationLanguageChanged?.Invoke(this, EventArgs.Empty));
+        }
     }
 }
diff --git a/src/Avalonia.Base/Platform/IPlatformSettings.cs b/src/Avalonia.Base/Platform/IPlatformSettings.cs
index 46980c6d51..a45d8dc20f 100644
--- a/src/Avalonia.Base/Platform/IPlatformSettings.cs
+++ b/src/Avalonia.Base/Platform/IPlatformSettings.cs
@@ -37,12 +37,26 @@ namespace Avalonia.Platform
         /// Holding duration between pointer press and when event is fired.
         /// </summary>
         TimeSpan HoldWaitDuration { get; }
-        
+
         /// <summary>
         /// Get a configuration for platform-specific hotkeys in an Avalonia application.
         /// </summary>
         PlatformHotkeyConfiguration HotkeyConfiguration { get; }
-        
+
+        /// <summary>
+        /// Gets the preferred application language as specified in the operating system settings.
+        /// </summary>
+        /// <value>
+        /// BCP 47 language tag. Examples: <c>en</c>, <c>en-US</c> or <c>zh-Hans-CN</c>.
+        /// Can be empty if the operating system doesn't report a preferred language.
+        /// </value>
+        /// <remarks>
+        /// Most platforms read this value from the operating system instead of the .NET runtime,
+        /// so a language tag can be returned even in globalization-invariant mode.
+        /// When that mode is disabled, the tag can be passed to <see cref="System.Globalization.CultureInfo"/>.
+        /// </remarks>
+        string PreferredApplicationLanguage { get; }
+
         /// <summary>
         /// Gets current system color values including dark mode and accent colors.
         /// </summary>
@@ -52,5 +66,10 @@ namespace Avalonia.Platform
         /// Raises when current system color values are changed. Including changing of a dark mode and accent colors.
         /// </summary>
         event EventHandler<PlatformColorValues>? ColorValuesChanged;
+
+        /// <summary>
+        /// Raises when the preferred application language is changed in the operating system settings.
+        /// </summary>
+        event EventHandler? PreferredApplicationLanguageChanged;
     }
 }
diff --git a/src/Avalonia.Native/NativePlatformSettings.cs b/src/Avalonia.Native/NativePlatformSettings.cs
index 63fc4e64af..0b8b76b69b 100644
--- a/src/Avalonia.Native/NativePlatformSettings.cs
+++ b/src/Avalonia.Native/NativePlatformSettings.cs
@@ -9,11 +9,13 @@ internal class NativePlatformSettings : DefaultPlatformSettings
 {
     private readonly IAvnPlatformSettings _platformSettings;
     private PlatformColorValues? _colorValues;
+    private string? _lastLanguage;
 
     public NativePlatformSettings(IAvnPlatformSettings platformSettings)
     {
         _platformSettings = platformSettings;
         platformSettings.RegisterColorsChange(new ColorsChangeCallback(this));
+        platformSettings.RegisterLanguageChange(new LanguageChangeCallback(this));
     }
 
     public override PlatformColorValues GetColorValues()
@@ -62,6 +64,26 @@ internal class NativePlatformSettings : DefaultPlatformSettings
         }
     }
 
+    public override string PreferredApplicationLanguage =>
+        _lastLanguage ??= QueryPreferredApplicationLanguage();
+
+    private void OnPreferredLanguageChanged()
+    {
+        var oldLanguage = _lastLanguage;
+        _lastLanguage = null;
+
+        if (oldLanguage != PreferredApplicationLanguage)
+        {
+            OnPreferredApplicationLanguageChanged();
+        }
+    }
+
+    private string QueryPreferredApplicationLanguage()
+    {
+        using var language = _platformSettings.PreferredLanguage;
+        return language?.String is { Length: > 0 } value ? value : base.PreferredApplicationLanguage;
+    }
+
     private class ColorsChangeCallback : NativeCallbackBase, IAvnActionCallback
     {
         private readonly NativePlatformSettings _settings;
@@ -76,4 +98,19 @@ internal class NativePlatformSettings : DefaultPlatformSettings
             _settings.OnColorValuesChanged();
         }
     }
+
+    private class LanguageChangeCallback : NativeCallbackBase, IAvnActionCallback
+    {
+        private readonly NativePlatformSettings _settings;
+
+        public LanguageChangeCallback(NativePlatformSettings settings)
+        {
+            _settings = settings;
+        }
+
+        public void Run()
+        {
+            _settings.OnPreferredLanguageChanged();
+        }
+    }
 }
diff --git a/src/Avalonia.Native/avn.idl b/src/Avalonia.Native/avn.idl
index 91a252c020..ee46a46f8c 100644
--- a/src/Avalonia.Native/avn.idl
+++ b/src/Avalonia.Native/avn.idl
@@ -1367,6 +1367,8 @@ interface IAvnPlatformSettings : IUnknown
     AvnPlatformThemeVariant GetPlatformTheme();
     uint GetAccentColor();
     void RegisterColorsChange(IAvnActionCallback* callback);
+    HRESULT GetPreferredLanguage(IAvnString** ret);
+    void RegisterLanguageChange(IAvnActionCallback* callback);
 }
 
 [uuid(12edf00d-5803-4d3f-9947-b4840e5e9372)]
diff --git a/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs b/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs
index ceaece821b..12d7a79ade 100644
--- a/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs
+++ b/src/Browser/Avalonia.Browser/BrowserPlatformSettings.cs
@@ -10,22 +10,43 @@ internal class BrowserPlatformSettings : DefaultPlatformSettings
     private bool _isHighContrast;
     private bool _isInitialized;
     private PlatformColorValues? _colorValues;
+    private string? _lastLanguage;
 
     public override event EventHandler<PlatformColorValues>? ColorValuesChanged
     {
         add
         {
-            EnsureBackend();
+            EnsureSettings();
             base.ColorValuesChanged += value;
         }
         remove => base.ColorValuesChanged -= value;
     }
 
+    public override event EventHandler? PreferredApplicationLanguageChanged
+    {
+        add
+        {
+            EnsureSettings();
+            base.PreferredApplicationLanguageChanged += value;
+        }
+        remove => base.PreferredApplicationLanguageChanged -= value;
+    }
+
+    public override string PreferredApplicationLanguage
+    {
+        get
+        {
+            EnsureSettings();
+
+            return _lastLanguage ?? base.PreferredApplicationLanguage;
+        }
+    }
+
     public override PlatformColorValues GetColorValues()
     {
         if (_colorValues is null)
         {
-            EnsureBackend();
+            EnsureSettings();
             _colorValues = BuildPlatformColorValues(_isDarkMode, _isHighContrast);
         }
 
@@ -39,18 +60,27 @@ internal class BrowserPlatformSettings : DefaultPlatformSettings
             ContrastPreference = isHighContrast ? ColorContrastPreference.High : ColorContrastPreference.NoPreference
         };
 
-    public void OnValuesChanged(bool isDarkMode, bool isHighContrast)
+    public void OnColorValuesChanged(bool isDarkMode, bool isHighContrast)
     {
         _isDarkMode = isDarkMode;
         _isHighContrast = isHighContrast;
         UpdateColorValues();
     }
-    
-    private void EnsureBackend()
+
+    public void OnPreferredLanguageChanged(string? language)
+    {
+        if (language is not null && _lastLanguage != language)
+        {
+            _lastLanguage = language;
+            OnPreferredApplicationLanguageChanged();
+        }
+    }
+
+    private void EnsureSettings()
     {
         if (!_isInitialized)
         {
-            // WASM module has async nature of initialization. We can't native code right away during components registration. 
+            // WASM module has async nature of initialization. We can't call platform code right away during components registration. 
             _isInitialized = true;
             var values = DomHelper.GetDarkMode(BrowserWindowingPlatform.GlobalThis);
             if (values.Length == 2)
@@ -58,6 +88,8 @@ internal class BrowserPlatformSettings : DefaultPlatformSettings
                 _isDarkMode = values[0] > 0;
                 _isHighContrast = values[1] > 0;
             }
+
+            _lastLanguage = DomHelper.GetNavigatorLanguage(BrowserWindowingPlatform.GlobalThis);
         }
     }
 
diff --git a/src/Browser/Avalonia.Browser/Interop/DomHelper.cs b/src/Browser/Avalonia.Browser/Interop/DomHelper.cs
index 4b929660e5..2c1189a9d2 100644
--- a/src/Browser/Avalonia.Browser/Interop/DomHelper.cs
+++ b/src/Browser/Avalonia.Browser/Interop/DomHelper.cs
@@ -31,6 +31,9 @@ internal static partial class DomHelper
     [JSImport("AvaloniaDOM.getDarkMode", AvaloniaModule.MainModuleName)]
     public static partial int[] GetDarkMode(JSObject globalThis);
 
+    [JSImport("AvaloniaDOM.getNavigatorLanguage", AvaloniaModule.MainModuleName)]
+    public static partial string? GetNavigatorLanguage(JSObject globalThis);
+
     [JSImport("AvaloniaDOM.addClass", AvaloniaModule.MainModuleName)]
     public static partial void AddCssClass(JSObject element, string className);
 
@@ -40,7 +43,7 @@ internal static partial class DomHelper
     [JSExport]
     public static Task DarkModeChanged(bool isDarkMode, bool isHighContrast)
     {
-        (AvaloniaLocator.Current.GetService<IPlatformSettings>() as BrowserPlatformSettings)?.OnValuesChanged(isDarkMode, isHighContrast);
+        (AvaloniaLocator.Current.GetService<IPlatformSettings>() as BrowserPlatformSettings)?.OnColorValuesChanged(isDarkMode, isHighContrast);
         return Task.CompletedTask;
     }
 
@@ -51,6 +54,13 @@ internal static partial class DomHelper
         return Task.CompletedTask;
     }
 
+    [JSExport]
+    public static Task LanguageChanged(string language)
+    {
+        (AvaloniaLocator.Current.GetService<IPlatformSettings>() as BrowserPlatformSettings)?.OnPreferredLanguageChanged(language);
+        return Task.CompletedTask;
+    }
+
     [JSExport]
     public static Task ScreensChanged()
     {
diff --git a/src/Browser/Avalonia.Browser/webapp/modules/avalonia/dom.ts b/src/Browser/Avalonia.Browser/webapp/modules/avalonia/dom.ts
index 175e51c0da..a09f926c07 100644
--- a/src/Browser/Avalonia.Browser/webapp/modules/avalonia/dom.ts
+++ b/src/Browser/Avalonia.Browser/webapp/modules/avalonia/dom.ts
@@ -136,6 +136,10 @@ export class AvaloniaDOM {
             });
         }
 
+        globalThis.addEventListener("languagechange", () => {
+            JsExports.DomHelper.LanguageChanged(globalThis.navigator.language);
+        });
+
         globalThis.document.addEventListener("visibilitychange", () => {
             JsExports.DomHelper.DocumentVisibilityChanged(globalThis.document.visibilityState);
         });
@@ -167,4 +171,8 @@ export class AvaloniaDOM {
             prefersContrastMedia.matches ? 1 : 0
         ];
     }
+
+    public static getNavigatorLanguage(globalThis: Window): string | null {
+        return globalThis.navigator?.language ?? null;
+    }
 }
diff --git a/src/Windows/Avalonia.Win32/Win32Platform.cs b/src/Windows/Avalonia.Win32/Win32Platform.cs
index c7cd651ca5..f98ae71dd3 100644
--- a/src/Windows/Avalonia.Win32/Win32Platform.cs
+++ b/src/Windows/Avalonia.Win32/Win32Platform.cs
@@ -184,6 +184,10 @@ namespace Avalonia.Win32
                     {
                         win32PlatformSettings.OnColorValuesChanged();
                     }
+                    else if (changedSetting == "intl") // language/locale change
+                    {
+                        win32PlatformSettings.OnLanguageChanged();
+                    }
                 }
 
                 // Notify WorkingArea changed to Screens
diff --git a/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs b/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
index 480eee9e67..3be3d4876a 100644
--- a/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
+++ b/src/Windows/Avalonia.Win32/Win32PlatformSettings.cs
@@ -12,7 +12,11 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
         WinRTApiInformation.IsTypePresent("Windows.UI.ViewManagement.UISettings")
         && WinRTApiInformation.IsTypePresent("Windows.UI.ViewManagement.AccessibilitySettings"));
 
+    private static readonly Lazy<bool> s_globalizationSupported = new(() =>
+        WinRTApiInformation.IsTypePresent("Windows.System.UserProfile.GlobalizationPreferences"));
+
     private PlatformColorValues? _colorValues;
+    private string? _lastLanguage;
 
     public override Size GetTapSize(PointerType type)
     {
@@ -33,7 +37,10 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
     }
 
     public override TimeSpan GetDoubleTapTime(PointerType type) => TimeSpan.FromMilliseconds(GetDoubleClickTime());
-    
+
+    public override string PreferredApplicationLanguage =>
+        _lastLanguage ??= QueryPreferredApplicationLanguage();
+
     public override PlatformColorValues GetColorValues()
         => _colorValues ??= GetUncachedColorValues();
 
@@ -47,10 +54,10 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
             };
         }
 
-        var uiSettings = NativeWinRTMethods.CreateInstance<IUISettings3>("Windows.UI.ViewManagement.UISettings");
+        using var uiSettings = NativeWinRTMethods.CreateInstance<IUISettings3>("Windows.UI.ViewManagement.UISettings");
         var accent = uiSettings.GetColorValue(UIColorType.Accent).ToAvalonia();
 
-        var accessibilitySettings = NativeWinRTMethods.CreateInstance<IAccessibilitySettings>("Windows.UI.ViewManagement.AccessibilitySettings");
+        using var accessibilitySettings = NativeWinRTMethods.CreateInstance<IAccessibilitySettings>("Windows.UI.ViewManagement.AccessibilitySettings");
         if (accessibilitySettings.HighContrast == 1)
         {
             // Windows 11 has 4 different high contrast schemes:
@@ -95,4 +102,37 @@ internal class Win32PlatformSettings : DefaultPlatformSettings
             OnColorValuesChanged(colorValues);
         }
     }
+
+    internal void OnLanguageChanged()
+    {
+        var oldLanguage = _lastLanguage;
+        _lastLanguage = null;
+        var newLanguage = PreferredApplicationLanguage;
+
+        if (oldLanguage != newLanguage)
+        {
+            OnPreferredApplicationLanguageChanged();
+        }
+    }
+
+    private string QueryPreferredApplicationLanguage()
+    {
+        // `GetUserPreferredUILanguages`win32 API doesn't seem to respect Win11 "Preferred Languages" setting.
+        // While GlobalizationPreferences works fine.
+        if (s_globalizationSupported.Value)
+        {
+            using var globalizationPreferences = NativeWinRTMethods.CreateActivationFactory<IGlobalizationPreferencesStatics>("Windows.System.UserProfile.GlobalizationPreferences");
+            var languages = globalizationPreferences.Languages;
+            if (languages.Size > 0)
+            {
+                using var languageHString = new HStringInterop(languages.GetAt(0));
+                if (languageHString.Value is { } language)
+                {
+                    return language;
+                }
+            }
+        }
+
+        return base.PreferredApplicationLanguage;
+    }
 }
diff --git a/src/Windows/Avalonia.Win32/WinRT/winrt.idl b/src/Windows/Avalonia.Win32/WinRT/winrt.idl
index b80a0de11b..6348fce3be 100644
--- a/src/Windows/Avalonia.Win32/WinRT/winrt.idl
+++ b/src/Windows/Avalonia.Win32/WinRT/winrt.idl
@@ -261,6 +261,15 @@ interface IPropertyValue : IInspectable
     HRESULT GetRectArray([out] UINT32* __valueSize, [out] [size_is(, *__valueSize)] void** value);
 }
 
+[uuid(fca5679c-bfd4-5187-8b2d-de225049b346)]
+interface IVectorViewHSTRING : IInspectable
+{
+    HRESULT GetAt([in] UINT32 index, [out, retval] HSTRING *value);
+    [propget] HRESULT Size([out, retval] UINT32 *value);
+    // HRESULT IndexOf([in, optional] T element, [out] UINT32 *index, [out, retval] BOOLEAN *value);
+    // HRESULT GetMany([in] UINT32 start_index, [in] UINT32 items_size, [out] T *items, [out, retval] UINT32 *value);
+}
+
 enum AsyncStatus {
   Started = 0,
   Completed, 
@@ -872,6 +881,15 @@ interface IAccessibilitySettings : IInspectable
     [propget] HRESULT HighContrastScheme([out] [retval] HSTRING* value);
 }
 
+[uuid(01BF4326-ED37-4E96-B0E9-C1340D1EA158)]
+interface IGlobalizationPreferencesStatics : IInspectable
+{
+    [propget] HRESULT Calendars([out, retval] IVectorViewHSTRING** value);
+    [propget] HRESULT Clocks([out, retval] IVectorViewHSTRING** value);
+    [propget] HRESULT Currencies([out, retval] IVectorViewHSTRING** value);
+    [propget] HRESULT Languages([out, retval] IVectorViewHSTRING** value);
+}
+
 [uuid(997439FE-F681-4A11-B416-C13A47E8BA36)]
 interface IApiInformationStatics : IInspectable
 {
diff --git a/src/iOS/Avalonia.iOS/PlatformSettings.cs b/src/iOS/Avalonia.iOS/PlatformSettings.cs
index e355a1bdf6..f92460f039 100644
--- a/src/iOS/Avalonia.iOS/PlatformSettings.cs
+++ b/src/iOS/Avalonia.iOS/PlatformSettings.cs
@@ -1,6 +1,7 @@
 using System;
 using Avalonia.Media;
 using Avalonia.Platform;
+using Foundation;
 using UIKit;
 
 namespace Avalonia.iOS;
@@ -9,6 +10,12 @@ namespace Avalonia.iOS;
 internal class PlatformSettings : DefaultPlatformSettings
 {
     private PlatformColorValues? _colorValues;
+    private string? _lastLanguage;
+
+    public PlatformSettings()
+    {
+        NSLocale.Notifications.ObserveCurrentLocaleDidChange(OnPreferredLanguageChanged);
+    }
 
     public override PlatformColorValues GetColorValues()
         => _colorValues ??= GetUncachedColorValues();
@@ -66,4 +73,23 @@ internal class PlatformSettings : DefaultPlatformSettings
             OnColorValuesChanged(colorValues);
         }
     }
+
+    public override string PreferredApplicationLanguage =>
+        _lastLanguage ??= QueryPreferredApplicationLanguage();
+
+    private string QueryPreferredApplicationLanguage() =>
+        NSLocale.PreferredLanguages is [{ Length: > 0 } language, ..]
+            ? language
+            : base.PreferredApplicationLanguage;
+
+    private void OnPreferredLanguageChanged(object? sender, NSNotificationEventArgs args)
+    {
+        var oldLanguage = _lastLanguage;
+        _lastLanguage = null;
+
+        if (oldLanguage != PreferredApplicationLanguage)
+        {
+            OnPreferredApplicationLanguageChanged();
+        }
+    }
 }

From 29bd4a253b4b92815871d80cbf8d2f839bf34df6 Mon Sep 17 00:00:00 2001
From: Benedikt Stebner <Gillibald@users.noreply.github.com>
Date: Wed, 19 Aug 2026 11:16:53 +0000
Subject: [PATCH 176/196] Fix keyDown event handling for macOS input methods
 (#21906)

* fix(macOS): always raise keyDown before the input context sees the event

AvnView passed every keyDown to the NSTextInputContext first and only
raised a KeyDown when the context did not consume the event. The context
consumes every printable key by routing it to insertText:, so while a
text input client was active no KeyDown was raised for space, letters or
digits and a KeyGesture on those keys could never match. Only modified
keys were special-cased.

keyDown: now always raises exactly one KeyDown per NSEvent before the
input context is consulted. Composition state only decides which key is
reported: while hasMarkedText is set the key is masked as
AvnKeyImeProcessed, the same way Win32 reports VK_PROCESSKEY, so user
code still observes the event but no gesture matches it. The physical key
and the key symbol keep their real values in both cases.

If user code handles the event the input context is skipped entirely, so
no text and no preedit is produced. This mirrors the Win32 behaviour of
swallowing WM_CHAR after a handled WM_KEYDOWN.

The modifier special case, the handleKeyDown: helper and
_lastKeyDownEvent are gone. doCommandBySelector: is kept but empty, since
falling back to NSResponder would perform the default action and beep.

Adds a Keyboard page to IntegrationTestApp that reports the last key
down, a key down count and the last text input, plus Appium tests
covering gestures with and without a modifier, text suppression for a
handled gesture, and a single key down per key press.

* fix(macOS): mask the composition starting key for composing input methods

hasMarkedText only becomes true once a composition is in progress, so the
keystroke that starts one was still reported with its real key and could
match a KeyGesture. Win32 reports VK_PROCESSKEY for that keystroke too.

keyDown: now also masks the key as AvnKeyImeProcessed when a printable
character key is typed into a text input client while the selected
keyboard input source is a composing input method.

Whether an input source composes is resolved through
TISGetInputSourceProperty: anything that is not a plain keyboard layout
composes, except an input method in the alphanumeric input mode, which
passes keys straight through and therefore keeps the real key. Unknown
input sources keep the real key as well, so gestures are never lost to a
failed lookup. The lookup includes installed but not enabled input
sources, since an input method mode can be selected without being listed
as enabled, and the result is cached per input source id because this runs
for every key down.

Only printable character keys are masked. KeySymbolFromScanCode reports
the control character for Backspace, Enter, Tab and Escape, so the
presence of a key symbol is not enough to decide: masking those would stop
TextBox from reacting to them, which broke Backspace while an input method
was selected. Command and Control combinations are shortcuts and are not
masked either.

Plain keyboard layouts are unaffected: dead key compositions are not
driven by the input source and stay covered by hasMarkedText.

The Keyboard page now subscribes to KeyDown and TextInput with
handledEventsToo, so keys TextBox handles in its class handler, such as
Backspace and the arrows, stay visible in the readout.

* test(macOS): skip the Keyboard tests on the Appium 1 leg

The tests synthesize key input through W3C actions, which the mac2
driver bundled with Appium 1 does not implement, so on the macOS CI leg
they could only fail. They keep running on Windows, where WinAppDriver
handles W3C actions, and on macOS builds with IsRunningAppium2, which
target a current mac2 driver. The infrastructure change that would run
them on macOS CI is split out for a separate pull request.

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 native/Avalonia.Native/src/OSX/AvnView.mm     | 195 +++++++++++++-----
 .../IntegrationTestApp/MainWindow.axaml.cs    |   1 +
 .../Pages/KeyboardPage.axaml                  |  45 ++++
 .../Pages/KeyboardPage.axaml.cs               |  63 ++++++
 .../KeyboardTests.cs                          | 133 ++++++++++++
 5 files changed, 386 insertions(+), 51 deletions(-)
 create mode 100644 samples/IntegrationTestApp/Pages/KeyboardPage.axaml
 create mode 100644 samples/IntegrationTestApp/Pages/KeyboardPage.axaml.cs
 create mode 100644 tests/Avalonia.IntegrationTests.Appium/KeyboardTests.cs

diff --git a/native/Avalonia.Native/src/OSX/AvnView.mm b/native/Avalonia.Native/src/OSX/AvnView.mm
index d4ab79bc47..805cd7ee02 100644
--- a/native/Avalonia.Native/src/OSX/AvnView.mm
+++ b/native/Avalonia.Native/src/OSX/AvnView.mm
@@ -4,6 +4,7 @@
 //
 
 #import <AppKit/AppKit.h>
+#import <Carbon/Carbon.h> /* For the TIS functions used to classify the keyboard input source. */
 #include "AvnView.h"
 #include "automation.h"
 #import "WindowInterfaces.h"
@@ -22,8 +23,9 @@
     NSMutableAttributedString* _text;
     NSRange _selectedRange;
     NSRange _markedRange;
-    NSEvent* _lastKeyDownEvent;
     NSMutableArray* _accessibilityChildren;
+    NSString* _keyboardInputSourceId;
+    bool _keyboardInputSourceComposes;
 }
 
 - (void)onClosed
@@ -649,9 +651,100 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
     [super flagsChanged:event];
 }
 
-- (bool) handleKeyDown: (NSTimeInterval) timestamp withKey:(AvnKey)key withPhysicalKey:(AvnPhysicalKey)physicalKey withModifiers:(AvnInputModifiers)modifiers withKeySymbol:(NSString*)keySymbol {
-    auto parent = _parent.tryGet();
-    return parent->TopLevelEvents->RawKeyEvent(KeyDown, timestamp, modifiers, key, physicalKey, [keySymbol UTF8String]);
+// The input mode an input method uses for direct alphanumeric typing. In this mode the input
+// method passes keys straight through instead of composing, so keys must not be masked.
+static CFStringRef const AlphanumericInputModeId = CFSTR("com.apple.inputmethod.Roman");
+
+static bool InputSourceComposes(TISInputSourceRef source)
+{
+    // A plain keyboard layout never composes. Dead keys are not driven by the input source, they
+    // show up as a composition in progress and are covered by hasMarkedText.
+    auto type = static_cast<CFStringRef>(TISGetInputSourceProperty(source, kTISPropertyInputSourceType));
+
+    if(type == nullptr || CFEqual(type, kTISTypeKeyboardLayout))
+    {
+        return false;
+    }
+
+    auto mode = static_cast<CFStringRef>(TISGetInputSourceProperty(source, kTISPropertyInputModeID));
+
+    return mode == nullptr || !CFEqual(mode, AlphanumericInputModeId);
+}
+
+// Whether this keystroke could be the one that starts a composition. Only a key that produces a
+// printable character can, and masking any of the others would stop controls like TextBox from
+// reacting to them at all.
+static bool CanStartComposition(NSString* keySymbol, NSEventModifierFlags modifierFlags)
+{
+    // No symbol at all: the arrows, the function keys, Home, End and friends.
+    if(keySymbol == nullptr || [keySymbol length] == 0)
+    {
+        return false;
+    }
+
+    // KeySymbolFromScanCode deliberately reports the control character for Backspace, Enter, Tab
+    // and Escape, and Forward Delete reports DEL (0x7F), so a symbol alone does not mean the key
+    // produces text. Those keys edit or cancel, they never start a composition.
+    auto firstChar = [keySymbol characterAtIndex:0];
+
+    if(firstChar < 0x20 || firstChar == 0x7F)
+    {
+        return false;
+    }
+
+    // Command and Control combinations are shortcuts, which an input method does not consume.
+    return (modifierFlags & (NSEventModifierFlagCommand | NSEventModifierFlagControl)) == 0;
+}
+
+// Returns true when the input source with the given id is an input method that can start a
+// composition, as opposed to a plain keyboard layout or an input method in alphanumeric mode.
+static bool KeyboardInputSourceComposes(NSString* sourceId)
+{
+    NSDictionary* filter = @{ (__bridge NSString*)kTISPropertyInputSourceID: sourceId };
+
+    // Include every installed source, not just the enabled ones: an input method mode can be
+    // selected without being listed as enabled, and failing to find it would classify a
+    // composing input method as a plain layout.
+    auto sources = TISCreateInputSourceList((__bridge CFDictionaryRef)filter, true);
+
+    if(sources == nullptr)
+    {
+        return false;
+    }
+
+    auto composes = CFArrayGetCount(sources) > 0 &&
+        InputSourceComposes((TISInputSourceRef)CFArrayGetValueAtIndex(sources, 0));
+
+    CFRelease(sources);
+
+    return composes;
+}
+
+// Whether the currently selected keyboard input source is a composing input method. The result
+// is cached per input source id, since this is queried for every key down.
+- (bool)isComposingInputSourceSelected
+{
+    auto inputContext = [self inputContext];
+
+    if(inputContext == nullptr)
+    {
+        return false;
+    }
+
+    NSString* sourceId = [inputContext selectedKeyboardInputSource];
+
+    if(sourceId == nullptr)
+    {
+        return false;
+    }
+
+    if(![sourceId isEqualToString:_keyboardInputSourceId])
+    {
+        _keyboardInputSourceId = sourceId;
+        _keyboardInputSourceComposes = KeyboardInputSourceComposes(sourceId);
+    }
+
+    return _keyboardInputSourceComposes;
 }
 
 - (void)keyDown:(NSEvent *)event
@@ -661,57 +754,57 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
     {
         return;
     }
-    
-    _lastKeyDownEvent = event;
-    
+
     auto timestamp = static_cast<uint64_t>([event timestamp] * 1000);
-    
+
     auto scanCode = [event keyCode];
-    auto key = VirtualKeyFromScanCode(scanCode, [event modifierFlags]);
     auto physicalKey = PhysicalKeyFromScanCode(scanCode);
     auto keySymbol = KeySymbolFromScanCode(scanCode, [event modifierFlags]);
-    
+    auto keySymbolUtf8 = keySymbol == nullptr ? nullptr : [keySymbol UTF8String];
+
     auto modifiers = [self getModifiers:[event modifierFlags]];
-    
-    //InputMethod is active
-    if(parent->InputMethod->IsActive()){
-        auto hasInputModifier = modifiers != AvnInputModifiersNone;
-        
-        //Handle keyDown first if an input modifier is present
-        if(hasInputModifier){
-            if([self handleKeyDown:timestamp withKey:key withPhysicalKey:physicalKey withModifiers:modifiers withKeySymbol:keySymbol]){
-                //User code has handled the event
-                _lastKeyDownEvent = nullptr;
-                
-                return;
-            }
-        }
-        
-        if([[self inputContext] handleEvent:event] == NO){
-            //KeyDown has not been consumed by the input context
-                
-            //Only raise a keyDown if we don't have a modifier
-            if(!hasInputModifier){
-                [self handleKeyDown:timestamp withKey:key withPhysicalKey:physicalKey withModifiers:modifiers withKeySymbol:keySymbol];
-            }
-        }
-        
+
+    // The keystroke belongs to the input method when a composition is already in progress, since
+    // it then selects a candidate, commits or cancels it. It also belongs to the input method
+    // when a character key is typed into a text input client while a composing input method is
+    // selected, because that keystroke may be the one that starts the composition and we cannot
+    // know that before the input context has seen it.
+    //
+    // In both cases mask the key the way Win32 reports VK_PROCESSKEY, so that user code still
+    // observes a KeyDown but no KeyGesture can match it. The physical key and the key symbol
+    // keep their real values, so the underlying key remains recoverable.
+    //
+    // Both cases require an active client: without one the input context is never consulted, so
+    // marked text left over from a composition that lost its client mid-way must not mask keys.
+    auto imeProcessed = parent->InputMethod->IsActive() &&
+        ([self hasMarkedText] ||
+         (CanStartComposition(keySymbol, [event modifierFlags]) &&
+          [self isComposingInputSourceSelected]));
+
+    auto key = imeProcessed
+        ? AvnKeyImeProcessed
+        : VirtualKeyFromScanCode(scanCode, [event modifierFlags]);
+
+    // A KeyDown is always raised before the input context sees the event, otherwise the
+    // input context silently consumes printable keys (space, letters, digits) and user code
+    // never gets a chance to react to them.
+    auto handled = parent->TopLevelEvents->RawKeyEvent(KeyDown, timestamp, modifiers, key, physicalKey, keySymbolUtf8);
+
+    if(handled)
+    {
+        // User code has handled the event, so no text may be produced from it.
+        return;
     }
-    //InputMethod not active
-    else{
-        auto keyDownHandled = [self handleKeyDown:timestamp withKey:key withPhysicalKey:physicalKey withModifiers:modifiers withKeySymbol:keySymbol];
-            
-        //Raise text input event for unhandled key down
-        if(!keyDownHandled){
-            if(keySymbol != nullptr && key != AvnKeyEnter){
-                auto timestamp = static_cast<uint64_t>([event timestamp] * 1000);
-                
-                parent->TopLevelEvents->RawTextInputEvent(timestamp, [keySymbol UTF8String]);
-            }
-        }
+
+    if(parent->InputMethod->IsActive())
+    {
+        // Let the input context produce the text or drive the composition.
+        [[self inputContext] handleEvent:event];
+    }
+    else if(keySymbol != nullptr && key != AvnKeyEnter)
+    {
+        parent->TopLevelEvents->RawTextInputEvent(timestamp, keySymbolUtf8);
     }
-    
-    _lastKeyDownEvent = nullptr;
 }
 
 - (void)keyUp:(NSEvent *)event
@@ -721,9 +814,9 @@ static void ConvertTilt(NSPoint tilt, float* xTilt, float* yTilt)
 }
 
 - (void) doCommandBySelector:(SEL)selector{
-    if(_lastKeyDownEvent != nullptr){
-        [self keyboardEvent:_lastKeyDownEvent withType:KeyDown];
-    }
+    // -keyDown: already raised a KeyDown for this event before handing it to the input
+    // context, so nothing is left to do here. The method still has to be implemented:
+    // falling back to NSResponder would perform the default action and emit a system beep.
 }
 
 - (AvnInputModifiers)getModifiers:(NSEventModifierFlags)mod
diff --git a/samples/IntegrationTestApp/MainWindow.axaml.cs b/samples/IntegrationTestApp/MainWindow.axaml.cs
index f306ce84af..355df243ef 100644
--- a/samples/IntegrationTestApp/MainWindow.axaml.cs
+++ b/samples/IntegrationTestApp/MainWindow.axaml.cs
@@ -86,6 +86,7 @@ namespace IntegrationTestApp
                 new("DragDrop", () => new DragDropPage()),
                 new("Embedding", () => new EmbeddingPage()),
                 new("Gestures", () => new GesturesPage()),
+                new("Keyboard", () => new KeyboardPage()),
                 new("ListBox", () => new ListBoxPage()),
                 new("Menu", () => new MenuPage()),
                 new("Pointer", () => new PointerPage()),
diff --git a/samples/IntegrationTestApp/Pages/KeyboardPage.axaml b/samples/IntegrationTestApp/Pages/KeyboardPage.axaml
new file mode 100644
index 0000000000..23dba97f40
--- /dev/null
+++ b/samples/IntegrationTestApp/Pages/KeyboardPage.axaml
@@ -0,0 +1,45 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+             x:Class="IntegrationTestApp.Pages.KeyboardPage">
+  <StackPanel Margin="8" Spacing="8">
+    <Border Name="GestureScope" Padding="8" BorderThickness="1" BorderBrush="Gray">
+      <StackPanel Spacing="4">
+        <TextBlock>Key bindings in scope: Space, A, Ctrl+G</TextBlock>
+        <TextBox Name="GestureTextBox"/>
+      </StackPanel>
+    </Border>
+
+    <StackPanel Orientation="Horizontal" Spacing="4">
+      <TextBlock>Gesture text box content:</TextBlock>
+      <TextBlock Name="GestureTextBoxContent" Text="{Binding #GestureTextBox.Text}"/>
+    </StackPanel>
+
+    <StackPanel Orientation="Horizontal" Spacing="4">
+      <TextBlock>Last key binding:</TextBlock>
+      <TextBlock Name="LastKeyBinding"/>
+    </StackPanel>
+
+    <TextBlock Margin="0,8,0,0">No key bindings in scope, used to inspect raw key downs:</TextBlock>
+    <TextBox Name="KeyDownTextBox"/>
+
+    <StackPanel Orientation="Horizontal" Spacing="4">
+      <TextBlock>Last key down:</TextBlock>
+      <TextBlock Name="LastKeyDown"/>
+    </StackPanel>
+
+    <StackPanel Orientation="Horizontal" Spacing="4">
+      <TextBlock>Key down count:</TextBlock>
+      <TextBlock Name="KeyDownCount"/>
+    </StackPanel>
+
+    <StackPanel Orientation="Horizontal" Spacing="4">
+      <TextBlock>Last text input:</TextBlock>
+      <TextBlock Name="LastTextInput"/>
+    </StackPanel>
+
+    <Button Name="ResetKeyboard" Click="ResetKeyboard_Click" HorizontalAlignment="Left">Reset</Button>
+  </StackPanel>
+</UserControl>
diff --git a/samples/IntegrationTestApp/Pages/KeyboardPage.axaml.cs b/samples/IntegrationTestApp/Pages/KeyboardPage.axaml.cs
new file mode 100644
index 0000000000..62b386b40f
--- /dev/null
+++ b/samples/IntegrationTestApp/Pages/KeyboardPage.axaml.cs
@@ -0,0 +1,63 @@
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Interactivity;
+
+namespace IntegrationTestApp.Pages;
+
+public partial class KeyboardPage : UserControl
+{
+    private int _keyDownCount;
+
+    public KeyboardPage()
+    {
+        InitializeComponent();
+
+        // Gestures without a modifier are the interesting case: on macOS the key down used to be
+        // swallowed by the input context while a text input client was active.
+        AddKeyBinding(new KeyGesture(Key.Space), "Space");
+        AddKeyBinding(new KeyGesture(Key.A), "A");
+        AddKeyBinding(new KeyGesture(Key.G, KeyModifiers.Control), "Ctrl+G");
+
+        // TextBox handles TextInput, and KeyDown for keys like Backspace and the arrows, in a
+        // class handler that runs before instance handlers. Subscribe with handledEventsToo so
+        // those keys stay visible here.
+        KeyDownTextBox.AddHandler(KeyDownEvent, KeyDownTextBox_KeyDown, handledEventsToo: true);
+        KeyDownTextBox.AddHandler(TextInputEvent, KeyDownTextBox_TextInput, handledEventsToo: true);
+    }
+
+    private void AddKeyBinding(KeyGesture gesture, string name)
+    {
+        GestureScope.KeyBindings.Add(new KeyBinding
+        {
+            Gesture = gesture,
+            Command = new DelegateCommand(() => LastKeyBinding.Text = name)
+        });
+    }
+
+    private void KeyDownTextBox_KeyDown(object? sender, KeyEventArgs e)
+    {
+        // While an input method is composing, the key is masked as Key.ImeProcessed but the
+        // physical key and the key symbol keep their real values. The key symbol is bracketed
+        // to keep whitespace symbols like the space key's visible and assertable.
+        LastKeyDown.Text = $"{e.Key}|{e.PhysicalKey}|[{e.KeySymbol}]";
+
+        // Counts every key down, including the ones flagsChanged raises for modifier keys.
+        KeyDownCount.Text = (++_keyDownCount).ToString();
+    }
+
+    private void KeyDownTextBox_TextInput(object? sender, TextInputEventArgs e)
+    {
+        LastTextInput.Text = $"[{e.Text}]";
+    }
+
+    private void ResetKeyboard_Click(object? sender, RoutedEventArgs e)
+    {
+        _keyDownCount = 0;
+        KeyDownCount.Text = string.Empty;
+        LastKeyBinding.Text = string.Empty;
+        LastKeyDown.Text = string.Empty;
+        LastTextInput.Text = string.Empty;
+        GestureTextBox.Text = string.Empty;
+        KeyDownTextBox.Text = string.Empty;
+    }
+}
diff --git a/tests/Avalonia.IntegrationTests.Appium/KeyboardTests.cs b/tests/Avalonia.IntegrationTests.Appium/KeyboardTests.cs
new file mode 100644
index 0000000000..ced2efb3d1
--- /dev/null
+++ b/tests/Avalonia.IntegrationTests.Appium/KeyboardTests.cs
@@ -0,0 +1,133 @@
+using OpenQA.Selenium;
+using OpenQA.Selenium.Interactions;
+using Xunit;
+
+namespace Avalonia.IntegrationTests.Appium
+{
+    [Collection("Default")]
+    public class KeyboardTests : TestBase
+    {
+        // These tests synthesize key input through W3C actions, which the mac2 driver bundled
+        // with Appium 1 does not implement. On macOS they need Appium 2+ with a current mac2
+        // driver, so the Appium 1 configuration only runs them on Windows via WinAppDriver.
+        private const string RequiresW3CKeyActions =
+            "The mac2 driver bundled with Appium 1 does not implement W3C key actions";
+
+        public KeyboardTests(DefaultAppFixture fixture)
+            : base(fixture, "Keyboard")
+        {
+            var reset = Session.FindElementByAccessibilityId("ResetKeyboard");
+            reset.Click();
+        }
+
+#if APPIUM1
+        [PlatformFact(TestPlatforms.Windows, RequiresW3CKeyActions)]
+#else
+        [Fact]
+#endif
+        public void KeyBinding_Without_Modifier_Is_Raised_While_TextBox_Is_Focused()
+        {
+            var textBox = Session.FindElementByAccessibilityId("GestureTextBox");
+            var lastKeyBinding = Session.FindElementByAccessibilityId("LastKeyBinding");
+
+            textBox.Click();
+            new Actions(Session).SendKeys(Keys.Space).Perform();
+
+            Assert.Equal("Space", lastKeyBinding.Text);
+        }
+
+#if APPIUM1
+        [PlatformFact(TestPlatforms.Windows, RequiresW3CKeyActions)]
+#else
+        [Fact]
+#endif
+        public void KeyBinding_On_Character_Key_Is_Raised_While_TextBox_Is_Focused()
+        {
+            var textBox = Session.FindElementByAccessibilityId("GestureTextBox");
+            var lastKeyBinding = Session.FindElementByAccessibilityId("LastKeyBinding");
+
+            textBox.Click();
+            new Actions(Session).SendKeys("a").Perform();
+
+            Assert.Equal("A", lastKeyBinding.Text);
+        }
+
+#if APPIUM1
+        [PlatformFact(TestPlatforms.Windows, RequiresW3CKeyActions)]
+#else
+        [Fact]
+#endif
+        public void KeyBinding_With_Modifier_Is_Raised_While_TextBox_Is_Focused()
+        {
+            var textBox = Session.FindElementByAccessibilityId("GestureTextBox");
+            var lastKeyBinding = Session.FindElementByAccessibilityId("LastKeyBinding");
+
+            textBox.Click();
+            new Actions(Session)
+                .KeyDown(Keys.Control)
+                .SendKeys("g")
+                .KeyUp(Keys.Control)
+                .Perform();
+
+            Assert.Equal("Ctrl+G", lastKeyBinding.Text);
+        }
+
+#if APPIUM1
+        [PlatformFact(TestPlatforms.Windows, RequiresW3CKeyActions)]
+#else
+        [Fact]
+#endif
+        public void Handled_KeyBinding_Does_Not_Insert_Text()
+        {
+            var textBox = Session.FindElementByAccessibilityId("GestureTextBox");
+            var content = Session.FindElementByAccessibilityId("GestureTextBoxContent");
+
+            textBox.Click();
+            new Actions(Session).SendKeys(Keys.Space).Perform();
+
+            // A matched KeyBinding marks the key event as handled, which must prevent the
+            // platform from producing text for it.
+            Assert.Equal(string.Empty, content.Text);
+        }
+
+#if APPIUM1
+        [PlatformFact(TestPlatforms.Windows, RequiresW3CKeyActions)]
+#else
+        [Fact]
+#endif
+        public void Unhandled_Key_Still_Produces_Text()
+        {
+            var textBox = Session.FindElementByAccessibilityId("KeyDownTextBox");
+            var lastKeyDown = Session.FindElementByAccessibilityId("LastKeyDown");
+            var lastTextInput = Session.FindElementByAccessibilityId("LastTextInput");
+
+            textBox.Click();
+            new Actions(Session).SendKeys("b").Perform();
+
+            Assert.Equal("b", textBox.Text);
+            Assert.Equal("B|B|[b]", lastKeyDown.Text);
+            Assert.Equal("[b]", lastTextInput.Text);
+        }
+
+#if APPIUM1
+        [PlatformFact(TestPlatforms.Windows, RequiresW3CKeyActions)]
+#else
+        [Fact]
+#endif
+        public void Unhandled_Space_Produces_Exactly_One_KeyDown_And_Text()
+        {
+            var textBox = Session.FindElementByAccessibilityId("KeyDownTextBox");
+            var lastKeyDown = Session.FindElementByAccessibilityId("LastKeyDown");
+            var keyDownCount = Session.FindElementByAccessibilityId("KeyDownCount");
+            var lastTextInput = Session.FindElementByAccessibilityId("LastTextInput");
+
+            textBox.Click();
+            new Actions(Session).SendKeys(Keys.Space).Perform();
+
+            // The input context must not produce a second key down for the same NSEvent.
+            Assert.Equal("1", keyDownCount.Text);
+            Assert.Equal("Space|Space|[ ]", lastKeyDown.Text);
+            Assert.Equal("[ ]", lastTextInput.Text);
+        }
+    }
+}

From 055e123b5cb48e79260fb1bf5c36091214266ff1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=BE=8A=E6=92=85=E6=92=85?=
 <31302548+Fachep@users.noreply.github.com>
Date: Wed, 19 Aug 2026 14:43:27 +0000
Subject: [PATCH 177/196] Call ApplyStyling unconditionally in MeasureCore
 (#21572)

* Add unit test for styling affecting measurements in WindowDrawnDecorationsContent

* Refactor layout measurement to apply styling before visibility checks

* Add core measure test

* Add StackPanel test

* Call ApplyStyling unconditionally in MeasureCore

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 src/Avalonia.Base/Layout/Layoutable.cs        |  3 +-
 src/Avalonia.Controls/StackPanel.cs           |  5 +-
 .../Layout/MeasureTests.cs                    | 29 +++++++
 .../StackPanelTests.cs                        | 34 ++++++++
 .../WindowTests.cs                            | 77 +++++++++++++++++++
 5 files changed, 145 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.Base/Layout/Layoutable.cs b/src/Avalonia.Base/Layout/Layoutable.cs
index e526dec046..170b52491e 100644
--- a/src/Avalonia.Base/Layout/Layoutable.cs
+++ b/src/Avalonia.Base/Layout/Layoutable.cs
@@ -543,6 +543,8 @@ namespace Avalonia.Layout
         /// </remarks>
         protected virtual Size MeasureCore(Size availableSize)
         {
+            ApplyStyling();
+
             if (IsVisible)
             {
                 var margin = Margin;
@@ -555,7 +557,6 @@ namespace Avalonia.Layout
                     margin = LayoutHelper.RoundLayoutThickness(margin, scale);
                 }
 
-                ApplyStyling();
                 ApplyTemplate();
 
                 var minMax = new MinMax(this);
diff --git a/src/Avalonia.Controls/StackPanel.cs b/src/Avalonia.Controls/StackPanel.cs
index 007a35c077..63984592da 100644
--- a/src/Avalonia.Controls/StackPanel.cs
+++ b/src/Avalonia.Controls/StackPanel.cs
@@ -261,6 +261,9 @@ namespace Avalonia.Controls
                 // Get next child.
                 var child = children[i];
 
+                // Measure the child.
+                child.Measure(layoutSlotSize);
+
                 bool isVisible = child.IsVisible;
 
                 if (isVisible && !hasVisibleChild)
@@ -268,8 +271,6 @@ namespace Avalonia.Controls
                     hasVisibleChild = true;
                 }
 
-                // Measure the child.
-                child.Measure(layoutSlotSize);
                 Size childDesiredSize = child.DesiredSize;
 
                 // Accumulate child size.
diff --git a/tests/Avalonia.Base.UnitTests/Layout/MeasureTests.cs b/tests/Avalonia.Base.UnitTests/Layout/MeasureTests.cs
index 32c3e89b74..83c634d6ae 100644
--- a/tests/Avalonia.Base.UnitTests/Layout/MeasureTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Layout/MeasureTests.cs
@@ -1,10 +1,39 @@
 using Avalonia.Controls;
+using Avalonia.Styling;
+using Avalonia.UnitTests;
 using Xunit;
 
 namespace Avalonia.Base.UnitTests.Layout
 {
     public class MeasureTests
     {
+        [Fact]
+        public void Style_Hiding_Control_Should_Be_Applied_Before_Measuring()
+        {
+            var child = new Border
+            {
+                Width = 100,
+                Height = 100,
+                Classes = { "hidden" }
+            };
+            var target = new Decorator
+            {
+                Child = child
+            };
+            var root = new TestRoot(target);
+
+            root.Styles.Add(new Style(x => x.OfType<Border>().Class("hidden"))
+            {
+                Setters = { new Setter(Visual.IsVisibleProperty, false) }
+            });
+
+            target.Measure(Size.Infinity);
+
+            Assert.False(child.IsVisible);
+            Assert.Equal(new Size(0,0), child.DesiredSize);
+            Assert.Equal(new Size(0,0), target.DesiredSize);
+        }
+
         [Fact]
         public void Margin_Should_Be_Included_In_DesiredSize()
         {
diff --git a/tests/Avalonia.Controls.UnitTests/StackPanelTests.cs b/tests/Avalonia.Controls.UnitTests/StackPanelTests.cs
index 28ad64bac0..dfb8d38d20 100644
--- a/tests/Avalonia.Controls.UnitTests/StackPanelTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/StackPanelTests.cs
@@ -1,5 +1,6 @@
 using System.Linq;
 using Avalonia.Layout;
+using Avalonia.Styling;
 using Avalonia.UnitTests;
 using Xunit;
 
@@ -330,6 +331,39 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(sizeWithTwoChildren, sizeWithThreeChildren);
         }
 
+        [Theory]
+        [InlineData(Orientation.Horizontal)]
+        [InlineData(Orientation.Vertical)]
+        public void Spacing_Not_Added_For_Children_Hidden_By_Style_Applied_During_Measure(Orientation orientation)
+        {
+            var target = new StackPanel
+            {
+                Spacing = 40,
+                Orientation = orientation,
+                Children =
+                {
+                    new StackPanel { Width = 10, Height = 10, Classes = { "hidden" } },
+                    new StackPanel { Width = 10, Height = 10 },
+                    new StackPanel { Width = 10, Height = 10 },
+                }
+            };
+
+            var root = new TestRoot(target);
+
+            root.Styles.Add(new Style(x => x.OfType<StackPanel>().Class("hidden"))
+            {
+                Setters = { new Setter(Visual.IsVisibleProperty, false) }
+            });
+
+            target.Measure(Size.Infinity);
+
+            var expected = orientation == Orientation.Horizontal ?
+                new Size(60, 10) :
+                new Size(10, 60);
+
+            Assert.Equal(expected, target.DesiredSize);
+        }
+
         [Theory]
         [InlineData(Orientation.Horizontal)]
         [InlineData(Orientation.Vertical)]
diff --git a/tests/Avalonia.Controls.UnitTests/WindowTests.cs b/tests/Avalonia.Controls.UnitTests/WindowTests.cs
index ebd07d2596..ccc7e0ca0f 100644
--- a/tests/Avalonia.Controls.UnitTests/WindowTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/WindowTests.cs
@@ -1642,6 +1642,83 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void IsVisible_Setter_Should_Affect_Measurements_Inside_WindowDrawnDecorationsContent()
+        {
+            using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+            var windowImpl = MockWindowingPlatform.CreateWindowMock();
+            windowImpl.Setup(x => x.NeedsManagedDecorations).Returns(true);
+            windowImpl.Setup(x => x.RequestedDrawnDecorations).Returns(PlatformRequestedDrawnDecoration.TitleBar);
+
+            var window = new Window(windowImpl.Object);
+
+            var stackPanel = new StackPanel
+            {
+                Width = 32,
+                Spacing = 2,
+                Children =
+                {
+                    new Control { Height = 32 },
+                    new Control
+                    {
+                        Height = 32,
+                        Classes = { "hidden-by-style" }
+                    },
+                }
+            };
+
+            var contentControl = new ContentControl
+            {
+                Content = new Control
+                {
+                    Height = 32,
+                    Width = 32,
+                    Classes = { "hidden-by-style" }
+                }
+            };
+
+            var content = new WindowDrawnDecorationsContent
+            {
+                Overlay = new ContentControl
+                {
+                    Content = new Panel
+                    {
+                        Children = { stackPanel, contentControl }
+                    }
+                }
+            };
+
+            var template = new WindowDrawnDecorationsTemplate
+            {
+                Content = (IServiceProvider? _) => new TemplateResult<WindowDrawnDecorationsContent>(content, new NameScope())
+            };
+
+            var theme = new ControlTheme(typeof(WindowDrawnDecorations))
+            {
+                Setters =
+                {
+                    new Setter(WindowDrawnDecorations.TemplateProperty, template)
+                }
+            };
+
+            var style = new Style(x => x.Is<WindowDrawnDecorations>().Template().OfType<Control>().Class("hidden-by-style"))
+            {
+                Setters =
+                {
+                    new Setter(Visual.IsVisibleProperty, false)
+                }
+            };
+
+            window.WindowDecorationsTheme = theme;
+            window.Styles.Add(style);
+            window.Show();
+            window.Measure(Size.Infinity);
+
+            Assert.Equal(new Size(), contentControl.DesiredSize);
+            Assert.Equal(new Size(32, 32), stackPanel.DesiredSize);
+        }
+
         public class TitleBarDecorationsTests : ScopedTestBase
         {
             private static Window CreateWindowWithDrawnDecorations(PlatformAllowedWindowActions allowedActions = PlatformAllowedWindowActions.All)

From 9b5437bb5a29974eba34305fedca90572e17f0dd Mon Sep 17 00:00:00 2001
From: JoaoCruz <joaosantaremdacruz@tecnico.ulisboa.pt>
Date: Wed, 19 Aug 2026 15:11:41 +0000
Subject: [PATCH 178/196] Implement VerticalContentAlignment for DatePicker and
 TimePicker (#21464)

* Add VerticalContentAlignment property to DatePicker and TimePicker

This change registers VerticalContentAlignmentProperty as a
StyledProperty using ContentControl's property as the owner for both
DatePicker and TimePicker controls to maintain framework consistency.

Basic xUnit v3 unit tests are introduced to validate property
round-trips (Top, Center, Bottom, Stretch) and to ensure the default
value correctly resolves to Stretch. This establishes the necessary
C# infrastructure before modifying the control templates.

Part of #21211: implment fluent theme layout

* Fix VerticalContentAlignment bindings and integration tests

- Bind internal grids to VerticalContentAlignment in Fluent and Simple
  themes for DatePicker and TimePicker controls.
- Add comprehensive integration tests using mocked NameScopes in
  DatePickerTests and TimePickerTests to verify visual propagation.
- Validate visual layout correctness using the ControlCatalog app.

Closes AvaloniaUI#21211

* Remove tautological tests

---------

Co-authored-by: Martim Claudino <martimffclaudino@tecnico.ulisboa.pt>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../DateTimePickers/DatePicker.cs             | 15 +++++++++++++++
 .../DateTimePickers/TimePicker.cs             | 14 ++++++++++++++
 .../Controls/DatePicker.xaml                  |  2 +-
 .../Controls/TimePicker.xaml                  |  2 +-
 .../Controls/DatePicker.xaml                  |  3 ++-
 .../Controls/TimePicker.xaml                  |  2 +-
 .../DatePickerTests.cs                        | 19 +++++++++++++++++++
 .../TimePickerTests.cs                        | 19 +++++++++++++++++++
 8 files changed, 72 insertions(+), 4 deletions(-)

diff --git a/src/Avalonia.Controls/DateTimePickers/DatePicker.cs b/src/Avalonia.Controls/DateTimePickers/DatePicker.cs
index 2f406252f7..c4206c7315 100644
--- a/src/Avalonia.Controls/DateTimePickers/DatePicker.cs
+++ b/src/Avalonia.Controls/DateTimePickers/DatePicker.cs
@@ -75,6 +75,21 @@ namespace Avalonia.Controls
         public static readonly StyledProperty<bool> YearVisibleProperty =
             AvaloniaProperty.Register<DatePicker, bool>(nameof(YearVisible), true);
 
+        /// <summary>
+        /// Defines the <see cref="VerticalContentAlignment"/> property.
+        /// </summary>
+        public static readonly StyledProperty<VerticalAlignment> VerticalContentAlignmentProperty =
+            ContentControl.VerticalContentAlignmentProperty.AddOwner<DatePicker>();
+
+        /// <summary>
+        /// Gets or sets the vertical alignment of the content within the control.
+        /// </summary>
+        public VerticalAlignment VerticalContentAlignment
+        {
+            get => GetValue(VerticalContentAlignmentProperty);
+            set => SetValue(VerticalContentAlignmentProperty, value);
+        }
+
         /// <summary>
         /// Defines the <see cref="SelectedDate"/> Property
         /// </summary>
diff --git a/src/Avalonia.Controls/DateTimePickers/TimePicker.cs b/src/Avalonia.Controls/DateTimePickers/TimePicker.cs
index 95d9e82782..7c6f96247f 100644
--- a/src/Avalonia.Controls/DateTimePickers/TimePicker.cs
+++ b/src/Avalonia.Controls/DateTimePickers/TimePicker.cs
@@ -50,6 +50,20 @@ namespace Avalonia.Controls
         public static readonly StyledProperty<string> ClockIdentifierProperty =
            AvaloniaProperty.Register<TimePicker, string>(nameof(ClockIdentifier), "12HourClock", coerce: CoerceClockIdentifier);
         
+        /// <summary>
+        /// Defines the <see cref="VerticalContentAlignment"/> property.
+        /// </summary>
+        public static readonly StyledProperty<VerticalAlignment> VerticalContentAlignmentProperty =
+            ContentControl.VerticalContentAlignmentProperty.AddOwner<TimePicker>();
+
+        /// <summary>
+        /// Gets or sets the vertical alignment of the content within the control.
+        /// </summary>
+        public VerticalAlignment VerticalContentAlignment
+        {
+            get => GetValue(VerticalContentAlignmentProperty);
+            set => SetValue(VerticalContentAlignmentProperty, value);
+        }
         /// <summary>
         /// Defines the <see cref="UseSeconds"/> property
         /// </summary>
diff --git a/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml b/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml
index b38187cd60..d7bb32fb43 100644
--- a/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml
@@ -98,7 +98,7 @@
                     HorizontalAlignment="Stretch"
                     VerticalAlignment="Stretch"
                     TemplatedControl.IsTemplateFocusTarget="True">
-              <Grid Name="PART_ButtonContentGrid" ColumnDefinitions="78*,Auto,132*,Auto,78*">
+              <Grid Name="PART_ButtonContentGrid" ColumnDefinitions="78*,Auto,132*,Auto,78*" VerticalAlignment="{TemplateBinding VerticalContentAlignment}">
                 <TextBlock Name="PART_DayTextBlock" Text="{DynamicResource StringDatePickerDayText}" HorizontalAlignment="Center"
                            Padding="{DynamicResource DatePickerHostPadding}" />
                 <TextBlock Name="PART_MonthTextBlock" Text="{DynamicResource StringDatePickerMonthText}" TextAlignment="Left"
diff --git a/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml b/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
index 0b4f6852bf..81c31fecda 100644
--- a/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
@@ -97,7 +97,7 @@
                     HorizontalAlignment="Stretch"
                     VerticalAlignment="Stretch">
 
-              <Grid Name="PART_FlyoutButtonContentGrid">
+              <Grid Name="PART_FlyoutButtonContentGrid" VerticalAlignment="{TemplateBinding VerticalContentAlignment}">
                 <!--Ignore col defs here, set in code-->
                 <Border x:Name="PART_FirstPickerHost"
                         Grid.Column="0"
diff --git a/src/Avalonia.Themes.Simple/Controls/DatePicker.xaml b/src/Avalonia.Themes.Simple/Controls/DatePicker.xaml
index d933afa43e..f7cf34d0dc 100644
--- a/src/Avalonia.Themes.Simple/Controls/DatePicker.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/DatePicker.xaml
@@ -106,7 +106,8 @@
                     TemplatedControl.IsTemplateFocusTarget="True"
                     Theme="{StaticResource SimpleDatePickerFlyoutButton}">
               <Grid Name="PART_ButtonContentGrid"
-                    ColumnDefinitions="78*,Auto,132*,Auto,78*">
+                    ColumnDefinitions="78*,Auto,132*,Auto,78*"
+                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}">
                 <TextBlock Name="PART_DayTextBlock"
                            Padding="{DynamicResource DatePickerHostPadding}"
                            HorizontalAlignment="Center"
diff --git a/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml b/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml
index aed297fba2..3c95d9f63c 100644
--- a/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml
@@ -103,7 +103,7 @@
                     IsEnabled="{TemplateBinding IsEnabled}"
                     Theme="{StaticResource SimpleTimePickerFlyoutButton}">
 
-              <Grid Name="PART_FlyoutButtonContentGrid">
+              <Grid Name="PART_FlyoutButtonContentGrid" VerticalAlignment="{TemplateBinding VerticalContentAlignment}">
                 <!--  Ignore col defs here, set in code  -->
                 <Border x:Name="PART_FirstPickerHost"
                         Grid.Column="0"
diff --git a/tests/Avalonia.Controls.UnitTests/DatePickerTests.cs b/tests/Avalonia.Controls.UnitTests/DatePickerTests.cs
index 4688a88fc5..67eb176206 100644
--- a/tests/Avalonia.Controls.UnitTests/DatePickerTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/DatePickerTests.cs
@@ -13,6 +13,7 @@ using Avalonia.Platform;
 using Avalonia.Threading;
 using Avalonia.UnitTests;
 using Avalonia.VisualTree;
+using Avalonia.Layout;
 using Moq;
 using Xunit;
 
@@ -371,6 +372,24 @@ namespace Avalonia.Controls.UnitTests
             });
         }
 
+        [Theory]
+        [InlineData(Avalonia.Layout.VerticalAlignment.Top)]
+        [InlineData(Avalonia.Layout.VerticalAlignment.Center)]
+        [InlineData(Avalonia.Layout.VerticalAlignment.Bottom)]
+        [InlineData(Avalonia.Layout.VerticalAlignment.Stretch)]
+        public void VerticalContentAlignment_RoundTrips(Avalonia.Layout.VerticalAlignment value)
+        {
+            var datePicker = new DatePicker { VerticalContentAlignment = value };
+            Assert.Equal(value, datePicker.VerticalContentAlignment);
+        }
+
+        [Fact]
+        public void VerticalContentAlignment_Default_Is_Stretch()
+        {
+            var datePicker = new DatePicker();
+            Assert.Equal(Avalonia.Layout.VerticalAlignment.Stretch, datePicker.VerticalContentAlignment);
+        }
+
         private static IControlTemplate CreatePickerTemplate()
         {
             return new FuncControlTemplate((_, scope) =>
diff --git a/tests/Avalonia.Controls.UnitTests/TimePickerTests.cs b/tests/Avalonia.Controls.UnitTests/TimePickerTests.cs
index 11c52392f1..86e77f9722 100644
--- a/tests/Avalonia.Controls.UnitTests/TimePickerTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TimePickerTests.cs
@@ -11,6 +11,7 @@ using Avalonia.Platform;
 using Avalonia.Threading;
 using Avalonia.UnitTests;
 using Avalonia.VisualTree;
+using Avalonia.Layout;
 using Moq;
 using Xunit;
 
@@ -466,5 +467,23 @@ namespace Avalonia.Controls.UnitTests
                 return contentPanel;
             });
         }
+
+        [Theory]
+        [InlineData(Avalonia.Layout.VerticalAlignment.Top)]
+        [InlineData(Avalonia.Layout.VerticalAlignment.Center)]
+        [InlineData(Avalonia.Layout.VerticalAlignment.Bottom)]
+        [InlineData(Avalonia.Layout.VerticalAlignment.Stretch)]
+        public void VerticalContentAlignment_RoundTrips(Avalonia.Layout.VerticalAlignment value)
+        {
+            var timePicker = new TimePicker { VerticalContentAlignment = value };
+            Assert.Equal(value, timePicker.VerticalContentAlignment);
+        }
+
+        [Fact]
+        public void VerticalContentAlignment_Default_Is_Stretch()
+        {
+            var timePicker = new TimePicker();
+            Assert.Equal(Avalonia.Layout.VerticalAlignment.Stretch, timePicker.VerticalContentAlignment);
+        }
     }
 }

From 4918bdf37012173e18ad43eca4a5729a952c13f0 Mon Sep 17 00:00:00 2001
From: Brian Pham <brian.w.pham@gmail.com>
Date: Wed, 19 Aug 2026 15:24:20 +0000
Subject: [PATCH 179/196] osx: keep window creation on-screen during display
 reconfiguration (#21543)

* osx: anchor new windows to the primary screen origin

WindowBaseImpl::CreateNSWindow anchors the new NSWindow's content rect to the
primary screen's frame.origin. The primary screen is at Cocoa (0,0) on a
healthy Mac, but can be offset (often negative) while the display server is
mid-reconfiguration -- e.g. CGMainDisplayID() briefly returns 0 after
wake-from-sleep -- or on multi-monitor layouts where the primary is not at the
origin. Anchoring keeps the window on a real screen so it is positioned
on-screen and its flipped Position lands inside a Screen.Bounds.

See #18895.

Co-authored-by: Cursor <cursoragent@cursor.com>

* osx: keep window construction resilient when no screen contains it

When locating the screen that sizes a new window, fall back to a default size
if AppKit reports no screens -- or none whose bounds contain the last-known
position -- during a display reconfiguration. The window is repositioned on the
next ScreenChanged event once the display server settles.

See #18895.

Co-authored-by: Cursor <cursoragent@cursor.com>

* Less verbose comments

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 native/Avalonia.Native/src/OSX/WindowBaseImpl.mm | 14 ++++++++++++--
 src/Avalonia.Native/WindowImplBase.cs            | 16 ++++++++++++++--
 2 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm b/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm
index 33ab1529fc..205f1efbdf 100644
--- a/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm
+++ b/native/Avalonia.Native/src/OSX/WindowBaseImpl.mm
@@ -465,11 +465,21 @@ void WindowBaseImpl::CleanNSWindow() {
 }
 
 void WindowBaseImpl::CreateNSWindow(bool usePanel) {
+    // Anchor the content rect to the primary screen's origin. It's usually at (0,0), but can be offset while the
+    // display server is mid-reconfiguration. This ensures the window is always on a proper screen.
+    // See https://github.com/AvaloniaUI/Avalonia/issues/18895
+    NSPoint origin = NSZeroPoint;
+    NSArray<NSScreen*>* screens = [NSScreen screens];
+    if (screens.count > 0)
+        origin = screens.firstObject.frame.origin;
+
+    NSRect contentRect = NSRect { origin.x, origin.y, lastSize };
+
     if (usePanel) {
-        Window = [[AvnPanel alloc] initWithParent:this contentRect:NSRect{0, 0, lastSize} styleMask:NSWindowStyleMaskBorderless];
+        Window = [[AvnPanel alloc] initWithParent:this contentRect:contentRect styleMask:NSWindowStyleMaskBorderless];
         [Window setHidesOnDeactivate:false];
     } else {
-        Window = [[AvnWindow alloc] initWithParent:this contentRect:NSRect{0, 0, lastSize} styleMask:NSWindowStyleMaskBorderless];
+        Window = [[AvnWindow alloc] initWithParent:this contentRect:contentRect styleMask:NSWindowStyleMaskBorderless];
     }
 }
 
diff --git a/src/Avalonia.Native/WindowImplBase.cs b/src/Avalonia.Native/WindowImplBase.cs
index 8d7270dede..1f7f478788 100644
--- a/src/Avalonia.Native/WindowImplBase.cs
+++ b/src/Avalonia.Native/WindowImplBase.cs
@@ -51,11 +51,23 @@ namespace Avalonia.Native
 
             base.Init(handle);
 
+            int defaultWidth = 0, defaultHeight = 0;
+
             var monitor = this.TryGetFeature<IScreenImpl>()!.AllScreens
                 .OrderBy(x => x.Scaling)
-                .First(m => m.Bounds.Contains(Position));
+                .FirstOrDefault(m => m.Bounds.Contains(Position));
+
+            if (monitor != null)
+            {
+                // Emulate Windows 7+ default window size behavior.
+                defaultWidth = (int)(monitor.WorkingArea.Width * 0.75d);
+                defaultHeight = (int)(monitor.WorkingArea.Height * 0.7d);
+            }
+
+            defaultWidth = Math.Max(defaultWidth, 300);
+            defaultHeight = Math.Max(defaultHeight, 200);
 
-            Resize(new Size(monitor.WorkingArea.Width * 0.75d, monitor.WorkingArea.Height * 0.7d), WindowResizeReason.Layout);
+            Resize(new Size(defaultWidth, defaultHeight), WindowResizeReason.Layout);
         }
 
         public void Activate()

From aed3e84bbf4125ad7b57d2200c6130f11d71e10b Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Wed, 19 Aug 2026 16:47:10 +0000
Subject: [PATCH 180/196] RefreshContainer - show refresh indicator when
 refresh is triggered programmatically (#22020)

* refresh container - show refresh indicator when refresh is triggered programmatically

* add test
---
 .../Pages/RefreshContainerPage.axaml          |  1 +
 .../Pages/RefreshContainerPage.axaml.cs       |  7 ++++
 .../ViewModels/RefreshContainerViewModel.cs   |  2 --
 .../PullToRefresh/RefreshVisualizer.cs        |  3 +-
 .../PullToRefresh/RefreshVisualizerTests.cs   | 36 +++++++++++++++++++
 5 files changed, 46 insertions(+), 3 deletions(-)
 create mode 100644 tests/Avalonia.Controls.UnitTests/PullToRefresh/RefreshVisualizerTests.cs

diff --git a/samples/ControlCatalog/Pages/RefreshContainerPage.axaml b/samples/ControlCatalog/Pages/RefreshContainerPage.axaml
index a905e4efdf..5e25d927ba 100644
--- a/samples/ControlCatalog/Pages/RefreshContainerPage.axaml
+++ b/samples/ControlCatalog/Pages/RefreshContainerPage.axaml
@@ -27,6 +27,7 @@
             </generic:List>
           </ComboBox.ItemsSource>
         </ComboBox>
+        <Button Content="Refresh" Name="RefreshButton"/>
       </StackPanel>
     </StackPanel>
     <RefreshContainer Name="Refresh"
diff --git a/samples/ControlCatalog/Pages/RefreshContainerPage.axaml.cs b/samples/ControlCatalog/Pages/RefreshContainerPage.axaml.cs
index 2c886fa9de..0845160155 100644
--- a/samples/ControlCatalog/Pages/RefreshContainerPage.axaml.cs
+++ b/samples/ControlCatalog/Pages/RefreshContainerPage.axaml.cs
@@ -11,11 +11,18 @@ namespace ControlCatalog.Pages
         {
             InitializeComponent();
 
+            RefreshButton.Click += RefreshButton_Click;
+
             _viewModel = new RefreshContainerViewModel();
 
             DataContext = _viewModel;
         }
 
+        private void RefreshButton_Click(object? sender, Avalonia.Interactivity.RoutedEventArgs e)
+        {
+            Refresh.RequestRefresh();
+        }
+
         private async void RefreshContainerPage_RefreshRequested(object? sender, RefreshRequestedEventArgs e)
         {
             var deferral = e.GetDeferral();
diff --git a/samples/ControlCatalog/ViewModels/RefreshContainerViewModel.cs b/samples/ControlCatalog/ViewModels/RefreshContainerViewModel.cs
index aa15d7758b..d2361178e1 100644
--- a/samples/ControlCatalog/ViewModels/RefreshContainerViewModel.cs
+++ b/samples/ControlCatalog/ViewModels/RefreshContainerViewModel.cs
@@ -1,8 +1,6 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Threading.Tasks;
-using Avalonia.Controls.Notifications;
-using ControlCatalog.Pages;
 using MiniMvvm;
 
 namespace ControlCatalog.ViewModels
diff --git a/src/Avalonia.Controls/PullToRefresh/RefreshVisualizer.cs b/src/Avalonia.Controls/PullToRefresh/RefreshVisualizer.cs
index d323965c13..cafd812941 100644
--- a/src/Avalonia.Controls/PullToRefresh/RefreshVisualizer.cs
+++ b/src/Avalonia.Controls/PullToRefresh/RefreshVisualizer.cs
@@ -312,6 +312,7 @@ namespace Avalonia.Controls
         /// </summary>
         public void RequestRefresh()
         {
+            RefreshInfoProvider?.InteractionRatio = 1;
             RefreshVisualizerState = RefreshVisualizerState.Refreshing;
             RefreshInfoProvider?.OnRefreshStarted();
 
@@ -320,8 +321,8 @@ namespace Avalonia.Controls
 
         private void RefreshCompleted()
         {
+            RefreshInfoProvider?.InteractionRatio = 0;
             RefreshVisualizerState = RefreshVisualizerState.Idle;
-
             RefreshInfoProvider?.OnRefreshCompleted();
         }
 
diff --git a/tests/Avalonia.Controls.UnitTests/PullToRefresh/RefreshVisualizerTests.cs b/tests/Avalonia.Controls.UnitTests/PullToRefresh/RefreshVisualizerTests.cs
new file mode 100644
index 0000000000..4a494509d7
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/PullToRefresh/RefreshVisualizerTests.cs
@@ -0,0 +1,36 @@
+using Avalonia.Controls.PullToRefresh;
+using Avalonia.Input;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests.PullToRefresh
+{
+    public class RefreshVisualizerTests : ScopedTestBase
+    {
+        [Fact]
+        public void InteractionRatio_Is_One_While_Refreshing_And_Zero_After_Completion()
+        {
+            var provider = new RefreshInfoProvider(
+                PullDirection.TopToBottom,
+                new Size(100, 100),
+                visual: null);
+
+            var visualizer = new RefreshVisualizer();
+            visualizer.RefreshInfoProvider = provider;
+
+            var sawDuringRefresh = false;
+
+            visualizer.RefreshRequested += (s, e) =>
+            {
+                Assert.Equal(1d, provider.InteractionRatio);
+                sawDuringRefresh = true;
+            };
+
+            visualizer.RequestRefresh();
+
+            Assert.True(sawDuringRefresh, "RefreshRequested event should have been raised");
+
+            Assert.Equal(0d, provider.InteractionRatio);
+        }
+    }
+}

From 79162b5da8c39c6fd0fffc21bfc872025f0ae561 Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Wed, 19 Aug 2026 17:22:19 +0000
Subject: [PATCH 181/196] feat: implement unified IFormattable on Color,
 HslColor, and HsvColor (#20919)

* fix: correct HslColor.ToString() prefix from hsva to hsla

Pre-existing copy-paste bug: HslColor.ToString() was outputting
"hsva(" instead of "hsla(" for its default format.

* feat: implement unified IFormattable on Color, HslColor, and HsvColor

All three color types now support all format specifiers via
auto-conversion, following the DateTime analogy where the same
format codes work regardless of source type.

Format specifiers:
  Hex:  X (#AARRGGBB), x (#RRGGBB), H (#RRGGBBAA)
  RGB:  R/r (absolute), R%/r% (percent)
  HSL:  L/l (CSS standard), L%/l% (all percent)
  HSV:  V/v (CSS standard), V%/v% (all percent)

Convention: uppercase = include alpha (rgba/hsla/hsva prefix),
lowercase = exclude alpha (rgb/hsl/hsv prefix).

Each type handles its native model natively and delegates
cross-model formats via ToRgb()/ToHsl()/ToHsv().

Breaking changes from prior PR iteration:
- "h" dropped (identical to "x" without alpha)
- "C"/"c" removed, reserved for future complex format strings
- "P"/"p" replaced by "R%"/"r%"
- "R" now outputs rgba() not rgb() (CSS convention)
- "L" now outputs hsla() not hsl() (CSS convention)
- "V" now outputs hsva() not hsv() (CSS convention)

* refactor(media): clarify color CSS formatters

Color formatting now exposes the same IFormattable implementation in the BuildTask compile path as in normal builds. Keeping the interface conditional made the public contract harder to reason about even though the formatting members are System-only APIs.

Remove the BuildTask guard from the formatting members, combine alpha and no-alpha CSS helpers behind includeAlpha parameters, and rename the helpers so future changes preserve the CSS-compliant output contract.

* Remove regions

---------

Co-authored-by: Jumar Macato <16554748+jmacato@users.noreply.github.com>
Co-authored-by: Nathan Nguyen <HoangAnhVu.Nguyen-1@student.uts.edu.au>
Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 src/Avalonia.Base/Media/Color.cs              |  93 +++-
 src/Avalonia.Base/Media/HslColor.cs           |  97 ++++-
 src/Avalonia.Base/Media/HsvColor.cs           |  95 +++-
 .../Media/ColorTests.cs                       | 411 ++++++++++++++++++
 4 files changed, 692 insertions(+), 4 deletions(-)

diff --git a/src/Avalonia.Base/Media/Color.cs b/src/Avalonia.Base/Media/Color.cs
index ae16c30320..624513f065 100644
--- a/src/Avalonia.Base/Media/Color.cs
+++ b/src/Avalonia.Base/Media/Color.cs
@@ -21,7 +21,7 @@ namespace Avalonia.Media
 #if !BUILDTASK
     public
 #endif
-    readonly struct Color : IEquatable<Color>
+    readonly struct Color : IEquatable<Color>, IFormattable
     {
         private const double byteToDouble = 1.0 / 255;
 
@@ -461,6 +461,97 @@ namespace Avalonia.Media
             }
         }
 
+        /// <summary>
+        /// Returns a formatted string representation of the color.
+        /// </summary>
+        /// <param name="format">
+        /// The format specifier. All color types support all specifiers via auto-conversion.
+        /// Uppercase includes alpha, lowercase excludes it. <c>%</c> suffix = percent mode:
+        /// <list type="bullet">
+        /// <item><c>null</c> or <c>""</c> — Default (known name or <c>#aarrggbb</c>)</item>
+        /// <item><c>"X"</c> — XAML hex with alpha: <c>#AARRGGBB</c></item>
+        /// <item><c>"x"</c> — Hex without alpha: <c>#RRGGBB</c></item>
+        /// <item><c>"H"</c> — HTML hex with alpha: <c>#RRGGBBAA</c></item>
+        /// <item><c>"R"</c> — CSS rgba absolute: <c>rgba(r, g, b, a)</c></item>
+        /// <item><c>"r"</c> — CSS rgb absolute: <c>rgb(r, g, b)</c></item>
+        /// <item><c>"R%"</c> — CSS rgba percent: <c>rgba(r%, g%, b%, a%)</c></item>
+        /// <item><c>"r%"</c> — CSS rgb percent: <c>rgb(r%, g%, b%)</c></item>
+        /// <item><c>"L"/"l"/"L%"/"l%"</c> — CSS hsl/hsla (auto-converts to HSL)</item>
+        /// <item><c>"V"/"v"/"V%"/"v%"</c> — CSS hsv/hsva (auto-converts to HSV)</item>
+        /// </list>
+        /// <para><c>"C"</c> and <c>"A"</c> are reserved for future complex format strings.</para>
+        /// </param>
+        /// <param name="formatProvider">Ignored. Color formatting is culture-invariant.</param>
+        /// <returns>The formatted string representation.</returns>
+        /// <exception cref="FormatException">Thrown when <paramref name="format"/> is not recognized.</exception>
+        public string ToString(string? format, IFormatProvider? formatProvider)
+        {
+            if (string.IsNullOrEmpty(format))
+            {
+                return ToString();
+            }
+
+            return format switch
+            {
+                "X" => $"#{A:X2}{R:X2}{G:X2}{B:X2}",
+                "x" => $"#{R:X2}{G:X2}{B:X2}",
+                "H" => $"#{R:X2}{G:X2}{B:X2}{A:X2}",
+
+                "R" => FormatRgbCss(),
+                "r" => FormatRgbCss(includeAlpha: false),
+                "R%" => FormatRgbPercentCss(),
+                "r%" => FormatRgbPercentCss(includeAlpha: false),
+
+                "L" or "l" or "L%" or "l%" => ToHsl().ToString(format, formatProvider),
+                "V" or "v" or "V%" or "v%" => ToHsv().ToString(format, formatProvider),
+
+                _ => throw new FormatException($"Format string '{format}' is not supported.")
+            };
+        }
+
+        /// <summary>
+        /// Formats the color as a CSS rgb() or rgba() string using absolute RGB components and fractional alpha.
+        /// </summary>
+        private string FormatRgbCss(bool includeAlpha = true)
+        {
+            if (includeAlpha)
+            {
+                return string.Format(
+                    CultureInfo.InvariantCulture,
+                    "rgba({0}, {1}, {2}, {3:F2})",
+                    R,
+                    G,
+                    B,
+                    A * byteToDouble);
+            }
+
+            return string.Format(CultureInfo.InvariantCulture, "rgb({0}, {1}, {2})", R, G, B);
+        }
+
+        /// <summary>
+        /// Formats the color as a CSS rgb() or rgba() string with all components as percentages.
+        /// </summary>
+        private string FormatRgbPercentCss(bool includeAlpha = true)
+        {
+            int rPct = (int)Math.Round(R * byteToDouble * 100.0);
+            int gPct = (int)Math.Round(G * byteToDouble * 100.0);
+            int bPct = (int)Math.Round(B * byteToDouble * 100.0);
+
+            if (includeAlpha)
+            {
+                int aPct = (int)Math.Round(A * byteToDouble * 100.0);
+                return string.Format(
+                    CultureInfo.InvariantCulture,
+                    "rgba({0}%, {1}%, {2}%, {3}%)",
+                    rPct,
+                    gPct,
+                    bPct,
+                    aPct);
+            }
+
+            return string.Format(CultureInfo.InvariantCulture, "rgb({0}%, {1}%, {2}%)", rPct, gPct, bPct);
+        }
+
         /// <summary>
         /// Returns the integer representation of the color.
         /// </summary>
diff --git a/src/Avalonia.Base/Media/HslColor.cs b/src/Avalonia.Base/Media/HslColor.cs
index 02176d65d7..2a09575d69 100644
--- a/src/Avalonia.Base/Media/HslColor.cs
+++ b/src/Avalonia.Base/Media/HslColor.cs
@@ -17,7 +17,7 @@ namespace Avalonia.Media
 #if !BUILDTASK
     public
 #endif
-    readonly struct HslColor : IEquatable<HslColor>
+    readonly struct HslColor : IEquatable<HslColor>, IFormattable
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="HslColor"/> struct.
@@ -177,6 +177,99 @@ namespace Avalonia.Media
             return HslColor.ToHsv(H, S, L, A);
         }
 
+        /// <summary>
+        /// Returns a formatted string representation of the HSL color.
+        /// </summary>
+        /// <param name="format">
+        /// The format specifier. All color types support all specifiers via auto-conversion.
+        /// Uppercase includes alpha, lowercase excludes it. <c>%</c> suffix = percent mode.
+        /// <list type="bullet">
+        /// <item><c>null</c> or <c>""</c> — Default (full-precision <c>hsla(h, s, l, a)</c>)</item>
+        /// <item><c>"X"</c> — XAML hex: <c>#AARRGGBB</c></item>
+        /// <item><c>"x"</c> — Hex: <c>#RRGGBB</c></item>
+        /// <item><c>"H"</c> — HTML hex: <c>#RRGGBBAA</c></item>
+        /// <item><c>"R"/"r"/"R%"/"r%"</c> — CSS rgb/rgba (auto-converts to RGB)</item>
+        /// <item><c>"L"</c> — CSS hsla: <c>hsla(h, s%, l%, a)</c></item>
+        /// <item><c>"l"</c> — CSS hsl: <c>hsl(h, s%, l%)</c></item>
+        /// <item><c>"L%"</c> — All percent: <c>hsla(h%, s%, l%, a%)</c></item>
+        /// <item><c>"l%"</c> — All percent: <c>hsl(h%, s%, l%)</c></item>
+        /// <item><c>"V"/"v"/"V%"/"v%"</c> — CSS hsv/hsva (auto-converts to HSV)</item>
+        /// </list>
+        /// <para><c>"C"</c> and <c>"A"</c> are reserved for future complex format strings.</para>
+        /// </param>
+        /// <param name="formatProvider">Ignored. Color formatting is culture-invariant.</param>
+        /// <returns>The formatted string representation.</returns>
+        /// <exception cref="FormatException">Thrown when <paramref name="format"/> is not recognized.</exception>
+        public string ToString(string? format, IFormatProvider? formatProvider)
+        {
+            if (string.IsNullOrEmpty(format))
+            {
+                return ToString();
+            }
+
+            return format switch
+            {
+                "X" or "x" or "H" or "R" or "r" or "R%" or "r%" => ToRgb().ToString(format, formatProvider),
+
+                "L" => FormatHslCss(),
+                "l" => FormatHslCss(includeAlpha: false),
+                "L%" => FormatHslPercentCss(),
+                "l%" => FormatHslPercentCss(includeAlpha: false),
+
+                "V" or "v" or "V%" or "v%" => ToHsv().ToString(format, formatProvider),
+
+                _ => throw new FormatException($"Format string '{format}' is not supported.")
+            };
+        }
+
+        /// <summary>
+        /// Formats the color as a CSS hsl() or hsla() string using degrees, percent saturation/lightness,
+        /// and fractional alpha.
+        /// </summary>
+        private string FormatHslCss(bool includeAlpha = true)
+        {
+            int hDeg = (int)Math.Round(H);
+            int sPct = (int)Math.Round(S * 100.0);
+            int lPct = (int)Math.Round(L * 100.0);
+
+            if (includeAlpha)
+            {
+                return string.Format(
+                    CultureInfo.InvariantCulture,
+                    "hsla({0}, {1}%, {2}%, {3:F2})",
+                    hDeg,
+                    sPct,
+                    lPct,
+                    A);
+            }
+
+            return string.Format(CultureInfo.InvariantCulture, "hsl({0}, {1}%, {2}%)", hDeg, sPct, lPct);
+        }
+
+        /// <summary>
+        /// Formats the color as a CSS hsl() or hsla() string with all components as percentages.
+        /// </summary>
+        private string FormatHslPercentCss(bool includeAlpha = true)
+        {
+            int hPct = (int)Math.Round(H / 360.0 * 100.0);
+            int sPct = (int)Math.Round(S * 100.0);
+            int lPct = (int)Math.Round(L * 100.0);
+
+            if (includeAlpha)
+            {
+                int aPct = (int)Math.Round(A * 100.0);
+                return string.Format(
+                    CultureInfo.InvariantCulture,
+                    "hsla({0}%, {1}%, {2}%, {3}%)",
+                    hPct,
+                    sPct,
+                    lPct,
+                    aPct);
+            }
+
+            return string.Format(CultureInfo.InvariantCulture, "hsl({0}%, {1}%, {2}%)", hPct, sPct, lPct);
+        }
+
         /// <inheritdoc/>
         public override string ToString()
         {
@@ -193,7 +286,7 @@ namespace Avalonia.Media
             // hsla(230, 1.0, 0.5, 1.0)
             //
 
-            sb.Append("hsva(");
+            sb.Append("hsla(");
             sb.Append(H.ToString(CultureInfo.InvariantCulture));
             sb.Append(", ");
             sb.Append(S.ToString(CultureInfo.InvariantCulture));
diff --git a/src/Avalonia.Base/Media/HsvColor.cs b/src/Avalonia.Base/Media/HsvColor.cs
index 03949d32aa..7ff180c8c5 100644
--- a/src/Avalonia.Base/Media/HsvColor.cs
+++ b/src/Avalonia.Base/Media/HsvColor.cs
@@ -17,7 +17,7 @@ namespace Avalonia.Media
 #if !BUILDTASK
     public
 #endif
-    readonly struct HsvColor : IEquatable<HsvColor>
+    readonly struct HsvColor : IEquatable<HsvColor>, IFormattable
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="HsvColor"/> struct.
@@ -207,6 +207,99 @@ namespace Avalonia.Media
             return HsvColor.ToHsl(H, S, V, A);
         }
 
+        /// <summary>
+        /// Returns a formatted string representation of the HSV color.
+        /// </summary>
+        /// <param name="format">
+        /// The format specifier. All color types support all specifiers via auto-conversion.
+        /// Uppercase includes alpha, lowercase excludes it. <c>%</c> suffix = percent mode.
+        /// <list type="bullet">
+        /// <item><c>null</c> or <c>""</c> — Default (full-precision <c>hsva(h, s, v, a)</c>)</item>
+        /// <item><c>"X"</c> — XAML hex: <c>#AARRGGBB</c></item>
+        /// <item><c>"x"</c> — Hex: <c>#RRGGBB</c></item>
+        /// <item><c>"H"</c> — HTML hex: <c>#RRGGBBAA</c></item>
+        /// <item><c>"R"/"r"/"R%"/"r%"</c> — CSS rgb/rgba (auto-converts to RGB)</item>
+        /// <item><c>"L"/"l"/"L%"/"l%"</c> — CSS hsl/hsla (auto-converts to HSL)</item>
+        /// <item><c>"V"</c> — CSS hsva: <c>hsva(h, s%, v%, a)</c></item>
+        /// <item><c>"v"</c> — CSS hsv: <c>hsv(h, s%, v%)</c></item>
+        /// <item><c>"V%"</c> — All percent: <c>hsva(h%, s%, v%, a%)</c></item>
+        /// <item><c>"v%"</c> — All percent: <c>hsv(h%, s%, v%)</c></item>
+        /// </list>
+        /// <para><c>"C"</c> and <c>"A"</c> are reserved for future complex format strings.</para>
+        /// </param>
+        /// <param name="formatProvider">Ignored. Color formatting is culture-invariant.</param>
+        /// <returns>The formatted string representation.</returns>
+        /// <exception cref="FormatException">Thrown when <paramref name="format"/> is not recognized.</exception>
+        public string ToString(string? format, IFormatProvider? formatProvider)
+        {
+            if (string.IsNullOrEmpty(format))
+            {
+                return ToString();
+            }
+
+            return format switch
+            {
+                "X" or "x" or "H" or "R" or "r" or "R%" or "r%" => ToRgb().ToString(format, formatProvider),
+
+                "L" or "l" or "L%" or "l%" => ToHsl().ToString(format, formatProvider),
+
+                "V" => FormatHsvCss(),
+                "v" => FormatHsvCss(includeAlpha: false),
+                "V%" => FormatHsvPercentCss(),
+                "v%" => FormatHsvPercentCss(includeAlpha: false),
+
+                _ => throw new FormatException($"Format string '{format}' is not supported.")
+            };
+        }
+
+        /// <summary>
+        /// Formats the color as a CSS hsv() or hsva() string using degrees, percent saturation/value,
+        /// and fractional alpha.
+        /// </summary>
+        private string FormatHsvCss(bool includeAlpha = true)
+        {
+            int hDeg = (int)Math.Round(H);
+            int sPct = (int)Math.Round(S * 100.0);
+            int vPct = (int)Math.Round(V * 100.0);
+
+            if (includeAlpha)
+            {
+                return string.Format(
+                    CultureInfo.InvariantCulture,
+                    "hsva({0}, {1}%, {2}%, {3:F2})",
+                    hDeg,
+                    sPct,
+                    vPct,
+                    A);
+            }
+
+            return string.Format(CultureInfo.InvariantCulture, "hsv({0}, {1}%, {2}%)", hDeg, sPct, vPct);
+        }
+
+        /// <summary>
+        /// Formats the color as a CSS hsv() or hsva() string with all components as percentages.
+        /// </summary>
+        private string FormatHsvPercentCss(bool includeAlpha = true)
+        {
+            int hPct = (int)Math.Round(H / 360.0 * 100.0);
+            int sPct = (int)Math.Round(S * 100.0);
+            int vPct = (int)Math.Round(V * 100.0);
+
+            if (includeAlpha)
+            {
+                int aPct = (int)Math.Round(A * 100.0);
+                return string.Format(
+                    CultureInfo.InvariantCulture,
+                    "hsva({0}%, {1}%, {2}%, {3}%)",
+                    hPct,
+                    sPct,
+                    vPct,
+                    aPct);
+            }
+
+            return string.Format(CultureInfo.InvariantCulture, "hsv({0}%, {1}%, {2}%)", hPct, sPct, vPct);
+        }
+
         /// <inheritdoc/>
         public override string ToString()
         {
diff --git a/tests/Avalonia.Base.UnitTests/Media/ColorTests.cs b/tests/Avalonia.Base.UnitTests/Media/ColorTests.cs
index 52680eb59b..4b48a728a4 100644
--- a/tests/Avalonia.Base.UnitTests/Media/ColorTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Media/ColorTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Globalization;
 using Avalonia.Media;
 using Xunit;
 
@@ -364,5 +365,415 @@ namespace Avalonia.Base.UnitTests.Media
                 Assert.Equal(convertedHsl, dataPoint.Item2);
             }
         }
+        // =====================================================================
+        // IFormattable unified format specifier tests
+        //
+        // All three color types (Color, HslColor, HsvColor) support ALL
+        // format specifiers. Cross-model formats auto-convert.
+        //
+        // Convention:
+        //   Uppercase = include alpha, a-suffixed prefix (rgba, hsla, hsva)
+        //   Lowercase = exclude alpha, plain prefix (rgb, hsl, hsv)
+        //   "%" suffix = percent mode
+        // =====================================================================
+
+        [Fact]
+        public void Color_ToString_Default_Returns_KnownName()
+        {
+            var red = new Color(0xFF, 0xFF, 0x00, 0x00);
+
+            Assert.Equal("Red", red.ToString());
+        }
+
+        [Fact]
+        public void Color_ToString_Default_Returns_Hex_For_Unknown()
+        {
+            var color = new Color(0x40, 0xFF, 0x88, 0x44);
+
+            Assert.Equal("#40ff8844", color.ToString());
+        }
+
+        [Fact]
+        public void Color_ToString_Null_Format_Matches_Default()
+        {
+            var color = new Color(0x40, 0xFF, 0x88, 0x44);
+
+            Assert.Equal(color.ToString(), color.ToString(null, null));
+        }
+
+        [Fact]
+        public void Color_ToString_Empty_Format_Matches_Default()
+        {
+            var color = new Color(0x40, 0xFF, 0x88, 0x44);
+
+            Assert.Equal(color.ToString(), color.ToString("", null));
+        }
+
+        [Fact]
+        public void HslColor_ToString_Null_Format_Matches_Default()
+        {
+            var color = new HslColor(0.8, 200, 0.6, 0.4);
+
+            Assert.Equal(color.ToString(), color.ToString(null, null));
+        }
+
+        [Fact]
+        public void HsvColor_ToString_Null_Format_Matches_Default()
+        {
+            var color = new HsvColor(0.8, 200, 0.6, 0.4);
+
+            Assert.Equal(color.ToString(), color.ToString(null, null));
+        }
+
+        [Theory]
+        [InlineData(0xFF, 0xFF, 0x88, 0x44, "#FFFF8844")]
+        [InlineData(0x40, 0xFF, 0x88, 0x44, "#40FF8844")]
+        [InlineData(0xFF, 0x00, 0x00, 0x00, "#FF000000")]
+        [InlineData(0x00, 0x00, 0x00, 0x00, "#00000000")]
+        public void Color_ToString_X_Returns_Xaml_Hex_With_Alpha(byte a, byte r, byte g, byte b, string expected)
+        {
+            var color = new Color(a, r, g, b);
+
+            Assert.Equal(expected, color.ToString("X", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(0xFF, 0xFF, 0x88, 0x44, "#FF8844")]
+        [InlineData(0x40, 0xFF, 0x88, 0x44, "#FF8844")]
+        [InlineData(0x00, 0x00, 0x00, 0x00, "#000000")]
+        public void Color_ToString_x_Returns_Hex_Without_Alpha(byte a, byte r, byte g, byte b, string expected)
+        {
+            var color = new Color(a, r, g, b);
+
+            Assert.Equal(expected, color.ToString("x", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(0xFF, 0xFF, 0x88, 0x44, "#FF8844FF")]
+        [InlineData(0x40, 0xFF, 0x88, 0x44, "#FF884440")]
+        [InlineData(0x00, 0x00, 0x00, 0x00, "#00000000")]
+        public void Color_ToString_H_Returns_Html_Hex_With_Alpha(byte a, byte r, byte g, byte b, string expected)
+        {
+            var color = new Color(a, r, g, b);
+
+            Assert.Equal(expected, color.ToString("H", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void HslColor_ToString_X_Converts_To_Rgb_Hex()
+        {
+            // Pure red: HSL(0, 1, 0.5) = RGB(255, 0, 0)
+            var hsl = new HslColor(1.0, 0, 1.0, 0.5);
+
+            Assert.Equal("#FFFF0000", hsl.ToString("X", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void HslColor_ToString_x_Converts_To_Rgb_Hex()
+        {
+            var hsl = new HslColor(1.0, 0, 1.0, 0.5);
+
+            Assert.Equal("#FF0000", hsl.ToString("x", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void HsvColor_ToString_X_Converts_To_Rgb_Hex()
+        {
+            // Pure red: HSV(0, 1, 1) = RGB(255, 0, 0)
+            var hsv = new HsvColor(1.0, 0, 1.0, 1.0);
+
+            Assert.Equal("#FFFF0000", hsv.ToString("X", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void HsvColor_ToString_x_Converts_To_Rgb_Hex()
+        {
+            var hsv = new HsvColor(1.0, 0, 1.0, 1.0);
+
+            Assert.Equal("#FF0000", hsv.ToString("x", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(0xFF, 0xFF, 0x88, 0x44, "rgba(255, 136, 68, 1.00)")]
+        [InlineData(0x80, 0xFF, 0x88, 0x44, "rgba(255, 136, 68, 0.50)")]
+        [InlineData(0x00, 0x00, 0x00, 0x00, "rgba(0, 0, 0, 0.00)")]
+        public void Color_ToString_R_Returns_Rgba_With_Alpha(byte a, byte r, byte g, byte b, string expected)
+        {
+            var color = new Color(a, r, g, b);
+
+            Assert.Equal(expected, color.ToString("R", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(0xFF, 0xFF, 0x88, 0x44, "rgb(255, 136, 68)")]
+        [InlineData(0x80, 0xFF, 0x88, 0x44, "rgb(255, 136, 68)")]
+        [InlineData(0xFF, 0x00, 0x00, 0x00, "rgb(0, 0, 0)")]
+        public void Color_ToString_r_Returns_Rgb_Without_Alpha(byte a, byte r, byte g, byte b, string expected)
+        {
+            var color = new Color(a, r, g, b);
+
+            Assert.Equal(expected, color.ToString("r", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void HslColor_ToString_R_Converts_To_Rgba()
+        {
+            // Pure blue: HSL(240, 1, 0.5) = RGB(0, 0, 255)
+            var hsl = new HslColor(1.0, 240, 1.0, 0.5);
+
+            Assert.Equal("rgba(0, 0, 255, 1.00)", hsl.ToString("R", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void HsvColor_ToString_r_Converts_To_Rgb()
+        {
+            // Pure red: HSV(0, 1, 1) = RGB(255, 0, 0)
+            var hsv = new HsvColor(1.0, 0, 1.0, 1.0);
+
+            Assert.Equal("rgb(255, 0, 0)", hsv.ToString("r", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(0xFF, 0xFF, 0x80, 0x00, "rgba(100%, 50%, 0%, 100%)")]
+        [InlineData(0x80, 0xFF, 0x80, 0x00, "rgba(100%, 50%, 0%, 50%)")]
+        [InlineData(0x00, 0x00, 0x00, 0x00, "rgba(0%, 0%, 0%, 0%)")]
+        public void Color_ToString_RPct_Returns_Rgba_Percent(byte a, byte r, byte g, byte b, string expected)
+        {
+            var color = new Color(a, r, g, b);
+
+            Assert.Equal(expected, color.ToString("R%", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(0xFF, 0xFF, 0x80, 0x00, "rgb(100%, 50%, 0%)")]
+        [InlineData(0x80, 0xFF, 0x80, 0x00, "rgb(100%, 50%, 0%)")]
+        [InlineData(0xFF, 0x00, 0x00, 0x00, "rgb(0%, 0%, 0%)")]
+        public void Color_ToString_rPct_Returns_Rgb_Percent(byte a, byte r, byte g, byte b, string expected)
+        {
+            var color = new Color(a, r, g, b);
+
+            Assert.Equal(expected, color.ToString("r%", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void HslColor_ToString_RPct_Converts_To_Rgba_Percent()
+        {
+            // Pure red: HSL(0, 1, 0.5) = RGB(255, 0, 0)
+            var hsl = new HslColor(1.0, 0, 1.0, 0.5);
+
+            Assert.Equal("rgba(100%, 0%, 0%, 100%)", hsl.ToString("R%", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(1.0, 180, 0.5, 0.5, "hsla(180, 50%, 50%, 1.00)")]
+        [InlineData(0.5, 240, 0.8, 0.2, "hsla(240, 80%, 20%, 0.50)")]
+        [InlineData(0.0, 0, 0.0, 0.0, "hsla(0, 0%, 0%, 0.00)")]
+        public void HslColor_ToString_L_Returns_Hsla_With_Alpha(double a, double h, double s, double l, string expected)
+        {
+            var color = new HslColor(a, h, s, l);
+
+            Assert.Equal(expected, color.ToString("L", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(1.0, 180, 0.5, 0.5, "hsl(180, 50%, 50%)")]
+        [InlineData(0.5, 240, 0.8, 0.2, "hsl(240, 80%, 20%)")]
+        [InlineData(0.0, 0, 0.0, 0.0, "hsl(0, 0%, 0%)")]
+        public void HslColor_ToString_l_Returns_Hsl_Without_Alpha(double a, double h, double s, double l, string expected)
+        {
+            var color = new HslColor(a, h, s, l);
+
+            Assert.Equal(expected, color.ToString("l", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void Color_ToString_L_Converts_To_Hsla()
+        {
+            // Pure red: RGB(255, 0, 0) = HSL(0, 100%, 50%)
+            var color = new Color(0xFF, 0xFF, 0x00, 0x00);
+
+            Assert.Equal("hsla(0, 100%, 50%, 1.00)", color.ToString("L", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void Color_ToString_l_Converts_To_Hsl()
+        {
+            var color = new Color(0xFF, 0xFF, 0x00, 0x00);
+
+            Assert.Equal("hsl(0, 100%, 50%)", color.ToString("l", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void HsvColor_ToString_L_Converts_To_Hsla()
+        {
+            // Pure red: HSV(0, 1, 1) = HSL(0, 100%, 50%)
+            var hsv = new HsvColor(1.0, 0, 1.0, 1.0);
+
+            Assert.Equal("hsla(0, 100%, 50%, 1.00)", hsv.ToString("L", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(1.0, 180, 0.5, 0.5, "hsla(50%, 50%, 50%, 100%)")]
+        [InlineData(0.5, 90, 1.0, 1.0, "hsla(25%, 100%, 100%, 50%)")]
+        [InlineData(1.0, 0, 0.0, 0.0, "hsla(0%, 0%, 0%, 100%)")]
+        public void HslColor_ToString_LPct_Returns_Hsla_All_Percent(double a, double h, double s, double l, string expected)
+        {
+            var color = new HslColor(a, h, s, l);
+
+            Assert.Equal(expected, color.ToString("L%", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(1.0, 180, 0.5, 0.5, "hsl(50%, 50%, 50%)")]
+        [InlineData(0.5, 90, 1.0, 1.0, "hsl(25%, 100%, 100%)")]
+        [InlineData(1.0, 0, 0.0, 0.0, "hsl(0%, 0%, 0%)")]
+        public void HslColor_ToString_lPct_Returns_Hsl_All_Percent(double a, double h, double s, double l, string expected)
+        {
+            var color = new HslColor(a, h, s, l);
+
+            Assert.Equal(expected, color.ToString("l%", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(1.0, 180, 0.5, 0.5, "hsva(180, 50%, 50%, 1.00)")]
+        [InlineData(0.5, 240, 0.8, 0.2, "hsva(240, 80%, 20%, 0.50)")]
+        [InlineData(0.0, 0, 0.0, 0.0, "hsva(0, 0%, 0%, 0.00)")]
+        public void HsvColor_ToString_V_Returns_Hsva_With_Alpha(double a, double h, double s, double v, string expected)
+        {
+            var color = new HsvColor(a, h, s, v);
+
+            Assert.Equal(expected, color.ToString("V", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(1.0, 180, 0.5, 0.5, "hsv(180, 50%, 50%)")]
+        [InlineData(0.5, 240, 0.8, 0.2, "hsv(240, 80%, 20%)")]
+        [InlineData(0.0, 0, 0.0, 0.0, "hsv(0, 0%, 0%)")]
+        public void HsvColor_ToString_v_Returns_Hsv_Without_Alpha(double a, double h, double s, double v, string expected)
+        {
+            var color = new HsvColor(a, h, s, v);
+
+            Assert.Equal(expected, color.ToString("v", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void Color_ToString_V_Converts_To_Hsva()
+        {
+            // Pure red: RGB(255, 0, 0) = HSV(0, 100%, 100%)
+            var color = new Color(0xFF, 0xFF, 0x00, 0x00);
+
+            Assert.Equal("hsva(0, 100%, 100%, 1.00)", color.ToString("V", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void HslColor_ToString_V_Converts_To_Hsva()
+        {
+            // Pure red: HSL(0, 1, 0.5) = HSV(0, 100%, 100%)
+            var hsl = new HslColor(1.0, 0, 1.0, 0.5);
+
+            Assert.Equal("hsva(0, 100%, 100%, 1.00)", hsl.ToString("V", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(1.0, 180, 0.5, 0.5, "hsva(50%, 50%, 50%, 100%)")]
+        [InlineData(0.5, 90, 1.0, 1.0, "hsva(25%, 100%, 100%, 50%)")]
+        [InlineData(1.0, 0, 0.0, 0.0, "hsva(0%, 0%, 0%, 100%)")]
+        public void HsvColor_ToString_VPct_Returns_Hsva_All_Percent(double a, double h, double s, double v, string expected)
+        {
+            var color = new HsvColor(a, h, s, v);
+
+            Assert.Equal(expected, color.ToString("V%", CultureInfo.InvariantCulture));
+        }
+
+        [Theory]
+        [InlineData(1.0, 180, 0.5, 0.5, "hsv(50%, 50%, 50%)")]
+        [InlineData(0.5, 90, 1.0, 1.0, "hsv(25%, 100%, 100%)")]
+        [InlineData(1.0, 0, 0.0, 0.0, "hsv(0%, 0%, 0%)")]
+        public void HsvColor_ToString_vPct_Returns_Hsv_All_Percent(double a, double h, double s, double v, string expected)
+        {
+            var color = new HsvColor(a, h, s, v);
+
+            Assert.Equal(expected, color.ToString("v%", CultureInfo.InvariantCulture));
+        }
+
+        [Fact]
+        public void Color_ToString_Invalid_Format_Throws()
+        {
+            var color = new Color(0xFF, 0xFF, 0x00, 0x00);
+
+            Assert.Throws<FormatException>(() => color.ToString("Z", null));
+        }
+
+        [Fact]
+        public void HslColor_ToString_Invalid_Format_Throws()
+        {
+            var color = new HslColor(1.0, 0, 0, 0);
+
+            Assert.Throws<FormatException>(() => color.ToString("Z", null));
+        }
+
+        [Fact]
+        public void HsvColor_ToString_Invalid_Format_Throws()
+        {
+            var color = new HsvColor(1.0, 0, 0, 0);
+
+            Assert.Throws<FormatException>(() => color.ToString("Z", null));
+        }
+
+        [Theory]
+        [InlineData("C")]
+        [InlineData("c")]
+        [InlineData("A")]
+        [InlineData("a")]
+        [InlineData("P")]
+        [InlineData("h")]
+        public void Color_ToString_Reserved_And_Removed_Specifiers_Throw(string format)
+        {
+            var color = new Color(0xFF, 0xFF, 0x00, 0x00);
+
+            Assert.Throws<FormatException>(() => color.ToString(format, null));
+        }
+
+        [Theory]
+        [InlineData("C")]
+        [InlineData("c")]
+        public void HslColor_ToString_Reserved_C_Throws(string format)
+        {
+            var color = new HslColor(1.0, 0, 1.0, 0.5);
+
+            Assert.Throws<FormatException>(() => color.ToString(format, null));
+        }
+
+        [Theory]
+        [InlineData("C")]
+        [InlineData("c")]
+        public void HsvColor_ToString_Reserved_C_Throws(string format)
+        {
+            var color = new HsvColor(1.0, 0, 1.0, 1.0);
+
+            Assert.Throws<FormatException>(() => color.ToString(format, null));
+        }
+
+        [Fact]
+        public void Color_ToString_IFormatProvider_Is_Ignored()
+        {
+            var color = new Color(0x80, 0xFF, 0x88, 0x44);
+            var french = CultureInfo.GetCultureInfo("fr-FR");
+
+            Assert.Equal(
+                color.ToString("R", CultureInfo.InvariantCulture),
+                color.ToString("R", french));
+        }
+
+        [Fact]
+        public void HslColor_ToString_IFormatProvider_Is_Ignored()
+        {
+            var color = new HslColor(0.5, 180, 0.5, 0.5);
+            var french = CultureInfo.GetCultureInfo("fr-FR");
+
+            Assert.Equal(
+                color.ToString("L", CultureInfo.InvariantCulture),
+                color.ToString("L", french));
+        }
     }
 }

From 11376dd1c2886fd384d6f3351a61d498a5167566 Mon Sep 17 00:00:00 2001
From: Tim <47110241+timunie@users.noreply.github.com>
Date: Thu, 20 Aug 2026 08:07:24 +0000
Subject: [PATCH 182/196] Add week numbers support to Calendar (#21981)

* Proposal: Add week numbers to Calendar

* FluentTheme for adding CW

* Add sample to ControlCatalog about week numbers

* workaround for XAML not accepting empty strings

* SimpleTheme

* refractor TemplateParts of Calendar

* ensure Calendar updates and improve xml comment

* undo whitespace formatting

* Add some test to CalendarTests

* adress self review

* Introduce a method to show / hide the week numbers panel

since it is not part of the MonthGrid, it can leak into the year view. We solved this by updating IsVisible in code behind just like other template parts.

Moved the header into the panel to show / hide it together with the entire Grid.

* fix typo and redundant cast

* Crush the last moths

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../Pages/CalendarDatePickerPage.xaml         |   3 +
 .../ControlCatalog/Pages/CalendarPage.xaml    |  11 +
 src/Avalonia.Controls/Calendar/Calendar.cs    |  41 ++++
 .../Calendar/CalendarItem.cs                  |  89 +++++++-
 .../Calendar/DateTimeHelper.cs                |  25 +++
 .../CalendarDatePicker.Properties.cs          |  27 +++
 .../Accents/FluentControlResources.xaml       |   2 +
 .../Controls/CalendarDatePicker.xaml          |   4 +-
 .../Controls/CalendarItem.xaml                |  72 ++++++-
 .../Strings/InvariantResources.xaml           |   2 +
 .../Controls/CalendarDatePicker.xaml          |   4 +-
 .../Controls/CalendarItem.xaml                | 149 +++++++++-----
 .../CalendarTests.cs                          | 193 +++++++++++++++++-
 13 files changed, 546 insertions(+), 76 deletions(-)

diff --git a/samples/ControlCatalog/Pages/CalendarDatePickerPage.xaml b/samples/ControlCatalog/Pages/CalendarDatePickerPage.xaml
index 769dbc0dac..c00af6c801 100644
--- a/samples/ControlCatalog/Pages/CalendarDatePickerPage.xaml
+++ b/samples/ControlCatalog/Pages/CalendarDatePickerPage.xaml
@@ -49,6 +49,9 @@
 
         <TextBlock Text="Validation Example"/>
         <CalendarDatePicker SelectedDate="{CompiledBinding ValidatedDateExample, Mode=TwoWay}"/>
+        
+        <TextBlock Text="WeekNumbers example"/>
+        <CalendarDatePicker IsWeekNumberVisible="True" />
       </StackPanel>
 
     </StackPanel>
diff --git a/samples/ControlCatalog/Pages/CalendarPage.xaml b/samples/ControlCatalog/Pages/CalendarPage.xaml
index 99727e9124..44ab767dea 100644
--- a/samples/ControlCatalog/Pages/CalendarPage.xaml
+++ b/samples/ControlCatalog/Pages/CalendarPage.xaml
@@ -48,6 +48,17 @@
         <Calendar Name="BlackoutDatesCalendar"
                   SelectionMode="SingleDate" />
       </StackPanel>
+      <StackPanel>
+        <TextBlock Text="WeekNumbers (ISO-Week)" />
+        <Calendar Name="WeekNumbers"
+                  WeekNumberRule="FirstFourDayWeek"
+                  FirstDayOfWeek="Monday"
+                  IsWeekNumberVisible="True">
+          <Calendar.Resources>
+            <x:String x:Key="StringCalendarWeekNumberHeader">#</x:String>
+          </Calendar.Resources>
+        </Calendar>
+      </StackPanel>
     </WrapPanel>
   </StackPanel>
 </ContentPage>
diff --git a/src/Avalonia.Controls/Calendar/Calendar.cs b/src/Avalonia.Controls/Calendar/Calendar.cs
index 7062a9af81..76d7220ee6 100644
--- a/src/Avalonia.Controls/Calendar/Calendar.cs
+++ b/src/Avalonia.Controls/Calendar/Calendar.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
+using System.Globalization;
 using Avalonia.Automation.Peers;
 using Avalonia.Controls.Metadata;
 using Avalonia.Controls.Primitives;
@@ -353,6 +354,43 @@ namespace Avalonia.Controls
             set => SetValue(HeaderBackgroundProperty, value);
         }
 
+        /// <summary>
+        /// Defines the <see cref="IsWeekNumberVisible"/> property.
+        /// </summary>
+        public static readonly StyledProperty<bool> IsWeekNumberVisibleProperty =
+            AvaloniaProperty.Register<Calendar, bool>(nameof(IsWeekNumberVisible));
+
+        /// <summary>
+        /// Gets or sets a value indicating whether week numbers are shown in the month view.
+        /// </summary>
+        public bool IsWeekNumberVisible
+        {
+            get => GetValue(IsWeekNumberVisibleProperty);
+            set => SetValue(IsWeekNumberVisibleProperty, value);
+        }
+
+        /// <summary>
+        /// Defines the <see cref="WeekNumberRule"/> property.
+        /// </summary>
+        public static readonly StyledProperty<CalendarWeekRule> WeekNumberRuleProperty =
+            AvaloniaProperty.Register<Calendar, CalendarWeekRule>(
+                nameof(WeekNumberRule),
+                defaultValue: DateTimeHelper.GetCurrentDateFormat().CalendarWeekRule);
+
+        /// <summary>
+        /// Gets or sets the rule used to determine the first week of the year for week number display.
+        /// The default is taken from the current culture.
+        /// </summary>
+        /// <remarks>
+        /// Use <c>WeekNumberRule</c> = <see cref="CalendarWeekRule.FirstFourDayWeek"/> in combination with <c>FirstDayOfWeek</c> = <see cref="DayOfWeek.Monday"/>
+        /// for ISO 8601 week numbering. (see also: <see cref="ISOWeek"/>)
+        /// </remarks>
+        public CalendarWeekRule WeekNumberRule
+        {
+            get => GetValue(WeekNumberRuleProperty);
+            set => SetValue(WeekNumberRuleProperty, value);
+        }
+        
         public static readonly StyledProperty<CalendarMode> DisplayModeProperty =
             AvaloniaProperty.Register<Calendar, CalendarMode>(
                 nameof(DisplayMode),
@@ -421,6 +459,7 @@ namespace Avalonia.Controls
                         }
                 }
             }
+            monthControl?.UpdateWeekNumberLabelsVisibility();
             OnDisplayModeChanged(new CalendarModeChangedEventArgs((CalendarMode)e.OldValue, mode));
         }
         private static bool IsValidDisplayMode(CalendarMode mode)
@@ -2209,6 +2248,8 @@ namespace Avalonia.Controls
             DisplayDateProperty.Changed.AddClassHandler<Calendar>((x, e) => x.OnDisplayDateChanged(e));
             DisplayDateStartProperty.Changed.AddClassHandler<Calendar>((x, e) => x.OnDisplayDateStartChanged(e));
             DisplayDateEndProperty.Changed.AddClassHandler<Calendar>((x, e) => x.OnDisplayDateEndChanged(e));
+            IsWeekNumberVisibleProperty.Changed.AddClassHandler<Calendar>((x, _) => x.UpdateMonths());
+            WeekNumberRuleProperty.Changed.AddClassHandler<Calendar>((x, _) => x.UpdateMonths());
             KeyDownEvent.AddClassHandler<Calendar>((x, e) => x.Calendar_KeyDown(e));
             KeyUpEvent.AddClassHandler<Calendar>((x, e) => x.Calendar_KeyUp(e));
         }
diff --git a/src/Avalonia.Controls/Calendar/CalendarItem.cs b/src/Avalonia.Controls/Calendar/CalendarItem.cs
index e33298023f..1e703e8a42 100644
--- a/src/Avalonia.Controls/Calendar/CalendarItem.cs
+++ b/src/Avalonia.Controls/Calendar/CalendarItem.cs
@@ -1,4 +1,4 @@
-// (c) Copyright Microsoft Corporation.
+// (c) Copyright Microsoft Corporation.
 // This source is subject to the Microsoft Public License (Ms-PL).
 // Please see https://go.microsoft.com/fwlink/?LinkID=131993 for details.
 // All other rights reserved.
@@ -19,12 +19,13 @@ namespace Avalonia.Controls.Primitives
     /// Represents the currently displayed month or year on a
     /// <see cref="T:Avalonia.Controls.Calendar" />.
     /// </summary>
-    [TemplatePart(PART_ElementHeaderButton,   typeof(Button))]
-    [TemplatePart(PART_ElementMonthView,      typeof(Grid))]
-    [TemplatePart(PART_ElementNextButton,     typeof(Button))]
-    [TemplatePart(PART_ElementPreviousButton, typeof(Button))]
-    [TemplatePart(PART_ElementYearView,       typeof(Grid))]
-    [PseudoClasses(":calendardisabled")]
+    [TemplatePart(PART_ElementHeaderButton,     typeof(Button))]
+    [TemplatePart(PART_ElementMonthView,        typeof(Grid))]
+    [TemplatePart(PART_ElementNextButton,       typeof(Button))]
+    [TemplatePart(PART_ElementPreviousButton,   typeof(Button))]
+    [TemplatePart(PART_ElementYearView,         typeof(Grid))]
+    [TemplatePart(PART_ElementWeekNumberLabels, typeof(Grid))]
+    [PseudoClasses(":calendardisabled", ":hasweeknumbers")]
     public sealed class CalendarItem : TemplatedControl
     {
         /// <summary>
@@ -37,6 +38,7 @@ namespace Avalonia.Controls.Primitives
         private const string PART_ElementNextButton = "PART_NextButton";
         private const string PART_ElementMonthView = "PART_MonthView";
         private const string PART_ElementYearView = "PART_YearView";
+        private const string PART_ElementWeekNumberLabels = "PART_ElementWeekNumberLabels";
 
         private Button? _headerButton;
         private Button? _nextButton;
@@ -164,6 +166,11 @@ namespace Avalonia.Controls.Primitives
         /// </summary>
         internal Grid? YearView { get; set; }
         
+        /// <summary>
+        /// Gets the Grid that hosts the week number labels when in month mode.
+        /// </summary>
+        private Grid? WeekNumberLabels { get; set; }
+        
         private void PopulateGrids()
         {
             if (MonthView != null)
@@ -210,6 +217,21 @@ namespace Avalonia.Controls.Primitives
                 MonthView.Children.AddRange(children);
             }
 
+            if (WeekNumberLabels != null)
+            {
+                using var children = new PooledList<Control>(Calendar.RowsPerMonth);
+                
+                for (int i = 1; i < Calendar.RowsPerMonth; i++)
+                {
+                    var cell = new ContentControl();
+                    cell.SetValue(Grid.RowProperty, i);
+                    cell.TemplatedParent = this;
+                    children.Add(cell);
+                }
+                
+                WeekNumberLabels.Children.AddRange(children);
+            }
+
             if (YearView != null)
             {
                 var childCount = Calendar.RowsPerYear * Calendar.ColumnsPerYear;
@@ -254,6 +276,7 @@ namespace Avalonia.Controls.Primitives
             NextButton = e.NameScope.Find<Button>(PART_ElementNextButton);
             MonthView = e.NameScope.Find<Grid>(PART_ElementMonthView);
             YearView = e.NameScope.Find<Grid>(PART_ElementYearView);
+            WeekNumberLabels = e.NameScope.Find<Grid>(PART_ElementWeekNumberLabels);
             
             if (Owner != null)
             {
@@ -373,6 +396,7 @@ namespace Avalonia.Controls.Primitives
             {
                 SetDayTitles();
                 SetCalendarDayButtons(_currentMonth);
+                UpdateWeekNumberLabels(_currentMonth);
             }
         }
         private void SetMonthModeHeaderButton()
@@ -589,6 +613,57 @@ namespace Avalonia.Controls.Primitives
             }
         }
 
+        /// <summary>
+        /// Updates the week number labels if <see cref="Calendar.IsWeekNumberVisible"/> is true and the
+        /// <see cref="Calendar.DisplayMode"/> is set to <see cref="CalendarMode.Month"/>.
+        /// </summary>
+        private void UpdateWeekNumberLabels(DateTime firstDayOfMonth)
+        {
+            // first set the pseudo classes
+            bool show = Owner?.IsWeekNumberVisible ?? false;
+            PseudoClasses.Set(":hasweeknumbers", show);
+            
+            // if we don't have a week number labels grid, or it has no children, then we don't need to update
+            if (WeekNumberLabels is null || WeekNumberLabels.Children.Count == 0)
+                return;
+            
+            UpdateWeekNumberLabelsVisibility();
+            
+            int lastMonthToDisplay = PreviousMonthDays(firstDayOfMonth);
+            DateTime firstDateDisplayed = DateTimeHelper.CompareYearMonth(firstDayOfMonth, DateTime.MinValue) > 0
+                ? _calendar.AddDays(firstDayOfMonth, -lastMonthToDisplay)
+                : firstDayOfMonth;
+
+            var rule = Owner?.WeekNumberRule ?? DateTimeHelper.GetCurrentDateFormat().CalendarWeekRule;
+            var firstDayOfWeek = Owner?.FirstDayOfWeek ?? DateTimeHelper.GetCurrentDateFormat().FirstDayOfWeek;
+
+            // We have 6 rows with weeks. The ControlTheme may have added more children to the Grid (Header, Background, ...).
+            // We only want to update the last 6 children of the Grid, which are the week number labels.
+            var startIndex = WeekNumberLabels.Children.Count - (Calendar.RowsPerMonth - 1);
+            for (int i = startIndex; i < WeekNumberLabels.Children.Count; i++)
+            {
+                var daysToAdd = (i - startIndex) * NumberOfDaysPerWeek;
+                DateTime firstDayOfRow = _calendar.AddDays(firstDateDisplayed, daysToAdd);
+
+                var label = WeekNumberLabels.Children[i] as ContentControl;
+                label?.Content = DateTimeHelper.GetWeekOfYear(firstDayOfRow, rule, firstDayOfWeek, _calendar);
+            }
+        }
+
+        /// <summary>
+        /// Updates the visibility of the week number labels based on the <see cref="Calendar.IsWeekNumberVisible"/> property
+        /// and the <see cref="Calendar.DisplayMode"/>.
+        /// </summary>
+        /// <exception cref="NotImplementedException"></exception>
+        internal void UpdateWeekNumberLabelsVisibility()
+        {
+            if (WeekNumberLabels is not null && Owner is not null)
+            {
+                WeekNumberLabels.IsVisible =
+                    Owner.IsWeekNumberVisible && Owner.DisplayMode == CalendarMode.Month;
+            }
+        }
+
         internal void UpdateYearMode()
         {
             if (Owner != null)
diff --git a/src/Avalonia.Controls/Calendar/DateTimeHelper.cs b/src/Avalonia.Controls/Calendar/DateTimeHelper.cs
index 570f05cfe8..f678cb4683 100644
--- a/src/Avalonia.Controls/Calendar/DateTimeHelper.cs
+++ b/src/Avalonia.Controls/Calendar/DateTimeHelper.cs
@@ -131,5 +131,30 @@ namespace Avalonia.Controls
             var format = GetCurrentDateFormat();
             return date.Year.ToString(format);
         }
+
+        /// <summary>
+        /// Gets the week-of-year number for the specified date.
+        /// </summary>
+        /// <param name="date">The date.</param>
+        /// <param name="rule">The rule that defines what constitutes the first week of the year.</param>
+        /// <param name="firstDayOfWeek">The first day of the week.</param>
+        /// <param name="calendar">the calendar to use.</param>
+        /// <returns>The week number that <paramref name="date"/> falls in.</returns>
+        /// <remarks>
+        /// This method fixes an issue where .NET's Calendar.GetWeekOfYear incorrectly returns week 53 for
+        /// late-December dates that ISO 8601 assigns to week 1 of the next year (e.g. 2018-12-31).
+        /// </remarks>
+        public static int GetWeekOfYear(DateTime date, 
+            CalendarWeekRule rule, 
+            DayOfWeek firstDayOfWeek, 
+            System.Globalization.Calendar calendar)
+        {
+            // .NET's Calendar.GetWeekOfYear incorrectly returns week 53 for late-December dates
+            // that ISO 8601 assigns to week 1 of the next year (e.g. 2018-12-31).
+            if (rule == CalendarWeekRule.FirstFourDayWeek && firstDayOfWeek == DayOfWeek.Monday)
+                return ISOWeek.GetWeekOfYear(date);
+
+            return calendar.GetWeekOfYear(date, rule, firstDayOfWeek);
+        }
     }
 }
diff --git a/src/Avalonia.Controls/CalendarDatePicker/CalendarDatePicker.Properties.cs b/src/Avalonia.Controls/CalendarDatePicker/CalendarDatePicker.Properties.cs
index 5209744bb3..f34a6ade89 100644
--- a/src/Avalonia.Controls/CalendarDatePicker/CalendarDatePicker.Properties.cs
+++ b/src/Avalonia.Controls/CalendarDatePicker/CalendarDatePicker.Properties.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Globalization;
 using Avalonia.Controls.Primitives;
 using Avalonia.Data;
 using Avalonia.Data.Converters;
@@ -149,6 +150,18 @@ namespace Avalonia.Controls
         public static readonly StyledProperty<VerticalAlignment> VerticalContentAlignmentProperty =
             ContentControl.VerticalContentAlignmentProperty.AddOwner<CalendarDatePicker>();
 
+        /// <summary>
+        /// Defines the <see cref="IsWeekNumberVisible"/> property.
+        /// </summary>
+        public static readonly StyledProperty<bool> IsWeekNumberVisibleProperty =
+            Calendar.IsWeekNumberVisibleProperty.AddOwner<CalendarDatePicker>();
+
+        /// <summary>
+        /// Defines the <see cref="WeekNumberRule"/> property.
+        /// </summary>
+        public static readonly StyledProperty<CalendarWeekRule> WeekNumberRuleProperty =
+            Calendar.WeekNumberRuleProperty.AddOwner<CalendarDatePicker>();
+
         /// <summary>
         /// Gets a collection of dates that are marked as not selectable.
         /// </summary>
@@ -389,5 +402,19 @@ namespace Avalonia.Controls
             get => GetValue(VerticalContentAlignmentProperty);
             set => SetValue(VerticalContentAlignmentProperty, value);
         }
+
+        /// <inheritdoc cref="Calendar.IsWeekNumberVisible"/>
+        public bool IsWeekNumberVisible
+        {
+            get => GetValue(IsWeekNumberVisibleProperty);
+            set => SetValue(IsWeekNumberVisibleProperty, value);
+        }
+
+        /// <inheritdoc cref="Calendar.WeekNumberRule"/>
+        public CalendarWeekRule WeekNumberRule
+        {
+            get => GetValue(WeekNumberRuleProperty);
+            set => SetValue(WeekNumberRuleProperty, value);
+        }
     }
 }
diff --git a/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml b/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml
index 2248551a95..778ea5b002 100644
--- a/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml
+++ b/src/Avalonia.Themes.Fluent/Accents/FluentControlResources.xaml
@@ -416,6 +416,7 @@
       <StaticResource x:Key="CalendarViewNavigationButtonBorderBrush" ResourceKey="SystemControlTransparentBrush" />
       <x:Double x:Key="CalendarFontSize">20</x:Double>
       <x:Double x:Key="CalendarDayButtonFontSize">12</x:Double>
+      <x:Double x:Key="CalendarWeekNumberFontSize">12</x:Double>
       <FontWeight x:Key="CalendarViewTodayFontWeight">SemiBold</FontWeight>
 
       <!-- Resources for Expander.xaml -->
@@ -1262,6 +1263,7 @@
       <StaticResource x:Key="CalendarViewNavigationButtonBorderBrush" ResourceKey="SystemControlTransparentBrush" />
       <x:Double x:Key="CalendarFontSize">20</x:Double>
       <x:Double x:Key="CalendarDayButtonFontSize">12</x:Double>
+      <x:Double x:Key="CalendarWeekNumberFontSize">12</x:Double>
       <FontWeight x:Key="CalendarViewTodayFontWeight">SemiBold</FontWeight>
 
       <!-- Resources for Expander.xaml -->
diff --git a/src/Avalonia.Themes.Fluent/Controls/CalendarDatePicker.xaml b/src/Avalonia.Themes.Fluent/Controls/CalendarDatePicker.xaml
index 2718733419..dbc36efd85 100644
--- a/src/Avalonia.Themes.Fluent/Controls/CalendarDatePicker.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/CalendarDatePicker.xaml
@@ -133,7 +133,9 @@
                           SelectedDate="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=SelectedDate, Mode=TwoWay}"
                           DisplayDate="{TemplateBinding DisplayDate}"
                           DisplayDateStart="{TemplateBinding DisplayDateStart}"
-                          DisplayDateEnd="{TemplateBinding DisplayDateEnd}" />
+                          DisplayDateEnd="{TemplateBinding DisplayDateEnd}"
+                          IsWeekNumberVisible="{TemplateBinding IsWeekNumberVisible}"
+                          WeekNumberRule="{TemplateBinding WeekNumberRule}" />
               </Popup>
             </Grid>
           </Panel>
diff --git a/src/Avalonia.Themes.Fluent/Controls/CalendarItem.xaml b/src/Avalonia.Themes.Fluent/Controls/CalendarItem.xaml
index ac3ebadbb8..58f8a2b150 100644
--- a/src/Avalonia.Themes.Fluent/Controls/CalendarItem.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/CalendarItem.xaml
@@ -10,7 +10,8 @@
         x:ClassModifier="internal">
   <Design.PreviewWith>
     <Border Padding="20">
-      <Calendar DisplayDate="2000-01-01">
+      <Calendar DisplayDate="2000-01-01" 
+                IsWeekNumberVisible="True">
         <Calendar.BlackoutDates>
           <CalendarDateRange>
             <x:Arguments>
@@ -75,8 +76,14 @@
                  basically...MinWidth of DayItem = 40, 40 * 7 = 280 + margins/padding = ~294
                  Viewport height is set from # of rows displayed (2-8) in Month mode, = ~290 for 6 weeks (+ day names)
                  -->
-          <Grid VerticalAlignment="Stretch" HorizontalAlignment="Stretch" RowDefinitions="40,*" MinWidth="294">
-            <Grid ColumnDefinitions="5*,*,*">
+          <Grid VerticalAlignment="Stretch" 
+                HorizontalAlignment="Stretch" 
+                ColumnDefinitions="Auto, *" 
+                RowDefinitions="40,*" 
+                MinWidth="294"
+                Grid.IsSharedSizeScope="True" >
+            <Grid ColumnDefinitions="5*,*,*"
+                  Grid.ColumnSpan="2">
               <Button Name="PART_HeaderButton"
                       Theme="{StaticResource FluentCalendarButton}"
                       Foreground="{TemplateBinding Foreground}"
@@ -110,17 +117,49 @@
               </Button>
             </Grid>
             <!--Border below is used only for MonthView but it can't be moved inside of Grid because CalendarItem expects it to be empty and it will cause side-effects-->
-            <Border Name="BackgroundLayer" Background="{TemplateBinding BorderBrush}" Margin="0,38,0,0" IsVisible="{Binding #PART_MonthView.IsVisible}" Grid.Row="1" />
-            <Grid Name="PART_MonthView" Grid.Row="1" IsVisible="False" MinHeight="290">
+            <Border Name="BackgroundLayer" 
+                    Background="{TemplateBinding BorderBrush}" 
+                    Margin="0,38,0,0" 
+                    IsVisible="{Binding #PART_MonthView.IsVisible}" 
+                    Grid.Row="1" 
+                    Grid.Column="1" />
+            <!-- The below Grid will be feed by the week numbers -->
+            <Grid Name="PART_ElementWeekNumberLabels"
+                  Grid.Row="1"
+                  Grid.Column="0"
+                  MinWidth="38"
+                  IsVisible="False">
+              <Grid.RowDefinitions>
+                <RowDefinition Height="38" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+              </Grid.RowDefinitions>
+              <!-- Header for the Weeks. -->
+              <ContentControl Name="WeekNumberHeader" 
+                              Grid.Row="0"
+                              Content="{DynamicResource StringCalendarWeekNumberHeader}"
+                              FontSize="{DynamicResource CalendarWeekNumberFontSize}"
+                              VerticalContentAlignment="Center"
+                              HorizontalContentAlignment="Center" />
+            </Grid>
+            <Grid Name="PART_MonthView" 
+                  Grid.Column="1" 
+                  Grid.Row="1" 
+                  IsVisible="False" 
+                  MinHeight="290">
               <Grid.RowDefinitions>
                 <!--This should always be the week day names??-->
                 <RowDefinition Height="38" />
-                <RowDefinition Height="Auto" />
-                <RowDefinition Height="Auto" />
-                <RowDefinition Height="Auto" />
-                <RowDefinition Height="Auto" />
-                <RowDefinition Height="Auto" />
-                <RowDefinition Height="Auto" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
               </Grid.RowDefinitions>
               <Grid.ColumnDefinitions>
                 <ColumnDefinition Width="Auto" />
@@ -136,6 +175,7 @@
                   Background="{TemplateBinding BorderBrush}"
                   MinHeight="290"
                   Grid.Row="1"
+                  Grid.ColumnSpan="2" 
                   IsVisible="False">
               <Grid.RowDefinitions>
                 <RowDefinition Height="*" />
@@ -159,5 +199,15 @@
     <Style Selector="^ /template/ Button:pressed > Path">
       <Setter Property="Stroke" Value="{DynamicResource CalendarViewNavigationButtonForegroundPressed}" />
     </Style>
+    <Style Selector="^:hasweeknumbers">
+      <Setter Property="MinWidth" Value="332" />
+      <Style Selector="^ /template/ Grid#PART_ElementWeekNumberLabels">
+        <Style Selector="^ ContentControl">
+          <Setter Property="FontSize" Value="{DynamicResource CalendarWeekNumberFontSize}" />
+          <Setter Property="HorizontalContentAlignment" Value="Center" />
+          <Setter Property="VerticalContentAlignment" Value="Center" />
+        </Style>
+      </Style>
+    </Style>
   </ControlTheme>
 </ResourceDictionary>
diff --git a/src/Avalonia.Themes.Fluent/Strings/InvariantResources.xaml b/src/Avalonia.Themes.Fluent/Strings/InvariantResources.xaml
index a540e8c119..506dbc3ac6 100644
--- a/src/Avalonia.Themes.Fluent/Strings/InvariantResources.xaml
+++ b/src/Avalonia.Themes.Fluent/Strings/InvariantResources.xaml
@@ -1,6 +1,8 @@
 <ResourceDictionary xmlns="https://github.com/avaloniaui"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                     x:ClassModifier="internal">
+  <!-- Calendar -->
+  <x:String x:Key="StringCalendarWeekNumberHeader"> </x:String> <!-- Just one whitespace to preserve the resource -->
   <!-- DatePicker -->
   <x:String x:Key="StringDatePickerDayText">day</x:String>
   <x:String x:Key="StringDatePickerMonthText">month</x:String>
diff --git a/src/Avalonia.Themes.Simple/Controls/CalendarDatePicker.xaml b/src/Avalonia.Themes.Simple/Controls/CalendarDatePicker.xaml
index 9eba0a413b..52c9469034 100644
--- a/src/Avalonia.Themes.Simple/Controls/CalendarDatePicker.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/CalendarDatePicker.xaml
@@ -128,7 +128,9 @@
                       FirstDayOfWeek="{TemplateBinding FirstDayOfWeek}"
                       IsTodayHighlighted="{TemplateBinding IsTodayHighlighted}"
                       SelectedDate="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=SelectedDate,
-                                                     Mode=TwoWay}" />
+                                                     Mode=TwoWay}"
+                      IsWeekNumberVisible="{TemplateBinding IsWeekNumberVisible}"
+                      WeekNumberRule="{TemplateBinding WeekNumberRule}" />
           </Popup>
         </Grid>
       </ControlTemplate>
diff --git a/src/Avalonia.Themes.Simple/Controls/CalendarItem.xaml b/src/Avalonia.Themes.Simple/Controls/CalendarItem.xaml
index e9e9299960..4012caa98f 100644
--- a/src/Avalonia.Themes.Simple/Controls/CalendarItem.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/CalendarItem.xaml
@@ -8,6 +8,9 @@
 <ResourceDictionary xmlns="https://github.com/avaloniaui"
                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                     x:ClassModifier="internal">
+  <Design.PreviewWith>
+    <Calendar IsWeekNumberVisible="True" />
+  </Design.PreviewWith>
   <ControlTheme x:Key="{x:Type CalendarItem}"
                 TargetType="CalendarItem">
     <Setter Property="CornerRadius" Value="1" />
@@ -23,7 +26,7 @@
             <Border BorderBrush="{DynamicResource ThemeBackgroundBrush}"
                     BorderThickness="2"
                     CornerRadius="1">
-              <Grid>
+              <Grid  Grid.IsSharedSizeScope="True">
                 <Grid.RowDefinitions>
                   <RowDefinition Height="Auto" />
                   <RowDefinition Height="*" />
@@ -31,7 +34,6 @@
                 <Grid.ColumnDefinitions>
                   <ColumnDefinition Width="Auto" />
                   <ColumnDefinition Width="*" />
-                  <ColumnDefinition Width="Auto" />
                 </Grid.ColumnDefinitions>
 
                 <Grid.Styles>
@@ -60,65 +62,91 @@
                   </Style>
                 </Grid.Styles>
 
-                <Rectangle Grid.ColumnSpan="3"
-                           Height="22"
-                           VerticalAlignment="Top"
-                           Fill="{TemplateBinding HeaderBackground}"
-                           Stretch="Fill" />
-
-                <Button Name="PART_PreviousButton"
-                        HorizontalAlignment="Left"
-                        Classes="CalendarHeader CalendarNavigation"
-                        IsVisible="False">
-
-                  <Path Width="6"
-                        Height="10"
-                        Margin="14,-6,0,0"
-                        HorizontalAlignment="Left"
-                        VerticalAlignment="Center"
-                        Data="M288.75,232.25 L288.75,240.625 L283,236.625 z"
-                        Stretch="Fill" />
-
-                </Button>
-
-                <Button Name="PART_HeaderButton"
-                        Grid.Column="1"
-                        Padding="1,5,1,9"
-                        HorizontalAlignment="Center"
-                        VerticalAlignment="Center"
-                        Classes="CalendarHeader"
-                        FontSize="10.5"
-                        FontWeight="Bold" />
-
-                <Button Name="PART_NextButton"
-                        Grid.Column="2"
-                        HorizontalAlignment="Right"
-                        Classes="CalendarHeader CalendarNavigation"
-                        IsVisible="False">
-
-                  <Path Width="6"
-                        Height="10"
-                        Margin="0,-6,14,0"
-                        HorizontalAlignment="Right"
-                        VerticalAlignment="Center"
-                        Data="M282.875,231.875 L282.875,240.375 L288.625,236 z"
-                        Stretch="Fill" />
-
-                </Button>
+                <Grid Grid.ColumnSpan="2" >
+                  <Rectangle Grid.ColumnSpan="3"
+                             Height="22"
+                             VerticalAlignment="Top"
+                             Fill="{TemplateBinding HeaderBackground}"
+                             Stretch="Fill" />
+
+                  <Button Name="PART_PreviousButton"
+                          HorizontalAlignment="Left"
+                          Classes="CalendarHeader CalendarNavigation"
+                          IsVisible="False">
+
+                    <Path Width="6"
+                          Height="10"
+                          Margin="14,-6,0,0"
+                          HorizontalAlignment="Left"
+                          VerticalAlignment="Center"
+                          Data="M288.75,232.25 L288.75,240.625 L283,236.625 z"
+                          Stretch="Fill" />
+
+                  </Button>
+
+                  <Button Name="PART_HeaderButton"
+                          Grid.Column="1"
+                          Padding="1,5,1,9"
+                          HorizontalAlignment="Center"
+                          VerticalAlignment="Center"
+                          Classes="CalendarHeader"
+                          FontSize="10.5"
+                          FontWeight="Bold" />
+
+                  <Button Name="PART_NextButton"
+                          Grid.Column="2"
+                          HorizontalAlignment="Right"
+                          Classes="CalendarHeader CalendarNavigation"
+                          IsVisible="False">
+
+                    <Path Width="6"
+                          Height="10"
+                          Margin="0,-6,14,0"
+                          HorizontalAlignment="Right"
+                          VerticalAlignment="Center"
+                          Data="M282.875,231.875 L282.875,240.375 L288.625,236 z"
+                          Stretch="Fill" />
+
+                  </Button>
+                </Grid>
+
+                <Grid Name="PART_ElementWeekNumberLabels" 
+                      Grid.Row="1"
+                      Grid.Column="0"
+                      IsVisible="False"
+                      MinWidth="20"
+                      Margin="6,-1,6,6"
+                      VerticalAlignment="Stretch">
+                  <Grid.RowDefinitions>
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewHeaderRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                  </Grid.RowDefinitions>
+                  <!-- week number header -->
+                  <ContentControl Content="{DynamicResource StringCalendarWeekNumberHeader}"
+                                  FontSize="9.5"
+                                  VerticalAlignment="Top"
+                                  VerticalContentAlignment="Center"
+                                  HorizontalContentAlignment="Center" />
+                </Grid>
 
                 <Grid Name="PART_MonthView"
                       Grid.Row="1"
-                      Grid.ColumnSpan="3"
+                      Grid.Column="1"
                       Margin="6,-1,6,6"
                       IsVisible="False">
                   <Grid.RowDefinitions>
-                    <RowDefinition Height="Auto" />
-                    <RowDefinition Height="Auto" />
-                    <RowDefinition Height="Auto" />
-                    <RowDefinition Height="Auto" />
-                    <RowDefinition Height="Auto" />
-                    <RowDefinition Height="Auto" />
-                    <RowDefinition Height="Auto" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewHeaderRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
+                    <RowDefinition Height="Auto" SharedSizeGroup="CalendarMonthViewWeekRow" />
                   </Grid.RowDefinitions>
                   <Grid.ColumnDefinitions>
                     <ColumnDefinition Width="Auto" />
@@ -176,5 +204,16 @@
     <Style Selector="^:calendardisabled /template/ Rectangle#DisabledVisual">
       <Setter Property="IsVisible" Value="True" />
     </Style>
+    
+    <Style Selector="^:hasweeknumbers">
+      <Style Selector="^ /template/ Grid#PART_ElementWeekNumberLabels">
+        <Style Selector="^ ContentControl">
+          <Setter Property="FontSize" Value="9.5" />
+          <Setter Property="HorizontalContentAlignment" Value="Center" />
+          <Setter Property="VerticalAlignment" Value="Stretch" />
+          <Setter Property="VerticalContentAlignment" Value="Center" />
+        </Style>
+      </Style>
+    </Style>
   </ControlTheme>
 </ResourceDictionary>
diff --git a/tests/Avalonia.Controls.UnitTests/CalendarTests.cs b/tests/Avalonia.Controls.UnitTests/CalendarTests.cs
index 75ba43c9e4..04c658c3b7 100644
--- a/tests/Avalonia.Controls.UnitTests/CalendarTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/CalendarTests.cs
@@ -1,10 +1,13 @@
-using Xunit;
+using Xunit;
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using Avalonia.Controls.Primitives;
+using Avalonia.Controls.Templates;
 using Avalonia.Input;
 using Avalonia.UnitTests;
+using Avalonia.VisualTree;
 
 namespace Avalonia.Controls.UnitTests
 {
@@ -440,5 +443,193 @@ namespace Avalonia.Controls.UnitTests
             // Verify the flag was reset
             Assert.False((bool)field.GetValue(calendarItem)!);
         }
+
+
+        // --- Week number tests ---
+
+        [Fact]
+        public void IsWeekNumberVisible_Defaults_To_False()
+        {
+            var calendar = new Calendar();
+            Assert.False(calendar.IsWeekNumberVisible);
+        }
+
+        [Fact]
+        public void WeekNumberRule_Defaults_To_Culture_CalendarWeekRule()
+        {
+            var calendar = new Calendar();
+            Assert.IsType<CalendarWeekRule>(calendar.WeekNumberRule);
+        }
+
+        [Fact]
+        public void IsWeekNumberVisible_Can_Be_Set()
+        {
+            var calendar = new Calendar();
+            calendar.IsWeekNumberVisible = true;
+            Assert.True(calendar.IsWeekNumberVisible);
+        }
+
+        [Fact]
+        public void WeekNumberRule_Can_Be_Set()
+        {
+            var calendar = new Calendar();
+            calendar.WeekNumberRule = CalendarWeekRule.FirstFourDayWeek;
+            Assert.Equal(CalendarWeekRule.FirstFourDayWeek, calendar.WeekNumberRule);
+        }
+
+        [Theory]
+        // ISO 8601: week 1 of 2023 starts on Monday 2 Jan 2023
+        [InlineData(2023, 1, 2, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday, 1)]
+        // 2022-12-31 is still in ISO week 52 of 2022
+        [InlineData(2022, 12, 31, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday, 52)]
+        // .NET bug: 2018-12-31 is a Monday and is ISO week 1 of 2019, not week 53 of 2018
+        [InlineData(2018, 12, 31, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday, 1)]
+        // US rule: week 1 always starts on Jan 1
+        [InlineData(2023, 1, 1, CalendarWeekRule.FirstDay, DayOfWeek.Sunday, 1)]
+        [InlineData(2023, 12, 31, CalendarWeekRule.FirstDay, DayOfWeek.Sunday, 53)]
+        public void GetWeekOfYear_Returns_Correct_Week_Number(
+            int year, int month, int day,
+            CalendarWeekRule rule,
+            DayOfWeek firstDayOfWeek,
+            int expectedWeek)
+        {
+            var _calendar = new GregorianCalendar();
+            var date = new DateTime(year, month, day);
+            int week = DateTimeHelper.GetWeekOfYear(date, rule, firstDayOfWeek, _calendar);
+            Assert.Equal(expectedWeek, week);
+        }
+
+
+        // ------------------------------------------------------------------------
+        //  ISO‑week fallback tests – verify that GetWeekOfYear returns the expected
+        //  week numbers for edge‑case dates.
+        // ------------------------------------------------------------------------
+        [Theory]
+        // 31 Dec 2018 is part of ISO‑week 1 of 2019
+        [InlineData(2018, 12, 31, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday, 1)]
+        // 1 Jan 2020 is also ISO‑week 1 (Monday)
+        [InlineData(2020, 01, 01, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday, 1)]
+        // 29 Dec 2014 (Monday) should be week 1 of 2015 (ISO)
+        [InlineData(2014, 12, 29, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday, 1)]
+        // 30 Dec 2019 (Monday) is week 1 of 2020 (ISO)
+        [InlineData(2019, 12, 30, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday, 1)]
+        public void GetWeekOfYear_IsoWeekFallback_Returns_Correct_Week(
+            int year, int month, int day,
+            CalendarWeekRule rule,
+            DayOfWeek firstDay,
+            int expectedWeek)
+        {
+            var _calendar = new GregorianCalendar();
+            var date = new DateTime(year, month, day);
+            // DateTimeHelper is the internal helper used by Calendar.
+            // It falls back to ISO‑week calculation when the culture’s
+            // CalendarWeekRule does not produce a valid week.
+            int week = DateTimeHelper.GetWeekOfYear(date, rule, firstDay, _calendar);
+            Assert.Equal(expectedWeek, week);
+        }
+
+        // ------------------------------------------------------------------------
+        //  Property change refresh tests – ensure the control updates its
+        //  visual state when week‑number related properties are changed.
+        // ------------------------------------------------------------------------
+        [Fact]
+        public void Changing_IsWeekNumberVisible_Toggles_HasWeekNumbers_PseudoClass()
+        {
+            var calendar = CreateTestCalendar();
+            
+            calendar.ApplyTemplate();
+            calendar.DisplayMode = CalendarMode.Month;
+            calendar.IsWeekNumberVisible = false;
+
+            // Grab the CalendarItem from the visual tree
+            var calendarItem = calendar.GetVisualDescendants()
+                .OfType<CalendarItem>()
+                .FirstOrDefault();
+            Assert.NotNull(calendarItem);
+            
+            calendarItem.ApplyTemplate();
+
+            // Assert pseudo-class is NOT set
+            Assert.False(calendarItem.Classes.Contains(":hasweeknumbers"));
+            
+            // Turn on week numbers
+            calendar.IsWeekNumberVisible = true;
+            
+            // Assert pseudo-class IS set
+            Assert.True(calendarItem.Classes.Contains(":hasweeknumbers"));
+        }
+
+        [Fact]
+        public void Changing_WeekNumberRule_Refreshes_WeekNumber_Labels()
+        {
+            var calendar = CreateTestCalendar();
+            
+            // Apply template so that the internal CalendarItem is created
+            calendar.ApplyTemplate();
+
+            calendar.DisplayMode = CalendarMode.Month;
+            calendar.IsWeekNumberVisible = true;
+            // Use ISO‑rule (FirstFourDayWeek) for the test
+            calendar.WeekNumberRule = CalendarWeekRule.FirstFourDayWeek;
+            calendar.FirstDayOfWeek = DayOfWeek.Monday;
+            calendar.DisplayDate = new DateTime(2021, 01, 04); // First Monday of 2021
+
+            // Grab the CalendarItem from the visual tree
+            var calendarItem = calendar.GetVisualDescendants()
+                .OfType<CalendarItem>()
+                .FirstOrDefault();
+            Assert.NotNull(calendarItem);
+            
+            calendarItem.ApplyTemplate();
+
+            // The first week‑number label should display “1” for the first week of 2021
+            var weekLabelsGrid = calendarItem.GetVisualDescendants()
+                .OfType<Grid>()
+                .FirstOrDefault(x => x.Name == "PART_ElementWeekNumberLabels");
+            Assert.NotNull(weekLabelsGrid);
+            var firstLabel = weekLabelsGrid.Children.OfType<ContentControl>().First(x => Grid.GetRow(x) == 2);
+            Assert.Equal(1, firstLabel.Content);
+
+            // Change the rule to use FirstDay (which for 2021‑01‑04 would be week 2)
+            calendar.WeekNumberRule = CalendarWeekRule.FirstDay;
+
+            // Force a layout pass – in unit‑tests this is enough to trigger the update
+            calendar.InvalidateMeasure();
+            calendar.UpdateLayout();
+
+            // After the rule change the first visible week number should now be “2”
+            firstLabel = weekLabelsGrid.Children.OfType<ContentControl>().First(x => Grid.GetRow(x) == 2);
+            Assert.Equal(2, firstLabel.Content);
+        }
+
+        private static Calendar CreateTestCalendar()
+        {
+            var cal = new Calendar();
+            var template = new FuncControlTemplate<Calendar>((c, scope) => new Panel()
+            {
+                Name = "PART_Root",
+                Children =
+                {
+                    new CalendarItem()
+                    {
+                        Name = "PART_CalendarItem",
+                        Owner = c,
+                        DayTitleTemplate = new FuncTemplate<Control>(() => new TextBlock()),
+                        Template = new FuncControlTemplate<CalendarItem>((_, itemScope) => new Grid()
+                        {
+                            Children =
+                            {
+                                new Grid { Name = "PART_MonthView" }.RegisterInNameScope(itemScope),
+                                new Grid { Name = "PART_YearView" }.RegisterInNameScope(itemScope),
+                                new Grid { Name = "PART_ElementWeekNumberLabels" }.RegisterInNameScope(itemScope)
+                            }
+                        })
+                    }.RegisterInNameScope(scope)
+                }
+            }.RegisterInNameScope(scope));
+            cal.Template = template;
+
+            return cal;
+        }
     }
 }

From f5d2bc9e6dd23231b1328c18c8d3644146226a80 Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Thu, 20 Aug 2026 10:50:13 +0000
Subject: [PATCH 183/196] fix(VirtualizingStackPanel): hide cached focused
 items (#21835)

* test(VirtualizingStackPanel): cover focused item virtualization

A focused item remains attached so keyboard focus can be preserved after it leaves the realized range. It must nevertheless stop rendering until it is realized again; otherwise an estimated position can surface it in the viewport.

* fix(VirtualizingStackPanel): hide cached focused items

A focused container stays attached after it leaves the realized range so keyboard focus survives. Its estimated position can overlap the viewport when item sizes vary, causing it to render and receive pointer input as a ghost item.\n\nSuppress rendering and hit testing while the container is cached, then restore its original state before re-realization or recycling. This preserves focus and template-provided opacity.

* fix(VirtualizingStackPanel): restore current focused container state

Focused-container suppression previously replayed the opacity and hit-test values observed when virtualization began. That could hide updates from bindings, styles, or application code while the container was retained.\n\nUse disposable animation-priority overrides for the temporary suppression so disposing them reveals the property's current underlying value.

* fix(VirtualizingStackPanel): keep retained focused container out of the viewport

The container of a focused item that leaves the realized range is retained
to preserve keyboard focus, and arranged at a position estimated from the
average realized element size. With differing item sizes that estimate can
place the container so that it overlaps the viewport, where it renders as a
ghost item and intercepts pointer input (#17935).

An unrealized item before the realized range always ends at or before the
range's start, and one after it always starts at or after the range's end.
Clamp the estimated arrange position to that invariant so the retained
container can never overlap the realized elements, replacing the previous
approach of masking the container with animation-priority opacity and
hit-test overrides.
---
 .../VirtualizingStackPanel.cs                 | 22 ++++++++++--
 .../VirtualizingStackPanelTests.cs            | 34 +++++++++++++++++++
 2 files changed, 54 insertions(+), 2 deletions(-)

diff --git a/src/Avalonia.Controls/VirtualizingStackPanel.cs b/src/Avalonia.Controls/VirtualizingStackPanel.cs
index a8cc7b669d..62010aecc4 100644
--- a/src/Avalonia.Controls/VirtualizingStackPanel.cs
+++ b/src/Avalonia.Controls/VirtualizingStackPanel.cs
@@ -293,10 +293,28 @@ namespace Avalonia.Controls
                 // Ensure that the focused element is in the correct position.
                 if (_focusedElement is not null && _focusedIndex >= 0)
                 {
+                    var realizedEndU = u;
+                    var sizeU = orientation == Orientation.Horizontal ?
+                        _focusedElement.DesiredSize.Width :
+                        _focusedElement.DesiredSize.Height;
+
                     u = GetOrEstimateElementU(_focusedIndex);
+
+                    // The focused element's position is estimated as it's outside the realized
+                    // range. A bad estimate must not place it over the realized elements in the
+                    // viewport: an element before the realized range always ends at or before its
+                    // start, and one after it always starts at or after its end.
+                    if (_realizedElements.Count > 0 && !double.IsNaN(_realizedElements.StartU))
+                    {
+                        if (_focusedIndex < _realizedElements.FirstIndex)
+                            u = Math.Min(u, _realizedElements.StartU - sizeU);
+                        else if (_focusedIndex > _realizedElements.LastIndex)
+                            u = Math.Max(u, realizedEndU);
+                    }
+
                     var rect = orientation == Orientation.Horizontal ?
-                        new Rect(u, 0, _focusedElement.DesiredSize.Width, finalSize.Height) :
-                        new Rect(0, u, finalSize.Width, _focusedElement.DesiredSize.Height);
+                        new Rect(u, 0, sizeU, finalSize.Height) :
+                        new Rect(0, u, finalSize.Width, sizeU);
 
                     _focusedElement.Arrange(rect);
                 }
diff --git a/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs b/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs
index 873da11c67..f9d079835d 100644
--- a/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs
@@ -492,6 +492,40 @@ namespace Avalonia.Controls.UnitTests
             Assert.Same(focused, target.GetRealizedElements().First());
         }
 
+        [Theory]
+        [InlineData(0d)]
+        [InlineData(0.5d)]
+        public void Focused_Element_Outside_Realized_Range_Is_Not_Arranged_In_Viewport(double bufferFactor)
+        {
+            using var app = App();
+
+            // Item 0 is much taller than the others, so the average-based position estimated for
+            // it once it has left the realized range lands inside the viewport (#17935).
+            var items = Enumerable.Range(0, 100).Select(x => new ItemWithHeight(x, x == 0 ? 100 : 10));
+            var (target, scroll, itemsControl) = CreateTarget(
+                items: items,
+                itemTemplate: CanvasWithHeightTemplate,
+                bufferFactor: bufferFactor);
+
+            var focused = target.GetRealizedElements().First()!;
+            focused.Focusable = true;
+            focused.Focus();
+            Assert.True(focused.IsKeyboardFocusWithin);
+
+            scroll.Offset = new Vector(0, 160);
+            Layout(target);
+
+            var viewport = new Rect(scroll.Offset.X, scroll.Offset.Y, scroll.Viewport.Width, scroll.Viewport.Height);
+            Assert.True(focused.IsKeyboardFocusWithin);
+            Assert.False(focused.Bounds.Intersects(viewport));
+
+            scroll.Offset = new Vector(0, 0);
+            Layout(target);
+
+            Assert.Same(focused, target.GetRealizedElements().First());
+            Assert.Equal(new Rect(0, 0, 100, 100), focused.Bounds);
+        }
+
         [Theory]
         [InlineData(0d)]
         [InlineData(0.5d)]

From d2853724fcd54ed59ee3fbc987e6616042230c35 Mon Sep 17 00:00:00 2001
From: Ole Ross <97119047+OleRoss@users.noreply.github.com>
Date: Thu, 20 Aug 2026 11:18:38 +0000
Subject: [PATCH 184/196] fix: Set the LogicalParent of the TableViewColumn
 (#21840)

TableViewColumn extends StyledElement. However, many features such as StyleSelectors did not work because no logical parent was set. This is solved by registering the TableView as a logical parent when the TableViewColumn is attached (and setting it to null when detacting).
---
 src/Avalonia.Controls/TableView.cs            |  3 ++
 .../TableViewTests.cs                         | 41 +++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/src/Avalonia.Controls/TableView.cs b/src/Avalonia.Controls/TableView.cs
index 87141677f0..6fbc634478 100644
--- a/src/Avalonia.Controls/TableView.cs
+++ b/src/Avalonia.Controls/TableView.cs
@@ -5,6 +5,7 @@ using Avalonia.Collections;
 using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Templates;
 using Avalonia.Data;
+using Avalonia.LogicalTree;
 using Avalonia.Metadata;
 using static Avalonia.Controls.Presenters.TableViewLayoutHelper;
 
@@ -139,6 +140,7 @@ public class TableView : ListBox
         }
 
         column.TableView = this;
+        ((ISetLogicalParent)column).SetParent(this);
     }
 
     private void DetachColumn(TableViewColumn column)
@@ -146,6 +148,7 @@ public class TableView : ListBox
         Debug.Assert(column.TableView == this || column.TableView is null);
 
         column.TableView = null;
+        ((ISetLogicalParent)column).SetParent(null);
         column.ActualWidth = double.NaN;
     }
 
diff --git a/tests/Avalonia.Controls.UnitTests/TableViewTests.cs b/tests/Avalonia.Controls.UnitTests/TableViewTests.cs
index 139a11c13d..e347d436da 100644
--- a/tests/Avalonia.Controls.UnitTests/TableViewTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TableViewTests.cs
@@ -70,6 +70,47 @@ public sealed class TableViewTests : ScopedTestBase
         Assert.Null(column.TableView);
     }
 
+    [Fact]
+    public void Column_LogicalParent_Is_Set_When_Added_And_Unset_When_Removed()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        var column = new TableViewColumn();
+        target.Columns.Add(column);
+
+        Prepare(target);
+
+        Assert.Same(target, column.GetLogicalParent());
+
+        target.Columns.Remove(column);
+
+        Assert.Null(column.GetLogicalParent());
+    }
+
+    [Fact]
+    public void Column_Receives_Styles_From_TableView()
+    {
+        using var app = Start();
+
+        var target = CreateTarget(new[] { "Foo" });
+        var style = new Style(x => x.OfType<TableViewColumn>().Class("right-align"))
+        {
+            Setters = { new Setter(TableViewColumn.HorizontalContentAlignmentProperty, HorizontalAlignment.Right) }
+        };
+        target.Styles.Add(style);
+
+        var column = new TableViewColumn
+        {
+            Classes = { "right-align" }
+        };
+        target.Columns.Add(column);
+
+        Prepare(target);
+
+        Assert.Equal(HorizontalAlignment.Right, column.HorizontalContentAlignment);
+    }
+
     [Fact]
     public void Column_Cannot_Belong_To_Two_TableViews()
     {

From 37f3e607a6bc970354b70e3b7dfa817e2bd8cf88 Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Thu, 20 Aug 2026 13:08:31 +0000
Subject: [PATCH 185/196] Disconnect template descendants hosted inside Viewbox
 when the template changes (#21879)

* Add failing test for template child presented inside Viewbox not being reparented on template change

When a ControlTemplate contains Viewbox > ContentPresenter presenting a
control that outlives the template, swapping the template throws
"The control already has a visual parent" because the old presenter
never releases the presented control.

Repro for #9551.

* Forward TemplatedParent to Viewbox's internal container so template teardown reaches its subtree

Viewbox hosts its Child inside an internal ViewboxContainer visual that
is a visual child but not a logical child of the Viewbox. Template
teardown (TemplatedControl.ApplyTemplate) finds descendants to
disconnect via GetTemplateDescendants, a visual-tree walk that stops
recursing at any visual whose TemplatedParent is null. ViewboxContainer
never had a TemplatedParent, so the walk stopped at it and template
descendants hosted inside the Viewbox (e.g. a ContentPresenter) never
had their TemplatedParent cleared. Their template bindings therefore
stayed live, the old ContentPresenter kept the presented control as its
visual child, and re-presenting that control in the new template threw
"The control already has a visual parent".

Forward the Viewbox's TemplatedParent to the container, restoring the
invariant that every template descendant is reachable through visuals
whose TemplatedParent is non-null. Null is deliberately not forwarded:
teardown clears the Viewbox's TemplatedParent while iterating lazily,
and forwarding null would prune the walk before it reaches the
container's subtree; the walk clears the container's TemplatedParent
itself instead.

Fixes #9551

* Trim down comment

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 src/Avalonia.Controls/Viewbox.cs              |  9 +++
 .../ViewboxTests.cs                           | 55 +++++++++++++++++++
 2 files changed, 64 insertions(+)

diff --git a/src/Avalonia.Controls/Viewbox.cs b/src/Avalonia.Controls/Viewbox.cs
index b21a04c1d4..dd575c01ec 100644
--- a/src/Avalonia.Controls/Viewbox.cs
+++ b/src/Avalonia.Controls/Viewbox.cs
@@ -113,6 +113,15 @@ namespace Avalonia.Controls
 
                 InvalidateMeasure();
             }
+            else if (change.Property == TemplatedParentProperty)
+            {
+                // Update _containerVisual.TemplateParent, otherwise its descendants aren't reachable
+                // during the template's teardown and incorrectly stay attached to the visual tree.
+                if (change.NewValue is AvaloniaObject templatedParent)
+                {
+                    _containerVisual.TemplatedParent = templatedParent;
+                }
+            }
         }
 
         /// <inheritdoc />
diff --git a/tests/Avalonia.Controls.UnitTests/ViewboxTests.cs b/tests/Avalonia.Controls.UnitTests/ViewboxTests.cs
index cc798afb19..8b36543675 100644
--- a/tests/Avalonia.Controls.UnitTests/ViewboxTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ViewboxTests.cs
@@ -1,8 +1,11 @@
+using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Shapes;
+using Avalonia.Controls.Templates;
 using Avalonia.Data;
 using Avalonia.LogicalTree;
 using Avalonia.Media;
 using Avalonia.UnitTests;
+using Avalonia.VisualTree;
 using Xunit;
 
 namespace Avalonia.Controls.UnitTests
@@ -228,6 +231,58 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal("foo", target.Child.DataContext);
         }
       
+        [Fact]
+        public void Content_Presented_In_Viewbox_Should_Be_Reparented_When_Template_Changes()
+        {
+            // Issue #9551: a template containing Viewbox > ContentPresenter presenting a control
+            // that outlives the template. Swapping the template must disconnect the presented
+            // control so the new template's presenter can adopt it.
+            using var app = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface);
+
+            static FuncControlTemplate CreateTemplate()
+            {
+                return new FuncControlTemplate<TestTemplatedControl>((_, _) => new Viewbox
+                {
+                    Child = new ContentPresenter
+                    {
+                        [~ContentPresenter.ContentProperty] = new TemplateBinding(TestTemplatedControl.MyControlProperty),
+                    },
+                });
+            }
+
+            var child = new Canvas();
+            var target = new TestTemplatedControl
+            {
+                MyControl = child,
+                Template = CreateTemplate(),
+            };
+
+            var root = new TestRoot(target);
+            root.ExecuteInitialLayoutPass();
+
+            var oldPresenter = Assert.IsType<ContentPresenter>(child.GetVisualParent());
+
+            target.Template = CreateTemplate();
+            target.ApplyTemplate();
+            root.LayoutManager.ExecuteLayoutPass();
+
+            var newPresenter = Assert.IsType<ContentPresenter>(child.GetVisualParent());
+            Assert.NotSame(oldPresenter, newPresenter);
+            Assert.Same(root, child.GetVisualRoot());
+        }
+
+        private class TestTemplatedControl : Avalonia.Controls.Primitives.TemplatedControl
+        {
+            public static readonly StyledProperty<Control?> MyControlProperty =
+                AvaloniaProperty.Register<TestTemplatedControl, Control?>(nameof(MyControl));
+
+            public Control? MyControl
+            {
+                get => GetValue(MyControlProperty);
+                set => SetValue(MyControlProperty, value);
+            }
+        }
+
         private static bool TryGetScale(Viewbox viewbox, out Vector scale)
         {
             if (viewbox.InternalTransform is null)

From 41fbff90eafd352c9500e57ebfcf2240bf8fe0cb Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Mon, 24 Aug 2026 09:17:36 +0000
Subject: [PATCH 186/196] Drop dead
 WM_POINTERDEVICEINRANGE/WM_POINTERDEVICEOUTOFRANGE handling (#22046)

These notifications are only delivered to windows that opted in via
RegisterPointerDeviceNotifications, which we never call, so both
branches have been unreachable since they were introduced. They also
parse wParam as a pointer id, while these messages carry a device
handle there.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .../Avalonia.Win32/WindowImpl.AppWndProc.cs     | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/src/Windows/Avalonia.Win32/WindowImpl.AppWndProc.cs b/src/Windows/Avalonia.Win32/WindowImpl.AppWndProc.cs
index f0140204a4..93d76ee057 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.AppWndProc.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.AppWndProc.cs
@@ -582,7 +582,6 @@ namespace Avalonia.Win32
                         e = args;
                         break;
                     }
-                case WindowsMessage.WM_POINTERDEVICEOUTOFRANGE:
                 case WindowsMessage.WM_POINTERLEAVE:
                 case WindowsMessage.WM_POINTERCAPTURECHANGED:
                     {
@@ -612,22 +611,6 @@ namespace Avalonia.Win32
                         };
                         break;
                     }
-                case WindowsMessage.WM_POINTERDEVICEINRANGE:
-                    {
-                        if (!_wmPointerEnabled)
-                        {
-                            break;
-                        }
-
-                        // Do not generate events, but release mouse capture on any other device input.
-                        GetDevicePointerInfo(wParam, out var device, out _, out _, out _, ref timestamp);
-                        if (device != _mouseDevice)
-                        {
-                            _mouseDevice.Capture(null);
-                            return IntPtr.Zero;
-                        }
-                        break;
-                    }
                 case WindowsMessage.WM_POINTERACTIVATE:
                     {
                         //occurs when a pointer activates an inactive window.

From a9cd0d1402d094348132d51215af5117f8f8fc6b Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Mon, 24 Aug 2026 11:07:44 +0000
Subject: [PATCH 187/196] fix(animation): keep transform playback in sync when
 hidden (#21896)

OnlyIfVisible paused properties applied directly to a Visual, but transform setters continued advancing because their AnimationInstance targeted a child Transform. This left scale and opacity out of phase after visibility was restored.\n\nCarry the owning visual separately from the property target so transform instances observe the same visibility and detachment lifecycle. Cover the pause and resume timeline with a regression test.

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../Animation/AnimationInstance`1.cs          |  9 ++-
 .../Animation/Animators/Animator`1.cs         | 19 ++++++-
 .../Animation/Animators/TransformAnimator.cs  |  4 +-
 .../DisposeAnimationInstanceSubject.cs        | 11 +++-
 .../Animation/AnimationIterationTests.cs      | 56 +++++++++++++++++++
 5 files changed, 89 insertions(+), 10 deletions(-)

diff --git a/src/Avalonia.Base/Animation/AnimationInstance`1.cs b/src/Avalonia.Base/Animation/AnimationInstance`1.cs
index f1b0a937a4..cdfa1f9dda 100644
--- a/src/Avalonia.Base/Animation/AnimationInstance`1.cs
+++ b/src/Avalonia.Base/Animation/AnimationInstance`1.cs
@@ -15,6 +15,7 @@ namespace Avalonia.Animation
         private readonly Animator<T> _animator;
         private readonly Animation _animation;
         private readonly Animatable _targetControl;
+        private readonly Visual? _visualTarget;
         private readonly Action? _onCompleteAction;
         private IDisposable? _timerSub;
         private EventHandler<AvaloniaPropertyChangedEventArgs>? _propertyChangedDelegate;
@@ -61,7 +62,8 @@ namespace Avalonia.Animation
 
         private readonly bool _shouldPauseOnInvisible;
 
-        public AnimationInstance(Animation animation, Animatable control, Animator<T> animator, IClock baseClock, Action? OnComplete, Func<double, T, T> Interpolator, bool shouldPauseOnInvisible)
+        public AnimationInstance(Animation animation, Animatable control, Animator<T> animator, IClock baseClock,
+            Action? OnComplete, Func<double, T, T> Interpolator, bool shouldPauseOnInvisible, Visual? visualTarget)
         {
             _lastInterpValue = default!;
             _animator = animator;
@@ -70,6 +72,7 @@ namespace Avalonia.Animation
             _onCompleteAction = OnComplete;
             _interpolator = Interpolator;
             _baseClock = baseClock;
+            _visualTarget = visualTarget;
             _initialKFValue = default!;
             _neutralValue = default!;
             _shouldPauseOnInvisible = shouldPauseOnInvisible;
@@ -132,7 +135,7 @@ namespace Avalonia.Animation
             _targetControl.PropertyChanged -= _propertyChangedDelegate;
             timerSub.Dispose();
 
-            if (_targetControl is Visual visual)
+            if (_visualTarget is { } visual)
             {
                 if (_visibilityChangedHandler is not null)
                 {
@@ -155,7 +158,7 @@ namespace Avalonia.Animation
             _clock = new Clock(_baseClock);
             _timerSub = _clock.Subscribe(Step);
 
-            if (_targetControl is Visual visual)
+            if (_visualTarget is { } visual)
             {
                 if (_shouldPauseOnInvisible)
                 {
diff --git a/src/Avalonia.Base/Animation/Animators/Animator`1.cs b/src/Avalonia.Base/Animation/Animators/Animator`1.cs
index 20311c8389..88446fe533 100644
--- a/src/Avalonia.Base/Animation/Animators/Animator`1.cs
+++ b/src/Avalonia.Base/Animation/Animators/Animator`1.cs
@@ -18,8 +18,19 @@ namespace Avalonia.Animation.Animators
 
         /// <inheritdoc/>
         public virtual IDisposable? Apply(Animation animation, Animatable control, IClock? clock, IObservable<bool> match, Action? onComplete, bool shouldPauseOnInvisible)
+            => Apply(animation, control, clock, match, onComplete, shouldPauseOnInvisible, control as Visual);
+
+        internal IDisposable? Apply(Animation animation, Animatable control, IClock? clock, IObservable<bool> match,
+            Action? onComplete, bool shouldPauseOnInvisible, Visual? visualTarget)
         {
-            var subject = new DisposeAnimationInstanceSubject<T>(this, animation, control, clock, onComplete, shouldPauseOnInvisible);
+            var subject = new DisposeAnimationInstanceSubject<T>(
+                this,
+                animation,
+                control,
+                clock,
+                onComplete,
+                shouldPauseOnInvisible,
+                visualTarget);
             return new CompositeDisposable(match.Subscribe(subject), subject);
         }
 
@@ -103,7 +114,8 @@ namespace Avalonia.Animation.Animators
         /// <summary>
         /// Runs the KeyFrames Animation.
         /// </summary>
-        internal IDisposable Run(Animation animation, Animatable control, IClock? clock, Action? onComplete, bool shouldPauseOnInvisible)
+        internal IDisposable Run(Animation animation, Animatable control, IClock? clock, Action? onComplete,
+            bool shouldPauseOnInvisible, Visual? visualTarget)
         {
             var instance = new AnimationInstance<T>(
                 animation,
@@ -112,7 +124,8 @@ namespace Avalonia.Animation.Animators
                 clock ?? control.Clock ?? Clock.GlobalClock,
                 onComplete,
                 InterpolationHandler,
-                shouldPauseOnInvisible);
+                shouldPauseOnInvisible,
+                visualTarget);
 
             return BindAnimation(control, instance);
         }
diff --git a/src/Avalonia.Base/Animation/Animators/TransformAnimator.cs b/src/Avalonia.Base/Animation/Animators/TransformAnimator.cs
index aef5c78f95..260a2a71ab 100644
--- a/src/Avalonia.Base/Animation/Animators/TransformAnimator.cs
+++ b/src/Avalonia.Base/Animation/Animators/TransformAnimator.cs
@@ -67,7 +67,7 @@ namespace Avalonia.Animation.Animators
                 if (renderTransformType == Property.OwnerType)
                 {
                     return _doubleAnimator.Apply(animation, (Transform) ctrl.RenderTransform, clock ?? control.Clock,
-                        obsMatch, onComplete, shouldPauseOnInvisible);
+                        obsMatch, onComplete, shouldPauseOnInvisible, ctrl);
                 }
                 // It's a TransformGroup and try finding the target there.
                 else if (renderTransformType == typeof(TransformGroup))
@@ -77,7 +77,7 @@ namespace Avalonia.Animation.Animators
                         if (transform.GetType() == Property.OwnerType)
                         {
                             return _doubleAnimator.Apply(animation, transform, clock ?? control.Clock,
-                                obsMatch, onComplete, shouldPauseOnInvisible);
+                                obsMatch, onComplete, shouldPauseOnInvisible, ctrl);
                         }
                     }
                 }
diff --git a/src/Avalonia.Base/Animation/DisposeAnimationInstanceSubject.cs b/src/Avalonia.Base/Animation/DisposeAnimationInstanceSubject.cs
index 7d355cc77c..36ec54127c 100644
--- a/src/Avalonia.Base/Animation/DisposeAnimationInstanceSubject.cs
+++ b/src/Avalonia.Base/Animation/DisposeAnimationInstanceSubject.cs
@@ -12,7 +12,8 @@ namespace Avalonia.Animation
         Animatable control,
         IClock? clock,
         Action? onComplete,
-        bool shouldPauseOnInvisible)
+        bool shouldPauseOnInvisible,
+        Visual? visualTarget)
         : IObserver<bool>, IDisposable
     {
         private IDisposable? _lastInstance;
@@ -41,7 +42,13 @@ namespace Avalonia.Animation
 
                 if (matchVal)
                 {
-                    _lastInstance = animator.Run(animation, control, clock, onComplete, shouldPauseOnInvisible);
+                    _lastInstance = animator.Run(
+                        animation,
+                        control,
+                        clock,
+                        onComplete,
+                        shouldPauseOnInvisible,
+                        visualTarget);
                 }
                 else
                 {
diff --git a/tests/Avalonia.Base.UnitTests/Animation/AnimationIterationTests.cs b/tests/Avalonia.Base.UnitTests/Animation/AnimationIterationTests.cs
index b32cb5a7d1..7a6574d118 100644
--- a/tests/Avalonia.Base.UnitTests/Animation/AnimationIterationTests.cs
+++ b/tests/Avalonia.Base.UnitTests/Animation/AnimationIterationTests.cs
@@ -9,6 +9,7 @@ using System.Threading;
 using System.Reactive.Linq;
 using Avalonia.Data;
 using Avalonia.Layout;
+using Avalonia.Media;
 using Avalonia.UnitTests;
 
 namespace Avalonia.Base.UnitTests.Animation
@@ -159,6 +160,61 @@ namespace Avalonia.Base.UnitTests.Animation
             Assert.True(animationRun.Status == TaskStatus.RanToCompletion);
             Assert.Equal(100d, border.Width);
         }
+
+        [Fact]
+        public void OnlyIfVisible_Resumes_Transform_Animations_With_Visual()
+        {
+            var animation = new Animation
+            {
+                Duration = TimeSpan.FromSeconds(1),
+                IterationCount = IterationCount.Infinite,
+                Easing = new LinearEasing(),
+                PlaybackBehavior = PlaybackBehavior.OnlyIfVisible,
+                Children =
+                {
+                    new KeyFrame
+                    {
+                        Cue = new Cue(0d),
+                        Setters =
+                        {
+                            new Setter(ScaleTransform.ScaleXProperty, 1d),
+                            new Setter(Visual.OpacityProperty, 0.9d),
+                        }
+                    },
+                    new KeyFrame
+                    {
+                        Cue = new Cue(1d),
+                        Setters =
+                        {
+                            new Setter(ScaleTransform.ScaleXProperty, 2.5d),
+                            new Setter(Visual.OpacityProperty, 0d),
+                        }
+                    }
+                }
+            };
+            var border = new Border();
+            var clock = new MockGlobalClock();
+
+            using var subscription = animation.Apply(border, clock, Observable.Return(true), null);
+
+            clock.Pulse(TimeSpan.FromSeconds(0.25));
+
+            var scale = (ScaleTransform)((TransformGroup)border.RenderTransform!).Children[0];
+            var scaleBeforePause = scale.ScaleX;
+            var opacityBeforePause = border.Opacity;
+
+            border.IsVisible = false;
+            clock.Pulse(TimeSpan.FromSeconds(0.75));
+
+            Assert.Equal(scaleBeforePause, scale.ScaleX);
+            Assert.Equal(opacityBeforePause, border.Opacity);
+
+            border.IsVisible = true;
+            clock.Pulse(TimeSpan.FromSeconds(1));
+
+            Assert.Equal(1.375d, scale.ScaleX);
+            Assert.Equal(0.675d, border.Opacity, 10);
+        }
         
         [Fact]
         public void OnlyIfVisible_Pauses_Animation_When_IsEffectivelyVisible_Is_False_Nested()

From af9d9a7d89dc28de56464c6dda113e5f6a76cfe5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E3=81=B7=E3=81=93=E3=82=8B=E3=81=B5?=
 <86549420+puk06@users.noreply.github.com>
Date: Mon, 24 Aug 2026 11:43:22 +0000
Subject: [PATCH 188/196] Fix TextBlock ellipsis not showing with TextWrapping
 and MaxLines (#22017)

* Fix TextBlock ellipsis not showing with TextWrapping and MaxLines

When TextWrapping and MaxLines are set, the collapsing width was using the
layout's maximum width instead of the current line's width. This caused the
ellipsis to not appear when the last line was shorter than other lines.

Also added HasCollapsed check to prevent double-collapsing when text has
already been collapsed due to overflow.

* Remove HasCollapsed check

* Add unit test for MaxLines trailing ellipsis on short wrapped lines

* Remove redundant comment

* fix: simplify TextLayout test
---
 .../Media/TextFormatting/TextLayout.cs        |  2 +-
 .../Media/TextFormatting/TextLayoutTests.cs   | 40 +++++++++++++++++++
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs b/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs
index 4fe887dcbc..9810935c5a 100644
--- a/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs
+++ b/src/Avalonia.Base/Media/TextFormatting/TextLayout.cs
@@ -634,7 +634,7 @@ namespace Avalonia.Media.TextFormatting
                     {
                         if (textLine.TextLineBreak is { IsSplit: true })
                         {
-                            textLines[textLines.Count - 1] = textLine.Collapse(GetCollapsingProperties(WidthIncludingTrailingWhitespace));
+                            textLines[textLines.Count - 1] = textLine.Collapse(GetCollapsingProperties(textLine.WidthIncludingTrailingWhitespace));
                         }
 
                         break;
diff --git a/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLayoutTests.cs b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLayoutTests.cs
index 1c8ad72f0f..e46fa69531 100644
--- a/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLayoutTests.cs
+++ b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLayoutTests.cs
@@ -626,6 +626,46 @@ namespace Avalonia.Skia.UnitTests.Media.TextFormatting
             }
         }
 
+        public static IEnumerable<object[]> MaxLinesEllipsisData
+        {
+            get
+            {
+                yield return new object[] { TextTrimming.CharacterEllipsis };
+                yield return new object[] { TextTrimming.WordEllipsis };
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(MaxLinesEllipsisData))]
+        public void Should_Add_Ellipsis_When_MaxLines_Cuts_Short_Wrapped_Line(TextTrimming trimming)
+        {
+            using (Start())
+            {
+                const string text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
+                const int maxLines = 2;
+
+                var layout = new TextLayout(
+                    text,
+                    Typeface.Default,
+                    12,
+                    Brushes.Black,
+                    textWrapping: TextWrapping.Wrap,
+                    textTrimming: trimming,
+                    maxWidth: 180,
+                    maxLines: maxLines);
+
+                Assert.Equal(maxLines, layout.TextLines.Count);
+
+                var lastLine = layout.TextLines[layout.TextLines.Count - 1];
+                var formattedLineText = string.Concat(lastLine.TextRuns.Select(r => r.Text.ToString()));
+
+                Assert.True(lastLine.HasCollapsed, "The wrapped line cut off by MaxLines must be collapsed.");
+                Assert.Equal('\u2026', formattedLineText.Last());
+
+                layout.Dispose();
+            }
+        }
+
         [Fact]
         public void Should_Produce_Fixed_Height_Lines()
         {

From 7c4123f2f3cfadeeec04b5658fac8140b96278de Mon Sep 17 00:00:00 2001
From: Ronny <ronny.cohen@artonik.com>
Date: Mon, 24 Aug 2026 13:32:54 +0000
Subject: [PATCH 189/196] Android: unregister automation peers when their
 control leaves the visual tree (#22024)

AvaloniaAccessHelper keeps every automation peer it has ever handed to
Android in three dictionaries (_peers, _peerIds, _peerNodeInfoProviders)
and never removes any of them - the file contains no Remove or Clear call.
Each ControlAutomationPeer holds a strong reference to its Owner, so once
accessibility has explored a control, that control (and the visual tree
hanging off it) is pinned for the lifetime of the AvaloniaView.

This is invisible in an app with a static UI, but it is unbounded in one
that rebuilds its visual tree: on a digital-signage device rebuilding its
screen every 20-40 s, this retained one full dead screen per rebuild -
about 2.5 MB of live managed heap each time, measured after a forced
gen2 collection, growing until the low-memory killer stepped in.
Removing the stale entries brought the same bench from unbounded growth
to a flat plateau over 28 consecutive rebuilds.

The registration is now dropped when the peer's control is detached from
the visual tree, and the two peer event handlers are unsubscribed at the
same time (they were never removed either).

Virtual view IDs are now allocated from a monotonic counter instead of
being derived from _peerNodeInfoProviders.Count. That was safe only while
nothing was ever removed: with removal, Count can fall back onto an ID
that is still in use and the next registration would throw from
Dictionary.Add inside an accessibility callback.

The root peer (ID 0) is deliberately left registered: GetVirtualViewAt and
GetVisibleVirtualViews index _peers[0] directly, so removing it would
throw. It is a single entry, owned by the view, and dies with the helper.
---
 .../Avalonia.Android/AvaloniaAccessHelper.cs  | 45 +++++++++++++++++--
 1 file changed, 41 insertions(+), 4 deletions(-)

diff --git a/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs b/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
index 2943e13a21..0bec287fed 100644
--- a/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
+++ b/src/Android/Avalonia.Android/AvaloniaAccessHelper.cs
@@ -49,6 +49,14 @@ namespace Avalonia.Android
 
         private readonly Dictionary<AutomationPeer, HashSet<INodeInfoProvider>> _peerNodeInfoProviders;
 
+        /// <remarks>
+        /// Virtual view IDs must be allocated from a monotonic counter rather than derived from
+        /// the size of <see cref="_peerNodeInfoProviders"/>: entries are now removed when their
+        /// owner leaves the visual tree, so the dictionary's count no longer grows monotonically
+        /// and reusing it would hand out an ID that is still in use.
+        /// </remarks>
+        private int _nextPeerViewId;
+
         private readonly AvaloniaView _view;
 
         public AvaloniaAccessHelper(AvaloniaView view) : base(view)
@@ -85,16 +93,16 @@ namespace Avalonia.Android
             }
             else
             {
-                peerViewId = _peerNodeInfoProviders.Count;
+                peerViewId = _nextPeerViewId++;
                 _peers.Add(peerViewId, peer);
                 _peerIds.Add(peer, peerViewId);
 
                 nodeInfoProviders = new();
                 _peerNodeInfoProviders.Add(peer, nodeInfoProviders);
 
-                peer.ChildrenChanged += (s, ev) => InvalidateVirtualView(peerViewId,
+                EventHandler childrenChanged = (s, ev) => InvalidateVirtualView(peerViewId,
                     AccessibilityEventCompat.ContentChangeTypeSubtree);
-                peer.PropertyChanged += (s, ev) =>
+                EventHandler<AutomationPropertyChangedEventArgs> propertyChanged = (s, ev) =>
                 {
                     if (ev.Property == AutomationElementIdentifiers.NameProperty)
                     {
@@ -104,13 +112,42 @@ namespace Avalonia.Android
                     {
                         InvalidateVirtualView(peerViewId, AccessibilityEventCompat.ContentChangeTypeContentDescription);
                     }
-                    else if (ev.Property == AutomationElementIdentifiers.BoundingRectangleProperty || 
+                    else if (ev.Property == AutomationElementIdentifiers.BoundingRectangleProperty ||
                         ev.Property == AutomationElementIdentifiers.ClassNameProperty)
                     {
                         InvalidateVirtualView(peerViewId);
                     }
                 };
 
+                peer.ChildrenChanged += childrenChanged;
+                peer.PropertyChanged += propertyChanged;
+
+                // Drop the registration once the peer's control leaves the visual tree, otherwise
+                // every control ever explored by accessibility is kept alive for the lifetime of
+                // the view: the peer holds a strong reference to its Owner, and these three
+                // dictionaries were never pruned. On a long-running app that rebuilds its UI (for
+                // instance digital signage swapping screens), this retains each dead visual tree in
+                // full — measured at ~2.5 MB per rebuild on a real device.
+                // The root peer (ID 0) is deliberately never unregistered: GetVirtualViewAt and
+                // GetVisibleVirtualViews index _peers[0] directly, so removing it would throw.
+                // It is a single entry owned by the view itself, and dies with the helper.
+                if (peerViewId != 0 && peer is ControlAutomationPeer controlPeer)
+                {
+                    EventHandler<VisualTreeAttachmentEventArgs>? detachedFromVisualTree = null;
+                    detachedFromVisualTree = (s, ev) =>
+                    {
+                        controlPeer.Owner.DetachedFromVisualTree -= detachedFromVisualTree;
+                        peer.ChildrenChanged -= childrenChanged;
+                        peer.PropertyChanged -= propertyChanged;
+
+                        _peers.Remove(peerViewId);
+                        _peerIds.Remove(peer);
+                        _peerNodeInfoProviders.Remove(peer);
+                    };
+
+                    controlPeer.Owner.DetachedFromVisualTree += detachedFromVisualTree;
+                }
+
                 if (peer.GetProvider<IExpandCollapseProvider>() is not null)
                     nodeInfoProviders.Add(new ExpandCollapseNodeInfoProvider(this, peer, peerViewId));
                 if (peer.GetProvider<IInvokeProvider>() is not null)

From 7f456057cdad1c64253d208091112f63bca7456f Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Mon, 24 Aug 2026 13:41:38 +0000
Subject: [PATCH 190/196] Raise TopLevel.Closed from managed Dispose() paths
 (#22045)

TopLevel teardown (HandleClosed) was only ever triggered by the backend
invoking ITopLevelImpl.Closed. Browser, iOS, Android, macOS and the offscreen
(designer previewer) impls never raise it from Dispose(), so
EmbeddableControlRoot.Closed was never raised there and StopRendering() was
never reached - the top level stayed registered in MediaContext forever.

Make teardown idempotent behind EnsureClosed() and call it from the managed
Dispose() paths (EmbeddableControlRoot, OffscreenTopLevel, PopupRoot). The
guard lives in a new non-virtual entry point because WindowBase and Window
override HandleClosed and run side effects before calling base.

Also drop ChoreographerTimer's view-visibility gate on Android. It predates
the render timer rewrite and vetoed ticks that DefaultRenderLoop had explicitly
asked for, so the synchronous compositor round-trip in HandleClosed
(Renderer.Dispose -> MediaContext.SyncDisposeCompositionTarget) could never
complete once the view had unsubscribed - deadlocking every activity destroy.
DefaultRenderLoop already owns the sleep/wake state machine, driven by
StartRendering/StopRendering, which makes the extra gate redundant.

Verified at runtime on X11, Wayland, Win32, macOS, Headless, Browser (WASM),
Android and iOS: Closed fires exactly once per teardown, MediaContext returns
to baseline, and platform-initiated closes still fire exactly once.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/Android/Avalonia.Android/AvaloniaView.cs  | 15 ++--
 .../Avalonia.Android/ChoreographerTimer.cs    | 22 +-----
 .../Embedding/EmbeddableControlRoot.cs        |  2 +-
 .../Embedding/Offscreen/OffscreenTopLevel.cs  |  1 +
 src/Avalonia.Controls/Primitives/PopupRoot.cs |  1 +
 src/Avalonia.Controls/TopLevel.cs             | 15 +++-
 .../TopLevelTests.cs                          | 76 +++++++++++++++++++
 7 files changed, 99 insertions(+), 33 deletions(-)

diff --git a/src/Android/Avalonia.Android/AvaloniaView.cs b/src/Android/Avalonia.Android/AvaloniaView.cs
index b2decd5fa2..96a95b8a12 100644
--- a/src/Android/Avalonia.Android/AvaloniaView.cs
+++ b/src/Android/Avalonia.Android/AvaloniaView.cs
@@ -23,7 +23,7 @@ namespace Avalonia.Android
         private readonly ViewImpl _view;
         private readonly ExploreByTouchHelper _accessHelper;
 
-        private IDisposable? _timerSubscription;
+        private bool _isRendering;
         private bool _surfaceCreated;
 
         public AvaloniaView(Context context) : base(context)
@@ -106,13 +106,9 @@ namespace Avalonia.Android
             if (_root == null || !_surfaceCreated)
                 return;
 
-            if (isVisible && _timerSubscription == null)
+            if (isVisible && !_isRendering)
             {
-                if (AndroidPlatform.Timer is { } timer)
-                {
-                    _timerSubscription = timer.SubscribeView(this);
-                }
-
+                _isRendering = true;
                 _root.StartRendering();
 
                 if (_view.TryGetFeature<IInsetsManager>(out var insetsManager) == true)
@@ -120,11 +116,10 @@ namespace Avalonia.Android
                     (insetsManager as AndroidInsetsManager)?.ApplyStatusBarState();
                 }
             }
-            else if (!isVisible && _timerSubscription != null)
+            else if (!isVisible && _isRendering)
             {
+                _isRendering = false;
                 _root.StopRendering();
-                _timerSubscription?.Dispose();
-                _timerSubscription = null;
             }
         }
 
diff --git a/src/Android/Avalonia.Android/ChoreographerTimer.cs b/src/Android/Avalonia.Android/ChoreographerTimer.cs
index 9bc8e78a52..d31a0aa915 100644
--- a/src/Android/Avalonia.Android/ChoreographerTimer.cs
+++ b/src/Android/Avalonia.Android/ChoreographerTimer.cs
@@ -1,9 +1,7 @@
 using System;
-using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
-using Avalonia.Reactive;
 using Avalonia.Rendering;
 using static Avalonia.Android.Platform.SkiaPlatform.AndroidFramebuffer;
 
@@ -17,7 +15,6 @@ namespace Avalonia.Android
         private readonly TaskCompletionSource<IntPtr> _choreographer = new();
         private readonly AutoResetEvent _event = new(false);
         private readonly GCHandle _timerHandle;
-        private readonly HashSet<AvaloniaView> _views = new();
         private Action<TimeSpan>? _tick;
         private bool _pendingCallback;
         private long _lastTime;
@@ -49,23 +46,6 @@ namespace Avalonia.Android
             }
         }
 
-        internal IDisposable SubscribeView(AvaloniaView view)
-        {
-            lock (_lock)
-            {
-                _views.Add(view);
-                PostFrameCallbackIfNeeded();
-            }
-
-            return Disposable.Create(
-                () =>
-                {
-                    lock (_lock) 
-                        _views.Remove(view);
-                }
-            );
-        }
-
         private void Loop()
         {
             Looper.Prepare();
@@ -94,7 +74,7 @@ namespace Avalonia.Android
                 if(_pendingCallback)
                     return;
                 
-                if (_tick == null || _views.Count == 0)
+                if (_tick == null)
                     return;
 
                 _pendingCallback = true;
diff --git a/src/Avalonia.Controls/Embedding/EmbeddableControlRoot.cs b/src/Avalonia.Controls/Embedding/EmbeddableControlRoot.cs
index 59718c3e3f..b65db54a93 100644
--- a/src/Avalonia.Controls/Embedding/EmbeddableControlRoot.cs
+++ b/src/Avalonia.Controls/Embedding/EmbeddableControlRoot.cs
@@ -69,7 +69,7 @@ namespace Avalonia.Controls.Embedding
         public void Dispose()
         {
             PlatformImpl?.Dispose();
-            LayoutManager?.Dispose();
+            EnsureClosed();
         }
     }
 }
diff --git a/src/Avalonia.Controls/Embedding/Offscreen/OffscreenTopLevel.cs b/src/Avalonia.Controls/Embedding/Offscreen/OffscreenTopLevel.cs
index a87e36d00d..65ca492f1f 100644
--- a/src/Avalonia.Controls/Embedding/Offscreen/OffscreenTopLevel.cs
+++ b/src/Avalonia.Controls/Embedding/Offscreen/OffscreenTopLevel.cs
@@ -35,6 +35,7 @@ namespace Avalonia.Controls.Embedding.Offscreen
         public void Dispose()
         {
             PlatformImpl?.Dispose();
+            EnsureClosed();
         }
     }
 }
diff --git a/src/Avalonia.Controls/Primitives/PopupRoot.cs b/src/Avalonia.Controls/Primitives/PopupRoot.cs
index 93a30b06a3..234f47258d 100644
--- a/src/Avalonia.Controls/Primitives/PopupRoot.cs
+++ b/src/Avalonia.Controls/Primitives/PopupRoot.cs
@@ -126,6 +126,7 @@ namespace Avalonia.Controls.Primitives
         public void Dispose()
         {
             PlatformImpl?.Dispose();
+            EnsureClosed();
         }
 
         private void UpdatePosition()
diff --git a/src/Avalonia.Controls/TopLevel.cs b/src/Avalonia.Controls/TopLevel.cs
index ac5f6693e8..2fd1524cef 100644
--- a/src/Avalonia.Controls/TopLevel.cs
+++ b/src/Avalonia.Controls/TopLevel.cs
@@ -123,6 +123,7 @@ namespace Avalonia.Controls
         private readonly IDisposable? _backGestureSubscription;
         private readonly Dictionary<AvaloniaProperty, Action> _platformImplBindings = new();
         private double _scaling;
+        private bool _isClosed;
         private Size _clientSize;
         private Size? _frameSize;
         private WindowTransparencyLevel _actualTransparencyLevel;
@@ -233,7 +234,7 @@ namespace Avalonia.Controls
 
 
 
-            impl.Closed = HandleClosed;
+            impl.Closed = EnsureClosed;
             impl.Paint = HandlePaint;
             impl.Resized = HandleResized;
             impl.ScalingChanged += HandleScalingChanged;
@@ -661,6 +662,18 @@ namespace Avalonia.Controls
 
         private protected void StopRendering() => MediaContext.Instance.RemoveTopLevel(this);
 
+        /// <summary>
+        /// Runs the top level teardown exactly once, no matter whether it was initiated by the
+        /// platform via <see cref="ITopLevelImpl.Closed"/> or by a managed <c>Dispose()</c>.
+        /// </summary>
+        private protected void EnsureClosed()
+        {
+            if (_isClosed)
+                return;
+            _isClosed = true;
+            HandleClosed();
+        }
+
         /// <summary>
         /// Handles a closed notification from <see cref="ITopLevelImpl.Closed"/>.
         /// </summary>
diff --git a/tests/Avalonia.Controls.UnitTests/TopLevelTests.cs b/tests/Avalonia.Controls.UnitTests/TopLevelTests.cs
index 15c1f650da..d48f69e710 100644
--- a/tests/Avalonia.Controls.UnitTests/TopLevelTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/TopLevelTests.cs
@@ -1,4 +1,5 @@
 using System;
+using Avalonia.Controls.Embedding;
 using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Templates;
 using Avalonia.Input;
@@ -166,6 +167,81 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Impl_Close_Should_Raise_Closed_Event_Only_Once()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var impl = CreateMockTopLevelImpl(true);
+
+                var raised = 0;
+                var target = new TestTopLevel(impl.Object);
+                target.Closed += (s, e) => raised++;
+
+                impl.Object.Closed!();
+                impl.Object.Closed!();
+
+                Assert.Equal(1, raised);
+            }
+        }
+
+        [Fact]
+        public void EmbeddableControlRoot_Dispose_Should_Raise_Closed_Event()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var impl = CreateMockTopLevelImpl(true);
+
+                var raised = 0;
+                var target = new EmbeddableControlRoot(impl.Object);
+                target.Closed += (s, e) => raised++;
+
+                target.Dispose();
+
+                Assert.Equal(1, raised);
+            }
+        }
+
+        [Fact]
+        public void EmbeddableControlRoot_Dispose_After_Impl_Close_Should_Raise_Closed_Event_Only_Once()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var impl = CreateMockTopLevelImpl(true);
+
+                var raised = 0;
+                var target = new EmbeddableControlRoot(impl.Object);
+                target.Closed += (s, e) => raised++;
+
+                impl.Object.Closed!();
+                target.Dispose();
+
+                Assert.Equal(1, raised);
+            }
+        }
+
+        [Fact]
+        public void EmbeddableControlRoot_Dispose_Should_Dispose_Impl_Before_Teardown()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var impl = CreateMockTopLevelImpl(true);
+
+                var closedRaised = false;
+                var implDisposedBeforeClosed = false;
+                impl.Setup(x => x.Dispose()).Callback(() => implDisposedBeforeClosed = !closedRaised);
+
+                var target = new EmbeddableControlRoot(impl.Object);
+                target.Closed += (s, e) => closedRaised = true;
+
+                target.Dispose();
+
+                impl.Verify(x => x.Dispose(), Times.Once);
+                Assert.True(implDisposedBeforeClosed);
+                Assert.True(closedRaised);
+            }
+        }
+
         [Fact]
         public void Impl_Close_Should_Raise_DetachedFromLogicalTree_Event()
         {

From 7f8dd8e6bd5557fb30f935c261db05acd38821b5 Mon Sep 17 00:00:00 2001
From: Yoyo <zrt2399@163.com>
Date: Mon, 24 Aug 2026 15:26:58 +0000
Subject: [PATCH 191/196] Fix VirtualizingStackPanel ScrollToEnd with
 variable-sized items (#22014)

* Fix VirtualizingStackPanel ScrollToEnd with variable-sized items

* Refine VirtualizingStackPanel ScrollToEnd regression test

Keep the initial viewport before the variable-sized trailing items and exercise ScrollToEnd directly.

---------

Co-authored-by: Emmanuel Hansen <emmausssss@gmail.com>
---
 .../VirtualizingStackPanel.cs                 | 21 +++++++
 .../VirtualizingStackPanelTests.cs            | 59 +++++++++++++++++++
 2 files changed, 80 insertions(+)

diff --git a/src/Avalonia.Controls/VirtualizingStackPanel.cs b/src/Avalonia.Controls/VirtualizingStackPanel.cs
index 62010aecc4..fbb9c83de2 100644
--- a/src/Avalonia.Controls/VirtualizingStackPanel.cs
+++ b/src/Avalonia.Controls/VirtualizingStackPanel.cs
@@ -836,6 +836,18 @@ namespace Avalonia.Controls
                 return;
             }
 
+            var horizontal = Orientation == Orientation.Horizontal;
+            var viewportEnd = horizontal ? _viewport.Right : _viewport.Bottom;
+
+            if (!_hasReachedEnd && MathUtilities.GreaterThanOrClose(
+                viewportEnd,
+                horizontal ? Bounds.Width : Bounds.Height))
+            {
+                index = itemCount - 1;
+                position = viewportEnd - EstimateElementSizeU();
+                return;
+            }
+
             // If we have realised elements and a valid StartU then try to use this information to
             // get the anchor element.
             if (_realizedElements?.StartU is { } u && !double.IsNaN(u))
@@ -925,6 +937,9 @@ namespace Avalonia.Controls
             var index = viewport.anchorIndex;
             var horizontal = Orientation == Orientation.Horizontal;
             var u = viewport.anchorU;
+            var viewportEnd = horizontal ? _viewport.Right : _viewport.Bottom;
+            var anchorAtEnd = !_hasReachedEnd && index == items.Count - 1 &&
+                MathUtilities.GreaterThanOrClose(viewportEnd, horizontal ? Bounds.Width : Bounds.Height);
                     
             // Reset boundary flags
             _hasReachedStart = false;
@@ -947,6 +962,12 @@ namespace Avalonia.Controls
                 var sizeU = horizontal ? e.DesiredSize.Width : e.DesiredSize.Height;
                 var sizeV = horizontal ? e.DesiredSize.Height : e.DesiredSize.Width;
 
+                if (anchorAtEnd && index == viewport.anchorIndex)
+                {
+                    u = viewportEnd - sizeU;
+                    viewport.anchorU = u;
+                }
+
                 _measureElements!.Add(index, e, u, sizeU);
                 viewport.measuredV = Math.Max(viewport.measuredV, sizeV);
 
diff --git a/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs b/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs
index f9d079835d..10584cd3f9 100644
--- a/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/VirtualizingStackPanelTests.cs
@@ -140,6 +140,38 @@ namespace Avalonia.Controls.UnitTests
             AssertRealizedItems(target, itemsControl, expectedFirstIndex, expectedCount);
         }
 
+        [Theory]
+        [InlineData(Orientation.Vertical, 0d)]
+        [InlineData(Orientation.Vertical, 0.5d)]
+        [InlineData(Orientation.Horizontal, 0d)]
+        [InlineData(Orientation.Horizontal, 0.5d)]
+        public void ScrollToEnd_Arrives_At_End_When_Items_Have_Different_Sizes(Orientation orientation, double bufferFactor)
+        {
+            using var app = App();
+            var horizontal = orientation == Orientation.Horizontal;
+            var items = Enumerable.Range(0, 100)
+                .Select(x => horizontal ? (object)new ItemWithWidth(x, x < 60 ? 20 : 50) : new ItemWithHeight(x, x < 60 ? 20 : 50))
+                .ToList();
+            var (target, scroll, itemsControl) = CreateUnrootedTarget<ItemsControl>(
+                items: items,
+                itemTemplate: horizontal ? CanvasWithWidthTemplate : CanvasWithHeightTemplate,
+                orientation: orientation,
+                bufferFactor: bufferFactor);
+            scroll.Template = ScrollViewerTemplateWithScrollBars();
+            CreateRoot(itemsControl).LayoutManager.ExecuteInitialLayoutPass();
+
+            (horizontal ? scroll.HorizontalScrollBar : scroll.VerticalScrollBar)?.ScrollToEnd();
+            Layout(target);
+
+            Assert.Equal(
+                horizontal ? scroll.Extent.Width - scroll.Viewport.Width : scroll.Extent.Height - scroll.Viewport.Height,
+                horizontal ? scroll.Offset.X : scroll.Offset.Y);
+            Assert.Equal(items.Count - 1, target.LastRealizedIndex);
+            Assert.Equal(
+                horizontal ? target.ViewPort.Right : target.ViewPort.Bottom,
+                horizontal ? target.GetRealizedElements().Last()!.Bounds.Right : target.GetRealizedElements().Last()!.Bounds.Bottom);
+        }
+
         [Theory]
         [InlineData(0d, 10)]
         [InlineData(0.5d, 20)]
@@ -2536,6 +2568,33 @@ namespace Avalonia.Controls.UnitTests
                 }.RegisterInNameScope(ns));
         }
 
+        private static IControlTemplate ScrollViewerTemplateWithScrollBars()
+        {
+            return new FuncControlTemplate<ScrollViewer>((_, ns) =>
+            {
+                var presenter = new ScrollContentPresenter
+                {
+                    Name = "PART_ScrollContentPresenter",
+                }.RegisterInNameScope(ns);
+
+                var horizontalScrollBar = new ScrollBar
+                {
+                    Name = "PART_HorizontalScrollBar",
+                    Orientation = Orientation.Horizontal,
+                    VerticalAlignment = VerticalAlignment.Bottom
+                }.RegisterInNameScope(ns);
+
+                var verticalScrollBar = new ScrollBar
+                {
+                    Name = "PART_VerticalScrollBar",
+                    Orientation = Orientation.Vertical,
+                    HorizontalAlignment = HorizontalAlignment.Right
+                }.RegisterInNameScope(ns);
+
+                return new Panel { Children = { presenter, horizontalScrollBar, verticalScrollBar } };
+            });
+        }
+
         private static IDisposable App() => UnitTestApplication.Start(TestServices.RealFocus);
 
         private class ItemWithHeight : NotifyingBase

From f43b77e52f51530748cb55972ed285bf1e712a24 Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Mon, 24 Aug 2026 15:40:33 +0000
Subject: [PATCH 192/196] Fix TreeViewItem.BringIntoView (#21918)

---
 src/Avalonia.Controls/TreeViewItem.cs         |  13 +-
 .../TreeViewBringIntoViewTests.cs             | 122 ++++++++++++++++++
 2 files changed, 134 insertions(+), 1 deletion(-)
 create mode 100644 tests/Avalonia.Controls.UnitTests/TreeViewBringIntoViewTests.cs

diff --git a/src/Avalonia.Controls/TreeViewItem.cs b/src/Avalonia.Controls/TreeViewItem.cs
index 8c6a17a429..d51e72dc3b 100644
--- a/src/Avalonia.Controls/TreeViewItem.cs
+++ b/src/Avalonia.Controls/TreeViewItem.cs
@@ -198,7 +198,7 @@ namespace Avalonia.Controls
 
                     if (m.HasValue)
                     {
-                        var bounds = new Rect(_header.Bounds.Size);
+                        var bounds = new Rect(GetHeaderTargetSize(_header));
                         var rect = bounds.TransformToAABB(m.Value);
                         e.TargetRect = rect;
                     }
@@ -206,6 +206,17 @@ namespace Avalonia.Controls
             }
         }
 
+        private static Size GetHeaderTargetSize(Control header)
+        {
+            // Use the DesiredWidth, not Bounds.Width: the latter is stretched to the full width of the tree view's extent,
+            // preventing scrolling, whereas the desired size is what the header actually needs.
+            var margin = header.Margin;
+            var desiredWidth = header.DesiredSize.Width - margin.Left - margin.Right;
+            var boundsSize = header.Bounds.Size;
+
+            return boundsSize.WithWidth(Math.Clamp(desiredWidth, 0.0, boundsSize.Width));
+        }
+
         /// <inheritdoc/>
         protected override void OnKeyDown(KeyEventArgs e)
         {
diff --git a/tests/Avalonia.Controls.UnitTests/TreeViewBringIntoViewTests.cs b/tests/Avalonia.Controls.UnitTests/TreeViewBringIntoViewTests.cs
new file mode 100644
index 0000000000..c0c4c914b9
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/TreeViewBringIntoViewTests.cs
@@ -0,0 +1,122 @@
+using System.Linq;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Themes.Simple;
+using Avalonia.UnitTests;
+using Avalonia.VisualTree;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests;
+
+public class TreeViewBringIntoViewTests : ScopedTestBase
+{
+    [Fact]
+    public void BringIntoView_Should_Scroll_Back_To_Item_Scrolled_Off_To_The_Left()
+    {
+        using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+        var (root, treeView) = CreateTarget([CreateHeader(100), CreateHeader(500), CreateHeader(900)]);
+
+        root.LayoutManager.ExecuteInitialLayoutPass();
+
+        var scrollViewer = GetScrollViewer(treeView);
+
+        scrollViewer.Offset = new Vector(scrollViewer.Extent.Width - scrollViewer.Viewport.Width, 0);
+        root.LayoutManager.ExecuteLayoutPass();
+
+        var startOffset = scrollViewer.Offset.X;
+        Assert.True(startOffset > 0);
+
+        // The first item is narrow and now completely off to the left:
+        // bringing it into view must scroll back so that its header becomes visible.
+        var item = Assert.IsType<TreeViewItem>(treeView.ContainerFromIndex(0));
+        item.BringIntoView();
+        root.LayoutManager.ExecuteLayoutPass();
+
+        Assert.True(scrollViewer.Offset.X < 30);
+    }
+
+    [Fact]
+    public void BringIntoView_Should_Not_Scroll_When_Item_Is_Already_Visible()
+    {
+        using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+        var (root, treeView) = CreateTarget([CreateHeader(100), CreateHeader(500), CreateHeader(900)]);
+
+        root.LayoutManager.ExecuteInitialLayoutPass();
+
+        var scrollViewer = GetScrollViewer(treeView);
+        Assert.Equal(0, scrollViewer.Offset.X);
+
+        var item = Assert.IsType<TreeViewItem>(treeView.ContainerFromIndex(0));
+        item.BringIntoView();
+        root.LayoutManager.ExecuteLayoutPass();
+
+        Assert.Equal(0, scrollViewer.Offset.X);
+    }
+
+    [Fact]
+    public void BringIntoView_Should_Reveal_A_Nested_Item()
+    {
+        using var app = UnitTestApplication.Start(TestServices.StyledWindow);
+
+        // A narrow item nested three levels deep, under wide ancestors that make the tree scroll.
+        var nestedHeader = CreateHeader(100);
+        var nestedItem = new TreeViewItem { Header = nestedHeader };
+        var item = nestedItem;
+
+        for (var i = 0; i < 3; i++)
+        {
+            item = new TreeViewItem
+            {
+                Header = CreateHeader(900),
+                IsExpanded = true,
+                ItemsSource = new[] { item }
+            };
+        }
+
+        var (root, treeView) = CreateTarget([item]);
+
+        root.LayoutManager.ExecuteInitialLayoutPass();
+
+        var scrollViewer = GetScrollViewer(treeView);
+
+        scrollViewer.Offset = new Vector(scrollViewer.Extent.Width - scrollViewer.Viewport.Width, 0);
+        root.LayoutManager.ExecuteLayoutPass();
+        Assert.True(scrollViewer.Offset.X > 0);
+
+        nestedItem.BringIntoView();
+        root.LayoutManager.ExecuteLayoutPass();
+
+        var headerBounds = new Rect(nestedHeader.Bounds.Size).TransformToAABB(nestedHeader.TransformToVisual(scrollViewer)!.Value);
+
+        Assert.True(headerBounds.Left >= -0.5 && headerBounds.Right <= scrollViewer.Viewport.Width + 0.5);
+    }
+
+    private static Border CreateHeader(double width) => new()
+    {
+        Width = width,
+        Height = 20,
+        HorizontalAlignment = HorizontalAlignment.Left,
+        Background = Brushes.Red
+    };
+
+    private static (TestRoot Root, TreeView TreeView) CreateTarget(Control[] headers)
+    {
+        var treeView = new TreeView
+        {
+            Width = 400,
+            Height = 200,
+            ItemsSource = headers
+        };
+
+        var root = new TestRoot { Width = 400, Height = 200 };
+        root.Resources.MergedDictionaries.Add(new SimpleTheme());
+        root.Child = treeView;
+
+        return (root, treeView);
+    }
+
+    private static ScrollViewer GetScrollViewer(TreeView treeView)
+        => treeView.GetVisualDescendants().OfType<ScrollViewer>().Single();
+}

From f1e09e4e319f8e0bc443e5675b384d015a179d60 Mon Sep 17 00:00:00 2001
From: Yoyo <zrt2399@163.com>
Date: Mon, 24 Aug 2026 16:05:45 +0000
Subject: [PATCH 193/196] Fix DatePicker and TimePicker separator alignment
 with VerticalContentAlignment (#22023)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Fix DatePicker and TimePicker separator alignment with VerticalContentAlignment

* Fix DatePicker and TimePicker separator alignment in Simple Theme

---------

Co-authored-by: Javier Suárez <javiersuarezruiz@hotmail.com>
---
 src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml | 6 +++++-
 src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml | 6 +++++-
 src/Avalonia.Themes.Simple/Controls/DatePicker.xaml | 7 +++++--
 src/Avalonia.Themes.Simple/Controls/TimePicker.xaml | 6 +++++-
 4 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml b/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml
index d7bb32fb43..52c63f8e22 100644
--- a/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/DatePicker.xaml
@@ -98,7 +98,7 @@
                     HorizontalAlignment="Stretch"
                     VerticalAlignment="Stretch"
                     TemplatedControl.IsTemplateFocusTarget="True">
-              <Grid Name="PART_ButtonContentGrid" ColumnDefinitions="78*,Auto,132*,Auto,78*" VerticalAlignment="{TemplateBinding VerticalContentAlignment}">
+              <Grid Name="PART_ButtonContentGrid" ColumnDefinitions="78*,Auto,132*,Auto,78*">
                 <TextBlock Name="PART_DayTextBlock" Text="{DynamicResource StringDatePickerDayText}" HorizontalAlignment="Center"
                            Padding="{DynamicResource DatePickerHostPadding}" />
                 <TextBlock Name="PART_MonthTextBlock" Text="{DynamicResource StringDatePickerMonthText}" TextAlignment="Left"
@@ -133,6 +133,10 @@
       <Setter Property="Fill" Value="{DynamicResource DatePickerSpacerFillDisabled}"/>
     </Style>
 
+    <Style Selector="^ /template/ Button#PART_FlyoutButton TextBlock">
+      <Setter Property="VerticalAlignment" Value="{TemplateBinding VerticalContentAlignment}"/>
+    </Style>
+
     <!-- Changes foreground for watermark text when SelectedDate is null-->
     <Style Selector="^:hasnodate /template/ Button#PART_FlyoutButton TextBlock">
       <Setter Property="Foreground" Value="{DynamicResource TextControlPlaceholderForeground}"/>
diff --git a/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml b/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
index 81c31fecda..e5fb28b609 100644
--- a/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
+++ b/src/Avalonia.Themes.Fluent/Controls/TimePicker.xaml
@@ -97,7 +97,7 @@
                     HorizontalAlignment="Stretch"
                     VerticalAlignment="Stretch">
 
-              <Grid Name="PART_FlyoutButtonContentGrid" VerticalAlignment="{TemplateBinding VerticalContentAlignment}">
+              <Grid Name="PART_FlyoutButtonContentGrid">
                 <!--Ignore col defs here, set in code-->
                 <Border x:Name="PART_FirstPickerHost"
                         Grid.Column="0"
@@ -175,6 +175,10 @@
       <Setter Property="Fill" Value="{DynamicResource TimePickerSpacerFillDisabled}"/>
     </Style>
 
+    <Style Selector="^ /template/ Button#PART_FlyoutButton TextBlock">
+      <Setter Property="VerticalAlignment" Value="{TemplateBinding VerticalContentAlignment}"/>
+    </Style>
+
     <Style Selector="^:hasnotime /template/ Button#PART_FlyoutButton TextBlock">
       <Setter Property="Foreground" Value="{DynamicResource TextControlPlaceholderForeground}"/>
     </Style>
diff --git a/src/Avalonia.Themes.Simple/Controls/DatePicker.xaml b/src/Avalonia.Themes.Simple/Controls/DatePicker.xaml
index f7cf34d0dc..45d895541d 100644
--- a/src/Avalonia.Themes.Simple/Controls/DatePicker.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/DatePicker.xaml
@@ -106,8 +106,7 @@
                     TemplatedControl.IsTemplateFocusTarget="True"
                     Theme="{StaticResource SimpleDatePickerFlyoutButton}">
               <Grid Name="PART_ButtonContentGrid"
-                    ColumnDefinitions="78*,Auto,132*,Auto,78*"
-                    VerticalAlignment="{TemplateBinding VerticalContentAlignment}">
+                    ColumnDefinitions="78*,Auto,132*,Auto,78*">
                 <TextBlock Name="PART_DayTextBlock"
                            Padding="{DynamicResource DatePickerHostPadding}"
                            HorizontalAlignment="Center"
@@ -159,6 +158,10 @@
       <Setter Property="Opacity" Value="{DynamicResource ThemeDisabledOpacity}" />
     </Style>
 
+    <Style Selector="^ /template/ Button#PART_FlyoutButton TextBlock">
+      <Setter Property="VerticalAlignment" Value="{TemplateBinding VerticalContentAlignment}"/>
+    </Style>
+
     <!--  Changes foreground for watermark text when SelectedDate is null  -->
     <Style Selector="^:hasnodate /template/ Button#PART_FlyoutButton TextBlock">
       <Setter Property="Foreground" Value="{DynamicResource ThemeForegroundLowBrush}" />
diff --git a/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml b/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml
index 3c95d9f63c..53fa121663 100644
--- a/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml
+++ b/src/Avalonia.Themes.Simple/Controls/TimePicker.xaml
@@ -103,7 +103,7 @@
                     IsEnabled="{TemplateBinding IsEnabled}"
                     Theme="{StaticResource SimpleTimePickerFlyoutButton}">
 
-              <Grid Name="PART_FlyoutButtonContentGrid" VerticalAlignment="{TemplateBinding VerticalContentAlignment}">
+              <Grid Name="PART_FlyoutButtonContentGrid">
                 <!--  Ignore col defs here, set in code  -->
                 <Border x:Name="PART_FirstPickerHost"
                         Grid.Column="0"
@@ -192,6 +192,10 @@
     <Style Selector="^:disabled /template/ Rectangle">
       <Setter Property="Opacity" Value="{DynamicResource ThemeDisabledOpacity}" />
     </Style>
+    
+    <Style Selector="^ /template/ Button#PART_FlyoutButton TextBlock">
+      <Setter Property="VerticalAlignment" Value="{TemplateBinding VerticalContentAlignment}"/>
+    </Style>
 
     <Style Selector="^:hasnotime /template/ Button#PART_FlyoutButton TextBlock">
       <Setter Property="Foreground" Value="{DynamicResource ThemeForegroundLowBrush}" />

From 6074f9cce230cd2fb54481a73709d3b7660fd774 Mon Sep 17 00:00:00 2001
From: Nathan Nguyen <nathannguyen927151@gmail.com>
Date: Mon, 24 Aug 2026 17:09:00 +0000
Subject: [PATCH 194/196] Fix vector geometry anti-aliasing regression by
 making stencil buffers opt-in (#21899)

* Add failing test for stencil buffer default, single-source the policy

Stencil buffer selection was duplicated as `useStencilBuffers == false` across the
GL, Metal and Vulkan backends, so there was no single place to review or test the
default. Move it to SkiaOptions.ShouldAvoidStencilBuffers and add a test asserting
the contract the default should honour. The test fails at this commit.

* Avoid stencil buffers unless explicitly enabled

Enabling stencil buffers lets Skia select multisample-based path rendering, which
quantizes edge coverage instead of computing analytic coverage. Vector geometry
therefore rasterizes with visibly softer, rougher edges on GPU backends, most
noticeably on small icons. Text is unaffected because glyphs are drawn from the
mask atlas rather than the path renderer.

Make the null default avoid stencil buffers again, restoring 12.0.5 rendering.
Applications that want the faster clipping can still opt in explicitly with
SkiaOptions.UseStencilBuffers = true.

Fixes #21760
---
 .../Avalonia.Skia/Gpu/Metal/SkiaMetalGpu.cs   |  2 +-
 .../Avalonia.Skia/Gpu/OpenGl/GlSkiaGpu.cs     |  2 +-
 .../Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs |  2 +-
 src/Skia/Avalonia.Skia/SkiaOptions.cs         | 12 ++++++++++--
 .../SkiaOptionsTests.cs                       | 19 +++++++++++++++++++
 5 files changed, 32 insertions(+), 5 deletions(-)
 create mode 100644 tests/Avalonia.Skia.UnitTests/SkiaOptionsTests.cs

diff --git a/src/Skia/Avalonia.Skia/Gpu/Metal/SkiaMetalGpu.cs b/src/Skia/Avalonia.Skia/Gpu/Metal/SkiaMetalGpu.cs
index 05bcd9fa42..c60b3b3dba 100644
--- a/src/Skia/Avalonia.Skia/Gpu/Metal/SkiaMetalGpu.cs
+++ b/src/Skia/Avalonia.Skia/Gpu/Metal/SkiaMetalGpu.cs
@@ -17,7 +17,7 @@ internal class SkiaMetalGpu : ISkiaGpu
 
     public SkiaMetalGpu(IMetalDevice device, long? maxResourceBytes, bool? useStencilBuffers = null)
     {
-        var avoidStencilBuffers = useStencilBuffers == false;
+        var avoidStencilBuffers = SkiaOptions.ShouldAvoidStencilBuffers(useStencilBuffers);
         _context = GRContext.CreateMetal(
                        new GRMtlBackendContext { DeviceHandle = device.Device, QueueHandle = device.CommandQueue, },
                        new GRContextOptions { AvoidStencilBuffers = avoidStencilBuffers })
diff --git a/src/Skia/Avalonia.Skia/Gpu/OpenGl/GlSkiaGpu.cs b/src/Skia/Avalonia.Skia/Gpu/OpenGl/GlSkiaGpu.cs
index af957551e3..107ab79ac7 100644
--- a/src/Skia/Avalonia.Skia/Gpu/OpenGl/GlSkiaGpu.cs
+++ b/src/Skia/Avalonia.Skia/Gpu/OpenGl/GlSkiaGpu.cs
@@ -40,7 +40,7 @@ namespace Avalonia.Skia
                 
                 using(iface)
                 {
-                    var avoidStencilBuffers = useStencilBuffers == false;
+                    var avoidStencilBuffers = SkiaOptions.ShouldAvoidStencilBuffers(useStencilBuffers);
                     _grContext = GRContext.CreateGl(iface, new GRContextOptions { AvoidStencilBuffers = avoidStencilBuffers });
                     if (maxResourceBytes.HasValue)
                     {
diff --git a/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs b/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs
index b66054b340..9f8a746044 100644
--- a/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs
+++ b/src/Skia/Avalonia.Skia/Gpu/Vulkan/VulkanSkiaGpu.cs
@@ -48,7 +48,7 @@ internal class VulkanSkiaGpu : ISkiaGpu
                 GetProcedureAddress = GetProcAddressWrapper
             };
 
-            var avoidStencilBuffers = useStencilBuffers == false;
+            var avoidStencilBuffers = SkiaOptions.ShouldAvoidStencilBuffers(useStencilBuffers);
             
             GrContext = GRContext.CreateVulkan(ctx, new GRContextOptions { AvoidStencilBuffers = avoidStencilBuffers }) ??
                          throw new VulkanException("Unable to create GrContext from IVulkanDevice");
diff --git a/src/Skia/Avalonia.Skia/SkiaOptions.cs b/src/Skia/Avalonia.Skia/SkiaOptions.cs
index 1a95919300..9afaf6b307 100644
--- a/src/Skia/Avalonia.Skia/SkiaOptions.cs
+++ b/src/Skia/Avalonia.Skia/SkiaOptions.cs
@@ -26,9 +26,17 @@ namespace Avalonia
         public bool UseOpacitySaveLayer { get; set; } = false;
         
         /// <summary>
-        /// Gets whether stencil buffers can be used for various draw operations, improving performance.
-        /// If null (the default), Avalonia chooses whether to enable stencil buffers depending on the platform.
+        /// Gets whether stencil buffers can be used for various draw operations, improving clipping performance.
+        /// Enabling them lets Skia pick multisample-based path rendering, which quantizes edge coverage and
+        /// visibly degrades anti-aliasing of vector geometry, so they are disabled unless explicitly requested.
         /// </summary>
         public bool? UseStencilBuffers { get; set; }
+
+        /// <summary>
+        /// Maps <see cref="UseStencilBuffers"/> onto Skia's inverted <c>GRContextOptions.AvoidStencilBuffers</c>.
+        /// Only an explicit <c>true</c> opts in: stencil buffers trade geometry anti-aliasing quality for
+        /// clipping speed (see issue #21760), so they must never be enabled implicitly.
+        /// </summary>
+        internal static bool ShouldAvoidStencilBuffers(bool? useStencilBuffers) => useStencilBuffers != true;
     }
 }
diff --git a/tests/Avalonia.Skia.UnitTests/SkiaOptionsTests.cs b/tests/Avalonia.Skia.UnitTests/SkiaOptionsTests.cs
new file mode 100644
index 0000000000..660d89b929
--- /dev/null
+++ b/tests/Avalonia.Skia.UnitTests/SkiaOptionsTests.cs
@@ -0,0 +1,19 @@
+using Xunit;
+
+namespace Avalonia.Skia.UnitTests
+{
+    public class SkiaOptionsTests
+    {
+        // Stencil buffers let Skia choose multisample-based path rendering, which quantizes edge
+        // coverage and visibly degraded vector geometry anti-aliasing on GPU backends in 12.1.0.
+        // They are a performance opt-in, so anything other than an explicit `true` must avoid them.
+        [Theory]
+        [InlineData(null, true)]
+        [InlineData(false, true)]
+        [InlineData(true, false)]
+        public void Stencil_Buffers_Are_Avoided_Unless_Explicitly_Enabled(bool? useStencilBuffers, bool expected)
+        {
+            Assert.Equal(expected, SkiaOptions.ShouldAvoidStencilBuffers(useStencilBuffers));
+        }
+    }
+}

From 6625f70671f594bbdcd2181fdab8e802062de047 Mon Sep 17 00:00:00 2001
From: Emmanuel Hansen <emmausssss@gmail.com>
Date: Mon, 24 Aug 2026 20:39:36 +0000
Subject: [PATCH 195/196] [Feature] Add Flex Panel (#20263)

* add flex panel control

* add flex panel tests

* increase flex panel sample item count

* update namespace style to block namespaces

* fix build

* rename flex enums

* fix FlexViewModel enum values

* remove allocations in flexpanel measure/arrange

* flexpanel - measure even if mult is 0

* addressed review

* use numberstyles

* add locale tests

* simplified state

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>
---
 .../FlexDemoNumberToThicknessConverter.cs     |  24 +
 samples/ControlCatalog/MainView.xaml          |   2 +-
 samples/ControlCatalog/Pages/FlexPage.axaml   | 219 ++++++
 .../ControlCatalog/Pages/FlexPage.axaml.cs    |  37 +
 .../ViewModels/FlexItemViewModel.cs           | 118 ++++
 .../ViewModels/FlexViewModel.cs               | 126 ++++
 .../MainWindowViewModel_PageList.cs           |   1 +
 .../Avalonia.Controls.csproj                  |   2 +-
 src/Avalonia.Controls/FlexPanel/Flex.cs       | 274 ++++++++
 .../FlexPanel/FlexAlignContent.cs             |  46 ++
 .../FlexPanel/FlexAlignItems.cs               |  38 +
 src/Avalonia.Controls/FlexPanel/FlexBasis.cs  | 116 +++
 .../FlexPanel/FlexBasisKind.cs                |  23 +
 .../FlexPanel/FlexDirection.cs                |  31 +
 .../FlexPanel/FlexJustifyContent.cs           |  53 ++
 src/Avalonia.Controls/FlexPanel/FlexPanel.cs  | 661 ++++++++++++++++++
 src/Avalonia.Controls/FlexPanel/FlexWrap.cs   |  26 +
 .../FlexBasisTests.cs                         |  68 ++
 .../FlexPanelTests.cs                         | 415 +++++++++++
 19 files changed, 2278 insertions(+), 2 deletions(-)
 create mode 100644 samples/ControlCatalog/Converter/FlexDemoNumberToThicknessConverter.cs
 create mode 100644 samples/ControlCatalog/Pages/FlexPage.axaml
 create mode 100644 samples/ControlCatalog/Pages/FlexPage.axaml.cs
 create mode 100644 samples/ControlCatalog/ViewModels/FlexItemViewModel.cs
 create mode 100644 samples/ControlCatalog/ViewModels/FlexViewModel.cs
 create mode 100644 src/Avalonia.Controls/FlexPanel/Flex.cs
 create mode 100644 src/Avalonia.Controls/FlexPanel/FlexAlignContent.cs
 create mode 100644 src/Avalonia.Controls/FlexPanel/FlexAlignItems.cs
 create mode 100644 src/Avalonia.Controls/FlexPanel/FlexBasis.cs
 create mode 100644 src/Avalonia.Controls/FlexPanel/FlexBasisKind.cs
 create mode 100644 src/Avalonia.Controls/FlexPanel/FlexDirection.cs
 create mode 100644 src/Avalonia.Controls/FlexPanel/FlexJustifyContent.cs
 create mode 100644 src/Avalonia.Controls/FlexPanel/FlexPanel.cs
 create mode 100644 src/Avalonia.Controls/FlexPanel/FlexWrap.cs
 create mode 100644 tests/Avalonia.Controls.UnitTests/FlexBasisTests.cs
 create mode 100644 tests/Avalonia.Controls.UnitTests/FlexPanelTests.cs

diff --git a/samples/ControlCatalog/Converter/FlexDemoNumberToThicknessConverter.cs b/samples/ControlCatalog/Converter/FlexDemoNumberToThicknessConverter.cs
new file mode 100644
index 0000000000..c5c3e0e2ed
--- /dev/null
+++ b/samples/ControlCatalog/Converter/FlexDemoNumberToThicknessConverter.cs
@@ -0,0 +1,24 @@
+using System;
+using System.Globalization;
+using Avalonia;
+using Avalonia.Data.Converters;
+
+namespace ControlCatalog.Converter
+{
+    internal sealed class FlexDemoNumberToThicknessConverter : IValueConverter
+    {
+        public object? Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+        {
+            if (value is int x && targetType.IsAssignableFrom(typeof(Thickness)))
+            {
+                var y = 16 + 2 * ((x * 5) % 9);
+                return new Thickness(2 * y, y);
+            }
+
+            throw new NotSupportedException();
+        }
+
+        public object? ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) =>
+            throw new NotSupportedException();
+    }
+}
diff --git a/samples/ControlCatalog/MainView.xaml b/samples/ControlCatalog/MainView.xaml
index f7b2658b0f..d473f76439 100644
--- a/samples/ControlCatalog/MainView.xaml
+++ b/samples/ControlCatalog/MainView.xaml
@@ -158,4 +158,4 @@
   </DrawerPage.DrawerFooterTemplate>
 
   <NavigationPage Name="NavPage"/>
-</DrawerPage>
+</DrawerPage>
\ No newline at end of file
diff --git a/samples/ControlCatalog/Pages/FlexPage.axaml b/samples/ControlCatalog/Pages/FlexPage.axaml
new file mode 100644
index 0000000000..16596320ec
--- /dev/null
+++ b/samples/ControlCatalog/Pages/FlexPage.axaml
@@ -0,0 +1,219 @@
+<ContentPage xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:panels="using:Avalonia.Labs.Panels"
+             xmlns:conv="using:ControlCatalog.Converter"
+             xmlns:vm="using:ControlCatalog.ViewModels"
+             mc:Ignorable="d"
+             d:DesignWidth="800"
+             d:DesignHeight="450"
+             x:DataType="vm:FlexViewModel"
+             HorizontalContentAlignment="Stretch"
+             VerticalContentAlignment="Stretch"
+             x:Class="ControlCatalog.Pages.FlexPage">
+  <ContentPage.Resources>
+    <conv:FlexDemoNumberToThicknessConverter x:Key="NumberToThicknessConverter" />
+    <DataTemplate x:Key="ItemTemplate"
+                  x:DataType="vm:FlexItemViewModel">
+      <ListBoxItem Padding="{Binding Value, Converter={StaticResource NumberToThicknessConverter}}"
+                   IsSelected="{Binding IsSelected}"
+                   Background="{Binding Color}"
+                   Tapped="OnItemTapped">
+        <ListBoxItem.Styles>
+          <Style Selector="ListBoxItem:selected">
+            <Setter Property="Background" Value="DodgerBlue" />
+          </Style>
+        </ListBoxItem.Styles>
+        <TextBlock HorizontalAlignment="Center"
+                   VerticalAlignment="Center"
+                   Text="{Binding Value}" />
+      </ListBoxItem>
+    </DataTemplate>
+  </ContentPage.Resources>
+  <ContentPage.Styles>
+    <Style Selector="CheckBox">
+      <Setter Property="MinWidth" Value="0" />
+      <Setter Property="Padding" Value="8,0,0,0" />
+      <Setter Property="VerticalContentAlignment" Value="Center" />
+    </Style>
+    <Style Selector="ComboBox">
+      <Setter Property="HorizontalAlignment" Value="Stretch" />
+    </Style>
+    <Style Selector="RadioButton">
+      <Setter Property="MinWidth" Value="0" />
+      <Setter Property="Padding" Value="8,0,0,0" />
+      <Setter Property="VerticalContentAlignment" Value="Center" />
+    </Style>
+  </ContentPage.Styles>
+
+  <DockPanel Margin="16">
+
+    <ScrollViewer HorizontalScrollBarVisibility="Disabled"
+                  Padding="0,0,16,0"
+                  MinWidth="200">
+
+      <StackPanel Spacing="16">
+
+        <TextBlock FontSize="16"
+                   Text="Properties" />
+
+        <!--<panels:FlexPanel ColumnSpacing="16">
+          <RadioButton IsChecked="{Binding IsItemsControl}"
+                       Content="ItemsControl" />
+          <RadioButton IsChecked="{Binding IsItemsRepeater}"
+                       Content="ItemsRepeater" />
+        </panels:FlexPanel>-->
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="Direction:" />
+          <ComboBox ItemsSource="{Binding DirectionValues}"
+                    SelectedItem="{Binding Direction}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="JustifyContent:" />
+          <ComboBox ItemsSource="{Binding JustifyContentValues}"
+                    SelectedItem="{Binding JustifyContent}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="AlignItems:" />
+          <ComboBox ItemsSource="{Binding AlignItemsValues}"
+                    SelectedItem="{Binding AlignItems}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="AlignContent:" />
+          <ComboBox ItemsSource="{Binding AlignContentValues}"
+                    SelectedItem="{Binding AlignContent}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="Wrap:" />
+          <ComboBox ItemsSource="{Binding WrapValues}"
+                    SelectedItem="{Binding Wrap}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="ColumnSpacing:" />
+          <NumericUpDown Minimum="0"
+                          Value="{Binding ColumnSpacing}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="RowSpacing:" />
+          <NumericUpDown Minimum="0"
+                         Value="{Binding RowSpacing}" />
+        </StackPanel>
+
+        <CheckBox IsEnabled="{Binding SelectedItem, Converter={x:Static ObjectConverters.IsNotNull}}"
+                  Content="SelectedItem IsVisible"
+                  IsChecked="{Binding SelectedItem.IsVisible}" />
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="SelectedItem AlignSelf:" />
+          <ComboBox IsEnabled="{Binding SelectedItem, Converter={x:Static ObjectConverters.IsNotNull}}"
+                    ItemsSource="{Binding AlignSelfValues}"
+                    SelectedItem="{Binding SelectedItem.AlignSelfItem}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="SelectedItem Order:" />
+          <NumericUpDown IsEnabled="{Binding SelectedItem, Converter={x:Static ObjectConverters.IsNotNull}}"
+                         Value="{Binding SelectedItem.Order}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="SelectedItem Shrink:" />
+          <NumericUpDown Minimum="0.0"
+                         IsEnabled="{Binding SelectedItem, Converter={x:Static ObjectConverters.IsNotNull}}"
+                         Value="{Binding SelectedItem.Shrink}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="SelectedItem Grow:" />
+          <NumericUpDown Minimum="0.0"
+                         IsEnabled="{Binding SelectedItem, Converter={x:Static ObjectConverters.IsNotNull}}"
+                         Value="{Binding SelectedItem.Grow}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="SelectedItem Basis:" />
+          <ComboBox IsEnabled="{Binding SelectedItem, Converter={x:Static ObjectConverters.IsNotNull}}"
+                    ItemsSource="{Binding FlexBasisKindValues}"
+                    SelectedItem="{Binding SelectedItem.BasisKind}" />
+          <NumericUpDown Minimum="0.0"
+                         IsEnabled="{Binding SelectedItem, Converter={x:Static ObjectConverters.IsNotNull}}"
+                         Value="{Binding SelectedItem.BasisValue}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="SelectedItem HorizontalAlignment:" />
+          <ComboBox IsEnabled="{Binding SelectedItem, Converter={x:Static ObjectConverters.IsNotNull}}"
+                    ItemsSource="{Binding HorizontalAlignmentValues}"
+                    SelectedItem="{Binding SelectedItem.HorizontalAlignment}" />
+        </StackPanel>
+
+        <StackPanel Spacing="8">
+          <TextBlock Text="SelectedItem VerticalAlignment:" />
+          <ComboBox IsEnabled="{Binding SelectedItem, Converter={x:Static ObjectConverters.IsNotNull}}"
+                    ItemsSource="{Binding VerticalAlignmentValues}"
+                    SelectedItem="{Binding SelectedItem.VerticalAlignment}" />
+        </StackPanel>
+
+        <Grid ColumnDefinitions="*,8,*">
+
+          <Button Grid.Column="0"
+                  HorizontalAlignment="Stretch"
+                  HorizontalContentAlignment="Center"
+                  Command="{Binding AddItemCommand}"
+                  Content="Add Item" />
+
+          <Button Grid.Column="2"
+                  HorizontalAlignment="Stretch"
+                  HorizontalContentAlignment="Center"
+                  Command="{Binding RemoveItemCommand}"
+                  Content="Remove Item" />
+
+        </Grid>
+
+      </StackPanel>
+
+    </ScrollViewer>
+
+    <ItemsControl BorderBrush="#777"
+                  BorderThickness="1"
+                  ItemsSource="{Binding Numbers}"
+                  ItemTemplate="{StaticResource ItemTemplate}">
+      <ItemsControl.Styles>
+        <Style Selector="ContentPresenter"
+               x:DataType="vm:FlexItemViewModel">
+          <Setter Property="Flex.AlignSelf" Value="{Binding AlignSelf}" />
+          <Setter Property="Flex.Order" Value="{Binding Order}" />
+          <Setter Property="Flex.Shrink" Value="{Binding Shrink}" />
+          <Setter Property="Flex.Grow" Value="{Binding Grow}" />
+          <Setter Property="Flex.Basis" Value="{Binding Basis}" />
+          <Setter Property="HorizontalAlignment" Value="{Binding HorizontalAlignment}" />
+          <Setter Property="VerticalAlignment" Value="{Binding VerticalAlignment}" />
+          <Setter Property="IsVisible" Value="{Binding IsVisible}" />
+        </Style>
+      </ItemsControl.Styles>
+      <ItemsControl.ItemsPanel>
+        <ItemsPanelTemplate>
+          <FlexPanel Direction="{Binding Direction}"
+                          JustifyContent="{Binding JustifyContent}"
+                          AlignItems="{Binding AlignItems}"
+                          AlignContent="{Binding AlignContent}"
+                          Wrap="{Binding Wrap}"
+                          ColumnSpacing="{Binding ColumnSpacing}"
+                          RowSpacing="{Binding RowSpacing}" />
+        </ItemsPanelTemplate>
+      </ItemsControl.ItemsPanel>
+    </ItemsControl>
+
+  </DockPanel>
+
+
+
+</ContentPage>
diff --git a/samples/ControlCatalog/Pages/FlexPage.axaml.cs b/samples/ControlCatalog/Pages/FlexPage.axaml.cs
new file mode 100644
index 0000000000..397def77ae
--- /dev/null
+++ b/samples/ControlCatalog/Pages/FlexPage.axaml.cs
@@ -0,0 +1,37 @@
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using ControlCatalog.ViewModels;
+
+namespace ControlCatalog.Pages
+{
+    public partial class FlexPage : ContentPage
+    {
+        public FlexPage()
+        {
+            InitializeComponent();
+
+            DataContext = new FlexViewModel();
+        }
+
+        private void OnItemTapped(object? sender, RoutedEventArgs e)
+        {
+            if (sender is ListBoxItem control && DataContext is FlexViewModel vm && control.DataContext is FlexItemViewModel item)
+            {
+                if (vm.SelectedItem != null)
+                {
+                    vm.SelectedItem.IsSelected = false;
+                }
+
+                if (vm.SelectedItem == item)
+                {
+                    vm.SelectedItem = null;
+                }
+                else
+                {
+                    vm.SelectedItem = item;
+                    vm.SelectedItem.IsSelected = true;
+                }
+            }
+        }
+    }
+}
diff --git a/samples/ControlCatalog/ViewModels/FlexItemViewModel.cs b/samples/ControlCatalog/ViewModels/FlexItemViewModel.cs
new file mode 100644
index 0000000000..9ffade90a0
--- /dev/null
+++ b/samples/ControlCatalog/ViewModels/FlexItemViewModel.cs
@@ -0,0 +1,118 @@
+using System;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
+using MiniMvvm;
+
+namespace ControlCatalog.ViewModels
+{
+    public sealed class FlexItemViewModel : ViewModelBase
+    {
+        internal const FlexAlignItems AlignSelfAuto = (FlexAlignItems)(-1);
+
+        private FlexAlignItems _alignSelf;
+
+        private bool _isSelected;
+        private bool _isVisible = true;
+
+        private FlexAlignItems _alignSelfItem = AlignSelfAuto;
+        private int _order;
+        private double _shrink = 1.0;
+        private double _grow;
+        private double _basisValue = 100.0;
+        private FlexBasisKind _basisKind;
+        private HorizontalAlignment _horizontalAlignment;
+        private VerticalAlignment _verticalAlignment; 
+
+        public FlexItemViewModel(int value)
+        {
+            Value = value;
+
+            _alignSelf = AlignSelfItem == AlignSelfAuto ? default(FlexAlignItems) : AlignSelfItem;
+
+            var color = Random.Shared.Next();
+
+            Color = new SolidColorBrush((uint)color);
+        }
+
+        public int Value { get; }
+
+        public Brush Color { get; }
+
+        public bool IsSelected
+        {
+            get => _isSelected;
+            set => this.RaiseAndSetIfChanged(ref _isSelected, value);
+        }
+
+        public bool IsVisible
+        {
+            get => _isVisible;
+            set => this.RaiseAndSetIfChanged(ref _isVisible, value);
+        }
+
+        public FlexAlignItems AlignSelfItem
+        {
+            get => _alignSelfItem;
+            set
+            {
+                this.RaiseAndSetIfChanged(ref _alignSelfItem, value);
+                this.RaisePropertyChanged(nameof(AlignSelf));
+            }
+        }
+
+        public FlexAlignItems? AlignSelf => _alignSelf;
+
+        public int Order
+        {
+            get => _order;
+            set => this.RaiseAndSetIfChanged(ref _order, value);
+        }
+
+        public double Shrink
+        {
+            get => _shrink;
+            set => this.RaiseAndSetIfChanged(ref _shrink, value);
+        }
+
+        public double Grow
+        {
+            get => _grow;
+            set => this.RaiseAndSetIfChanged(ref _grow, value);
+        }
+
+        public double BasisValue
+        {
+            get => _basisValue;
+            set
+            {
+                this.RaiseAndSetIfChanged(ref _basisValue, value);
+                this.RaisePropertyChanged(nameof(Basis));
+            }
+        }
+
+        public FlexBasisKind BasisKind
+        {
+            get => _basisKind;
+            set
+            {
+                this.RaiseAndSetIfChanged(ref _basisKind, value);
+                this.RaisePropertyChanged(nameof(Basis));
+            }
+        }
+
+        public FlexBasis Basis => new(_basisValue, _basisKind);
+
+        public HorizontalAlignment HorizontalAlignment
+        {
+            get => _horizontalAlignment;
+            set => this.RaiseAndSetIfChanged(ref _horizontalAlignment, value);
+        }
+
+        public VerticalAlignment VerticalAlignment
+        {
+            get => _verticalAlignment;
+            set => this.RaiseAndSetIfChanged(ref _verticalAlignment, value);
+        }
+    }
+}
diff --git a/samples/ControlCatalog/ViewModels/FlexViewModel.cs b/samples/ControlCatalog/ViewModels/FlexViewModel.cs
new file mode 100644
index 0000000000..abc7143659
--- /dev/null
+++ b/samples/ControlCatalog/ViewModels/FlexViewModel.cs
@@ -0,0 +1,126 @@
+using System;
+using System.Collections;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Windows.Input;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using MiniMvvm;
+
+namespace ControlCatalog.ViewModels
+{
+    public sealed class FlexViewModel : ViewModelBase
+    {
+        private readonly ObservableCollection<FlexItemViewModel> _numbers;
+
+        private FlexDirection _direction = FlexDirection.Row;
+        private FlexJustifyContent _justifyContent = FlexJustifyContent.FlexStart;
+        private FlexAlignItems _alignItems = FlexAlignItems.FlexStart;
+        private FlexAlignContent _alignContent = FlexAlignContent.FlexStart;
+        private FlexWrap _wrap = FlexWrap.Wrap;
+
+        private int _columnSpacing = 64;
+        private int _rowSpacing = 32;
+
+        private int _currentNumber = 41;
+
+        private FlexItemViewModel? _selectedItem;
+
+        public FlexViewModel()
+        {
+            _numbers = new ObservableCollection<FlexItemViewModel>(Enumerable.Range(1, 40).Select(x => new FlexItemViewModel(x)));
+
+            Numbers = new ReadOnlyObservableCollection<FlexItemViewModel>(_numbers);
+
+            AddItemCommand = MiniCommand.Create(AddItem);
+            RemoveItemCommand = MiniCommand.Create(RemoveItem);
+        }
+
+        public IEnumerable DirectionValues { get; } = Enum.GetValues<FlexDirection>();
+
+        public IEnumerable JustifyContentValues { get; } = Enum.GetValues<FlexJustifyContent>();
+
+        public IEnumerable AlignItemsValues { get; } = Enum.GetValues<FlexAlignItems>();
+
+        public IEnumerable AlignContentValues { get; } = Enum.GetValues<FlexAlignContent>();
+
+        public IEnumerable WrapValues { get; } = Enum.GetValues<FlexWrap>();
+
+        public IEnumerable FlexBasisKindValues { get; } = Enum.GetValues<FlexBasisKind>();
+
+        public IEnumerable HorizontalAlignmentValues { get; } = Enum.GetValues<HorizontalAlignment>();
+
+        public IEnumerable VerticalAlignmentValues { get; } = Enum.GetValues<VerticalAlignment>();
+
+        public IEnumerable AlignSelfValues { get; } = Enum.GetValues<FlexAlignItems>().Cast<FlexAlignItems>().Prepend(FlexItemViewModel.AlignSelfAuto);
+        
+        public FlexDirection Direction
+        {
+            get => _direction;
+            set => this.RaiseAndSetIfChanged(ref _direction, value);
+        }
+
+        public FlexJustifyContent JustifyContent
+        {
+            get => _justifyContent;
+            set => this.RaiseAndSetIfChanged(ref _justifyContent, value);
+        }
+
+        public FlexAlignItems AlignItems
+        {
+            get => _alignItems;
+            set => this.RaiseAndSetIfChanged(ref _alignItems, value);
+        }
+
+        public FlexAlignContent AlignContent
+        {
+            get => _alignContent;
+            set => this.RaiseAndSetIfChanged(ref _alignContent, value);
+        }
+
+        public FlexWrap Wrap
+        {
+            get => _wrap;
+            set => this.RaiseAndSetIfChanged(ref _wrap, value);
+        }
+
+        public int ColumnSpacing
+        {
+            get => _columnSpacing;
+            set => this.RaiseAndSetIfChanged(ref _columnSpacing, value);
+        }
+
+        public int RowSpacing
+        {
+            get => _rowSpacing;
+            set => this.RaiseAndSetIfChanged(ref _rowSpacing, value);
+        }
+
+        public ReadOnlyObservableCollection<FlexItemViewModel> Numbers { get; }
+
+        public FlexItemViewModel? SelectedItem
+        {
+            get => _selectedItem;
+            set => this.RaiseAndSetIfChanged(ref _selectedItem, value);
+        }
+
+        public ICommand AddItemCommand { get; }
+
+        public ICommand RemoveItemCommand { get; }
+
+        private void AddItem() => _numbers.Add(new FlexItemViewModel(_currentNumber++));
+
+        private void RemoveItem()
+        {
+            if (SelectedItem is null)
+            {
+                return;
+            }
+
+            _numbers.Remove(SelectedItem);
+
+            SelectedItem.IsSelected = false;
+            SelectedItem = null;
+        }
+    }
+}
diff --git a/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs b/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
index 61476a0407..1f02d1a6f7 100644
--- a/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
+++ b/samples/ControlCatalog/ViewModels/MainWindowViewModel_PageList.cs
@@ -57,6 +57,7 @@ namespace ControlCatalog.ViewModels
             new PageItem("Drag+Drop",() => new DragAndDropPage(), Icons.DragDrop),
             new PageItem("DrawerPage",() => new DrawerDemoPage(), Icons.Drawer),
             new PageItem("Expander",() => new ExpanderPage(), Icons.Expand),
+            new PageItem("Flex Panel",() => new FlexPage(), Icons.Grid),
             new PageItem("Flyouts",() => new FlyoutsPage(), Icons.Flyout),
             new PageItem("Focus",() => new FocusPage(), Icons.Target),
             new PageItem("Gestures",() => new GesturePage(), Icons.Gesture),
diff --git a/src/Avalonia.Controls/Avalonia.Controls.csproj b/src/Avalonia.Controls/Avalonia.Controls.csproj
index 53f1df7358..2a67934a98 100644
--- a/src/Avalonia.Controls/Avalonia.Controls.csproj
+++ b/src/Avalonia.Controls/Avalonia.Controls.csproj
@@ -18,7 +18,7 @@
     <InternalsVisibleTo Include="Avalonia.Controls.UnitTests, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.Markup.UnitTests, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.DesignerSupport, PublicKey=$(AvaloniaPublicKey)" />
-    <InternalsVisibleTo Include="Avalonia.Diagnostics, PublicKey=$(AvaloniaPublicKey)"/>
+    <InternalsVisibleTo Include="Avalonia.Diagnostics, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="AvaloniaUI.DiagnosticsSupport.Avalonia, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.LeakTests, PublicKey=$(AvaloniaPublicKey)" />
     <InternalsVisibleTo Include="Avalonia.Headless, PublicKey=$(AvaloniaPublicKey)" />
diff --git a/src/Avalonia.Controls/FlexPanel/Flex.cs b/src/Avalonia.Controls/FlexPanel/Flex.cs
new file mode 100644
index 0000000000..965e3da2a2
--- /dev/null
+++ b/src/Avalonia.Controls/FlexPanel/Flex.cs
@@ -0,0 +1,274 @@
+using System;
+
+using Avalonia.Layout;
+
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Provides attached properties for controlling the layout behavior of child elements within a <see cref="FlexPanel"/>.
+    /// </summary>
+    public static class Flex
+    {
+        /// <summary>
+        /// Defines an attached property to control the cross-axis alignment of a specific child in a flex layout.
+        /// </summary>
+        public static readonly AttachedProperty<FlexAlignItems?> AlignSelfProperty =
+            AvaloniaProperty.RegisterAttached<Layoutable, FlexAlignItems?>("AlignSelf", typeof(Flex));
+
+        /// <summary>
+        /// Defines an attached property to control the order of a specific child in a flex layout.
+        /// </summary>
+        public static readonly AttachedProperty<int> OrderProperty =
+            AvaloniaProperty.RegisterAttached<Layoutable, int>("Order", typeof(Flex));
+
+        /// <summary>
+        /// Defines an attached property to control the initial main-axis size of a specific child in a flex layout.
+        /// </summary>
+        public static readonly AttachedProperty<FlexBasis> BasisProperty =
+            AvaloniaProperty.RegisterAttached<Layoutable, FlexBasis>("Basis", typeof(Flex), FlexBasis.Auto);
+
+        /// <summary>
+        /// Defines an attached property to control the factor by which a specific child can shrink
+        /// along the main-axis in a flex layout.
+        /// </summary>
+        public static readonly AttachedProperty<double> ShrinkProperty =
+            AvaloniaProperty.RegisterAttached<Layoutable, double>("Shrink", typeof(Flex), 1.0, validate: v => v >= 0.0);
+
+        /// <summary>
+        /// Defines an attached property to control the factor by which a specific child can grow
+        /// along the main-axis in a flex layout.
+        /// </summary>
+        public static readonly AttachedProperty<double> GrowProperty =
+            AvaloniaProperty.RegisterAttached<Layoutable, double>("Grow", typeof(Flex), 0.0, validate: v => v >= 0.0);
+
+        internal static readonly AttachedProperty<double> BaseLengthProperty =
+            AvaloniaProperty.RegisterAttached<Layoutable, double>("BaseLength", typeof(Flex), 0.0);
+
+        internal static readonly AttachedProperty<double> CurrentLengthProperty =
+            AvaloniaProperty.RegisterAttached<Layoutable, double>("CurrentLength", typeof(Flex), 0.0);
+
+        /// <summary>
+        /// Gets the cross-axis alignment override for a child item in a <see cref="FlexPanel"/>
+        /// </summary>
+        /// <remarks>
+        /// This property is used to override the <see cref="FlexPanel.AlignItems"/> property for a specific child.
+        /// When omitted, <see cref="FlexPanel.AlignItems"/> in not overridden.
+        /// Equivalent to CSS align-self property.
+        /// </remarks>
+        public static FlexAlignItems? GetAlignSelf(Layoutable layoutable)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            return layoutable.GetValue(AlignSelfProperty);
+        }
+
+        /// <summary>
+        /// Sets the cross-axis alignment override for a child item in a <see cref="FlexPanel"/>
+        /// </summary>
+        /// <remarks>
+        /// This property is used to override the <see cref="FlexPanel.AlignItems"/> property for a specific child.
+        /// When omitted, <see cref="FlexPanel.AlignItems"/> in not overridden.
+        /// Equivalent to CSS align-self property.
+        /// </remarks>
+        public static void SetAlignSelf(Layoutable layoutable, FlexAlignItems? value)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            layoutable.SetValue(AlignSelfProperty, value);
+        }
+
+        /// <summary>
+        /// Retrieves the order in which a child item appears within the <see cref="FlexPanel"/>.
+        /// </summary>
+        /// <remarks>
+        /// A lower order value means the item will be positioned earlier within the container.
+        /// Items with the same order value are laid out in their source document order.
+        /// When omitted, it is set to 0.
+        /// Equivalent to CSS order property.
+        /// </remarks>
+        public static int GetOrder(Layoutable layoutable)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            return layoutable.GetValue(OrderProperty);
+        }
+
+        /// <summary>
+        /// Sets the order in which a child item appears within the <see cref="FlexPanel"/>.
+        /// </summary>
+        /// <remarks>
+        /// A lower order value means the item will be positioned earlier within the container.
+        /// Items with the same order value are laid out in their source document order.
+        /// When omitted, it is set to 0.
+        /// Equivalent to CSS order property.
+        /// </remarks>
+        public static void SetOrder(Layoutable layoutable, int value)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            layoutable.SetValue(OrderProperty, value);
+        }
+
+        /// <summary>
+        /// Gets the initial size along the main-axis of an item in a <see cref="FlexPanel"/>,
+        /// before free space is distributed according to the flex factors.
+        /// </summary>
+        /// <remarks>
+        /// Either automatic size, a fixed length, or a percentage of the container's size.
+        /// When omitted, it is set to <see cref="FlexBasis.Auto"/>.
+        /// Equivalent to CSS flex-basis property.
+        /// </remarks>
+        public static FlexBasis GetBasis(Layoutable layoutable)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            return layoutable.GetValue(BasisProperty);
+        }
+
+        /// <summary>
+        /// Sets the initial size along the main-axis of an item in a <see cref="FlexPanel"/>,
+        /// before free space is distributed according to the flex factors.
+        /// </summary>
+        /// <remarks>
+        /// Either automatic size, a fixed length, or a percentage of the container's size.
+        /// When omitted, it is set to <see cref="FlexBasis.Auto"/>.
+        /// Equivalent to CSS flex-basis property.
+        /// </remarks>
+        public static void SetBasis(Layoutable layoutable, FlexBasis value)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            layoutable.SetValue(BasisProperty, value);
+        }
+
+        /// <summary>
+        /// Gets the factor by which an item can shrink along the main-axis,
+        /// relative to other items in a <see cref="FlexPanel"/>.
+        /// </summary>
+        /// <remarks>
+        /// When omitted, it is set to 1.
+        /// Equivalent to CSS flex-shrink property.
+        /// </remarks>
+        public static double GetShrink(Layoutable layoutable)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            return layoutable.GetValue(ShrinkProperty);
+        }
+
+        /// <summary>
+        /// Sets the factor by which an item can shrink along the main-axis,
+        /// relative to other items in a <see cref="FlexPanel"/>.
+        /// </summary>
+        /// <remarks>
+        /// When omitted, it is set to 1.
+        /// Equivalent to CSS flex-shrink property.
+        /// </remarks>
+        public static void SetShrink(Layoutable layoutable, double value)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            layoutable.SetValue(ShrinkProperty, value);
+        }
+
+        /// <summary>
+        /// Gets the factor by which an item can grow along the main-axis,
+        /// relative to other items in a <see cref="FlexPanel"/>.
+        /// </summary>
+        /// <remarks>
+        /// When omitted, it is set to 0.
+        /// Equivalent to CSS flex-grow property.
+        /// </remarks>
+        public static double GetGrow(Layoutable layoutable)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            return layoutable.GetValue(GrowProperty);
+        }
+
+        /// <summary>
+        /// Sets the factor by which an item can grow along the main-axis,
+        /// relative to other items in a <see cref="FlexPanel"/>.
+        /// </summary>
+        /// <remarks>
+        /// When omitted, it is set to 0.
+        /// Equivalent to CSS flex-grow property.
+        /// </remarks>
+        public static void SetGrow(Layoutable layoutable, double value)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            layoutable.SetValue(GrowProperty, value);
+        }
+
+        internal static double GetBaseLength(Layoutable layoutable)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            return layoutable.GetValue(BaseLengthProperty);
+        }
+
+        internal static void SetBaseLength(Layoutable layoutable, double value)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            layoutable.SetValue(BaseLengthProperty, value);
+        }
+
+        internal static double GetCurrentLength(Layoutable layoutable)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            return layoutable.GetValue(CurrentLengthProperty);
+        }
+
+        internal static void SetCurrentLength(Layoutable layoutable, double value)
+        {
+            if (layoutable is null)
+            {
+                throw new ArgumentNullException(nameof(layoutable));
+            }
+
+            layoutable.SetValue(CurrentLengthProperty, value);
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/FlexPanel/FlexAlignContent.cs b/src/Avalonia.Controls/FlexPanel/FlexAlignContent.cs
new file mode 100644
index 0000000000..ac60c76990
--- /dev/null
+++ b/src/Avalonia.Controls/FlexPanel/FlexAlignContent.cs
@@ -0,0 +1,46 @@
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Defines the alignment mode of the lines inside a <see cref="FlexPanel"/> along the cross-axis. 
+    /// </summary>
+    public enum FlexAlignContent
+    {
+        /// <summary>
+        /// Lines are packed toward the start of the container.
+        /// </summary>
+        FlexStart,
+        
+        /// <summary>
+        /// Lines are packed toward the end of the container.
+        /// </summary>
+        FlexEnd,
+        
+        /// <summary>
+        /// Lines are packed toward the center of the container
+        /// </summary>
+        Center,
+        
+        /// <summary>
+        /// Lines are stretched to take up the remaining space.
+        /// </summary>
+        /// <remarks>
+        /// This is the default value.
+        /// </remarks>
+        Stretch,
+        
+        /// <summary>
+        /// Lines are evenly distributed in the container, with no space on either end.
+        /// </summary>
+        SpaceBetween,
+        
+        /// <summary>
+        /// Lines are evenly distributed in the container, with half-size spaces on either end.
+        /// </summary>
+        SpaceAround,
+        
+        /// <summary>
+        /// Lines are evenly distributed in the container, with equal-size spaces between each line and on either end. 
+        /// </summary>
+        SpaceEvenly
+    }
+}
diff --git a/src/Avalonia.Controls/FlexPanel/FlexAlignItems.cs b/src/Avalonia.Controls/FlexPanel/FlexAlignItems.cs
new file mode 100644
index 0000000000..09f3113e0f
--- /dev/null
+++ b/src/Avalonia.Controls/FlexPanel/FlexAlignItems.cs
@@ -0,0 +1,38 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Defines the alignment mode along the cross-axis of <see cref="FlexPanel"/> child items.
+    /// </summary>
+    [SuppressMessage("Naming", "CA1717:Only FlagsAttribute enums should have plural names")]
+    public enum FlexAlignItems
+    {
+        /// <summary>
+        /// Items are aligned to the cross-axis start margin edge of the line.
+        /// </summary>
+        FlexStart,
+        
+        /// <summary>
+        /// Items are aligned to the cross-axis end margin edge of the line.
+        /// </summary>
+        FlexEnd,
+        
+        /// <summary>
+        /// Items are aligned to the cross-axis center of the line.
+        /// </summary>
+        /// <remarks>
+        /// If the cross size of the line is less than that of the child item,
+        /// it will overflow equally in both directions.
+        /// </remarks>
+        Center,
+        
+        /// <summary>
+        /// Items are stretched to fill the cross size of the line.
+        /// </summary>
+        /// <remarks>
+        /// This is the default value.
+        /// </remarks>
+        Stretch
+    }
+}
diff --git a/src/Avalonia.Controls/FlexPanel/FlexBasis.cs b/src/Avalonia.Controls/FlexPanel/FlexBasis.cs
new file mode 100644
index 0000000000..c6f9848a41
--- /dev/null
+++ b/src/Avalonia.Controls/FlexPanel/FlexBasis.cs
@@ -0,0 +1,116 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Specifies the initial size of a flex item.
+    /// </summary>
+    public readonly partial struct FlexBasis : IEquatable<FlexBasis>
+    {
+        /// <summary>
+        /// Gets the value of the <see cref="FlexBasis"/>. The meaning of this value depends on the <see cref="FlexBasisKind"/>
+        /// </summary>
+        public double Value { get; }
+
+        /// <summary>
+        /// Gets the <see cref="FlexBasisKind"/>. This determines how the value affects the size of the flex item
+        /// </summary>
+        public FlexBasisKind Kind { get; }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="FlexBasis"/> and sets the value and <see cref="FlexBasisKind"/>
+        /// </summary>
+        /// <param name="value">The value of the <see cref="FlexBasis"/></param>
+        /// <param name="kind">The <see cref="FlexBasisKind">. This determines how the value affects the size of the flex item</see>/></param>
+        /// <exception cref="ArgumentException"></exception>
+        public FlexBasis(double value, FlexBasisKind kind)
+        {
+            if (value < 0 || double.IsNaN(value) || double.IsInfinity(value))
+                throw new ArgumentException($"Invalid basis value: {value}", nameof(value));
+            if (kind < FlexBasisKind.Auto || kind > FlexBasisKind.Relative)
+                throw new ArgumentException($"Invalid basis kind: {kind}", nameof(kind));
+            Value = value;
+            Kind = kind;
+        }
+
+        /// <summary>
+        /// Initializes an instance of <see cref="FlexBasis"/> and sets the absolute value
+        /// </summary>
+        /// <param name="value">The absolute value of the <see cref="FlexBasis"/></param>
+        /// <exception cref="ArgumentException"></exception>
+        public FlexBasis(double value) : this(value, FlexBasisKind.Absolute) { }
+
+        /// <summary>
+        /// Gets a <see cref="FlexBasis"/> instance that represents the "auto" value, which means the size of the flex item is determined by its content or other factors.
+        /// </summary>
+        public static FlexBasis Auto => new(0.0, FlexBasisKind.Auto);
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="FlexBasis"/> is set to "auto".
+        /// </summary>
+        public bool IsAuto => Kind == FlexBasisKind.Auto;
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="FlexBasis"/> is set to an absolute value.
+        /// </summary>
+        public bool IsAbsolute => Kind == FlexBasisKind.Absolute;
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="FlexBasis"/> is set to a relative value.
+        /// </summary>
+        public bool IsRelative => Kind == FlexBasisKind.Relative;
+
+        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
+        public bool Equals(FlexBasis other) =>
+            (IsAuto && other.IsAuto) || (Value == other.Value && Kind == other.Kind);
+
+        public override bool Equals(object? obj) =>
+            obj is FlexBasis other && Equals(other);
+
+        public override int GetHashCode() =>
+            (Value, Kind).GetHashCode();
+
+        public static bool operator ==(FlexBasis left, FlexBasis right) =>
+            left.Equals(right);
+
+        public static bool operator !=(FlexBasis left, FlexBasis right) =>
+            !left.Equals(right);
+
+        public override string ToString()
+        {
+            return Kind switch
+            {
+                FlexBasisKind.Auto => "Auto",
+                FlexBasisKind.Absolute => FormattableString.Invariant($"{Value:G17}"),
+                FlexBasisKind.Relative => FormattableString.Invariant($"{Value * 100:G17}%"),
+                _ => throw new InvalidOperationException(),
+            };
+        }
+
+        /// <summary>
+        /// Converts a string flex-basis value to a <see cref="FlexBasis"/> instance.
+        /// </summary>
+        /// <param name="str">The value to parse.</param>
+        /// <returns></returns>
+        public static FlexBasis Parse(string str)
+        {
+            var span = str.AsSpan().Trim();
+            if (string.Equals(str, "AUTO", StringComparison.OrdinalIgnoreCase))
+            {
+                return Auto;
+            }
+            else if (span.EndsWith("%") && double.TryParse(span[..^1], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var val))
+            {
+                return new FlexBasis(val / 100, FlexBasisKind.Relative);
+            }
+            else if (double.TryParse(str, NumberStyles.Float, CultureInfo.InvariantCulture, out var value))
+            {
+                return new FlexBasis(value, FlexBasisKind.Absolute);
+            }
+
+            throw new ArgumentException($"Value '{str}' is not a valid flex-basis value. Valid values are 'auto', a number (e.g., '100'), or a percentage (e.g., '50%').", nameof(str));
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/FlexPanel/FlexBasisKind.cs b/src/Avalonia.Controls/FlexPanel/FlexBasisKind.cs
new file mode 100644
index 0000000000..b43781d28c
--- /dev/null
+++ b/src/Avalonia.Controls/FlexPanel/FlexBasisKind.cs
@@ -0,0 +1,23 @@
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Determines how <see cref="FlexBasis"/> affects the size of the flex item
+    /// </summary>
+    public enum FlexBasisKind
+    {
+        /// <summary>
+        /// Uses the measured Width and Height of the <see cref="FlexPanel"/> to determine the initial size of the item.
+        /// </summary>
+        Auto,
+
+        /// <summary>
+        /// The initial size of the item is set to the <see cref="FlexBasis"/> value.
+        /// </summary>
+        Absolute,
+
+        /// <summary>
+        /// Indicates the <see cref="FlexBasis"/> value is a percentage, and the size of the flex item is scaled by it.
+        /// </summary>
+        Relative,
+    }
+}
diff --git a/src/Avalonia.Controls/FlexPanel/FlexDirection.cs b/src/Avalonia.Controls/FlexPanel/FlexDirection.cs
new file mode 100644
index 0000000000..ed8a59e4b3
--- /dev/null
+++ b/src/Avalonia.Controls/FlexPanel/FlexDirection.cs
@@ -0,0 +1,31 @@
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Describes the orientation and direction along which items are placed inside the <see cref="FlexPanel"/>
+    /// </summary>
+    public enum FlexDirection
+    {
+        /// <summary>
+        /// Items are placed along the horizontal axis, starting from the left
+        /// </summary>
+        /// <remarks>
+        /// This is the default value.
+        /// </remarks>
+        Row,
+        
+        /// <summary>
+        /// Items are placed along the horizontal axis, starting from the right
+        /// </summary>
+        RowReverse,
+        
+        /// <summary>
+        /// Items are placed along the vertical axis, starting from the top
+        /// </summary>
+        Column,
+        
+        /// <summary>
+        /// Items are placed along the vertical axis, starting from the bottom
+        /// </summary>
+        ColumnReverse
+    }
+}
diff --git a/src/Avalonia.Controls/FlexPanel/FlexJustifyContent.cs b/src/Avalonia.Controls/FlexPanel/FlexJustifyContent.cs
new file mode 100644
index 0000000000..24bb56709a
--- /dev/null
+++ b/src/Avalonia.Controls/FlexPanel/FlexJustifyContent.cs
@@ -0,0 +1,53 @@
+namespace Avalonia.Controls
+{
+    
+    /// <summary>
+    /// Describes the main-axis alignment of items inside a <see cref="FlexPanel"/> line.
+    /// </summary>
+    public enum FlexJustifyContent
+    {
+        /// <summary>
+        /// Child items are packed toward the start of the line.
+        /// </summary>
+        /// <remarks>
+        /// This is the default value.
+        /// </remarks>
+        FlexStart,
+        
+        /// <summary>
+        /// Child items are packed toward the end of the line.
+        /// </summary>
+        FlexEnd,
+        
+        /// <summary>
+        /// Child items are packed toward the center of the line.
+        /// </summary>
+        /// <remarks>
+        /// If the leftover free-space is negative, the child items will overflow equally in both directions.
+        /// </remarks>
+        Center,
+        
+        /// <summary>
+        /// Child items are evenly distributed in the line, with no space on either end.
+        /// </summary>
+        /// <remarks>
+        /// If the leftover free-space is negative or there is only a single child item on the line,
+        /// this value is identical to <see cref="FlexStart"/>.
+        /// </remarks>
+        SpaceBetween,
+        
+        /// <summary>
+        /// Child items are evenly distributed in the line, with half-size spaces on either end.
+        /// </summary>
+        /// <remarks>
+        /// If the leftover free-space is negative or there is only a single child item on the line,
+        /// this value is identical to <see cref="Center"/>.
+        /// </remarks>
+        SpaceAround,
+        
+        /// <summary>
+        /// Child items are evenly distributed in the line, with equal-size spaces between each item and on either end.
+        /// </summary>
+        SpaceEvenly
+    }
+}
diff --git a/src/Avalonia.Controls/FlexPanel/FlexPanel.cs b/src/Avalonia.Controls/FlexPanel/FlexPanel.cs
new file mode 100644
index 0000000000..9efdc04901
--- /dev/null
+++ b/src/Avalonia.Controls/FlexPanel/FlexPanel.cs
@@ -0,0 +1,661 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Linq;
+using Avalonia.Layout;
+using Avalonia.Reactive;
+using Avalonia.Utilities;
+
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// A panel that arranges child controls using CSS FlexBox principles.
+    /// It organizes child items in one or more lines along a main-axis (either row or column)
+    /// and provides advanced control over their sizing and layout.
+    /// </summary>
+    /// <remarks>
+    /// See CSS FlexBox specification: https://www.w3.org/TR/css-flexbox-1
+    /// </remarks>
+    public sealed class FlexPanel : Panel
+    {
+        private static readonly Func<Layoutable, int> s_getOrder = x => Flex.GetOrder(x);
+        private static readonly Func<Layoutable, bool> s_isVisible = x => x.IsVisible;
+
+        /// <summary>
+        /// Defines the <see cref="Direction"/> property.
+        /// </summary>
+        public static readonly StyledProperty<FlexDirection> DirectionProperty =
+            AvaloniaProperty.Register<FlexPanel, FlexDirection>(nameof(Direction));
+
+        /// <summary>
+        /// Defines the <see cref="JustifyContent"/> property.
+        /// </summary>
+        public static readonly StyledProperty<FlexJustifyContent> JustifyContentProperty =
+            AvaloniaProperty.Register<FlexPanel, FlexJustifyContent>(nameof(JustifyContent));
+
+        /// <summary>
+        /// Defines the <see cref="AlignItems"/> property.
+        /// </summary>
+        public static readonly StyledProperty<FlexAlignItems> AlignItemsProperty =
+            AvaloniaProperty.Register<FlexPanel, FlexAlignItems>(nameof(AlignItems), FlexAlignItems.Stretch);
+
+        /// <summary>
+        /// Defines the <see cref="AlignContent"/> property.
+        /// </summary>
+        public static readonly StyledProperty<FlexAlignContent> AlignContentProperty =
+            AvaloniaProperty.Register<FlexPanel, FlexAlignContent>(nameof(AlignContent), FlexAlignContent.Stretch);
+
+        /// <summary>
+        /// Defines the <see cref="Wrap"/> property.
+        /// </summary>
+        public static readonly StyledProperty<FlexWrap> WrapProperty =
+            AvaloniaProperty.Register<FlexPanel, FlexWrap>(nameof(Wrap));
+
+        /// <summary>
+        /// Defines the <see cref="ColumnSpacing"/> property.
+        /// </summary>
+        public static readonly StyledProperty<double> ColumnSpacingProperty =
+            AvaloniaProperty.Register<FlexPanel, double>(nameof(ColumnSpacing));
+
+        /// <summary>
+        /// Defines the <see cref="RowSpacing"/> property.
+        /// </summary>
+        public static readonly StyledProperty<double> RowSpacingProperty =
+            AvaloniaProperty.Register<FlexPanel, double>(nameof(RowSpacing));
+
+        private FlexLayoutState _state = new FlexLayoutState();
+        private Dictionary<Visual, IDisposable> _childVisibilitySubscriptions = new Dictionary<Visual, IDisposable>();
+        private Layoutable[]? _visibleChildren;
+
+        static FlexPanel()
+        {
+            AffectsMeasure<FlexPanel>(
+                DirectionProperty,
+                JustifyContentProperty,
+                WrapProperty,
+                ColumnSpacingProperty,
+                RowSpacingProperty);
+
+            AffectsArrange<FlexPanel>(
+                AlignItemsProperty,
+                AlignContentProperty);
+
+            AffectsParentMeasure<FlexPanel>(
+                HorizontalAlignmentProperty,
+                VerticalAlignmentProperty,
+                Flex.OrderProperty,
+                Flex.BasisProperty,
+                Flex.ShrinkProperty,
+                Flex.GrowProperty);
+
+            AffectsParentArrange<FlexPanel>(
+                Flex.AlignSelfProperty);
+        }
+
+        /// <summary>
+        /// Gets or sets the direction of the <see cref="FlexPanel"/>'s main-axis,
+        /// determining the orientation in which child controls are laid out.
+        /// </summary>
+        /// <remarks>
+        /// The default value is <see cref="FlexDirection.Row"/>.
+        /// Equivalent to CSS flex-direction property
+        /// </remarks>
+        public FlexDirection Direction
+        {
+            get => GetValue(DirectionProperty);
+            set => SetValue(DirectionProperty, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the main-axis alignment of child items inside a line of the <see cref="FlexPanel"/>.
+        /// Typically used to distribute extra free space leftover after flexible lengths and margins have been resolved.
+        /// </summary>
+        /// <remarks>
+        /// The default value is <see cref="FlexJustifyContent.FlexStart"/>.
+        /// Equivalent to CSS justify-content property.
+        /// </remarks>
+        public FlexJustifyContent JustifyContent
+        {
+            get => GetValue(JustifyContentProperty);
+            set => SetValue(JustifyContentProperty, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the cross-axis alignment of all child items inside a line of the <see cref="FlexPanel"/>.
+        /// Similar to <see cref="JustifyContent"/>, but in the perpendicular direction.
+        /// </summary>
+        /// <remarks>
+        /// The default value is <see cref="FlexAlignItems.Stretch"/>.
+        /// Equivalent to CSS align-items property.
+        /// </remarks>
+        public FlexAlignItems AlignItems
+        {
+            get => GetValue(AlignItemsProperty);
+            set => SetValue(AlignItemsProperty, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the cross-axis alignment of lines in the <see cref="FlexPanel"/> when there is extra space. 
+        /// Similar to <see cref="AlignItems"/>, but for entire lines.
+        /// <see cref="FlexPanel.Wrap"/> property set to <see cref="FlexWrap.Wrap"/> mode
+        /// allows controls to be arranged on multiple lines.
+        /// </summary>
+        /// <remarks>
+        /// The default value is <see cref="FlexAlignContent.Stretch"/>.
+        /// Equivalent to CSS align-content property.
+        /// </remarks>
+        public FlexAlignContent AlignContent
+        {
+            get => GetValue(AlignContentProperty);
+            set => SetValue(AlignContentProperty, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the wrap mode, controlling whether the <see cref="FlexPanel"/> is single-line or multi-line.
+        /// Additionally, it determines the cross-axis stacking direction for new lines.
+        /// </summary>
+        /// <remarks>
+        /// The default value is <see cref="FlexWrap.NoWrap"/>.
+        /// Equivalent to CSS flex-wrap property.
+        /// </remarks>
+        public FlexWrap Wrap
+        {
+            get => GetValue(WrapProperty);
+            set => SetValue(WrapProperty, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the minimum horizontal spacing between child items or lines,
+        /// depending on main-axis direction of the <see cref="FlexPanel"/>.
+        /// </summary>
+        /// <remarks>
+        /// The default value is 0.
+        /// Similar to CSS column-gap property.
+        /// </remarks>
+        public double ColumnSpacing
+        {
+            get => GetValue(ColumnSpacingProperty);
+            set => SetValue(ColumnSpacingProperty, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the minimum vertical spacing between child items or lines,
+        /// depending on main-axis direction of the <see cref="FlexPanel"/>.
+        /// </summary>
+        /// <remarks>
+        /// The default value is 0.
+        /// Similar to CSS row-gap property.
+        /// </remarks>
+        public double RowSpacing
+        {
+            get => GetValue(RowSpacingProperty);
+            set => SetValue(RowSpacingProperty, value);
+        }
+
+        /// <inheritdoc />
+        protected override Size MeasureOverride(Size availableSize)
+        {
+            if (_visibleChildren is not { Length: > 0 } children)
+            {
+                _state.Lines.Clear();
+                return availableSize;
+            }
+
+            var isColumn = Direction is FlexDirection.Column or FlexDirection.ColumnReverse;
+
+            var max = Uv.FromSize(availableSize, isColumn);
+            var spacing = Uv.FromSize(ColumnSpacing, RowSpacing, isColumn);
+
+            LineData lineData = default;
+            var (childIndex, firstChildIndex, itemIndex) = (0, 0, 0);
+
+            _state.Lines.Clear();
+
+            double panelSizeU = 0;
+            Func<FlexLine, double> maxSelector = l => l.U + (l.Count - 1) * spacing.U;
+
+            foreach (var element in children)
+            {
+                var size = MeasureChild(element, max, isColumn);
+
+                if (Wrap != FlexWrap.NoWrap && MathUtilities.GreaterThanOrClose(lineData.U + size.U + itemIndex * spacing.U, max.U))
+                {
+                    var line = new FlexLine(firstChildIndex, childIndex - 1, lineData);
+                    _state.Lines.Add(line);
+                    lineData = default;
+                    firstChildIndex = childIndex;
+                    itemIndex = 0;
+
+                    panelSizeU = Math.Max(panelSizeU, maxSelector(line));
+                }
+
+                lineData.U += size.U;
+                lineData.V = Math.Max(lineData.V, size.V);
+                lineData.Shrink += Flex.GetShrink(element);
+                lineData.Grow += Flex.GetGrow(element);
+                lineData.AutoMargins += GetItemAutoMargins(element, isColumn);
+                itemIndex++;
+                childIndex++;
+            }
+
+            if (itemIndex != 0)
+            {
+                var line = new FlexLine(firstChildIndex, firstChildIndex + itemIndex - 1, lineData);
+                _state.Lines.Add(line);
+                panelSizeU = Math.Max(panelSizeU, maxSelector(line));
+            }
+
+            var totalSpacingV = (_state.Lines.Count - 1) * spacing.V;
+
+            // Resizing along main axis using grow and shrink factors can affect cross axis, so remeasure affected items and lines.
+            for (var i = 0; i < _state.Lines.Count; i++)
+            {
+                var flexLine = _state.Lines[i];
+                var (itemsCount, freeU) = GetLineMeasureU(flexLine, max.U, spacing.U);
+                var (lineMult, autoMargins, remainingFreeU) = GetLineMultInfo(flexLine, freeU);
+
+                if (lineMult != 0.0 && remainingFreeU != 0.0)
+                {
+                    double maxV = 0.0;
+                    for (var j = flexLine.First; j <= flexLine.Last; j++)
+                    {
+                        var element = _visibleChildren[j];
+                        var baseLength = Flex.GetBaseLength(element);
+                        var mult = GetItemMult(element, freeU);
+                        var length = Math.Max(0.0, baseLength + remainingFreeU * mult / lineMult);
+                        element.Measure(Uv.ToSize(max.WithU(length), isColumn));
+
+                        maxV = Math.Max(Uv.FromSize(element.DesiredSize, isColumn).V, maxV);
+                    }
+
+                    flexLine.V = maxV;
+                    _state.Lines[i] = flexLine;
+                }
+            }
+
+            if (Wrap == FlexWrap.WrapReverse)
+            {
+                _state.Lines.Reverse();
+            }
+
+            var totalLineV = _state.Lines.Sum(l => l.V);
+            var panelSize = _state.Lines.Count == 0 ? default : new Uv(panelSizeU, totalLineV + totalSpacingV);
+            return Uv.ToSize(panelSize, isColumn);
+        }
+
+        /// <inheritdoc />
+        protected override Size ArrangeOverride(Size finalSize)
+        {
+            if (_visibleChildren is not { Length: > 0 } || _state.Lines.Count == 0)
+            {
+                return finalSize;
+            }
+
+            var isColumn = Direction is FlexDirection.Column or FlexDirection.ColumnReverse;
+            var isReverse = Direction is FlexDirection.RowReverse or FlexDirection.ColumnReverse;
+
+            var panelSize = Uv.FromSize(finalSize, isColumn);
+            var spacing = Uv.FromSize(ColumnSpacing, RowSpacing, isColumn);
+
+            var linesCount = _state.Lines.Count;
+            var totalLineV = _state.Lines.Sum(s => s.V);
+            var totalSpacingV = (linesCount - 1) * spacing.V;
+            var totalV = totalLineV + totalSpacingV;
+            var freeV = panelSize.V - totalV;
+
+            var alignContent = DetermineAlignContent(AlignContent, freeV, linesCount);
+
+            var (v, spacingV) = GetCrossAxisPosAndSpacing(alignContent, spacing, freeV, linesCount);
+
+            var scaleV = alignContent == FlexAlignContent.Stretch && totalLineV != 0 ? (panelSize.V - totalSpacingV) / totalLineV : 1.0;
+
+            foreach (var line in _state.Lines)
+            {
+                var lineV = scaleV * line.V;
+                var (itemsCount, freeU) = GetLineMeasureU(line, panelSize.U, spacing.U);
+                var (lineMult, lineAutoMargins, remainingFreeU) = GetLineMultInfo(line, freeU);
+
+                var currentFreeU = remainingFreeU;
+                if (lineMult != 0.0 && remainingFreeU != 0.0)
+                {
+                    for (var i = line.First; i <= line.Last; i++)
+                    {
+                        var element = _visibleChildren[i];
+                        var baseLength = Flex.GetBaseLength(element);
+                        var mult = GetItemMult(element, freeU);
+                        if (mult != 0.0)
+                        {
+                            var length = Math.Max(0.0, baseLength + remainingFreeU * mult / lineMult);
+                            Flex.SetCurrentLength(element, length);
+                            currentFreeU -= length - baseLength;
+                        }
+                    }
+                }
+                remainingFreeU = currentFreeU;
+
+                if (lineAutoMargins != 0 && remainingFreeU != 0.0)
+                {
+                    for (var i = line.First; i <= line.Last; i++)
+                    {
+                        var element = _visibleChildren[i];
+                        var baseLength = Flex.GetCurrentLength(element);
+                        var autoMargins = GetItemAutoMargins(element, isColumn);
+                        if (autoMargins != 0)
+                        {
+                            var length = Math.Max(0.0, baseLength + remainingFreeU * autoMargins / lineAutoMargins);
+                            Flex.SetCurrentLength(element, length);
+                            currentFreeU -= length - baseLength;
+                        }
+                    }
+                }
+                remainingFreeU = currentFreeU;
+
+                var (u, spacingU) = GetMainAxisPosAndSpacing(JustifyContent, line, spacing, remainingFreeU, itemsCount);
+
+                for (var i = line.First; i <= line.Last; i++)
+                {
+                    var element = _visibleChildren[i];
+                    var size = Uv.FromSize(element.DesiredSize, isColumn).WithU(Flex.GetCurrentLength(element));
+                    var align = Flex.GetAlignSelf(element) ?? AlignItems;
+
+                    var positionV = align switch
+                    {
+                        FlexAlignItems.FlexStart => v,
+                        FlexAlignItems.FlexEnd => v + lineV - size.V,
+                        FlexAlignItems.Center => v + (lineV - size.V) / 2,
+                        FlexAlignItems.Stretch => v,
+                        _ => throw new InvalidOperationException()
+                    };
+
+                    size = size.WithV(align == FlexAlignItems.Stretch ? lineV : size.V);
+                    var position = new Uv(isReverse ? panelSize.U - size.U - u : u, positionV);
+                    element.Arrange(new Rect(Uv.ToPoint(position, isColumn), Uv.ToSize(size, isColumn)));
+
+                    u += size.U + spacingU;
+                }
+
+                v += lineV + spacingV;
+            }
+
+            return finalSize;
+        }
+
+        private static Uv MeasureChild(Layoutable element, Uv max, bool isColumn)
+        {
+            var basis = Flex.GetBasis(element);
+            var flexConstraint = basis.Kind switch
+            {
+                FlexBasisKind.Auto => max.U,
+                FlexBasisKind.Absolute => basis.Value,
+                FlexBasisKind.Relative => max.U * basis.Value / 100,
+                _ => throw new InvalidOperationException($"Unsupported FlexBasisKind value: {basis.Kind}")
+            };
+            element.Measure(Uv.ToSize(max.WithU(flexConstraint), isColumn));
+
+            var size = Uv.FromSize(element.DesiredSize, isColumn);
+
+            var flexLength = basis.Kind switch
+            {
+                FlexBasisKind.Auto => size.U,
+                FlexBasisKind.Absolute or FlexBasisKind.Relative => Math.Max(size.U, flexConstraint),
+                _ => throw new InvalidOperationException()
+            };
+            size = size.WithU(flexLength);
+
+            Flex.SetBaseLength(element, flexLength);
+            Flex.SetCurrentLength(element, flexLength);
+            return size;
+        }
+
+        private static FlexAlignContent DetermineAlignContent(FlexAlignContent currentAlignContent, double freeV, int linesCount)
+        {
+            // Determine AlignContent based on available space and line count
+            return currentAlignContent switch
+            {
+                // If there's free vertical space, handle distribution based on the content alignment
+                FlexAlignContent.Stretch when freeV > 0.0 => FlexAlignContent.Stretch,
+                FlexAlignContent.SpaceBetween when freeV > 0.0 && linesCount > 1 => FlexAlignContent.SpaceBetween,
+                FlexAlignContent.SpaceAround when freeV > 0.0 && linesCount > 0 => FlexAlignContent.SpaceAround,
+                FlexAlignContent.SpaceEvenly when freeV > 0.0 && linesCount > 0 => FlexAlignContent.SpaceEvenly,
+
+                // Default alignments when there's no free space or not enough lines
+                FlexAlignContent.Stretch => FlexAlignContent.FlexStart,
+                FlexAlignContent.SpaceBetween => FlexAlignContent.FlexStart,
+                FlexAlignContent.SpaceAround => FlexAlignContent.Center,
+                FlexAlignContent.SpaceEvenly => FlexAlignContent.Center,
+                FlexAlignContent.FlexStart or FlexAlignContent.Center or FlexAlignContent.FlexEnd => currentAlignContent,
+
+                _ => throw new InvalidOperationException($"Unsupported AlignContent value: {currentAlignContent}")
+            };
+        }
+
+        private static (double v, double spacingV) GetCrossAxisPosAndSpacing(FlexAlignContent alignContent, Uv spacing,
+            double freeV, int linesCount)
+        {
+            return alignContent switch
+            {
+                FlexAlignContent.FlexStart => (0.0, spacing.V),
+                FlexAlignContent.FlexEnd => (freeV, spacing.V),
+                FlexAlignContent.Center => (freeV / 2, spacing.V),
+                FlexAlignContent.Stretch => (0.0, spacing.V),
+
+                FlexAlignContent.SpaceBetween when linesCount > 1 => (0.0, spacing.V + freeV / (linesCount - 1)),
+                FlexAlignContent.SpaceBetween => (0.0, spacing.V),
+
+                FlexAlignContent.SpaceAround when linesCount > 0 => (freeV / linesCount / 2, spacing.V + freeV / linesCount),
+                FlexAlignContent.SpaceAround => (freeV / 2, spacing.V),
+
+                FlexAlignContent.SpaceEvenly => (freeV / (linesCount + 1), spacing.V + freeV / (linesCount + 1)),
+
+                _ => throw new InvalidOperationException($"Unsupported AlignContent value: {alignContent}")
+            };
+        }
+
+        private static (double u, double spacingU) GetMainAxisPosAndSpacing(FlexJustifyContent justifyContent, FlexLine line,
+            Uv spacing, double remainingFreeU, int itemsCount)
+        {
+            return line.Grow > 0 ? (0.0, spacing.U) : justifyContent switch
+            {
+                FlexJustifyContent.FlexStart => (0.0, spacing.U),
+                FlexJustifyContent.FlexEnd => (remainingFreeU, spacing.U),
+                FlexJustifyContent.Center => (remainingFreeU / 2, spacing.U),
+
+                FlexJustifyContent.SpaceBetween when itemsCount > 1 => (0.0, spacing.U + remainingFreeU / (itemsCount - 1)),
+                FlexJustifyContent.SpaceBetween => (0.0, spacing.U),
+
+                FlexJustifyContent.SpaceAround when itemsCount > 0 => (remainingFreeU / itemsCount / 2, spacing.U + remainingFreeU / itemsCount),
+                FlexJustifyContent.SpaceAround => (remainingFreeU / 2, spacing.U),
+
+                FlexJustifyContent.SpaceEvenly when itemsCount > 0 => (remainingFreeU / (itemsCount + 1), spacing.U + remainingFreeU / (itemsCount + 1)),
+                FlexJustifyContent.SpaceEvenly => (remainingFreeU / 2, spacing.U),
+
+                _ => throw new InvalidOperationException($"Unsupported JustifyContent value: {justifyContent}")
+            };
+        }
+
+        private static (int ItemsCount, double FreeU) GetLineMeasureU(
+            FlexLine line, double panelSizeU, double spacingU)
+        {
+            var itemsCount = line.Count;
+            var totalSpacingU = (itemsCount - 1) * spacingU;
+            var totalU = line.U + totalSpacingU;
+            var freeU = panelSizeU - totalU;
+            return (itemsCount, freeU);
+        }
+
+        private static (double LineMult, double LineAutoMargins, double RemainingFreeU) GetLineMultInfo(FlexLine line, double freeU)
+        {
+            var lineMult = freeU switch
+            {
+                < 0 => line.Shrink,
+                > 0 => line.Grow,
+                _ => 0.0,
+            };
+            // https://www.w3.org/TR/css-flexbox-1/#remaining-free-space
+            // Sum of flex factors less than 1 reduces remaining free space to be distributed.
+            return lineMult is > 0 and < 1
+                ? (lineMult, line.AutoMargins, freeU * lineMult)
+                : (lineMult, line.AutoMargins, freeU);
+        }
+
+        private static double GetItemMult(Layoutable element, double freeU)
+        {
+            var mult = freeU switch
+            {
+                < 0 => Flex.GetShrink(element),
+                > 0 => Flex.GetGrow(element),
+                _ => 0.0,
+            };
+            return mult;
+        }
+
+        private static int GetItemAutoMargins(Layoutable element, bool isColumn)
+        {
+            return isColumn
+                ? element.VerticalAlignment switch
+                {
+                    VerticalAlignment.Stretch => 0,
+                    VerticalAlignment.Top or VerticalAlignment.Bottom => 1,
+                    VerticalAlignment.Center => 2,
+                    _ => throw new InvalidOperationException()
+                }
+                : element.HorizontalAlignment switch
+                {
+                    HorizontalAlignment.Stretch => 0,
+                    HorizontalAlignment.Left or HorizontalAlignment.Right => 1,
+                    HorizontalAlignment.Center => 2,
+                    _ => throw new InvalidOperationException()
+                };
+        }
+
+        protected override void ChildrenChanged(object? sender, NotifyCollectionChangedEventArgs e)
+        {
+            base.ChildrenChanged(sender, e);
+
+            if (e.OldItems is { } oldItems)
+                foreach (var old in oldItems)
+                {
+                    if (old is Visual v)
+                        if (_childVisibilitySubscriptions.Remove(v, out var disposable))
+                        {
+                            disposable.Dispose();
+                        }
+                }
+
+            if (e.NewItems is { } newItems)
+                foreach (var newItem in newItems)
+                {
+                    if (newItem is Visual visual)
+                    {
+                        _childVisibilitySubscriptions.Add(visual, visual.GetObservable(IsVisibleProperty).Subscribe(new AnonymousObserver<bool>(OnChildVisibilityChanged)));
+                    }
+                }
+
+            UpdateVisibleChildren();
+        }
+
+        private void OnChildVisibilityChanged(bool isVisible)
+        {
+            UpdateVisibleChildren();
+        }
+
+        private void UpdateVisibleChildren()
+        {
+            _visibleChildren = Children.Where(s_isVisible).OrderBy(s_getOrder).ToArray();
+
+            InvalidateMeasure();
+        }
+
+        private readonly struct FlexLayoutState
+        {
+            public List<FlexLine> Lines { get; } = new List<FlexLine>();
+
+            public FlexLayoutState() { }
+        }
+
+        private struct LineData
+        {
+            public double U { get; set; }
+
+            public double V { get; set; }
+
+            public double Shrink { get; set; }
+
+            public double Grow { get; set; }
+
+            public int AutoMargins { get; set; }
+        }
+
+        private struct FlexLine
+        {
+            public FlexLine(int first, int last, LineData l)
+            {
+                First = first;
+                Last = last;
+                U = l.U;
+                V = l.V;
+                Shrink = l.Shrink;
+                Grow = l.Grow;
+                AutoMargins = l.AutoMargins;
+            }
+
+            /// <summary>First item index.</summary>
+            public int First { get; }
+
+            /// <summary>Last item index.</summary>
+            public int Last { get; }
+
+            /// <summary>Sum of main sizes of items.</summary>
+            public double U { get; }
+
+            /// <summary>Max of cross sizes of items.</summary>
+            public double V { get; set; }
+
+            /// <summary>Sum of shrink factors of flexible items.</summary>
+            public double Shrink { get; }
+
+            /// <summary>Sum of grow factors of flexible items.</summary>
+            public double Grow { get; }
+
+            /// <summary>Number of "auto margins" along main axis.</summary>
+            public int AutoMargins { get; }
+
+            /// <summary>Number of items.</summary>
+            public int Count => Last - First + 1;
+        }
+
+        private readonly struct Uv
+        {
+            public Uv(double u, double v)
+            {
+                U = u;
+                V = v;
+            }
+
+            public double U { get; }
+
+            public double V { get; }
+
+            public static Uv FromSize(double width, double height, bool swap) =>
+                new Uv(swap ? height : width, swap ? width : height);
+
+            public static Uv FromSize(Size size, bool swap) =>
+                FromSize(size.Width, size.Height, swap);
+
+            public static Point ToPoint(Uv uv, bool swap) =>
+                new Point(swap ? uv.V : uv.U, swap ? uv.U : uv.V);
+
+            public static Size ToSize(Uv uv, bool swap) =>
+                new Size(swap ? uv.V : uv.U, swap ? uv.U : uv.V);
+
+            public Uv WithU(double u) =>
+                new Uv(u, V);
+
+            public Uv WithV(double v) =>
+                new Uv(U, v);
+
+            public override string ToString() =>
+                $"U: {U}, V: {V}";
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/FlexPanel/FlexWrap.cs b/src/Avalonia.Controls/FlexPanel/FlexWrap.cs
new file mode 100644
index 0000000000..826d7bf661
--- /dev/null
+++ b/src/Avalonia.Controls/FlexPanel/FlexWrap.cs
@@ -0,0 +1,26 @@
+namespace Avalonia.Controls
+{
+    /// <summary>
+    /// Describes the wrap behavior of the <see cref="FlexPanel"/>
+    /// </summary>
+    public enum FlexWrap
+    {
+        /// <summary>
+        /// The <see cref="FlexPanel"/> is single line.
+        /// </summary>
+        /// <remarks>
+        /// This is the default value.
+        /// </remarks>
+        NoWrap,
+        
+        /// <summary>
+        /// The <see cref="FlexPanel"/> is multi line.
+        /// </summary>
+        Wrap,
+        
+        /// <summary>
+        /// Same as <see cref="Wrap"/> but new lines are added in the opposite cross-axis direction.
+        /// </summary>
+        WrapReverse
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/FlexBasisTests.cs b/tests/Avalonia.Controls.UnitTests/FlexBasisTests.cs
new file mode 100644
index 0000000000..77bbb6398c
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/FlexBasisTests.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading.Tasks;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests
+{
+    public class FlexBasisTests : ScopedTestBase
+    {
+        [Fact]
+        public void Parse_Should_Parse_Auto()
+        {
+            var result = FlexBasis.Parse("Auto");
+
+            Assert.Equal(FlexBasis.Auto, result);
+        }
+
+        [Fact]
+        public void Parse_Should_Parse_Auto_Lowercase()
+        {
+            var result = FlexBasis.Parse("auto");
+
+            Assert.Equal(FlexBasis.Auto, result);
+        }
+
+        [Fact]
+        public void Parse_Should_Parse_Percentage()
+        {
+            var result = FlexBasis.Parse("50%");
+
+            Assert.Equal(new FlexBasis(0.5, FlexBasisKind.Relative), result);
+        }
+
+        [Fact]
+        public void Parse_Should_Parse_Absolute_Value()
+        {
+            var result = FlexBasis.Parse("2");
+
+            Assert.Equal(new FlexBasis(2, FlexBasisKind.Absolute), result);
+        }
+
+        [Fact]
+        public void Parse_Should_Throw_ArgumentException_For_Invalid_String()
+        {
+            Assert.Throws<ArgumentException>(() => FlexBasis.Parse("2x"));
+        }
+
+
+        [Fact]
+        public async Task ToString_AllCulture_Absolute_Should_Pass()
+        {
+            List<CultureInfo> cultureInfos = [CultureInfo.GetCultureInfo("en-US"), CultureInfo.GetCultureInfo("fr-FR")];
+            var length = new FlexBasis(1.2d, FlexBasisKind.Absolute);
+
+            foreach (var culture in cultureInfos)
+            {
+                await Task.Run(() =>
+                {
+                    CultureInfo.CurrentCulture = culture;
+                    Assert.Equal("1.2", length.ToString());
+                }, TestContext.Current.CancellationToken);
+            }
+        }
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/FlexPanelTests.cs b/tests/Avalonia.Controls.UnitTests/FlexPanelTests.cs
new file mode 100644
index 0000000000..f3418c75db
--- /dev/null
+++ b/tests/Avalonia.Controls.UnitTests/FlexPanelTests.cs
@@ -0,0 +1,415 @@
+using System;
+using Avalonia.Layout;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Controls.UnitTests
+{
+    public class FlexPanelTests : ScopedTestBase
+    {
+        [Fact]
+        public void Lays_Items_In_A_Single_Row()
+        {
+            var target = new FlexPanel()
+            {
+                Width = 200,
+                Children =
+                {
+                    new Border { Height = 50, Width = 100 },
+                    new Border { Height = 50, Width = 100 },
+                }
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(200, 50), target.Bounds.Size);
+            Assert.Equal(new Rect(0, 0, 100, 50), target.Children[0].Bounds);
+            Assert.Equal(new Rect(100, 0, 100, 50), target.Children[1].Bounds);
+        }
+
+        [Fact]
+        public void Lays_Items_In_A_Single_Column()
+        {
+            var target = new FlexPanel()
+            {
+                Direction = FlexDirection.Column,
+                Height = 120,
+                Children =
+                {
+                    new Border { Height = 50, Width = 100 },
+                    new Border { Height = 50, Width = 100 },
+                }
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(100, 120), target.Bounds.Size);
+            Assert.Equal(new Rect(0, 0, 100, 50), target.Children[0].Bounds);
+            Assert.Equal(new Rect(0, 50, 100, 50), target.Children[1].Bounds);
+        }
+
+        [Fact]
+        public void Can_Wrap_Items_Into_Next_Row()
+        {
+            var target = new FlexPanel()
+            {
+                Width = 100,
+                Children =
+                {
+                    new Border { Height = 50, Width = 100 },
+                    new Border { Height = 50, Width = 100 },
+                },
+                Wrap = FlexWrap.Wrap
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(100, 100), target.Bounds.Size);
+            Assert.Equal(new Rect(0, 0, 100, 50), target.Children[0].Bounds);
+            Assert.Equal(new Rect(0, 50, 100, 50), target.Children[1].Bounds);
+        }
+
+        [Fact]
+        public void Can_Wrap_Items_Into_Next_Row_In_Reverse_Wrap()
+        {
+            var target = new FlexPanel()
+            {
+                Width = 100,
+                Children =
+                {
+                    new Border { Height = 50, Width = 100 },
+                    new Border { Height = 50, Width = 100 },
+                },
+                Wrap = FlexWrap.WrapReverse
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(100, 100), target.Bounds.Size);
+            Assert.Equal(new Rect(0, 50, 100, 50), target.Children[0].Bounds);
+            Assert.Equal(new Rect(0, 0, 100, 50), target.Children[1].Bounds);
+        }
+
+        [Fact]
+        public void Can_Wrap_Items_Into_Next_Column()
+        {
+            var target = new FlexPanel()
+            {
+                Height = 60,
+                Children =
+                {
+                    new Border { Height = 50, Width = 100 },
+                    new Border { Height = 50, Width = 100 },
+                },
+                Wrap = FlexWrap.Wrap,
+                Direction = FlexDirection.Column
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(200, 60), target.Bounds.Size);
+            Assert.Equal(new Rect(0, 0, 100, 50), target.Children[0].Bounds);
+            Assert.Equal(new Rect(100, 0, 100, 50), target.Children[1].Bounds);
+        }
+
+        [Fact]
+        public void Can_Wrap_Items_Into_Next_Column_In_Reverse_Wrap()
+        {
+            var target = new FlexPanel()
+            {
+                Height = 60,
+                Children =
+                {
+                    new Border { Height = 50, Width = 100 },
+                    new Border { Height = 50, Width = 100 },
+                },
+                Wrap = FlexWrap.WrapReverse,
+                Direction = FlexDirection.Column
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(200, 60), target.Bounds.Size);
+            Assert.Equal(new Rect(100, 0, 100, 50), target.Children[0].Bounds);
+            Assert.Equal(new Rect(0, 0, 100, 50), target.Children[1].Bounds);
+        }
+
+        public static TheoryData<FlexDirection, FlexAlignItems> GetAlignItemsValues()
+        {
+            var data = new TheoryData<FlexDirection, FlexAlignItems>();
+            foreach (var direction in Enum.GetValues<FlexDirection>())
+            {
+                foreach (var alignment in Enum.GetValues<FlexAlignItems>())
+                {
+                    data.Add(direction, alignment);
+                }
+            }
+            return data;
+        }
+
+        public static TheoryData<FlexDirection, FlexJustifyContent> GetJustifyContentValues()
+        {
+            var data = new TheoryData<FlexDirection, FlexJustifyContent>();
+            foreach (var direction in Enum.GetValues<FlexDirection>())
+            {
+                foreach (var justify in Enum.GetValues<FlexJustifyContent>())
+                {
+                    data.Add(direction, justify);
+                }
+            }
+            return data;
+        }
+
+        [Theory, MemberData(nameof(GetAlignItemsValues))]
+        public void Lays_Out_With_Items_Alignment(FlexDirection direction, FlexAlignItems itemsAlignment)
+        {
+            var target = new FlexPanel()
+            {
+                Width = 200,
+                Height = 200,
+                Direction = direction,
+                AlignItems = itemsAlignment,
+                Children =
+                {
+                    new Border { Height = 50, Width = 50 },
+                    new Border { Height = 50, Width = 50 },
+                }
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(200, 200), target.Bounds.Size);
+
+            var rowBounds = target.Children[0].Bounds.Union(target.Children[1].Bounds);
+
+            Assert.Equal(direction switch
+            {
+                FlexDirection.Row => new(100, 50),
+                FlexDirection.RowReverse => new(100, 50),
+                FlexDirection.Column => new(50, 100),
+                FlexDirection.ColumnReverse => new(50, 100),
+                _ => throw new NotImplementedException()
+            }, rowBounds.Size);
+
+            Assert.Equal((direction, itemsAlignment) switch
+            {
+                (FlexDirection.Row, FlexAlignItems.FlexStart) => new(0, 0),
+                (FlexDirection.Column, FlexAlignItems.FlexStart) => new(0, 0),
+                (FlexDirection.Row, FlexAlignItems.Center) => new(0, 75),
+                (FlexDirection.Column, FlexAlignItems.Center) => new(75, 0),
+                (FlexDirection.Row, FlexAlignItems.FlexEnd) => new(0, 150),
+                (FlexDirection.Column, FlexAlignItems.FlexEnd) => new(150, 0),
+                (FlexDirection.Row, FlexAlignItems.Stretch) => new(0, 75),
+                (FlexDirection.Column, FlexAlignItems.Stretch) => new(75, 0),
+                (FlexDirection.RowReverse, FlexAlignItems.FlexStart) => new(100, 0),
+                (FlexDirection.ColumnReverse, FlexAlignItems.FlexStart) => new(0, 100),
+                (FlexDirection.RowReverse, FlexAlignItems.Center) => new(100, 75),
+                (FlexDirection.ColumnReverse, FlexAlignItems.Center) => new(75, 100),
+                (FlexDirection.RowReverse, FlexAlignItems.FlexEnd) => new(100, 150),
+                (FlexDirection.ColumnReverse, FlexAlignItems.FlexEnd) => new(150, 100),
+                (FlexDirection.RowReverse, FlexAlignItems.Stretch) => new(100, 75),
+                (FlexDirection.ColumnReverse, FlexAlignItems.Stretch) => new(75, 100),
+                _ => throw new NotImplementedException(),
+            }, rowBounds.Position);
+        }
+
+        [Theory, MemberData(nameof(GetJustifyContentValues))]
+        public void Lays_Out_With_Justify_Content(FlexDirection direction, FlexJustifyContent justify)
+        {
+            var target = new FlexPanel()
+            {
+                Width = 200,
+                Height = 200,
+                Direction = direction,
+                JustifyContent = justify,
+                AlignItems = FlexAlignItems.FlexStart,
+                Children =
+                {
+                    new Border { Height = 50, Width = 50 },
+                    new Border { Height = 50, Width = 50 },
+                }
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(200, 200), target.Bounds.Size);
+
+            var rowBounds = target.Children[0].Bounds.Union(target.Children[1].Bounds);
+
+            Assert.Equal((direction, justify) switch
+            {
+                (FlexDirection.Row, FlexJustifyContent.FlexStart) => new(0, 0),
+                (FlexDirection.Column, FlexJustifyContent.FlexStart) => new(0, 0),
+                (FlexDirection.Row, FlexJustifyContent.Center) => new(50, 0),
+                (FlexDirection.Column, FlexJustifyContent.Center) => new(0, 50),
+                (FlexDirection.Row, FlexJustifyContent.FlexEnd) => new(100, 0),
+                (FlexDirection.Column, FlexJustifyContent.FlexEnd) => new(0, 100),
+                (FlexDirection.Row, FlexJustifyContent.SpaceAround) => new(25, 0),
+                (FlexDirection.Column, FlexJustifyContent.SpaceAround) => new(0, 25),
+                (FlexDirection.Row, FlexJustifyContent.SpaceBetween) => new(0, 0),
+                (FlexDirection.Column, FlexJustifyContent.SpaceBetween) => new(0, 0),
+                (FlexDirection.Row, FlexJustifyContent.SpaceEvenly) => new(33, 0),
+                (FlexDirection.Column, FlexJustifyContent.SpaceEvenly) => new(0, 33),
+                (FlexDirection.RowReverse, FlexJustifyContent.FlexStart) => new(100, 0),
+                (FlexDirection.ColumnReverse, FlexJustifyContent.FlexStart) => new(0, 100),
+                (FlexDirection.RowReverse, FlexJustifyContent.Center) => new(50, 0),
+                (FlexDirection.ColumnReverse, FlexJustifyContent.Center) => new(0, 50),
+                (FlexDirection.RowReverse, FlexJustifyContent.FlexEnd) => new(0, 0),
+                (FlexDirection.ColumnReverse, FlexJustifyContent.FlexEnd) => new(0, 0),
+                (FlexDirection.RowReverse, FlexJustifyContent.SpaceAround) => new(25, 0),
+                (FlexDirection.ColumnReverse, FlexJustifyContent.SpaceAround) => new(0, 25),
+                (FlexDirection.RowReverse, FlexJustifyContent.SpaceBetween) => new(0, 0),
+                (FlexDirection.ColumnReverse, FlexJustifyContent.SpaceBetween) => new(0, 0),
+                (FlexDirection.RowReverse, FlexJustifyContent.SpaceEvenly) => new(33, 0),
+                (FlexDirection.ColumnReverse, FlexJustifyContent.SpaceEvenly) => new(0, 33),
+                _ => throw new NotImplementedException(),
+            }, rowBounds.Position);
+        }
+
+        [Fact]
+        public void Can_Wrap_Items_Into_Next_Row_With_Spacing()
+        {
+            var target = new FlexPanel()
+            {
+                Width = 110,
+                ColumnSpacing = 10,
+                RowSpacing = 20,
+                Children =
+                {
+                    new Border { Height = 50, Width = 60 }, // line 0
+                    new Border { Height = 50, Width = 30 }, // line 0
+                    new Border { Height = 50, Width = 70 }, // line 1
+                    new Border { Height = 50, Width = 30 }, // line 2
+                },
+                Wrap = FlexWrap.Wrap
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(110, 190), target.Bounds.Size);
+            Assert.Equal(new Rect(0, 0, 60, 50), target.Children[0].Bounds);
+            Assert.Equal(new Rect(70, 0, 30, 50), target.Children[1].Bounds);
+            Assert.Equal(new Rect(0, 70, 70, 50), target.Children[2].Bounds);
+            Assert.Equal(new Rect(0, 140, 30, 50), target.Children[3].Bounds);
+        }
+
+        [Fact]
+        public void Can_Wrap_Items_Into_Next_Row_With_Spacing_And_Invisible_Content()
+        {
+            var target = new FlexPanel()
+            {
+                ColumnSpacing = 10,
+                Children =
+                {
+                    new Border { Height = 50, Width = 60 }, // line 0
+                    new Border { Height = 50, Width = 30 , IsVisible = false }, // line 0
+                    new Border { Height = 50, Width = 50 }, // line 0
+                },
+                Wrap = FlexWrap.Wrap
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(120, 50), target.Bounds.Size);
+            Assert.Equal(new Rect(0, 0, 60, 50), target.Children[0].Bounds);
+            Assert.Equal(new Rect(70, 0, 50, 50), target.Children[2].Bounds);
+        }
+
+        [Fact]
+        public void Can_Wrap_Items_Into_Next_Column_With_Spacing()
+        {
+            var target = new FlexPanel()
+            {
+                Height = 110,
+                RowSpacing = 10,
+                ColumnSpacing = 20,
+                Children =
+                {
+                    new Border { Width = 50, Height = 60 }, // line 0
+                    new Border { Width = 50, Height = 30 }, // line 0
+                    new Border { Width = 50, Height = 70 }, // line 1
+                    new Border { Width = 50, Height = 30 }, // line 2
+                },
+                Wrap = FlexWrap.Wrap,
+                Direction = FlexDirection.Column
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(190, 110), target.Bounds.Size);
+            Assert.Equal(new Rect(0, 0, 50, 60), target.Children[0].Bounds);
+            Assert.Equal(new Rect(0, 70, 50, 30), target.Children[1].Bounds);
+            Assert.Equal(new Rect(70, 0, 50, 70), target.Children[2].Bounds);
+            Assert.Equal(new Rect(140, 0, 50, 30), target.Children[3].Bounds);
+        }
+
+        [Fact]
+        public void Applies_Absolute_FlexBasis_Properties()
+        {
+            var target = new FlexPanel()
+            {
+                Width = 50,
+                Children =
+                {
+                    new Border()
+                    {
+                        [Flex.BasisProperty] = new FlexBasis(20),
+                        Height = 15
+                    },
+                    new Border()
+                    {
+                        [Flex.BasisProperty] = new FlexBasis(20),
+                        Height = 15
+                    }
+                }
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(50, 15), target.Bounds.Size);
+            Assert.Equal(new Rect(0, 0, 20, 15), target.Children[0].Bounds);
+            Assert.Equal(new Rect(20, 0, 20, 15), target.Children[1].Bounds);
+        }
+
+        [Fact]
+        public void Applies_Relative_FlexBasis_Properties()
+        {
+            var target = new FlexPanel()
+            {
+                Width = 50,
+                Children =
+                {
+                    new Border()
+                    {
+                        [Flex.BasisProperty] = new FlexBasis(50, FlexBasisKind.Relative),
+                        Height = 15
+                    },
+                    new Border()
+                    {
+                        [Flex.BasisProperty] = new FlexBasis(50, FlexBasisKind.Relative),
+                        Height = 15
+                    }
+                }
+            };
+
+            target.Measure(Size.Infinity);
+            target.Arrange(new Rect(target.DesiredSize));
+
+            Assert.Equal(new Size(50, 15), target.Bounds.Size);
+            Assert.Equal(new Rect(0, 0, 25, 15), target.Children[0].Bounds);
+            Assert.Equal(new Rect(25, 0, 25, 15), target.Children[1].Bounds);
+        }
+    }
+}

From cc1dbbd062306e70442937642916c78c617bdf9a Mon Sep 17 00:00:00 2001
From: Julien Lebosquain <julien@lebosquain.net>
Date: Mon, 24 Aug 2026 22:25:23 +0000
Subject: [PATCH 196/196] Wayland: handle (0,0) surface size (#21863)

---
 .../Server/Persistent/WSurface.cs               |  8 +++++++-
 .../Rendering/WaylandEglDmaBufSurface.cs        |  9 ++++++---
 .../Transient/Rendering/WaylandEglWsiSurface.cs | 17 +++++++++++------
 .../Transient/Rendering/WaylandFramebuffer.cs   |  4 +++-
 4 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/src/Avalonia.Wayland/Server/Persistent/WSurface.cs b/src/Avalonia.Wayland/Server/Persistent/WSurface.cs
index 1db7515b74..b429f644b9 100644
--- a/src/Avalonia.Wayland/Server/Persistent/WSurface.cs
+++ b/src/Avalonia.Wayland/Server/Persistent/WSurface.cs
@@ -591,6 +591,12 @@ class WXdgShellSurface : WSurface, IWXdgShellSurface
             surfaceHeight = (bufferPixelSize.Height + intScale - 1) / intScale;
         }
 
+        if (surfaceWidth <= 0 || surfaceHeight <= 0)
+        {
+            LastWindowGeometry = null;
+            return;
+        }
+
         var left = Math.Clamp((int)shadowExtents.Left, 0, surfaceWidth - 1);
         var top = Math.Clamp((int)shadowExtents.Top, 0, surfaceHeight - 1);
         var right = Math.Clamp(
@@ -1101,4 +1107,4 @@ class WXdgPopup : WXdgShellSurface, IWXdgPopup
         _pendingBatch = new();
         base.OnDisconnected();
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufSurface.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufSurface.cs
index 8917a6e18c..6cc698e95d 100644
--- a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufSurface.cs
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglDmaBufSurface.cs
@@ -55,7 +55,10 @@ internal class WaylandEglDmaBufSurface : EglGlPlatformImageSurfaceBase, IPlatfor
             if (!_parent._surface.State.IsReady)
                 throw new RenderTargetNotReadyException();
 
-            EnsureSwapchain(sceneInfo.Size);
+            var size = sceneInfo.Size;
+            size = new PixelSize(Math.Max(1, size.Width), Math.Max(1, size.Height));
+
+            EnsureSwapchain(size);
 
             // Select least recently used free slot
             BufferSlot? freeSlot = null;
@@ -70,7 +73,7 @@ internal class WaylandEglDmaBufSurface : EglGlPlatformImageSurfaceBase, IPlatfor
 
             var capturedSlot = freeSlot;
             capturedSlot.LastUsedFrame = ++_frameCounter;
-            return BeginDraw(capturedSlot.EglImage!.Handle, sceneInfo.Size, sceneInfo.Scaling, () =>
+            return BeginDraw(capturedSlot.EglImage!.Handle, size, sceneInfo.Scaling, () =>
             {
                 // Stage per-frame state (frame callback + ack_configure +
                 // geometry + viewport/scale + min/max) into the next
@@ -79,7 +82,7 @@ internal class WaylandEglDmaBufSurface : EglGlPlatformImageSurfaceBase, IPlatfor
                 // issues the commit itself.
                 _parent._surface.OnBeforeNewBufferAttached(sceneInfo);
                 _parent._surface.WlSurface!.Attach(capturedSlot.WlBuffer!, 0, 0);
-                _parent._surface.WlSurface.DamageBuffer(0, 0, sceneInfo.Size.Width, sceneInfo.Size.Height);
+                _parent._surface.WlSurface.DamageBuffer(0, 0, size.Width, size.Height);
                 capturedSlot.Busy = true;
                 _parent._surface.WlSurface.Commit();
             });
diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs
index 9073d984ff..4db0f67154 100644
--- a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandEglWsiSurface.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using Avalonia.OpenGL;
 using Avalonia.OpenGL.Egl;
 using Avalonia.OpenGL.Surfaces;
@@ -64,7 +65,10 @@ internal sealed class WaylandEglWsiSurface : EglGlPlatformSurfaceBase, IPlatform
             if (!_surface.State.IsReady)
                 throw new RenderTargetNotReadyException();
 
-            EnsureWindow(sceneInfo.Size);
+            var size = sceneInfo.Size;
+            size = new PixelSize(Math.Max(1, size.Width), Math.Max(1, size.Height));
+
+            EnsureWindow(size);
 
             // OnBeforeNewBufferAttached must run *immediately* before the
             // implicit commit performed by eglSwapBuffers; the base class
@@ -73,7 +77,7 @@ internal sealed class WaylandEglWsiSurface : EglGlPlatformSurfaceBase, IPlatform
             // SwapInterval(0) is set inside beforeSwap (so it runs with our
             // surface current); GTK re-asserts it every frame defensively
             // and we follow suit — some drivers reset it on resize.
-            var session = BeginDraw(_eglSurface!, sceneInfo.Size, sceneInfo.Scaling,
+            var session = BeginDraw(_eglSurface!, size, sceneInfo.Scaling,
                 beforeSwap: () =>
                 {
                     var display = Context.Display;
@@ -86,7 +90,7 @@ internal sealed class WaylandEglWsiSurface : EglGlPlatformSurfaceBase, IPlatform
             if (session.Context.Version.Type == GlProfileType.OpenGL)
             {
                 var gl = session.Context.GlInterface;
-                gl.Viewport(0, 0, sceneInfo.Size.Width, sceneInfo.Size.Height);
+                gl.Viewport(0, 0, size.Width, size.Height);
                 if (gl.IsReadBufferAvailable)
                     gl.ReadBuffer(GL_BACK);
                 if (gl.IsWriteBufferAvailable)
@@ -118,13 +122,15 @@ internal sealed class WaylandEglWsiSurface : EglGlPlatformSurfaceBase, IPlatform
 
         private void EnsureWindow(PixelSize size)
         {
+            Debug.Assert(size.Width > 0 && size.Height > 0);
+
             if (_eglWindow != IntPtr.Zero && _currentSize == size)
                 return;
 
             if (_eglWindow == IntPtr.Zero)
             {
                 _eglWindow = WaylandEglNativeMethods.wl_egl_window_create(
-                    _surface.WlSurface!.Handle, Math.Max(1, size.Width), Math.Max(1, size.Height));
+                    _surface.WlSurface!.Handle, size.Width, size.Height);
                 if (_eglWindow == IntPtr.Zero)
                     throw new OpenGlException("wl_egl_window_create failed");
 
@@ -141,8 +147,7 @@ internal sealed class WaylandEglWsiSurface : EglGlPlatformSurfaceBase, IPlatform
             }
             else
             {
-                WaylandEglNativeMethods.wl_egl_window_resize(_eglWindow,
-                    Math.Max(1, size.Width), Math.Max(1, size.Height), 0, 0);
+                WaylandEglNativeMethods.wl_egl_window_resize(_eglWindow, size.Width, size.Height, 0, 0);
             }
 
             _currentSize = size;
diff --git a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs
index 65d8a9c6df..99dbb971ea 100644
--- a/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs
+++ b/src/Avalonia.Wayland/Server/Transient/Rendering/WaylandFramebuffer.cs
@@ -47,7 +47,9 @@ class WaylandFramebuffer(IWaylandFramebufferSurface surface) : IFramebufferPlatf
                 throw new RenderTargetNotReadyException();
 
             var size = sceneInfo.Size;
-            var bufferLen = sceneInfo.Size.Width * sceneInfo.Size.Height * 4;
+            size = new PixelSize(Math.Max(1, size.Width), Math.Max(1, size.Height));
+
+            var bufferLen = size.Width * size.Height * 4;
             var stride = size.Width * 4;
             
             var fd = memfd_create("avalonia-wayland-framebuffer", MFD_CLOEXEC);