diff --git a/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Content/Controls/ShadowContainerSamplePage.WinUI.xaml b/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Content/Controls/ShadowContainerSamplePage.WinUI.xaml
index 8c83612be..0cdee50bf 100644
--- a/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Content/Controls/ShadowContainerSamplePage.WinUI.xaml
+++ b/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Content/Controls/ShadowContainerSamplePage.WinUI.xaml
@@ -84,227 +84,228 @@
 	</Page.Resources>
 
 	<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
-		<sample:SamplePageLayout x:Name="SamplePageLayout"
-								 IsDesignAgnostic="True">
+		<sample:SamplePageLayout x:Name="SamplePageLayout" IsDesignAgnostic="True">
 			<sample:SamplePageLayout.DesignAgnosticTemplate>
 				<DataTemplate>
 					<ScrollViewer HorizontalScrollMode="Disabled">
-						<StackPanel>
+						<StackPanel Spacing="24">
 
-							<TextBlock Margin="0,24,0,0"
-									   Style="{StaticResource TitleTextBlockStyle}"
-									   Text="Many colored shadows" />
-							<TextBlock Style="{StaticResource BodyTextBlockStyle}"
-									   Text="You can add as many shadows as you like. You can also dynamically change the shadow properties." />
+							<StackPanel>
+								<TextBlock Text="Many colored shadows" Style="{StaticResource TitleTextBlockStyle}" />
+								<TextBlock Text="You can add as many shadows as you like. You can also dynamically change the shadow properties." Style="{StaticResource BodyTextBlockStyle}" />
 
-							<utu:ShadowContainer x:Name="ShadowContainer"
-												 Margin="32">
-								<utu:ShadowContainer.Shadows>
-									<utu:ShadowCollection x:Name="Shadows">
-										<utu:Shadow BlurRadius="20"
-													OffsetX="10"
-													OffsetY="10"
-													Opacity="0.5"
-													Spread="0"
-													Color="{StaticResource UnoColor}" />
-										<utu:Shadow BlurRadius="20"
-													OffsetX="-10"
-													OffsetY="-10"
-													Opacity="0.5"
-													Spread="0"
-													Color="{StaticResource UnoPink}" />
-									</utu:ShadowCollection>
-								</utu:ShadowContainer.Shadows>
-								<StackPanel MinWidth="300"
-											MaxWidth="500"
-											Padding="16"
-											Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"
-											BorderBrush="{StaticResource CardStrokeColorDefaultBrush}"
-											BorderThickness="1"
-											CornerRadius="20">
-									<ItemsControl x:Name="ShadowsItemsControl">
-										<ItemsControl.ItemsPanel>
-											<ItemsPanelTemplate>
-												<StackPanel Orientation="Vertical"
-															Spacing="10" />
-											</ItemsPanelTemplate>
-										</ItemsControl.ItemsPanel>
-										<ItemsControl.ItemTemplate>
-											<DataTemplate>
-												<Grid ColumnSpacing="5"
-													  RowSpacing="5">
-													<Grid.RowDefinitions>
-														<RowDefinition Height="Auto" />
-														<RowDefinition Height="Auto" />
-													</Grid.RowDefinitions>
-													<Grid.ColumnDefinitions>
-														<ColumnDefinition Width="70" />
-														<ColumnDefinition Width="70" />
-														<ColumnDefinition Width="60" />
-														<ColumnDefinition Width="80" />
-													</Grid.ColumnDefinitions>
+								<utu:ShadowContainer x:Name="ShadowContainer"
+													 Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"
+													 CornerRadius="20"
+													 Margin="32">
+									<utu:ShadowContainer.Shadows>
+										<utu:ShadowCollection x:Name="Shadows">
+											<utu:Shadow BlurRadius="20"
+														OffsetX="10"
+														OffsetY="10"
+														Opacity="0.5"
+														Spread="0"
+														Color="{StaticResource UnoColor}" />
+											<utu:Shadow BlurRadius="20"
+														OffsetX="-10"
+														OffsetY="-10"
+														Opacity="0.5"
+														Spread="0"
+														Color="{StaticResource UnoPink}" />
+										</utu:ShadowCollection>
+									</utu:ShadowContainer.Shadows>
+									<StackPanel MinWidth="300"
+												MaxWidth="500"
+												Padding="16"
+												BorderBrush="{StaticResource CardStrokeColorDefaultBrush}"
+												CornerRadius="20"
+												BorderThickness="1">
+										<ItemsControl x:Name="ShadowsItemsControl">
+											<ItemsControl.ItemsPanel>
+												<ItemsPanelTemplate>
+													<StackPanel Orientation="Vertical" Spacing="10" />
+												</ItemsPanelTemplate>
+											</ItemsControl.ItemsPanel>
+											<ItemsControl.ItemTemplate>
+												<DataTemplate>
+													<Grid ColumnSpacing="5" RowSpacing="5">
+														<Grid.RowDefinitions>
+															<RowDefinition Height="Auto" />
+															<RowDefinition Height="Auto" />
+														</Grid.RowDefinitions>
+														<Grid.ColumnDefinitions>
+															<ColumnDefinition Width="70" />
+															<ColumnDefinition Width="70" />
+															<ColumnDefinition Width="60" />
+															<ColumnDefinition Width="80" />
+														</Grid.ColumnDefinitions>
 
-													<TextBox Grid.ColumnSpan="2"
-															 PlaceholderText="Color"
-															 Text="{Binding Color, Mode=TwoWay, Converter={StaticResource HexToColor}}">
-														<TextBox.Foreground>
-															<SolidColorBrush Color="{Binding Color}" />
-														</TextBox.Foreground>
-													</TextBox>
-													<TextBox Grid.Column="2"
-															 PlaceholderText="Opacity"
-															 Text="{Binding Opacity, Mode=TwoWay}" />
-													<CheckBox Grid.Column="3"
-															  Padding="5,0"
-															  Content="Inner"
-															  IsChecked="{Binding IsInner, Mode=TwoWay}" />
+														<TextBox Grid.ColumnSpan="2"
+																 PlaceholderText="Color"
+																 Text="{Binding Color, Mode=TwoWay, Converter={StaticResource HexToColor}}">
+															<TextBox.Foreground>
+																<SolidColorBrush Color="{Binding Color}" />
+															</TextBox.Foreground>
+														</TextBox>
+														<TextBox Grid.Column="2"
+																 PlaceholderText="Opacity"
+																 Text="{Binding Opacity, Mode=TwoWay}" />
+														<CheckBox Grid.Column="3"
+																  Padding="5,0"
+																  Content="Inner"
+																  IsChecked="{Binding IsInner, Mode=TwoWay}" />
 
-													<TextBox Grid.Row="1"
-															 PlaceholderText="X"
-															 Text="{Binding OffsetX, Mode=TwoWay}" />
-													<TextBox Grid.Row="1"
-															 Grid.Column="1"
-															 PlaceholderText="Y"
-															 Text="{Binding OffsetY, Mode=TwoWay}" />
-													<TextBox Grid.Row="1"
-															 Grid.Column="2"
-															 PlaceholderText="Blur"
-															 Text="{Binding BlurRadius, Mode=TwoWay}" />
-													<TextBox Grid.Row="1"
-															 Grid.Column="3"
-															 PlaceholderText="Spread"
-															 Text="{Binding Spread, Mode=TwoWay}" />
+														<TextBox Grid.Row="1"
+																 PlaceholderText="X"
+																 Text="{Binding OffsetX, Mode=TwoWay}" />
+														<TextBox Grid.Row="1"
+																 Grid.Column="1"
+																 PlaceholderText="Y"
+																 Text="{Binding OffsetY, Mode=TwoWay}" />
+														<TextBox Grid.Row="1"
+																 Grid.Column="2"
+																 PlaceholderText="Blur"
+																 Text="{Binding BlurRadius, Mode=TwoWay}" />
+														<TextBox Grid.Row="1"
+																 Grid.Column="3"
+																 PlaceholderText="Spread"
+																 Text="{Binding Spread, Mode=TwoWay}" />
 
-												</Grid>
-											</DataTemplate>
-										</ItemsControl.ItemTemplate>
-									</ItemsControl>
-									<StackPanel Margin="0,16,0,0"
-												HorizontalAlignment="Center"
-												Orientation="Horizontal"
-												Spacing="16">
-										<utu:ShadowContainer Shadows="{StaticResource ButtonShadows}">
-											<Button Background="{StaticResource UnoColor}"
-													BorderThickness="1"
-													Click="AddShadow"
-													Content="Add Shadow"
-													Foreground="White" />
-										</utu:ShadowContainer>
-										<utu:ShadowContainer Shadows="{StaticResource ButtonShadows}">
-											<Button Background="{StaticResource UnoColor}"
-													BorderThickness="1"
-													Click="RemoveShadow"
-													Content="Remove Shadow"
-													Foreground="White" />
-										</utu:ShadowContainer>
+													</Grid>
+												</DataTemplate>
+											</ItemsControl.ItemTemplate>
+										</ItemsControl>
+										<StackPanel Margin="0,16,0,0"
+													HorizontalAlignment="Center"
+													Orientation="Horizontal"
+													Spacing="16">
+											<utu:ShadowContainer Background="{StaticResource UnoColor}"
+																 CornerRadius="20"
+																 Shadows="{StaticResource ButtonShadows}">
+												<Button Content="Add Shadow"
+														Click="AddShadow"
+														Background="Transparent"
+														BorderThickness="1"
+														Foreground="White" />
+											</utu:ShadowContainer>
+											<utu:ShadowContainer Background="{StaticResource UnoColor}"
+																 CornerRadius="20"
+																 Shadows="{StaticResource ButtonShadows}">
+												<Button Content="Remove Shadow"
+														Click="RemoveShadow"
+														Background="Transparent"
+														BorderThickness="1"
+														Foreground="White" />
+											</utu:ShadowContainer>
+										</StackPanel>
 									</StackPanel>
