diff --git a/.gitignore b/.gitignore
index 20af7cd..3920243 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,4 @@ PCPalService/service_log.txt
 /PCPal/Configurator/obj
 /PCPal/Core/bin
 /PCPal/Core/obj
+/PCPal/Configurator/bin
diff --git a/PCPal/Configurator/AppShell.xaml b/PCPal/Configurator/AppShell.xaml
index ebb1483..41101e0 100644
--- a/PCPal/Configurator/AppShell.xaml
+++ b/PCPal/Configurator/AppShell.xaml
@@ -1,72 +1,77 @@
 <Shell xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
        xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
-       x:Class="PCPal.Configurator.AppShell">
-    
-    <Shell.ContentTemplate>
-        <Grid ColumnDefinitions="220,*">
-            <!-- Sidebar -->
-            <StackLayout Grid.Column="0" 
-                         Padding="10" 
-                         Spacing="10"
-                         BackgroundColor="{StaticResource Surface}">
+       xmlns:views="clr-namespace:PCPal.Configurator.Views"
+       x:Class="PCPal.Configurator.AppShell"
+       Shell.NavBarIsVisible="False"
+       Shell.FlyoutBehavior="Disabled">
 
-                <!-- App logo and title -->
-                <HorizontalStackLayout Spacing="10" Margin="0,10,0,20">
-                    <Image Source="app_icon.png" HeightRequest="32" WidthRequest="32" />
-                    <Label Text="PCPal" 
-                           FontSize="22" 
-                           FontAttributes="Bold" 
-                           TextColor="{StaticResource Primary}" 
-                           VerticalOptions="Center" />
-                </HorizontalStackLayout>
+    <ShellContent>
+        <ContentPage>
+            <Grid ColumnDefinitions="220,*">
+                <!-- Sidebar -->
+                <StackLayout Grid.Column="0" 
+                             Padding="10" 
+                             Spacing="10"
+                             BackgroundColor="{StaticResource Surface}">
 
-                <!-- Navigation menu -->
-                <CollectionView x:Name="NavMenu" 
-                               SelectionMode="Single" 
-                               SelectionChanged="OnNavMenuSelectionChanged">
-                    <CollectionView.ItemsSource>
-                        <x:Array Type="{x:Type x:String}">
-                            <x:String>1602 LCD Display</x:String>
-                            <x:String>4.6" TFT Display</x:String>
-                            <x:String>OLED Display</x:String>
-                            <x:String>Settings</x:String>
-                            <x:String>Help</x:String>
-                        </x:Array>
-                    </CollectionView.ItemsSource>
-                    <CollectionView.ItemTemplate>
-                        <DataTemplate>
-                            <Border Padding="15,10"
-                                    StrokeShape="RoundRectangle 8,8,8,8"
-                                    BackgroundColor="{Binding Source={x:Reference NavMenu}, Path=SelectedItem, Converter={StaticResource StringMatchConverter}, ConverterParameter={Binding .}}">
-                                <HorizontalStackLayout Spacing="10">
-                                    <Label Text="{Binding .}" 
-                                           VerticalOptions="Center"
-                                           TextColor="{Binding Source={x:Reference NavMenu}, Path=SelectedItem, Converter={StaticResource StringMatchTextConverter}, ConverterParameter={Binding .}}" />
-                                </HorizontalStackLayout>
-                            </Border>
-                        </DataTemplate>
-                    </CollectionView.ItemTemplate>
-                </CollectionView>
-
-                <!-- Connection status -->
-                <StackLayout VerticalOptions="EndAndExpand" Margin="0,30,0,10">
-                    <HorizontalStackLayout Spacing="8">
-                        <Ellipse Fill="{Binding IsConnected, Converter={StaticResource ConnectionStatusColorConverter}}"
-                                WidthRequest="12"
-                                HeightRequest="12" />
-                        <Label Text="{Binding ConnectionStatus}" 
-                               FontSize="14" 
-                               TextColor="{StaticResource TextSecondary}" />
+                    <!-- App logo and title -->
+                    <HorizontalStackLayout Spacing="10" Margin="0,10,0,20">
+                        <Image Source="app_icon.png" HeightRequest="32" WidthRequest="32" />
+                        <Label Text="PCPal" 
+                               FontSize="22" 
+                               FontAttributes="Bold" 
+                               TextColor="{StaticResource Primary}" 
+                               VerticalOptions="Center" />
                     </HorizontalStackLayout>
-                    <Label Text="{Binding LastUpdateTime, StringFormat='Updated: {0}'}" 
-                           FontSize="12" 
-                           TextColor="{StaticResource TextSecondary}" 
-                           Margin="0,5,0,0" />
-                </StackLayout>
-            </StackLayout>
 
-            <!-- Content area -->
-            <ContentView Grid.Column="1" x:Name="ContentContainer" />
-        </Grid>
-    </Shell.ContentTemplate>
+                    <!-- Navigation menu -->
+                    <CollectionView x:Name="NavMenu" 
+                                   SelectionMode="Single" 
+                                   SelectionChanged="OnNavMenuSelectionChanged">
+                        <CollectionView.ItemsSource>
+                            <x:Array Type="{x:Type x:String}">
+                                <x:String>1602 LCD Display</x:String>
+                                <x:String>4.6" TFT Display</x:String>
+                                <x:String>OLED Display</x:String>
+                                <x:String>Settings</x:String>
+                                <x:String>Help</x:String>
+                            </x:Array>
+                        </CollectionView.ItemsSource>
+                        <CollectionView.ItemTemplate>
+                            <DataTemplate>
+                                <Border Padding="15,10"
+                                        StrokeShape="RoundRectangle 8,8,8,8"
+                                        BackgroundColor="{Binding Source={x:Reference NavMenu}, Path=SelectedItem, Converter={StaticResource StringMatchConverter}, ConverterParameter={Binding .}}">
+                                    <HorizontalStackLayout Spacing="10">
+                                        <Label Text="{Binding .}" 
+                                               VerticalOptions="Center"
+                                               TextColor="{Binding Source={x:Reference NavMenu}, Path=SelectedItem, Converter={StaticResource StringMatchTextConverter}, ConverterParameter={Binding .}}" />
+                                    </HorizontalStackLayout>
+                                </Border>
+                            </DataTemplate>
+                        </CollectionView.ItemTemplate>
+                    </CollectionView>
+
+                    <!-- Connection status -->
+                    <StackLayout VerticalOptions="EndAndExpand" Margin="0,30,0,10">
+                        <HorizontalStackLayout Spacing="8">
+                            <Ellipse Fill="{Binding IsConnected, Converter={StaticResource ConnectionStatusColorConverter}}"
+                                    WidthRequest="12"
+                                    HeightRequest="12" />
+                            <Label Text="{Binding ConnectionStatus}" 
+                                   FontSize="14" 
+                                   TextColor="{StaticResource TextSecondary}" />
+                        </HorizontalStackLayout>
+                        <Label Text="{Binding LastUpdateTime, StringFormat='Updated: {0}'}" 
+                               FontSize="12" 
+                               TextColor="{StaticResource TextSecondary}" 
+                               Margin="0,5,0,0" />
+                    </StackLayout>
+                </StackLayout>
+
+                <!-- Content area -->
+                <ContentView Grid.Column="1" x:Name="ContentContainer" />
+            </Grid>
+        </ContentPage>
+    </ShellContent>
 </Shell>
\ No newline at end of file
diff --git a/PCPal/Configurator/AppShell.xaml.cs b/PCPal/Configurator/AppShell.xaml.cs
index a39d112..a2ddfbd 100644
--- a/PCPal/Configurator/AppShell.xaml.cs
+++ b/PCPal/Configurator/AppShell.xaml.cs
@@ -5,7 +5,6 @@ using PCPal.Configurator.Views.LCD;
 using PCPal.Configurator.Views.OLED;
 using PCPal.Configurator.Views.TFT;
 using System.ComponentModel;
-//using UIKit;
 
 namespace PCPal.Configurator;
 
@@ -14,6 +13,7 @@ public partial class AppShell : Shell, INotifyPropertyChanged
     private bool _isConnected;
     private string _connectionStatus;
     private DateTime _lastUpdateTime;
+    private CancellationTokenSource _monitoringCts;
 
     private readonly IServiceProvider _serviceProvider;
 
@@ -60,7 +60,8 @@ public partial class AppShell : Shell, INotifyPropertyChanged
     {
         InitializeComponent();
 
-        _serviceProvider = IPlatformApplication.Current.Services;
+        _serviceProvider = IPlatformApplication.Current?.Services;
+        _monitoringCts = new CancellationTokenSource();
 
         // Set initial connection status
         IsConnected = false;
@@ -74,17 +75,29 @@ public partial class AppShell : Shell, INotifyPropertyChanged
         StartConnectivityMonitoring();
     }
 
