diff --git a/samples/XCT.Sample.WPF/DrawingViewRenderer.wpf.cs b/samples/XCT.Sample.WPF/DrawingViewRenderer.wpf.cs
index c0c249a16..e6f927c49 100644
--- a/samples/XCT.Sample.WPF/DrawingViewRenderer.wpf.cs
+++ b/samples/XCT.Sample.WPF/DrawingViewRenderer.wpf.cs
@@ -1,4 +1,5 @@
-using System.Collections.Specialized;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Linq;
 using System.Windows.Controls;
@@ -10,6 +11,7 @@
 using Xamarin.Forms.Platform.WPF;
 
 [assembly: ExportRenderer(typeof(DrawingView), typeof(DrawingViewRenderer))]
+
 namespace Xamarin.CommunityToolkit.Sample.WPF
 {
 	public class DrawingViewRenderer : ViewRenderer<DrawingView, InkCanvas>
@@ -19,11 +21,11 @@ public class DrawingViewRenderer : ViewRenderer<DrawingView, InkCanvas>
 		protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
 		{
 			base.OnElementPropertyChanged(sender, e);
-			if (e.PropertyName == DrawingView.PointsProperty.PropertyName)
+			if (e.PropertyName == DrawingView.LinesProperty.PropertyName)
 			{
 				canvas!.Strokes.StrokesChanged -= OnStrokesChanged;
 				canvas.Strokes.Clear();
-				LoadPoints();
+				LoadLines();
 				canvas.Strokes.StrokesChanged += OnStrokesChanged;
 			}
 		}
@@ -35,15 +37,15 @@ protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
 			{
 				canvas = new InkCanvas
 				{
-					DefaultDrawingAttributes =
+					Background = Element.BackgroundColor.ToBrush(),
+					DefaultDrawingAttributes = new()
 					{
-						Color = Element.LineColor.ToMediaColor(),
-						Width = Element.LineWidth,
-						Height = Element.LineWidth
-					},
-					Background = Element.BackgroundColor.ToBrush()
+						Color = Element.DefaultLineColor.ToMediaColor(),
+						Width = Element.DefaultLineWidth,
+						Height = Element.DefaultLineWidth
+					}
 				};
-				Element.Points.CollectionChanged += OnCollectionChanged;
+				Element.Lines.CollectionChanged += OnCollectionChanged;
 				SetNativeControl(canvas);
 
 				canvas.Strokes.StrokesChanged += OnStrokesChanged;
@@ -53,55 +55,96 @@ protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
 			if (e.OldElement != null)
 			{
 				canvas!.Strokes.StrokesChanged -= OnStrokesChanged;
-				Element!.Points.CollectionChanged -= OnCollectionChanged;
+				Element!.Lines.CollectionChanged -= OnCollectionChanged;
 				if (Control != null)
 					Control.PreviewMouseDown -= OnPreviewMouseDown;
 			}
 		}
 
-		void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs args) => LoadPoints();
+		void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs args)
+		{
+			canvas!.Strokes.StrokesChanged -= OnStrokesChanged;
+			canvas.Strokes.Clear();
+			LoadLines();
+			canvas.Strokes.StrokesChanged += OnStrokesChanged;
+		}
+
+		void OnPreviewMouseDown(object sender, MouseButtonEventArgs e) => Clear();
 
-		void OnPreviewMouseDown(object sender, MouseButtonEventArgs e)
+		void Clear(bool force = false)
 		{
-			canvas!.Strokes.Clear();
-			Element.Points.Clear();
+			if (!Element.MultiLineMode || force)
+			{
+				canvas!.Strokes.Clear();
+				Element.Lines.Clear();
+			}
 		}
 
 		void OnStrokesChanged(object sender, StrokeCollectionChangedEventArgs e)
 		{
-			Element.Points.CollectionChanged -= OnCollectionChanged;
+			Element.Lines.CollectionChanged -= OnCollectionChanged;
 			if (e.Added.Count > 0)
 			{
-				var points = e.Added.First().StylusPoints.Select(point => new Point(point.X, point.Y));
-				Element.Points.Clear();
-				foreach (var point in points)
-					Element.Points.Add(point);
+				if (!Element.MultiLineMode)
+				{
+					Element.Lines.Clear();
+				}
 
-				if (Element.Points.Count > 0)
+				var lines = Element.MultiLineMode ? e.Added : new StrokeCollection() {e.Added.First()};
+
+				foreach (var line in lines)
+				{
+					var points = line.StylusPoints.Select(point => new Point(point.X, point.Y)).ToList();
+					Element.Lines.Add(new Line()
+					{
+						Points = new ObservableCollection<Point>(points),
+						LineColor = Color.FromRgba(line.DrawingAttributes.Color.R, line.DrawingAttributes.Color.G,
+							line.DrawingAttributes.Color.B, line.DrawingAttributes.Color.A),
+						LineWidth = (float) line.DrawingAttributes.Width
+					});
+				}
+
+				if (Element.Lines.Count > 0)
 				{
-					if (Element.DrawingCompletedCommand?.CanExecute(null) ?? false)
-						Element.DrawingCompletedCommand.Execute(Element.Points);
+					var lastLine = Element.Lines.Last();
+					if (Element.DrawingLineCompletedCommand?.CanExecute(lastLine) ?? false)
+						Element.DrawingLineCompletedCommand.Execute(lastLine);
 				}
 
 				if (Element.ClearOnFinish)
 				{
-					canvas!.Strokes.StrokesChanged -= OnStrokesChanged;
-					canvas.Strokes.Clear();
-					canvas.Strokes.StrokesChanged += OnStrokesChanged;
-					Element.Points.Clear();
+					Element.Lines.CollectionChanged -= OnCollectionChanged;
+					Clear(true);
+					canvas!.Strokes.StrokesChanged += OnStrokesChanged;
 				}
 			}
 
-			Element.Points.CollectionChanged += OnCollectionChanged;
+			Element.Lines.CollectionChanged += OnCollectionChanged;
 		}
 
-		void LoadPoints()
+		void LoadLines()
 		{
-			var stylusPoints = Element?.Points.Select(point => new StylusPoint(point.X, point.Y)).ToList();
-			if (stylusPoints is { Count: > 0 })
+			var lines = Element.MultiLineMode
+				? Element.Lines
+				: Element.Lines.Any()
+					? new ObservableCollection<Line> {Element.Lines.LastOrDefault()}
+					: new ObservableCollection<Line>();
+			foreach (var line in lines)
 			{
-				var stroke = new Stroke(new StylusPointCollection(stylusPoints), canvas!.DefaultDrawingAttributes);
-				canvas.Strokes.Add(stroke);
+				var stylusPoints = line.Points.Select(point => new StylusPoint(point.X, point.Y)).ToList();
+				if (stylusPoints is {Count: > 0})
+				{
+					var stroke = new Stroke(new StylusPointCollection(stylusPoints))
+					{
+						DrawingAttributes = new()
+						{
+							Color = line.LineColor.ToMediaColor(),
+							Width = line.LineWidth,
+							Height = line.LineWidth
+						}
+					};
+					canvas!.Strokes.Add(stroke);
+				}
 			}
 		}
 	}
diff --git a/samples/XCT.Sample/Pages/Views/DrawingViewPage.xaml b/samples/XCT.Sample/Pages/Views/DrawingViewPage.xaml
index 36345608a..9ff847aea 100644
--- a/samples/XCT.Sample/Pages/Views/DrawingViewPage.xaml
+++ b/samples/XCT.Sample/Pages/Views/DrawingViewPage.xaml
@@ -6,22 +6,25 @@
                 xmlns:pages="clr-namespace:Xamarin.CommunityToolkit.Sample.Pages"
                 xmlns:viewsVodel="clr-namespace:Xamarin.CommunityToolkit.Sample.ViewModels.Views;assembly=Xamarin.CommunityToolkit.Sample">
 
-    <pages:BasePage.BindingContext>
-        <viewsVodel:DrawingViewViewModel/>
-    </pages:BasePage.BindingContext>
-
     <ScrollView>
         <StackLayout>
-            <Switch x:Name="ClearOnFinish"  />
+            <StackLayout Orientation="Horizontal" Margin="5">
+                <Label Text="Clear on Finish" Margin="0,0,5,0" />
+                <Switch x:Name="ClearOnFinish" />
+            </StackLayout>
+            <StackLayout Orientation="Horizontal" Margin="5">
+                <Label Text="Multi-Line Mode" Margin="0,0,5,0" />
+                <Switch x:Name="MultiLineMode" />
+            </StackLayout>
             <Button
                 BackgroundColor="White"
-                Clicked="LoadPointsButtonClicked"
-                Text="Load points"
+                Clicked="AddNewLine"
+                Text="Add new line"
                 TextColor="Black" />
             <Button
                 BackgroundColor="White"
-                Command="{Binding SetPointsCommand}"
-                Text="Load points ViewModel"
+                Clicked="LoadPointsButtonClicked"
+                Text="Load points"
                 TextColor="Black" />
             <Label
                 x:Name="HiddenLabel"
@@ -33,11 +36,6 @@
                 Clicked="DisplayHiddenLabelButtonClicked"
                 Text="Display hidden label"
                 TextColor="Black" />
-            <Button
-                BackgroundColor="White"
-                Command="{Binding GetPointsCommand}"
-                Text="Get points ViewModel"
-                TextColor="Black" />
             <Button
                 BackgroundColor="White"
                 Clicked="GetCurrentDrawingViewImageClicked"
@@ -53,21 +51,16 @@
                 HeightRequest="100"
                 WidthRequest="100" />
             
-            <Label Text="Default DrawingView"/>
-            <views:DrawingView BackgroundColor="LightGray" HeightRequest="200" />
+            <Label Text="DrawingView (Code behind)"/>
+            <views:DrawingView x:Name="DrawingViewControl" 
+                               BackgroundColor="LightGray" 
+                               HeightRequest="200"
+                               DefaultLineColor="Red"
+                               DefaultLineWidth="3"
+                               Lines="{Binding Lines, Mode=TwoWay}"
+                               ClearOnFinish="{Binding Source={x:Reference ClearOnFinish}, Path=IsToggled}"
+                               MultiLineMode="{Binding Source={x:Reference MultiLineMode}, Path=IsToggled}"/>
 
-            <Label Text="Advanced DrawingView"/>
-            <views:DrawingView
-                x:Name="DrawingViewControl"
-                Points="{Binding MacroPoints, Mode=TwoWay}"
-                EnableSmoothedPath="false"
-                Granularity="5"
-                BackgroundColor="DarkGray"
-                ClearOnFinish="{Binding Source={x:Reference ClearOnFinish}, Path=IsToggled}"
-                HorizontalOptions="FillAndExpand"
-                LineColor="Red"
-                LineWidth="10"
-                HeightRequest="200" />
             <Editor x:Name="Logs" HeightRequest="50" />
         </StackLayout>
     </ScrollView>
diff --git a/samples/XCT.Sample/Pages/Views/DrawingViewPage.xaml.cs b/samples/XCT.Sample/Pages/Views/DrawingViewPage.xaml.cs
index 0f8cc2830..d41e32bf1 100644
--- a/samples/XCT.Sample/Pages/Views/DrawingViewPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Views/DrawingViewPage.xaml.cs
@@ -3,25 +3,32 @@
 using Xamarin.Forms;
 using Xamarin.CommunityToolkit.UI.Views;
 using System.Collections.ObjectModel;
