diff --git a/samples/SkiaSharpDemo/App.xaml b/samples/SkiaSharpDemo/App.xaml
index 96137544..dcc70754 100644
--- a/samples/SkiaSharpDemo/App.xaml
+++ b/samples/SkiaSharpDemo/App.xaml
@@ -5,6 +5,9 @@
              x:Class="SkiaSharpDemo.App">
     <Application.Resources>
         <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <views:BottomTabBarResources />
+            </ResourceDictionary.MergedDictionaries>
 
             <converters:RoundToIntConverter x:Key="RoundToInt" />
             <converters:RoundToConverter x:Key="RoundTo" />
@@ -19,6 +22,38 @@
                 <Setter Property="Padding" Value="0" />
             </Style>
 
+            <!-- OptionButton styles -->
+            <ResourceDictionary>
+                <Style x:Key="OptionButtonStyle" TargetType="Button">
+                    <Setter Property="CornerRadius" Value="3" />
+                    <Setter Property="VisualStateManager.VisualStateGroups">
+                        <VisualStateGroupList>
+                            <VisualStateGroup x:Name="CommonStates">
+                                <VisualState x:Name="Normal" />
+                                <VisualState x:Name="Pressed">
+                                    <VisualState.Setters>
+                                        <Setter Property="Scale" Value="0.8" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                            </VisualStateGroup>
+                            <VisualStateGroup x:Name="SelectedStates">
+                                <VisualState x:Name="Unselected" />
+                                <VisualState x:Name="Selected">
+                                    <VisualState.Setters>
+                                        <Setter Property="BorderColor" Value="Black" />
+                                        <Setter Property="BorderWidth" Value="3" />
+                                    </VisualState.Setters>
+                                </VisualState>
+                            </VisualStateGroup>
+                        </VisualStateGroupList>
+                    </Setter>
+                </Style>
+                <Style x:Key="TextOptionButtonStyle" TargetType="Button" BasedOn="{StaticResource OptionButtonStyle}">
+                    <Setter Property="BackgroundColor" Value="Accent" />
+                    <Setter Property="TextColor" Value="White" />
+                    <Setter Property="Padding" Value="24,12" />
+                </Style>
+            </ResourceDictionary>
         </ResourceDictionary>
 
         <!-- Application resource dictionary -->
diff --git a/samples/SkiaSharpDemo/App.xaml.cs b/samples/SkiaSharpDemo/App.xaml.cs
index e93e424b..6da48107 100644
--- a/samples/SkiaSharpDemo/App.xaml.cs
+++ b/samples/SkiaSharpDemo/App.xaml.cs
@@ -12,6 +12,8 @@ public partial class App : Application
 	{
 		public App()
 		{
+			Device.SetFlags(new[] { "CarouselView_Experimental" });
+
 			InitializeComponent();
 
 			// register the default fonts that we want for Iconify
diff --git a/samples/SkiaSharpDemo/Demos/Confetti/ConfettiConfig.cs b/samples/SkiaSharpDemo/Demos/Confetti/ConfettiConfig.cs
new file mode 100644
index 00000000..02b07c61
--- /dev/null
+++ b/samples/SkiaSharpDemo/Demos/Confetti/ConfettiConfig.cs
@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using SkiaSharp;
+using SkiaSharp.Extended.UI.Controls;
+using Xamarin.Forms;
+
+namespace SkiaSharpDemo.Demos
+{
+	public class ConfettiConfig : BindableObject
+	{
+		private static readonly SKPath heartGeometry = SKPath.ParseSvgPathData("M 311.92745,171.20458 170.5061,312.62594 29.08474,171.20458 A 100,100 0 0 1 170.5061,29.783225 100,100 0 0 1 311.92745,171.20458 Z");
+
+		private int minSpeed = 100;
+		private int maxSpeed = 200;
+		private double lifetime = 2;
+		private double duration = 5;
+
+		public ConfettiConfig(int numberOfSystems = 1)
+		{
+			NumberOfSystems = numberOfSystems;
+		}
+
+		public int NumberOfSystems { get; }
+
+		public int MinSpeed
+		{
+			get => minSpeed;
+			set
+			{
+				minSpeed = value;
+				OnPropertyChanged();
+			}
+		}
+
+		public int MaxSpeed
+		{
+			get => maxSpeed;
+			set
+			{
+				maxSpeed = value;
+				OnPropertyChanged();
+			}
+		}
+
+		public double Lifetime
+		{
+			get => lifetime;
+			set
+			{
+				lifetime = value;
+				OnPropertyChanged();
+			}
+		}
+
+		public double Duration
+		{
+			get => duration;
+			set
+			{
+				duration = value;
+				OnPropertyChanged();
+			}
+		}
+
+		public ObservableCollection<string> Shapes { get; } = new ObservableCollection<string>
+		{
+			"Square",
+			"Circle",
+			"Line",
+		};
+
+		public ObservableCollection<Color> Colors { get; } = new ObservableCollection<Color>
+		{
+			Color.FromUint(0xfffce18a),
+			Color.FromUint(0xffff726d),
+			Color.FromUint(0xfff4306d),
+			Color.FromUint(0xffb48def),
+		};
+
+		public Action<int, SKConfettiSystem>? OnCreateSystem { get; set; }
+
+		public IEnumerable<SKConfettiSystem> CreateSystems()
+		{
+			for (var i = 0; i < NumberOfSystems; i++)
+			{
+				var system = new SKConfettiSystem
+				{
+					Lifetime = Lifetime,
+					Emitter = SKConfettiEmitter.Stream(100, Duration),
+					EmitterBounds = SKConfettiEmitterBounds.Top,
+					Colors = new SKConfettiColorCollection(Colors),
+					Shapes = new SKConfettiShapeCollection(GetShapes(Shapes).SelectMany(s => s)),
+					MinimumInitialVelocity = MinSpeed,
+					MaximumInitialVelocity = MaxSpeed,
+				};
+
+				OnCreateSystem?.Invoke(i, system);
+
+				yield return system;
+			}
+		}
+
+		private static IEnumerable<IEnumerable<SKConfettiShape>> GetShapes(IEnumerable<string> shapes)
+		{
+			foreach (var shape in shapes)
+			{
+				yield return shape.ToLowerInvariant() switch
+				{
+					"square" => new SKConfettiShape[] { new SKConfettiSquareShape(), new SKConfettiRectShape(0.5) },
+					"circle" => new SKConfettiShape[] { new SKConfettiCircleShape(), new SKConfettiOvalShape(0.5) },
+					"line" => new[] { new SKConfettiRectShape(0.1) },
+					"heart" => new[] { new SKConfettiPathShape(heartGeometry) },
+					"star" => new[] { new ConfettiStar(5) },
+					_ => throw new ArgumentOutOfRangeException(nameof(shape)),
+				};
+			}
+		}
+	}
+}
diff --git a/samples/SkiaSharpDemo/Demos/Confetti/ConfettiPage.xaml b/samples/SkiaSharpDemo/Demos/Confetti/ConfettiPage.xaml
new file mode 100644
index 00000000..0e129bc4
--- /dev/null
+++ b/samples/SkiaSharpDemo/Demos/Confetti/ConfettiPage.xaml
@@ -0,0 +1,157 @@
+<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             xmlns:controls="clr-namespace:SkiaSharp.Extended.UI.Controls;assembly=SkiaSharp.Extended.UI"
+             xmlns:views="clr-namespace:SkiaSharpDemo.Views"
+             x:Class="SkiaSharpDemo.Demos.ConfettiPage"
+             Title="Confetti">
+
+    <Grid>
+
+        <Label Text="{Binding Message}" FontSize="32" FontAttributes="Bold"
+               Margin="0,-150,0,0"
+               HorizontalOptions="Center" VerticalOptions="Center" />
+
+        <controls:SKConfettiView x:Name="confettiView">
+            <controls:SKConfettiView.GestureRecognizers>
+                <TapGestureRecognizer Tapped="OnTapped" />
+            </controls:SKConfettiView.GestureRecognizers>
+        </controls:SKConfettiView>
+
+        <views:BottomTabBar SelectedIndex="{Binding SelectedTab}" PagePadding="12,6">
+            <views:BottomTabCollection>
+
+                <!-- "add type" -->
+                <views:BottomTab Title="&#xf04b;" HorizontalOptions="Center" VerticalOptions="Center">
+                    <StackLayout Orientation="Horizontal" Spacing="12"
+                                 views:OptionButtons.AllowNone="False"
+                                 views:OptionButtons.SelectionMode="Single"
+                                 views:OptionButtons.SelectedItem="{Binding ConfigName}">
+                        <StackLayout.Resources>
+                            <ResourceDictionary>
+                                <Style TargetType="Button" BasedOn="{StaticResource TextOptionButtonStyle}">
+                                    <Setter Property="BindingContext" Value="{Binding Text, Source={RelativeSource Self}}" />
+                                </Style>
+                            </ResourceDictionary>
+                        </StackLayout.Resources>
+
+                        <Button Text="Top" />
+                        <Button Text="Center" />
+                        <Button Text="Sides" />
+                    </StackLayout>
+                </views:BottomTab>
+
+                <!-- colors -->
+                <views:BottomTab Title="&#xf53f;" HorizontalOptions="Center" VerticalOptions="Center">
+                    <Grid RowSpacing="12" ColumnSpacing="12"
+                          views:OptionButtons.AllowNone="False"
+                          views:OptionButtons.SelectionMode="Multiple"
+                          views:OptionButtons.SelectedItems="{Binding CurrentConfig.Colors}">
+                        <Grid.Resources>
+                            <ResourceDictionary>
+                                <Style TargetType="Button" BasedOn="{StaticResource OptionButtonStyle}">
+                                    <Setter Property="WidthRequest" Value="48" />
+                                    <Setter Property="HeightRequest" Value="32" />
+                                    <Setter Property="BindingContext" Value="{Binding BackgroundColor, Source={RelativeSource Self}}" />
+                                </Style>
+                            </ResourceDictionary>
+                        </Grid.Resources>
+
+                        <Button BackgroundColor="#fffce18a" Grid.Column="0" Grid.Row="0" />
+                        <Button BackgroundColor="#ffff726d" Grid.Column="1" Grid.Row="0" />
+                        <Button BackgroundColor="#fff4306d" Grid.Column="2" Grid.Row="0" />
+                        <Button BackgroundColor="#ffb48def" Grid.Column="3" Grid.Row="0" />
+                        <Button BackgroundColor="#ff38ba9e" Grid.Column="0" Grid.Row="1" />
+                        <Button BackgroundColor="#ff3aaab8" Grid.Column="1" Grid.Row="1" />
+                        <Button BackgroundColor="#ffbb3d72" Grid.Column="2" Grid.Row="1" />
+                        <Button BackgroundColor="#ff006ded" Grid.Column="3" Grid.Row="1" />
+                    </Grid>
+                </views:BottomTab>
+
+                <!-- shapes -->
+                <views:BottomTab Title="&#xf61f;" HorizontalOptions="Center" VerticalOptions="Center">
+                    <StackLayout Orientation="Horizontal" Spacing="12"
+                                 views:OptionButtons.AllowNone="False"
+                                 views:OptionButtons.SelectionMode="Multiple"
+                                 views:OptionButtons.SelectedItems="{Binding CurrentConfig.Shapes}">
+                        <StackLayout.Resources>
+                            <ResourceDictionary>
+                                <Style TargetType="Button" BasedOn="{StaticResource TextOptionButtonStyle}">
+                                    <Setter Property="FontFamily" Value="FontAwesome" />
+                                    <Setter Property="FontSize" Value="20" />
+                                    <Setter Property="Padding" Value="0" />
+                                    <Setter Property="WidthRequest" Value="48" />
+                                    <Setter Property="HeightRequest" Value="48" />
+                                </Style>
+                            </ResourceDictionary>
+                        </StackLayout.Resources>
+
+                        <Button Text="&#xf0c8;" BindingContext="Square" />
+                        <Button Text="&#xf111;" BindingContext="Circle" />
+                        <Button Text="&#xf068;" BindingContext="Line" />
+                        <Button Text="&#xf004;" BindingContext="Heart" />
+                        <Button Text="&#xf005;" BindingContext="Star" />
+                    </StackLayout>
+                </views:BottomTab>
+
+                <views:BottomTab Title="&#xf3fd;" HorizontalOptions="Fill" VerticalOptions="Center">
+                    <Grid ColumnDefinitions="Auto,*,30" ColumnSpacing="12" RowSpacing="12" Padding="12">
+                        <Label Text="Min"
+                               Grid.Column="0" Grid.Row="0"
+                               HorizontalOptions="End" VerticalOptions="Center" />
+                        <Slider Maximum="500" Minimum="10" Value="{Binding CurrentConfig.MinSpeed, Converter={StaticResource RoundToInt}}"
+                                Grid.Column="1" Grid.Row="0"
+                                VerticalOptions="Center"
+                                MinimumTrackColor="Accent" MaximumTrackColor="Accent"
+                                ThumbColor="Accent" />
+                        <Label Text="{Binding CurrentConfig.MinSpeed}"
+                               Grid.Column="2" Grid.Row="0"
+                               HorizontalOptions="Start" VerticalOptions="Center" />
+
+                        <Label Text="Max"
+                               Grid.Column="0" Grid.Row="1"
+                               HorizontalOptions="End" VerticalOptions="Center" />
+                        <Slider Maximum="500" Minimum="10" Value="{Binding CurrentConfig.MaxSpeed, Converter={StaticResource RoundToInt}}"
+                                Grid.Column="1" Grid.Row="1"
+                                VerticalOptions="Center"
+                                MinimumTrackColor="Accent" MaximumTrackColor="Accent"
+                                ThumbColor="Accent" />
+                        <Label Text="{Binding CurrentConfig.MaxSpeed}"
+                               Grid.Column="2" Grid.Row="1"
+                               HorizontalOptions="Start" VerticalOptions="Center" />
+                    </Grid>
+                </views:BottomTab>
+
+                <views:BottomTab Title="&#xf017;" HorizontalOptions="Fill" VerticalOptions="Center">
+                    <Grid ColumnDefinitions="Auto,*,30" ColumnSpacing="12" RowSpacing="12" Padding="12">
+                        <Label Text="Lifetime"
+                               Grid.Column="0" Grid.Row="0"
+                               HorizontalOptions="End" VerticalOptions="Center" />
+                        <Slider Maximum="6" Minimum="0" Value="{Binding CurrentConfig.Lifetime, Converter={StaticResource RoundTo}, ConverterParameter=1}"
+                                Grid.Column="1" Grid.Row="0"
+                                VerticalOptions="Center"
+                                MinimumTrackColor="Accent" MaximumTrackColor="Accent"
+                                ThumbColor="Accent" />
+                        <Label Text="{Binding CurrentConfig.Lifetime, StringFormat='{}{0}s'}"
+                               Grid.Column="2" Grid.Row="0"
+                               HorizontalOptions="Start" VerticalOptions="Center" />
+
+                        <Label Text="Duration"
+                               Grid.Column="0" Grid.Row="1"
+                               HorizontalOptions="End" VerticalOptions="Center" />
+                        <Slider Maximum="6" Minimum="0" Value="{Binding CurrentConfig.Duration, Converter={StaticResource RoundTo}, ConverterParameter=1}"
+                                Grid.Column="1" Grid.Row="1"
+                                VerticalOptions="Center"
+                                MinimumTrackColor="Accent" MaximumTrackColor="Accent"
+                                ThumbColor="Accent" />
+                        <Label Text="{Binding CurrentConfig.Duration, StringFormat='{}{0}s'}"
+                               Grid.Column="2" Grid.Row="1"
+                               HorizontalOptions="Start" VerticalOptions="Center" />
+                    </Grid>
+                </views:BottomTab>
+
+            </views:BottomTabCollection>
+        </views:BottomTabBar>
+
+    </Grid>
+
+</ContentPage>
\ No newline at end of file
diff --git a/samples/SkiaSharpDemo/Demos/Confetti/ConfettiPage.xaml.cs b/samples/SkiaSharpDemo/Demos/Confetti/ConfettiPage.xaml.cs
new file mode 100644
index 00000000..76c89c6d
--- /dev/null
+++ b/samples/SkiaSharpDemo/Demos/Confetti/ConfettiPage.xaml.cs
@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using SkiaSharp.Extended.UI.Controls;
+using Xamarin.Forms;
+
+namespace SkiaSharpDemo.Demos
+{
+	public partial class ConfettiPage : ContentPage
+	{
+		private static readonly Dictionary<string, string> messages = new Dictionary<string, string>
+		{
+			["Top"] = "Tap to rain 🎊",
+			["Center"] = "Tap to explode 🎊",
+			["Sides"] = "Tap to spray 🎊",
+		};
+
+		private string configName = "Top";
+
+		public ConfettiPage()
+		{
+			InitializeComponent();
+
+			Configs = new Dictionary<string, ConfettiConfig>
+			{
+				["Top"] = new ConfettiConfig(),
+				["Center"] = new ConfettiConfig
+				{
+					MinSpeed = 30,
+					MaxSpeed = 150,
+					Duration = 0,
+					OnCreateSystem = (i, system) =>
+					{
+						system.Emitter = SKConfettiEmitter.Burst(100);
+						system.EmitterBounds = SKConfettiEmitterBounds.Center;
+					}
+				},
+				["Sides"] = new ConfettiConfig(2)
+				{
+					MinSpeed = 50,
+					MaxSpeed = 400,
+					Duration = 0,
+					OnCreateSystem = (i, system) =>
+					{
+						system.Emitter = SKConfettiEmitter.Burst(100);
+						if (i % 2 == 0)
+						{
+							system.EmitterBounds = SKConfettiEmitterBounds.Point(0, Height);
+							system.StartAngle = -85;
+							system.EndAngle = -35;
+						}
+						else
+						{
+							system.EmitterBounds = SKConfettiEmitterBounds.Point(Width, Height);
+							system.StartAngle = 265;
+							system.EndAngle = 215;
+						}
+					}
+				},
+			};
+
+			BindingContext = this;
+		}
+
+		public int SelectedTab { get; set; } = 0;
+
+		public string ConfigName
+		{
+			get => configName;
+			set
+			{
+				configName = value;
+				OnPropertyChanged();
+				OnPropertyChanged(nameof(CurrentConfig));
+				OnPropertyChanged(nameof(Message));
+			}
+		}
+
+		public Dictionary<string, ConfettiConfig> Configs { get; }
+
+		public ConfettiConfig CurrentConfig => Configs[ConfigName];
+
+		public string Message => messages[ConfigName];
+
+		private void OnTapped(object sender, EventArgs e)
+		{
+			foreach (var system in CurrentConfig.CreateSystems())
+				confettiView.Systems!.Add(system);
+		}
+	}
+}
diff --git a/samples/SkiaSharpDemo/Demos/Confetti/ConfettiStar.cs b/samples/SkiaSharpDemo/Demos/Confetti/ConfettiStar.cs
new file mode 100644
index 00000000..34da51c2
--- /dev/null
+++ b/samples/SkiaSharpDemo/Demos/Confetti/ConfettiStar.cs
@@ -0,0 +1,23 @@
+using SkiaSharp;
+using SkiaSharp.Extended;
+using SkiaSharp.Extended.UI.Controls;
+
+namespace SkiaSharpDemo.Demos
+{
+	public class ConfettiStar : SKConfettiShape
+	{
+		public ConfettiStar(int points)
+		{
+			Points = points;
+		}
+
+		public int Points { get; }
+
+		protected override void OnDraw(SKCanvas canvas, SKPaint paint, float size)
+		{
+			using var star = SKGeometry.CreateRegularStarPath(size, size / 2, Points);
+
+			canvas.DrawPath(star, paint);
+		}
+	}
+}
diff --git a/samples/SkiaSharpDemo/MainPage.xaml.cs b/samples/SkiaSharpDemo/MainPage.xaml.cs
index 45aa2bb2..ad9a902d 100644
--- a/samples/SkiaSharpDemo/MainPage.xaml.cs
+++ b/samples/SkiaSharpDemo/MainPage.xaml.cs
@@ -38,6 +38,16 @@ public MainPage()
 						Color = Color.LightSkyBlue,
 					},
 				},