+    protected override void OnDisappearing()
+    {
+        base.OnDisappearing();
+        _monitoringCts?.Cancel();
+    }
+
+    ~AppShell()
+    {
+        _monitoringCts?.Cancel();
+        _monitoringCts?.Dispose();
+    }
+
     private void OnNavMenuSelectionChanged(object sender, SelectionChangedEventArgs e)
     {
         if (e.CurrentSelection.FirstOrDefault() is string selection)
         {
             ContentView view = selection switch
             {
-                "1602 LCD Display" => _serviceProvider.GetService<LcdConfigView>(),
-                "4.6 TFT Display" => _serviceProvider.GetService<TftConfigView>(),
-                "OLED Display" => _serviceProvider.GetService<OledConfigView>(),
-                "Settings" => _serviceProvider.GetService<SettingsView>(),
-                "Help" => _serviceProvider.GetService<HelpView>(),
+                "1602 LCD Display" => _serviceProvider?.GetService<LcdConfigView>(),
+                "4.6\" TFT Display" => _serviceProvider?.GetService<TftConfigView>(),
+                "OLED Display" => _serviceProvider?.GetService<OledConfigView>(),
+                "Settings" => _serviceProvider?.GetService<SettingsView>(),
+                "Help" => _serviceProvider?.GetService<HelpView>(),
                 _ => null
             };
 
@@ -97,7 +110,7 @@ public partial class AppShell : Shell, INotifyPropertyChanged
 
     private async void StartConnectivityMonitoring()
     {
-        var serialPortService = _serviceProvider.GetService<ISerialPortService>();
+        var serialPortService = _serviceProvider?.GetService<ISerialPortService>();
         if (serialPortService != null)
         {
             // Subscribe to connection status changes
@@ -112,19 +125,31 @@ public partial class AppShell : Shell, INotifyPropertyChanged
             };
 
             // Start periodic connection check
-            while (true)
+            try
             {
-                await Task.Delay(5000);
-                try
+                while (!_monitoringCts.Token.IsCancellationRequested)
                 {
-                    await serialPortService.CheckConnectionAsync();
-                }
-                catch (Exception ex)
-                {
-                    // Log error but don't crash the app
-                    System.Diagnostics.Debug.WriteLine($"Connection check error: {ex.Message}");
+                    await Task.Delay(5000, _monitoringCts.Token);
+
+                    if (_monitoringCts.Token.IsCancellationRequested)
+                        break;
+
+                    try
+                    {
+                        await serialPortService.CheckConnectionAsync();
+                    }
+                    catch (Exception ex)
+                    {
+                        // Log error but don't crash the app
+                        System.Diagnostics.Debug.WriteLine($"Connection check error: {ex.Message}");
+                    }
                 }
             }
+            catch (OperationCanceledException)
+            {
+                // Expected when cancellation is requested
+                System.Diagnostics.Debug.WriteLine("Connectivity monitoring canceled");
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/PCPal/Configurator/Controls/OledPreviewCanvas.cs b/PCPal/Configurator/Controls/OledPreviewCanvas.cs
index c86455e..3de217b 100644
--- a/PCPal/Configurator/Controls/OledPreviewCanvas.cs
+++ b/PCPal/Configurator/Controls/OledPreviewCanvas.cs
@@ -1,5 +1,4 @@
-//using Android.Sax;
-using Microsoft.Maui.Controls.Shapes;
+using Microsoft.Maui.Controls.Shapes;
 using PCPal.Configurator.ViewModels;
 using PCPal.Core.Models;
 using System.Collections.ObjectModel;
@@ -162,138 +161,142 @@ public class OledPreviewCanvas : GraphicsView
         dragStartPoint = point;
 
         // Check if an element was clicked
-        if (Elements != null)
+        if (Elements == null || Elements.Count == 0) return;
+
+        // Need to adjust for scale
+        float x = (float)point.X / Scale;
+        float y = (float)point.Y / Scale;
+
+        // Check in reverse order (top elements first)
+        for (int i = Elements.Count - 1; i >= 0; i--)
         {
-            // Need to adjust for scale
-            float x = (float)point.X / Scale;
-            float y = (float)point.Y / Scale;
+            var element = Elements[i];
 
-            foreach (var element in Elements)
+            if (element is TextElement textElement)
             {
-                if (element is TextElement textElement)
+                // Simple bounding box check
+                if (x >= textElement.X && x <= textElement.X + 100 &&
+                    y >= textElement.Y - 20 && y <= textElement.Y)
                 {
-                    // Simple bounding box check
-                    if (x >= textElement.X && x <= textElement.X + 100 &&
-                        y >= textElement.Y - 20 && y <= textElement.Y)
+                    // Find the OledElement that corresponds to this PreviewElement
+                    var oledElement = FindOledElementForPreviewElement(textElement);
+                    if (oledElement != null)
                     {
-                        // Find the OledElement that corresponds to this PreviewElement
-                        var oledElement = FindOledElementForPreviewElement(textElement);
-                        if (oledElement != null)
-                        {
-                            draggedElement = oledElement;
-                            SelectedElement = oledElement;
-                            return;
-                        }
-                    }
-                }
-                else if (element is BarElement barElement)
-                {
-                    if (x >= barElement.X && x <= barElement.X + barElement.Width &&
-                        y >= barElement.Y && y <= barElement.Y + barElement.Height)
-                    {
-                        var oledElement = FindOledElementForPreviewElement(barElement);
-                        if (oledElement != null)
-                        {
-                            draggedElement = oledElement;
-                            SelectedElement = oledElement;
-                            return;
-                        }
-                    }
-                }
-                else if (element is RectElement rectElement)
-                {
-                    if (x >= rectElement.X && x <= rectElement.X + rectElement.Width &&
-                        y >= rectElement.Y && y <= rectElement.Y + rectElement.Height)
-                    {
-                        var oledElement = FindOledElementForPreviewElement(rectElement);
-                        if (oledElement != null)
-                        {
-                            draggedElement = oledElement;
-                            SelectedElement = oledElement;
-                            return;
-                        }
-                    }
-                }
-                else if (element is LineElement lineElement)
-                {
-                    // Simplified line hit detection
-                    float lineLength = (float)Math.Sqrt(
-                        Math.Pow(lineElement.X2 - lineElement.X1, 2) +
-                        Math.Pow(lineElement.Y2 - lineElement.Y1, 2));
-
-                    // Check if point is close to the line
-                    float distance = DistancePointToLine(
-                        x, y,
-                        lineElement.X1, lineElement.Y1,
-                        lineElement.X2, lineElement.Y2);
-
-                    if (distance < 10) // 10 pixel tolerance
-                    {
-                        var oledElement = FindOledElementForPreviewElement(lineElement);
-                        if (oledElement != null)
-                        {
-                            draggedElement = oledElement;
-                            SelectedElement = oledElement;
-                            return;
-                        }
-                    }
-                }
-                else if (element is IconElement iconElement)
-                {
-                    if (x >= iconElement.X && x <= iconElement.X + 24 &&
-                        y >= iconElement.Y && y <= iconElement.Y + 24)
-                    {
-                        var oledElement = FindOledElementForPreviewElement(iconElement);
-                        if (oledElement != null)
-                        {
-                            draggedElement = oledElement;
-                            SelectedElement = oledElement;
-                            return;
-                        }
+                        draggedElement = oledElement;
+                        SelectedElement = oledElement;
+                        return;
                     }
                 }
             }
+            else if (element is BarElement barElement)
+            {
+                if (x >= barElement.X && x <= barElement.X + barElement.Width &&
+                    y >= barElement.Y && y <= barElement.Y + barElement.Height)
+                {
+                    var oledElement = FindOledElementForPreviewElement(barElement);
+                    if (oledElement != null)
+                    {
+                        draggedElement = oledElement;
+                        SelectedElement = oledElement;
+                        return;
+                    }
+                }
+            }
+            else if (element is RectElement rectElement)
+            {
+                if (x >= rectElement.X && x <= rectElement.X + rectElement.Width &&
+                    y >= rectElement.Y && y <= rectElement.Y + rectElement.Height)
+                {
+                    var oledElement = FindOledElementForPreviewElement(rectElement);
+                    if (oledElement != null)
+                    {
+                        draggedElement = oledElement;
+                        SelectedElement = oledElement;
+                        return;
+                    }
+                }
+            }
+            else if (element is LineElement lineElement)
+            {
+                // Simplified line hit detection
+                float distance = DistancePointToLine(
+                    x, y,
+                    lineElement.X1, lineElement.Y1,
+                    lineElement.X2, lineElement.Y2);
 
-            // No element was clicked, deselect
-            SelectedElement = null;
+                if (distance < 10) // 10 pixel tolerance
+                {
+                    var oledElement = FindOledElementForPreviewElement(lineElement);
+                    if (oledElement != null)
+                    {
+                        draggedElement = oledElement;
+                        SelectedElement = oledElement;
+                        return;
+                    }
+                }
+            }
+            else if (element is IconElement iconElement)
+            {
+                if (x >= iconElement.X && x <= iconElement.X + 24 &&
+                    y >= iconElement.Y && y <= iconElement.Y + 24)
+                {
+                    var oledElement = FindOledElementForPreviewElement(iconElement);
+                    if (oledElement != null)
+                    {
+                        draggedElement = oledElement;
+                        SelectedElement = oledElement;
+                        return;
+                    }
+                }
+            }
         }
+
+        // No element was clicked, deselect
+        SelectedElement = null;
     }
 
     private void OnDragInteraction(object sender, TouchEventArgs e)
     {
         if (!IsEditable || draggedElement == null) return;
 
-        var point = e.Touches[0];
-
-        // Calculate the delta from the start point
-        float deltaX = (float)(point.X - dragStartPoint.X) / Scale;
-        float deltaY = (float)(point.Y - dragStartPoint.Y) / Scale;
-
-        // Update the position of the dragged element
-        draggedElement.X += (int)deltaX;
-        draggedElement.Y += (int)deltaY;
-
-        // Keep element within bounds
-        draggedElement.X = Math.Max(0, Math.Min(Width - 10, draggedElement.X));
-        draggedElement.Y = Math.Max(0, Math.Min(Height - 10, draggedElement.Y));
-
-        // Update the start point for the next move
-        dragStartPoint = point;
-
-        // Notify property changes
-        var viewModel = BindingContext as OledConfigViewModel;
-        if (viewModel != null)
+        try
         {
-            // Update the view model properties to reflect the new position
-            viewModel.OnPropertyChanged(nameof(viewModel.SelectedElementX));
-            viewModel.OnPropertyChanged(nameof(viewModel.SelectedElementY));
+            var point = e.Touches[0];
 
-            // Update the markup
-            viewModel.UpdateMarkupFromElements();
+            // Calculate the delta from the start point
+            float deltaX = (float)(point.X - dragStartPoint.X) / Scale;
+            float deltaY = (float)(point.Y - dragStartPoint.Y) / Scale;
+
+            // Update the position of the dragged element
+            draggedElement.X += (int)deltaX;
+            draggedElement.Y += (int)deltaY;
+
+            // Keep element within bounds
+            draggedElement.X = Math.Max(0, Math.Min(Width - 10, draggedElement.X));
+            draggedElement.Y = Math.Max(0, Math.Min(Height - 10, draggedElement.Y));
+
+            // Update the start point for the next move
+            dragStartPoint = point;
+
+            // Notify property changes
+            var viewModel = BindingContext as PCPal.Configurator.ViewModels.OledConfigViewModel;
+            if (viewModel != null)
+            {
+                // Update the view model properties to reflect the new position
+                viewModel.OnPropertyChanged(nameof(viewModel.SelectedElementX));
+                viewModel.OnPropertyChanged(nameof(viewModel.SelectedElementY));
+
+                // Update the markup
+                viewModel.UpdateMarkupFromElements();
+            }
+
+            // Invalidate the canvas to redraw
+            Invalidate();
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Error in drag interaction: {ex.Message}");
         }
-
-        // Invalidate the canvas to redraw
-        Invalidate();
     }
 
     private void OnEndInteraction(object sender, TouchEventArgs e)
@@ -378,66 +381,73 @@ public class OledCanvasDrawable : IDrawable
 
     public void Draw(ICanvas canvas, RectF dirtyRect)
     {
-        float scale = _canvas.Scale;
-
-        // Clear background
-        canvas.FillColor = Colors.Black;
-        canvas.FillRectangle(0, 0, dirtyRect.Width, dirtyRect.Height);
-
-        // Draw grid if requested
-        if (_canvas.IsEditable && _canvas.Parent?.BindingContext is OledConfigViewModel viewModel && viewModel.ShowGridLines)
+        try
         {
-            canvas.StrokeColor = new Color(64, 64, 64, 64); // Semi-transparent gray
-            canvas.StrokeSize = 1;
+            float scale = _canvas.Scale;
 
-            // Draw vertical grid lines
-            for (int x = 0; x <= _canvas.Width; x += 10)
-            {
-                canvas.DrawLine(x * scale, 0, x * scale, _canvas.Height * scale);
-            }
+            // Clear background
+            canvas.FillColor = Colors.Black;
+            canvas.FillRectangle(0, 0, dirtyRect.Width, dirtyRect.Height);
 
-            // Draw horizontal grid lines
-            for (int y = 0; y <= _canvas.Height; y += 10)
+            // Draw grid if requested
+            if (_canvas.IsEditable && _canvas.Parent?.BindingContext is OledConfigViewModel viewModel && viewModel.ShowGridLines)
             {
-                canvas.DrawLine(0, y * scale, _canvas.Width * scale, y * scale);
-            }
-        }
+                canvas.StrokeColor = new Color(64, 64, 64, 64); // Semi-transparent gray
+                canvas.StrokeSize = 1;
 
-        // Draw elements
-        if (_canvas.Elements != null)
-        {
-            foreach (var element in _canvas.Elements)
-            {
-                // Check if this element is selected
-                bool isSelected = false;
-                if (_canvas.SelectedElement != null && _canvas.IsEditable)
+                // Draw vertical grid lines
+                for (int x = 0; x <= _canvas.Width; x += 10)
                 {
-                    if (element is TextElement textElement && _canvas.SelectedElement.Type == "text")
-                    {
-                        isSelected = _canvas.SelectedElement.X == textElement.X && _canvas.SelectedElement.Y == textElement.Y;
-                    }
-                    else if (element is BarElement barElement && _canvas.SelectedElement.Type == "bar")
-                    {
-                        isSelected = _canvas.SelectedElement.X == barElement.X && _canvas.SelectedElement.Y == barElement.Y;
-                    }
-                    else if (element is RectElement rectElement &&
-                             (_canvas.SelectedElement.Type == "rect" || _canvas.SelectedElement.Type == "box"))
-                    {
-                        isSelected = _canvas.SelectedElement.X == rectElement.X && _canvas.SelectedElement.Y == rectElement.Y;
-                    }
-                    else if (element is LineElement lineElement && _canvas.SelectedElement.Type == "line")
-                    {
-                        isSelected = _canvas.SelectedElement.X == lineElement.X1 && _canvas.SelectedElement.Y == lineElement.Y1;
-                    }
-                    else if (element is IconElement iconElement && _canvas.SelectedElement.Type == "icon")
-                    {
-                        isSelected = _canvas.SelectedElement.X == iconElement.X && _canvas.SelectedElement.Y == iconElement.Y;
-                    }
+                    canvas.DrawLine(x * scale, 0, x * scale, _canvas.Height * scale);
                 }
 
-                // Draw the element with appropriate styling
-                DrawElement(canvas, element, scale, isSelected);
+                // Draw horizontal grid lines
+                for (int y = 0; y <= _canvas.Height; y += 10)
+                {
+                    canvas.DrawLine(0, y * scale, _canvas.Width * scale, y * scale);
+                }
             }
+
+            // Draw elements
+            if (_canvas.Elements != null)
+            {
+                foreach (var element in _canvas.Elements)
+                {
+                    // Check if this element is selected
+                    bool isSelected = false;
+                    if (_canvas.SelectedElement != null && _canvas.IsEditable)
+                    {
+                        if (element is TextElement textElement && _canvas.SelectedElement.Type == "text")
+                        {
+                            isSelected = _canvas.SelectedElement.X == textElement.X && _canvas.SelectedElement.Y == textElement.Y;
+                        }
+                        else if (element is BarElement barElement && _canvas.SelectedElement.Type == "bar")
+                        {
+                            isSelected = _canvas.SelectedElement.X == barElement.X && _canvas.SelectedElement.Y == barElement.Y;
+                        }
+                        else if (element is RectElement rectElement &&
+                                 (_canvas.SelectedElement.Type == "rect" || _canvas.SelectedElement.Type == "box"))
+                        {
+                            isSelected = _canvas.SelectedElement.X == rectElement.X && _canvas.SelectedElement.Y == rectElement.Y;
+                        }
+                        else if (element is LineElement lineElement && _canvas.SelectedElement.Type == "line")
+                        {
+                            isSelected = _canvas.SelectedElement.X == lineElement.X1 && _canvas.SelectedElement.Y == lineElement.Y1;
+                        }
+                        else if (element is IconElement iconElement && _canvas.SelectedElement.Type == "icon")
+                        {
+                            isSelected = _canvas.SelectedElement.X == iconElement.X && _canvas.SelectedElement.Y == iconElement.Y;
+                        }
+                    }
+
+                    // Draw the element with appropriate styling
+                    DrawElement(canvas, element, scale, isSelected);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Error drawing canvas: {ex.Message}");
         }
     }
 
diff --git a/PCPal/Configurator/Resources/Styles/Colors.xaml b/PCPal/Configurator/Resources/Styles/Colors.xaml
index 30307a5..2850f03 100644
--- a/PCPal/Configurator/Resources/Styles/Colors.xaml
+++ b/PCPal/Configurator/Resources/Styles/Colors.xaml
@@ -6,12 +6,20 @@
 
     <!-- Note: For Android please see also Platforms\Android\Resources\values\colors.xml -->
 
-    <Color x:Key="Primary">#512BD4</Color>
-    <Color x:Key="PrimaryDark">#ac99ea</Color>
-    <Color x:Key="PrimaryDarkText">#242424</Color>
-    <Color x:Key="Secondary">#DFD8F7</Color>
-    <Color x:Key="SecondaryDarkText">#9880e5</Color>
+    <Color x:Key="Primary">#1E88E5</Color>
+    <Color x:Key="PrimaryDark">#1565C0</Color>
+    <Color x:Key="PrimaryLight">#E3F2FD</Color>
+    <Color x:Key="Secondary">#CFD8DC</Color>
     <Color x:Key="Tertiary">#2B0B98</Color>
+    <Color x:Key="Accent">#03A9F4</Color>
+    <Color x:Key="Background">#F4F6F8</Color>
+    <Color x:Key="Surface">#FFFFFF</Color>
+    <Color x:Key="TextPrimary">#333333</Color>
+    <Color x:Key="TextSecondary">#555555</Color>
+    <Color x:Key="BorderColor">#E1E4E8</Color>
+    <Color x:Key="Success">#4CAF50</Color>
+    <Color x:Key="Error">#F44336</Color>
+    <Color x:Key="Warning">#FF9800</Color>
 
     <Color x:Key="White">White</Color>
     <Color x:Key="Black">Black</Color>
diff --git a/PCPal/Configurator/Resources/Styles/Converters.xaml.cs b/PCPal/Configurator/Resources/Styles/Converters.xaml.cs
index f39faef..f2d0f53 100644
--- a/PCPal/Configurator/Resources/Styles/Converters.xaml.cs
+++ b/PCPal/Configurator/Resources/Styles/Converters.xaml.cs
@@ -83,15 +83,21 @@ public class StringMatchConverter : IValueConverter
         {
             if (currentValue == targetValue)
             {
-                // Handle different return types based on an additional parameter
-                if (parameter is string param2 && param2 == "TextColor")
+                // Default to background coloring
+                Color returnColor = Application.Current.Resources["PrimaryLight"] as Color ?? Colors.LightBlue;
+
+                // Check for additional parameter context
+                if (targetValue.EndsWith(":TextColor"))
                 {
-                    // Return text color for selected item
-                    return Application.Current.Resources["Primary"] as Color ?? Colors.Black;
+                    // Strip the ":TextColor" suffix before comparison
+                    string strippedTarget = targetValue.Substring(0, targetValue.Length - 10);
+                    if (currentValue == strippedTarget)
+                    {
+                        return Application.Current.Resources["Primary"] as Color ?? Colors.Black;
+                    }
                 }
 
-                // Return background color for selected item
-                return Application.Current.Resources["PrimaryLight"] as Color ?? Colors.LightBlue;
+                return returnColor;
             }
         }
 
diff --git a/PCPal/Configurator/Resources/Styles/Styles.xaml b/PCPal/Configurator/Resources/Styles/Styles.xaml
index 4e3b560..6982355 100644
--- a/PCPal/Configurator/Resources/Styles/Styles.xaml
+++ b/PCPal/Configurator/Resources/Styles/Styles.xaml
@@ -86,12 +86,6 @@
         <Setter Property="ThumbColor" Value="{AppThemeBinding Light={StaticResource Surface}, Dark=White}" />
     </Style>
 
-    <Style TargetType="TabBar">
-        <Setter Property="BarBackgroundColor" Value="{AppThemeBinding Light={StaticResource Surface}, Dark=#333333}" />
-        <Setter Property="BarTextColor" Value="{AppThemeBinding Light=#777777, Dark=#777777}" />
-        <Setter Property="BarSelectedTextColor" Value="{AppThemeBinding Light={StaticResource Primary}, Dark={StaticResource Primary}}" />
-    </Style>
-
     <!-- Custom Styles -->
 
     <Style x:Key="HeaderLabelStyle" TargetType="Label">
diff --git a/PCPal/Configurator/ViewModels/OledConfigViewModel.cs b/PCPal/Configurator/ViewModels/OledConfigViewModel.cs
index ffd2341..e0597da 100644
--- a/PCPal/Configurator/ViewModels/OledConfigViewModel.cs
+++ b/PCPal/Configurator/ViewModels/OledConfigViewModel.cs
@@ -4,8 +4,8 @@ using PCPal.Configurator.Views.OLED;
 using System.Collections.ObjectModel;
 using System.Windows.Input;
 using System.Text.RegularExpressions;
-//using Javax.Xml.Transform;
 using System.Diagnostics;
+//using Javax.Xml.Transform;
 
 namespace PCPal.Configurator.ViewModels;
 
@@ -49,6 +49,7 @@ public class OledConfigViewModel : BaseViewModel
 
     // Timer for sensor updates
     private Timer _sensorUpdateTimer;
+    private CancellationTokenSource _sensorUpdateCts;
 
     #region Properties
 
@@ -410,9 +411,9 @@ public class OledConfigViewModel : BaseViewModel
         IConfigurationService configService,
         ISerialPortService serialPortService)
     {
-        _sensorService = sensorService;
-        _configService = configService;
-        _serialPortService = serialPortService;
+        _sensorService = sensorService ?? throw new ArgumentNullException(nameof(sensorService));
+        _configService = configService ?? throw new ArgumentNullException(nameof(configService));
+        _serialPortService = serialPortService ?? throw new ArgumentNullException(nameof(serialPortService));
 
         // Initialize collections
         _oledElements = new ObservableCollection<OledElement>();
@@ -422,6 +423,9 @@ public class OledConfigViewModel : BaseViewModel
         _templateList = new ObservableCollection<Template>();
         _customTemplates = new ObservableCollection<Template>();
 
+        // Setup cancellation token source
+        _sensorUpdateCts = new CancellationTokenSource();
+
         // Create views
         _visualEditorView = new OledVisualEditorView { BindingContext = this };
         _markupEditorView = new OledMarkupEditorView { BindingContext = this };
@@ -468,6 +472,25 @@ public class OledConfigViewModel : BaseViewModel
         _sensorUpdateTimer = new Timer(async (_) => await UpdateSensorDataAsync(), null, Timeout.Infinite, Timeout.Infinite);
     }
 
+    ~OledConfigViewModel()
+    {
+        CleanupResources();
+    }
+
+    private void CleanupResources()
+    {
+        try
+        {
+            _sensorUpdateCts?.Cancel();
+            _sensorUpdateTimer?.Dispose();
+            _sensorUpdateCts?.Dispose();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error cleaning up resources: {ex.Message}");
+        }
+    }
+
     public async Task Initialize()
     {
         IsBusy = true;
@@ -492,6 +515,7 @@ public class OledConfigViewModel : BaseViewModel
         }
         catch (Exception ex)
         {
+            Debug.WriteLine($"Error initializing: {ex.Message}");
             await Shell.Current.DisplayAlert("Error", $"Failed to initialize: {ex.Message}", "OK");
         }
         finally
@@ -502,103 +526,128 @@ public class OledConfigViewModel : BaseViewModel
 
     private async Task LoadSensorsAsync()
     {
-        await _sensorService.UpdateSensorValuesAsync();
-
-        var sensorGroups = _sensorService.GetAllSensorsGrouped();
-        var sensors = new List<SensorItem>();
-
-        foreach (var group in sensorGroups)
+        try
         {
-            foreach (var sensor in group.Sensors)
-            {
-                sensors.Add(sensor);
-            }
-        }
+            await _sensorService.UpdateSensorValuesAsync();
 
-        AvailableSensors = new ObservableCollection<SensorItem>(sensors);
-        FilteredSensors = new ObservableCollection<SensorItem>(sensors);
+            var sensorGroups = _sensorService.GetAllSensorsGrouped();
+            var sensors = new List<SensorItem>();
+
+            foreach (var group in sensorGroups)
+            {
+                foreach (var sensor in group.Sensors)
+                {
+                    sensors.Add(sensor);
+                }
+            }
+
+            // Update on main thread to ensure thread safety
+            await MainThread.InvokeOnMainThreadAsync(() => {
+                AvailableSensors = new ObservableCollection<SensorItem>(sensors);
+                FilteredSensors = new ObservableCollection<SensorItem>(sensors);
+            });
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error loading sensors: {ex.Message}");
+        }
     }
 
     private async Task LoadConfigAsync()
     {
-        var config = await _configService.LoadConfigAsync();
+        try
+        {
+            var config = await _configService.LoadConfigAsync();
 
-        // If OLED markup exists, load it
-        if (!string.IsNullOrEmpty(config.OledMarkup))
-        {
-            OledMarkup = config.OledMarkup;
-            await ParseMarkupToElementsAsync(OledMarkup);
-            UpdatePreviewFromMarkup();
+            // If OLED markup exists, load it
+            if (!string.IsNullOrEmpty(config.OledMarkup))
+            {
+                OledMarkup = config.OledMarkup;
+                await ParseMarkupToElementsAsync(OledMarkup);
+                UpdatePreviewFromMarkup();
+            }
+            else
+            {
+                // Load an example if no config exists
+                await LoadExampleMarkupAsync();
+            }
         }
-        else
+        catch (Exception ex)
         {
-            // Load an example if no config exists
-            await LoadExampleMarkupAsync();
+            Debug.WriteLine($"Error loading configuration: {ex.Message}");
+            await LoadExampleMarkupAsync(); // Fallback to example
         }
     }
 
     private async Task LoadTemplatesAsync()
     {
-        // Predefined templates
-        var templates = new List<Template>
+        try
         {
-            new Template
+            // Predefined templates
+            var templates = new List<Template>
             {
-                Name = "System Monitor",
-                Description = "Shows CPU, GPU, and memory usage with progress bars",
-                Markup = await CreateSystemMonitorTemplateAsync()
-            },
-            new Template
-            {
-                Name = "Temperature Monitor",
-                Description = "Shows temperatures of key components",
-                Markup = await CreateTemperatureMonitorTemplateAsync()
-            },
-            new Template
-            {
-                Name = "Network Monitor",
-                Description = "Shows network activity and throughput",
-                Markup = await CreateNetworkMonitorTemplateAsync()
-            },
-            new Template
-            {
-                Name = "Storage Monitor",
-                Description = "Shows disk space usage and activity",
-                Markup = await CreateStorageMonitorTemplateAsync()
-            }
-        };
-
-        // Process templates to create preview elements
-        foreach (var template in templates)
-        {
-            template.PreviewElements = await ParseMarkupToPreviewElements(template.Markup);
-        }
-
-        TemplateList = new ObservableCollection<Template>(templates);
-
-        // Load custom templates
-        var config = await _configService.LoadConfigAsync();
-        if (config.SavedProfiles != null && config.SavedProfiles.Any())
-        {
-            var customTemplates = new List<Template>();
-
-            foreach (var profile in config.SavedProfiles)
-            {
-                if (profile.ScreenType == "OLED")
+                new Template
                 {
-                    var template = new Template
-                    {
-                        Name = profile.Name,
-                        Description = "Custom template",
-                        Markup = profile.ConfigData
-                    };
-
-                    template.PreviewElements = await ParseMarkupToPreviewElements(template.Markup);
-                    customTemplates.Add(template);
+                    Name = "System Monitor",
+                    Description = "Shows CPU, GPU, and memory usage with progress bars",
+                    Markup = await CreateSystemMonitorTemplateAsync()
+                },
+                new Template
+                {
+                    Name = "Temperature Monitor",
+                    Description = "Shows temperatures of key components",
+                    Markup = await CreateTemperatureMonitorTemplateAsync()
+                },
+                new Template
+                {
+                    Name = "Network Monitor",
+                    Description = "Shows network activity and throughput",
+                    Markup = await CreateNetworkMonitorTemplateAsync()
+                },
+                new Template
+                {
+                    Name = "Storage Monitor",
+                    Description = "Shows disk space usage and activity",
+                    Markup = await CreateStorageMonitorTemplateAsync()
                 }
+            };
+
+            // Process templates to create preview elements
+            foreach (var template in templates)
+            {
+                template.PreviewElements = await ParseMarkupToPreviewElements(template.Markup);
             }
 
-            CustomTemplates = new ObservableCollection<Template>(customTemplates);
+            TemplateList = new ObservableCollection<Template>(templates);
+
+            // Load custom templates
+            var config = await _configService.LoadConfigAsync();
+            if (config.SavedProfiles != null && config.SavedProfiles.Any())
+            {
+                var customTemplates = new List<Template>();
+
+                foreach (var profile in config.SavedProfiles)
+                {
+                    if (profile.ScreenType == "OLED")
+                    {
+                        var template = new Template
+                        {
+                            Name = profile.Name,
+                            Description = "Custom template",
+                            Markup = profile.ConfigData
+                        };
+
+                        template.PreviewElements = await ParseMarkupToPreviewElements(template.Markup);
+                        customTemplates.Add(template);
+                    }
+                }
+
+                CustomTemplates = new ObservableCollection<Template>(customTemplates);
+            }
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error loading templates: {ex.Message}");
         }
     }
 
@@ -647,6 +696,7 @@ public class OledConfigViewModel : BaseViewModel
         }
         catch (Exception ex)
         {
+            Debug.WriteLine($"Error saving configuration: {ex.Message}");
             await Shell.Current.DisplayAlert("Error", $"Failed to save configuration: {ex.Message}", "OK");
         }
         finally
@@ -682,6 +732,7 @@ public class OledConfigViewModel : BaseViewModel
         }
         catch (Exception ex)
         {
+            Debug.WriteLine($"Error previewing on device: {ex.Message}");
             await Shell.Current.DisplayAlert("Error", $"Preview failed: {ex.Message}", "OK");
         }
         finally
@@ -692,14 +743,21 @@ public class OledConfigViewModel : BaseViewModel
 
     private async Task ResetLayoutAsync()
     {
-        bool confirm = await Shell.Current.DisplayAlert(
-            "Reset Layout",
-            "Are you sure you want to reset your layout? This will discard all your changes.",
-            "Reset", "Cancel");
-
-        if (confirm)
+        try
         {
-            await LoadExampleMarkupAsync();
+            bool confirm = await Shell.Current.DisplayAlert(
+                "Reset Layout",
+                "Are you sure you want to reset your layout? This will discard all your changes.",
+                "Reset", "Cancel");
+
+            if (confirm)
+            {
+                await LoadExampleMarkupAsync();
+            }
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error resetting layout: {ex.Message}");
         }
     }
 
@@ -709,7 +767,12 @@ public class OledConfigViewModel : BaseViewModel
         {
             // Parse the markup into preview elements
             var markupParser = new MarkupParser(_sensorService.GetAllSensorValues());
-            PreviewElements = markupParser.ParseMarkup(OledMarkup);
+            var elements = markupParser.ParseMarkup(OledMarkup);
+
+            // Update on main thread to ensure thread safety
+            MainThread.BeginInvokeOnMainThread(() => {
+                PreviewElements = elements;
+            });
         }
         catch (Exception ex)
         {
@@ -717,16 +780,44 @@ public class OledConfigViewModel : BaseViewModel
         }
     }
 
+    public void UpdateMarkupFromElements()
+    {
+        try
+        {
+            var sb = new System.Text.StringBuilder();
+
+            foreach (var element in OledElements)
+            {
+                sb.AppendLine(element.ToMarkup());
+            }
+
+            OledMarkup = sb.ToString();
+            UpdatePreviewFromMarkup();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error updating markup from elements: {ex.Message}");
+        }
+    }
+
     private async Task UpdateSensorDataAsync()
     {
         try
         {
+            if (_sensorUpdateCts.Token.IsCancellationRequested)
+                return;
+
             await _sensorService.UpdateSensorValuesAsync();
             UpdatePreviewFromMarkup();
 
             // Update available sensors
             await LoadSensorsAsync();
         }
+        catch (OperationCanceledException)
+        {
+            // Expected when cancellation is requested
+            Debug.WriteLine("Sensor update canceled");
+        }
         catch (Exception ex)
         {
             // Log error but don't display to user since this happens in background
@@ -736,183 +827,204 @@ public class OledConfigViewModel : BaseViewModel
 
     private void ApplySensorFilter()
     {
-        if (string.IsNullOrEmpty(CurrentSensorFilter) || CurrentSensorFilter == "All")
+        try
         {
-            FilteredSensors = new ObservableCollection<SensorItem>(AvailableSensors);
-            return;
+            if (string.IsNullOrEmpty(CurrentSensorFilter) || CurrentSensorFilter == "All")
+            {
+                MainThread.BeginInvokeOnMainThread(() => {
+                    FilteredSensors = new ObservableCollection<SensorItem>(AvailableSensors);
+                });
+                return;
+            }
+
+            var filtered = AvailableSensors.Where(s =>
+                s.HardwareName.Contains(CurrentSensorFilter, StringComparison.OrdinalIgnoreCase)).ToList();
+
+            MainThread.BeginInvokeOnMainThread(() => {
+                FilteredSensors = new ObservableCollection<SensorItem>(filtered);
+            });
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error applying sensor filter: {ex.Message}");
         }
-
-        var filtered = AvailableSensors.Where(s =>
-            s.HardwareName.Contains(CurrentSensorFilter, StringComparison.OrdinalIgnoreCase)).ToList();
-
-        FilteredSensors = new ObservableCollection<SensorItem>(filtered);
     }
 
     private void AddElement(string type)
     {
-        var element = new OledElement
+        try
         {
-            Type = type,
-            X = 10,
-            Y = 10
-        };
+            var element = new OledElement
+            {
+                Type = type,
+                X = 10,
+                Y = 10
+            };
 
-        // Set default properties based on type
-        switch (type)
-        {
-            case "text":
-                element.Properties["size"] = "1";
-                element.Properties["content"] = "New Text";
-                break;
+            // Set default properties based on type
+            switch (type)
+            {
+                case "text":
+                    element.Properties["size"] = "1";
+                    element.Properties["content"] = "New Text";
+                    break;
 
-            case "bar":
-                element.Properties["width"] = "100";
-                element.Properties["height"] = "8";
-                element.Properties["value"] = "50";
-                break;
+                case "bar":
+                    element.Properties["width"] = "100";
+                    element.Properties["height"] = "8";
+                    element.Properties["value"] = "50";
+                    break;
 
-            case "rect":
-            case "box":
-                element.Properties["width"] = "20";
-                element.Properties["height"] = "10";
-                break;
+                case "rect":
+                case "box":
+                    element.Properties["width"] = "20";
+                    element.Properties["height"] = "10";
+                    break;
 
-            case "line":
-                element.Properties["x2"] = "30";
-                element.Properties["y2"] = "30";
-                break;
+                case "line":
+                    element.Properties["x2"] = "30";
+                    element.Properties["y2"] = "30";
+                    break;
 
-            case "icon":
-                element.Properties["name"] = "cpu";
-                break;
-        }
+                case "icon":
+                    element.Properties["name"] = "cpu";
+                    break;
+            }
 
-        OledElements.Add(element);
-        SelectedElement = element;
-
-        // Update markup
-        UpdateMarkupFromElements();
-    }
-
-    private void DeleteSelectedElement()
-    {
-        if (SelectedElement != null)
-        {
-            OledElements.Remove(SelectedElement);
-            SelectedElement = null;
+            OledElements.Add(element);
+            SelectedElement = element;
 
             // Update markup
             UpdateMarkupFromElements();
         }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error adding element: {ex.Message}");
+        }
     }
 
-    public void UpdateMarkupFromElements()
+    private void DeleteSelectedElement()
     {
-        var sb = new System.Text.StringBuilder();
-
-        foreach (var element in OledElements)
+        try
         {
-            sb.AppendLine(element.ToMarkup());
-        }
+            if (SelectedElement != null)
+            {
+                OledElements.Remove(SelectedElement);
+                SelectedElement = null;
 
-        OledMarkup = sb.ToString();
-        UpdatePreviewFromMarkup();
+                // Update markup
+                UpdateMarkupFromElements();
+            }
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error deleting element: {ex.Message}");
+        }
     }
 
     private async Task ParseMarkupToElementsAsync(string markup)
     {
         if (string.IsNullOrEmpty(markup))
         {
-            OledElements.Clear();
+            await MainThread.InvokeOnMainThreadAsync(() => {
+                OledElements.Clear();
+            });
             return;
         }
 
         var elements = new List<OledElement>();
 
-        // Parse text elements
-        foreach (Match match in Regex.Matches(markup, @"<text\s+x=(\d+)\s+y=(\d+)(?:\s+size=(\d+))?>([^<]*)</text>"))
+        try
         {
-            var element = new OledElement { Type = "text" };
-            element.X = int.Parse(match.Groups[1].Value);
-            element.Y = int.Parse(match.Groups[2].Value);
+            // Parse text elements
+            foreach (Match match in Regex.Matches(markup, @"<text\s+x=(\d+)\s+y=(\d+)(?:\s+size=(\d+))?>([^<]*)</text>"))
+            {
+                var element = new OledElement { Type = "text" };
+                element.X = int.Parse(match.Groups[1].Value);
+                element.Y = int.Parse(match.Groups[2].Value);
 
-            if (match.Groups[3].Success)
-            {
-                element.Properties["size"] = match.Groups[3].Value;
-            }
-            else
-            {
-                element.Properties["size"] = "1";
+                if (match.Groups[3].Success)
+                {
+                    element.Properties["size"] = match.Groups[3].Value;
+                }
+                else
+                {
+                    element.Properties["size"] = "1";
+                }
+
+                element.Properties["content"] = match.Groups[4].Value;
+                elements.Add(element);
             }
 
-            element.Properties["content"] = match.Groups[4].Value;
-            elements.Add(element);
-        }
-
-        // Parse bar elements
-        foreach (Match match in Regex.Matches(markup, @"<bar\s+x=(\d+)\s+y=(\d+)\s+w=(\d+)\s+h=(\d+)\s+val=(\d+|\{[^}]+\})\s*/>"))
-        {
-            var element = new OledElement { Type = "bar" };
-            element.X = int.Parse(match.Groups[1].Value);
-            element.Y = int.Parse(match.Groups[2].Value);
-            element.Properties["width"] = match.Groups[3].Value;
-            element.Properties["height"] = match.Groups[4].Value;
-            element.Properties["value"] = match.Groups[5].Value;
-            elements.Add(element);
-        }
-
-        // Parse rect elements
-        foreach (Match match in Regex.Matches(markup, @"<rect\s+x=(\d+)\s+y=(\d+)\s+w=(\d+)\s+h=(\d+)\s*/>"))
-        {
-            var element = new OledElement { Type = "rect" };
-            element.X = int.Parse(match.Groups[1].Value);
-            element.Y = int.Parse(match.Groups[2].Value);
-            element.Properties["width"] = match.Groups[3].Value;
-            element.Properties["height"] = match.Groups[4].Value;
-            elements.Add(element);
-        }
-
-        // Parse box elements
-        foreach (Match match in Regex.Matches(markup, @"<box\s+x=(\d+)\s+y=(\d+)\s+w=(\d+)\s+h=(\d+)\s*/>"))
-        {
-            var element = new OledElement { Type = "box" };
-            element.X = int.Parse(match.Groups[1].Value);
-            element.Y = int.Parse(match.Groups[2].Value);
-            element.Properties["width"] = match.Groups[3].Value;
-            element.Properties["height"] = match.Groups[4].Value;
-            elements.Add(element);
-        }
-
-        // Parse line elements
-        foreach (Match match in Regex.Matches(markup, @"<line\s+x1=(\d+)\s+y1=(\d+)\s+x2=(\d+)\s+y2=(\d+)\s*/>"))
-        {
-            var element = new OledElement { Type = "line" };
-            element.X = int.Parse(match.Groups[1].Value);
-            element.Y = int.Parse(match.Groups[2].Value);
-            element.Properties["x2"] = match.Groups[3].Value;
-            element.Properties["y2"] = match.Groups[4].Value;
-            elements.Add(element);
-        }
-
-        // Parse icon elements
-        foreach (Match match in Regex.Matches(markup, @"<icon\s+x=(\d+)\s+y=(\d+)\s+name=([a-zA-Z0-9_]+)\s*/>"))
-        {
-            var element = new OledElement { Type = "icon" };
-            element.X = int.Parse(match.Groups[1].Value);
-            element.Y = int.Parse(match.Groups[2].Value);
-            element.Properties["name"] = match.Groups[3].Value;
-            elements.Add(element);
-        }
-
-        // Update the collection on the UI thread
-        await MainThread.InvokeOnMainThreadAsync(() =>
-        {
-            OledElements.Clear();
-            foreach (var element in elements)
+            // Parse bar elements
+            foreach (Match match in Regex.Matches(markup, @"<bar\s+x=(\d+)\s+y=(\d+)\s+w=(\d+)\s+h=(\d+)\s+val=(\d+|\{[^}]+\})\s*/>"))
             {
-                OledElements.Add(element);
+                var element = new OledElement { Type = "bar" };
+                element.X = int.Parse(match.Groups[1].Value);
+                element.Y = int.Parse(match.Groups[2].Value);
+                element.Properties["width"] = match.Groups[3].Value;
+                element.Properties["height"] = match.Groups[4].Value;
+                element.Properties["value"] = match.Groups[5].Value;
+                elements.Add(element);
             }
-        });
+
+            // Parse rect elements
+            foreach (Match match in Regex.Matches(markup, @"<rect\s+x=(\d+)\s+y=(\d+)\s+w=(\d+)\s+h=(\d+)\s*/>"))
+            {
+                var element = new OledElement { Type = "rect" };
+                element.X = int.Parse(match.Groups[1].Value);
+                element.Y = int.Parse(match.Groups[2].Value);
+                element.Properties["width"] = match.Groups[3].Value;
+                element.Properties["height"] = match.Groups[4].Value;
+                elements.Add(element);
+            }
+
+            // Parse box elements
+            foreach (Match match in Regex.Matches(markup, @"<box\s+x=(\d+)\s+y=(\d+)\s+w=(\d+)\s+h=(\d+)\s*/>"))
+            {
+                var element = new OledElement { Type = "box" };
+                element.X = int.Parse(match.Groups[1].Value);
+                element.Y = int.Parse(match.Groups[2].Value);
+                element.Properties["width"] = match.Groups[3].Value;
+                element.Properties["height"] = match.Groups[4].Value;
+                elements.Add(element);
+            }
+
+            // Parse line elements
+            foreach (Match match in Regex.Matches(markup, @"<line\s+x1=(\d+)\s+y1=(\d+)\s+x2=(\d+)\s+y2=(\d+)\s*/>"))
+            {
+                var element = new OledElement { Type = "line" };
+                element.X = int.Parse(match.Groups[1].Value);
+                element.Y = int.Parse(match.Groups[2].Value);
+                element.Properties["x2"] = match.Groups[3].Value;
+                element.Properties["y2"] = match.Groups[4].Value;
+                elements.Add(element);
+            }
+
+            // Parse icon elements
+            foreach (Match match in Regex.Matches(markup, @"<icon\s+x=(\d+)\s+y=(\d+)\s+name=([a-zA-Z0-9_]+)\s*/>"))
+            {
+                var element = new OledElement { Type = "icon" };
+                element.X = int.Parse(match.Groups[1].Value);
+                element.Y = int.Parse(match.Groups[2].Value);
+                element.Properties["name"] = match.Groups[3].Value;
+                elements.Add(element);
+            }
+
+            // Update the collection on the UI thread
+            await MainThread.InvokeOnMainThreadAsync(() =>
+            {
+                OledElements.Clear();
+                foreach (var element in elements)
+                {
+                    OledElements.Add(element);
+                }
+            });
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error parsing markup: {ex.Message}");
+        }
     }
 
     private async Task<List<PreviewElement>> ParseMarkupToPreviewElements(string markup)
@@ -947,297 +1059,409 @@ public class OledConfigViewModel : BaseViewModel
 
     private void AddSensorToDisplay(string sensorId)
     {
-        // Find the sensor
-        var sensor = AvailableSensors.FirstOrDefault(s => s.Id == sensorId);
-
-        if (sensor == null)
+        try
         {
-            return;
-        }
+            // Find the sensor
+            var sensor = AvailableSensors.FirstOrDefault(s => s.Id == sensorId);
 
-        // Determine appropriate Y position (avoid overlap)
-        int yPos = 15;
-        if (OledElements.Any())
-        {
-            yPos = OledElements.Max(e => e.Y) + 15;
-        }
-
-        // Create text element with the sensor variable
-        var element = new OledElement
-        {
-            Type = "text",
-            X = 10,
-            Y = yPos
-        };
-
-        element.Properties["size"] = "1";
-        element.Properties["content"] = $"{sensor.Name}: {{{sensorId}}} {sensor.Unit}";
-
-        OledElements.Add(element);
-        SelectedElement = element;
-
-        // Create a progress bar if it's a load/percentage sensor
-        if (sensor.SensorType == LibreHardwareMonitor.Hardware.SensorType.Load ||
-            sensor.SensorType == LibreHardwareMonitor.Hardware.SensorType.Level)
-        {
-            var barElement = new OledElement
+            if (sensor == null)
             {
-                Type = "bar",
+                return;
+            }
+
+            // Determine appropriate Y position (avoid overlap)
+            int yPos = 15;
+            if (OledElements.Any())
+            {
+                yPos = OledElements.Max(e => e.Y) + 15;
+            }
+
+            // Create text element with the sensor variable
+            var element = new OledElement
+            {
+                Type = "text",
                 X = 10,
-                Y = yPos + 5
+                Y = yPos
             };
 
-            barElement.Properties["width"] = "100";
-            barElement.Properties["height"] = "8";
-            barElement.Properties["value"] = $"{{{sensorId}}}";
+            element.Properties["size"] = "1";
+            element.Properties["content"] = $"{sensor.Name}: {{{sensorId}}} {sensor.Unit}";
 
-            OledElements.Add(barElement);
+            OledElements.Add(element);
+            SelectedElement = element;
+
+            // Create a progress bar if it's a load/percentage sensor
+            if (sensor.SensorType == LibreHardwareMonitor.Hardware.SensorType.Load ||
+                sensor.SensorType == LibreHardwareMonitor.Hardware.SensorType.Level)
+            {
+                var barElement = new OledElement
+                {
+                    Type = "bar",
+                    X = 10,
+                    Y = yPos + 5
+                };
+
+                barElement.Properties["width"] = "100";
+                barElement.Properties["height"] = "8";
+                barElement.Properties["value"] = $"{{{sensorId}}}";
+
+                OledElements.Add(barElement);
+            }
+
+            // Update markup
+            UpdateMarkupFromElements();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error adding sensor to display: {ex.Message}");
         }
-
-        // Update markup
-        UpdateMarkupFromElements();
     }
 
     private async Task BrowseIconsAsync()
     {
-        // A mock implementation - in a real app, you'd implement a proper icon browser
-        var icons = new string[] { "cpu", "gpu", "ram", "disk", "network", "fan" };
-        string result = await Shell.Current.DisplayActionSheet("Select an icon", "Cancel", null, icons);
-
-        if (!string.IsNullOrEmpty(result) && result != "Cancel")
+        try
         {
-            SelectedElementIconName = result;
+            // A mock implementation - in a real app, you'd implement a proper icon browser
+            var icons = new string[] { "cpu", "gpu", "ram", "disk", "network", "fan" };
+            string result = await Shell.Current.DisplayActionSheet("Select an icon", "Cancel", null, icons);
+
+            if (!string.IsNullOrEmpty(result) && result != "Cancel")
+            {
+                SelectedElementIconName = result;
+            }
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error browsing icons: {ex.Message}");
         }
     }
 
     private void InsertMarkupTemplate(string type)
     {
-        string template = string.Empty;
-
-        switch (type)
+        try
         {
-            case "text":
-                template = "<text x=10 y=20 size=1>Sample Text</text>";
-                break;
+            string template = string.Empty;
 
-            case "bar":
-                template = "<bar x=10 y=30 w=100 h=8 val=75 />";
-                break;
+            switch (type)
+            {
+                case "text":
+                    template = "<text x=10 y=20 size=1>Sample Text</text>";
+                    break;
+
+                case "bar":
+                    template = "<bar x=10 y=30 w=100 h=8 val=75 />";
+                    break;
+
+                case "rect":
+                    template = "<rect x=10 y=40 w=50 h=20 />";
+                    break;
+
+                case "box":
+                    template = "<box x=70 y=40 w=50 h=20 />";
+                    break;
+
+                case "line":
+                    template = "<line x1=10 y1=50 x2=60 y2=50 />";
+                    break;
+
+                case "icon":
+                    template = "<icon x=130 y=20 name=cpu />";
+                    break;
+            }
+
+            if (!string.IsNullOrEmpty(template))
+            {
+                OledMarkup += Environment.NewLine + template;
+                UpdatePreviewFromMarkup();
+            }
         }
-
-        if (!string.IsNullOrEmpty(template))
+        catch (Exception ex)
         {
-            OledMarkup += Environment.NewLine + template;
-            UpdatePreviewFromMarkup();
+            Debug.WriteLine($"Error inserting markup template: {ex.Message}");
         }
     }
 
     private async Task InsertSensorVariableAsync()
     {
-        // Create a list of sensor options
-        var options = AvailableSensors.Select(s => $"{s.DisplayName} ({s.Id})").ToArray();
-
-        string result = await Shell.Current.DisplayActionSheet("Select a sensor", "Cancel", null, options);
-
-        if (!string.IsNullOrEmpty(result) && result != "Cancel")
+        try
         {
-            // Extract sensor ID
-            string id = result.Substring(result.LastIndexOf('(') + 1).TrimEnd(')');
+            // Create a list of sensor options
+            var options = AvailableSensors.Select(s => $"{s.DisplayName} ({s.Id})").ToArray();
 
-            // Insert the variable at the current cursor position (not implemented in this mock-up)
-            // In a real implementation, you'd need to track the cursor position in the editor
-            OledMarkup += $"{{{id}}}";
-            UpdatePreviewFromMarkup();
+            string result = await Shell.Current.DisplayActionSheet("Select a sensor", "Cancel", null, options);
+
+            if (!string.IsNullOrEmpty(result) && result != "Cancel")
+            {
+                // Extract sensor ID
+                string id = result.Substring(result.LastIndexOf('(') + 1).TrimEnd(')');
+
+                // Insert the variable at the current cursor position (not implemented in this mock-up)
+                // In a real implementation, you'd need to track the cursor position in the editor
+                OledMarkup += $"{{{id}}}";
+                UpdatePreviewFromMarkup();
+            }
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error inserting sensor variable: {ex.Message}");
         }
     }
 
     private async Task LoadExampleMarkupAsync()
     {
-        OledMarkup = await _sensorService.CreateExampleMarkupAsync();
-        await ParseMarkupToElementsAsync(OledMarkup);
-        UpdatePreviewFromMarkup();
+        try
+        {
+            OledMarkup = await _sensorService.CreateExampleMarkupAsync();
+            await ParseMarkupToElementsAsync(OledMarkup);
+            UpdatePreviewFromMarkup();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error loading example markup: {ex.Message}");
+        }
     }
 
     private async Task<string> CreateSystemMonitorTemplateAsync()
     {
-        return await _sensorService.CreateExampleMarkupAsync();
+        try
+        {
+            return await _sensorService.CreateExampleMarkupAsync();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error creating system monitor template: {ex.Message}");
+            return "<text x=10 y=20 size=1>System Monitor</text>";
+        }
     }
 
     private async Task<string> CreateTemperatureMonitorTemplateAsync()
     {
-        var sb = new System.Text.StringBuilder();
-
-        string cpuTemp = _sensorService.FindFirstSensorOfType(LibreHardwareMonitor.Hardware.HardwareType.Cpu,
-            LibreHardwareMonitor.Hardware.SensorType.Temperature);
-
-        string gpuTemp = _sensorService.FindFirstSensorOfType(LibreHardwareMonitor.Hardware.HardwareType.GpuNvidia,
-            LibreHardwareMonitor.Hardware.SensorType.Temperature);
-
-        sb.AppendLine("<text x=0 y=12 size=2>Temperatures</text>");
-
-        if (!string.IsNullOrEmpty(cpuTemp))
+        try
         {
-            sb.AppendLine($"<text x=0 y=30 size=1>CPU: {{{cpuTemp}}}°C</text>");
-        }
+            var sb = new System.Text.StringBuilder();
 
-        if (!string.IsNullOrEmpty(gpuTemp))
+            string cpuTemp = _sensorService.FindFirstSensorOfType(LibreHardwareMonitor.Hardware.HardwareType.Cpu,
+                LibreHardwareMonitor.Hardware.SensorType.Temperature);
+
+            string gpuTemp = _sensorService.FindFirstSensorOfType(LibreHardwareMonitor.Hardware.HardwareType.GpuNvidia,
+                LibreHardwareMonitor.Hardware.SensorType.Temperature);
+
+            sb.AppendLine("<text x=0 y=12 size=2>Temperatures</text>");
+
+            if (!string.IsNullOrEmpty(cpuTemp))
+            {
+                sb.AppendLine($"<text x=0 y=30 size=1>CPU: {{{cpuTemp}}}°C</text>");
+            }
+
+            if (!string.IsNullOrEmpty(gpuTemp))
+            {
+                sb.AppendLine($"<text x=0 y=45 size=1>GPU: {{{gpuTemp}}}°C</text>");
+            }
+
+            return sb.ToString();
+        }
+        catch (Exception ex)
         {
-            sb.AppendLine($"<text x=0 y=45 size=1>GPU: {{{gpuTemp}}}°C</text>");
+            Debug.WriteLine($"Error creating temperature monitor template: {ex.Message}");
+            return "<text x=10 y=20 size=1>Temperature Monitor</text>";
         }
-
-        return sb.ToString();
     }
 
     private async Task<string> CreateNetworkMonitorTemplateAsync()
     {
-        var sb = new System.Text.StringBuilder();
+        try
+        {
+            var sb = new System.Text.StringBuilder();
 
-        sb.AppendLine("<text x=0 y=12 size=2>Network Monitor</text>");
-        sb.AppendLine("<text x=0 y=30 size=1>Coming soon!</text>");
+            sb.AppendLine("<text x=0 y=12 size=2>Network Monitor</text>");
+            sb.AppendLine("<text x=0 y=30 size=1>Coming soon!</text>");
 
-        return sb.ToString();
+            return sb.ToString();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error creating network monitor template: {ex.Message}");
+            return "<text x=10 y=20 size=1>Network Monitor</text>";
+        }
     }
 
     private async Task<string> CreateStorageMonitorTemplateAsync()
     {
-        var sb = new System.Text.StringBuilder();
+        try
+        {
+            var sb = new System.Text.StringBuilder();
 
-        sb.AppendLine("<text x=0 y=12 size=2>Storage Monitor</text>");
-        sb.AppendLine("<text x=0 y=30 size=1>Coming soon!</text>");
+            sb.AppendLine("<text x=0 y=12 size=2>Storage Monitor</text>");
+            sb.AppendLine("<text x=0 y=30 size=1>Coming soon!</text>");
 
-        return sb.ToString();
+            return sb.ToString();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error creating storage monitor template: {ex.Message}");
+            return "<text x=10 y=20 size=1>Storage Monitor</text>";
+        }
     }
 
     private async Task UseSelectedTemplateAsync()
     {
-        if (SelectedTemplate == null)
+        try
         {
-            return;
+            if (SelectedTemplate == null)
+            {
+                return;
+            }
+
+            bool confirm = await Shell.Current.DisplayAlert(
+                "Apply Template",
+                "Are you sure you want to apply this template? This will replace your current design.",
+                "Apply", "Cancel");
+
+            if (confirm)
+            {
+                OledMarkup = SelectedTemplate.Markup;
+                await ParseMarkupToElementsAsync(OledMarkup);
+                UpdatePreviewFromMarkup();
+                SwitchTab("markup");
+            }
         }
-
-        bool confirm = await Shell.Current.DisplayAlert(
-            "Apply Template",
-            "Are you sure you want to apply this template? This will replace your current design.",
-            "Apply", "Cancel");
-
-        if (confirm)
+        catch (Exception ex)
         {
-            OledMarkup = SelectedTemplate.Markup;
-            await ParseMarkupToElementsAsync(OledMarkup);
-            UpdatePreviewFromMarkup();
-            SwitchTab("markup");
+            Debug.WriteLine($"Error using selected template: {ex.Message}");
         }
     }
 
     private async Task SaveAsTemplateAsync()
     {
-        if (string.IsNullOrWhiteSpace(NewTemplateName))
+        try
         {
-            await Shell.Current.DisplayAlert("Error", "Please enter a name for your template.", "OK");
-            return;
-        }
-
-        // Check for duplicate names
-        if (CustomTemplates.Any(t => t.Name == NewTemplateName))
-        {
-            bool replace = await Shell.Current.DisplayAlert(
-                "Template Exists",
-                "A template with this name already exists. Do you want to replace it?",
-                "Replace", "Cancel");
-
-            if (!replace)
+            if (string.IsNullOrWhiteSpace(NewTemplateName))
             {
+                await Shell.Current.DisplayAlert("Error", "Please enter a name for your template.", "OK");
                 return;
             }
 
-            // Remove the existing template
-            var existingTemplate = CustomTemplates.First(t => t.Name == NewTemplateName);
-            CustomTemplates.Remove(existingTemplate);
+            // Check for duplicate names
+            if (CustomTemplates.Any(t => t.Name == NewTemplateName))
+            {
+                bool replace = await Shell.Current.DisplayAlert(
+                    "Template Exists",
+                    "A template with this name already exists. Do you want to replace it?",
+                    "Replace", "Cancel");
+
+                if (!replace)
+                {
+                    return;
+                }
+
+                // Remove the existing template
+                var existingTemplate = CustomTemplates.First(t => t.Name == NewTemplateName);
+                CustomTemplates.Remove(existingTemplate);
+            }
+
+            // Create new template
+            var template = new Template
+            {
+                Name = NewTemplateName,
+                Description = "Custom template",
+                Markup = OledMarkup
+            };
+
+            template.PreviewElements = await ParseMarkupToPreviewElements(template.Markup);
+            CustomTemplates.Add(template);
+
+            // Save to configuration
+            var config = await _configService.LoadConfigAsync();
+
+            if (config.SavedProfiles == null)
+            {
+                config.SavedProfiles = new List<DisplayProfile>();
+            }
+
+            // Remove existing profile with same name
+            config.SavedProfiles.RemoveAll(p => p.Name == NewTemplateName && p.ScreenType == "OLED");
+
+            // Add new profile
+            config.SavedProfiles.Add(new DisplayProfile
+            {
+                Name = NewTemplateName,
+                ScreenType = "OLED",
+                ConfigData = OledMarkup
+            });
+
+            await _configService.SaveConfigAsync(config);
+
+            // Clear the input field
+            NewTemplateName = string.Empty;
+
+            await Shell.Current.DisplayAlert("Success", "Template saved successfully!", "OK");
         }
-
-        // Create new template
-        var template = new Template
+        catch (Exception ex)
         {
-            Name = NewTemplateName,
-            Description = "Custom template",
-            Markup = OledMarkup
-        };
-
-        template.PreviewElements = await ParseMarkupToPreviewElements(template.Markup);
-        CustomTemplates.Add(template);
-
-        // Save to configuration
-        var config = await _configService.LoadConfigAsync();
-
-        if (config.SavedProfiles == null)
-        {
-            config.SavedProfiles = new List<DisplayProfile>();
+            Debug.WriteLine($"Error saving as template: {ex.Message}");
+            await Shell.Current.DisplayAlert("Error", $"Failed to save template: {ex.Message}", "OK");
         }
-
-        // Remove existing profile with same name
-        config.SavedProfiles.RemoveAll(p => p.Name == NewTemplateName && p.ScreenType == "OLED");
-
-        // Add new profile
-        config.SavedProfiles.Add(new DisplayProfile
-        {
-            Name = NewTemplateName,
-            ScreenType = "OLED",
-            ConfigData = OledMarkup
-        });
-
-        await _configService.SaveConfigAsync(config);
-
-        // Clear the input field
-        NewTemplateName = string.Empty;
-
-        await Shell.Current.DisplayAlert("Success", "Template saved successfully!", "OK");
     }
 
     private async Task UseCustomTemplateAsync(Template template)
     {
-        if (template == null)
+        try
         {
-            return;
+            if (template == null)
+            {
+                return;
+            }
+
+            bool confirm = await Shell.Current.DisplayAlert(
+                "Apply Template",
+                "Are you sure you want to apply this template? This will replace your current design.",
+                "Apply", "Cancel");
+
+            if (confirm)
+            {
+                OledMarkup = template.Markup;
+                await ParseMarkupToElementsAsync(OledMarkup);
+                UpdatePreviewFromMarkup();
+                SwitchTab("markup");
+            }
         }
-
-        bool confirm = await Shell.Current.DisplayAlert(
-            "Apply Template",
-            "Are you sure you want to apply this template? This will replace your current design.",
-            "Apply", "Cancel");
-
-        if (confirm)
+        catch (Exception ex)
         {
-            OledMarkup = template.Markup;
-            await ParseMarkupToElementsAsync(OledMarkup);
-            UpdatePreviewFromMarkup();
-            SwitchTab("markup");
+            Debug.WriteLine($"Error using custom template: {ex.Message}");
         }
     }
 
     private async Task DeleteCustomTemplateAsync(Template template)
     {
-        if (template == null)
+        try
         {
-            return;
-        }
-
-        bool confirm = await Shell.Current.DisplayAlert(
-            "Delete Template",
-            $"Are you sure you want to delete the template '{template.Name}'?",
-            "Delete", "Cancel");
-
-        if (confirm)
-        {
-            CustomTemplates.Remove(template);
-
-            // Update configuration
-            var config = await _configService.LoadConfigAsync();
-
-            if (config.SavedProfiles != null)
+            if (template == null)
             {
-                config.SavedProfiles.RemoveAll(p => p.Name == template.Name && p.ScreenType == "OLED");
-                await _configService.SaveConfigAsync(config);
+                return;
             }
+
+            bool confirm = await Shell.Current.DisplayAlert(
+                "Delete Template",
+                $"Are you sure you want to delete the template '{template.Name}'?",
+                "Delete", "Cancel");
+
+            if (confirm)
+            {
+                CustomTemplates.Remove(template);
+
+                // Update configuration
+                var config = await _configService.LoadConfigAsync();
+
+                if (config.SavedProfiles != null)
+                {
+                    config.SavedProfiles.RemoveAll(p => p.Name == template.Name && p.ScreenType == "OLED");
+                    await _configService.SaveConfigAsync(config);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error deleting custom template: {ex.Message}");
         }
     }
 }
diff --git a/PCPal/Core/Services/SerialPortService.cs b/PCPal/Core/Services/SerialPortService.cs
index 1390bbf..5ae9120 100644
--- a/PCPal/Core/Services/SerialPortService.cs
+++ b/PCPal/Core/Services/SerialPortService.cs
@@ -16,12 +16,13 @@ public interface ISerialPortService
     event EventHandler<bool> ConnectionStatusChanged;
 }
 