-								</StackPanel>
-							</utu:ShadowContainer>
-
-
-							<TextBlock Margin="0,24,0,0"
-									   Style="{StaticResource TitleTextBlockStyle}"
-									   Text="Enable neumorphism" />
-							<TextBlock Style="{StaticResource BodyTextBlockStyle}"
-									   Text="Being able to add several shadows enables you to create neumorphic designs." />
-
-
-							<StackPanel Width="400"
-										Margin="0,32"
-										Padding="32"
-										Background="{StaticResource UnoColor}"
-										CornerRadius="30">
-								<utu:ShadowContainer Shadows="{StaticResource NeumorphismRaising}">
-									<Grid Width="300"
-										  Padding="20"
-										  Background="{StaticResource UnoColor}"
-										  CornerRadius="20">
-										<Grid.RowDefinitions>
-											<RowDefinition Height="20" />
-											<RowDefinition Height="20" />
-										</Grid.RowDefinitions>
-
-										<TextBlock FontSize="15"
-												   Foreground="White"
-												   Text="Neumorphism" />
-										<TextBlock Grid.Row="1"
-												   FontSize="12"
-												   Foreground="White"
-												   Text="Raising element" />
-									</Grid>
 								</utu:ShadowContainer>
+							</StackPanel>
 
-								<utu:ShadowContainer Margin="0,60,0,0"
-													 Shadows="{StaticResource NeumorphismHollow}">
-									<TextBox Width="200"
-											 Padding="10"
-											 Background="{StaticResource UnoColor}"
-											 BorderThickness="0"
-											 CornerRadius="20"
-											 Foreground="White"
-											 PlaceholderForeground="LightGray"
-											 PlaceholderText="Hollow element"
-											 Text="Login" />
-								</utu:ShadowContainer>
-								<utu:ShadowContainer Margin="0,15"
-													 Shadows="{StaticResource NeumorphismHollow}">
-									<TextBox Width="200"
-											 Padding="10"
-											 Background="{StaticResource UnoColor}"
-											 BorderThickness="0"
-											 CornerRadius="20"
-											 Foreground="White"
-											 PlaceholderForeground="LightGray"
-											 PlaceholderText="Hollow element"
-											 Text="Password" />
-								</utu:ShadowContainer>
+							<StackPanel>
+								<TextBlock Text="Enable neumorphism" Style="{StaticResource TitleTextBlockStyle}" />
+								<TextBlock Text="Being able to add several shadows enables you to create neumorphic designs." Style="{StaticResource BodyTextBlockStyle}" />
 
-								<utu:ShadowContainer Margin="0,30"
-													 Shadows="{StaticResource NeumorphismBulging}">
-									<Button Width="200"
-											Height="40"
+								<StackPanel Width="400"
+											Margin="0,20"
+											Padding="20"
 											Background="{StaticResource UnoColor}"
-											BorderBrush="{StaticResource UnoColor}"
-											Content="Bulging element"
-											CornerRadius="15"
-											Foreground="White" />
-								</utu:ShadowContainer>
+											CornerRadius="30">
+									<utu:ShadowContainer Shadows="{StaticResource NeumorphismRaising}">
+										<Grid Width="300"
+											  Padding="20"
+											  Background="{StaticResource UnoColor}"
+											  CornerRadius="20">
+											<Grid.RowDefinitions>
+												<RowDefinition Height="20" />
+												<RowDefinition Height="20" />
+											</Grid.RowDefinitions>
 
-								<StackPanel Margin="0,30,0,0"
-											Padding="24"
-											HorizontalAlignment="Center"
-											Orientation="Horizontal"
-											Spacing="16">
+											<TextBlock FontSize="15"
+													   Foreground="White"
+													   Text="Neumorphism" />
+											<TextBlock Grid.Row="1"
+													   FontSize="12"
+													   Foreground="White"
+													   Text="Raising element" />
+										</Grid>
+									</utu:ShadowContainer>
 
-									<utu:ShadowContainer Shadows="{StaticResource NeumorphismRaising}">
-										<Button Background="{StaticResource UnoColor}"
-												BorderThickness="0"
-												Content="Regular"
-												Foreground="White" />
+									<utu:ShadowContainer Margin="0,60,0,0"
+														 Background="{StaticResource UnoColor}"
+														 Shadows="{StaticResource NeumorphismHollow}">
+										<TextBox Width="200"
+												 Padding="10"
+												 BorderThickness="0"
+												 CornerRadius="20"
+												 Foreground="White"
+												 PlaceholderForeground="LightGray"
+												 PlaceholderText="Hollow element"
+												 Text="Login" />
+									</utu:ShadowContainer>
+									<utu:ShadowContainer Background="{StaticResource UnoColor}"
+														 Shadows="{StaticResource NeumorphismHollow}"
+														 Margin="0,15">
+										<TextBox Width="200"
+												 Padding="10"
+												 BorderThickness="0"
+												 CornerRadius="20"
+												 Foreground="White"
+												 PlaceholderForeground="LightGray"
+												 PlaceholderText="Hollow element"
+												 Text="Password" />
 									</utu:ShadowContainer>
 
-									<utu:ShadowContainer Shadows="{StaticResource NeumorphismRaising}">
-										<Button Width="80"
-												Height="80"
-												Background="{StaticResource UnoColor}"
+									<utu:ShadowContainer Margin="0,30"
+														 Background="{StaticResource UnoColor}"
+														 Shadows="{StaticResource NeumorphismBulging}">
+										<Button Width="200"
+												Height="40"
 												BorderBrush="{StaticResource UnoColor}"
-												Content="Circular"
-												CornerRadius="40"
+												Content="Bulging element"
+												CornerRadius="15"
+												Background="Transparent"
 												Foreground="White" />
 									</utu:ShadowContainer>
 
-									<utu:ShadowContainer Shadows="{StaticResource NeumorphismRaising}">
-										<Button Height="60"
-												Background="{StaticResource UnoColor}"
-												BorderThickness="0"
-												Content="Bigger"
-												CornerRadius="20"
-												Foreground="White" />
-									</utu:ShadowContainer>
+									<StackPanel Margin="0,30,0,0"
+												Padding="16"
+												HorizontalAlignment="Center"
+												Orientation="Horizontal"
+												Spacing="16">
+
+										<utu:ShadowContainer Background="{StaticResource UnoColor}" Shadows="{StaticResource NeumorphismRaising}">
+											<Button Content="Regular"
+													CornerRadius="20"
+													BorderThickness="0"
+													Background="Transparent"
+													Foreground="White" />
+										</utu:ShadowContainer>
+
+										<utu:ShadowContainer Background="{StaticResource UnoColor}" Shadows="{StaticResource NeumorphismRaising}">
+											<Button Content="Round"
+													Width="100"
+													Height="100"
+													BorderBrush="{StaticResource UnoColor}"
+													CornerRadius="50"
+													Background="Transparent"
+													Foreground="White" />
+										</utu:ShadowContainer>
+
+										<utu:ShadowContainer Background="{StaticResource UnoColor}" Shadows="{StaticResource NeumorphismRaising}">
+											<Button Content="Bigger"
+													Height="60"
+													BorderThickness="0"
+													CornerRadius="20"
+													Background="Transparent"
+													Foreground="White" />
+										</utu:ShadowContainer>
+									</StackPanel>
 								</StackPanel>
+
 							</StackPanel>
-						</StackPanel>
 
+						</StackPanel>
 					</ScrollViewer>
 				</DataTemplate>
 			</sample:SamplePageLayout.DesignAgnosticTemplate>
diff --git a/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Content/TestPages/ShadowContainerTestPage.WinUI.xaml b/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Content/TestPages/ShadowContainerTestPage.WinUI.xaml
index 893ec0f6f..3bc5136eb 100644
--- a/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Content/TestPages/ShadowContainerTestPage.WinUI.xaml
+++ b/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Content/TestPages/ShadowContainerTestPage.WinUI.xaml
@@ -22,11 +22,11 @@
 					Padding="10"
 					Height="220"
 					Width="220">
-				<utu:ShadowContainer x:Name="shadowContainer">
+				<utu:ShadowContainer x:Name="shadowContainer"
+									 Background="Green">
 					<Border Width="200"
 							Height="200"
-							x:Name="border"
-							Background="Green" />
+							x:Name="border" />
 				</utu:ShadowContainer>
 			</Border>
 		</StackPanel>
