diff --git a/GUIDE.md b/GUIDE.md
new file mode 100644
index 0000000..2c4e243
--- /dev/null
+++ b/GUIDE.md
@@ -0,0 +1,1226 @@
+
+# OpenMaui Linux Samples - User Guide
+
+A collection of sample applications demonstrating .NET MAUI applications running on Linux using the OpenMaui Linux platform. These samples showcase various MAUI controls, navigation patterns, and features working with SkiaSharp-based rendering on Linux desktop.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Getting Started](#getting-started)
+ - [Prerequisites](#prerequisites)
+ - [Installation](#installation)
+ - [Building the Samples](#building-the-samples)
+ - [Running the Applications](#running-the-applications)
+- [Sample Applications](#sample-applications)
+ - [ShellDemo](#shelldemo)
+ - [TodoApp](#todoapp)
+ - [WebViewDemo](#webviewdemo)
+- [Common Workflows](#common-workflows)
+ - [Creating a New Linux MAUI App](#creating-a-new-linux-maui-app)
+ - [Adding OpenMaui Linux Support](#adding-openmaui-linux-support)
+ - [Implementing Navigation](#implementing-navigation)
+ - [Working with Themes](#working-with-themes)
+- [Project Structure](#project-structure)
+- [API Reference](#api-reference)
+ - [MauiProgram Configuration](#mauiprogram-configuration)
+ - [Platform Entry Point](#platform-entry-point)
+ - [Navigation APIs](#navigation-apis)
+ - [Dialog Services](#dialog-services)
+- [Tips and Best Practices](#tips-and-best-practices)
+- [Troubleshooting](#troubleshooting)
+
+## Overview
+
+This repository contains three production-ready sample applications that demonstrate different aspects of building .NET MAUI applications for Linux:
+
+- **ShellDemo**: Comprehensive showcase of MAUI controls (buttons, text input, lists, pickers, grids) with Shell-based navigation
+- **TodoApp**: Full-featured task management app demonstrating NavigationPage, MVVM patterns, and data binding
+- **WebViewDemo**: Web browser application showcasing WebKitGTK integration with HTML rendering and JavaScript execution
+
+All samples are built on the OpenMaui.Controls.Linux platform, which brings .NET MAUI to Linux desktop using SkiaSharp for rendering.
+
+## Getting Started
+
+### Prerequisites
+
+Before you begin, ensure you have the following installed on your Linux system:
+
+- **.NET 9.0 SDK** or later
+- **OpenMaui.Controls.Linux** package or source
+- **GTK 3** (for WebView support)
+- **WebKitGTK** (for WebViewDemo)
+
+Install system dependencies on Ubuntu/Debian:
+
+```bash
+sudo apt-get update
+sudo apt-get install dotnet-sdk-9.0 libgtk-3-dev libwebkit2gtk-4.0-dev
+```
+
+### Installation
+
+Clone the repository:
+
+```bash
+git clone https://github.com/openmaui/maui-linux-samples.git
+cd maui-linux-samples
+```
+
+The samples support two development modes:
+
+**Local Development** (with OpenMaui source):
+```bash
+# Clone OpenMaui alongside the samples
+cd ..
+git clone https://github.com/openmaui/maui-linux.git
+cd maui-linux-samples
+```
+
+**Package Reference** (using NuGet):
+```bash
+# Set environment variable to use package reference
+export UsePackageReference=true
+```
+
+### Building the Samples
+
+Build all samples in the solution:
+
+```bash
+dotnet build maui-linux-samples.sln
+```
+
+Build a specific sample:
+
+```bash
+cd ShellDemo
+dotnet build
+```
+
+Build for release:
+
+```bash
+dotnet build -c Release
+```
+
+### Running the Applications
+
+Each sample includes a `run.sh` script for easy execution:
+
+```bash
+cd ShellDemo
+./run.sh
+```
+
+Or run directly with `dotnet`:
+
+```bash
+cd ShellDemo
+dotnet run
+```
+
+Run from the compiled output:
+
+```bash
+cd ShellDemo/bin/Debug/net9.0
+./ShellDemo
+```
+
+## Sample Applications
+
+### ShellDemo
+
+A comprehensive demonstration of MAUI controls and Shell navigation patterns.
+
+**Features:**
+- Shell-based navigation with flyout menu
+- Button controls with various styles and events
+- Text input controls (Entry, Editor, SearchBar)
+- Selection controls (CheckBox, Switch, Slider)
+- Pickers (Picker, DatePicker, TimePicker)
+- CollectionView with selection and data binding
+- Progress indicators (ProgressBar, ActivityIndicator)
+- Grid layouts with various sizing options
+- Theme switching (Light/Dark mode)
+- Push/pop navigation for detail pages
+
+**Key Files:**
+- `AppShell.xaml` - Shell configuration with flyout menu
+- `Pages/HomePage.xaml` - Welcome page with feature cards
+- `Pages/ButtonsPage.xaml` - Button demonstrations
+- `Pages/ListsPage.xaml` - CollectionView examples
+- `Pages/GridsPage.xaml` - Grid layout demonstrations
+
+**Running ShellDemo:**
+
+```bash
+cd ShellDemo
+./run.sh
+```
+
+**Example: Navigating to a detail page**
+
+```csharp
+// From any page in ShellDemo
+private void OnPushDetailClicked(object? sender, EventArgs e)
+{
+ var success = LinuxViewRenderer.PushPage(new DetailPage("My Item"));
+ Console.WriteLine($"Navigation result: {success}");
+}
+```
+
+**Log File Location:**
+
+ShellDemo writes diagnostic logs to `~/shelldemo.log` for debugging.
+
+### TodoApp
+
+A full-featured task management application demonstrating real-world MAUI patterns.
+
+**Features:**
+- NavigationPage-based navigation
+- CRUD operations (Create, Read, Update, Delete)
+- Data binding with INotifyPropertyChanged
+- ObservableCollection for reactive lists
+- Custom value converters for UI logic
+- Alternating row colors in lists
+- Task completion tracking with statistics
+- Confirmation dialogs for destructive actions
+- Theme support with dynamic color updates
+
+**Key Files:**
+- `App.xaml.cs` - NavigationPage setup
+- `TodoItem.cs` - Data model with property change notifications
+- `TodoService.cs` - Business logic and data management
+- `Pages/TodoListPage.xaml` - Main list view with statistics
+- `Pages/TodoDetailPage.xaml` - Task editing and deletion
+- `Pages/NewTodoPage.xaml` - Task creation form
+
+**Running TodoApp:**
+
+```bash
+cd TodoApp
+./run.sh
+```
+
+**Example: Adding a new task**
+
+```csharp
+// In NewTodoPage.xaml.cs
+private async void OnSaveClicked(object? sender, EventArgs e)
+{
+ var title = TitleEntry.Text?.Trim();
+
+ if (string.IsNullOrEmpty(title))
+ {
+ TitleEntry.Placeholder = "Title is required!";
+ TitleEntry.PlaceholderColor = Colors.Red;
+ return;
+ }
+
+ TodoService.Instance.AddTodo(title, NotesEditor.Text ?? "");
+ await Navigation.PopAsync();
+}
+```
+
+**Example: Custom value converter**
+
+```csharp
+// Converter for alternating row colors with theme support
+public class AlternatingRowColorConverter : IValueConverter
+{
+ public object? Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+ {
+ bool isDarkMode = Application.Current?.RequestedTheme == AppTheme.Dark;
+
+ if (value is int index)
+ {
+ if (isDarkMode)
+ return index % 2 == 0 ? Color.FromArgb("#1E1E1E") : Color.FromArgb("#2A2A2A");
+ return index % 2 == 0 ? Colors.White : Color.FromArgb("#F5F5F5");
+ }
+ return isDarkMode ? Color.FromArgb("#1E1E1E") : Colors.White;
+ }
+
+ public object? ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+ {
+ throw new NotImplementedException();
+ }
+}
+```
+
+**Log File Location:**
+
+TodoApp writes diagnostic logs to `~/todoapp.log`.
+
+### WebViewDemo
+
+A web browser application showcasing WebKitGTK integration with MAUI.
+
+**Features:**
+- WebView with WebKitGTK backend
+- URL navigation with address bar
+- Back/forward navigation history
+- Page reload functionality
+- HTML content loading (local and remote)
+- JavaScript execution and evaluation
+- Progress indication during page loads
+- Theme switching
+- Double-click to select all in URL entry
+
+**Key Files:**
+- `Pages/WebViewPage.xaml` - Main browser interface
+- `Program.cs` - GTK mode initialization for WebView
+
+**Running WebViewDemo:**
+
+```bash
+cd WebViewDemo
+./run.sh
+```
+
+**Example: Loading a URL**
+
+```csharp
+private void Navigate()
+{
+ var url = UrlEntry.Text?.Trim();
+ if (string.IsNullOrEmpty(url))
+ return;
+
+ // Add https:// if not present
+ if (!url.StartsWith("http://") && !url.StartsWith("https://"))
+ url = "https://" + url;
+
+ MainWebView.Source = new UrlWebViewSource { Url = url };
+ UrlEntry.Text = url;
+}
+```
+
+**Example: Loading HTML content**
+
+```csharp
+private void OnLoadHtmlClicked(object? sender, EventArgs e)
+{
+ var html = @"
+
+
+
+ OpenMaui WebView
+
+
+
+
Hello from OpenMaui Linux!
+
This HTML is rendered by WebKitGTK.
+
+";
+
+ MainWebView.Source = new HtmlWebViewSource { Html = html };
+}
+```
+
+**Example: Evaluating JavaScript**
+
+```csharp
+private async void OnEvalJsClicked(object? sender, EventArgs e)
+{
+ try
+ {
+ var result = await MainWebView.EvaluateJavaScriptAsync("document.title");
+ StatusLabel.Text = $"Page title: {result}";
+ }
+ catch (Exception ex)
+ {
+ StatusLabel.Text = $"Error: {ex.Message}";
+ }
+}
+```
+
+**GTK Mode Requirement:**
+
+WebViewDemo requires GTK mode to be enabled in `Program.cs`:
+
+```csharp
+LinuxApplication.Run(app, args, options =>
+{
+ options.UseGtk = true;
+});
+```
+
+**Log File Location:**
+
+WebViewDemo writes diagnostic logs to `~/webviewdemo.log`.
+
+## Common Workflows
+
+### Creating a New Linux MAUI App
+
+Create a new .NET MAUI application that runs on Linux:
+
+**Step 1: Create project structure**
+
+```bash
+mkdir MyLinuxApp
+cd MyLinuxApp
+dotnet new console -n MyLinuxApp
+```
+
+**Step 2: Update the .csproj file**
+
+```xml
+
+
+ Exe
+ net9.0
+ enable
+ enable
+ true
+
+ My Linux App
+ com.mycompany.mylinuxapp
+ 1.0.0
+
+ true
+ true
+
+
+
+ linux-x64;linux-arm64
+
+
+
+
+
+
+```
+
+**Step 3: Create Program.cs**
+
+```csharp
+using Microsoft.Maui.Platform.Linux;
+
+namespace MyLinuxApp;
+
+class Program
+{
+ static void Main(string[] args)
+ {
+ var logPath = Path.Combine(
+ Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+ "mylinuxapp.log");
+ using var logWriter = new StreamWriter(logPath, append: false) { AutoFlush = true };
+ var multiWriter = new MultiTextWriter(Console.Out, logWriter);
+ Console.SetOut(multiWriter);
+
+ Console.WriteLine($"Starting MyLinuxApp at {DateTime.Now}");
+
+ var app = MauiProgram.CreateMauiApp();
+ LinuxApplication.Run(app, args);
+ }
+}
+
+class MultiTextWriter : TextWriter
+{
+ private readonly TextWriter[] _writers;
+ public MultiTextWriter(params TextWriter[] writers) => _writers = writers;
+ public override System.Text.Encoding Encoding => System.Text.Encoding.UTF8;
+ public override void Write(char value) { foreach (var w in _writers) w.Write(value); }
+ public override void WriteLine(string? value) { foreach (var w in _writers) w.WriteLine(value); }
+}
+```
+
+**Step 4: Create MauiProgram.cs**
+
+```csharp
+using Microsoft.Maui.Hosting;
+using Microsoft.Maui.Platform.Linux.Hosting;
+
+namespace MyLinuxApp;
+
+public static class MauiProgram
+{
+ public static MauiApp CreateMauiApp()
+ {
+ var builder = MauiApp.CreateBuilder();
+ builder.UseMauiApp();
+ builder.UseLinux();
+ return builder.Build();
+ }
+}
+```
+
+**Step 5: Create App.xaml and App.xaml.cs**
+
+```xml
+
+
+
+
+
+
+
+
+
+```
+
+```csharp
+// App.xaml.cs
+using Microsoft.Maui.Controls;
+
+namespace MyLinuxApp;
+
+public partial class App : Application
+{
+ public App()
+ {
+ InitializeComponent();
+ }
+
+ protected override Window CreateWindow(IActivationState? activationState)
+ {
+ return new Window(new MainPage());
+ }
+}
+```
+
+**Step 6: Build and run**
+
+```bash
+dotnet build
+dotnet run
+```
+
+### Adding OpenMaui Linux Support
+
+Add Linux support to an existing MAUI project:
+
+**Step 1: Update .csproj conditionally**
+
+```xml
+
+
+ linux-x64;linux-arm64
+
+
+
+
+
+
+```
+
+**Step 2: Update MauiProgram.cs**
+
+```csharp
+using Microsoft.Maui.Hosting;
+using Microsoft.Maui.Platform.Linux.Hosting;
+
+public static class MauiProgram
+{
+ public static MauiApp CreateMauiApp()
+ {
+ var builder = MauiApp.CreateBuilder();
+ builder.UseMauiApp();
+
+ // Add Linux platform support
+ builder.UseLinux();
+
+ return builder.Build();
+ }
+}
+```
+
+**Step 3: Create Linux entry point (Program.cs)**
+
+```csharp
+using Microsoft.Maui.Platform.Linux;
+
+namespace YourApp;
+
+class Program
+{
+ static void Main(string[] args)
+ {
+ var app = MauiProgram.CreateMauiApp();
+ LinuxApplication.Run(app, args);
+ }
+}
+```
+
+### Implementing Navigation
+
+OpenMaui Linux supports multiple navigation patterns:
+
+**Shell Navigation (ShellDemo pattern)**
+
+```csharp
+// AppShell.xaml
+
+
+
+
+
+
+
+
+
+
+
+```
+
+```csharp
+// AppShell.xaml.cs
+public partial class AppShell : Shell
+{
+ public AppShell()
+ {
+ InitializeComponent();
+
+ // Register routes for push navigation
+ Routing.RegisterRoute("details", typeof(DetailsPage));
+ }
+}
+
+// Navigate using routes
+await Shell.Current.GoToAsync("details?id=123");
+```
+
+**NavigationPage Pattern (TodoApp pattern)**
+
+```csharp
+// App.xaml.cs
+protected override Window CreateWindow(IActivationState? activationState)
+{
+ var navigationPage = new NavigationPage(new MainPage())
+ {
+ BarBackgroundColor = Color.FromArgb("#5C6BC0"),
+ BarTextColor = Colors.White
+ };
+
+ return new Window(navigationPage);
+}
+
+// Push a new page
+await Navigation.PushAsync(new DetailsPage());
+
+// Pop back
+await Navigation.PopAsync();
+```
+
+**Direct Push/Pop with LinuxViewRenderer**
+
+```csharp
+// Push a page directly
+var success = LinuxViewRenderer.PushPage(new DetailPage());
+
+// Pop the current page
+var success = LinuxViewRenderer.PopPage();
+
+// Navigate to a Shell route
+LinuxViewRenderer.NavigateToRoute("settings");
+```
+
+### Working with Themes
+
+All samples support Light and Dark themes with dynamic switching.
+
+**Step 1: Define theme resources in App.xaml**
+
+```xml
+
+
+
+ #5C6BC0
+ #FFFFFF
+ #212121
+
+
+ #3949AB
+ #121212
+ #FFFFFF
+
+
+```
+
+**Step 2: Use AppThemeBinding in XAML**
+
+```xml
+
+```
+
+**Step 3: Use SetAppThemeColor in code**
+
+```csharp
+var label = new Label { Text = "Hello World" };
+label.SetAppThemeColor(
+ Label.TextColorProperty,
+ Color.FromArgb("#212121"), // Light
+ Color.FromArgb("#FFFFFF") // Dark
+);
+```
+
+**Step 4: Toggle theme programmatically**
+
+```csharp
+private void OnThemeToggleClicked(object? sender, EventArgs e)
+{
+ if (Application.Current == null) return;
+
+ var currentTheme = Application.Current.UserAppTheme;
+ var newTheme = currentTheme == AppTheme.Dark ? AppTheme.Light : AppTheme.Dark;
+
+ Application.Current.UserAppTheme = newTheme;
+}
+```
+
+**Step 5: Respond to theme changes**
+
+```csharp
+protected override void OnAppearing()
+{
+ base.OnAppearing();
+ UpdateThemeUI();
+}
+
+private void UpdateThemeUI()
+{
+ var isDark = Application.Current?.UserAppTheme == AppTheme.Dark ||
+ (Application.Current?.UserAppTheme == AppTheme.Unspecified &&
+ Application.Current?.RequestedTheme == AppTheme.Dark);
+
+ ThemeIcon.Source = isDark ? "light_mode.svg" : "dark_mode.svg";
+}
+```
+
+## Project Structure
+
+All sample projects follow a consistent structure:
+
+```
+SampleApp/
+├── Program.cs # Linux platform entry point
+├── MauiProgram.cs # MAUI app configuration
+├── App.xaml # Application resources and theme
+├── App.xaml.cs # Application code-behind
+├── AppShell.xaml # Shell navigation (ShellDemo only)
+├── Pages/ # Application pages
+│ ├── HomePage.xaml
+│ ├── HomePage.xaml.cs
+│ └── ...
+├── Resources/ # Images, icons, fonts
+│ ├── AppIcon/
+│ └── Images/
+├── run.sh # Launch script
+└── SampleApp.csproj # Project file
+```
+
+**Key Components:**
+
+| File | Purpose |
+|------|---------|
+| `Program.cs` | Platform entry point, sets up logging and exception handling |
+| `MauiProgram.cs` | Configures MAUI app with `UseLinux()` extension |
+| `App.xaml` | Application-level resources, themes, and styles |
+| `AppShell.xaml` | Shell navigation structure (flyout, tabs, routes) |
+| `*.csproj` | Project configuration with conditional Linux support |
+| `run.sh` | Convenience script for launching the app |
+
+## API Reference
+
+### MauiProgram Configuration
+
+Configure your MAUI app for Linux in `MauiProgram.cs`:
+
+```csharp
+using Microsoft.Maui.Hosting;
+using Microsoft.Maui.Platform.Linux.Hosting;
+
+public static class MauiProgram
+{
+ public static MauiApp CreateMauiApp()
+ {
+ var builder = MauiApp.CreateBuilder();
+
+ // Register your app
+ builder.UseMauiApp();
+
+ // Add Linux platform support (registers all handlers)
+ builder.UseLinux();
+
+ // Configure fonts (optional)
+ builder.ConfigureFonts(fonts =>
+ {
+ fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
+ fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
+ });
+
+ return builder.Build();
+ }
+}
+```
+
+### Platform Entry Point
+
+Create a Linux entry point in `Program.cs`:
+
+```csharp
+using Microsoft.Maui.Platform.Linux;
+
+class Program
+{
+ static void Main(string[] args)
+ {
+ // Optional: Set up logging
+ var logPath = Path.Combine(
+ Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+ "myapp.log");
+ using var logWriter = new StreamWriter(logPath, append: false) { AutoFlush = true };
+ var multiWriter = new MultiTextWriter(Console.Out, logWriter);
+ Console.SetOut(multiWriter);
+ Console.SetError(multiWriter);
+
+ // Optional: Global exception handlers
+ AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
+ {
+ var ex = e.ExceptionObject as Exception;
+ Console.WriteLine($"[FATAL] Unhandled exception: {ex?.Message}");
+ };
+
+ try
+ {
+ var app = MauiProgram.CreateMauiApp();
+
+ // Run with default options
+ LinuxApplication.Run(app, args);
+
+ // Or run with GTK mode (required for WebView)
+ // LinuxApplication.Run(app, args, options =>
+ // {
+ // options.UseGtk = true;
+ // });
+ }
+ catch (Exception ex)
+ {
+ Console.WriteLine($"[FATAL] Exception in Main: {ex.Message}");
+ throw;
+ }
+ }
+}
+```
+
+### Navigation APIs
+
+Navigate between pages using these APIs:
+
+**LinuxViewRenderer.PushPage**
+
+```csharp
+// Push a new page onto the navigation stack
+bool success = LinuxViewRenderer.PushPage(new DetailPage());
+```
+
+**LinuxViewRenderer.PopPage**
+
+```csharp
+// Pop the current page from the navigation stack
+bool success = LinuxViewRenderer.PopPage();
+```
+
+**LinuxViewRenderer.NavigateToRoute**
+
+```csharp
+// Navigate to a registered Shell route
+LinuxViewRenderer.NavigateToRoute("settings");
+```
+
+**Navigation Property (in NavigationPage)**
+
+```csharp
+// Push a page
+await Navigation.PushAsync(new DetailPage());
+
+// Pop a page
+await Navigation.PopAsync();
+
+// Pop to root
+await Navigation.PopToRootAsync();
+```
+
+**Shell Navigation**
+
+```csharp
+// Navigate to a route
+await Shell.Current.GoToAsync("details");
+
+// Navigate with parameters
+await Shell.Current.GoToAsync($"details?id={itemId}");
+
+// Navigate back
+await Shell.Current.GoToAsync("..");
+```
+
+### Dialog Services
+
+Show alerts and confirmation dialogs:
+
+**LinuxDialogService.ShowAlertAsync**
+
+```csharp
+// Show confirmation dialog
+bool confirmed = await LinuxDialogService.ShowAlertAsync(
+ "Delete Task",
+ "Are you sure you want to delete this task?",
+ "Delete",
+ "Cancel");
+
+if (confirmed)
+{
+ // User clicked "Delete"
+ DeleteTask();
+}
+```
+
+**DisplayAlert (MAUI standard)**
+
+```csharp
+// Show alert with OK button
+await DisplayAlert("Success", "Task saved successfully", "OK");
+
+// Show confirmation dialog
+bool answer = await DisplayAlert(
+ "Confirm",
+ "Delete this item?",
+ "Yes",
+ "No");
+```
+
+## Tips and Best Practices
+
+### Performance
+
+1. **Use compiled bindings** for better performance:
+ ```xml
+
+ ```
+
+2. **Virtualize lists** with CollectionView (default behavior):
+ ```xml
+
+ ```
+
+3. **Avoid excessive property change notifications**:
+ ```csharp
+ private string _title;
+ public string Title
+ {
+ get => _title;
+ set
+ {
+ if (_title != value) // Only notify if changed
+ {
+ _title = value;
+ OnPropertyChanged(nameof(Title));
+ }
+ }
+ }
+ ```
+
+### Logging and Debugging
+
+1. **All samples write logs** to `~/appname.log`:
+ ```bash
+ tail -f ~/shelldemo.log
+ ```
+
+2. **Add console logging** throughout your app:
+ ```csharp
+ Console.WriteLine($"[MyPage] Button clicked at {DateTime.Now}");
+ ```
+
+3. **Use global exception handlers** (see `Program.cs` examples)
+
+### Theme Support
+
+1. **Always use AppThemeBinding** for colors that should change with theme:
+ ```xml
+
+
+
+ ```
+
+2. **Test both themes** during development:
+ ```csharp
+ Application.Current.UserAppTheme = AppTheme.Dark; // Test dark mode
+ ```
+
+3. **Update UI when theme changes**:
+ ```csharp
+ Application.Current.RequestedThemeChanged += (s, e) =>
+ {
+ UpdateThemeSpecificUI();
+ };
+ ```
+
+### Resource Management
+
+1. **Use embedded resources** for images:
+ ```xml
+
+
+
+ ```
+
+2. **Reference images** in XAML:
+ ```xml
+
+ ```
+
+### Navigation Patterns
+
+1. **Use Shell for complex navigation** (flyout, tabs, routes)
+2. **Use NavigationPage for simple hierarchical navigation**
+3. **Register routes** for type-safe navigation:
+ ```csharp
+ Routing.RegisterRoute("details", typeof(DetailsPage));
+ ```
+
+### Data Binding
+
+1. **Implement INotifyPropertyChanged** for reactive data:
+ ```csharp
+ public class TodoItem : INotifyPropertyChanged
+ {
+ private bool _isCompleted;
+ public bool IsCompleted
+ {
+ get => _isCompleted;
+ set
+ {
+ if (_isCompleted != value)
+ {
+ _isCompleted = value;
+ OnPropertyChanged(nameof(IsCompleted));
+ }
+ }
+ }
+
+ public event PropertyChangedEventHandler? PropertyChanged;
+
+ protected void OnPropertyChanged(string propertyName)
+ {
+ PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+ }
+ }
+ ```
+
+2. **Use ObservableCollection** for lists:
+ ```csharp
+ public ObservableCollection Todos { get; } = new();
+ ```
+
+## Troubleshooting
+
+### Application won't start
+
+**Problem:** App crashes immediately on launch
+
+**Solutions:**
+
+1. Check the log file (`~/appname.log`):
+ ```bash
+ cat ~/shelldemo.log
+ ```
+
+2. Verify .NET SDK is installed:
+ ```bash
+ dotnet --version
+ ```
+
+3. Ensure OpenMaui package is referenced:
+ ```bash
+ dotnet restore
+ dotnet build
+ ```
+
+4. Check for missing dependencies:
+ ```bash
+ ldd bin/Debug/net9.0/ShellDemo
+ ```
+
+### WebView not working
+
+**Problem:** WebView shows blank or crashes
+
+**Solutions:**
+
+1. Verify WebKitGTK is installed:
+ ```bash
+ sudo apt-get install libwebkit2gtk-4.0-dev
+ ```
+
+2. Ensure GTK mode is enabled in `Program.cs`:
+ ```csharp
+ LinuxApplication.Run(app, args, options =>
+ {
+ options.UseGtk = true;
+ });
+ ```
+
+3. Check WebView logs:
+ ```bash
+ cat ~/webviewdemo.log | grep WebView
+ ```
+
+### Navigation not working
+
+**Problem:** PushPage or PopPage returns false
+
+**Solutions:**
+
+1. Ensure you're in a NavigationPage or Shell context:
+ ```csharp
+ // Check if navigation is available
+ if (Navigation != null)
+ {
+ await Navigation.PushAsync(new DetailPage());
+ }
+ ```
+
+2. For Shell navigation, register routes:
+ ```csharp
+ Routing.RegisterRoute("details", typeof(DetailsPage));
+ ```
+
+3. Check console output for navigation errors:
+ ```bash
+ grep "Navigation" ~/shelldemo.log
+ ```
+
+### Theme not updating
+
+**Problem:** UI doesn't update when theme changes
+
+**Solutions:**
+
+1. Use `AppThemeBinding` instead of static colors:
+ ```xml
+
+
+
+
+
+ ```
+
+2. Subscribe to theme change events:
+ ```csharp
+ Application.Current.RequestedThemeChanged += (s, e) =>
+ {
+ UpdateUI();
+ };
+ ```
+
+3. Force UI refresh in `OnAppearing`:
+ ```csharp
+ protected override void OnAppearing()
+ {
+ base.OnAppearing();
+ UpdateThemeUI();
+ }
+ ```
+
+### Build errors on Linux
+
+**Problem:** Build fails with missing references
+
+**Solutions:**
+
+1. Restore packages:
+ ```bash
+ dotnet restore
+ ```
+
+2. Clean and rebuild:
+ ```bash
+ dotnet clean
+ dotnet build
+ ```
+
+3. Check .csproj conditional compilation:
+ ```xml
+
+
+
+ ```
+
+4. Verify you're on Linux:
+ ```bash
+ uname -a
+ ```
+
+### Images not displaying
+
+**Problem:** Images show as blank or missing
+
+**Solutions:**
+
+1. Check image paths are correct:
+ ```xml
+
+ ```
+
+2. Verify images are included in .csproj:
+ ```xml
+
+
+
+ ```
+
+3. Use absolute paths for testing:
+ ```csharp
+ Image.Source = ImageSource.FromFile("/full/path/to/image.png");
+ ```
+
+### Performance issues
+
+**Problem:** App is slow or unresponsive
+
+**Solutions:**
+
+1. Use virtualization for long lists (CollectionView does this by default)
+
+2. Avoid binding to expensive properties:
+ ```csharp
+ // Bad: Computed property called on every frame
+ public string ExpensiveProperty => ComputeExpensiveValue();
+
+ // Good: Cache the value
+ private string _cachedValue;
+ public string CachedProperty => _cachedValue ??= ComputeExpensiveValue();
+ ```
+
+3. Profile with console timestamps:
+ ```csharp
+ var sw = System.Diagnostics.Stopwatch.StartNew();
+ // ... operation ...
+ Console.WriteLine($"Operation took {sw.ElapsedMilliseconds}ms");
+ ```
+
+---
+
+For more information, visit the [OpenMaui GitHub repository](https://github.com/openmaui) or check the individual sample README files.
diff --git a/README.md b/README.md
index c3bcf55..207214e 100644
--- a/README.md
+++ b/README.md
@@ -1,76 +1,782 @@
# OpenMaui Linux Samples
-Sample applications demonstrating [OpenMaui Linux](https://git.marketally.com/open-maui/maui-linux) - .NET MAUI on Linux.
+Sample applications demonstrating [OpenMaui Linux](https://git.marketally.com/open-maui/maui-linux) - .NET MAUI on Linux desktop with SkiaSharp rendering.
-## Samples
+## Table of Contents
-| Sample | Description |
-|--------|-------------|
-| [TodoApp](./TodoApp/) | Full-featured task manager with NavigationPage, XAML data binding, and CollectionView |
-| [ShellDemo](./ShellDemo/) | Comprehensive control showcase with Shell navigation and flyout menu |
+- [Overview](#overview)
+- [Sample Applications](#sample-applications)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Building and Deployment](#building-and-deployment)
+- [Sample Details](#sample-details)
+ - [TodoApp](#todoapp)
+ - [ShellDemo](#shelldemo)
+ - [WebViewDemo](#webviewdemo)
+- [Project Structure](#project-structure)
+- [Development Guide](#development-guide)
+- [API Usage Examples](#api-usage-examples)
+- [Related Resources](#related-resources)
+- [License](#license)
+
+## Overview
+
+This repository contains production-ready sample applications showcasing **OpenMaui Linux** - a .NET MAUI implementation for Linux desktop environments. These samples demonstrate how to build cross-platform applications using familiar MAUI APIs with native Linux rendering via SkiaSharp and optional GTK integration.
+
+**Key Features:**
+- Full .NET MAUI API compatibility
+- SkiaSharp-based rendering for high-performance graphics
+- X11 window management support
+- GTK integration for WebView and native dialogs
+- Light/Dark theme support with dynamic switching
+- Navigation (NavigationPage, Shell, push/pop)
+- Data binding and MVVM patterns
+- Comprehensive control coverage
+
+## Sample Applications
+
+| Sample | Description | Key Features |
+|--------|-------------|--------------|
+| [TodoApp](./TodoApp/) | Full-featured task manager | NavigationPage, XAML data binding, CollectionView, value converters, theme switching |
+| [ShellDemo](./ShellDemo/) | Comprehensive control showcase | Shell navigation, flyout menu, all core controls, event logging |
+| [WebViewDemo](./WebViewDemo/) | Web browser with WebKitGTK | WebView, JavaScript evaluation, GTK integration, HTML rendering |
## Requirements
-- .NET 9.0 SDK
-- Linux with X11 (Ubuntu, Fedora, etc.)
-- SkiaSharp dependencies: `libfontconfig1-dev libfreetype6-dev`
+**Software:**
+- .NET 9.0 SDK or later
+- Linux with X11 display server (Wayland not yet supported)
+- Supported distributions: Ubuntu 20.04+, Fedora 35+, Debian 11+, or similar
+
+**System Dependencies:**
+```bash
+# Ubuntu/Debian
+sudo apt-get install libfontconfig1-dev libfreetype6-dev
+
+# Fedora/RHEL
+sudo dnf install fontconfig-devel freetype-devel
+
+# For WebView support (WebViewDemo)
+sudo apt-get install libwebkit2gtk-4.0-dev # Ubuntu/Debian
+sudo dnf install webkit2gtk3-devel # Fedora/RHEL
+```
+
+## Installation
+
+### Clone the Repository
+
+```bash
+git clone https://git.marketally.com/open-maui/maui-linux-samples.git
+cd maui-linux-samples
+```
+
+### Install .NET SDK
+
+If you don't have .NET 9.0 SDK installed:
+
+```bash
+# Download and install .NET SDK
+wget https://dot.net/v1/dotnet-install.sh
+chmod +x dotnet-install.sh
+./dotnet-install.sh --channel 9.0
+
+# Add to PATH (add to ~/.bashrc for persistence)
+export DOTNET_ROOT=$HOME/.dotnet
+export PATH=$DOTNET_ROOT:$PATH
+```
+
+### Verify Installation
+
+```bash
+dotnet --version # Should show 9.0.x or later
+```
## Quick Start
-```bash
-# Clone the samples
-git clone https://git.marketally.com/open-maui/maui-linux-samples.git
-cd maui-linux-samples
+### Run TodoApp
-# Run TodoApp
+```bash
cd TodoApp
dotnet run
+```
-# Or run ShellDemo
+The todo application will launch with sample tasks. You can:
+- Add new tasks with the "+" button
+- Tap tasks to view/edit details
+- Mark tasks as completed
+- Delete tasks
+- Toggle between light and dark themes
+
+### Run ShellDemo
+
+```bash
cd ../ShellDemo
dotnet run
```
-## Building for Deployment
+The control gallery will open with a flyout menu. Navigate through different pages to explore:
+- Button styles and events
+- Text input controls (Entry, Editor, SearchBar)
+- Selection controls (CheckBox, Switch, Slider)
+- Pickers (Picker, DatePicker, TimePicker)
+- CollectionView with dynamic data
+- Progress indicators
+- Grid layouts with various configurations
+
+### Run WebViewDemo
```bash
-# Build for Linux ARM64
-dotnet publish -c Release -r linux-arm64
-
-# Build for Linux x64
-dotnet publish -c Release -r linux-x64
+cd ../WebViewDemo
+dotnet run
```
-## TodoApp
+A web browser window will open. You can:
+- Navigate to any URL
+- Use back/forward buttons
+- Load custom HTML content
+- Execute JavaScript
+- Toggle themes
-A complete task management application demonstrating:
-- NavigationPage with toolbar and back navigation
-- CollectionView with data binding and selection
-- XAML value converters for dynamic styling
-- DisplayAlert dialogs
-- Grid layouts with star sizing
-- Entry and Editor text input
+## Building and Deployment
-
+### Debug Build
-## ShellDemo
+```bash
+# Build without running
+dotnet build
-A comprehensive control gallery demonstrating:
-- Shell with flyout menu navigation
-- All core MAUI controls (Button, Entry, CheckBox, Switch, Slider, etc.)
-- Picker, DatePicker, TimePicker
-- CollectionView with various item types
-- ProgressBar and ActivityIndicator
-- Grid layouts
-- Real-time event logging
+# Output location: bin/Debug/net9.0/
+```
-
+### Release Build
-## Related
+```bash
+# Build optimized release version
+dotnet build -c Release
+```
-- [OpenMaui Linux Framework](https://git.marketally.com/open-maui/maui-linux) - The core framework
-- [NuGet Package](https://www.nuget.org/packages/OpenMaui.Controls.Linux) - Install via NuGet
+### Publish for Distribution
+
+Create self-contained executables for specific Linux architectures:
+
+```bash
+# Linux x64 (most desktops)
+dotnet publish -c Release -r linux-x64 --self-contained
+
+# Linux ARM64 (Raspberry Pi, ARM servers)
+dotnet publish -c Release -r linux-arm64 --self-contained
+
+# Framework-dependent (requires .NET runtime installed)
+dotnet publish -c Release -r linux-x64 --no-self-contained
+```
+
+Published applications will be in `bin/Release/net9.0/linux-x64/publish/` and can be distributed as standalone executables.
+
+### Create Desktop Launcher
+
+```bash
+# Make the run script executable
+chmod +x TodoApp/run.sh
+
+# Create a .desktop file for your application
+cat > ~/.local/share/applications/openmaui-todo.desktop << EOF
+[Desktop Entry]
+Type=Application
+Name=OpenMaui Todo
+Exec=/path/to/maui-linux-samples/TodoApp/run.sh
+Icon=utilities-terminal
+Terminal=false
+Categories=Utility;
+EOF
+```
+
+## Sample Details
+
+### TodoApp
+
+A complete task management application demonstrating production-ready patterns.
+
+**Features:**
+- **NavigationPage** with toolbar and back navigation
+- **CollectionView** with item selection and data templates
+- **XAML data binding** with INotifyPropertyChanged
+- **Value converters** for dynamic styling (alternating rows, completed tasks)
+- **DisplayAlert** dialogs for confirmations
+- **Theme switching** (Light/Dark) with AppThemeBinding
+- **Grid layouts** with star sizing
+- **Entry and Editor** for text input
+- **Alternating row colors** with theme support
+
+**Architecture:**
+- `TodoItem.cs` - Data model with property change notifications
+- `TodoService.cs` - Business logic with ObservableCollection
+- `TodoListPage.xaml` - Main list view with data templates
+- `TodoDetailPage.xaml` - Detail/edit view
+- `NewTodoPage.xaml` - Create new task view
+- Value converters for visual state management
+
+**Code Example - Data Binding:**
+
+```xaml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+**Logging:**
+Application logs are written to `~/todoapp.log` for debugging.
+
+### ShellDemo
+
+A comprehensive control gallery showcasing all supported MAUI controls with Shell navigation.
+
+**Features:**
+- **Shell navigation** with flyout menu
+- **All core controls**: Button, Entry, Editor, SearchBar, CheckBox, Switch, Slider, Stepper
+- **Pickers**: Picker, DatePicker, TimePicker
+- **CollectionView** with various data types and selection modes
+- **ProgressBar and ActivityIndicator**
+- **Grid layouts** with demonstrations of:
+ - Auto, Star, and Absolute sizing
+ - Row and column spanning
+ - Spacing and padding
+ - Mixed sizing strategies
+- **Real-time event logging** for all interactions
+- **Push/pop navigation** examples
+- **Theme switching** support
+
+**Navigation Structure:**
+
+```csharp
+// AppShell.xaml.cs - Shell with flyout menu
+public partial class AppShell : Shell
+{
+ public AppShell()
+ {
+ InitializeComponent();
+
+ // Register routes for push navigation
+ Routing.RegisterRoute("detail", typeof(DetailPage));
+ }
+}
+```
+
+**Code Example - Grid Layouts:**
+
+```csharp
+// GridsPage.xaml.cs - Programmatic grid creation
+private View CreateStarSizingDemo()
+{
+ var grid = new Grid
+ {
+ ColumnDefinitions =
+ {
+ new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) },
+ new ColumnDefinition { Width = new GridLength(2, GridUnitType.Star) },
+ new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) }
+ }
+ };
+
+ // Add cells with proportional sizing: 25% | 50% | 25%
+ grid.Children.Add(CreateCell("1*", "#BBDEFB"));
+ grid.Children.Add(CreateCell("2* (double)", "#C8E6C9"));
+ grid.Children.Add(CreateCell("1*", "#FFECB3"));
+
+ return grid;
+}
+```
+
+**Logging:**
+Application logs are written to `~/shelldemo.log` for debugging.
+
+### WebViewDemo
+
+A web browser application demonstrating WebView integration with WebKitGTK.
+
+**Features:**
+- **WebView** with full HTML5 support
+- **WebKitGTK** backend (same engine as GNOME Web)
+- **Navigation controls** (back, forward, reload)
+- **URL entry** with automatic https:// prefix
+- **JavaScript evaluation** via `EvaluateJavaScriptAsync`
+- **HTML content loading** from strings
+- **Progress indicator** with animations
+- **Theme switching** support
+- **GTK mode** for native WebView rendering
+
+**Important:** Requires GTK mode enabled in `Program.cs`:
+
+```csharp
+// WebViewDemo/Program.cs
+LinuxApplication.Run(app, args, options =>
+{
+ options.UseGtk = true; // Required for WebView
+});
+```
+
+**Code Example - JavaScript Evaluation:**
+
+```csharp
+private async void OnEvalJsClicked(object? sender, EventArgs e)
+{
+ try
+ {
+ var result = await MainWebView.EvaluateJavaScriptAsync("document.title");
+ StatusLabel.Text = $"JS Result: {result ?? "(null)"}";
+ }
+ catch (Exception ex)
+ {
+ StatusLabel.Text = $"JS Error: {ex.Message}";
+ }
+}
+```
+
+**Code Example - Loading HTML:**
+
+```csharp
+private void OnLoadHtmlClicked(object? sender, EventArgs e)
+{
+ var html = @"
+
+
+
+
+
+
+
Hello from OpenMaui!
+
+
+";
+
+ MainWebView.Source = new HtmlWebViewSource { Html = html };
+}
+```
+
+**Logging:**
+Application logs are written to `~/webviewdemo.log` for debugging.
+
+## Project Structure
+
+Each sample follows a similar structure:
+
+```
+SampleApp/
+├── Program.cs # Linux platform entry point
+├── MauiProgram.cs # MAUI app configuration
+├── App.xaml # Application resources and theme definitions
+├── App.xaml.cs # Application lifecycle
+├── SampleApp.csproj # Project configuration
+├── Pages/ # XAML pages and code-behind
+│ ├── MainPage.xaml
+│ └── MainPage.xaml.cs
+├── Resources/ # Images, fonts, icons
+│ ├── AppIcon/
+│ └── Images/
+└── run.sh # Launcher script
+```
+
+### Project Configuration
+
+All samples use conditional compilation for cross-platform support:
+
+```xml
+
+
+
+ net9.0
+ Exe
+ true
+
+
+
+
+ linux-x64;linux-arm64
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+## Development Guide
+
+### Creating a New Linux MAUI App
+
+1. **Create project structure:**
+
+```bash
+mkdir MyApp
+cd MyApp
+dotnet new console -n MyApp
+```
+
+2. **Edit MyApp.csproj:**
+
+```xml
+
+
+ Exe
+ net9.0
+ true
+ true
+
+
+
+
+
+
+```
+
+3. **Create Program.cs:**
+
+```csharp
+using Microsoft.Maui.Platform.Linux;
+
+namespace MyApp;
+
+class Program
+{
+ static void Main(string[] args)
+ {
+ var app = MauiProgram.CreateMauiApp();
+ LinuxApplication.Run(app, args);
+ }
+}
+```
+
+4. **Create MauiProgram.cs:**
+
+```csharp
+using Microsoft.Maui.Hosting;
+using Microsoft.Maui.Platform.Linux.Hosting;
+
+namespace MyApp;
+
+public static class MauiProgram
+{
+ public static MauiApp CreateMauiApp()
+ {
+ var builder = MauiApp.CreateBuilder();
+ builder.UseMauiApp();
+ builder.UseLinux();
+ return builder.Build();
+ }
+}
+```
+
+5. **Create App.xaml and App.xaml.cs** (see samples for examples)
+
+6. **Build and run:**
+
+```bash
+dotnet build
+dotnet run
+```
+
+### Exception Handling
+
+All samples include comprehensive exception handling:
+
+```csharp
+// Global exception handlers in Program.cs
+AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
+{
+ var ex = e.ExceptionObject as Exception;
+ Console.WriteLine($"[FATAL] Unhandled exception: {ex?.Message}");
+ Console.WriteLine($"[FATAL] Stack trace: {ex?.StackTrace}");
+};
+
+TaskScheduler.UnobservedTaskException += (sender, e) =>
+{
+ Console.WriteLine($"[FATAL] Unobserved task exception: {e.Exception?.Message}");
+ e.SetObserved(); // Prevent crash
+};
+```
+
+### Logging
+
+All samples redirect console output to log files in the user's home directory:
+
+```csharp
+var logPath = Path.Combine(
+ Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),
+ "myapp.log");
+using var logWriter = new StreamWriter(logPath, append: false) { AutoFlush = true };
+var multiWriter = new MultiTextWriter(Console.Out, logWriter);
+Console.SetOut(multiWriter);
+Console.SetError(multiWriter);
+```
+
+## API Usage Examples
+
+### Navigation
+
+**NavigationPage (TodoApp):**
+
+```csharp
+// App.xaml.cs - Create NavigationPage
+protected override Window CreateWindow(IActivationState? activationState)
+{
+ NavigationPage = new NavigationPage(new TodoListPage())
+ {
+ BarBackgroundColor = Color.FromArgb("#5C6BC0"),
+ BarTextColor = Colors.White
+ };
+ return new Window(NavigationPage);
+}
+
+// Push a page
+await Navigation.PushAsync(new TodoDetailPage(todo));
+
+// Pop back
+await Navigation.PopAsync();
+```
+
+**Shell Navigation (ShellDemo):**
+
+```csharp
+// AppShell.xaml.cs - Register routes
+Routing.RegisterRoute("detail", typeof(DetailPage));
+
+// Navigate using route
+await Shell.Current.GoToAsync("detail?item=MyItem");
+
+// Navigate with parameters
+await Shell.Current.GoToAsync($"detail?item={Uri.EscapeDataString(itemName)}");
+
+// Use LinuxViewRenderer for direct navigation
+LinuxViewRenderer.NavigateToRoute("Buttons");
+LinuxViewRenderer.PushPage(new DetailPage());
+LinuxViewRenderer.PopPage();
+```
+
+### Data Binding
+
+**Observable Collections:**
+
+```csharp
+public class TodoService
+{
+ public ObservableCollection Todos { get; } = new();
+
+ public TodoItem AddTodo(string title, string notes = "")
+ {
+ var todo = new TodoItem { Title = title, Notes = notes };
+ Todos.Add(todo);
+ return todo;
+ }
+}
+```
+
+**INotifyPropertyChanged:**
+
+```csharp
+public class TodoItem : INotifyPropertyChanged
+{
+ private bool _isCompleted;
+
+ public bool IsCompleted
+ {
+ get => _isCompleted;
+ set
+ {
+ if (_isCompleted != value)
+ {
+ _isCompleted = value;
+ OnPropertyChanged(nameof(IsCompleted));
+ }
+ }
+ }
+
+ public event PropertyChangedEventHandler? PropertyChanged;
+
+ protected void OnPropertyChanged(string propertyName)
+ {
+ PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+ }
+}
+```
+
+### Value Converters
+
+**Theme-Aware Color Converter:**
+
+```csharp
+public class CompletedToColorConverter : IValueConverter
+{
+ private static readonly Color AccentColorLight = Color.FromArgb("#26A69A");
+ private static readonly Color AccentColorDark = Color.FromArgb("#4DB6AC");
+
+ public object? Convert(object? value, Type targetType, object? parameter, CultureInfo culture)
+ {
+ bool isCompleted = value is bool b && b;
+ bool isDarkMode = Application.Current?.RequestedTheme == AppTheme.Dark;
+
+ if (isCompleted)
+ return Color.FromArgb("#9E9E9E");
+
+ return isDarkMode ? AccentColorDark : AccentColorLight;
+ }
+
+ public object? ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture)
+ {
+ throw new NotImplementedException();
+ }
+}
+```
+
+**Register in App.xaml:**
+
+```xaml
+
+
+
+```
+
+### Theme Switching
+
+**Toggle Theme:**
+
+```csharp
+private void OnThemeToggleClicked(object? sender, EventArgs e)
+{
+ if (Application.Current == null) return;
+
+ var isDarkMode = Application.Current.UserAppTheme == AppTheme.Dark;
+ Application.Current.UserAppTheme = isDarkMode ? AppTheme.Light : AppTheme.Dark;
+}
+```
+
+**AppThemeBinding in XAML:**
+
+```xaml
+
+
+
+```
+
+**Programmatic AppThemeBinding:**
+
+```csharp
+label.SetAppThemeColor(Label.TextColorProperty,
+ Colors.Black, // Light theme
+ Colors.White); // Dark theme
+```
+
+### Dialogs
+
+**DisplayAlert (using LinuxDialogService):**
+
+```csharp
+private async void OnDeleteClicked(object? sender, EventArgs e)
+{
+ var confirmed = await LinuxDialogService.ShowAlertAsync(
+ "Delete Task",
+ $"Are you sure you want to delete \"{_todo.Title}\"?",
+ "Delete",
+ "Cancel");
+
+ if (confirmed)
+ {
+ _service.DeleteTodo(_todo);
+ await Navigation.PopAsync();
+ }
+}
+```
+
+### WebView
+
+**Load URL:**
+
+```csharp
+MainWebView.Source = new UrlWebViewSource { Url = "https://dotnet.microsoft.com" };
+```
+
+**Load HTML:**
+
+```csharp
+MainWebView.Source = new HtmlWebViewSource
+{
+ Html = "
Hello!
"
+};
+```
+
+**Execute JavaScript:**
+
+```csharp
+var result = await MainWebView.EvaluateJavaScriptAsync("document.title");
+```
+
+**Navigation Events:**
+
+```csharp
+private void OnNavigating(object? sender, WebNavigatingEventArgs e)
+{
+ Console.WriteLine($"Navigating to: {e.Url}");
+ // e.Cancel = true; // Cancel navigation if needed
+}
+
+private void OnNavigated(object? sender, WebNavigatedEventArgs e)
+{
+ Console.WriteLine($"Navigated: {e.Result} - {e.Url}");
+}
+```
+
+## Related Resources
+
+- **[OpenMaui Linux Framework](https://git.marketally.com/open-maui/maui-linux)** - The core framework repository
+- **[NuGet Package](https://www.nuget.org/packages/OpenMaui.Controls.Linux)** - Install via NuGet
+- **[.NET MAUI Documentation](https://learn.microsoft.com/dotnet/maui/)** - Official Microsoft documentation
+- **[SkiaSharp Documentation](https://learn.microsoft.com/xamarin/xamarin-forms/user-interface/graphics/skiasharp/)** - Graphics rendering engine
## License
MIT License - See [LICENSE](LICENSE) for details.
+
+Copyright (c) 2024 OpenMaui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file