-public class SerialPortService : ISerialPortService
+public class SerialPortService : ISerialPortService, IDisposable
 {
     private SerialPort _serialPort;
     private bool _isConnected;
     private string _currentPort;
     private readonly ILogger<SerialPortService> _logger;
+    private bool _disposed = false;
 
     public bool IsConnected => _isConnected;
     public string CurrentPort => _currentPort;
@@ -30,13 +31,19 @@ public class SerialPortService : ISerialPortService
 
     public SerialPortService(ILogger<SerialPortService> logger)
     {
-        _logger = logger;
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         _isConnected = false;
         _currentPort = string.Empty;
     }
 
     public async Task<bool> ConnectAsync(string port)
     {
+        if (string.IsNullOrEmpty(port))
+        {
+            _logger.LogWarning("Cannot connect to null or empty port name");
+            return false;
+        }
+
         try
         {
             // Disconnect if already connected
@@ -71,6 +78,7 @@ public class SerialPortService : ISerialPortService
             // Not a valid PCPal device, close the connection
             _serialPort.Close();
             _serialPort.Dispose();
+            _serialPort = null;
             return false;
         }
         catch (Exception ex)
@@ -81,6 +89,7 @@ public class SerialPortService : ISerialPortService
             {
                 _serialPort.Close();
                 _serialPort.Dispose();
+                _serialPort = null;
             }
 
             return false;
@@ -126,8 +135,15 @@ public class SerialPortService : ISerialPortService
 
     public async Task<bool> SendCommandAsync(string command)
     {
+        if (string.IsNullOrEmpty(command))
+        {
+            _logger.LogWarning("Cannot send null or empty command");
+            return false;
+        }
+
         if (!_isConnected || _serialPort == null || !_serialPort.IsOpen)
         {
+            _logger.LogWarning("Cannot send command: Device not connected");
             return false;
         }
 
@@ -155,9 +171,10 @@ public class SerialPortService : ISerialPortService
 
         foreach (string port in ports)
         {
+            SerialPort testPort = null;
             try
             {
-                using SerialPort testPort = new SerialPort(port, 115200)
+                testPort = new SerialPort(port, 115200)
                 {
                     ReadTimeout = 1000,
                     WriteTimeout = 1000
@@ -173,15 +190,33 @@ public class SerialPortService : ISerialPortService
                     response.Contains("DISPLAY_TYPE:OLED") ||
                     response.Contains("DISPLAY_TYPE:TFT"))
                 {
+                    // Make sure to close and dispose the port before returning
+                    testPort.Close();
+                    testPort.Dispose();
                     return port;
                 }
 
                 testPort.Close();
+                testPort.Dispose();
             }
-            catch
+            catch (Exception ex)
             {
-                // Skip ports that can't be opened
-                continue;
+                _logger.LogDebug(ex, $"Failed to check port {port}");
+
+                // Clean up the port if an exception occurs
+                if (testPort != null)
+                {
+                    try
+                    {
+                        if (testPort.IsOpen)
+                            testPort.Close();
+                        testPort.Dispose();
+                    }
+                    catch (Exception disposalEx)
+                    {
+                        _logger.LogDebug(disposalEx, $"Error disposing test port {port}");
+                    }
+                }
             }
         }
 
@@ -224,8 +259,10 @@ public class SerialPortService : ISerialPortService
 
             return connected;
         }
-        catch
+        catch (Exception ex)
         {
+            _logger.LogError(ex, "Error checking connection");
+
             if (_isConnected)
             {
                 _isConnected = false;
@@ -236,4 +273,40 @@ public class SerialPortService : ISerialPortService
             return false;
         }
     }
+
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (!_disposed)
+        {
+            if (disposing)
+            {
+                if (_serialPort != null && _serialPort.IsOpen)
+                {
+                    try
+                    {
+                        _serialPort.Close();
+                        _serialPort.Dispose();
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "Error disposing serial port");
+                    }
+                    _serialPort = null;
+                }
+            }
+
+            _disposed = true;
+        }
+    }
+
+    ~SerialPortService()
+    {
+        Dispose(false);
+    }
 }
\ No newline at end of file