diff --git a/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Converters/HexToColorConverter.cs b/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Converters/HexToColorConverter.cs
index eac558142..6c94765fd 100644
--- a/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Converters/HexToColorConverter.cs
+++ b/samples/Uno.Toolkit.Samples/Uno.Toolkit.Samples.Shared/Converters/HexToColorConverter.cs
@@ -16,7 +16,7 @@ public class HexToColorConverter : IValueConverter
 	{
 		public object Convert(object value, Type targetType, object parameter, string language)
 		{
-			return value.ToString();
+			return value?.ToString();
 		}
 
 		public object ConvertBack(object value, Type targetType, object parameter, string language)
diff --git a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/Shadow.cs b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/Shadow.cs
index f7f28444e..71ef7b5ba 100644
--- a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/Shadow.cs
+++ b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/Shadow.cs
@@ -148,16 +148,6 @@ public double Spread
 
 	public event PropertyChangedEventHandler? PropertyChanged;
 
-	internal static bool IsShadowProperty(string propertyName)
-	{
-		return propertyName == nameof(OffsetX) || propertyName == nameof(OffsetY) ||
-			   propertyName == nameof(IsInner) ||
-			   propertyName == nameof(Color) ||
-			   propertyName == nameof(Opacity) ||
-			   propertyName == nameof(BlurRadius) ||
-			   propertyName == nameof(Spread);
-	}
-
 	internal static bool IsShadowSizeProperty(string propertyName)
 	{
 		return propertyName == nameof(OffsetX) || propertyName == nameof(OffsetY) ||
@@ -174,9 +164,6 @@ private static void OnPropertyChanged(object dependencyObject, string propertyNa
 	public override string ToString() =>
 		$"{{ IsInner: {{{IsInner}}}, Offset: {{{OffsetX}, {OffsetY}}} Color: {{A={Color.A}, R={Color.R}, G={Color.G}, B={Color.B}}}, Opacity: {Opacity}, BlurRadius: {BlurRadius}, Spread: {Spread} }}";
 
-	public string ToKey() =>
-		string.Join(",", IsInner, OffsetX, OffsetY, Color.ToString(), Opacity, BlurRadius, Spread);
-
 	public Shadow Clone()
 	{
 		return new Shadow
diff --git a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowCollection.cs b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowCollection.cs
index ad1d163e8..bf947364c 100644
--- a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowCollection.cs
+++ b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowCollection.cs
@@ -6,10 +6,4 @@ namespace Uno.Toolkit.UI;
 
 public class ShadowCollection : ObservableCollection<Shadow>
 {
-	public bool HasInnerShadow() => this.Any(s => s.IsInner);
-
-	public string ToKey(double width, double height, Windows.UI.Color? contentBackground)
-		=> string.Create(CultureInfo.InvariantCulture, $"w{width},h{height}") +
-		(contentBackground.HasValue ? $",cb{contentBackground.Value}:" : ":") +
-		string.Join("/", this.Select(x => x.ToKey()));
 }
diff --git a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.Paint.cs b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.Paint.cs
index 14cdad866..cf91d3c87 100644
--- a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.Paint.cs
+++ b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.Paint.cs
@@ -1,23 +1,16 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
-
-using SkiaSharp;
-
-using Windows.UI;
-
 using Microsoft.Extensions.Logging;
-using Uno.Extensions;
-using Uno.Logging;
-
-#if IS_WINUI
+using Microsoft.UI;
+using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Media;
-using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Shapes;
+using SkiaSharp;
 using SkiaSharp.Views.Windows;
-#else
-using Windows.UI.Xaml.Media;
-using Windows.UI.Xaml.Controls;
-using SkiaSharp.Views.UWP;
-#endif
+using Uno.Extensions;
+using Uno.Logging;
+using Windows.UI;
 
 namespace Uno.Toolkit.UI;
 
@@ -25,358 +18,310 @@ public partial class ShadowContainer
 {
 	private static readonly ILogger _logger = typeof(ShadowContainer).Log();
 
-	private record ShadowInfos(double Width, double Height, bool IsInner, double BlurRadius, double Spread, double X, double Y, Color color)
-	{
-		public static readonly ShadowInfos Empty = new ShadowInfos(0, 0, false, 0, 0, 0, 0, new Color());
-
-		public static ShadowInfos From(Shadow shadow, double width, double height)
-		{
-			return new ShadowInfos(
-				width,
-				height,
-				shadow.IsInner,
-				shadow.BlurRadius,
-				shadow.Spread,
-				shadow.OffsetX,
-				shadow.OffsetY,
-				Color.FromArgb((byte)(shadow.Color.A * shadow.Opacity), shadow.Color.R, shadow.Color.G, shadow.Color.B));
-		}
-	}
+	// note: There "may" be a difference between windows vs skia in measurement; This ratio is recorded as the `PixelRatio` where: WindowsValue * PixelRatio = SkiaValue.
+	// To ease comprehension, values in `double` type is in windows unit, and values in `float` is in skia unit or windows unit scaled to skia.
 
-	private readonly record struct SKShadow(
-		bool IsInner,
-		float OffsetX,
-		float OffsetY,
-		float BlurSigma,
-		SKColor Color,
-		float Spread,
-		float ContentWidth,
-		float ContentHeight,
-		float CornerRadius)
-	{
-		public static SKShadow From(Shadow shadow, float width, float height, float cornerRadius, float pixelRatio)
-		{
-			float blurRadius = (float)shadow.BlurRadius * pixelRatio;
-			// Blur sigma conversion taken from flutter source code
-			float blurSigma = blurRadius > 0 ? blurRadius * 0.57735f + 0.5f : 0f;
-
-			// Can't use ToSKColor() or we end up with a weird compilation error asking us to reference System.Drawing
-			Color windowsUiColor = shadow.Color;
-			var color = ToSkiaColor(windowsUiColor);
-			color = color.WithAlpha((byte)(color.Alpha * shadow.Opacity));
-
-			return new SKShadow(
-				shadow.IsInner,
-				(float)shadow.OffsetX * pixelRatio,
-				(float)shadow.OffsetY * pixelRatio,
-				blurSigma,
-				color,
-				(float)shadow.Spread * pixelRatio,
-				width,
-				height,
-				cornerRadius);
-		}
-	}
-
-	private ShadowInfos[] _shadowInfoArray = Array.Empty<ShadowInfos>();
-	private float _currentPixelRatio;
-	private Color? _currentContentBackgroundColor;
+	private ShadowPaintState? _lastPaintState;
+	private bool _isShadowDirty;
 
-	private bool NeedsPaint(double width, double height, float pixelRatio, out bool pixelRatioChanged)
+	private bool NeedsPaint(ShadowPaintState state, out bool pixelRatioChanged)
 	{
-		var shadows = Shadows ?? new ShadowCollection();
-		var newShadowInfos = shadows.Select(s => ShadowInfos.From(s, width, height)).ToArray();
-
-		pixelRatioChanged = false;
-
-		bool needsPaint = !newShadowInfos.SequenceEqual(_shadowInfoArray);
-		_shadowInfoArray = newShadowInfos;
-
-		if (pixelRatio != _currentPixelRatio)
-		{
-			_currentPixelRatio = pixelRatio;
-			pixelRatioChanged = needsPaint = true;
-		}
+		var needsPaint = state != _lastPaintState;
+		pixelRatioChanged = state.PixelRatio != _lastPaintState?.PixelRatio;
 
+		_lastPaintState = state;
 		return needsPaint;
 	}
 
-#if false // ANDROID  (see comment in ShadowContainer.cs)
-	private void OnSurfacePainted(object? sender, SKPaintGLSurfaceEventArgs e)
-	{
-		if (!_notOpaqueSet && ((ViewGroup)_shadowHost).GetChildAt(0) is TextureView openGlTexture)
-		{
-			openGlTexture.SetOpaque(false);
-			_notOpaqueSet = true;
-		}
-#else
 	private void OnSurfacePainted(object? sender, SKPaintSurfaceEventArgs e)
 	{
-#endif
-		if (_shadowHost == null || _currentContent is not { ActualHeight: > 0, ActualWidth: > 0 })
+		if (_shadowHost == null ||
+			Content is not FrameworkElement { ActualHeight: > 0, ActualWidth: > 0 } contentAsFE)
 		{
 			return;
 		}
 
-		var surface = e.Surface;
-		var surfaceWidth = e.Info.Width;
-		var surfaceHeight = e.Info.Height;
+		var background = GetBackgroundColor(Background);
+		if (background is { A: 0 })
+		{
+			// background step can be skipped with fully transparent background.
+			// any color with 0-alpha will produce the same result, null'ing it here will also prevent cache miss.
+			background = null;
+		}
 
-		float pixelRatio = surfaceWidth / (float)_shadowHost.Width;
-		double width = _currentContent.ActualWidth;
-		double height = _currentContent.ActualHeight;
+		var shape = GetShadowShapeContext(Content);
+		var pixelRatio = (float)(e.Info.Width / _shadowHost.ActualWidth);
+		var state = new ShadowPaintState(shape, background, pixelRatio, ShadowInfo.Snapshot(Shadows));
+		_isShadowDirty = false;
 
-		if (!NeedsPaint(width, height, pixelRatio, out bool pixelRatioChanged))
+		if (!NeedsPaint(state, out bool pixelRatioChanged))
 		{
 			return;
 		}
 
-		var canvas = surface.Canvas;
+		var canvas = e.Surface.Canvas;
 		canvas.Clear(SKColors.Transparent);
-		canvas.Save();
 
-		if (Shadows is not { Count: > 0 } shadows)
+		if (state.Shadows.Length == 0)
 		{
+			canvas.Clear(SKColors.Transparent);
+			shape.DrawContentBackground(state, canvas, background ?? Colors.Transparent);
 			return;
 		}
 
-		// If there is any inner shadow, we need to:
-		// 1. Get the background color from the content
-		// 2. Set the content background to transparent
-		// 3. Draw the content background with skia underneath inner shadows
-		bool hasInnerShadow = shadows.HasInnerShadow();
-		if (hasInnerShadow)
-		{
-			// Will set the content background to transparent if needed
-			if (_currentContentBackgroundColor == null && ProcessContentBackgroundIfNeeded(out var contentBackgroundWinUIColor))
-			{
-				_currentContentBackgroundColor = contentBackgroundWinUIColor;
-			}
-		}
-		else if (_currentContentBackgroundColor.HasValue)
-		{
-			// Means that there were inner shadows, and they have been removed: restore content background
-			TrySetContentBackground(new SolidColorBrush(_currentContentBackgroundColor.Value));
-			_currentContentBackgroundColor = null;
-		}
+		using var _ = canvas.SnapshotState();
 
-		string shadowsKey = shadows.ToKey(width, height, _currentContentBackgroundColor);
-		if (Cache.TryGetValue(shadowsKey, out var shadowsImage))
+		var key =
+			FormattableString.Invariant($"[{contentAsFE.ActualWidth}x{contentAsFE.ActualHeight},{background}]: ") +
+			string.Join("; ", state.Shadows.Select(x => x.ToKey()));
+		if (Cache.TryGetValue(key, out var snapshot))
 		{
 			if (pixelRatioChanged)
 			{
 				// Monitor pixel density changed, need to remove cached image
-				Cache.Remove(shadowsKey);
+				Cache.Remove(key);
 			}
 			else
 			{
-				canvas.DrawImage(shadowsImage, SKPoint.Empty);
-				canvas.Restore();
+				canvas.DrawImage(snapshot, SKPoint.Empty);
 				return;
 			}
 		}
 
-		float childWidth = (float)width * pixelRatio;
-		float childHeight = (float)height * pixelRatio;
+		// relative to the SKCanvas, the entire content is padded to leave room for drop shadow
+		// here, we need to re-calibrate the coord system to zero on the top-left corner of the content
+		var deltaWidth = e.Info.Width - ((float)contentAsFE.ActualWidth * pixelRatio);
+		var deltaHeight = e.Info.Height - ((float)contentAsFE.ActualHeight * pixelRatio);
+		canvas.Translate(deltaWidth / 2, deltaHeight / 2);
 
-		float diffWidthSurfaceChild = surfaceWidth - childWidth;
-		float diffHeightSurfaceChild = surfaceHeight - childHeight;
-		canvas.Translate(diffWidthSurfaceChild / 2, diffHeightSurfaceChild / 2);
+		using var paint = new SKPaint() { IsAntialias = true };
 
-		using var paint = new SKPaint();
-		paint.IsAntialias = true;
+		foreach (var shadow in state.GetDropShadows())
+		{
+			shape.DrawDropShadow(state, canvas, paint, shadow);
+		}
 
-		float cornerRadius = (float)_cornerRadius.BottomRight * pixelRatio;
+		// clip background and inner shadow to content
+		state.Shape.ClipToContent(state, canvas);
 
-		foreach (var shadow in shadows.Where(s => !s.IsInner))
+		if (background is { } bg)
 		{
-			var skShadow = SKShadow.From(shadow, childWidth, childHeight, cornerRadius, pixelRatio);
-
-			DrawDropShadow(canvas, paint, skShadow);
+			shape.DrawContentBackground(state, canvas, bg);
 		}
 
-		// Always draw inner shadows on top of the drop shadows
-		if (hasInnerShadow)
+		foreach (var shadow in state.GetInsetShadows())
 		{
-			var contentShape = new SKRoundRect(new SKRect(0, 0, childWidth, childHeight), cornerRadius);
-			canvas.ClipRoundRect(contentShape, antialias: true);
-
-			// Draw the content background first
-			if (_currentContentBackgroundColor.HasValue)
-			{
-				var contentBackgroundColor = ToSkiaColor(_currentContentBackgroundColor.Value);
-				DrawContentBackground(canvas, contentBackgroundColor, contentShape);
-			}
-
-			// Then we draw the inner shadows
-			foreach (var shadow in shadows.Where(s => s.IsInner))
-			{
-				var skShadow = SKShadow.From(shadow, childWidth, childHeight, cornerRadius, pixelRatio);
-
-				DrawInnerShadow(canvas, paint, skShadow);
-			}
+			shape.DrawInnerShadow(state, canvas, paint, shadow);
 		}
 
-		canvas.Restore();
-
-		if (!_shadowPropertyChanged)
+		// If a property has changed dynamically during this paint method,
+		// then we don't want to cache the updated shadows
+		if (!_isShadowDirty)
 		{
-			// If a property has changed dynamically, we don't want to cache the updated shadows
-			Cache.AddOrUpdate(shadowsKey, surface.Snapshot());
+			Cache.AddOrUpdate(key, e.Surface.Snapshot());
 		}
-
-		_shadowPropertyChanged = false;
 	}
 
-	private bool ProcessContentBackgroundIfNeeded(out Color? contentBackgroundColor)
+	private static Color? GetBackgroundColor(Brush? background)
 	{
-		contentBackgroundColor = null;
-		if (TryGetContentBackground(out var background))
+		return background switch
 		{
-			if (background is not SolidColorBrush backgroundColorBrush)
-			{
-				throw new NotSupportedException("[ShadowContainer] Unsupported Background brush: when using inner shadows the only supported brush type for the Background property is SolidBrushColor");
-			}
+			SolidColorBrush scb => scb.Color with { A = (byte)(scb.Color.A * scb.Opacity) },
 
-			if (backgroundColorBrush.Color != Color.FromArgb(0, 0, 0, 0))
-			{
-				contentBackgroundColor = backgroundColorBrush.Color;
-			}
-
-			TrySetContentBackground(new SolidColorBrush(Color.FromArgb(0, 0, 0, 0)));
-			return true;
-		}
-
-		return false;
+			null => default(Color?),
+			_ => throw new NotSupportedException($"Invalid background brush type: {background.GetType().Name}"),
+		};
 	}
 
-	private static void DrawContentBackground(SKCanvas canvas, SKColor contentBackgroundColor, SKRoundRect childShape)
+	private IShadowShapeContext GetShadowShapeContext(object? content)
 	{
-		using var backgroundPaint = new SKPaint
+		return content switch
 		{
-			Color = contentBackgroundColor,
-			Style = SKPaintStyle.Fill,
-		};
+			FrameworkElement fe => new RectangularShadowShapeContext(fe.ActualWidth, fe.ActualHeight, GetCornerRadiusFor(Content) ?? default),
 
-		if (_logger.IsEnabled(LogLevel.Debug))
-		{
-			_logger.Debug(
-				$"[ShadowContainer] DrawContentBackground => color: {backgroundPaint.Color}");
-		}
-		canvas.DrawRoundRect(childShape, backgroundPaint);
+			null => RectangularShadowShapeContext.Empty,
+			_ => throw new NotSupportedException($"Unsupported content type: {content.GetType().Name}"),
+		};
 	}
 
-	private static void DrawDropShadow(SKCanvas canvas, SKPaint paint, SKShadow shadow)
+	/// <summary>
+	/// Serves both as a record of states relevant to shadow shape, and the implementations for painting the shadows
+	/// </summary>
+	private interface IShadowShapeContext
 	{
-		paint.Style = SKPaintStyle.Fill;
-		paint.Color = shadow.Color;
-		paint.ImageFilter = SKImageFilter.CreateBlur(shadow.BlurSigma, shadow.BlurSigma);
-		paint.MaskFilter = null;
-		paint.StrokeWidth = 0;
-
-		// Two other ways to create shadows
-		// 1. Mask filter
-		// x = 0;
-		// y = 0;
-		// paint.MaskFilter = SKMaskFilter.CreateBlur(SKBlurStyle.Normal, blurSigma);
-		// 2. DropShadow
-		// paint.ImageFilter = SKImageFilter.CreateDropShadowOnly(
-		//     0,
-		//     0,
-		//     blurSigma,
-		//     blurSigma,
-		//     color);
-
-		var shadowShape = new SKRoundRect(
-			new SKRect(
-				shadow.OffsetX,
-				shadow.OffsetY,
-				shadow.OffsetX + shadow.ContentWidth,
-				shadow.OffsetY + shadow.ContentHeight),
-			shadow.CornerRadius);
-		shadowShape.Inflate(shadow.Spread, shadow.Spread);
-		canvas.DrawRoundRect(shadowShape, paint);
-
-		if (_logger.IsEnabled(LogLevel.Debug))
-		{
-			_logger.Debug(
-				$"[ShadowContainer] DrawDropShadow => x: {shadow.OffsetX}, y: {shadow.OffsetY}, width: {shadow.ContentWidth}, height: {shadow.ContentHeight}");
-		}
+		void ClipToContent(ShadowPaintState state, SKCanvas canvas);
+
+		void DrawContentBackground(ShadowPaintState state, SKCanvas canvas, Color color);
+
+		void DrawDropShadow(ShadowPaintState state, SKCanvas canvas, SKPaint paint, ShadowInfo shadow);
+
+		void DrawInnerShadow(ShadowPaintState state, SKCanvas canvas, SKPaint paint, ShadowInfo shadow);
 	}
 
-	private static void DrawInnerShadow(SKCanvas canvas, SKPaint paint, SKShadow shadow)
+	private record RectangularShadowShapeContext(double ContentWidth, double ContentHeight, CornerRadius CornerRadius) : IShadowShapeContext
 	{
-		float strokeWidthX = Math.Abs(shadow.OffsetX);
-		float strokeWidthY = Math.Abs(shadow.OffsetY);
-		float strokeWidth = Math.Max(Math.Max(strokeWidthX, strokeWidthY), shadow.BlurSigma) + shadow.Spread * 2;
-
-		paint.Style = SKPaintStyle.Stroke;
-		paint.Color = shadow.Color;
-		paint.StrokeWidth = strokeWidth * 2;
-		paint.MaskFilter = SKMaskFilter.CreateBlur(SKBlurStyle.Normal, shadow.BlurSigma);
-		paint.ImageFilter = null;
+		public static readonly RectangularShadowShapeContext Empty = new(0, 0, default);
 
-		if (_logger.IsEnabled(LogLevel.Debug))
+		private SKRoundRect GetContentShape(ShadowPaintState state)
 		{
-			_logger.Debug(
-			$"[ShadowContainer] DrawInnerShadow => strokeWidth: {paint.StrokeWidth}, cornerRadius: {shadow.CornerRadius}, x: {shadow.OffsetX}, y: {shadow.OffsetY}, width: {shadow.ContentWidth}, height: {shadow.ContentHeight}");
+			var rect = new SKRect(0, 0, (float)ContentWidth * state.PixelRatio, (float)ContentHeight * state.PixelRatio);
+			var shape = new SKRoundRect(rect, (float)CornerRadius.BottomRight * state.PixelRatio);
+
+			return shape;
 		}
 
-		var shadowShape = new SKRoundRect(
-			new SKRect(
-				0,
-				0,
-				shadow.ContentWidth + (paint.StrokeWidth),
-				shadow.ContentHeight + (paint.StrokeWidth)),
-			shadow.CornerRadius);
+		public void ClipToContent(ShadowPaintState state, SKCanvas canvas)
+		{
+			canvas.ClipRoundRect(GetContentShape(state), antialias: true);
+		}
 
-		shadowShape.Deflate(shadow.Spread, shadow.Spread);
+		public void DrawContentBackground(ShadowPaintState state, SKCanvas canvas, Color color)
+		{
+			var shape = GetContentShape(state);
+			using var backgroundPaint = new SKPaint
+			{
+				Color = color.ToSkiaColor(),
+				Style = SKPaintStyle.Fill,
+			};
 
-		shadowShape.Offset(shadow.OffsetX - strokeWidth, shadow.OffsetY - strokeWidth);
-		canvas.DrawRoundRect(shadowShape, paint);
-	}
+			if (_logger.IsEnabled(LogLevel.Trace))
+			{
+				_logger.Trace($"[ShadowContainer] DrawContentBackground => color: {color}");
+			}
+			canvas.DrawRoundRect(shape, backgroundPaint);
+		}
 
-	private bool TryGetContentBackground(out Brush? background)
-	{
-		if (_currentContent == null)
+		public void DrawDropShadow(ShadowPaintState state, SKCanvas canvas, SKPaint paint, ShadowInfo shadow)
 		{
-			background = null;
-			return false;
+			var spread = (float)shadow.Spread * state.PixelRatio;
+			var offsetX = (float)shadow.OffsetX * state.PixelRatio;
+			var offsetY = (float)shadow.OffsetY * state.PixelRatio;
+
+			var blurSigma = shadow.GetBlurSigma(state.PixelRatio);
+
+			paint.Style = SKPaintStyle.Fill;
+			paint.Color = shadow.GetSKColor();
+			paint.ImageFilter = SKImageFilter.CreateBlur(blurSigma, blurSigma);
+			paint.MaskFilter = null;
+			paint.StrokeWidth = 0;
+
+			// Two other ways to create shadows
+			// 1. Mask filter
+			// x = 0;
+			// y = 0;
+			// paint.MaskFilter = SKMaskFilter.CreateBlur(SKBlurStyle.Normal, blurSigma);
+			// 2. DropShadow
+			// paint.ImageFilter = SKImageFilter.CreateDropShadowOnly(
+			//     0,
+			//     0,
+			//     blurSigma,
+			//     blurSigma,
+			//     color);
+
+			var shape = GetContentShape(state);
+			shape.Offset(offsetX, offsetY);
+			shape.Inflate(spread, spread);
+
+			if (_logger.IsEnabled(LogLevel.Trace))
+			{
+				_logger.Trace($"[ShadowContainer] DrawDropShadow => x: {shape.Rect.Left}, y: {shape.Rect.Top}, width: {shape.Rect.Width}, height: {shape.Rect.Height}");
+			}
+			canvas.DrawRoundRect(shape, paint);
 		}
 
-		background = _currentContent switch
+		public void DrawInnerShadow(ShadowPaintState state, SKCanvas canvas, SKPaint paint, ShadowInfo shadow)
 		{
-			Control control => control.Background,
-			Panel panel => panel.Background,
-			Border border => border.Background,
-			_ => null,
-		};
-
-		return background != null;
+			var cornerRadius = (float)CornerRadius.BottomRight * state.PixelRatio;
+			var spread = (float)shadow.Spread * state.PixelRatio;
+			var offsetX = (float)shadow.OffsetX * state.PixelRatio;
+			var offsetY = (float)shadow.OffsetY * state.PixelRatio;
+
+			var blurSigma = shadow.GetBlurSigma(state.PixelRatio);
+			var strokeWidthX = Math.Abs(offsetX);
+			var strokeWidthY = Math.Abs(offsetY);
+			var strokeWidth = Math.Max(Math.Max(strokeWidthX, strokeWidthY), blurSigma) + spread * 2;
+
+			paint.Style = SKPaintStyle.Stroke;
+			paint.Color = shadow.GetSKColor();
+			paint.StrokeWidth = strokeWidth * 2;
+			paint.MaskFilter = SKMaskFilter.CreateBlur(SKBlurStyle.Normal, blurSigma);
+			paint.ImageFilter = null;
+
+			var shape = GetContentShape(state);
+			shape.Offset(offsetX, offsetY);
+			shape.Inflate(strokeWidth - spread, strokeWidth - spread);
+
+			if (_logger.IsEnabled(LogLevel.Trace))
+			{
+				_logger.Trace($"[ShadowContainer] DrawInnerShadow => strokeWidth: {paint.StrokeWidth}, cornerRadius: {cornerRadius}, x: {offsetX}, y: {offsetY}, width: {shape.Rect.Width}, height: {shape.Rect.Height}");
+			}
+			canvas.DrawRoundRect(shape, paint);
+		}
 	}
 
-	private bool TrySetContentBackground(SolidColorBrush background)
+	/// <summary>
+	/// Record of <see cref="Shadow"/> properties at one point in time.
+	/// </summary>
+	private readonly record struct ShadowInfo(bool Inset, double OffsetX, double OffsetY, double BlurRadius, double Spread, Color Color, double Opacity)
 	{
-		switch (_currentContent)
+		public static ShadowInfo Snapshot(Shadow x) => new(
+			x.IsInner,
+			x.OffsetX, x.OffsetY,
+			x.BlurRadius, x.Spread,
+			x.Color,
+			x.Opacity
+		);
+
+		public static ShadowInfo[] Snapshot(IEnumerable<Shadow> shadows) => shadows.Safe().Select(Snapshot).ToArray();
+
+		public SKColor GetSKColor() => new SKColor(Color.R, Color.G, Color.B, (byte)(Color.A * Opacity));
+
+		public float GetBlurSigma(float pixelRatio)
 		{
-			case Control control:
-				control.Background = background;
-				break;
-			case Panel panel:
-				panel.Background = background;
-				break;
-			case Border border:
-				border.Background = background;
-				break;
-			default:
-				return false;
+			var radius = (float)BlurRadius * pixelRatio;
+			// Blur sigma conversion taken from flutter source code
+			var sigma = radius > 0 ? radius * 0.57735f + 0.5f : 0f;
+
+			return sigma;
 		}
 
-		return true;
+		public string ToKey() => string.Join(",", Inset, OffsetX, OffsetY, BlurRadius, Spread, Color, Opacity);
 	}
 
-	private static SKColor ToSkiaColor(Color windowsUiColor)
+	/// <summary>
+	/// Used in comparison to determine if the shadow needs to be repainted.
+	/// </summary>
+	private sealed record ShadowPaintState(
+		IShadowShapeContext Shape,
+		Color? Background,
+		float PixelRatio,
+		ShadowInfo[] Shadows)
 	{
-		return new SKColor(windowsUiColor.R, windowsUiColor.G, windowsUiColor.B, windowsUiColor.A);
+		public IEnumerable<ShadowInfo> GetDropShadows() => Shadows.Safe().Where(x => !x.Inset);
+		public IEnumerable<ShadowInfo> GetInsetShadows() => Shadows.Safe().Where(x => x.Inset);
+
+		// GetHashCode+Equals are needed here for Shadows' sequential equality
+
+		public override int GetHashCode()
+		{
+			var hash = new HashCode();
+
+			hash.Add(Shape.GetHashCode());
+			hash.Add(Background.GetHashCode());
+			hash.Add(PixelRatio.GetHashCode());
+			foreach (var item in Shadows)
+			{
+				hash.Add(item);
+			}
+
+			return hash.ToHashCode();
+		}
+
+		public bool Equals(ShadowPaintState? x) =>
+			x is { } y &&
+			Shape == y.Shape &&
+			Background == y.Background &&
+			PixelRatio == y.PixelRatio &&
+			Shadows.SequenceEqual(y.Shadows);
 	}
 }
diff --git a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.Properties.cs b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.Properties.cs
index f68273212..d080cf315 100644
--- a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.Properties.cs
+++ b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.Properties.cs
@@ -1,33 +1,20 @@
 using System.Collections.Specialized;
 using System.ComponentModel;
-using System.Linq;
-using Uno.Disposables;
-
-#if IS_WINUI
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
-#else
-using Windows.UI.Xaml;
-using Windows.UI.Xaml.Controls;
-#endif
+using Uno.Disposables;
 
 namespace Uno.Toolkit.UI;
 
 public partial class ShadowContainer : ContentControl
 {
-	private readonly SerialDisposable _shadowsCollectionChanged = new();
-	private readonly SerialDisposable _shadowPropertiesChanged = new();
-	private readonly SerialDisposable _cornerRadiusChanged = new();
-	private readonly CompositeDisposable _activeShadowRegistrations = new CompositeDisposable();
-
 	#region DependencyProperty: Shadows
 
-	public static readonly DependencyProperty ShadowsProperty =
-		DependencyProperty.Register(
-			nameof(Shadows),
-			typeof(ShadowCollection),
-			typeof(ShadowContainer),
-			new(null, OnShadowsChanged));
+	public static DependencyProperty ShadowsProperty { get; } = DependencyProperty.Register(
+		nameof(Shadows),
+		typeof(ShadowCollection),
+		typeof(ShadowContainer),
+		new PropertyMetadata(default(ShadowCollection)));
 
 	/// <summary>
 	/// The collection of shadows that will be displayed under your control.
@@ -41,111 +28,4 @@ public ShadowCollection Shadows
 	}
 
 	#endregion
-
-	// True if a shadow property has changed dynamically or if we add or removed a shadow
-	private bool _shadowPropertyChanged;
-
-	private static void OnShadowsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-	{
-		if (d is ShadowContainer shadowContainer)
-		{
-			shadowContainer.UpdateShadows();
-		}
-	}
-
-	private void OnShadowCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
-	{
-		switch (e.Action)
-		{
-			case NotifyCollectionChangedAction.Add:
-				for (int i = 0; i < e.NewItems!.Count; i++)
-				{
-					OnShadowInserted((Shadow)e.NewItems[i]!);
-				}
-
-				OnShadowSizeChanged();
-				InvalidateFromShadowPropertyChange();
-
-				break;
-			case NotifyCollectionChangedAction.Remove:
-				for (int i = 0; i < e.OldItems!.Count; i++)
-				{
-					OnShadowRemoved((Shadow)e.OldItems[i]!);
-				}
-
-				OnShadowSizeChanged();
-				InvalidateFromShadowPropertyChange();
-				break;
-
-			case NotifyCollectionChangedAction.Reset:
-				OnShadowSizeChanged();
-				InvalidateFromShadowPropertyChange();
-				break;
-		}
-	}
-
-	private void UpdateShadows()
-	{
-		_shadowsCollectionChanged.Disposable = null;
-		_shadowPropertiesChanged.Disposable = null;
-
-		if (Shadows is not { } shadows)
-		{
-			return;
-		}
-
-		foreach (var shadow in shadows)
-		{
-			_activeShadowRegistrations.Add(() => shadow.PropertyChanged -= ShadowPropertyChanged);
-			shadow.PropertyChanged += ShadowPropertyChanged;
-		}
-
-		_shadowsCollectionChanged.Disposable = Disposable.Create(() => shadows.CollectionChanged -= OnShadowCollectionChanged);
-		shadows.CollectionChanged += OnShadowCollectionChanged;
-
-		_shadowPropertiesChanged.Disposable = _activeShadowRegistrations;
-
-		OnShadowSizeChanged();
-		_shadowHost?.Invalidate();
-	}
-
-	private void OnShadowInserted(Shadow shadow)
-	{
-		_activeShadowRegistrations.Add(() => shadow.PropertyChanged -= ShadowPropertyChanged);
-		shadow.PropertyChanged += ShadowPropertyChanged;
-	}
-
-	private void OnShadowRemoved(Shadow shadow)
-	{
-		shadow.PropertyChanged -= ShadowPropertyChanged;
-	}
-
-	private void ShadowPropertyChanged(object? sender, PropertyChangedEventArgs e)
-	{
-		if (e.PropertyName is null)
-		{
-			return;
-		}
-
-		if (UI.Shadow.IsShadowSizeProperty(e.PropertyName))
-		{
-			OnShadowSizeChanged();
-		}
-
-		InvalidateFromShadowPropertyChange();
-	}
-
-	private void OnShadowSizeChanged()
-	{
-		if (_currentContent != null && _currentContent.ActualWidth > 0 && _currentContent.ActualHeight > 0)
-		{
-			UpdateCanvasSize(_currentContent.ActualWidth, _currentContent.ActualHeight, Shadows);
-		}
-	}
-
-	private void InvalidateFromShadowPropertyChange()
-	{
-		_shadowPropertyChanged = true;
-		_shadowHost?.Invalidate();
-	}
 }
diff --git a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.cs b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.cs
index 6e3258378..74209d19d 100644
--- a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.cs
+++ b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowContainer.cs
@@ -1,15 +1,14 @@
 using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.ComponentModel;
 using System.Linq;
-
-#if IS_WINUI
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Media;
+using Microsoft.UI.Xaml.Shapes;
 using SkiaSharp.Views.Windows;
-#else
-using Windows.UI.Xaml;
-using Windows.UI.Xaml.Controls;
-using SkiaSharp.Views.UWP;
-#endif
+using Uno.Disposables;
 
 #if __ANDROID__
 using Android.Views;
@@ -29,159 +28,225 @@ public partial class ShadowContainer : ContentControl
 {
 	private const string PART_Canvas = "PART_Canvas";
 
-	private Canvas? _canvas;
-
-#if false // ANDROID (see comment below)
-    private readonly SKSwapChainPanel _shadowHost;
-    private bool _notOpaqueSet = false;
-#else
-	private SKXamlCanvas? _shadowHost;
-#endif
-
 	private static readonly ShadowsCache Cache = new ShadowsCache();
 
-	private FrameworkElement? _currentContent;
+	private readonly SerialDisposable _eventSubscriptions = new();
 
-	private CornerRadius _cornerRadius;
+	private Canvas? _canvas;
+
+	private SKXamlCanvas? _shadowHost;
 
 	public ShadowContainer()
 	{
-		Shadows = new();
-
 		DefaultStyleKey = typeof(ShadowContainer);
 
-		_cornerRadius = new CornerRadius(0);
+		Shadows = new();
 
 		Loaded += ShadowContainerLoaded;
 		Unloaded += ShadowContainerUnloaded;
 	}
 
-	private void ShadowContainerUnloaded(object sender, RoutedEventArgs e)
-	{
-		RevokeListeners();
-	}
-
 	private void ShadowContainerLoaded(object sender, RoutedEventArgs e)
 	{
-		UpdateShadows();
+		BindToPaintingProperties();
+
+		InvalidateCanvasLayout();
+		InvalidateShadows();
 	}
 
-	private void RevokeListeners()
+	private void ShadowContainerUnloaded(object sender, RoutedEventArgs e)
 	{
-		_shadowsCollectionChanged.Disposable = null;
-		_shadowPropertiesChanged.Disposable = null;
-		_cornerRadiusChanged.Disposable = null;
+		_eventSubscriptions.Disposable = null;
 	}
 
-	protected override void OnApplyTemplate()
+	private void BindToPaintingProperties()
 	{
-		_canvas = GetTemplateChild(nameof(PART_Canvas)) as Canvas;
+		var backgroundNestedDisposable = new SerialDisposable();
+		var shadowsNestedDisposable = new SerialDisposable();
+		var contentNestedDisposable = new SerialDisposable();
 
+		_eventSubscriptions.Disposable = new CompositeDisposable
+		{
+			this.RegisterDisposablePropertyChangedCallback(BackgroundProperty, OnBackgroundChanged),
+			this.RegisterDisposablePropertyChangedCallback(ShadowsProperty, OnShadowsChanged),
+			this.RegisterDisposablePropertyChangedCallback(ContentProperty, OnContentChanged),
 
-#if false // ANDROID: We keep that as a reference cause it would be better to use the hardware-accelerated version
-        var skiaCanvas = new SKSwapChainPanel();
-        skiaCanvas.PaintSurface += OnSurfacePainted;
-#else
-		var skiaCanvas = new SKXamlCanvas();
-		skiaCanvas.PaintSurface += OnSurfacePainted;
-#endif
+			backgroundNestedDisposable,
+			shadowsNestedDisposable,
+			contentNestedDisposable,
+		};
 
-#if __IOS__ || __MACCATALYST__
-        skiaCanvas.Opaque = false;
-#endif
+		// manually proc inner registration once
+		BindToBackgroundMemberProperties(Background);
+		BindToShadowCollectionChanged(Shadows);
+		BindToContent(Content);
 
-		_shadowHost = skiaCanvas;
-		_canvas?.Children.Insert(0, _shadowHost!);
+		// This method should not fire any of InvalidateXyz-methods directly,
+		// in order to avoid duplicated invalidate calls.
+		// Which is why the BindToXyz has been separated from the OnXyzChanged.
 
-		base.OnApplyTemplate();
-	}
+		void OnBackgroundChanged(DependencyObject sender, DependencyProperty dp)
+		{
+			BindToBackgroundMemberProperties(Background);
 
-	/// <inheritdoc/>
-	protected override void OnContentChanged(object oldContent, object newContent)
-	{
-		_cornerRadiusChanged.Disposable = null;
+			InvalidateShadows();
+		}
+		void OnShadowsChanged(DependencyObject sender, DependencyProperty dp)
+		{
+			BindToShadowCollectionChanged(Shadows);
 
-		if (oldContent is FrameworkElement oldElement)
+			InvalidateCanvasLayout();
+			InvalidateShadows();
+		}
+		void OnContentChanged(DependencyObject sender, DependencyProperty dp)
 		{
-			_canvas?.Children.Remove(oldElement);
-			oldElement.SizeChanged -= OnContentSizeChanged;
+			BindToContent(Content);
+
+			InvalidateShadows();
 		}
 
-		if (newContent is FrameworkElement newElement)
+		void OnShadowPropertyChanged(object? sender, PropertyChangedEventArgs e)
+		{
+			_isShadowDirty = true;
+
+			if (Uno.Toolkit.UI.Shadow.IsShadowSizeProperty(e.PropertyName ?? ""))
+			{
+				InvalidateCanvasLayout();
+			}
+			InvalidateShadows();
+		}
+		void OnInnerPropertyChanged(DependencyObject sender, DependencyProperty dp)
 		{
-			_currentContent = newElement;
-			_currentContent.SizeChanged += OnContentSizeChanged;
+			if (sender == this && dp == CornerRadiusProperty)
+			{
+				InvalidateCanvasLayout();
+			}
+			InvalidateShadows();
+		}
+		void OnContentPropertyChanged(DependencyObject sender, DependencyProperty dp)
+		{
+			// among the content's nested properties (CornerRadius, Margin) that gets sent here,
+			// only Margin is used in UpdateCanvasLayout
+			if (dp == FrameworkElement.MarginProperty)
+			{
+				InvalidateCanvasLayout();
+			}
+			InvalidateShadows();
+		}
+		void OnContentSizeChanged(object sender, SizeChangedEventArgs e)
+		{
+			InvalidateCanvasLayout();
+			InvalidateShadows();
+		}
 
-			if (TryGetCornerRadius(newElement, out var cornerRadius))
+		void BindToBackgroundMemberProperties(Brush? background)
+		{
+			backgroundNestedDisposable.Disposable = background switch
 			{
-				var cornerRadiusProperty = newElement switch
+				SolidColorBrush scb => new CompositeDisposable
 				{
-					Grid _ => Grid.CornerRadiusProperty,
-					StackPanel _ => StackPanel.CornerRadiusProperty,
-					ContentPresenter _ => ContentPresenter.CornerRadiusProperty,
-					Border _ => Border.CornerRadiusProperty,
-					Control _ => Control.CornerRadiusProperty,
-					RelativePanel _ => RelativePanel.CornerRadiusProperty, 
-					_ => default,
+					scb.RegisterDisposablePropertyChangedCallback(SolidColorBrush.ColorProperty, OnInnerPropertyChanged),
+					scb.RegisterDisposablePropertyChangedCallback(Brush.OpacityProperty, OnInnerPropertyChanged),
+				},
 
-				};
+				null => null,
+				_ => throw new NotSupportedException($"'{background.GetType().Name}' background brush is not supported."),
+			};
+		}
+		void BindToShadowCollectionChanged(ShadowCollection? shadows)
+		{
+			if (shadows != null)
+			{
+				shadows.CollectionChanged += OnShadowCollectionChanged;
+				BindItems(shadows);
 
-				if (cornerRadiusProperty != null)
+				shadowsNestedDisposable.Disposable = Disposable.Create(() =>
 				{
-					_cornerRadiusChanged.Disposable = newElement.RegisterDisposablePropertyChangedCallback(
-						cornerRadiusProperty,
-						(s, dp) => OnCornerRadiusChanged(s, dp)
-					);
+					shadows.CollectionChanged -= OnShadowCollectionChanged;
+					UnbindItems(shadows);
+				});
+
+				_isShadowDirty = true;
+
+				void OnShadowCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+				{
+					if (e.Action != NotifyCollectionChangedAction.Move)
+					{
+						UnbindItems(e.OldItems?.Cast<Shadow>());
+						BindItems(e.NewItems?.Cast<Shadow>());
+
+						_isShadowDirty = true;
+						InvalidateCanvasLayout();
+					}
+				}
+				void BindItems(IEnumerable<Shadow>? shadows)
+				{
+					foreach (var item in shadows ?? Array.Empty<Shadow>())
+					{
+						item.PropertyChanged += OnShadowPropertyChanged;
+					}
+				}
+				void UnbindItems(IEnumerable<Shadow>? shadows)
+				{
+					foreach (var item in shadows ?? Array.Empty<Shadow>())
+					{
+						item.PropertyChanged -= OnShadowPropertyChanged;
+					}
 				}
 			}
+			else
+			{
+				shadowsNestedDisposable.Disposable = null;
 
-			_cornerRadius = cornerRadius;
+				_isShadowDirty = true;
+			}
 		}
-
-		_shadowHost?.Invalidate();
-		base.OnContentChanged(oldContent, newContent);
-	}
-
-	private void OnCornerRadiusChanged(DependencyObject sender, DependencyProperty dp)
-	{
-		if (_currentContent is { })
+		void BindToContent(object? content)
 		{
-			if (TryGetCornerRadius(_currentContent, out var cornerRadius))
+			if (content is FrameworkElement contentAsFE)
 			{
-				_cornerRadius = cornerRadius;
-				_shadowHost?.Invalidate();
+				contentAsFE.SizeChanged += OnContentSizeChanged;
+				contentNestedDisposable.Disposable = new CompositeDisposable
+				{
+					Disposable.Create(() => contentAsFE.SizeChanged -= OnContentSizeChanged),
+					GetCornerRadiusPropertyFor(content) is { } dp ? contentAsFE.RegisterDisposablePropertyChangedCallback(dp, OnContentPropertyChanged) : Disposable.Empty,
+					contentAsFE.RegisterDisposablePropertyChangedCallback(FrameworkElement.MarginProperty, OnContentPropertyChanged),
+				};
+			}
+			else
+			{
+				contentNestedDisposable.Disposable = null;
 			}
 		}
 	}
 
-	private static bool TryGetCornerRadius(FrameworkElement element, out CornerRadius cornerRadius)
+	protected override void OnApplyTemplate()
 	{
-		CornerRadius? localCornerRadius = element switch
-		{
-			Control control => control.CornerRadius,
-			StackPanel stackPanel => stackPanel.CornerRadius,
-			RelativePanel relativePanel => relativePanel.CornerRadius,
-			Grid grid => grid.CornerRadius,
-			Border border => border.CornerRadius,
-			_ => VisualTreeHelperEx.TryGetDpValue<CornerRadius>(element, "CornerRadius", out var value) ? value : default(CornerRadius?),
-		};
+		base.OnApplyTemplate();
+
+		_canvas = GetTemplateChild(nameof(PART_Canvas)) as Canvas;
+
+		var skiaCanvas = new SKXamlCanvas();
+		skiaCanvas.PaintSurface += OnSurfacePainted;
 
-		cornerRadius = localCornerRadius ?? new CornerRadius(0);
-		return localCornerRadius != null;
+#if __IOS__ || __MACCATALYST__
+		skiaCanvas.Opaque = false;
+#endif
+
+		_shadowHost = skiaCanvas;
+		_canvas?.Children.Insert(0, _shadowHost!);
 	}
 
-	private void OnContentSizeChanged(object sender, SizeChangedEventArgs args)
+	private void InvalidateCanvasLayout()
 	{
-		if (args.NewSize.Width > 0 && args.NewSize.Height > 0)
+		if (Content is not FrameworkElement contentAsFE || _canvas == null || _shadowHost == null)
 		{
-			UpdateCanvasSize(args.NewSize.Width, args.NewSize.Height, Shadows);
-			_shadowHost?.Invalidate();
+			return;
 		}
-	}
 
-	private void UpdateCanvasSize(double childWidth, double childHeight, ShadowCollection? shadows)
-	{
-		if (_currentContent == null || _canvas == null || _shadowHost == null)
+		var childWidth = contentAsFE.ActualWidth;
+		var childHeight = contentAsFE.ActualHeight;
+		if (childWidth == 0 || childHeight == 0)
 		{
 			return;
 		}
@@ -191,7 +256,7 @@ private void UpdateCanvasSize(double childWidth, double childHeight, ShadowColle
 		double maxBlurRadius = 0;
 		double maxSpread = 0;
 
-		if (shadows?.Any() == true)
+		if (Shadows is { Count: > 0 } shadows)
 		{
 			absoluteMaxOffsetX = shadows.Max(s => Math.Abs(s.OffsetX));
 			absoluteMaxOffsetY = shadows.Max(s => Math.Abs(s.OffsetY));
@@ -212,10 +277,49 @@ private void UpdateCanvasSize(double childWidth, double childHeight, ShadowColle
 		double diffWidthShadowHostChild = newHostWidth - childWidth;
 		double diffHeightShadowHostChild = newHostHeight - childHeight;
 
-		float left = (float)(-diffWidthShadowHostChild / 2 + _currentContent.Margin.Left);
-		float top = (float)(-diffHeightShadowHostChild / 2 + _currentContent.Margin.Top);
+		float left = (float)(-diffWidthShadowHostChild / 2 + contentAsFE.Margin.Left);
+		float top = (float)(-diffHeightShadowHostChild / 2 + contentAsFE.Margin.Top);
 
 		Canvas.SetLeft(_shadowHost, left);
 		Canvas.SetTop(_shadowHost, top);
 	}
+
+	private void InvalidateShadows(bool force = false)
+	{
+		_shadowHost?.Invalidate();
+	}
+
+	private static DependencyProperty? GetCornerRadiusPropertyFor(object? content)
+	{
+		return content switch
+		{
+			Control => Control.CornerRadiusProperty,
+
+			Border => Border.CornerRadiusProperty,
+			Grid => Grid.CornerRadiusProperty,
+			StackPanel => StackPanel.CornerRadiusProperty,
+
+			Shape => null,
+			DependencyObject @do => @do.FindDependencyPropertyUsingReflection<CornerRadius>("CornerRadiusProperty"),
+			_ => null,
+		};
+	}
+
+	private static CornerRadius? GetCornerRadiusFor(object? content)
+	{
+		return content switch
+		{
+			Control corner => corner.CornerRadius,
+
+			Border border => border.CornerRadius,
+			Grid grid => grid.CornerRadius,
+			StackPanel stackpanel => stackpanel.CornerRadius,
+
+			Shape => null,
+			DependencyObject @do => @do.FindDependencyPropertyUsingReflection<CornerRadius>("CornerRadiusProperty") is { } dp
+				? (CornerRadius)@do.GetValue(dp)
+				: null,
+			_ => null,
+		};
+	}
 }
diff --git a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowsCache.cs b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowsCache.cs
index 62e2e6f66..49d65a85b 100644
--- a/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowsCache.cs
+++ b/src/Uno.Toolkit.Skia.WinUI/Controls/Shadows/ShadowsCache.cs
@@ -1,62 +1,59 @@
 using System;
 using System.Collections.Concurrent;
-
+using Microsoft.Extensions.Logging;
 using SkiaSharp;
+using Uno.Extensions;
+using Uno.Logging;
 
 namespace Uno.Toolkit.UI;
 public class ShadowsCache
 {
-	private class CacheBucket
-	{
-		public CacheBucket(SKImage bitmap)
-		{
-			Bitmap = bitmap;
-			AddHit();
-		}
-
-		public SKImage Bitmap { get; }
-
-		public int Hit { get; private set; }
-
-		public DateTime LastHit { get; private set; }
-
-		public void AddHit()
-		{
-			Hit++;
-			LastHit = DateTime.UtcNow;
-		}
-	}
+	private static readonly ILogger _logger = typeof(ShadowsCache).Log();
 
 	private readonly ConcurrentDictionary<string, CacheBucket> _shadowsCache = new ConcurrentDictionary<string, CacheBucket>();
 
 	public void AddOrUpdate(string key, SKImage image)
 	{
-		System.Diagnostics.Debug.WriteLine($"[ShadowsCache] AddOrUpdate => key: {key}");
+		if (_logger.IsEnabled(LogLevel.Trace))
+		{
+			_logger.Trace($"[ShadowsCache] AddOrUpdate => key: {key}");
+		}
 
 		var bucket = _shadowsCache.AddOrUpdate(
 			key,
 			(key) =>
 			{
-				System.Diagnostics.Debug.WriteLine($"[ShadowsCache] inserting new shadow in cache");
+				if (_logger.IsEnabled(LogLevel.Trace))
+				{
+					_logger.Trace($"[ShadowsCache] inserting new shadow in cache");
+				}
 				return new CacheBucket(image);
 			},
 			(key, existing) =>
 			{
 				existing.AddHit();
-				System.Diagnostics.Debug.WriteLine($"[ShadowsCache] shadow image found, {existing.Hit} hits, last one at {existing.LastHit:T}");
+				if (_logger.IsEnabled(LogLevel.Trace))
+				{
+					_logger.Trace($"[ShadowsCache] shadow image found, {existing.Hit} hits, last one at {existing.LastHit:T}");
+				}
 				return existing;
 			});
 	}
 
 	public bool TryGetValue(string key, out SKImage? image)
 	{
-		System.Diagnostics.Debug.WriteLine($"[ShadowsCache] TryGet => key: {key}");
-
+		if (_logger.IsEnabled(LogLevel.Trace))
+		{
+			_logger.Trace($"[ShadowsCache] TryGet => key: {key}");
+		}
 		if (_shadowsCache.TryGetValue(key, out var bucket))
 		{
 			bucket.AddHit();
 			image = bucket.Bitmap;
-			System.Diagnostics.Debug.WriteLine($"[ShadowsCache] shadow image found, {bucket.Hit} hits, last one at {bucket.LastHit:T}");
+			if (_logger.IsEnabled(LogLevel.Trace))
+			{
+				_logger.Trace($"[ShadowsCache] shadow image found, {bucket.Hit} hits, last one at {bucket.LastHit:T}");
+			}
 			return true;
 		}
 
@@ -66,8 +63,32 @@ public bool TryGetValue(string key, out SKImage? image)
 
 	public bool Remove(string key)
 	{
-		System.Diagnostics.Debug.WriteLine($"[ShadowsCache] Remove => key: {key}");
+		if (_logger.IsEnabled(LogLevel.Trace))
+		{
+			_logger.Trace($"[ShadowsCache] Remove => key: {key}");
+		}
 
 		return _shadowsCache.TryRemove(key, out var _);
 	}
+
+	private class CacheBucket
+	{
+		public CacheBucket(SKImage bitmap)
+		{
+			Bitmap = bitmap;
+			AddHit();
+		}
+
+		public SKImage Bitmap { get; }
+
+		public int Hit { get; private set; }
+
+		public DateTime LastHit { get; private set; }
+
+		public void AddHit()
+		{
+			Hit++;
+			LastHit = DateTime.UtcNow;
+		}
+	}
 }
diff --git a/src/Uno.Toolkit.Skia.WinUI/Extensions/SKExtensions.cs b/src/Uno.Toolkit.Skia.WinUI/Extensions/SKExtensions.cs
new file mode 100644
index 000000000..4b79c13cf
--- /dev/null
+++ b/src/Uno.Toolkit.Skia.WinUI/Extensions/SKExtensions.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SkiaSharp;
+using Uno.Disposables;
+using Windows.UI;
+
+namespace Uno.Toolkit.UI;
+
+internal static class SKExtensions
+{
+	public static SKRect Scale(this SKRect x, float scale) => new(
+		x.Left * scale,
+		x.Top * scale,
+		x.Right * scale,
+		x.Bottom * scale
+	);
+
+	public static SKColor ToSkiaColor(this Color x) => new(x.R, x.G, x.B, x.A);
+
+	public static IDisposable SnapshotState(this SKCanvas canvas)
+	{
+		canvas.Save();
+		return Disposable.Create(() => canvas.Restore());
+	}
+}
diff --git a/src/Uno.Toolkit.Skia.WinUI/Themes/Generic.xaml b/src/Uno.Toolkit.Skia.WinUI/Themes/Generic.xaml
index 88fb5c800..9fff47c6b 100644
--- a/src/Uno.Toolkit.Skia.WinUI/Themes/Generic.xaml
+++ b/src/Uno.Toolkit.Skia.WinUI/Themes/Generic.xaml
@@ -8,8 +8,7 @@
 					xmlns:netstdref="http://uno.ui/netstdref"
 					mc:Ignorable="android ios netstdref">
 
-	<Style x:Key="DefaultShadowContainerStyle"
-	   TargetType="utu:ShadowContainer">
+	<Style x:Key="DefaultShadowContainerStyle" TargetType="utu:ShadowContainer">
 		<Setter Property="IsTabStop" Value="False" />
 		<Setter Property="HorizontalAlignment" Value="Stretch" />
 		<Setter Property="HorizontalContentAlignment" Value="Left" />
@@ -18,19 +17,21 @@
 		<Setter Property="Template">
 			<Setter.Value>
 				<ControlTemplate TargetType="utu:ShadowContainer">
+					<!--
+						note: Dont template-bind Background or CornerRadius here.
+						They will be painted in skia impl (see: ShadowContainer.Paint.cs).
+					-->
 					<Canvas x:Name="PART_Canvas"
-						HorizontalAlignment="{TemplateBinding HorizontalAlignment}"
-						VerticalAlignment="{TemplateBinding VerticalAlignment}"
-						Background="{TemplateBinding Background}">
+							HorizontalAlignment="{TemplateBinding HorizontalAlignment}"
+							VerticalAlignment="{TemplateBinding VerticalAlignment}">
 						<ContentPresenter HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
-									  VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
-									  Content="{TemplateBinding Content}" />
+										  VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
+										  Content="{TemplateBinding Content}" />
 					</Canvas>
 				</ControlTemplate>
 			</Setter.Value>
 		</Setter>
 	</Style>
 
-	<Style BasedOn="{StaticResource DefaultShadowContainerStyle}"
-	   TargetType="utu:ShadowContainer" />
+	<Style BasedOn="{StaticResource DefaultShadowContainerStyle}" TargetType="utu:ShadowContainer" />
 </ResourceDictionary>
diff --git a/src/Uno.Toolkit.UI/Extensions/DependencyObjectExtensions.cs b/src/Uno.Toolkit.UI/Extensions/DependencyObjectExtensions.cs
index 884fa2216..3133e4a1c 100644
--- a/src/Uno.Toolkit.UI/Extensions/DependencyObjectExtensions.cs
+++ b/src/Uno.Toolkit.UI/Extensions/DependencyObjectExtensions.cs
@@ -19,6 +19,8 @@
 using Windows.UI.Xaml.Media;
 #endif
 
+using static System.Reflection.BindingFlags;
+
 namespace Uno.Toolkit.UI
 {
 	internal static class DependencyObjectExtensions
@@ -191,19 +193,18 @@ internal static void SetParent(this DependencyObject dependencyObject, object? p
 				return property;
 			}
 
-			property = type.GetProperty(propertyName, BindingFlags.Public | BindingFlags.Static)?.GetValue(null) as DependencyProperty
-				?? type.GetField(propertyName, BindingFlags.Public | BindingFlags.Static)?.GetValue(null) as DependencyProperty;
+			property =
+				type.GetProperty(propertyName, Public | Static | FlattenHierarchy)?.GetValue(null) as DependencyProperty ??
+				type.GetField(propertyName, Public | Static | FlattenHierarchy)?.GetValue(null) as DependencyProperty;
 
+#if HAS_UNO
 			if (property == null)
 			{
-#if HAS_UNO
-				dependencyObject.Log().LogWarning($"The {propertyName} dependency property does not exist on {type}");
-#endif
+				typeof(DependencyObjectExtensions).Log().LogWarning($"The '{type}.{propertyName}' dependency property does not exist.");
 			}
-#if HAS_UNO
 			else if (property.GetType() != propertyType)
 			{
-				dependencyObject.Log().LogWarning($"The {propertyName} dependency property {type} is not of the {propertyType} Type.");
+				typeof(DependencyObjectExtensions).Log().LogWarning($"The '{type}.{propertyName}' dependency property is not of the expected '{propertyType}' type.");
 				property = null;
 			}
 #endif