+using System.Linq;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages.Views
 {
 	public partial class DrawingViewPage : BasePage
 	{
+		static Random random = new Random();
+
 		public DrawingViewPage()
 		{
 			InitializeComponent();
-			DrawingViewControl.Points = GeneratePoints(200);
-			DrawingViewControl.DrawingCompletedCommand = new Command<ObservableCollection<Point>>(points =>
+			DrawingViewControl.Lines = GenerateLines(5);
+			DrawingViewControl.DrawingLineCompletedCommand = new Command<Line>(line =>
 			{
 				Logs.Text += "GestureCompletedCommand executed" + Environment.NewLine;
-				DrawImage(points);
+				var stream = Line.GetImageStream(line.Points.ToList(), new Size(GestureImage.Width, GestureImage.Height), 10, Color.White, Color.Black);
+				GestureImage.Source = ImageSource.FromStream(() => stream);
 			});
+
+			BindingContext = this;
 		}
 
-		void LoadPointsButtonClicked(object sender, EventArgs e) => DrawingViewControl.Points = GeneratePoints(50);
+		void LoadPointsButtonClicked(object sender, EventArgs e) => DrawingViewControl.Lines = GenerateLines(50);
 
-		void DisplayHiddenLabelButtonClicked(object sender, EventArgs e) => HiddenLabel.IsVisible = !HiddenLabel.IsVisible;
+		void DisplayHiddenLabelButtonClicked(object sender, EventArgs e) =>
+			HiddenLabel.IsVisible = !HiddenLabel.IsVisible;
 
 		void GetCurrentDrawingViewImageClicked(object sender, EventArgs e)
 		{
@@ -31,26 +38,55 @@ void GetCurrentDrawingViewImageClicked(object sender, EventArgs e)
 
 		void GetImageClicked(object sender, EventArgs e)
 		{
-			var points = GeneratePoints(100);
-			DrawImage(points);
+			var lines = GenerateLines(10);
+			DrawImage(lines.ToList());
+		}
+
+		ObservableCollection<Line> GenerateLines(int count)
+		{
+			var lines = new ObservableCollection<Line>();
+			for (var i = 0; i < count; i++)
+			{
+				lines.Add(new Line()
+				{
+					Points = GeneratePoints(10),
+					LineColor = Color.FromRgb(random.Next(255), random.Next(255), random.Next(255)),
+					LineWidth = 10,
+					EnableSmoothedPath = false,
+					Granularity = 5
+				});
+			}
+
+			return lines;
 		}
 
-		static ObservableCollection<Point> GeneratePoints(int count)
+		ObservableCollection<Point> GeneratePoints(int count)
 		{
 			var points = new ObservableCollection<Point>();
 			for (var i = 0; i < count; i++)
 			{
-				points.Add(new Point(i, i));
+				points.Add(new Point(random.Next(1, 100), random.Next(1, 100)));
 			}
 
 			return points;
 		}
 
-		void DrawImage(IEnumerable<Point> points)
+		void DrawImage(List<Line> lines)
 		{
-			var stream = DrawingView.GetImageStream(points, new Size(GestureImage.Width, GestureImage.Height), 10,
-				Color.White, Color.Black);
+			var stream = DrawingView.GetImageStream(lines, new Size(GestureImage.Width, GestureImage.Height), Color.Gray);
 			GestureImage.Source = ImageSource.FromStream(() => stream);
 		}
+
+		private void AddNewLine(object sender, EventArgs e)
+		{
+			DrawingViewControl.Lines.Add(new Line()
+			{
+				Points = GeneratePoints(10),
+				LineColor = Color.FromRgb(random.Next(255), random.Next(255), random.Next(255)),
+				LineWidth = 10,
+				EnableSmoothedPath = true,
+				Granularity = 5
+			});
+		}
 	}
 }
\ No newline at end of file
diff --git a/samples/XCT.Sample/ViewModels/Views/DrawingViewViewModel.cs b/samples/XCT.Sample/ViewModels/Views/DrawingViewViewModel.cs
deleted file mode 100644
index 00ec31f56..000000000
--- a/samples/XCT.Sample/ViewModels/Views/DrawingViewViewModel.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-using System.Collections.Generic;
-using System.Windows.Input;
-using Xamarin.Forms;
-using System.Linq;
-using Xamarin.CommunityToolkit.Extensions;
-using System.Collections.ObjectModel;
-using Xamarin.CommunityToolkit.ObjectModel;
-
-namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
-{
-	public class DrawingViewViewModel : BaseViewModel
-	{
-		ObservableCollection<Point> macroPoints = new ObservableCollection<Point>();
-
-		public DrawingViewViewModel()
-		{
-			SetPointsCommand = new Command(() =>
-			{
-				var points = GeneratePoints(100).ToList();
-				MacroPoints = new ObservableCollection<Point>(points);
-
-				MacroPoints2.Clear();
-				foreach (var point in points)
-				{
-					MacroPoints2.Add(point);
-				}
-				OnPropertyChanged(nameof(MacroPoints2));
-			});
-			GetPointsCommand = new AsyncCommand(async () =>
-			{
-				await Application.Current.MainPage.DisplayToastAsync($"PointsCount: {MacroPoints.Count}");
-				await Application.Current.MainPage.DisplayToastAsync($"Points2Count: {MacroPoints2.Count}");
-			});
-		}
-
-		public ICommand SetPointsCommand { get; }
-
-		public ICommand GetPointsCommand { get; }
-
-		public ObservableCollection<Point> MacroPoints
-		{
-			get => macroPoints;
-			set => SetProperty( ref macroPoints, value);
-		}
-
-		public ObservableCollection<Point> MacroPoints2 { get; } = new ObservableCollection<Point>();
-
-		static IEnumerable<Point> GeneratePoints(int count)
-		{
-			var points = new List<Point>();
-			for (var i = 0; i < count; i++)
-			{
-				points.Add(new Point(i, i));
-			}
-
-			return points;
-		}
-	}
-}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/Views/DrawingView_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/Views/DrawingView_Tests.cs
index 162f63991..6003706d1 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/Views/DrawingView_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/Views/DrawingView_Tests.cs
@@ -1,4 +1,5 @@
-using NUnit.Framework;
+using System.Linq;
+using NUnit.Framework;
 using Xamarin.CommunityToolkit.UI.Views;
 using Xamarin.Forms;
 
@@ -7,17 +8,92 @@ namespace Xamarin.CommunityToolkit.UnitTests.Views
 	public class DrawingView_Tests
 	{
 		[Test]
-		public void AllInstancesShouldHaveTheirOwnPoints()
+		public void AllInstancesShouldHaveTheirOwnLines()
 		{
 			var drawingViewOne = new DrawingView();
 			var drawingViewTwo = new DrawingView();
 
-			drawingViewOne.Points.Add(Point.Zero);
+			drawingViewOne.Lines.Add(new Line());
 
-			drawingViewTwo.Points.Clear();
+			drawingViewTwo.Lines.Clear();
 
-			Assert.IsNotEmpty(drawingViewOne.Points);
-			Assert.IsFalse(ReferenceEquals(drawingViewOne.Points, drawingViewTwo.Points));
+			Assert.IsNotEmpty(drawingViewOne.Lines);
+			Assert.IsFalse(ReferenceEquals(drawingViewOne.Lines, drawingViewTwo.Lines));
+		}
+
+		[Test]
+		public void AllLineInstancesShouldHaveTheirOwnPoints()
+		{
+			var drawingView = new DrawingView();
+
+			var line1 = new Line();
+			var line2 = new Line();
+			drawingView.Lines.Add(line1);
+			drawingView.Lines.Add(line2);
+
+			line1.Points.Add(Point.Zero);
+
+			line2.Points.Clear();
+
+			Assert.IsNotEmpty(line1.Points);
+			Assert.IsFalse(ReferenceEquals(line1.Points, line2.Points));
+		}
+
+		[Test]
+		public void DrawingLineCompletedCommandShouldFireWhenSet()
+		{
+			Line? line = null;
+			var drawingView = new DrawingView();
+
+			drawingView.DrawingLineCompletedCommand = new Command<Line?>((l) => line = l);
+
+			var newLine = new Line();
+			drawingView.Lines.Add(newLine);
+			drawingView.OnDrawingLineCompleted(newLine);
+
+			Assert.NotNull(line);
+			Assert.AreEqual(drawingView.Lines.Count(), 1);
+		}
+
+		[Test]
+		public void DrawingLineCompletedCommandShouldNotFireWhenLineNotSet()
+		{
+			Line? line = null;
+			var drawingView = new DrawingView();
+
+			drawingView.DrawingLineCompletedCommand = new Command<Line?>((l) => line = l);
+
+			drawingView.OnDrawingLineCompleted(null);
+
+			Assert.Null(line);
+		}
+
+		[Test]
+		public void DrawingLineCompletedShouldFireWhenSubscribed()
+		{
+			Line? line = null;
+			var drawingView = new DrawingView();
+
+			drawingView.DrawingLineCompleted += (sender, args) => line = args.Line;
+			var newLine = new Line();
+			drawingView.Lines.Add(newLine);
+			drawingView.OnDrawingLineCompleted(newLine);
+
+			Assert.NotNull(line);
+			Assert.AreEqual(drawingView.Lines.Count(), 1);
+		}
+
+		[Test]
+		public void DrawingLineCompletedShouldNotFireWhenSubscribedAndLineNotSet()
+		{
+			Line? line = null;
+			var drawingView = new DrawingView();
+
+			drawingView.DrawingLineCompleted += (sender, args) => line = args.Line;
+
+			drawingView.OnDrawingLineCompleted(null);
+
+			Assert.Null(line);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/DrawingLineCompletedEventArgs.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/DrawingLineCompletedEventArgs.shared.cs
new file mode 100644
index 000000000..4d50de521
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/DrawingLineCompletedEventArgs.shared.cs
@@ -0,0 +1,24 @@
+using System;
+
+namespace Xamarin.CommunityToolkit.UI.Views
+{
+	/// <summary>
+	/// Contains last drawing line
+	/// </summary>
+	public class DrawingLineCompletedEventArgs : EventArgs
+	{
+		/// <summary>
+		/// Last drawing line
+		/// </summary>
+		public Line? Line { get; }
+
+		/// <summary>
+		/// Initializes last drawing line
+		/// </summary>
+		/// <param name="line">Last drawing line</param>
+		public DrawingLineCompletedEventArgs(Line? line)
+		{
+			Line = line;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/DrawingView.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/DrawingView.shared.cs
index 622d6f47d..12b85105f 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/DrawingView.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/DrawingView.shared.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.IO;
 using System.Linq;
@@ -7,92 +8,148 @@
 
 namespace Xamarin.CommunityToolkit.UI.Views
 {
+	/// <summary>
+	/// The DrawingView allows you to draw one or multiple lines on a canvas
+	/// </summary>
 	public class DrawingView : View
 	{
-		const int minValueGranularity = 5;
-
-		public static readonly BindableProperty GranularityProperty =
-			BindableProperty.Create(nameof(Granularity), typeof(int), typeof(DrawingView), minValueGranularity, coerceValue: CoerceValue);
-
-		public static readonly BindableProperty EnableSmoothedPathProperty =
-			BindableProperty.Create(nameof(EnableSmoothedPath), typeof(bool), typeof(DrawingView), true);
-
-		public static readonly BindableProperty LineColorProperty =
-			BindableProperty.Create(nameof(LineColor), typeof(Color), typeof(DrawingView), Color.Black);
-
-		public static readonly BindableProperty LineWidthProperty =
-			BindableProperty.Create(nameof(LineWidth), typeof(float), typeof(DrawingView), 5f);
-
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="ClearOnFinish"/> property.
+		/// </summary>
 		public static readonly BindableProperty ClearOnFinishProperty =
 			BindableProperty.Create(nameof(ClearOnFinish), typeof(bool), typeof(DrawingView), default(bool));
 
-		public static readonly BindableProperty PointsProperty = BindableProperty.Create(
-			nameof(Points), typeof(ObservableCollection<Point>), typeof(DrawingView), default, BindingMode.TwoWay);
-
-		public static readonly BindableProperty DrawingCompletedCommandProperty = BindableProperty.Create(
-			nameof(DrawingCompletedCommand), typeof(ICommand), typeof(DrawingView));
-
-		public ObservableCollection<Point> Points
-		{
-			get => (ObservableCollection<Point>)GetValue(PointsProperty);
-			set => SetValue(PointsProperty, value);
-		}
-
-		public ICommand? DrawingCompletedCommand
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="MultiLineMode"/> property.
+		/// </summary>
+		public static readonly BindableProperty MultiLineModeProperty =
+			BindableProperty.Create(nameof(MultiLineMode), typeof(bool), typeof(DrawingView), default(bool));
+
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="Lines"/> property.
+		/// </summary>
+		public static readonly BindableProperty LinesProperty = BindableProperty.Create(
+			nameof(Lines), typeof(ObservableCollection<Line>), typeof(DrawingView), new ObservableCollection<Line>(),
+			BindingMode.TwoWay);
+
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="DrawingLineCompletedCommand"/> property.
+		/// </summary>
+		public static readonly BindableProperty DrawingLineCompletedCommandProperty = BindableProperty.Create(nameof(DrawingLineCompletedCommand), typeof(ICommand), typeof(DrawingView));
+
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="DefaultLineColor"/> property.
+		/// </summary>
+		public static readonly BindableProperty DefaultLineColorProperty =
+			BindableProperty.Create(nameof(DefaultLineColor), typeof(Color), typeof(DrawingView), Color.Black);
+
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="DefaultLineWidth"/> property.
+		/// </summary>
+		public static readonly BindableProperty DefaultLineWidthProperty =
+			BindableProperty.Create(nameof(DefaultLineWidth), typeof(float), typeof(DrawingView), 5f);
+
+		/// <summary>
+		/// Event occured when drawing line completed
+		/// </summary>
+		public event EventHandler<DrawingLineCompletedEventArgs>? DrawingLineCompleted;
+
+		/// <summary>
+		/// Initializes the DrawingView
+		/// </summary>
+		public DrawingView() => Lines = new ObservableCollection<Line>();
+
+		/// <summary>
+		/// The <see cref="Color"/> that is used by default to draw a line on the <see cref="DrawingView"/>. This is a bindable property.
+		/// </summary>
+		public Color DefaultLineColor
 		{
-			get => (ICommand)GetValue(DrawingCompletedCommandProperty);
-			set => SetValue(DrawingCompletedCommandProperty, value);
+			get => (Color)GetValue(DefaultLineColorProperty);
+			set => SetValue(DefaultLineColorProperty, value);
 		}
 
-		public int Granularity
+		/// <summary>
+		/// The width that is used by default to draw a line on the <see cref="DrawingView"/>. This is a bindable property.
+		/// </summary>
+		public float DefaultLineWidth
 		{
-			get => (int)GetValue(GranularityProperty);
-			set => SetValue(GranularityProperty, value);
+			get => (float)GetValue(DefaultLineWidthProperty);
+			set => SetValue(DefaultLineWidthProperty, value);
 		}
 
-		public bool EnableSmoothedPath
+		/// <summary>
+		/// This command is invoked whenever the drawing of a line on <see cref="DrawingView"/> has completed.
+		/// Note that this is fired after the tap or click is lifted. When <see cref="MultiLineMode"/> is enabled
+		/// this command is fired multiple times.
+		/// This is a bindable property.
+		/// </summary>
+		public ICommand? DrawingLineCompletedCommand
 		{
-			get => (bool)GetValue(EnableSmoothedPathProperty);
-			set => SetValue(EnableSmoothedPathProperty, value);
+			get => (ICommand)GetValue(DrawingLineCompletedCommandProperty);
+			set => SetValue(DrawingLineCompletedCommandProperty, value);
 		}
 
-		public Color LineColor
+		/// <summary>
+		/// The collection of lines that are currently on the <see cref="DrawingView"/>. This is a bindable property.
+		/// </summary>
+		public ObservableCollection<Line> Lines
 		{
-			get => (Color)GetValue(LineColorProperty);
-			set => SetValue(LineColorProperty, value);
+			get => (ObservableCollection<Line>)GetValue(LinesProperty);
+			set => SetValue(LinesProperty, value);
 		}
 
-		public float LineWidth
+		/// <summary>
+		/// Toggles multi-line mode. When true, multiple lines can be drawn on the <see cref="DrawingView"/> while the tap/click is released in-between lines.
+		/// Note: when <see cref="ClearOnFinish"/> is also enabled, the lines are cleared after the tap/click is released.
+		/// Additionally, <see cref="DrawingLineCompletedCommand"/> will be fired after each line that is drawn.
+		/// This is a bindable property.
+		/// </summary>
+		public bool MultiLineMode
 		{
-			get => (float)GetValue(LineWidthProperty);
-			set => SetValue(LineWidthProperty, value);
+			get => (bool)GetValue(MultiLineModeProperty);
+			set => SetValue(MultiLineModeProperty, value);
 		}
 
+		/// <summary>
+		/// Indicates whether the <see cref="DrawingView"/> is cleared after releasing the tap/click and a line is drawn.
+		/// Note: when <see cref="MultiLineMode"/> is also enabled, this might cause unexpected behavior.
+		/// This is a bindable property.
+		/// </summary>
 		public bool ClearOnFinish
 		{
 			get => (bool)GetValue(ClearOnFinishProperty);
 			set => SetValue(ClearOnFinishProperty, value);
 		}
 
-		public DrawingView()
-		{
-			Points = new ObservableCollection<Point>();
-		}
-
-		static object CoerceValue(BindableObject bindable, object value)
-			=> ((DrawingView)bindable).CoerceValue((int)value);
-
-		int CoerceValue(int value) => value < minValueGranularity ? minValueGranularity : value;
-
-		public Stream GetImageStream(double imageSizeWidth, double imageSizeHeight) =>
-			DrawingViewService.GetImageStream(Points.ToList(), new Size(imageSizeWidth, imageSizeHeight), LineWidth, LineColor,
-				BackgroundColor);
-
-		public static Stream GetImageStream(IEnumerable<Point> points,
+		/// <summary>
+		/// Retrieves a <see cref="Stream"/> containing an image of the <see cref="Lines"/> that are currently drawn on the <see cref="DrawingView"/>.
+		/// </summary>
+		/// <param name="imageSizeWidth">Desired width of the image that is returned.</param>
+		/// <param name="imageSizeHeight">Desired heigth of the image that is returned.</param>
+		/// <returns><see cref="Stream"/> containing the data of the requested image with data that's currently on the <see cref="DrawingView"/>.</returns>
+		public Stream GetImageStream(double imageSizeWidth, double imageSizeHeight) => DrawingViewService.GetImageStream(Lines.ToList(), new Size(imageSizeWidth, imageSizeHeight), BackgroundColor);
+
+		/// <summary>
+		/// Retrieves a <see cref="Stream"/> containing an image of the collection of <see cref="Line"/> that is provided as a parameter.
+		/// </summary>
+		/// <param name="lines">A collection of <see cref="Line"/> that a image is generated from.</param>
+		/// <param name="imageSize">The desired dimensions of the generated image.</param>
+		/// <param name="backgroundColor">Background color of the generated image.</param>
+		/// <returns><see cref="Stream"/> containing the data of the requested image with data that's provided through the <paramref name="lines"/> parameter.</returns>
+		public static Stream GetImageStream(IEnumerable<Line> lines,
 			Size imageSize,
-			float lineWidth,
-			Color strokeColor,
 			Color backgroundColor) =>
-			DrawingViewService.GetImageStream(points.ToList(), imageSize, lineWidth, strokeColor, backgroundColor);
+			DrawingViewService.GetImageStream(lines.ToList(), imageSize, backgroundColor);
+
+		/// <summary>
+		/// Executes DrawingLineCompleted event and DrawingLineCompletedCommand
+		/// </summary>
+		/// <param name="lastDrawingLine">Last drawing line</param>
+		internal void OnDrawingLineCompleted(Line? lastDrawingLine)
+		{
+			DrawingLineCompleted?.Invoke(this, new DrawingLineCompletedEventArgs(lastDrawingLine));
+			if (DrawingLineCompletedCommand?.CanExecute(lastDrawingLine) ?? false)
+				DrawingLineCompletedCommand.Execute(lastDrawingLine);
+		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Extensions/Extensions.ios.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Extensions/Extensions.ios.cs
index f752964c6..1ada8b8bc 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Extensions/Extensions.ios.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Extensions/Extensions.ios.cs
@@ -3,6 +3,9 @@
 
 namespace Xamarin.CommunityToolkit.UI.Views.iOS
 {
+	/// <summary>
+	/// Extension methods to support <see cref="DrawingView"/>
+	/// </summary>
 	public static class Extensions
 	{
 		/// <summary>
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Extensions/Extensions.macos.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Extensions/Extensions.macos.cs
index c08f13dd0..284918d87 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Extensions/Extensions.macos.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Extensions/Extensions.macos.cs
@@ -3,6 +3,9 @@
 
 namespace Xamarin.CommunityToolkit.UI.Views.macOS
 {
+	/// <summary>
+	/// Extension methods to support <see cref="DrawingView"/>
+	/// </summary>
 	public static class Extensions
 	{
 		/// <summary>
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Line.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Line.shared.cs
new file mode 100644
index 000000000..139df86aa
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Line.shared.cs
@@ -0,0 +1,131 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using Xamarin.Forms;
+
+namespace Xamarin.CommunityToolkit.UI.Views
+{
+	/// <summary>
+	/// The Line object is used to describe the lines that are drawn on a <see cref="DrawView"/>.
+	/// </summary>
+	public class Line : BindableObject
+	{
+		const int minValueGranularity = 5;
+
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="Granularity"/> property.
+		/// </summary>
+		public static readonly BindableProperty GranularityProperty =
+			BindableProperty.Create(nameof(Granularity), typeof(int), typeof(Line), minValueGranularity,
+				coerceValue: CoerceValue);
+
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="EnableSmoothedPath"/> property.
+		/// </summary>
+		public static readonly BindableProperty EnableSmoothedPathProperty =
+			BindableProperty.Create(nameof(EnableSmoothedPath), typeof(bool), typeof(Line), true);
+
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="Points"/> property.
+		/// </summary>
+		public static readonly BindableProperty PointsProperty = BindableProperty.Create(
+			nameof(Points), typeof(ObservableCollection<Point>), typeof(Line), new ObservableCollection<Point>(),
+			BindingMode.TwoWay);
+
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="LineColor"/> property.
+		/// </summary>
+		public static readonly BindableProperty LineColorProperty =
+			BindableProperty.Create(nameof(LineColor), typeof(Color), typeof(Line), Color.Black);
+
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="LineWidth"/> property.
+		/// </summary>
+		public static readonly BindableProperty LineWidthProperty =
+			BindableProperty.Create(nameof(LineWidth), typeof(float), typeof(Line), 5f);
+
+		/// <summary>
+		/// Initializes a new Line object.
+		/// </summary>
+		public Line() => Points = new ObservableCollection<Point>();
+
+		/// <summary>
+		/// The <see cref="Color"/> that is used to draw this line on the <see cref="DrawingView"/>. This is a bindable property.
+		/// </summary>
+		public Color LineColor
+		{
+			get => (Color)GetValue(LineColorProperty);
+			set => SetValue(LineColorProperty, value);
+		}
+
+		/// <summary>
+		/// The width that is used to draw this line on the <see cref="DrawingView"/>. This is a bindable property.
+		/// </summary>
+		public float LineWidth
+		{
+			get => (float)GetValue(LineWidthProperty);
+			set => SetValue(LineWidthProperty, value);
+		}
+
+		/// <summary>
+		/// The collection of <see cref="Point"/> that makes up this line on the <see cref="DrawingView"/>. This is a bindable property.
+		/// </summary>
+		public ObservableCollection<Point> Points
+		{
+			get => (ObservableCollection<Point>)GetValue(PointsProperty);
+			set => SetValue(PointsProperty, value);
+		}
+
+		/// <summary>
+		/// The granularity of this line. This is a bindable property.
+		/// </summary>
+		public int Granularity
+		{
+			get => (int)GetValue(GranularityProperty);
+			set => SetValue(GranularityProperty, value);
+		}
+
+		/// <summary>
+		/// Enables or disabled if this line is smoothed (anti-aliased) when drawn. This is a bindable property.
+		/// </summary>
+		public bool EnableSmoothedPath
+		{
+			get => (bool)GetValue(EnableSmoothedPathProperty);
+			set => SetValue(EnableSmoothedPathProperty, value);
+		}
+
+		static object CoerceValue(BindableObject bindable, object value)
+			=> ((Line)bindable).CoerceValue((int)value);
+
+		int CoerceValue(int value) => value < minValueGranularity ? minValueGranularity : value;
+
+		/// <summary>
+		/// Retrieves a <see cref="Stream"/> containing an image of this line, based on the <see cref="Points"/> data.
+		/// </summary>
+		/// <param name="imageSizeWidth">Desired width of the image that is returned.</param>
+		/// <param name="imageSizeHeight">Desired heigth of the image that is returned.</param>
+		/// <param name="backgroundColor">Background color of the generated image.</param>
+		/// <returns><see cref="Stream"/> containing the data of the requested image with data that's currently on the <see cref="DrawingView"/>.</returns>
+		public Stream GetImageStream(double imageSizeWidth, double imageSizeHeight, Color backgroundColor) =>
+			DrawingViewService.GetImageStream(Points.ToList(), new Size(imageSizeWidth, imageSizeHeight), LineWidth,
+				LineColor,
+				backgroundColor);
+
+		/// <summary>
+		/// Retrieves a <see cref="Stream"/> containing an image of the collection of <see cref="Point"/> that is provided as a parameter.
+		/// </summary>
+		/// <param name="points">A collection of <see cref="Point"/> that a image is generated from.</param>
+		/// <param name="imageSize">The desired dimensions of the generated image.</param>
+		/// <param name="lineWidth">The desired line width to be used in the generated image.</param>
+		/// <param name="strokeColor">The desired color of the line to be used in the generated image.</param>
+		/// <param name="backgroundColor">Background color of the generated image.</param>
+		/// <returns><see cref="Stream"/> containing the data of the requested image with data that's provided through the <paramref name="points"/> parameter.</returns>
+		public static Stream GetImageStream(IEnumerable<Point> points,
+			Size imageSize,
+			float lineWidth,
+			Color strokeColor,
+			Color backgroundColor) =>
+			DrawingViewService.GetImageStream(points.ToList(), imageSize, lineWidth, strokeColor, backgroundColor);
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.android.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.android.cs
index ee3055015..9756251d3 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.android.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.android.cs
@@ -13,6 +13,9 @@
 
 namespace Xamarin.CommunityToolkit.UI.Views
 {
+	/// <summary>
+	/// Android renderer for <see cref="Xamarin.CommunityToolkit.UI.Views.DrawingViewRenderer"/>
+	/// </summary>
 	public class DrawingViewRenderer : ViewRenderer<DrawingView, View>
 	{
 		bool disposed;
@@ -22,6 +25,7 @@ public class DrawingViewRenderer : ViewRenderer<DrawingView, View>
 		readonly Path drawPath;
 		Bitmap? canvasBitmap;
 		Canvas? drawCanvas;
+		Line? currentLine;
 
 		public DrawingViewRenderer(Context context)
 			: base(context)
@@ -45,8 +49,8 @@ public DrawingViewRenderer(Context context)
 		protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
 		{
 			base.OnElementPropertyChanged(sender, e);
-			if (e.PropertyName == DrawingView.PointsProperty.PropertyName)
-				LoadPoints();
+			if (e.PropertyName == DrawingView.LinesProperty.PropertyName)
+				LoadLines();
 		}
 
 		protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
@@ -55,13 +59,13 @@ protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
 			if (e.NewElement != null)
 			{
 				SetBackgroundColor(Element.BackgroundColor.ToAndroid());
-				drawPaint.Color = Element.LineColor.ToAndroid();
-				drawPaint.StrokeWidth = Element.LineWidth;
-				Element.Points.CollectionChanged += OnPointsCollectionChanged;
+				drawPaint.Color = Element.DefaultLineColor.ToAndroid();
+				drawPaint.StrokeWidth = Element.DefaultLineWidth;
+				Element.Lines.CollectionChanged += OnLinesCollectionChanged;
 			}
 		}
 
-		void OnPointsCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => LoadPoints();
+		void OnLinesCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => LoadLines();
 
 		protected override void OnSizeChanged(int w, int h, int oldw, int oldh)
 		{
@@ -71,15 +75,25 @@ protected override void OnSizeChanged(int w, int h, int oldw, int oldh)
 			h = h < minH ? minH : h;
 			base.OnSizeChanged(w, h, oldw, oldh);
 
-			canvasBitmap = Bitmap.CreateBitmap(w, h, Bitmap.Config.Argb8888!)!;
+			canvasBitmap = Bitmap.CreateBitmap(w, h, Bitmap.Config.Argb8888!) !;
 			drawCanvas = new Canvas(canvasBitmap);
-			LoadPoints();
+			LoadLines();
 		}
 
 		protected override void OnDraw(Canvas? canvas)
 		{
 			base.OnDraw(canvas);
 
+			foreach (var line in Element.Lines)
+			{
+				var path = new Path();
+				path.MoveTo((float)line.Points[0].X, (float)line.Points[0].Y);
+				foreach (var (x, y) in line.Points)
+					path.LineTo((float)x, (float)y);
+
+				canvas?.DrawPath(path, drawPaint);
+			}
+
 			canvas?.DrawBitmap(canvasBitmap!, 0, 0, canvasPaint);
 			canvas?.DrawPath(drawPath, drawPaint);
 		}
@@ -88,13 +102,24 @@ public override bool OnTouchEvent(MotionEvent e)
 		{
 			var touchX = e.GetX();
 			var touchY = e.GetY();
-			var points = Element.Points;
 
 			switch (e.Action)
 			{
 				case MotionEventActions.Down:
 					Parent?.RequestDisallowInterceptTouchEvent(true);
-					points.Clear();
+					if (!Element.MultiLineMode)
+					{
+						Element.Lines.Clear();
+					}
+
+					currentLine = new Line()
+					{
+						Points = new System.Collections.ObjectModel.ObservableCollection<Point>()
+						{
+							new Point(touchX, touchY)
+						}
+					};
+
 					drawCanvas!.DrawColor(Element.BackgroundColor.ToAndroid(), PorterDuff.Mode.Clear!);
 					drawPath.MoveTo(touchX, touchY);
 					break;
@@ -102,20 +127,21 @@ public override bool OnTouchEvent(MotionEvent e)
 					if (touchX > 0 && touchY > 0)
 						drawPath.LineTo(touchX, touchY);
 
-					points.Add(new Point(touchX, touchY));
+					currentLine!.Points.Add(new Point(touchX, touchY));
 					break;
 				case MotionEventActions.Up:
 					Parent?.RequestDisallowInterceptTouchEvent(false);
 					drawCanvas!.DrawPath(drawPath, drawPaint);
 					drawPath.Reset();
-					if (points.Count > 0)
+					if (currentLine != null)
 					{
-						if (Element.DrawingCompletedCommand?.CanExecute(null) ?? false)
-							Element.DrawingCompletedCommand.Execute(points);
+						Element.Lines.Add(currentLine);
+						Element.OnDrawingLineCompleted(currentLine);
 					}
 
 					if (Element.ClearOnFinish)
-						points.Clear();
+						Element.Lines.Clear();
+
 					break;
 				default:
 					return false;
@@ -134,19 +160,22 @@ public override bool OnInterceptTouchEvent(MotionEvent ev)
 			return base.OnInterceptTouchEvent(ev);
 		}
 
-		void LoadPoints()
+		void LoadLines()
 		{
 			drawCanvas!.DrawColor(Element.BackgroundColor.ToAndroid(), PorterDuff.Mode.Clear!);
 			drawPath.Reset();
-			var points = Element.Points;
-			if (points.Count > 0)
+			var lines = Element.Lines;
+			if (lines.Count > 0)
 			{
-				drawPath.MoveTo((float)points[0].X, (float)points[0].Y);
-				foreach (var (x, y) in points)
-					drawPath.LineTo((float)x, (float)y);
+				foreach (var line in lines)
+				{
+					drawPath.MoveTo((float)line.Points[0].X, (float)line.Points[0].Y);
+					foreach (var (x, y) in line.Points)
+						drawPath.LineTo((float)x, (float)y);
 
-				drawCanvas.DrawPath(drawPath, drawPaint);
-				drawPath.Reset();
+					drawCanvas.DrawPath(drawPath, drawPaint);
+					drawPath.Reset();
+				}
 
 				Invalidate();
 			}
@@ -165,7 +194,7 @@ protected override void Dispose(bool disposing)
 				canvasBitmap!.Dispose();
 				canvasPaint.Dispose();
 				if (Element != null)
-					Element.Points.CollectionChanged -= OnPointsCollectionChanged;
+					Element.Lines.CollectionChanged -= OnLinesCollectionChanged;
 			}
 
 			disposed = true;
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.gtk.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.gtk.cs
index 88eeeef1c..86fcaaa16 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.gtk.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.gtk.cs
@@ -14,6 +14,9 @@
 
 namespace Xamarin.CommunityToolkit.UI.Views
 {
+	/// <summary>
+	/// GTK renderer for <see cref="Xamarin.CommunityToolkit.UI.Views.DrawingViewRenderer"/>
+	/// </summary>
 	public class DrawingViewRenderer : ViewRenderer<DrawingView, VBox>
 	{
 		bool disposed;
@@ -23,6 +26,7 @@ public class DrawingViewRenderer : ViewRenderer<DrawingView, VBox>
 		PointD point;
 		PointD previousPoint;
 		ImageSurface? surface;
+		Line? currentLine;
 
 		protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
 		{
@@ -42,7 +46,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
 				isDrawing = false;
 
 				vBox.Add(area);
-				Element.Points.CollectionChanged += OnPointsCollectionChanged;
+				Element.Lines.CollectionChanged += OnLinesCollectionChanged;
 				SetNativeControl(vBox);
 			}
 
@@ -66,7 +70,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
 		protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
 		{
 			base.OnElementPropertyChanged(sender, e);
-			if (e.PropertyName == DrawingView.PointsProperty.PropertyName)
+			if (e.PropertyName == DrawingView.LinesProperty.PropertyName)
 			{
 				surface = new ImageSurface(Format.Argb32, Convert.ToInt32(Element.Width),
 										   Convert.ToInt32(Element.Height));
@@ -74,7 +78,7 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 			}
 		}
 
-		void OnPointsCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => LoadPoints(surface!);
+		void OnLinesCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => LoadPoints(surface!);
 
 		void OnDrawingAreaExposed(object source, ExposeEventArgs args)
 		{
@@ -98,31 +102,38 @@ void OnMousePress(object source, ButtonPressEventArgs args)
 
 			point.X = args.Event.X;
 			point.Y = args.Event.Y;
+			currentLine = new Line()
+			{
+				Points = new System.Collections.ObjectModel.ObservableCollection<Point>()
+				{
+					new Point(point.X, point.Y)
+				}
+			};
 			previousPoint = point;
 			isDrawing = true;
 			area!.QueueDraw();
-			Element.Points.Clear();
+			if (!Element.MultiLineMode)
+				Element.Lines.Clear();
 		}
 
 		void OnMouseRelease(object source, ButtonReleaseEventArgs args)
 		{
 			point.X = args.Event.X;
 			point.Y = args.Event.Y;
-			var points = Element.Points;
 			isDrawing = false;
 
 			using var ctx = new Context(surface);
 			DrawPoint(ctx, point);
 
 			area!.QueueDraw();
-			if (points.Count > 0)
+			if (currentLine != null)
 			{
-				if (Element.DrawingCompletedCommand?.CanExecute(null) ?? false)
-					Element.DrawingCompletedCommand.Execute(Element.Points);
+				Element.Lines.Add(currentLine);
+				Element.OnDrawingLineCompleted(currentLine);
 			}
 
 			if (Element.ClearOnFinish)
-				points.Clear();
+				Element.Lines.Clear();
 		}
 
 		void OnMouseMotion(object source, MotionNotifyEventArgs args)
@@ -141,27 +152,34 @@ void OnMouseMotion(object source, MotionNotifyEventArgs args)
 
 		void DrawPoint(Context ctx, PointD pointD)
 		{
-			ctx.SetSourceRGBA(Element.LineColor.R, Element.LineColor.G, Element.LineColor.B, Element.LineColor.A);
-			ctx.LineWidth = Element.LineWidth;
+			ctx.SetSourceRGBA(currentLine!.LineColor.R, currentLine!.LineColor.G, currentLine!.LineColor.B, currentLine!.LineColor.A);
+			ctx.LineWidth = currentLine.LineWidth;
 			ctx.MoveTo(previousPoint);
 			previousPoint = pointD;
 			ctx.LineTo(pointD);
 			ctx.Stroke();
-			Element.Points.Add(new Point(pointD.X, pointD.Y));
+			currentLine.Points.Add(new Point(pointD.X, pointD.Y));
 		}
 
 		void LoadPoints(ImageSurface imageSurface)
 		{
-			var stylusPoints = Element?.Points?.Select(stylusPoint => new PointD(stylusPoint.X, stylusPoint.Y)).ToList();
-			if (stylusPoints is { Count: > 0 })
+			var lines = Element.Lines;
+			if (lines.Count > 0)
 			{
-				previousPoint = stylusPoints[0];
-				using var ctx = new Context(imageSurface);
-
-				foreach (var stylusPoint in stylusPoints)
-					DrawPoint(ctx, stylusPoint);
-
-				area!.QueueDraw();
+				foreach (var line in lines)
+				{
+					var stylusPoints = line.Points.Select(stylusPoint => new PointD(stylusPoint.X, stylusPoint.Y)).ToList();
+					if (stylusPoints is { Count: > 0 })
+					{
+						previousPoint = stylusPoints[0];
+						using var ctx = new Context(imageSurface);
+
+						foreach (var stylusPoint in stylusPoints)
+							DrawPoint(ctx, stylusPoint);
+
+						area!.QueueDraw();
+					}
+				}
 			}
 		}
 
@@ -179,7 +197,7 @@ protected override void Dispose(bool disposing)
 				area.Dispose();
 				surface!.Dispose();
 				if (Element != null)
-					Element.Points.CollectionChanged -= OnPointsCollectionChanged;
+					Element.Lines.CollectionChanged -= OnLinesCollectionChanged;
 			}
 
 			disposed = true;
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.ios.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.ios.cs
index 093a89cc0..58d9a1455 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.ios.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.ios.cs
@@ -13,12 +13,16 @@
 
 namespace Xamarin.CommunityToolkit.UI.Views
 {
+	/// <summary>
+	/// iOS renderer for <see cref="DrawingViewRenderer"/>
+	/// </summary>
 	public class DrawingViewRenderer : ViewRenderer<DrawingView, UIView>
 	{
 		bool disposed;
 		UIBezierPath currentPath;
 		UIColor? lineColor;
 		CGPoint previousPoint;
+		Line? currentLine;
 
 		public DrawingViewRenderer() => currentPath = new UIBezierPath();
 
@@ -28,36 +32,46 @@ protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
 			if (Element != null)
 			{
 				BackgroundColor = Element.BackgroundColor.ToUIColor();
-				currentPath.LineWidth = Element.LineWidth;
-				lineColor = Element.LineColor.ToUIColor();
-				Element.Points.CollectionChanged += OnPointsCollectionChanged;
+				currentPath.LineWidth = Element.DefaultLineWidth;
+				lineColor = Element.DefaultLineColor.ToUIColor();
+				Element.Lines.CollectionChanged += OnLinesCollectionChanged;
 			}
 		}
 
 		protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
 		{
 			base.OnElementPropertyChanged(sender, e);
-			if (e.PropertyName == DrawingView.PointsProperty.PropertyName)
+			if (e.PropertyName == DrawingView.LinesProperty.PropertyName)
 				LoadPoints();
 		}
 
-		void OnPointsCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => LoadPoints();
+		void OnLinesCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => LoadPoints();
 
 		public override void TouchesBegan(NSSet touches, UIEvent? evt)
 		{
 			SetParentTouches(false);
 
-			Element.Points.CollectionChanged -= OnPointsCollectionChanged;
-			Element.Points.Clear();
-			currentPath.RemoveAllPoints();
+			Element.Lines.CollectionChanged -= OnLinesCollectionChanged;
+			if (!Element.MultiLineMode)
+			{
+				Element.Lines.Clear();
+				currentPath.RemoveAllPoints();
+			}
 
 			var touch = (UITouch)touches.AnyObject;
 			previousPoint = touch.PreviousLocationInView(this);
 			currentPath.MoveTo(previousPoint);
+			currentLine = new Line()
+			{
+				Points = new ObservableCollection<Point>()
+				{
+					new Point(previousPoint.X, previousPoint.Y)
+				}
+			};
 
 			SetNeedsDisplay();
 
-			Element.Points.CollectionChanged += OnPointsCollectionChanged;
+			Element.Lines.CollectionChanged += OnLinesCollectionChanged;
 		}
 
 		public override void TouchesMoved(NSSet touches, UIEvent? evt)
@@ -65,19 +79,20 @@ public override void TouchesMoved(NSSet touches, UIEvent? evt)
 			var touch = (UITouch)touches.AnyObject;
 			var currentPoint = touch.LocationInView(this);
 			AddPointToPath(currentPoint);
+			currentLine?.Points.Add(currentPoint.ToPoint());
 		}
 
 		public override void TouchesEnded(NSSet touches, UIEvent? evt)
 		{
-			UpdatePath();
-			if (Element.Points.Count > 0)
+			if (currentLine != null)
 			{
-				if (Element.DrawingCompletedCommand?.CanExecute(null) ?? false)
-					Element.DrawingCompletedCommand.Execute(Element.Points);
+				UpdatePath(currentLine);
+				Element.Lines.Add(currentLine);
+				Element.OnDrawingLineCompleted(currentLine);
 			}
 
 			if (Element.ClearOnFinish)
-				Element.Points.Clear();
+				Element.Lines.Clear();
 
 			SetParentTouches(true);
 		}
@@ -98,53 +113,47 @@ void AddPointToPath(CGPoint currentPoint)
 		{
 			currentPath.AddLineTo(currentPoint);
 			SetNeedsDisplay();
-			Element.Points.CollectionChanged -= OnPointsCollectionChanged;
-			var point = currentPoint.ToPoint();
-			Element.Points.Add(point);
-			Element.Points.CollectionChanged += OnPointsCollectionChanged;
 		}
 
 		void LoadPoints()
 		{
-			var stylusPoints = Element.Points.Select(point => new CGPoint(point.X, point.Y)).ToList();
 			currentPath.RemoveAllPoints();
-			if (stylusPoints.Count > 0)
+			foreach (var line in Element.Lines)
 			{
-				previousPoint = stylusPoints[0];
-				currentPath.MoveTo(previousPoint);
-				foreach (var point in stylusPoints)
-					AddPointToPath(point);
-
-				UpdatePath();
+				UpdatePath(line);
+				var stylusPoints = line.Points.Select(point => new CGPoint(point.X, point.Y)).ToList();
+				if (stylusPoints.Count > 0)
+				{
+					previousPoint = stylusPoints[0];
+					currentPath.MoveTo(previousPoint);
+					foreach (var point in stylusPoints)
+						AddPointToPath(point);
+				}
 			}
 		}
 
-		void UpdatePath()
+		void UpdatePath(Line line)
 		{
-			Element.Points.CollectionChanged -= OnPointsCollectionChanged;
-			var smoothedPoints = Element.EnableSmoothedPath
-				? SmoothedPathWithGranularity(Element.Points, Element.Granularity, ref currentPath)
-				: new ObservableCollection<Point>(Element.Points);
+			Element.Lines.CollectionChanged -= OnLinesCollectionChanged;
+			var smoothedPoints = line.EnableSmoothedPath
+				? SmoothedPathWithGranularity(line.Points, line.Granularity)
+				: new ObservableCollection<Point>(line.Points);
 
-			SetNeedsDisplay();
-			Element.Points.Clear();
+			line.Points.Clear();
 
 			foreach (var point in smoothedPoints)
-				Element.Points.Add(point);
+				line.Points.Add(point);
 
-			Element.Points.CollectionChanged += OnPointsCollectionChanged;
+			Element.Lines.CollectionChanged += OnLinesCollectionChanged;
 		}
 
 		ObservableCollection<Point> SmoothedPathWithGranularity(ObservableCollection<Point> currentPoints,
-			int granularity,
-			ref UIBezierPath smoothedPath)
+			int granularity)
 		{
 			// not enough points to smooth effectively, so return the original path and points.
 			if (currentPoints.Count < granularity + 2)
 				return new ObservableCollection<Point>(currentPoints);
 
-			// create a new bezier path to hold the smoothed path.
-			smoothedPath.RemoveAllPoints();
 			var smoothedPoints = new ObservableCollection<Point>();
 
 			// duplicate the first and last points as control points.
@@ -152,7 +161,6 @@ ObservableCollection<Point> SmoothedPathWithGranularity(ObservableCollection<Poi
 			currentPoints.Add(currentPoints[^1]);
 
 			// add the first point
-			smoothedPath.MoveTo(currentPoints[0].X, currentPoints[0].Y);
 			smoothedPoints.Add(currentPoints[0]);
 
 			var currentPointsCount = currentPoints.Count;
@@ -172,18 +180,15 @@ ObservableCollection<Point> SmoothedPathWithGranularity(ObservableCollection<Poi
 
 					// intermediate point
 					var mid = GetIntermediatePoint(p0, p1, p2, p3, t, tt, ttt);
-					smoothedPath.LineTo(mid.X, mid.Y);
 					smoothedPoints.Add(mid);
 				}
 
 				// add p2
-				smoothedPath.LineTo(p2.X, p2.Y);
 				smoothedPoints.Add(p2);
 			}
 
 			// add the last point
 			var last = currentPoints[^1];
-			smoothedPath.LineTo(last.X, last.Y);
 			smoothedPoints.Add(last);
 			return smoothedPoints;
 		}
@@ -212,7 +217,7 @@ protected override void Dispose(bool disposing)
 			{
 				currentPath.Dispose();
 				if (Element != null)
-					Element.Points.CollectionChanged -= OnPointsCollectionChanged;
+					Element.Lines.CollectionChanged -= OnLinesCollectionChanged;
 			}
 
 			disposed = true;
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.macos.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.macos.cs
index 841a1bea5..ed58f6d46 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.macos.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.macos.cs
@@ -12,12 +12,16 @@
 
 namespace Xamarin.CommunityToolkit.UI.Views
 {
+	/// <summary>
+	/// macOS renderer for <see cref="DrawingViewRenderer"/>
+	/// </summary>
 	public class DrawingViewRenderer : ViewRenderer<DrawingView, NSView>
 	{
 		bool disposed;
 		NSBezierPath currentPath;
 		NSColor? lineColor;
 		CGPoint previousPoint;
+		Line? currentLine;
 
 		public DrawingViewRenderer() => currentPath = new NSBezierPath();
 
@@ -28,51 +32,62 @@ protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
 			{
 				WantsLayer = true;
 				Layer!.BackgroundColor = Element.BackgroundColor.ToCGColor();
-				currentPath.LineWidth = Element.LineWidth;
-				lineColor = Element.LineColor.ToNSColor();
-				Element.Points.CollectionChanged += OnPointsCollectionChanged;
+				currentPath.LineWidth = Element.DefaultLineWidth;
+				lineColor = Element.DefaultLineColor.ToNSColor();
+				Element.Lines.CollectionChanged += OnLinesCollectionChanged;
 			}
 		}
 
 		protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
 		{
 			base.OnElementPropertyChanged(sender, e);
-			if (e.PropertyName == DrawingView.PointsProperty.PropertyName)
+			if (e.PropertyName == DrawingView.LinesProperty.PropertyName)
 				LoadPoints();
 		}
 
-		void OnPointsCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => LoadPoints();
+		void OnLinesCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => LoadPoints();
 
 		public override void MouseDown(NSEvent theEvent)
 		{
-			Element.Points.CollectionChanged -= OnPointsCollectionChanged;
-			Element.Points.Clear();
-			currentPath.RemoveAllPoints();
+			Element.Lines.CollectionChanged -= OnLinesCollectionChanged;
+			if (!Element.MultiLineMode)
+			{
+				Element.Lines.Clear();
+				currentPath.RemoveAllPoints();
+			}
 
 			previousPoint = theEvent.LocationInWindow;
 			currentPath.MoveTo(previousPoint);
+			currentLine = new Line()
+			{
+				Points = new ObservableCollection<Point>()
+				{
+					new Point(previousPoint.X, previousPoint.Y)
+				}
+			};
 
 			InvokeOnMainThread(Layer!.SetNeedsDisplay);
-			Element.Points.CollectionChanged += OnPointsCollectionChanged;
+			Element.Lines.CollectionChanged += OnLinesCollectionChanged;
 		}
 
 		public override void MouseUp(NSEvent theEvent)
 		{
-			UpdatePath();
-			if (Element.Points.Count > 0)
+			if (currentLine != null)
 			{
-				if (Element.DrawingCompletedCommand?.CanExecute(null) ?? false)
-					Element.DrawingCompletedCommand.Execute(Element.Points);
+				UpdatePath(currentLine);
+				Element.Lines.Add(currentLine);
+				Element.OnDrawingLineCompleted(currentLine);
 			}
 
 			if (Element.ClearOnFinish)
-				Element.Points.Clear();
+				Element.Lines.Clear();
 		}
 
 		public override void MouseDragged(NSEvent theEvent)
 		{
 			var currentPoint = theEvent.LocationInWindow;
 			AddPointToPath(currentPoint);
+			currentLine?.Points.Add(currentPoint.ToPoint());
 			InvokeOnMainThread(Layer!.SetNeedsDisplay);
 		}
 
@@ -83,56 +98,48 @@ public override void DrawRect(CGRect dirtyRect)
 			currentPath.Stroke();
 		}
 
-		void AddPointToPath(CGPoint currentPoint)
-		{
-			currentPath.LineTo(currentPoint);
-			Element.Points.CollectionChanged -= OnPointsCollectionChanged;
-			var point = currentPoint.ToPoint();
-			Element.Points.Add(point);
-			Element.Points.CollectionChanged += OnPointsCollectionChanged;
-		}
+		void AddPointToPath(CGPoint currentPoint) => currentPath.LineTo(currentPoint);
 
 		void LoadPoints()
 		{
-			var stylusPoints = Element.Points.Select(point => new CGPoint(point.X, point.Y)).ToList();
 			currentPath.RemoveAllPoints();
-			if (stylusPoints.Count > 0)
+			foreach (var line in Element.Lines)
 			{
-				previousPoint = stylusPoints[0];
-				currentPath.MoveTo(previousPoint);
-				foreach (var point in stylusPoints)
-					AddPointToPath(point);
-
-				UpdatePath();
+				UpdatePath(line);
+				var stylusPoints = line.Points.Select(point => new CGPoint(point.X, point.Y)).ToList();
+				if (stylusPoints.Count > 0)
+				{
+					previousPoint = stylusPoints[0];
+					currentPath.MoveTo(previousPoint);
+					foreach (var point in stylusPoints)
+						AddPointToPath(point);
+				}
 			}
 		}
 
-		void UpdatePath()
+		void UpdatePath(Line line)
 		{
-			Element.Points.CollectionChanged -= OnPointsCollectionChanged;
-			var smoothedPoints = Element.EnableSmoothedPath
-				? SmoothedPathWithGranularity(Element.Points, Element.Granularity, ref currentPath)
-				: new ObservableCollection<Point>(Element.Points);
+			Element.Lines.CollectionChanged -= OnLinesCollectionChanged;
 
-			InvokeOnMainThread(Layer!.SetNeedsDisplay);
-			Element.Points.Clear();
+			var smoothedPoints = line.EnableSmoothedPath
+			? SmoothedPathWithGranularity(line.Points, line.Granularity)
+			: new ObservableCollection<Point>(line.Points);
+
+			line.Points.Clear();
 
 			foreach (var point in smoothedPoints)
-				Element.Points.Add(point);
+				line.Points.Add(point);
 
-			Element.Points.CollectionChanged += OnPointsCollectionChanged;
+			Element.Lines.CollectionChanged += OnLinesCollectionChanged;
 		}
 
 		ObservableCollection<Point> SmoothedPathWithGranularity(ObservableCollection<Point> currentPoints,
-			int granularity,
-			ref NSBezierPath smoothedPath)
+			int granularity)
 		{
 			// not enough points to smooth effectively, so return the original path and points.
 			if (currentPoints.Count < granularity + 2)
 				return new ObservableCollection<Point>(currentPoints);
 
-			// create a new bezier path to hold the smoothed path.
-			smoothedPath.RemoveAllPoints();
 			var smoothedPoints = new ObservableCollection<Point>();
 
 			// duplicate the first and last points as control points.
@@ -140,7 +147,6 @@ ObservableCollection<Point> SmoothedPathWithGranularity(ObservableCollection<Poi
 			currentPoints.Add(currentPoints[^1]);
 
 			// add the first point
-			smoothedPath.MoveTo(currentPoints[0].X, currentPoints[0].Y);
 			smoothedPoints.Add(currentPoints[0]);
 
 			var currentPointsCount = currentPoints.Count;
@@ -160,18 +166,15 @@ ObservableCollection<Point> SmoothedPathWithGranularity(ObservableCollection<Poi
 
 					// intermediate point
 					var mid = GetIntermediatePoint(p0, p1, p2, p3, t, tt, ttt);
-					smoothedPath.LineTo(mid.X, mid.Y);
 					smoothedPoints.Add(mid);
 				}
 
 				// add p2
-				smoothedPath.LineTo(p2.X, p2.Y);
 				smoothedPoints.Add(p2);
 			}
 
 			// add the last point
 			var last = currentPoints[^1];
-			smoothedPath.LineTo(last.X, last.Y);
 			smoothedPoints.Add(last);
 			return smoothedPoints;
 		}
@@ -200,7 +203,7 @@ protected override void Dispose(bool disposing)
 			{
 				currentPath.Dispose();
 				if (Element != null)
-					Element.Points.CollectionChanged -= OnPointsCollectionChanged;
+					Element.Lines.CollectionChanged -= OnLinesCollectionChanged;
 			}
 
 			disposed = true;
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.tizen.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.tizen.cs
index 0b49435dd..9acbeb6d0 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.tizen.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.tizen.cs
@@ -12,9 +12,13 @@
 
 namespace Xamarin.CommunityToolkit.UI.Views
 {
+	/// <summary>
+	/// Tizen renderer for <see cref="DrawingViewRenderer"/>
+	/// </summary>
 	public class DrawingViewRenderer : ViewRenderer<DrawingView, SKCanvasView>
 	{
 		SKCanvasView? canvasView;
+		Line? currentLine;
 		bool isDrawing;
 		bool disposed;
 
@@ -28,7 +32,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
 					BackgroundColor = Element.BackgroundColor.ToNative()
 				};
 				canvasView.Show();
-				Element.Points.CollectionChanged += OnPointsCollectionChanged;
+				Element.Lines.CollectionChanged += OnLinesCollectionChanged;
 				SetNativeControl(canvasView);
 			}
 
@@ -52,7 +56,7 @@ protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
 		protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
 		{
 			base.OnElementPropertyChanged(sender, e);
-			if (e.PropertyName == DrawingView.PointsProperty.PropertyName)
+			if (e.PropertyName == DrawingView.LinesProperty.PropertyName)
 			{
 				canvasView!.EvasCanvas.DeleteEventAction(EvasObjectCallbackType.MouseUp, MouseUp);
 				LoadPoints();
@@ -60,14 +64,14 @@ protected override void OnElementPropertyChanged(object sender, PropertyChangedE
 			}
 		}
 
-		void OnPointsCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => LoadPoints();
+		void OnLinesCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => LoadPoints();
 
 		void MouseMove()
 		{
 			if (isDrawing)
 			{
 				var point = canvasView!.EvasCanvas.Pointer;
-				Element.Points.Add(new Point(point.X, point.Y));
+				currentLine!.Points.Add(new Point(point.X, point.Y));
 				canvasView.Invalidate();
 			}
 		}
@@ -79,7 +83,9 @@ void MouseDown()
 			if (Element == null)
 				return;
 
-			Clear();
+			if (!Element.MultiLineMode)
+				Clear();
+
 			isDrawing = true;
 		}
 
@@ -90,10 +96,10 @@ void MouseUp()
 
 			isDrawing = false;
 
-			if (Element.Points.Count > 0)
+			if (currentLine != null)
 			{
-				if (Element.DrawingCompletedCommand?.CanExecute(null) ?? false)
-					Element.DrawingCompletedCommand.Execute(Element.Points);
+				Element.Lines.Add(currentLine);
+				Element.OnDrawingLineCompleted(currentLine);
 			}
 
 			if (Element.ClearOnFinish)
@@ -111,25 +117,28 @@ void LoadPoints()
 		void DrawPath(SKCanvas canvas)
 		{
 			canvas.Clear(SKColor.Empty);
-			if (Element.Points.Count == 0)
+			if (Element.Lines.Count == 0)
 				return;
 
-			using var strokePaint = new SKPaint
+			foreach (var line in Element.Lines)
 			{
-				Style = SKPaintStyle.Stroke,
-				Color = Element.LineColor.ToNative().ToSKColor(),
-				StrokeWidth = Element.LineWidth,
-				IsAntialias = true
-			};
+				using var strokePaint = new SKPaint
+				{
+					Style = SKPaintStyle.Stroke,
+					Color = line.LineColor.ToNative().ToSKColor(),
+					StrokeWidth = line.LineWidth,
+					IsAntialias = true
+				};
 
-			var skPoints = Element.Points.Select(p => new SKPoint((float)p.X, (float)p.Y)).ToArray();
-			using var path = new SKPath();
-			path.MoveTo(skPoints[0]);
+				var skPoints = line.Points.Select(p => new SKPoint((float)p.X, (float)p.Y)).ToArray();
+				using var path = new SKPath();
+				path.MoveTo(skPoints[0]);
 
-			foreach (var point in skPoints)
-				path.LineTo(point);
+				foreach (var point in skPoints)
+					path.LineTo(point);
 
-			canvas.DrawPath(path, strokePaint);
+				canvas.DrawPath(path, strokePaint);
+			}
 		}
 
 		protected override void Dispose(bool disposing)
@@ -140,7 +149,7 @@ protected override void Dispose(bool disposing)
 
 			if (Element != null)
 			{
-				Element.Points.CollectionChanged -= OnPointsCollectionChanged;
+				Element.Lines.CollectionChanged -= OnLinesCollectionChanged;
 				canvasView!.EvasCanvas.DeleteEventAction(EvasObjectCallbackType.MouseDown, MouseDown);
 				canvasView.EvasCanvas.DeleteEventAction(EvasObjectCallbackType.MouseUp, MouseUp);
 				canvasView.EvasCanvas.DeleteEventAction(EvasObjectCallbackType.MouseMove, MouseMove);
@@ -152,7 +161,12 @@ protected override void Dispose(bool disposing)
 
 		void Clear()
 		{
-			Element.Points.Clear();
+			currentLine = new Line()
+			{
+				Points = new System.Collections.ObjectModel.ObservableCollection<Point>()
+			};
+
+			Element.Lines.Clear();
 			canvasView?.Invalidate();
 		}
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.uwp.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.uwp.cs
index b3a42f206..5f44c21cd 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.uwp.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Renderer/DrawingViewRenderer.uwp.cs
@@ -1,4 +1,7 @@
-using System.ComponentModel;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
 using System.Linq;
 using Windows.UI.Core;
 using Windows.UI.Input.Inking;
@@ -12,10 +15,12 @@
 
 namespace Xamarin.CommunityToolkit.UI.Views
 {
+	/// <summary>
+	/// UWP renderer for <see cref="Xamarin.CommunityToolkit.UI.Views.DrawingViewRenderer"/>
+	/// </summary>
 	public class DrawingViewRenderer : ViewRenderer<DrawingView, InkCanvas>
 	{
 		InkCanvas? canvas;
-		InkDrawingAttributes? inkDrawingAttributes;
 		bool disposed;
 
 		protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
@@ -24,83 +29,116 @@ protected override void OnElementChanged(ElementChangedEventArgs<DrawingView> e)
 			if (Control == null && Element != null)
 			{
 				canvas = new InkCanvas();
-				inkDrawingAttributes = new InkDrawingAttributes
+				var inkDrawingAttributes = new InkDrawingAttributes
 				{
-					Color = Element.LineColor.ToWindowsColor(),
-					Size = new Size(Element.LineWidth, Element.LineWidth)
+					Color = Element.DefaultLineColor.ToWindowsColor(),
+					Size = new Size(Element.DefaultLineWidth, Element.DefaultLineWidth)
 				};
 				canvas.InkPresenter.UpdateDefaultDrawingAttributes(inkDrawingAttributes);
 				canvas.InkPresenter.InputDeviceTypes = CoreInputDeviceTypes.Mouse |
-													   CoreInputDeviceTypes.Pen |
-													   CoreInputDeviceTypes.Touch;
-				Element.Points.CollectionChanged += OnPointsCollectionChanged;
+				                                       CoreInputDeviceTypes.Pen |
+				                                       CoreInputDeviceTypes.Touch;
+
+				Element.Lines.CollectionChanged += OnCollectionChanged;
 				SetNativeControl(canvas);
+
+				canvas!.InkPresenter.StrokeInput.StrokeStarted += StrokeInput_StrokeStarted;
+				canvas.InkPresenter.StrokesCollected += OnInkPresenterStrokesCollected;
 			}
 
 			if (e.OldElement != null)
 			{
 				canvas!.InkPresenter.StrokeInput.StrokeStarted -= StrokeInput_StrokeStarted;
 				canvas.InkPresenter.StrokesCollected -= OnInkPresenterStrokesCollected;
-			}
-
-			if (e.NewElement != null)
-			{
-				canvas!.InkPresenter.StrokeInput.StrokeStarted += StrokeInput_StrokeStarted;
-				canvas.InkPresenter.StrokesCollected += OnInkPresenterStrokesCollected;
+				Element!.Lines.CollectionChanged -= OnCollectionChanged;
 			}
 		}
 
-		void OnPointsCollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) => LoadPoints();
-
 		protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
 		{
 			base.OnElementPropertyChanged(sender, e);
-			if (e.PropertyName == DrawingView.PointsProperty.PropertyName)
+			if (e.PropertyName == DrawingView.LinesProperty.PropertyName)
 			{
 				canvas!.InkPresenter.StrokesCollected -= OnInkPresenterStrokesCollected;
 				canvas.InkPresenter.StrokeContainer.Clear();
-				LoadPoints();
+				LoadLines();
 				canvas.InkPresenter.StrokesCollected += OnInkPresenterStrokesCollected;
 			}
 		}
 
-		void OnInkPresenterStrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
+		void OnInkPresenterStrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs e)
 		{
-			var points = args.Strokes.First()
-							 .GetInkPoints()
-							 .Select(point => new Point(point.Position.X, point.Position.Y))
-							 .ToList();
-			var elementPoints = Element.Points;
+			Element.Lines.CollectionChanged -= OnCollectionChanged;
+			if (e.Strokes.Count > 0)
+			{
+				if (!Element.MultiLineMode)
+				{
+					Element.Lines.Clear();
+				}
 
-			elementPoints.Clear();
+				var lines = Element.MultiLineMode ? e.Strokes : new List<InkStroke>() {e.Strokes.First()};
 
-			foreach (var point in points)
-				elementPoints.Add(point);
+				foreach (var line in lines)
+				{
+					var points = line.GetInkPoints().Select(point => new Point(point.Position.X, point.Position.Y));
+					Element.Lines.Add(new Line()
+					{
+						Points = new ObservableCollection<Point>(points),
+						LineColor = Color.FromRgba(line.DrawingAttributes.Color.R, line.DrawingAttributes.Color.G,
+							line.DrawingAttributes.Color.B, line.DrawingAttributes.Color.A),
+						LineWidth = (float) line.DrawingAttributes.Size.Width
+					});
+				}
+
+				if (Element.Lines.Count > 0)
+				{
+					var lastLine = Element.Lines.Last();
+					Element.OnDrawingLineCompleted(lastLine);
+				}
 
-			if (elementPoints.Count > 0)
-			{
-				if (Element.DrawingCompletedCommand?.CanExecute(null) ?? false)
-					Element.DrawingCompletedCommand.Execute(elementPoints);
+				if (Element.ClearOnFinish)
+				{
+					Element.Lines.CollectionChanged -= OnCollectionChanged;
+					Clear(true);
+					Element.Lines.CollectionChanged += OnCollectionChanged;
+				}
 			}
 
-			if (Element.ClearOnFinish)
-				Clear();
+			Element.Lines.CollectionChanged += OnCollectionChanged;
 		}
 
-		void StrokeInput_StrokeStarted(InkStrokeInput sender, PointerEventArgs args)
+		void StrokeInput_StrokeStarted(InkStrokeInput sender, PointerEventArgs args) => Clear();
+
+		void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs args)
 		{
-			Clear();
+			canvas!.InkPresenter.StrokesCollected -= OnInkPresenterStrokesCollected;
+			canvas.InkPresenter.StrokeContainer.Clear();
+			LoadLines();
+			canvas.InkPresenter.StrokesCollected += OnInkPresenterStrokesCollected;
 		}
 
-		void LoadPoints()
+		void LoadLines()
 		{
-			var stylusPoints = Element?.Points?.Select(point => new Windows.Foundation.Point(point.X, point.Y)).ToList();
-			if (stylusPoints is { Count: > 0 })
+			var lines = Element.MultiLineMode
+				? Element.Lines
+				: Element.Lines.Any()
+					? new ObservableCollection<Line> {Element.Lines.LastOrDefault()}
+					: new ObservableCollection<Line>();
+			foreach (var line in lines)
 			{
-				var strokeBuilder = new InkStrokeBuilder();
-				strokeBuilder.SetDefaultDrawingAttributes(inkDrawingAttributes);
-				var stroke = strokeBuilder.CreateStroke(stylusPoints);
-				canvas!.InkPresenter.StrokeContainer.AddStroke(stroke);
+				var stylusPoints = line.Points.Select(point => new Windows.Foundation.Point(point.X, point.Y)).ToList();
+				if (stylusPoints is { Count: > 0 })
+				{
+					var strokeBuilder = new InkStrokeBuilder();
+					var inkDrawingAttributes = new InkDrawingAttributes
+					{
+						Color = line.LineColor.ToWindowsColor(),
+						Size = new Size(line.LineWidth, line.LineWidth)
+					};
+					strokeBuilder.SetDefaultDrawingAttributes(inkDrawingAttributes);
+					var stroke = strokeBuilder.CreateStroke(stylusPoints);
+					canvas!.InkPresenter.StrokeContainer.AddStroke(stroke);
+				}
 			}
 		}
 
@@ -113,7 +151,7 @@ protected override void Dispose(bool disposing)
 
 			if (Element != null)
 			{
-				Element.Points.CollectionChanged -= OnPointsCollectionChanged;
+				Element.Lines.CollectionChanged -= OnCollectionChanged;
 				canvas!.InkPresenter.StrokeInput.StrokeStarted -= StrokeInput_StrokeStarted;
 				canvas.InkPresenter.StrokesCollected -= OnInkPresenterStrokesCollected;
 			}
@@ -121,10 +159,13 @@ protected override void Dispose(bool disposing)
 			base.Dispose(disposing);
 		}
 
-		void Clear()
+		void Clear(bool force = false)
 		{
-			canvas!.InkPresenter.StrokeContainer.Clear();
-			Element.Points.Clear();
+			if (!Element.MultiLineMode || force)
+			{
+				canvas!.InkPresenter.StrokeContainer.Clear();
+				Element.Lines.Clear();
+			}
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.android.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.android.cs
index af3edb036..da47ba6cc 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.android.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.android.cs
@@ -13,6 +13,32 @@ namespace Xamarin.CommunityToolkit.UI.Views
 {
 	static class DrawingViewService
 	{
+		public static Stream GetImageStream(IList<Line>? lines,
+			Size imageSize,
+			Color backgroundColor)
+		{
+			if (lines == null)
+			{
+				return Stream.Null;
+			}
+
+			var image = GetImageInternal(lines, backgroundColor);
+			if (image == null)
+				return Stream.Null;
+
+			using var resizedImage = MaxResizeImage(image, (float)imageSize.Width, (float)imageSize.Height);
+			var stream = new MemoryStream();
+			var compressResult = resizedImage.Compress(Bitmap.CompressFormat.Jpeg, 100, stream);
+
+			resizedImage.Recycle();
+
+			if (!compressResult)
+				return Stream.Null;
+
+			stream.Position = 0;
+			return stream;
+		}
+
 		/// <summary>
 		/// Get image stream from points
 		/// </summary>
@@ -22,7 +48,7 @@ static class DrawingViewService
 		/// <param name="strokeColor">Line color</param>
 		/// <param name="backgroundColor">Image background color</param>
 		/// <returns>Image stream</returns>
-		public static Stream GetImageStream(IList<Point> points,
+		public static Stream GetImageStream(IList<Point>? points,
 			Size imageSize,
 			float lineWidth,
 			Color strokeColor,
@@ -61,7 +87,7 @@ public static Stream GetImageStream(IList<Point> points,
 			if (drawingWidth < minSize || drawingHeight < minSize)
 				return null;
 
-			var image = Bitmap.CreateBitmap((int)drawingWidth, (int)drawingHeight, Bitmap.Config.Argb8888!)!;
+			var image = Bitmap.CreateBitmap((int)drawingWidth, (int)drawingHeight, Bitmap.Config.Argb8888!) !;
 			using var canvas = new Canvas(image);
 
 			// background
@@ -91,6 +117,50 @@ public static Stream GetImageStream(IList<Point> points,
 			return image;
 		}
 
+		static Bitmap? GetImageInternal(IList<Line> lines,
+			Color backgroundColor)
+		{
+			var points = lines.SelectMany(x => x.Points).ToList();
+			var minPointX = points.Min(p => p.X);
+			var minPointY = points.Min(p => p.Y);
+			var drawingWidth = points.Max(p => p.X) - minPointX;
+			var drawingHeight = points.Max(p => p.Y) - minPointY;
+			const int minSize = 1;
+			if (drawingWidth < minSize || drawingHeight < minSize)
+				return null;
+
+			var image = Bitmap.CreateBitmap((int)drawingWidth, (int)drawingHeight, Bitmap.Config.Argb8888!) !;
+			using var canvas = new Canvas(image);
+
+			// background
+			canvas.DrawColor(backgroundColor.ToAndroid());
+
+			foreach (var line in lines)
+			{
+				using var paint = new Paint
+				{
+					Color = line.LineColor.ToAndroid(),
+					StrokeWidth = line.LineWidth,
+					StrokeJoin = Paint.Join.Round,
+					StrokeCap = Paint.Cap.Round,
+					AntiAlias = true
+				};
+
+				paint.SetStyle(Paint.Style.Stroke);
+
+				var pointsCount = line.Points.Count;
+				for (var i = 0; i < pointsCount - 1; i++)
+				{
+					var p1 = line.Points.ElementAt(i);
+					var p2 = line.Points.ElementAt(i + 1);
+					canvas.DrawLine((float)(p1.X - minPointX), (float)(p1.Y - minPointY), (float)(p2.X - minPointX),
+						(float)(p2.Y - minPointY), paint);
+				}
+			}
+
+			return image;
+		}
+
 		static Bitmap MaxResizeImage(Bitmap sourceImage, float maxWidth, float maxHeight)
 		{
 			var sourceSize = new Size(sourceImage.Width, sourceImage.Height);
@@ -100,7 +170,7 @@ static Bitmap MaxResizeImage(Bitmap sourceImage, float maxWidth, float maxHeight
 
 			var width = maxResizeFactor * sourceSize.Width;
 			var height = maxResizeFactor * sourceSize.Height;
-			return Bitmap.CreateScaledBitmap(sourceImage, (int)width, (int)height, false)!;
+			return Bitmap.CreateScaledBitmap(sourceImage, (int)width, (int)height, false) !;
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.gtk.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.gtk.cs
index d01250160..e1ad26112 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.gtk.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.gtk.cs
@@ -14,6 +14,29 @@ namespace Xamarin.CommunityToolkit.UI.Views
 {
 	static class DrawingViewService
 	{
+		public static Stream GetImageStream(IList<Line>? lines,
+			Size imageSize,
+			Color backgroundColor)
+		{
+			if (lines == null)
+			{
+				return Stream.Null;
+			}
+
+			var image = GetImageInternal(lines, backgroundColor);
+			if (image == null)
+				return Stream.Null;
+
+			var resizedImage = MaxResizeImage(image, (float)imageSize.Width, (float)imageSize.Height);
+			using (resizedImage)
+			{
+				var stream = new MemoryStream();
+				resizedImage.Save(stream, ImageFormat.Jpeg);
+				stream.Position = 0;
+				return stream;
+			}
+		}
+
 		/// <summary>
 		/// Get image stream from points
 		/// </summary>
@@ -23,7 +46,7 @@ static class DrawingViewService
 		/// <param name="strokeColor">Line color</param>
 		/// <param name="backgroundColor">Image background color</param>
 		/// <returns>Image stream</returns>
-		public static Stream GetImageStream(IList<Point> points,
+		public static Stream GetImageStream(IList<Point>? points,
 			Size imageSize,
 			float lineWidth,
 			Color strokeColor,
@@ -123,5 +146,45 @@ static Image MaxResizeImage(Image sourceImage, float maxWidth, float maxHeight)
 
 			return bm;
 		}
+
+		static Bitmap? GetImageInternal(IList<Line> lines,
+			Color backgroundColor)
+		{
+			var points = lines.SelectMany(x => x.Points).ToList();
+			var minPointX = points.Min(p => p.X);
+			var minPointY = points.Min(p => p.Y);
+			var drawingWidth = points.Max(p => p.X) - minPointX;
+			var drawingHeight = points.Max(p => p.Y) - minPointY;
+			const int minSize = 1;
+			if (drawingWidth < minSize || drawingHeight < minSize)
+				return null;
+
+			var bm = new Bitmap((int)drawingWidth, (int)drawingHeight);
+			using (var gr = Graphics.FromImage(bm))
+			{
+				var drawingBackgroundColor = XamarinColorToDrawingColor(backgroundColor);
+				gr.Clear(drawingBackgroundColor);
+
+				foreach (var line in lines)
+				{
+					using (var pen = new Pen(XamarinColorToDrawingColor(line.LineColor), line.LineWidth))
+					{
+						var path = new GraphicsPath();
+						var pointsCount = line.Points.Count;
+						for (var i = 0; i < pointsCount - 1; i++)
+						{
+							var p1 = XamarinPointToDrawingPoint(line.Points.ElementAt(i));
+							var p2 = XamarinPointToDrawingPoint(line.Points.ElementAt(i + 1));
+							path.AddLine(p1.X - (float)minPointX, p1.Y - (float)minPointY, p2.X - (float)minPointX,
+										 p2.Y - (float)minPointY);
+						}
+
+						gr.DrawPath(pen, path);
+					}
+				}
+			}
+
+			return bm;
+		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.ios.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.ios.cs
index 1493d2d0b..573559be5 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.ios.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.ios.cs
@@ -11,6 +11,25 @@ namespace Xamarin.CommunityToolkit.UI.Views
 {
 	static class DrawingViewService
 	{
+		public static Stream GetImageStream(IList<Line>? lines,
+			Size imageSize,
+			Color backgroundColor)
+		{
+			if (lines == null)
+			{
+				return Stream.Null;
+			}
+
+			var image = GetImageInternal(lines, backgroundColor);
+			if (image == null)
+			{
+				return Stream.Null;
+			}
+
+			var resizedImage = MaxResizeImage(image, (float)imageSize.Width, (float)imageSize.Height);
+			return resizedImage.AsJPEG().AsStream();
+		}
+
 		/// <summary>
 		/// Get image stream from points
 		/// </summary>
@@ -20,7 +39,7 @@ static class DrawingViewService
 		/// <param name="strokeColor">Line color</param>
 		/// <param name="backgroundColor">Image background color</param>
 		/// <returns>Image stream</returns>
-		public static Stream GetImageStream(IList<Point> points,
+		public static Stream GetImageStream(IList<Point>? points,
 			Size imageSize,
 			float lineWidth,
 			Color strokeColor,
@@ -81,6 +100,49 @@ public static Stream GetImageStream(IList<Point> points,
 			return image;
 		}
 
+		static UIImage? GetImageInternal(IList<Line> lines,
+			Color backgroundColor)
+		{
+			var points = lines.SelectMany(x => x.Points).ToList();
+			var minPointX = points.Min(p => p.X);
+			var minPointY = points.Min(p => p.Y);
+			var drawingWidth = points.Max(p => p.X) - minPointX;
+			var drawingHeight = points.Max(p => p.Y) - minPointY;
+			const int minSize = 1;
+			if (drawingWidth < minSize || drawingHeight < minSize)
+			{
+				return null;
+			}
+
+			var imageSize = new CGSize(drawingWidth, drawingHeight);
+			UIGraphics.BeginImageContextWithOptions(imageSize, false, 1);
+
+			var context = UIGraphics.GetCurrentContext();
+			if (context == null)
+			{
+				throw new Exception("Current Context is null");
+			}
+
+			context.SetFillColor(backgroundColor.ToCGColor());
+			context.FillRect(new CGRect(CGPoint.Empty, imageSize));
+			foreach (var line in lines)
+			{
+				context.SetStrokeColor(line.LineColor.ToCGColor());
+				context.SetLineWidth(line.LineWidth);
+				context.SetLineCap(CGLineCap.Round);
+				context.SetLineJoin(CGLineJoin.Round);
+
+				var startPoint = line.Points.First();
+				context.MoveTo((float)startPoint.X, (float)startPoint.Y);
+				context.AddLines(line.Points.Select(p => new CGPoint(p.X - minPointX, p.Y - minPointY)).ToArray());
+			}
+
+			context.StrokePath();
+			var image = UIGraphics.GetImageFromCurrentImageContext();
+			UIGraphics.EndImageContext();
+			return image;
+		}
+
 		static UIImage MaxResizeImage(UIImage sourceImage, float maxWidth, float maxHeight)
 		{
 			var sourceSize = sourceImage.Size;
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.macos.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.macos.cs
index 4bfa2c9a3..6a6213538 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.macos.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.macos.cs
@@ -11,6 +11,24 @@ namespace Xamarin.CommunityToolkit.UI.Views
 {
 	static class DrawingViewService
 	{
+		public static Stream GetImageStream(IList<Line>? lines,
+			Size imageSize,
+			Color backgroundColor)
+		{
+			if (lines == null)
+			{
+				return Stream.Null;
+			}
+
+			var image = GetImageInternal(lines, backgroundColor);
+			if (image is null)
+			{
+				return Stream.Null;
+			}
+
+			return image.AsTiff().AsStream();
+		}
+
 		/// <summary>
 		/// Get image stream from points
 		/// </summary>
@@ -20,13 +38,13 @@ static class DrawingViewService
 		/// <param name="strokeColor">Line color</param>
 		/// <param name="backgroundColor">Image background color</param>
 		/// <returns>Image stream</returns>
-		public static Stream GetImageStream(IList<Point> points,
+		public static Stream GetImageStream(IList<Point>? points,
 			Size imageSize,
 			float lineWidth,
 			Color strokeColor,
 			Color backgroundColor)
 		{
-			if (points.Count < 2)
+			if (points == null || points.Count < 2)
 			{
 				return Stream.Null;
 			}
@@ -72,7 +90,48 @@ public static Stream GetImageStream(IList<Point> points,
 			context.AddLines(points.Select(p => new CGPoint(p.X - minPointX, p.Y - minPointY)).ToArray());
 			context.StrokePath();
 			using var cgImage = context.ToImage();
-			NSImage image = new(cgImage, imageSize);
+			NSImage image = new (cgImage, imageSize);
+
+			return image;
+		}
+
+		static NSImage? GetImageInternal(IList<Line> lines,
+			Color backgroundColor)
+		{
+			var points = lines.SelectMany(x => x.Points).ToList();
+			var minPointX = points.Min(p => p.X);
+			var minPointY = points.Min(p => p.Y);
+			var drawingWidth = points.Max(p => p.X) - minPointX;
+			var drawingHeight = points.Max(p => p.Y) - minPointY;
+			const int minSize = 1;
+			if (drawingWidth < minSize || drawingHeight < minSize)
+				return null;
+
+			var imageSize = new CGSize(drawingWidth, drawingHeight);
+
+			using var context = new CGBitmapContext(IntPtr.Zero, (nint)drawingWidth, (nint)drawingHeight, 8,
+				(nint)drawingWidth * 4,
+				NSColorSpace.GenericRGBColorSpace.ColorSpace,
+				CGImageAlphaInfo.PremultipliedFirst);
+			context.SetFillColor(backgroundColor.ToCGColor());
+			context.FillRect(new CGRect(CGPoint.Empty, imageSize));
+
+			foreach (var line in lines)
+			{
+				context.SetStrokeColor(line.LineColor.ToCGColor());
+				context.SetLineWidth(line.LineWidth);
+				context.SetLineCap(CGLineCap.Round);
+				context.SetLineJoin(CGLineJoin.Round);
+
+				var startPoint = line.Points.First();
+				context.MoveTo((float)startPoint.X, (float)startPoint.Y);
+				context.AddLines(line.Points.Select(p => new CGPoint(p.X - minPointX, p.Y - minPointY)).ToArray());
+			}
+
+			context.StrokePath();
+
+			using var cgImage = context.ToImage();
+			NSImage image = new (cgImage, imageSize);
 
 			return image;
 		}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.shared.cs
index bb4b81500..f199f1e1b 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.shared.cs
@@ -24,6 +24,18 @@ public static Stream GetImageStream(IList<Point> points,
 			Color strokeColor,
 			Color backgroundColor) =>
 			Stream.Null;
+
+		/// <summary>
+		/// Get image stream from lines
+		/// </summary>
+		/// <param name="points">Drawing lines</param>
+		/// <param name="imageSize">Image size</param>
+		/// <param name="backgroundColor">Image background color</param>
+		/// <returns>Image stream</returns>
+		public static Stream GetImageStream(IList<Line> lines,
+			Size imageSize,
+			Color backgroundColor) =>
+			Stream.Null;
 	}
 #endif
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.tizen.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.tizen.cs
index 4bfc879fa..01b3b5341 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.tizen.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.tizen.cs
@@ -11,6 +11,30 @@ namespace Xamarin.CommunityToolkit.UI.Views
 {
 	static class DrawingViewService
 	{
+		public static Stream GetImageStream(IList<Line>? lines,
+			Size imageSize,
+			Color backgroundColor)
+		{
+			if (lines == null)
+			{
+				return Stream.Null;
+			}
+
+			var image = GetImageInternal(lines, backgroundColor);
+			if (image == null)
+			{
+				return Stream.Null;
+			}
+
+			var resizedImage = MaxResizeImage(image, (float)imageSize.Width, (float)imageSize.Height);
+			using (resizedImage)
+			{
+				var stream = resizedImage.Encode(SKEncodedImageFormat.Jpeg, 100).AsStream();
+				stream.Position = 0;
+				return stream;
+			}
+		}
+
 		/// <summary>
 		/// Get image stream from points
 		/// </summary>
@@ -20,7 +44,7 @@ static class DrawingViewService
 		/// <param name="strokeColor">Line color</param>
 		/// <param name="backgroundColor">Image background color</param>
 		/// <returns>Image stream</returns>
-		public static Stream GetImageStream(IList<Point> points,
+		public static Stream GetImageStream(IList<Point>? points,
 			Size imageSize,
 			float lineWidth,
 			Color strokeColor,
@@ -110,5 +134,47 @@ static SKBitmap MaxResizeImage(SKImage sourceImage, float maxWidth, float maxHei
 
 			return bm;
 		}
+
+		static SKImage? GetImageInternal(IList<Line> lines,
+			Color backgroundColor)
+		{
+			var points = lines.SelectMany(x => x.Points).ToList();
+			var minPointX = points.Min(p => p.X);
+			var minPointY = points.Min(p => p.Y);
+			var drawingWidth = points.Max(p => p.X) - minPointX;
+			var drawingHeight = points.Max(p => p.Y) - minPointY;
+			const int minSize = 1;
+			if (drawingWidth < minSize || drawingHeight < minSize)
+				return null;
+
+			var bm = new SKBitmap((int)drawingWidth, (int)drawingHeight);
+			using (var gr = new SKCanvas(bm))
+			{
+				var drawingBackgroundColor = XamarinColorToDrawingColor(backgroundColor);
+				gr.Clear(drawingBackgroundColor);
+
+				foreach (var line in lines)
+				{
+					using (var pen = new SKPaint
+					{
+						Color = XamarinColorToDrawingColor(line.LineColor),
+						StrokeWidth = line.LineWidth
+					})
+					{
+						var pointsCount = line.Points.Count;
+						for (var i = 0; i < pointsCount - 1; i++)
+						{
+							var p1 = XamarinPointToDrawingPoint(line.Points.ElementAt(i));
+							var p2 = XamarinPointToDrawingPoint(line.Points.ElementAt(i + 1));
+
+							gr.DrawLine(p1.X - (float)minPointX, p1.Y - (float)minPointY, p2.X - (float)minPointX,
+										p2.Y - (float)minPointY, pen);
+						}
+					}
+				}
+			}
+
+			return SKImage.FromBitmap(bm);
+		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.uwp.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.uwp.cs
index 458989930..9f661a107 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.uwp.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.uwp.cs
@@ -12,6 +12,31 @@ namespace Xamarin.CommunityToolkit.UI.Views
 {
 	static class DrawingViewService
 	{
+		public static Stream GetImageStream(IList<Line>? lines,
+			Size imageSize,
+			Color backgroundColor)
+		{
+			if (lines == null)
+			{
+				return Stream.Null;
+			}
+
+			var image = GetImageInternal(lines, backgroundColor);
+			if (image == null)
+				return Stream.Null;
+
+			using (image)
+			{
+				var fileStream = new InMemoryRandomAccessStream();
+				image.SaveAsync(fileStream, CanvasBitmapFileFormat.Jpeg).GetAwaiter().GetResult();
+
+				var stream = fileStream.AsStream();
+				stream.Position = 0;
+
+				return stream;
+			}
+		}
+
 		/// <summary>
 		/// Get image stream from points
 		/// </summary>
@@ -21,7 +46,7 @@ static class DrawingViewService
 		/// <param name="strokeColor">Line color</param>
 		/// <param name="backgroundColor">Image background color</param>
 		/// <returns>Image stream</returns>
-		public static Stream GetImageStream(IList<Point> points,
+		public static Stream GetImageStream(IList<Point>? points,
 			Size imageSize,
 			float lineWidth,
 			Color strokeColor,
@@ -86,5 +111,42 @@ public static Stream GetImageStream(IList<Point> points,
 
 			return offscreen;
 		}
+
+		static CanvasRenderTarget? GetImageInternal(IList<Line> lines,
+			Color backgroundColor)
+		{
+			var points = lines.SelectMany(x => x.Points).ToList();
+			var minPointX = points.Min(p => p.X);
+			var minPointY = points.Min(p => p.Y);
+			var drawingWidth = points.Max(p => p.X) - minPointX;
+			var drawingHeight = points.Max(p => p.Y) - minPointY;
+			const int minSize = 1;
+			if (drawingWidth < minSize || drawingHeight < minSize)
+				return null;
+
+			var device = CanvasDevice.GetSharedDevice();
+			var offscreen = new CanvasRenderTarget(device, (int)drawingWidth, (int)drawingHeight, 96);
+
+			using var session = offscreen.CreateDrawingSession();
+			session.Clear(backgroundColor.ToWindowsColor());
+
+			foreach (var line in lines)
+			{
+				var strokeBuilder = new InkStrokeBuilder();
+				var inkDrawingAttributes = new InkDrawingAttributes
+				{
+					Color = line.LineColor.ToWindowsColor(),
+					Size = new Windows.Foundation.Size(line.LineWidth, line.LineWidth)
+				};
+				strokeBuilder.SetDefaultDrawingAttributes(inkDrawingAttributes);
+				var strokes = new[]
+				{
+					strokeBuilder.CreateStroke(line.Points.Select(p => new Windows.Foundation.Point(p.X - minPointX, p.Y - minPointY)))
+				};
+				session.DrawInk(strokes);
+			}
+
+			return offscreen;
+		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.wpf.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.wpf.cs
index 58275c9d0..ecd45d726 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.wpf.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/DrawingView/Service/DrawingViewService.wpf.cs
@@ -14,6 +14,31 @@ namespace Xamarin.CommunityToolkit.UI.Views
 {
 	static class DrawingViewService
 	{
+		public static Stream GetImageStream(IList<Line>? lines,
+			Size imageSize,
+			Color backgroundColor)
+		{
+			if (lines == null)
+			{
+				return Stream.Null;
+			}
+
+			var image = GetImageInternal(lines, backgroundColor);
+			if (image is null)
+			{
+				return Stream.Null;
+			}
+
+			var resizedImage = MaxResizeImage(image, (float)imageSize.Width, (float)imageSize.Height);
+			using (resizedImage)
+			{
+				var stream = new MemoryStream();
+				resizedImage.Save(stream, ImageFormat.Jpeg);
+				stream.Position = 0;
+				return stream;
+			}
+		}
+
 		/// <summary>
 		/// Get image stream from points
 		/// </summary>
@@ -23,13 +48,13 @@ static class DrawingViewService
 		/// <param name="strokeColor">Line color</param>
 		/// <param name="backgroundColor">Image background color</param>
 		/// <returns>Image stream</returns>
-		public static Stream GetImageStream(IList<Point> points,
+		public static Stream GetImageStream(IList<Point>? points,
 			Size imageSize,
 			float lineWidth,
 			Color strokeColor,
 			Color backgroundColor)
 		{
-			if (points.Count < 2)
+			if (points == null || points.Count < 2)
 			{
 				return Stream.Null;
 			}
@@ -111,5 +136,45 @@ static Image MaxResizeImage(Image sourceImage, float maxWidth, float maxHeight)
 
 			return bm;
 		}
+
+		static Bitmap? GetImageInternal(IList<Line> lines,
+			Color backgroundColor)
+		{
+			var points = lines.SelectMany(x => x.Points).ToList();
+			var minPointX = points.Min(p => p.X);
+			var minPointY = points.Min(p => p.Y);
+			var drawingWidth = points.Max(p => p.X) - minPointX;
+			var drawingHeight = points.Max(p => p.Y) - minPointY;
+			const int minSize = 1;
+			if (drawingWidth < minSize || drawingHeight < minSize)
+				return null;
+
+			var bm = new Bitmap((int)drawingWidth, (int)drawingHeight);
+			using (var gr = Graphics.FromImage(bm))
+			{
+				var drawingBackgroundColor = XamarinColorToDrawingColor(backgroundColor);
+				gr.Clear(drawingBackgroundColor);
+
+				foreach (var line in lines)
+				{
+					using (var pen = new Pen(XamarinColorToDrawingColor(line.LineColor), line.LineWidth))
+					{
+						var path = new GraphicsPath();
+						var pointsCount = line.Points.Count;
+						for (var i = 0; i < pointsCount - 1; i++)
+						{
+							var p1 = XamarinPointToDrawingPoint(line.Points.ElementAt(i));
+							var p2 = XamarinPointToDrawingPoint(line.Points.ElementAt(i + 1));
+							path.AddLine(p1.X - (float)minPointX, p1.Y - (float)minPointY, p2.X - (float)minPointX,
+										 p2.Y - (float)minPointY);
+						}
+
+						gr.DrawPath(pen, path);
+					}
+				}
+			}
+
+			return bm;
+		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/LazyView/LazyView.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/LazyView/LazyView.shared.cs
index 8d312f49c..1741e0de3 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/LazyView/LazyView.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/LazyView/LazyView.shared.cs
@@ -10,7 +10,7 @@ namespace Xamarin.CommunityToolkit.UI.Views
 	public class LazyView<TView> : BaseLazyView where TView : View, new()
 	{
 		/// <summary>
-		/// This method initialize your <see cref="LazyView{TView}"/>.
+		/// This method initializes your <see cref="LazyView{TView}"/>.
 		/// </summary>
 		/// <returns><see cref="ValueTask"/></returns>
 		public override ValueTask LoadViewAsync()
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/Snackbar/Options/ToastOptions.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/Snackbar/Options/ToastOptions.shared.cs
index 5ddfbdfb7..23dbdb119 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/Snackbar/Options/ToastOptions.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/Snackbar/Options/ToastOptions.shared.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using Xamarin.Forms;
 
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj b/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
index bad141a8f..325d82cb7 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
@@ -61,7 +61,7 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="**/*.shared.cs" />
-    <Compile Include="**/*.shared.*.cs" />
+    <Compile Include="**/*.shared.*.cs" />    
     <None Include="..\..\..\LICENSE" PackagePath="" Pack="true" />
     <None Include="..\..\..\assets\XamarinCommunityToolkit_128x128.png" PackagePath="icon.png" Pack="true" />
     <PackageReference Include="Xamarin.Forms" Version="5.0.0.2083" />
@@ -213,5 +213,6 @@
     <Compile Remove="build\*.cs" />
     <None Include="build\**\*.cs;build\**\*.targets" Pack="true" PackagePath="build" />
   </ItemGroup>
+  
   <Import Project="..\..\mdoc.targets" Condition=" '$(OS)' == 'Windows_NT' AND '$(GenerateApiDocs)' == 'true'" />
 </Project>