+				new DemoGroup("UI & CONTROLS")
+				{
+					new Demo
+					{
+						Title = "Confetti",
+						Description = "Yeaaahhhhh! Throw that confetti! Woooooaaaaahhhh! We are the winners! Celebration words! Congrats! Yay!",
+						PageType = typeof(ConfettiPage),
+						Color = Color.SteelBlue,
+					},
+				},
 				new DemoGroup("TEXT & EMOJI")
 				{
 					new Demo
diff --git a/samples/SkiaSharpDemo/Views/BottomTab/BottomTab.cs b/samples/SkiaSharpDemo/Views/BottomTab/BottomTab.cs
new file mode 100644
index 00000000..7a912eaa
--- /dev/null
+++ b/samples/SkiaSharpDemo/Views/BottomTab/BottomTab.cs
@@ -0,0 +1,19 @@
+using Xamarin.Forms;
+
+namespace SkiaSharpDemo.Views
+{
+	public class BottomTab : ContentView
+	{
+		public static readonly BindableProperty TitleProperty = BindableProperty.Create(
+			nameof(Title),
+			typeof(string),
+			typeof(BottomTab),
+			null);
+
+		public string? Title
+		{
+			get => (string?)GetValue(TitleProperty);
+			set => SetValue(TitleProperty, value);
+		}
+	}
+}
diff --git a/samples/SkiaSharpDemo/Views/BottomTab/BottomTabBar.cs b/samples/SkiaSharpDemo/Views/BottomTab/BottomTabBar.cs
new file mode 100644
index 00000000..3bf6f529
--- /dev/null
+++ b/samples/SkiaSharpDemo/Views/BottomTab/BottomTabBar.cs
@@ -0,0 +1,167 @@
+using System.Threading.Tasks;
+using Xamarin.Forms;
+
+namespace SkiaSharpDemo.Views
+{
+	[ContentProperty(nameof(Tabs))]
+	public class BottomTabBar : TemplatedView
+	{
+		public static readonly BindableProperty TabsProperty = BindableProperty.Create(
+			nameof(Tabs),
+			typeof(BottomTabCollection),
+			typeof(BottomTabBar),
+			new BottomTabCollection());
+
+		public static readonly BindableProperty SelectedIndexProperty = BindableProperty.Create(
+			nameof(SelectedIndex),
+			typeof(int),
+			typeof(BottomTabBar),
+			-1,
+			defaultBindingMode: BindingMode.TwoWay,
+			propertyChanged: OnSelectedIndexChanged);
+
+		public static readonly BindableProperty HorizontalContentAlignmentProperty = BindableProperty.Create(
+			nameof(HorizontalContentAlignment),
+			typeof(LayoutOptions),
+			typeof(BottomTabBar),
+			LayoutOptions.Fill);
+
+		public static readonly BindableProperty VerticalContentAlignmentProperty = BindableProperty.Create(
+			nameof(VerticalContentAlignment),
+			typeof(LayoutOptions),
+			typeof(BottomTabBar),
+			LayoutOptions.Fill);
+
+		public static readonly BindableProperty HeaderContentTemplateProperty = BindableProperty.Create(
+			nameof(HeaderContentTemplate),
+			typeof(DataTemplate),
+			typeof(BottomTabBar),
+			null);
+
+		public static readonly BindableProperty PagePaddingProperty = BindableProperty.Create(
+			nameof(PagePadding),
+			typeof(Thickness),
+			typeof(BottomTabBar),
+			new Thickness());
+
+		private Layout<View>? tabBar;
+		private Layout<View>? pages;
+		private View? selector;
+
+		public BottomTabBar()
+		{
+			TabTappedCommand = new Command<View>(OnTabTapped);
+		}
+
+		public BottomTabCollection? Tabs
+		{
+			get => (BottomTabCollection?)GetValue(TabsProperty);
+			set => SetValue(TabsProperty, value);
+		}
+
+		public int SelectedIndex
+		{
+			get => (int)GetValue(SelectedIndexProperty);
+			set => SetValue(SelectedIndexProperty, value);
+		}
+
+		public LayoutOptions HorizontalContentAlignment
+		{
+			get => (LayoutOptions)GetValue(HorizontalContentAlignmentProperty);
+			set => SetValue(HorizontalContentAlignmentProperty, value);
+		}
+
+		public LayoutOptions VerticalContentAlignment
+		{
+			get => (LayoutOptions)GetValue(VerticalContentAlignmentProperty);
+			set => SetValue(VerticalContentAlignmentProperty, value);
+		}
+
+		public DataTemplate? HeaderContentTemplate
+		{
+			get => (DataTemplate?)GetValue(HeaderContentTemplateProperty);
+			set => SetValue(HeaderContentTemplateProperty, value);
+		}
+
+		public Thickness PagePadding
+		{
+			get => (Thickness)GetValue(PagePaddingProperty);
+			set => SetValue(PagePaddingProperty, value);
+		}
+
+		// TODO: this probably should not be a public property...
+		public Command<View> TabTappedCommand { get; }
+
+		protected override void OnApplyTemplate()
+		{
+			base.OnApplyTemplate();
+
+			tabBar = (Layout<View>?)GetTemplateChild("PART_TabBar");
+			pages = (Layout<View>?)GetTemplateChild("PART_PagesContainer");
+			selector = (View?)GetTemplateChild("PART_Selector");
+		}
+
+		protected override void OnSizeAllocated(double width, double height)
+		{
+			base.OnSizeAllocated(width, height);
+
+			if (Tabs?.Count > 0 && SelectedIndex == -1)
+				SelectedIndex = 0;
+			else
+				UpdateSelectedTab();
+		}
+
+		private void OnTabTapped(View tab) =>
+			SelectedIndex = tabBar?.Children?.IndexOf(tab) ?? -1;
+
+		private void UpdateSelectedTab()
+		{
+			if (!(tabBar?.Children?.Count > 0 && pages?.Children?.Count > 0))
+				return;
+
+			var index = SelectedIndex;
+
+			if (index < 0)
+				index = 0;
+			if (index >= tabBar.Children.Count)
+				index = tabBar.Children.Count - 1;
+
+			var tab = tabBar.Children[index];
+			var newPage = pages.Children[index];
+
+			if (selector != null)
+			{
+				selector.TranslateTo(tab.X, 0);
+				selector.ScaleXTo(tab.Width / selector.Width);
+			}
+
+			foreach (var page in pages.Children)
+			{
+				ViewExtensions.CancelAnimations(page);
+				if (page != newPage)
+					_ = HideTab(page);
+				else
+					_ = ShowTab(page);
+			}
+
+			static async Task HideTab(View page)
+			{
+				await page.FadeTo(0, 100);
+				page.IsVisible = false;
+			}
+
+			static async Task ShowTab(View page)
+			{
+				page.Opacity = 0;
+				page.IsVisible = true;
+				await page.FadeTo(1, 100);
+			}
+		}
+
+		private static void OnSelectedIndexChanged(BindableObject bindable, object oldValue, object newValue)
+		{
+			if (bindable is BottomTabBar control)
+				control.UpdateSelectedTab();
+		}
+	}
+}
diff --git a/samples/SkiaSharpDemo/Views/BottomTab/BottomTabBarResources.xaml b/samples/SkiaSharpDemo/Views/BottomTab/BottomTabBarResources.xaml
new file mode 100644
index 00000000..dc37135a
--- /dev/null
+++ b/samples/SkiaSharpDemo/Views/BottomTab/BottomTabBarResources.xaml
@@ -0,0 +1,70 @@
+<ResourceDictionary xmlns="http://xamarin.com/schemas/2014/forms"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+                    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+                    xmlns:d="http://xamarin.com/schemas/2014/forms/design"
+                    xmlns:views="clr-namespace:SkiaSharpDemo.Views"
+                    mc:Ignorable="d"
+                    x:Class="SkiaSharpDemo.Views.BottomTabBarResources">
+
+    <DataTemplate x:Key="BottomTabBarHeaderContentTemplate">
+        <views:TapLabel Text="{Binding Title}"
+                        FontFamily="FontAwesome" FontSize="20" HorizontalTextAlignment="Center"
+                        Padding="8"
+                        HorizontalOptions="FillAndExpand"
+                        Command="{Binding TabTappedCommand, Source={RelativeSource TemplatedParent}}"
+                        CommandParameter="{Binding Source={RelativeSource Self}}" />
+    </DataTemplate>
+
+    <!-- the bottom tab bar control template -->
+    <ControlTemplate x:Key="BottomTabBarControlTemplate">
+        <StackLayout Padding="0" Spacing="0">
+            <BoxView Color="LightGray" HeightRequest="1" />
+
+            <StackLayout x:Name="PART_TabBar"
+                         Padding="0" Spacing="0" Orientation="Horizontal"
+                         BindableLayout.ItemsSource="{Binding Tabs, Source={RelativeSource TemplatedParent}}"
+                         BindableLayout.ItemTemplate="{Binding HeaderContentTemplate, Source={RelativeSource TemplatedParent}}" />
+
+            <BoxView x:Name="PART_Selector" Color="Orange"
+                     WidthRequest="100" HeightRequest="3"
+                     HorizontalOptions="Start" AnchorX="0" />
+
+            <Grid x:Name="PART_PagesContainer"
+                  Padding="{Binding PagePadding, Source={RelativeSource TemplatedParent}}" RowSpacing="0" ColumnSpacing="0"
+                  HeightRequest="100"
+                  BindableLayout.ItemsSource="{Binding Tabs, Source={RelativeSource TemplatedParent}}">
+                <BindableLayout.ItemTemplate>
+                    <DataTemplate>
+                        <ContentPresenter Content="{Binding}"
+                                          HorizontalOptions="{Binding HorizontalContentAlignment, Source={RelativeSource TemplatedParent}}"
+                                          VerticalOptions="{Binding VerticalContentAlignment, Source={RelativeSource TemplatedParent}}" />
+                    </DataTemplate>
+                </BindableLayout.ItemTemplate>
+            </Grid>
+        </StackLayout>
+    </ControlTemplate>
+
+    <!-- the "base" style for the bottom tab bar -->
+    <Style x:Key="BottomTabBarStyle" TargetType="views:BottomTabBar">
+        <Setter Property="ControlTemplate"
+                Value="{StaticResource BottomTabBarControlTemplate}" />
+        <Setter Property="HeaderContentTemplate"
+                Value="{StaticResource BottomTabBarHeaderContentTemplate}" />
+        <Setter Property="VerticalOptions"
+                Value="End" />
+    </Style>
+
+    <!-- the "base" style for the bottom tab "page" -->
+    <Style x:Key="BottomTabStyle" TargetType="views:BottomTab">
+        <!-- bring the binding context from the control to the tab -->
+        <Setter Property="BindingContext"
+                Value="{Binding BindingContext, Source={RelativeSource AncestorType={x:Type views:BottomTabBar}}}" />
+    </Style>
+
+    <!-- the implicit styles -->
+    <Style TargetType="views:BottomTabBar"
+           BasedOn="{StaticResource BottomTabBarStyle}" />
+    <Style TargetType="views:BottomTab"
+           BasedOn="{StaticResource BottomTabStyle}" />
+
+</ResourceDictionary>
\ No newline at end of file
diff --git a/samples/SkiaSharpDemo/Views/BottomTab/BottomTabBarResources.xaml.cs b/samples/SkiaSharpDemo/Views/BottomTab/BottomTabBarResources.xaml.cs
new file mode 100644
index 00000000..69ddc776
--- /dev/null
+++ b/samples/SkiaSharpDemo/Views/BottomTab/BottomTabBarResources.xaml.cs
@@ -0,0 +1,12 @@
+using Xamarin.Forms;
+
+namespace SkiaSharpDemo.Views
+{
+	public partial class BottomTabBarResources : ResourceDictionary
+	{
+		public BottomTabBarResources()
+		{
+			InitializeComponent();
+		}
+	}
+}
diff --git a/samples/SkiaSharpDemo/Views/BottomTab/BottomTabCollection.cs b/samples/SkiaSharpDemo/Views/BottomTab/BottomTabCollection.cs
new file mode 100644
index 00000000..f113020a
--- /dev/null
+++ b/samples/SkiaSharpDemo/Views/BottomTab/BottomTabCollection.cs
@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace SkiaSharpDemo.Views
+{
+	public class BottomTabCollection : ObservableCollection<BottomTab>
+	{
+		public BottomTabCollection()
+		{
+		}
+
+		public BottomTabCollection(IEnumerable<BottomTab> collection)
+			: base(collection)
+		{
+		}
+
+		public BottomTabCollection(List<BottomTab> list)
+			: base(list)
+		{
+		}
+	}
+}
diff --git a/samples/SkiaSharpDemo/Views/OptionButtons/OptionButtons.cs b/samples/SkiaSharpDemo/Views/OptionButtons/OptionButtons.cs
new file mode 100644
index 00000000..db28a4e1
--- /dev/null
+++ b/samples/SkiaSharpDemo/Views/OptionButtons/OptionButtons.cs
@@ -0,0 +1,94 @@
+using System.Collections;
+using System.Collections.Generic;
+using Xamarin.Forms;
+
+namespace SkiaSharpDemo.Views
+{
+	public static class OptionButtons
+	{
+		// OptionButtonsManager
+
+		private static OptionButtonsManager? GetOptionButtonsManager(BindableObject obj) =>
+			(OptionButtonsManager?)obj.GetValue(OptionButtonsManagerProperty);
+
+		private static readonly BindableProperty OptionButtonsManagerProperty = BindableProperty.CreateAttached(
+			"OptionButtonsManager",
+			typeof(OptionButtonsManager),
+			typeof(Layout<View>),
+			null,
+			defaultValueCreator: _ => new OptionButtonsManager());
+
+		// SelectionMode
+
+		public static SelectionMode GetSelectionMode(BindableObject obj) =>
+			(SelectionMode)obj.GetValue(SelectionModeProperty);
+
+		public static void SetSelectionMode(BindableObject obj, SelectionMode value) =>
+			obj.SetValue(SelectionModeProperty, value);
+
+		public static readonly BindableProperty SelectionModeProperty = BindableProperty.CreateAttached(
+			"SelectionMode",
+			typeof(SelectionMode),
+			typeof(Layout<View>),
+			SelectionMode.None,
+			propertyChanged: OnPropertyChanged);
+
+		// AllowNone
+
+		public static bool GetAllowNone(BindableObject obj) =>
+			(bool)obj.GetValue(AllowNoneProperty);
+
+		public static void SetAllowNone(BindableObject obj, bool value) =>
+			obj.SetValue(AllowNoneProperty, value);
+
+		public static readonly BindableProperty AllowNoneProperty = BindableProperty.CreateAttached(
+			"AllowNone",
+			typeof(bool),
+			typeof(Layout<View>),
+			true,
+			propertyChanged: OnPropertyChanged);
+
+		// SelectedItems
+
+		public static IList? GetSelectedItems(BindableObject obj) =>
+			(IList?)obj.GetValue(SelectedItemsProperty);
+
+		public static void SetSelectedItems(BindableObject obj, IList? value) =>
+			obj.SetValue(SelectedItemsProperty, value);
+
+		public static readonly BindableProperty SelectedItemsProperty = BindableProperty.CreateAttached(
+			"SelectedItems",
+			typeof(IList),
+			typeof(Layout<View>),
+			null,
+			propertyChanged: OnPropertyChanged,
+			defaultValueCreator: _ => new List<object>());
+
+		// SelectedItem
+
+		public static object? GetSelectedItem(BindableObject obj) =>
+			obj.GetValue(SelectedItemProperty);
+
+		public static void SetSelectedItem(BindableObject obj, object? value) =>
+			obj.SetValue(SelectedItemProperty, value);
+
+		public static readonly BindableProperty SelectedItemProperty = BindableProperty.CreateAttached(
+			"SelectedItem",
+			typeof(object),
+			typeof(Layout<View>),
+			null,
+			propertyChanged: OnPropertyChanged,
+			defaultBindingMode: BindingMode.TwoWay);
+
+		//
+
+		private static void OnPropertyChanged(BindableObject bindable, object oldValue, object newValue)
+		{
+			if (!(bindable is Layout<View> layout) ||
+				!(GetOptionButtonsManager(bindable) is OptionButtonsManager manager))
+				return;
+
+			manager.Update(layout);
+		}
+	}
+}
diff --git a/samples/SkiaSharpDemo/Views/OptionButtons/OptionButtonsManager.cs b/samples/SkiaSharpDemo/Views/OptionButtons/OptionButtonsManager.cs
new file mode 100644
index 00000000..93ae2da2
--- /dev/null
+++ b/samples/SkiaSharpDemo/Views/OptionButtons/OptionButtonsManager.cs
@@ -0,0 +1,151 @@
+using System;
+using Xamarin.Forms;
+
+namespace SkiaSharpDemo.Views
+{
+	internal class OptionButtonsManager
+	{
+		private const string SelectedState = "Selected";
+		private const string UnselectedState = "Unselected";
+
+		private bool isSubscribed;
+
+		public void Update(Layout<View> layout)
+		{
+			var mode = OptionButtons.GetSelectionMode(layout);
+			if (mode == SelectionMode.None)
+			{
+				foreach (var child in layout.Children)
+				{
+					if (child is Button button)
+						button.Clicked -= OnButtonClicked;
+				}
+
+				layout.ChildAdded -= OnChildAdded;
+				layout.ChildRemoved -= OnChildRemoved;
+
+				isSubscribed = false;
+			}
+			else if (!isSubscribed)
+			{
+				foreach (var child in layout.Children)
+				{
+					if (child is Button button)
+						button.Clicked += OnButtonClicked;
+				}
+
+				layout.ChildAdded += OnChildAdded;
+				layout.ChildRemoved += OnChildRemoved;
+
+				isSubscribed = true;
+			}
+
+			UpdateSelection(layout);
+		}
+
+		private static void UpdateSelection(Layout<View> layout)
+		{
+			var mode = OptionButtons.GetSelectionMode(layout);
+			var allowNone = OptionButtons.GetAllowNone(layout);
+			var selectedItems = OptionButtons.GetSelectedItems(layout);
+			var selectedItem = OptionButtons.GetSelectedItem(layout);
+
+			for (var i = 0; i < layout.Children.Count; i++)
+			{
+				var child = (View?)layout.Children[i];
+				if (child is Button button && child.BindingContext is object item)
+				{
+					if (mode == SelectionMode.Multiple)
+					{
+						if (selectedItems?.Contains(item) == true)
+							VisualStateManager.GoToState(button, SelectedState);
+						else
+							VisualStateManager.GoToState(button, UnselectedState);
+					}
+					else if (mode == SelectionMode.Single)
+					{
+						if (selectedItem == item)
+							VisualStateManager.GoToState(button, SelectedState);
+						else
+							VisualStateManager.GoToState(button, UnselectedState);
+					}
+				}
+			}
+		}
+
+		private static void OnChildAdded(object sender, ElementEventArgs e)
+		{
+			if (e.Element is Button button)
+				button.Clicked += OnButtonClicked;
+		}
+
+		private static void OnChildRemoved(object sender, ElementEventArgs e)
+		{
+			if (e.Element is Button button)
+				button.Clicked -= OnButtonClicked;
+		}
+
+		private static void OnButtonClicked(object sender, EventArgs e)
+		{
+			if (!(sender is Button button) ||
+				!(button?.Parent is Layout<View> parent) ||
+				!(button.BindingContext is object item))
+				return;
+
+			var mode = OptionButtons.GetSelectionMode(parent);
+			if (mode == SelectionMode.None)
+				return;
+
+			var allowNone = OptionButtons.GetAllowNone(parent);
+			var selectedItems = OptionButtons.GetSelectedItems(parent);
+
+			if (!allowNone)
+			{
+				if (selectedItems != null)
+				{
+					// do not unselect a single item if we are not allowed
+					if (selectedItems.Count == 1 && item.Equals(selectedItems[0]))
+						return;
+				}
+			}
+
+			// clear the list if we are not a multi-select list
+			if (mode != SelectionMode.Multiple)
+			{
+				if (selectedItems != null)
+				{
+					for (var i = selectedItems.Count - 1; i >= 0; i--)
+					{
+						if (selectedItems[i] == item)
+							i--;
+						else
+							selectedItems.RemoveAt(i);
+					}
+				}
+
+				foreach (var btn in parent.Children)
+				{
+					if (btn != button)
+						VisualStateManager.GoToState(btn, UnselectedState);
+				}
+			}
+
+			var shouldSelect = false;
+
+			// update the selected items list
+			if (selectedItems != null)
+			{
+				shouldSelect = !selectedItems.Contains(item);
+				if (shouldSelect)
+					selectedItems.Add(item);
+				else
+					selectedItems.Remove(item);
+			}
+
+			// updated the selected item
+			OptionButtons.SetSelectedItem(parent, item);
+
+			VisualStateManager.GoToState(button, shouldSelect ? SelectedState : UnselectedState);
+		}
+	}
+}
diff --git a/samples/SkiaSharpDemo/Views/TapLabel.cs b/samples/SkiaSharpDemo/Views/TapLabel.cs
new file mode 100644
index 00000000..716077a4
--- /dev/null
+++ b/samples/SkiaSharpDemo/Views/TapLabel.cs
@@ -0,0 +1,52 @@
+using System;
+using System.Windows.Input;
+using Xamarin.Forms;
+
+namespace SkiaSharpDemo.Views
+{
+	public class TapLabel : Label
+	{
+		public static readonly BindableProperty CommandProperty = BindableProperty.Create(
+			nameof(Command),
+			typeof(ICommand),
+			typeof(TapLabel),
+			null);
+
+		public static readonly BindableProperty CommandParameterProperty = BindableProperty.Create(
+			nameof(CommandParameter),
+			typeof(object),
+			typeof(TapLabel),
+			null);
+
+		public TapLabel()
+		{
+			var tap = new TapGestureRecognizer();
+			tap.Tapped += OnTapped;
+
+			GestureRecognizers.Add(tap);
+		}
+
+		public ICommand? Command
+		{
+			get => (ICommand?)GetValue(CommandProperty);
+			set => SetValue(CommandProperty, value);
+		}
+
+		public object? CommandParameter
+		{
+			get => GetValue(CommandParameterProperty);
+			set => SetValue(CommandParameterProperty, value);
+		}
+
+		public event EventHandler? Tapped;
+
+		protected virtual void OnTapped(object sender, EventArgs e)
+		{
+			var param = CommandParameter;
+			if (Command is ICommand cmd && cmd.CanExecute(param))
+				cmd.Execute(param);
+
+			Tapped?.Invoke(this, e);
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiColorCollection.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiColorCollection.shared.cs
new file mode 100644
index 00000000..f070d16f
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiColorCollection.shared.cs
@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using Xamarin.Forms;
+
+namespace SkiaSharp.Extended.UI.Controls
+{
+	[TypeConverter(typeof(Converters.SKConfettiColorCollectionTypeConverter))]
+	public class SKConfettiColorCollection : List<Color>
+	{
+		public SKConfettiColorCollection()
+		{
+		}
+
+		public SKConfettiColorCollection(IEnumerable<Color> collection)
+			: base(collection)
+		{
+		}
+
+		public SKConfettiColorCollection(int capacity)
+			: base(capacity)
+		{
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiColorCollectionTypeConverter.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiColorCollectionTypeConverter.shared.cs
new file mode 100644
index 00000000..f11120aa
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiColorCollectionTypeConverter.shared.cs
@@ -0,0 +1,32 @@
+using Xamarin.Forms;
+using Xamarin.Forms.Xaml;
+
+namespace SkiaSharp.Extended.UI.Controls.Converters
+{
+	[TypeConversion(typeof(SKConfettiColorCollection))]
+	public class SKConfettiColorCollectionTypeConverter : TypeConverter
+	{
+		public override object? ConvertFromInvariantString(string? value)
+		{
+			if (value == null)
+				return null;
+
+			value = value?.Trim();
+			var parts = value?.Split(',');
+
+			if (parts == null)
+				return null;
+
+			var colors = new SKConfettiColorCollection();
+			var colConv = new ColorTypeConverter();
+
+			foreach (var part in parts)
+			{
+				var c = colConv.ConvertFromInvariantString(part);
+				colors.Add((Color)c);
+			}
+
+			return colors;
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitter.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitter.shared.cs
new file mode 100644
index 00000000..c7e48a01
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitter.shared.cs
@@ -0,0 +1,118 @@
+using System;
+using Xamarin.Forms;
+
+namespace SkiaSharp.Extended.UI.Controls
+{
+	public class SKConfettiEmitter : BindableObject
+	{
+		public static readonly BindableProperty ParticleRateProperty = BindableProperty.Create(
+			nameof(ParticleRate),
+			typeof(int),
+			typeof(SKConfettiEmitter),
+			100);
+
+		public static readonly BindableProperty MaxParticlesProperty = BindableProperty.Create(
+			nameof(MaxParticles),
+			typeof(int),
+			typeof(SKConfettiEmitter),
+			-1);
+
+		public static readonly BindableProperty DurationProperty = BindableProperty.Create(
+			nameof(Duration),
+			typeof(double),
+			typeof(SKConfettiEmitter),
+			5.0);
+
+		private static readonly BindablePropertyKey IsCompletePropertyKey = BindableProperty.CreateReadOnly(
+			nameof(IsComplete),
+			typeof(bool),
+			typeof(SKConfettiEmitter),
+			false);
+
+		public static readonly BindableProperty IsCompleteProperty = IsCompletePropertyKey.BindableProperty;
+
+		private int totalParticles = 0;
+		private double totalDuration = 0;
+
+		public SKConfettiEmitter()
+		{
+			DebugUtils.LogPropertyChanged(this);
+		}
+
+		public SKConfettiEmitter(int particleRate, int maxParticles, double duration)
+			: this()
+		{
+			ParticleRate = particleRate;
+			MaxParticles = maxParticles;
+			Duration = duration;
+		}
+
+		public int ParticleRate
+		{
+			get => (int)GetValue(ParticleRateProperty);
+			set => SetValue(ParticleRateProperty, value);
+		}
+
+		public int MaxParticles
+		{
+			get => (int)GetValue(MaxParticlesProperty);
+			set => SetValue(MaxParticlesProperty, value);
+		}
+
+		public double Duration
+		{
+			get => (double)GetValue(DurationProperty);
+			set => SetValue(DurationProperty, value);
+		}
+
+		public bool IsComplete
+		{
+			get => (bool)GetValue(IsCompleteProperty);
+			private set => SetValue(IsCompletePropertyKey, value);
+		}
+
+		public event Action<int>? ParticlesCreated;
+
+		public void Update(TimeSpan deltaTime)
+		{
+			if (IsComplete)
+				return;
+
+			var prevDuration = totalDuration;
+			var currDuration = deltaTime.TotalSeconds;
+			totalDuration += currDuration;
+
+			double secs;
+			if (Duration == 0)
+				secs = 1.0; // burst mode, so pop them all
+			else if (Duration > 0 && totalDuration > Duration)
+				secs = Duration - prevDuration; // took longer, so trim
+			else
+				secs = currDuration; // either infinite or normal
+
+			var particles = (int)(ParticleRate * secs);
+			if (MaxParticles > 0)
+				particles = Math.Min(particles, MaxParticles);
+			totalParticles += particles;
+
+			ParticlesCreated?.Invoke(particles);
+
+			IsComplete =
+				Duration == 0 || // burst mode
+				(MaxParticles > 0 && totalParticles >= MaxParticles) || // reached the max particles
+				(Duration > 0 && totalDuration >= Duration); // reached the max duration
+		}
+
+		public static SKConfettiEmitter Burst(int particles) =>
+			new SKConfettiEmitter(particles, -1, 0);
+
+		public static SKConfettiEmitter Stream(int particleRate, double duration) =>
+			new SKConfettiEmitter(particleRate, -1, duration);
+
+		public static SKConfettiEmitter Infinite(int particleRate) =>
+			new SKConfettiEmitter(particleRate, -1, -1);
+
+		public static SKConfettiEmitter Infinite(int particleRate, int maxParticles) =>
+			new SKConfettiEmitter(particleRate, maxParticles, -1);
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitterBounds.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitterBounds.shared.cs
new file mode 100644
index 00000000..d5f19fb4
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitterBounds.shared.cs
@@ -0,0 +1,85 @@
+using Xamarin.Forms;
+
+namespace SkiaSharp.Extended.UI.Controls
+{
+	[TypeConverter(typeof(Converters.SKConfettiEmitterBoundsTypeConverter))]
+	public readonly struct SKConfettiEmitterBounds
+	{
+		public SKConfettiEmitterBounds(SKConfettiEmitterSide side)
+			: this(Rect.Zero, side)
+		{
+		}
+
+		public SKConfettiEmitterBounds(double x, double y)
+			: this(new Rect(x, y, 0, 0), SKConfettiEmitterSide.Bounds)
+		{
+		}
+
+		public SKConfettiEmitterBounds(Point point)
+			: this(new Rect(point, Size.Zero), SKConfettiEmitterSide.Bounds)
+		{
+		}
+
+		public SKConfettiEmitterBounds(double x, double y, double width, double height)
+			: this(new Rect(x, y, width, height), SKConfettiEmitterSide.Bounds)
+		{
+		}
+
+		public SKConfettiEmitterBounds(Rect rect)
+			: this(rect, SKConfettiEmitterSide.Bounds)
+		{
+		}
+
+		private SKConfettiEmitterBounds(Rect rect, SKConfettiEmitterSide side)
+		{
+			Rect = rect;
+			Side = side;
+		}
+
+		//
+
+		public Rect Rect { get; }
+
+		public SKConfettiEmitterSide Side { get; }
+
+		//
+
+		public static implicit operator SKConfettiEmitterBounds(SKConfettiEmitterSide side) =>
+			new SKConfettiEmitterBounds(side);
+
+		public static implicit operator SKConfettiEmitterBounds(Point point) =>
+			new SKConfettiEmitterBounds(point);
+
+		public static implicit operator SKConfettiEmitterBounds(Rect rect) =>
+			new SKConfettiEmitterBounds(rect);
+
+		//
+
+		public static SKConfettiEmitterBounds Top =>
+			new SKConfettiEmitterBounds(SKConfettiEmitterSide.Top);
+
+		public static SKConfettiEmitterBounds Left =>
+			new SKConfettiEmitterBounds(SKConfettiEmitterSide.Left);
+
+		public static SKConfettiEmitterBounds Right =>
+			new SKConfettiEmitterBounds(SKConfettiEmitterSide.Right);
+
+		public static SKConfettiEmitterBounds Bottom =>
+			new SKConfettiEmitterBounds(SKConfettiEmitterSide.Bottom);
+
+		public static SKConfettiEmitterBounds Center =>
+			new SKConfettiEmitterBounds(SKConfettiEmitterSide.Center);
+
+		public static SKConfettiEmitterBounds Bounds(double x, double y, double width, double height) =>
+			new SKConfettiEmitterBounds(x, y, width, height);
+
+		public static SKConfettiEmitterBounds Bounds(Rect rect) =>
+			new SKConfettiEmitterBounds(rect);
+
+		public static SKConfettiEmitterBounds Point(double x, double y) =>
+			new SKConfettiEmitterBounds(x, y);
+
+		public static SKConfettiEmitterBounds Point(Point point) =>
+			new SKConfettiEmitterBounds(point);
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitterBoundsTypeConverter.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitterBoundsTypeConverter.shared.cs
new file mode 100644
index 00000000..d311b203
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitterBoundsTypeConverter.shared.cs
@@ -0,0 +1,44 @@
+using System;
+using Xamarin.Forms;
+using Xamarin.Forms.Xaml;
+
+namespace SkiaSharp.Extended.UI.Controls.Converters
+{
+	[TypeConversion(typeof(SKConfettiEmitterBounds))]
+	public class SKConfettiEmitterBoundsTypeConverter : TypeConverter
+	{
+		public override object? ConvertFromInvariantString(string? value)
+		{
+			if (value == null)
+				return null;
+
+			value = value?.Trim();
+
+			if (string.Compare(value, "top", StringComparison.OrdinalIgnoreCase) == 0)
+				return SKConfettiEmitterBounds.Top;
+
+			if (string.Compare(value, "left", StringComparison.OrdinalIgnoreCase) == 0)
+				return SKConfettiEmitterBounds.Left;
+
+			if (string.Compare(value, "right", StringComparison.OrdinalIgnoreCase) == 0)
+				return SKConfettiEmitterBounds.Right;
+
+			if (string.Compare(value, "bottom", StringComparison.OrdinalIgnoreCase) == 0)
+				return SKConfettiEmitterBounds.Bottom;
+
+			if (string.Compare(value, "center", StringComparison.OrdinalIgnoreCase) == 0)
+				return SKConfettiEmitterBounds.Center;
+
+			if (value?.IndexOf(',') == value?.LastIndexOf(','))
+			{
+				var pointConverter = new PointTypeConverter();
+				var point = (Point)pointConverter.ConvertFromInvariantString(value);
+				return SKConfettiEmitterBounds.Point(point);
+			}
+
+			var rectConverter = new RectTypeConverter();
+			var rect = (Rect)rectConverter.ConvertFromInvariantString(value);
+			return SKConfettiEmitterBounds.Bounds(rect);
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitterSide.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitterSide.shared.cs
new file mode 100644
index 00000000..53c4a392
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiEmitterSide.shared.cs
@@ -0,0 +1,14 @@
+namespace SkiaSharp.Extended.UI.Controls
+{
+	public enum SKConfettiEmitterSide
+	{
+		Top,
+		Left,
+		Right,
+		Bottom,
+
+		Center,
+
+		Bounds,
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiParticle.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiParticle.shared.cs
new file mode 100644
index 00000000..0b0bf8d5
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiParticle.shared.cs
@@ -0,0 +1,148 @@
+using System;
+
+namespace SkiaSharp.Extended.UI.Controls
+{
+	internal class SKConfettiParticle
+	{
+		private static readonly SKObjectPool<SKPaint> paintPool =
+			new SKObjectPool<SKPaint>(() => new SKPaint { IsAntialias = true });
+
+		private SKPoint acceleration = SKPoint.Empty;
+		private float rotationWidth = 0f;
+		private float scaleX = 1f;
+
+		private SKPoint location;
+		private float size;
+
+		public SKPoint Location
+		{
+			get => location;
+			set
+			{
+				location = value;
+				Bounds = new SKRect(location.X - size, location.Y - size, size * 2, size * 2);
+			}
+		}
+
+		public float Size
+		{
+			get => size;
+			set
+			{
+				size = value;
+				Bounds = new SKRect(location.X - size, location.Y - size, size * 2, size * 2);
+			}
+		}
+
+		public float Mass { get; set; }
+
+		public float Rotation { get; set; }
+
+		public SKColorF Color { get; set; }
+
+		public SKConfettiShape? Shape { get; set; }
+
+		public SKPoint Velocity { get; set; }
+
+		public float RotationVelocity { get; set; }
+
+		public SKPoint MaximumVelocity { get; set; }
+
+		public bool FadeOut { get; set; }
+
+		public double Lifetime { get; set; }
+
+		public SKRect Bounds { get; private set; }
+
+		public bool IsComplete { get; private set; }
+
+		public void Draw(SKCanvas canvas, TimeSpan deltaTime)
+		{
+			if (IsComplete || Shape == null)
+				return;
+
+			canvas.Save();
+			canvas.Translate(Location);
+
+			if (Rotation != 0)
+			{
+				canvas.RotateDegrees(Rotation);
+				canvas.Scale(scaleX, 1f);
+			}
+
+			var paint = paintPool.Get();
+			paint.Reset();
+			paint.ColorF = Color;
+
+			Shape.Draw(canvas, paint, Size);
+
+			paintPool.Return(paint);
+
+			canvas.Restore();
+		}
+
+		public void ApplyForce(SKPoint force, TimeSpan deltaTime)
+		{
+			if (IsComplete)
+				return;
+
+			var secs = (float)deltaTime.TotalSeconds;
+			force.X = (force.X / Mass) * secs;
+			force.Y = (force.Y / Mass) * secs;
+
+			if (force != SKPoint.Empty)
+				acceleration += force;
+
+			Velocity += acceleration;
+			if (MaximumVelocity != SKPoint.Empty)
+			{
+				var vx = Velocity.X;
+				var vy = Velocity.Y;
+
+				vx = vx < 0
+					? Math.Max(vx, -MaximumVelocity.X)
+					: Math.Min(vx, MaximumVelocity.X);
+				vy = vy < 0
+					? Math.Max(vy, -MaximumVelocity.Y)
+					: Math.Min(vy, MaximumVelocity.Y);
+
+				Velocity = new SKPoint(vx, vy);
+			}
+
+			Location = new SKPoint(
+				Location.X + Velocity.X * secs,
+				Location.Y + Velocity.Y * secs);
+
+			Lifetime -= deltaTime.TotalSeconds;
+			if (Lifetime <= 0)
+			{
+				if (FadeOut)
+				{
+					var c = Color;
+					var alpha = c.Alpha - secs;
+					Color = c.WithAlpha(alpha);
+					IsComplete = alpha <= 0;
+				}
+				else
+				{
+					IsComplete = true;
+				}
+			}
+
+			if (RotationVelocity != 0)
+			{
+				var rv = RotationVelocity * secs;
+
+				Rotation += rv;
+				if (Rotation >= 360)
+					Rotation = 0f;
+
+				rotationWidth -= rv;
+				if (rotationWidth < 0)
+					rotationWidth = Size;
+
+				scaleX = Math.Abs(rotationWidth / Size - 0.5f) * 2;
+			}
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiPhysics.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiPhysics.shared.cs
new file mode 100644
index 00000000..5fa0586b
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiPhysics.shared.cs
@@ -0,0 +1,18 @@
+using System.ComponentModel;
+
+namespace SkiaSharp.Extended.UI.Controls
+{
+	[TypeConverter(typeof(Converters.SKConfettiPhysicsTypeConverter))]
+	public readonly struct SKConfettiPhysics
+	{
+		public SKConfettiPhysics(double size, double mass)
+		{
+			Size = size;
+			Mass = mass;
+		}
+
+		public double Size { get; }
+
+		public double Mass { get; }
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiPhysicsCollection.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiPhysicsCollection.shared.cs
new file mode 100644
index 00000000..a1b25a0e
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiPhysicsCollection.shared.cs
@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+
+namespace SkiaSharp.Extended.UI.Controls
+{
+	public class SKConfettiPhysicsCollection : List<SKConfettiPhysics>
+	{
+		public SKConfettiPhysicsCollection()
+		{
+		}
+
+		public SKConfettiPhysicsCollection(IEnumerable<SKConfettiPhysics> collection)
+			: base(collection)
+		{
+		}
+
+		public SKConfettiPhysicsCollection(int capacity)
+			: base(capacity)
+		{
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiPhysicsTypeConverter.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiPhysicsTypeConverter.shared.cs
new file mode 100644
index 00000000..4b09ec95
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiPhysicsTypeConverter.shared.cs
@@ -0,0 +1,21 @@
+using Xamarin.Forms;
+using Xamarin.Forms.Xaml;
+
+namespace SkiaSharp.Extended.UI.Controls.Converters
+{
+	[TypeConversion(typeof(SKConfettiPhysics))]
+	public class SKConfettiPhysicsTypeConverter : TypeConverter
+	{
+		public override object? ConvertFromInvariantString(string? value)
+		{
+			if (value == null)
+				return null;
+
+			value = value?.Trim();
+
+			var pointConverter = new PointTypeConverter();
+			var point = (Point)pointConverter.ConvertFromInvariantString(value);
+			return new SKConfettiPhysics(point.X, point.Y);
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiShape.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiShape.shared.cs
new file mode 100644
index 00000000..524209a9
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiShape.shared.cs
@@ -0,0 +1,159 @@
+using System;
+using Xamarin.Forms;
+
+namespace SkiaSharp.Extended.UI.Controls
+{
+	public abstract class SKConfettiShape : BindableObject
+	{
+		public void Draw(SKCanvas canvas, SKPaint paint, float size)
+		{
+			OnDraw(canvas, paint, size);
+		}
+
+		protected abstract void OnDraw(SKCanvas canvas, SKPaint paint, float size);
+	}
+
+	public class SKConfettiSquareShape : SKConfettiShape
+	{
+		protected override void OnDraw(SKCanvas canvas, SKPaint paint, float size)
+		{
+			var offset = -size / 2f;
+			var rect = SKRect.Create(offset, offset, size, size);
+			canvas.DrawRect(rect, paint);
+		}
+	}
+
+	public class SKConfettiCircleShape : SKConfettiShape
+	{
+		protected override void OnDraw(SKCanvas canvas, SKPaint paint, float size)
+		{
+			canvas.DrawCircle(0, 0, size / 2f, paint);
+		}
+	}
+
+	public class SKConfettiRectShape : SKConfettiShape
+	{
+		public static readonly BindableProperty HeightRatioProperty = BindableProperty.Create(
+			nameof(HeightRatio),
+			typeof(double),
+			typeof(SKConfettiRectShape),
+			0.5,
+			coerceValue: OnCoerceHeightRatio);
+
+		public SKConfettiRectShape()
+		{
+		}
+
+		public SKConfettiRectShape(double heightRatio)
+		{
+			HeightRatio = heightRatio;
+		}
+
+		public double HeightRatio
+		{
+			get => (double)GetValue(HeightRatioProperty);
+			set => SetValue(HeightRatioProperty, value);
+		}
+
+		protected override void OnDraw(SKCanvas canvas, SKPaint paint, float size)
+		{
+			var height = size * (float)HeightRatio;
+			if (size <= 0 || height <= 0)
+				return;
+
+			var rect = SKRect.Create(-size / 2f, -height / 2f, size, height);
+			canvas.DrawRect(rect, paint);
+		}
+
+		private static object OnCoerceHeightRatio(BindableObject bindable, object value) =>
+			value is double ratio
+				? Math.Max(0, Math.Min(ratio, 1.0))
+				: (object)1.0;
+	}
+
+	public class SKConfettiOvalShape : SKConfettiShape
+	{
+		public static readonly BindableProperty HeightRatioProperty = BindableProperty.Create(
+			nameof(HeightRatio),
+			typeof(double),
+			typeof(SKConfettiOvalShape),
+			0.5,
+			coerceValue: OnCoerceHeightRatio);
+
+		public SKConfettiOvalShape()
+		{
+		}
+
+		public SKConfettiOvalShape(double heightRatio)
+		{
+			HeightRatio = heightRatio;
+		}
+
+		public double HeightRatio
+		{
+			get => (double)GetValue(HeightRatioProperty);
+			set => SetValue(HeightRatioProperty, value);
+		}
+
+		protected override void OnDraw(SKCanvas canvas, SKPaint paint, float size)
+		{
+			var height = size * (float)HeightRatio;
+			if (size <= 0 || height <= 0)
+				return;
+
+			var rect = SKRect.Create(-size / 2f, -height / 2f, size, height);
+			canvas.DrawOval(rect, paint);
+		}
+
+		private static object OnCoerceHeightRatio(BindableObject bindable, object value) =>
+			value is double ratio
+				? Math.Max(0, Math.Min(ratio, 1.0))
+				: (object)1.0;
+	}
+
+	public class SKConfettiPathShape : SKConfettiShape
+	{
+		public static readonly BindableProperty PathProperty = BindableProperty.Create(
+			nameof(Path),
+			typeof(SKPath),
+			typeof(SKConfettiPathShape),
+			null,
+			propertyChanged: OnPathChanged);
+
+		private SKSize baseSize;
+
+		public SKConfettiPathShape()
+		{
+		}
+
+		public SKConfettiPathShape(SKPath path)
+		{
+			Path = path ?? throw new ArgumentNullException(nameof(path));
+		}
+
+		public SKPath? Path
+		{
+			get => (SKPath?)GetValue(PathProperty);
+			set => SetValue(PathProperty, value);
+		}
+
+		protected override void OnDraw(SKCanvas canvas, SKPaint paint, float size)
+		{
+			if (baseSize.Width <= 0 || baseSize.Height <= 0 || Path == null)
+				return;
+
+			canvas.Save();
+			canvas.Scale(size / baseSize.Width, size / baseSize.Height);
+
+			canvas.DrawPath(Path, paint);
+
+			canvas.Restore();
+		}
+
+		private static void OnPathChanged(BindableObject bindable, object oldValue, object newValue)
+		{
+			if (bindable is SKConfettiPathShape shape && newValue is SKPath path)
+				shape.baseSize = path.TightBounds.Size;
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiShapeCollection.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiShapeCollection.shared.cs
new file mode 100644
index 00000000..4e500aac
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiShapeCollection.shared.cs
@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+
+namespace SkiaSharp.Extended.UI.Controls
+{
+	public class SKConfettiShapeCollection : List<SKConfettiShape>
+	{
+		public SKConfettiShapeCollection()
+		{
+		}
+
+		public SKConfettiShapeCollection(IEnumerable<SKConfettiShape> collection)
+			: base(collection)
+		{
+		}
+
+		public SKConfettiShapeCollection(int capacity)
+			: base(capacity)
+		{
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiSystem.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiSystem.shared.cs
new file mode 100644
index 00000000..db6767ee
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiSystem.shared.cs
@@ -0,0 +1,406 @@
+using System;
+using System.Collections.Generic;
+using SkiaSharp.Views.Forms;
+using Xamarin.Forms;
+
+namespace SkiaSharp.Extended.UI.Controls
+{
+	public class SKConfettiSystem : BindableObject
+	{
+		public static readonly BindableProperty EmitterBoundsProperty = BindableProperty.Create(
+			nameof(EmitterBounds),
+			typeof(SKConfettiEmitterBounds),
+			typeof(SKConfettiSystem),
+			SKConfettiEmitterBounds.Top);
+
+		public static readonly BindableProperty EmitterProperty = BindableProperty.Create(
+			nameof(Emitter),
+			typeof(SKConfettiEmitter),
+			typeof(SKConfettiSystem),
+			null,
+			propertyChanged: OnEmitterChanged,
+			defaultValueCreator: _ => new SKConfettiEmitter());
+
+		public static readonly BindableProperty ColorsProperty = BindableProperty.Create(
+			nameof(Colors),
+			typeof(SKConfettiColorCollection),
+			typeof(SKConfettiSystem),
+			null,
+			defaultValueCreator: _ => CreateDefaultColors());
+
+		public static readonly BindableProperty PhysicsProperty = BindableProperty.Create(
+			nameof(Physics),
+			typeof(SKConfettiPhysicsCollection),
+			typeof(SKConfettiSystem),
+			null,
+			defaultValueCreator: _ => CreateDefaultPhysics());
+
+		public static readonly BindableProperty ShapesProperty = BindableProperty.Create(
+			nameof(Shapes),
+			typeof(SKConfettiShapeCollection),
+			typeof(SKConfettiSystem),
+			null,
+			defaultValueCreator: _ => CreateDefaultShapes());
+
+		public static readonly BindableProperty StartAngleProperty = BindableProperty.Create(
+			nameof(StartAngle),
+			typeof(double),
+			typeof(SKConfettiSystem),
+			0.0);
+
+		public static readonly BindableProperty EndAngleProperty = BindableProperty.Create(
+			nameof(EndAngle),
+			typeof(double),
+			typeof(SKConfettiSystem),
+			360.0);
+
+		public static readonly BindableProperty MinimumInitialVelocityProperty = BindableProperty.Create(
+			nameof(MinimumInitialVelocity),
+			typeof(double),
+			typeof(SKConfettiSystem),
+			100.0);
+
+		public static readonly BindableProperty MaximumInitialVelocityProperty = BindableProperty.Create(
+			nameof(MaximumInitialVelocity),
+			typeof(double),
+			typeof(SKConfettiSystem),
+			200.0);
+
+		public static readonly BindableProperty MinimumRotationVelocityProperty = BindableProperty.Create(
+			nameof(MinimumRotationVelocity),
+			typeof(double),
+			typeof(SKConfettiSystem),
+			10.0);
+
+		public static readonly BindableProperty MaximumRotationVelocityProperty = BindableProperty.Create(
+			nameof(MaximumRotationVelocity),
+			typeof(double),
+			typeof(SKConfettiSystem),
+			75.0);
+
+		public static readonly BindableProperty MaximumVelocityProperty = BindableProperty.Create(
+			nameof(MaximumVelocity),
+			typeof(double),
+			typeof(SKConfettiSystem),
+			0.0);
+
+		public static readonly BindableProperty LifetimeProperty = BindableProperty.Create(
+			nameof(Lifetime),
+			typeof(double),
+			typeof(SKConfettiSystem),
+			2.0);
+
+		public static readonly BindableProperty FadeOutProperty = BindableProperty.Create(
+			nameof(FadeOut),
+			typeof(bool),
+			typeof(SKConfettiSystem),
+			true);
+
+		public static readonly BindableProperty GravityProperty = BindableProperty.Create(
+			nameof(Gravity),
+			typeof(Point),
+			typeof(SKConfettiSystem),
+			new Point(0, 9.81f));
+
+		private static readonly BindablePropertyKey IsCompletePropertyKey = BindableProperty.CreateReadOnly(
+			nameof(IsComplete),
+			typeof(bool),
+			typeof(SKConfettiSystem),
+			false);
+
+		public static readonly BindableProperty IsCompleteProperty = IsCompletePropertyKey.BindableProperty;
+
+		public static readonly BindableProperty IsRunningProperty = BindableProperty.Create(
+			nameof(IsRunning),
+			typeof(bool),
+			typeof(SKConfettiSystem),
+			true,
+			propertyChanged: OnIsRunningPropertyChanged);
+
+		private readonly Random random = new Random();
+		private readonly List<SKConfettiParticle> particles = new List<SKConfettiParticle>();
+
+		private SKRect lastViewBounds;
+		private Rect actualEmitterBounds;
+
+		public SKConfettiSystem()
+		{
+			DebugUtils.LogPropertyChanged(this);
+
+			OnEmitterChanged(this, null, Emitter);
+		}
+
+		public bool IsRunning
+		{
+			get => (bool)GetValue(IsRunningProperty);
+			set => SetValue(IsRunningProperty, value);
+		}
+
+		public SKConfettiEmitterBounds EmitterBounds
+		{
+			get => (SKConfettiEmitterBounds)GetValue(EmitterBoundsProperty);
+			set => SetValue(EmitterBoundsProperty, value);
+		}
+
+		public SKConfettiEmitter? Emitter
+		{
+			get => (SKConfettiEmitter?)GetValue(EmitterProperty);
+			set => SetValue(EmitterProperty, value);
+		}
+
+		public SKConfettiColorCollection? Colors
+		{
+			get => (SKConfettiColorCollection?)GetValue(ColorsProperty);
+			set => SetValue(ColorsProperty, value);
+		}
+
+		public SKConfettiPhysicsCollection? Physics
+		{
+			get => (SKConfettiPhysicsCollection?)GetValue(PhysicsProperty);
+			set => SetValue(PhysicsProperty, value);
+		}
+
+		public SKConfettiShapeCollection? Shapes
+		{
+			get => (SKConfettiShapeCollection?)GetValue(ShapesProperty);
+			set => SetValue(ShapesProperty, value);
+		}
+
+		public double StartAngle
+		{
+			get => (double)GetValue(StartAngleProperty);
+			set => SetValue(StartAngleProperty, value);
+		}
+
+		public double EndAngle
+		{
+			get => (double)GetValue(EndAngleProperty);
+			set => SetValue(EndAngleProperty, value);
+		}
+
+		public double MinimumInitialVelocity
+		{
+			get => (double)GetValue(MinimumInitialVelocityProperty);
+			set => SetValue(MinimumInitialVelocityProperty, value);
+		}
+
+		public double MaximumInitialVelocity
+		{
+			get => (double)GetValue(MaximumInitialVelocityProperty);
+			set => SetValue(MaximumInitialVelocityProperty, value);
+		}
+
+		public double MinimumRotationVelocity
+		{
+			get => (double)GetValue(MinimumRotationVelocityProperty);
+			set => SetValue(MinimumRotationVelocityProperty, value);
+		}
+
+		public double MaximumRotationVelocity
+		{
+			get => (double)GetValue(MaximumRotationVelocityProperty);
+			set => SetValue(MaximumRotationVelocityProperty, value);
+		}
+
+		public double MaximumVelocity
+		{
+			get => (double)GetValue(MaximumVelocityProperty);
+			set => SetValue(MaximumVelocityProperty, value);
+		}
+
+		public double Lifetime
+		{
+			get => (double)GetValue(LifetimeProperty);
+			set => SetValue(LifetimeProperty, value);
+		}
+
+		public bool FadeOut
+		{
+			get => (bool)GetValue(FadeOutProperty);
+			set => SetValue(FadeOutProperty, value);
+		}
+
+		public Point Gravity
+		{
+			get => (Point)GetValue(GravityProperty);
+			set => SetValue(GravityProperty, value);
+		}
+
+		public bool IsComplete
+		{
+			get => (bool)GetValue(IsCompleteProperty);
+			private set => SetValue(IsCompletePropertyKey, value);
+		}
+
+		internal int ParticleCount => particles.Count;
+
+		public void Draw(SKCanvas canvas, TimeSpan deltaTime)
+		{
+			if (IsRunning)
+				Emitter?.Update(deltaTime);
+
+			var g = Gravity.ToSKPoint();
+
+			var removed = false;
+			for (var i = particles.Count - 1; i >= 0; i--)
+			{
+				var particle = particles[i];
+
+				particle.ApplyForce(g, deltaTime);
+
+				if (!particle.IsComplete && lastViewBounds.IntersectsWith(particle.Bounds))
+				{
+					particle.Draw(canvas, deltaTime);
+				}
+				else
+				{
+					particles.RemoveAt(i);
+					removed = true;
+				}
+			}
+
+			if (removed)
+				UpdateIsComplete();
+		}
+
+		public void UpdateEmitterBounds(double width, double height)
+		{
+			lastViewBounds = new SKRect(0, 0, (float)width, (float)height);
+
+			actualEmitterBounds = EmitterBounds.Side switch
+			{
+				SKConfettiEmitterSide.Top => new Rect(0, -10, width, 0),
+				SKConfettiEmitterSide.Left => new Rect(-10, 0, 0, height),
+				SKConfettiEmitterSide.Right => new Rect(width + 10, 0, 0, height),
+				SKConfettiEmitterSide.Bottom => new Rect(0, height + 10, width, 0),
+				SKConfettiEmitterSide.Center => new Rect(width / 2, height / 2, 0, 0),
+				_ => EmitterBounds.Rect,
+			};
+		}
+
+		private void OnCreateParticle(int count)
+		{
+			if (Colors == null || Colors.Count == 0 ||
+				Physics == null || Physics.Count == 0 ||
+				Shapes == null || Shapes.Count == 0)
+				return;
+
+			for (var i = 0; i < count; i++)
+			{
+				var c = Colors[random.Next(Colors.Count)];
+				var p = Physics[random.Next(Physics.Count)];
+				var s = Shapes[random.Next(Shapes.Count)];
+
+				var particle = new SKConfettiParticle
+				{
+					Location = GetNewLocation().ToSKPoint(),
+					Velocity = GetNewVelocity().ToSKPoint(),
+					RotationVelocity = (float)GetNewRotationVelocity(),
+
+					Color = c.ToSKColor(),
+					Size = (float)p.Size,
+					Mass = (float)p.Mass,
+					Shape = s,
+					Rotation = (float)GetNewRotation(),
+
+					MaximumVelocity = new Point(MaximumVelocity, MaximumVelocity).ToSKPoint(),
+					FadeOut = FadeOut,
+					Lifetime = Lifetime,
+				};
+
+				particles.Add(particle);
+			}
+
+			UpdateIsComplete();
+
+			Point GetNewLocation()
+			{
+				var rect = actualEmitterBounds;
+				return new Point(
+					rect.Left + random.NextDouble() * rect.Width,
+					rect.Top + random.NextDouble() * rect.Height);
+			}
+
+			Point GetNewVelocity()
+			{
+				var velocity = MinimumInitialVelocity + random.NextDouble() * (MaximumInitialVelocity - MinimumInitialVelocity);
+				var deg = StartAngle + random.NextDouble() * (EndAngle - StartAngle);
+				var rad = Math.PI / 180.0 * deg;
+
+				var vx = velocity * Math.Cos(rad);
+				var vy = velocity * Math.Sin(rad);
+
+				return new Point(vx, vy);
+			}
+
+			double GetNewRotationVelocity()
+			{
+				if (MaximumRotationVelocity < MinimumRotationVelocity)
+					return 0;
+
+				return MinimumRotationVelocity + random.NextDouble() * (MaximumRotationVelocity - MinimumRotationVelocity);
+			}
+
+			double GetNewRotation() =>
+				random.NextDouble() * 360.0;
+		}
+
+		private static void OnEmitterChanged(BindableObject bindable, object? oldValue, object? newValue)
+		{
+			if (bindable is SKConfettiSystem system)
+			{
+				if (oldValue is SKConfettiEmitter oldE)
+					oldE.ParticlesCreated -= system.OnCreateParticle;
+
+				if (newValue is SKConfettiEmitter newE)
+					newE.ParticlesCreated += system.OnCreateParticle;
+
+				system.UpdateIsComplete();
+			}
+		}
+
+		private static void OnIsRunningPropertyChanged(BindableObject bindable, object oldValue, object newValue)
+		{
+			if (bindable is SKConfettiSystem system)
+			{
+				system.UpdateIsComplete();
+			}
+		}
+
+		private bool UpdateIsComplete() =>
+			IsComplete =
+				particles.Count == 0 &&
+				Emitter?.IsComplete != false &&
+				IsRunning;
+
+		private static SKConfettiColorCollection CreateDefaultColors() =>
+			new SKConfettiColorCollection
+			{
+				Color.FromUint(0xfffce18a),
+				Color.FromUint(0xffff726d),
+				Color.FromUint(0xffb48def),
+				Color.FromUint(0xfff4306d),
+				Color.FromUint(0xff3aaab8),
+				Color.FromUint(0xff38ba9e),
+				Color.FromUint(0xffbb3d72),
+				Color.FromUint(0xff006ded),
+			};
+
+		private static SKConfettiPhysicsCollection CreateDefaultPhysics() =>
+			new SKConfettiPhysicsCollection
+			{
+				new SKConfettiPhysics(12, 2),
+				new SKConfettiPhysics(16, 3),
+			};
+
+		private static SKConfettiShapeCollection CreateDefaultShapes() =>
+			new SKConfettiShapeCollection
+			{
+				new SKConfettiSquareShape(),
+				new SKConfettiCircleShape(),
+				new SKConfettiRectShape(0.5),
+				new SKConfettiOvalShape(0.5),
+				new SKConfettiRectShape(0.1),
+			};
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiSystemCollection.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiSystemCollection.shared.cs
new file mode 100644
index 00000000..04eb0b0c
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiSystemCollection.shared.cs
@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace SkiaSharp.Extended.UI.Controls
+{
+	public class SKConfettiSystemCollection : ObservableCollection<SKConfettiSystem>
+	{
+		public SKConfettiSystemCollection()
+		{
+		}
+
+		public SKConfettiSystemCollection(IEnumerable<SKConfettiSystem> collection)
+			: base(collection)
+		{
+		}
+
+		public SKConfettiSystemCollection(List<SKConfettiSystem> list)
+			: base(list)
+		{
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiView.shared.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiView.shared.cs
new file mode 100644
index 00000000..fcbef4ca
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiView.shared.cs
@@ -0,0 +1,237 @@
+using System;
+using System.Collections.Specialized;
+using SkiaSharp.Views.Forms;
+using Xamarin.Forms;
+
+namespace SkiaSharp.Extended.UI.Controls
+{
+	public class SKConfettiView : TemplatedView
+	{
+		public static readonly BindableProperty IsRunningProperty = BindableProperty.Create(
+			nameof(IsRunning),
+			typeof(bool),
+			typeof(SKConfettiView),
+			true,
+			propertyChanged: OnIsRunningPropertyChanged);
+
+		private static readonly BindablePropertyKey IsCompletePropertyKey = BindableProperty.CreateReadOnly(
+			nameof(IsComplete),
+			typeof(bool),
+			typeof(SKConfettiView),
+			false);
+
+		public static readonly BindableProperty IsCompleteProperty = IsCompletePropertyKey.BindableProperty;
+
+		public static readonly BindableProperty SystemsProperty = BindableProperty.Create(
+			nameof(Systems),
+			typeof(SKConfettiSystemCollection),
+			typeof(SKConfettiView),
+			null,
+			propertyChanged: OnSystemsPropertyChanged,
+			defaultValueCreator: _ => CreateDefaultSystems());
+
+		private readonly SKFrameCounter frameCounter = new SKFrameCounter();
+
+#if DEBUG
+		private readonly SKPaint fpsPaint = new SKPaint { IsAntialias = true };
+#endif
+
+		private SKCanvasView? canvasView;
+		private SKGLView? glView;
+
+		public SKConfettiView()
+		{
+			DebugUtils.LogPropertyChanged(this);
+
+			Themes.SKConfettiViewResources.EnsureRegistered();
+
+			SizeChanged += OnSizeChanged;
+
+			OnIsRunningPropertyChanged(this, false, IsRunning);
+			OnSystemsPropertyChanged(this, null, Systems);
+		}
+
+		public bool IsRunning
+		{
+			get => (bool)GetValue(IsRunningProperty);
+			set => SetValue(IsRunningProperty, value);
+		}
+
+		public bool IsComplete
+		{
+			get => (bool)GetValue(IsCompleteProperty);
+			private set => SetValue(IsCompletePropertyKey, value);
+		}
+
+		public SKConfettiSystemCollection? Systems
+		{
+			get => (SKConfettiSystemCollection?)GetValue(SystemsProperty);
+			set => SetValue(SystemsProperty, value);
+		}
+
+		protected override void OnApplyTemplate()
+		{
+			var templateChild = GetTemplateChild("PART_DrawingSurface");
+
+			if (canvasView != null)
+			{
+				canvasView.PaintSurface -= OnPaintSurface;
+				canvasView = null;
+			}
+
+			if (glView != null)
+			{
+				glView.PaintSurface -= OnPaintSurface;
+				glView = null;
+			}
+
+			if (templateChild is SKCanvasView view)
+			{
+				canvasView = view;
+				canvasView.PaintSurface += OnPaintSurface;
+			}
+
+			if (templateChild is SKGLView gl)
+			{
+				glView = gl;
+				glView.PaintSurface += OnPaintSurface;
+			}
+		}
+
+		private void OnPaintSurface(object sender, SKPaintSurfaceEventArgs e) =>
+			OnPaintSurface(e.Surface, e.Info.Size);
+
+		private void OnPaintSurface(object sender, SKPaintGLSurfaceEventArgs e) =>
+			OnPaintSurface(e.Surface, e.BackendRenderTarget.Size);
+
+		private void OnPaintSurface(SKSurface surface, SKSize size)
+		{
+			var deltaTime = frameCounter.NextFrame();
+
+			var canvas = surface.Canvas;
+
+			canvas.Clear(SKColors.Transparent);
+			canvas.Scale(size.Width / (float)Width);
+
+			var particles = 0;
+			if (Systems != null)
+			{
+				for (var i = Systems.Count - 1; i >= 0; i--)
+				{
+					var system = Systems[i];
+					system.Draw(canvas, deltaTime);
+
+					if (system.IsComplete)
+						Systems.RemoveAt(i);
+
+					particles += system.ParticleCount;
+				}
+			}
+
+#if DEBUG
+			canvas.DrawText($"{frameCounter.Rate:0.0}", 10f, fpsPaint.TextSize + 10f, fpsPaint);
+			canvas.DrawText($"{particles}", 10f, fpsPaint.TextSize * 2 + 20f, fpsPaint);
+#endif
+
+			if (Systems != null && Systems.Count == 0)
+				frameCounter.Reset();
+		}
+
+		private void OnSizeChanged(object sender, EventArgs e)
+		{
+			if (Systems != null)
+			{
+				foreach (var system in Systems)
+				{
+					system.UpdateEmitterBounds(Width, Height);
+				}
+			}
+		}
+
+		private void Invalidate()
+		{
+			canvasView?.InvalidateSurface();
+			glView?.InvalidateSurface();
+		}
+
+		private void OnSystemsChanged(object sender, NotifyCollectionChangedEventArgs e)
+		{
+			if (e.NewItems != null)
+			{
+				foreach (SKConfettiSystem system in e.NewItems)
+				{
+					system.UpdateEmitterBounds(Width, Height);
+					system.IsRunning = IsRunning;
+				}
+
+				Invalidate();
+			}
+
+			UpdateIsComplete();
+		}
+
+		private static void OnIsRunningPropertyChanged(BindableObject bindable, object? oldValue, object? newValue)
+		{
+			if (bindable is SKConfettiView cv && newValue is bool isRunning)
+			{
+				if (cv.Systems != null)
+				{
+					foreach (var system in cv.Systems)
+					{
+						system.IsRunning = isRunning;
+					}
+				}
+
+				cv.frameCounter.Reset();
+
+				Device.StartTimer(TimeSpan.FromMilliseconds(16), () =>
+				{
+					cv.Invalidate();
+
+					return cv.IsRunning;
+				});
+			}
+		}
+
+		private static void OnSystemsPropertyChanged(BindableObject bindable, object? oldValue, object? newValue)
+		{
+			if (bindable is SKConfettiView cv)
+			{
+				if (oldValue is SKConfettiSystemCollection oldCollection)
+					oldCollection.CollectionChanged -= cv.OnSystemsChanged;
+
+				if (newValue is SKConfettiSystemCollection newCollection)
+					newCollection.CollectionChanged += cv.OnSystemsChanged;
+
+				cv.UpdateIsComplete();
+			}
+		}
+
+		private void UpdateIsComplete()
+		{
+			if (Systems == null || Systems.Count == 0)
+			{
+				IsComplete = true;
+				return;
+			}
+
+			var isComplete = false;
+			foreach (var system in Systems)
+			{
+				if (system.IsComplete)
+				{
+					isComplete = true;
+					break;
+				}
+			}
+
+			IsComplete = isComplete;
+		}
+
+		private static SKConfettiSystemCollection CreateDefaultSystems() =>
+			new SKConfettiSystemCollection
+			{
+				new SKConfettiSystem()
+			};
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiViewResources.shared.xaml b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiViewResources.shared.xaml
new file mode 100644
index 00000000..fab96d46
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiViewResources.shared.xaml
@@ -0,0 +1,22 @@
+<ResourceDictionary xmlns="http://xamarin.com/schemas/2014/forms"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+                    xmlns:local="clr-namespace:SkiaSharp.Extended.UI.Controls"
+                    xmlns:skia="clr-namespace:SkiaSharp.Views.Forms;assembly=SkiaSharp.Views.Forms"
+                    x:Class="SkiaSharp.Extended.UI.Controls.Themes.SKConfettiViewResources">
+
+    <!-- the control template for SKConfettiView -->
+    <ControlTemplate x:Key="SKConfettiViewControlTemplate">
+        <skia:SKCanvasView x:Name="PART_DrawingSurface" />
+    </ControlTemplate>
+
+    <!-- the explicit style that allows for extension -->
+    <Style x:Key="SKConfettiViewStyle" TargetType="local:SKConfettiView">
+        <Setter Property="ControlTemplate"
+                Value="{StaticResource SKConfettiViewControlTemplate}" />
+    </Style>
+
+    <!-- the implicit style that applies to all controls -->
+    <Style TargetType="local:SKConfettiView"
+           BasedOn="{StaticResource SKConfettiViewStyle}" />
+
+</ResourceDictionary>
\ No newline at end of file
diff --git a/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiViewResources.shared.xaml.cs b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiViewResources.shared.xaml.cs
new file mode 100644
index 00000000..56b8ad72
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Controls/Confetti/SKConfettiViewResources.shared.xaml.cs
@@ -0,0 +1,39 @@
+using Xamarin.Forms;
+
+namespace SkiaSharp.Extended.UI.Controls.Themes
+{
+	public partial class SKConfettiViewResources : ResourceDictionary
+	{
+		private static bool registered;
+
+		public SKConfettiViewResources()
+		{
+			InitializeComponent();
+		}
+
+		internal static void EnsureRegistered()
+		{
+			if (registered)
+				return;
+
+			var merged = Application.Current?.Resources?.MergedDictionaries;
+			if (merged != null)
+			{
+				foreach (var dic in merged)
+				{
+					if (dic.GetType() == typeof(SKConfettiViewResources))
+					{
+						registered = true;
+						break;
+					}
+				}
+
+				if (!registered)
+				{
+					merged.Add(new SKConfettiViewResources());
+					registered = true;
+				}
+			}
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Utils/DebugUtils.shared.cs b/source/SkiaSharp.Extended.UI/Utils/DebugUtils.shared.cs
new file mode 100644
index 00000000..f35e8767
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Utils/DebugUtils.shared.cs
@@ -0,0 +1,22 @@
+using System.ComponentModel;
+using System.Diagnostics;
+using Xamarin.Forms;
+
+namespace SkiaSharp.Extended.UI
+{
+	internal static class DebugUtils
+	{
+		[Conditional("DEBUG")]
+		public static void LogPropertyChanged(BindableObject bindable)
+		{
+			bindable.PropertyChanged += OnPropertyChanged;
+
+			static void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
+			{
+				var value = sender.GetType().GetProperty(e.PropertyName)?.GetValue(sender);
+
+				Debug.WriteLine($"PropertyChanged: {sender.GetType().Name}.{e.PropertyName} = {value}");
+			}
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Utils/SKFrameCounter.shared.cs b/source/SkiaSharp.Extended.UI/Utils/SKFrameCounter.shared.cs
new file mode 100644
index 00000000..694710cc
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Utils/SKFrameCounter.shared.cs
@@ -0,0 +1,79 @@
+using System;
+
+namespace SkiaSharp.Extended.UI
+{
+	internal class SKFrameCounter
+	{
+#if DEBUG
+		private const int DefaultSampleCount = 100;
+#else
+		private const int DefaultSampleCount = 0;
+#endif
+
+		private readonly int sampleCount;
+		private readonly int[] samples;
+		private int index;
+		private int sum;
+
+		private bool firstRender = true;
+		private int lastTick;
+
+		public SKFrameCounter(int sampleCount = DefaultSampleCount)
+		{
+			this.sampleCount = Math.Max(0, sampleCount);
+			samples = new int[sampleCount];
+
+			Reset();
+		}
+
+		public TimeSpan Duration { get; private set; }
+
+		public float Rate { get; private set; }
+
+		public void Reset()
+		{
+			firstRender = true;
+
+			Duration = TimeSpan.Zero;
+			Rate = 0;
+		}
+
+		public TimeSpan NextFrame()
+		{
+			if (firstRender)
+			{
+				lastTick = Environment.TickCount;
+				firstRender = false;
+			}
+
+			var ticks = Environment.TickCount;
+			var delta = ticks - lastTick;
+			lastTick = ticks;
+
+			Duration = TimeSpan.FromMilliseconds(delta);
+			if (sampleCount <= 0)
+			{
+				Rate = 0;
+			}
+			else
+			{
+				var avg = CalculateAverage(delta);
+				Rate = avg <= 0 ? 0 : 1000f / avg;
+			}
+
+			return Duration;
+		}
+
+		private float CalculateAverage(int delta)
+		{
+			sum -= samples[index];
+			sum += delta;
+			samples[index] = delta;
+
+			if (++index == sampleCount)
+				index = 0;
+
+			return (float)sum / sampleCount;
+		}
+	}
+}
diff --git a/source/SkiaSharp.Extended.UI/Utils/SKObjectPool.shared.cs b/source/SkiaSharp.Extended.UI/Utils/SKObjectPool.shared.cs
new file mode 100644
index 00000000..c587875e
--- /dev/null
+++ b/source/SkiaSharp.Extended.UI/Utils/SKObjectPool.shared.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Concurrent;
+
+namespace SkiaSharp.Extended.UI
+{
+	internal class SKObjectPool<T>
+	{
+		private readonly ConcurrentBag<T> objects;
+		private readonly Func<T> generator;
+
+		public SKObjectPool(Func<T> objectGenerator)
+		{
+			generator = objectGenerator ?? throw new ArgumentNullException(nameof(objectGenerator));
+			objects = new ConcurrentBag<T>();
+		}
+
+		public T Get() =>
+			objects.TryTake(out var item) ? item : generator();
+
+		public void Return(T item) =>
+			objects.Add(item);
+	}
+}
diff --git a/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiColorCollectionTypeConverterTest.cs b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiColorCollectionTypeConverterTest.cs
new file mode 100644
index 00000000..e7ddc9bd
--- /dev/null
+++ b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiColorCollectionTypeConverterTest.cs
@@ -0,0 +1,46 @@
+using SkiaSharp.Extended.UI.Controls.Converters;
+using Xamarin.Forms;
+using Xunit;
+
+namespace SkiaSharp.Extended.UI.Controls.Tests
+{
+	public class SKConfettiColorCollectionTypeConverterTest
+	{
+		[Theory]
+		[InlineData("red")]
+		[InlineData(" red ")]
+		[InlineData("#ff0000")]
+		[InlineData("#ffff0000")]
+		[InlineData(" #ffff0000 ")]
+		public void CanParseSingleColor(string value)
+		{
+			var converter = new SKConfettiColorCollectionTypeConverter();
+
+			var result = converter.ConvertFromInvariantString(value);
+
+			var collection = Assert.IsType<SKConfettiColorCollection>(result);
+
+			Assert.NotNull(collection);
+			var color = Assert.Single(collection);
+			Assert.Equal(Color.Red, color);
+		}
+
+		[Theory]
+		[InlineData("red,red,blue")]
+		[InlineData(" red, red, blue ")]
+		[InlineData("#ff0000,#ff0000,#0000ff")]
+		[InlineData("#ffff0000,#ffff0000,#ff0000ff")]
+		[InlineData(" #ffff0000, #ffff0000, #ff0000ff ")]
+		public void CanParseMultipleColors(string value)
+		{
+			var converter = new SKConfettiColorCollectionTypeConverter();
+
+			var result = converter.ConvertFromInvariantString(value);
+
+			var collection = Assert.IsType<SKConfettiColorCollection>(result);
+
+			Assert.NotNull(collection);
+			Assert.Equal(new[] { Color.Red, Color.Red, Color.Blue }, collection);
+		}
+	}
+}
diff --git a/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiEmitterBoundsTypeConverterTest.cs b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiEmitterBoundsTypeConverterTest.cs
new file mode 100644
index 00000000..57f331e1
--- /dev/null
+++ b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiEmitterBoundsTypeConverterTest.cs
@@ -0,0 +1,82 @@
+using System;
+using SkiaSharp.Extended.UI.Controls.Converters;
+using Xamarin.Forms;
+using Xunit;
+
+namespace SkiaSharp.Extended.UI.Controls.Tests
+{
+	public class SKConfettiEmitterBoundsTypeConverterTest
+	{
+		[Theory]
+		[InlineData("center", SKConfettiEmitterSide.Center)]
+		[InlineData(" center ", SKConfettiEmitterSide.Center)]
+		[InlineData("top", SKConfettiEmitterSide.Top)]
+		[InlineData("left", SKConfettiEmitterSide.Left)]
+		[InlineData("right", SKConfettiEmitterSide.Right)]
+		[InlineData("bottom", SKConfettiEmitterSide.Bottom)]
+		public void CanParseSideValues(string value, SKConfettiEmitterSide side)
+		{
+			var converter = new SKConfettiEmitterBoundsTypeConverter();
+
+			var result = converter.ConvertFromInvariantString(value);
+
+			var bounds = Assert.IsType<SKConfettiEmitterBounds>(result);
+
+			Assert.Equal(side, bounds.Side);
+			Assert.Equal(Rect.Zero, bounds.Rect);
+		}
+
+		[Theory]
+		[InlineData("12,34")]
+		[InlineData("12, 34")]
+		[InlineData(" 12, 34 ")]
+		public void CanParsePointValues(string value)
+		{
+			var converter = new SKConfettiEmitterBoundsTypeConverter();
+
+			var result = converter.ConvertFromInvariantString(value);
+
+			var bounds = Assert.IsType<SKConfettiEmitterBounds>(result);
+
+			Assert.Equal(SKConfettiEmitterSide.Bounds, bounds.Side);
+			Assert.Equal(new Rect(12, 34, 0, 0), bounds.Rect);
+		}
+
+		[Theory]
+		[InlineData("12,34,56,78")]
+		[InlineData("12, 34, 56, 78")]
+		[InlineData(" 12, 34, 56, 78 ")]
+		public void CanParseRectValues(string value)
+		{
+			var converter = new SKConfettiEmitterBoundsTypeConverter();
+
+			var result = converter.ConvertFromInvariantString(value);
+
+			var bounds = Assert.IsType<SKConfettiEmitterBounds>(result);
+
+			Assert.Equal(SKConfettiEmitterSide.Bounds, bounds.Side);
+			Assert.Equal(new Rect(12, 34, 56, 78), bounds.Rect);
+		}
+
+		[Theory]
+		[InlineData("")]
+		[InlineData(" ")]
+		[InlineData("1,2,3")]
+		public void ThrowsOnBadValues(string value)
+		{
+			var converter = new SKConfettiEmitterBoundsTypeConverter();
+
+			Assert.Throws<InvalidOperationException>(() => converter.ConvertFromInvariantString(value));
+		}
+
+		[Fact]
+		public void NullIsNull()
+		{
+			var converter = new SKConfettiEmitterBoundsTypeConverter();
+
+			var result = converter.ConvertFromInvariantString(null);
+
+			Assert.Null(result);
+		}
+	}
+}
diff --git a/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiEmitterTest.cs b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiEmitterTest.cs
new file mode 100644
index 00000000..5db27f16
--- /dev/null
+++ b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiEmitterTest.cs
@@ -0,0 +1,140 @@
+using System;
+using Xunit;
+
+namespace SkiaSharp.Extended.UI.Controls.Tests
+{
+	public class SKConfettiEmitterTest
+	{
+		[Theory]
+		[InlineData(0)]
+		[InlineData(10)]
+		[InlineData(1000)]
+		[InlineData(10000)]
+		public void ParticleRateNoMaxBurstRunsOnce(int milliseconds)
+		{
+			var dt = TimeSpan.FromMilliseconds(milliseconds);
+
+			var totalCreated = 0;
+			var totalInvoke = 0;
+
+			var emitter = new SKConfettiEmitter(100, -1, 0);
+			emitter.ParticlesCreated += count =>
+			{
+				totalCreated += count;
+				totalInvoke++;
+			};
+
+			emitter.Update(dt);
+
+			Assert.Equal(100, totalCreated);
+			Assert.Equal(1, totalInvoke);
+			Assert.True(emitter.IsComplete);
+
+			emitter.Update(dt);
+
+			Assert.Equal(100, totalCreated);
+			Assert.Equal(1, totalInvoke);
+			Assert.True(emitter.IsComplete);
+		}
+
+		[Theory]
+		[InlineData(0)]
+		[InlineData(10)]
+		[InlineData(1000)]
+		[InlineData(10000)]
+		public void ParticleRateWithMaxBurstRunsOnce(int milliseconds)
+		{
+			var dt = TimeSpan.FromMilliseconds(milliseconds);
+
+			var totalCreated = 0;
+			var totalInvoke = 0;
+
+			var emitter = new SKConfettiEmitter(100, 50, 0);
+			emitter.ParticlesCreated += count =>
+			{
+				totalCreated += count;
+				totalInvoke++;
+			};
+
+			emitter.Update(dt);
+
+			Assert.Equal(50, totalCreated);
+			Assert.Equal(1, totalInvoke);
+			Assert.True(emitter.IsComplete);
+
+			emitter.Update(dt);
+
+			Assert.Equal(50, totalCreated);
+			Assert.Equal(1, totalInvoke);
+			Assert.True(emitter.IsComplete);
+		}
+
+		[Theory]
+		[InlineData(0)]
+		[InlineData(10)]
+		[InlineData(1000)]
+		[InlineData(10000)]
+		public void ParticleRateLargerMaxBurstRunsOnce(int milliseconds)
+		{
+			var dt = TimeSpan.FromMilliseconds(milliseconds);
+
+			var totalCreated = 0;
+			var totalInvoke = 0;
+
+			var emitter = new SKConfettiEmitter(100, 200, 0);
+			emitter.ParticlesCreated += count =>
+			{
+				totalCreated += count;
+				totalInvoke++;
+			};
+
+			emitter.Update(dt);
+
+			Assert.Equal(100, totalCreated);
+			Assert.Equal(1, totalInvoke);
+			Assert.True(emitter.IsComplete);
+
+			emitter.Update(dt);
+
+			Assert.Equal(100, totalCreated);
+			Assert.Equal(1, totalInvoke);
+			Assert.True(emitter.IsComplete);
+		}
+
+		[Theory]
+		[InlineData(0, 0, 0, false, false)]
+		[InlineData(10, 1, 2, false, false)]
+		[InlineData(500, 50, 100, false, true)]
+		[InlineData(1000, 100, 100, true, true)]
+		[InlineData(10000, 100, 100, true, true)]
+		public void ParticleRateNoMaxOneMin(int milliseconds, int expectedCreated, int expectedCreated2, bool complete, bool complete2)
+		{
+			var dt = TimeSpan.FromMilliseconds(milliseconds);
+
+			var totalCreated = 0;
+			var totalInvoke = 0;
+
+			var emitter = new SKConfettiEmitter(100, -1, 1.0);
+			emitter.ParticlesCreated += count =>
+			{
+				totalCreated += count;
+				totalInvoke++;
+			};
+
+			emitter.Update(dt);
+
+			Assert.Equal(expectedCreated, totalCreated);
+			Assert.Equal(1, totalInvoke);
+			Assert.Equal(complete, emitter.IsComplete);
+
+			emitter.Update(dt);
+
+			Assert.Equal(expectedCreated2, totalCreated);
+			if (complete)
+				Assert.Equal(1, totalInvoke);
+			else
+				Assert.Equal(2, totalInvoke);
+			Assert.Equal(complete2, emitter.IsComplete);
+		}
+	}
+}
diff --git a/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiPhysicsTest.cs b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiPhysicsTest.cs
new file mode 100644
index 00000000..61ebabe7
--- /dev/null
+++ b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiPhysicsTest.cs
@@ -0,0 +1,16 @@
+using Xunit;
+
+namespace SkiaSharp.Extended.UI.Controls.Tests
+{
+	public class SKConfettiPhysicsTest
+	{
+		[Fact]
+		public void CanCreateInstance()
+		{
+			var physics = new SKConfettiPhysics(2, 4);
+
+			Assert.Equal(2, physics.Size);
+			Assert.Equal(4, physics.Mass);
+		}
+	}
+}
diff --git a/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiPhysicsTypeConverterTest.cs b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiPhysicsTypeConverterTest.cs
new file mode 100644
index 00000000..aa9ef316
--- /dev/null
+++ b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiPhysicsTypeConverterTest.cs
@@ -0,0 +1,46 @@
+using System;
+using SkiaSharp.Extended.UI.Controls.Converters;
+using Xunit;
+
+namespace SkiaSharp.Extended.UI.Controls.Tests
+{
+	public class SKConfettiPhysicsTypeConverterTest
+	{
+		[Theory]
+		[InlineData("12,34")]
+		[InlineData("12, 34")]
+		[InlineData(" 12, 34 ")]
+		public void CanParsePointValues(string value)
+		{
+			var converter = new SKConfettiPhysicsTypeConverter();
+
+			var result = converter.ConvertFromInvariantString(value);
+
+			var physics = Assert.IsType<SKConfettiPhysics>(result);
+
+			Assert.Equal(12, physics.Size);
+			Assert.Equal(34, physics.Mass);
+		}
+
+		[Theory]
+		[InlineData("")]
+		[InlineData(" ")]
+		[InlineData("1,2,3")]
+		public void ThrowsOnBadValues(string value)
+		{
+			var converter = new SKConfettiPhysicsTypeConverter();
+
+			Assert.Throws<InvalidOperationException>(() => converter.ConvertFromInvariantString(value));
+		}
+
+		[Fact]
+		public void NullIsNull()
+		{
+			var converter = new SKConfettiPhysicsTypeConverter();
+
+			var result = converter.ConvertFromInvariantString(null);
+
+			Assert.Null(result);
+		}
+	}
+}
diff --git a/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiShapeTest.cs b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiShapeTest.cs
new file mode 100644
index 00000000..15769a6d
--- /dev/null
+++ b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiShapeTest.cs
@@ -0,0 +1,121 @@
+using System;
+using System.IO;
+using Xunit;
+
+namespace SkiaSharp.Extended.UI.Controls.Tests
+{
+	public class SKConfettiShapeTest
+	{
+		private static readonly bool SaveTestBitmaps = false;
+
+		[Fact]
+		public void EmptyDrawIsEqual()
+		{
+			EqualDrawing(new SKSizeI(24, 24),
+				canvas => { },
+				canvas => { });
+		}
+
+		[Fact]
+		public void DrawsSquareCorrectly()
+		{
+			using var paint = new SKPaint();
+
+			var shape = new SKConfettiSquareShape();
+
+			EqualDrawing(new SKSizeI(24, 24),
+				canvas =>
+				{
+					canvas.DrawRect(2, 2, 20, 20, paint);
+				},
+				canvas =>
+				{
+					canvas.Translate(12, 12);
+					shape.Draw(canvas, paint, 20);
+				});
+		}
+
+		[Fact]
+		public void DrawsCircleCorrectly()
+		{
+			using var paint = new SKPaint();
+
+			var shape = new SKConfettiCircleShape();
+
+			EqualDrawing(new SKSizeI(24, 24),
+				canvas =>
+				{
+					canvas.DrawOval(12, 12, 10, 10, paint);
+				},
+				canvas =>
+				{
+					canvas.Translate(12, 12);
+					shape.Draw(canvas, paint, 20);
+				});
+		}
+
+		[Fact]
+		public void DrawsOvalCorrectly()
+		{
+			using var paint = new SKPaint();
+
+			var shape = new SKConfettiOvalShape(0.5);
+
+			EqualDrawing(new SKSizeI(24, 24),
+				canvas =>
+				{
+					canvas.DrawOval(12, 12, 10, 5, paint);
+				},
+				canvas =>
+				{
+					canvas.Translate(12, 12);
+					shape.Draw(canvas, paint, 20);
+				});
+		}
+
+		[Fact]
+		public void DrawsRectCorrectly()
+		{
+			using var paint = new SKPaint();
+
+			var shape = new SKConfettiRectShape(0.5);
+
+			EqualDrawing(new SKSizeI(24, 24),
+				canvas =>
+				{
+					canvas.DrawRect(2, 7, 20, 10, paint);
+				},
+				canvas =>
+				{
+					canvas.Translate(12, 12);
+					shape.Draw(canvas, paint, 20);
+				});
+		}
+
+		private void EqualDrawing(SKSizeI size, Action<SKCanvas> expected, Action<SKCanvas> actual)
+		{
+			using var expectedBitmap = new SKBitmap(size.Width, size.Height);
+			using var expectedCanvas = new SKCanvas(expectedBitmap);
+			expectedCanvas.Clear(SKColors.Transparent);
+			expected(expectedCanvas);
+			SaveBitmap(expectedBitmap, "expected.png");
+
+			using var actualBitmap = new SKBitmap(size.Width, size.Height);
+			using var actualCanvas = new SKCanvas(actualBitmap);
+			actualCanvas.Clear(SKColors.Transparent);
+			actual(actualCanvas);
+			SaveBitmap(actualBitmap, "actual.png");
+
+			Assert.Equal(expectedBitmap.Pixels, actualBitmap.Pixels);
+		}
+
+		private void SaveBitmap(SKBitmap bitmap, string filename)
+		{
+			if (!SaveTestBitmaps)
+				return;
+
+			using var stream = File.Create(filename);
+			bitmap.Encode(stream, SKEncodedImageFormat.Png, 100);
+		}
+	}
+}
diff --git a/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiSystemTest.cs b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiSystemTest.cs
new file mode 100644
index 00000000..944b7f30
--- /dev/null
+++ b/tests/SkiaSharp.Extended.UI.Tests/Controls/Confetti/SKConfettiSystemTest.cs
@@ -0,0 +1,27 @@
+using System;
+using Xunit;
+
+namespace SkiaSharp.Extended.UI.Controls.Tests
+{
+	public class SKConfettiSystemTest
+	{
+		[Fact]
+		public void DefaultIsNotComplete()
+		{
+			var system = new SKConfettiSystem();
+
+			Assert.True(system.IsRunning);
+			Assert.False(system.IsComplete);
+		}
+
+		[Fact]
+		public void NotRunningIsNotComplete()
+		{
+			var system = new SKConfettiSystem();
+			system.IsRunning = false;
+
+			Assert.False(system.IsRunning);
+			Assert.False(system.IsComplete);
+		}
+	}
+}