diff --git a/global.json b/global.json
deleted file mode 100644
index ce2e41208c..0000000000
--- a/global.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-  "sdk": {
-    "version": "8.0.303",
-    "rollForward": "latestFeature",
-    "allowPrerelease": false
-  }
-}
diff --git a/samples/CommunityToolkit.Maui.Sample/AppShell.xaml.cs b/samples/CommunityToolkit.Maui.Sample/AppShell.xaml.cs
index 0c1f5c7176..91ebaa80e7 100644
--- a/samples/CommunityToolkit.Maui.Sample/AppShell.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/AppShell.xaml.cs
@@ -93,6 +93,7 @@ public partial class AppShell : Shell
 		CreateViewModelMapping<FileSaverPage, FileSaverViewModel, EssentialsGalleryPage, EssentialsGalleryViewModel>(),
 		CreateViewModelMapping<FolderPickerPage, FolderPickerViewModel, EssentialsGalleryPage, EssentialsGalleryViewModel>(),
 		CreateViewModelMapping<SpeechToTextPage, SpeechToTextViewModel, EssentialsGalleryPage, EssentialsGalleryViewModel>(),
+		CreateViewModelMapping<OfflineSpeechToTextPage, OfflineSpeechToTextViewModel, EssentialsGalleryPage, EssentialsGalleryViewModel>(),
 
 		// Add Extensions View Models
 		CreateViewModelMapping<ColorAnimationExtensionsPage, ColorAnimationExtensionsViewModel, ExtensionsGalleryPage, ExtensionsGalleryViewModel>(),
diff --git a/samples/CommunityToolkit.Maui.Sample/CommunityToolkit.Maui.Sample.csproj b/samples/CommunityToolkit.Maui.Sample/CommunityToolkit.Maui.Sample.csproj
index ab7ba34c21..7758b14b28 100644
--- a/samples/CommunityToolkit.Maui.Sample/CommunityToolkit.Maui.Sample.csproj
+++ b/samples/CommunityToolkit.Maui.Sample/CommunityToolkit.Maui.Sample.csproj
@@ -33,10 +33,7 @@
     <!--<EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>-->
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)' == 'Release' 
-                 AND $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) != 'tizen'
-                 AND $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) != 'android'
-                 AND $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) != 'windows'">
+  <PropertyGroup Condition="'$(Configuration)' == 'Release' &#xD;&#xA;                 AND $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) != 'tizen'&#xD;&#xA;                 AND $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) != 'android'&#xD;&#xA;                 AND $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) != 'windows'">
     <!-- Ahead-of-time compilation is not yet supported net8.0-tizen -->
     <!-- Cross-OS native compilation is not supported net8.0-android -->
     <!-- Only iOS + MacCatalyst support AOT in .NET 8 -->
@@ -61,7 +58,7 @@
     <!-- Custom Fonts -->
     <MauiFont Include="Resources\Fonts\*" />
 
-    <PackageReference Include="Microsoft.Maui.Controls" Version="*"/>
+    <PackageReference Include="Microsoft.Maui.Controls" Version="*" />
     <PackageReference Include="CommunityToolkit.Maui.Markup" Version="4.1.0" />
     <PackageReference Include="CommunityToolkit.Mvvm" Version="8.2.2" />
     <PackageReference Include="Microsoft.Extensions.Http.Resilience" Version="8.8.0" />
@@ -87,6 +84,18 @@
     <ProjectReference Include="..\..\src\CommunityToolkit.Maui.Maps\CommunityToolkit.Maui.Maps.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Compile Update="Pages\Essentials\OfflineSpeechToTextPage.xaml.cs">
+      <DependentUpon>OfflineSpeechToTextPage.xaml</DependentUpon>
+    </Compile>
+  </ItemGroup>
+
+  <ItemGroup>
+    <MauiXaml Update="Pages\Essentials\OfflineSpeechToTextPage.xaml">
+      <Generator>MSBuild:Compile</Generator>
+    </MauiXaml>
+  </ItemGroup>
+
   <PropertyGroup Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)'))=='windows' and $(Configuration) == 'Release'">
     <RuntimeIdentifier>win-x64</RuntimeIdentifier>
   </PropertyGroup>
diff --git a/samples/CommunityToolkit.Maui.Sample/MauiProgram.cs b/samples/CommunityToolkit.Maui.Sample/MauiProgram.cs
index c7625ee34b..71d632b94b 100644
--- a/samples/CommunityToolkit.Maui.Sample/MauiProgram.cs
+++ b/samples/CommunityToolkit.Maui.Sample/MauiProgram.cs
@@ -211,6 +211,7 @@ static void RegisterViewsAndViewModels(in IServiceCollection services)
 		services.AddTransientWithShellRoute<FileSaverPage, FileSaverViewModel>();
 		services.AddTransientWithShellRoute<FolderPickerPage, FolderPickerViewModel>();
 		services.AddTransientWithShellRoute<SpeechToTextPage, SpeechToTextViewModel>();
+		services.AddTransientWithShellRoute<OfflineSpeechToTextPage, OfflineSpeechToTextViewModel>();
 
 		// Add Extensions Pages + ViewModels
 		services.AddTransientWithShellRoute<ColorAnimationExtensionsPage, ColorAnimationExtensionsViewModel>();
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/OfflineSpeechToTextPage.xaml b/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/OfflineSpeechToTextPage.xaml
new file mode 100644
index 0000000000..865884c330
--- /dev/null
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/OfflineSpeechToTextPage.xaml
@@ -0,0 +1,100 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<pages:BasePage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+                xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+                xmlns:pages="clr-namespace:CommunityToolkit.Maui.Sample.Pages"
+                x:Class="CommunityToolkit.Maui.Sample.Pages.Essentials.OfflineSpeechToTextPage"
+                xmlns:vm="clr-namespace:CommunityToolkit.Maui.Sample.ViewModels.Essentials"
+                xmlns:essentials="clr-namespace:CommunityToolkit.Maui.Sample.Pages.Essentials"
+                x:TypeArguments="vm:OfflineSpeechToTextViewModel"
+                x:DataType="vm:OfflineSpeechToTextViewModel"
+                Title="OfflineSpeechToText">
+
+    <ContentPage.Resources>
+        <essentials:PickerLocaleDisplayConverter x:Key="PickerLocaleDisplayConverter" />
+    </ContentPage.Resources>
+
+    <ScrollView>
+        <VerticalStackLayout
+            Spacing="20"
+            Padding="30,0">
+
+            <Label
+                Text="SpeechToText allows the user to convert speech to text in real time"
+                HorizontalTextAlignment="Center"/>
+
+            <Label
+                Text="Locale"
+                FontAttributes="Bold"/>
+
+            <Picker
+                ItemsSource="{Binding Locales}"
+                SelectedItem="{Binding CurrentLocale}"
+                ItemDisplayBinding="{Binding ., Converter={StaticResource PickerLocaleDisplayConverter}}"/>
+
+            <Label
+                Text="State"
+                FontAttributes="Bold"/>
+
+            <Label
+                Text="{Binding State}"
+                FontSize="18"
+                HorizontalOptions="Center"
+                HorizontalTextAlignment="Center"
+                MinimumHeightRequest="100" />
+
+            <Label
+                Text="Language Output"
+                FontAttributes="Bold"/>
+
+            <Label
+                Text="{Binding RecognitionText}"
+                FontSize="18"
+                HorizontalOptions="Center"
+                HorizontalTextAlignment="Center"
+                MinimumHeightRequest="100" />
+
+            <Button
+                Text="Play"
+                Command="{Binding PlayCommand}"
+                HorizontalOptions="Center" />
+
+            <Border
+                StrokeThickness="2"
+                Stroke="#808080"
+                StrokeShape="RoundRectangle 8,8,8,8"
+                Padding="12">
+                <Border.Content>
+                    <Grid RowDefinitions="*,60"
+                          ColumnDefinitions="*,*"
+                          RowSpacing="12"
+                          ColumnSpacing="12">
+
+                        <Button
+                            Grid.Row="0"
+                            Grid.Column="0"
+                            Text="StartListenAsync"
+                            Command="{Binding StartListenCommand}"
+                            HorizontalOptions="End" />
+
+                        <Button
+                            Grid.Row="0"
+                            Grid.Column="1"
+                            Text="StopListenAsync"
+                            Command="{Binding StopListenCommand}"
+                            HorizontalOptions="Start" />
+
+                        <Label
+                            Grid.Row="1"
+                            Grid.ColumnSpan="2"
+                            Text="The `StartListenAsync` API starts the speech-to-text service and shares the results using `RecognitionResultUpdated` event and `RecognitionResultCompleted` event."
+                            HorizontalOptions="Center"
+                            HorizontalTextAlignment="Center"
+                            FontSize="12"/>
+
+                    </Grid>
+                </Border.Content>
+            </Border>
+        </VerticalStackLayout>
+    </ScrollView>
+
+</pages:BasePage>
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/OfflineSpeechToTextPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/OfflineSpeechToTextPage.xaml.cs
new file mode 100644
index 0000000000..a6d4374dc7
--- /dev/null
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/OfflineSpeechToTextPage.xaml.cs
@@ -0,0 +1,20 @@
+using System.Globalization;
+using CommunityToolkit.Maui.Converters;
+using CommunityToolkit.Maui.Sample.ViewModels.Essentials;
+
+namespace CommunityToolkit.Maui.Sample.Pages.Essentials;
+
+public partial class OfflineSpeechToTextPage : BasePage<OfflineSpeechToTextViewModel>
+{
+	public OfflineSpeechToTextPage(OfflineSpeechToTextViewModel viewModel) : base(viewModel)
+	{
+		InitializeComponent();
+	}
+
+	protected override async void OnAppearing()
+	{
+		base.OnAppearing();
+
+		await BindingContext.SetLocalesCommand.ExecuteAsync(null);
+	}
+}
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/SpeechToTextPage.xaml b/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/SpeechToTextPage.xaml
index 081ec37335..4dfb305630 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/SpeechToTextPage.xaml
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/SpeechToTextPage.xaml
@@ -94,44 +94,7 @@
                     </Grid>
                 </Border.Content>
             </Border>
-
-            <Border
-                StrokeThickness="2"
-                Stroke="#808080"
-                StrokeShape="RoundRectangle 8,8,8,8"
-                Padding="12">
-                <Border.Content>
-                    <Grid RowDefinitions="*,60"
-                          ColumnDefinitions="*,*"
-                          RowSpacing="12"
-                          ColumnSpacing="12">
-
-                        <Button
-                            Grid.Row="0"
-                            Grid.Column="0"
-                            Text="StartOfflineListenAsync"
-                            Command="{Binding StartOfflineListenCommand}"
-                            HorizontalOptions="End" />
-
-                        <Button
-                            Grid.Row="0"
-                            Grid.Column="1"
-                            Text="StopOfflineListenAsync"
-                            Command="{Binding StopOfflineListenCommand}"
-                            HorizontalOptions="Start" />
-
-                        <Label
-                            Grid.Row="1"
-                            Grid.ColumnSpan="2"
-                            Text="The `StartOfflineListenAsync` API starts the speech-to-text service and shares the results using `RecognitionResultUpdated` event and `RecognitionResultCompleted` event."
-                            HorizontalOptions="Center"
-                            HorizontalTextAlignment="Center"
-                            FontSize="12"/>
-
-                    </Grid>
-                </Border.Content>
-            </Border>
-
+ee
         </VerticalStackLayout>
     </ScrollView>
 
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/EssentialsGalleryViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/EssentialsGalleryViewModel.cs
index 9ed0760b30..85db25b68a 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/EssentialsGalleryViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/EssentialsGalleryViewModel.cs
@@ -8,5 +8,6 @@ public class EssentialsGalleryViewModel() : BaseGalleryViewModel(
 	SectionModel.Create<BadgeViewModel>("Badge", "Allows the user to set app icon badge count on the home screen"),
 	SectionModel.Create<FileSaverViewModel>("FileSaver", "Allows the user to save files to the filesystem"),
 	SectionModel.Create<FolderPickerViewModel>("FolderPicker", "Allows picking folders from the file system"),
-	SectionModel.Create<SpeechToTextViewModel>("SpeechToText", "Converts speech to text")
+	SectionModel.Create<SpeechToTextViewModel>("SpeechToText", "Converts speech to text"),
+	SectionModel.Create<OfflineSpeechToTextViewModel>("OfflineSpeechToText", "Converts speech to text offline")
 ]);
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/OfflineSpeechToTextViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/OfflineSpeechToTextViewModel.cs
new file mode 100644
index 0000000000..1c0fd6ac91
--- /dev/null
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/OfflineSpeechToTextViewModel.cs
@@ -0,0 +1,150 @@
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Globalization;
+using CommunityToolkit.Maui.Alerts;
+using CommunityToolkit.Maui.Media;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+
+namespace CommunityToolkit.Maui.Sample.ViewModels.Essentials;
+
+public partial class OfflineSpeechToTextViewModel : BaseViewModel
+{
+	const string defaultLanguage = "en-US";
+	const string defaultLanguage_android = "en";
+	const string defaultLanguage_tizen = "en_US";
+
+	readonly ITextToSpeech textToSpeech;
+	readonly ISpeechToText speechToText;
+
+	[ObservableProperty]
+	Locale? currentLocale;
+
+	public SpeechToTextState? State => speechToText.CurrentState;
+
+	[ObservableProperty]
+	string? recognitionText = "Welcome to .NET MAUI Community Toolkit!";
+
+	[ObservableProperty, NotifyCanExecuteChangedFor(nameof(StartListenCommand))]
+	bool canStartListenExecute = true;
+
+	[ObservableProperty, NotifyCanExecuteChangedFor(nameof(StopListenCommand))]
+	bool canStopListenExecute = false;
+
+	public OfflineSpeechToTextViewModel(ITextToSpeech textToSpeech)
+	{
+		this.textToSpeech = textToSpeech;
+		this.speechToText = OfflineSpeechToText.Default;
+
+		Locales.CollectionChanged += HandleLocalesCollectionChanged;
+		this.speechToText.StateChanged += HandleSpeechToTextStateChanged;
+		this.speechToText.RecognitionResultCompleted += HandleRecognitionResultCompleted;
+	}
+
+	public ObservableCollection<Locale> Locales { get; } = [];
+
+	[RelayCommand]
+	async Task SetLocales(CancellationToken token)
+	{
+		Locales.Clear();
+
+		var locales = await textToSpeech.GetLocalesAsync().WaitAsync(token);
+
+		foreach (var locale in locales.OrderBy(x => x.Language).ThenBy(x => x.Name))
+		{
+			Locales.Add(locale);
+		}
+
+		CurrentLocale = Locales.FirstOrDefault(x => x.Language is defaultLanguage or defaultLanguage_android or defaultLanguage_tizen) ?? Locales.FirstOrDefault();
+	}
+
+	[RelayCommand]
+	async Task Play(CancellationToken cancellationToken)
+	{
+		var timeoutCancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+
+		try
+		{
+			await textToSpeech.SpeakAsync(RecognitionText ?? "Welcome to .NET MAUI Community Toolkit!", new()
+			{
+				Locale = CurrentLocale,
+				Pitch = 1,
+				Volume = 1
+			}, cancellationToken).WaitAsync(timeoutCancellationTokenSource.Token);
+		}
+		catch (TaskCanceledException)
+		{
+			await Toast.Make("Playback automatically stopped after 5 seconds").Show(cancellationToken);
+#if IOS
+			await Toast.Make("If you did not hear playback, test again on a physical iOS device").Show(cancellationToken);
+#endif
+		}
+	}
+
+	[RelayCommand(CanExecute = nameof(CanStartListenExecute))]
+	async Task StartListen()
+	{
+		CanStartListenExecute = false;
+
+		var isGranted = await speechToText.RequestPermissions(CancellationToken.None);
+		if (!isGranted)
+		{
+			await Toast.Make("Permission not granted").Show(CancellationToken.None);
+			return;
+		}
+
+		if (Connectivity.NetworkAccess != NetworkAccess.Internet)
+		{
+			await Toast.Make("Internet connection is required").Show(CancellationToken.None);
+			return;
+		}
+
+		const string beginSpeakingPrompt = "Begin speaking...";
+
+		RecognitionText = beginSpeakingPrompt;
+
+		speechToText.RecognitionResultUpdated += HandleRecognitionResultUpdated;
+
+		await speechToText.StartListenAsync(new SpeechToTextOptions()
+		{
+			Culture = CultureInfo.GetCultureInfo(CurrentLocale?.Language ?? defaultLanguage),
+			ShouldReportPartialResults = true
+		}, CancellationToken.None);
+
+		if (RecognitionText is beginSpeakingPrompt)
+		{
+			RecognitionText = string.Empty;
+		}
+	}
+
+	[RelayCommand(CanExecute = nameof(CanStopListenExecute))]
+	Task StopListen()
+	{
+		CanStartListenExecute = true;
+		CanStopListenExecute = false;
+
+		speechToText.RecognitionResultUpdated -= HandleRecognitionResultUpdated;
+
+		return speechToText.StopListenAsync(CancellationToken.None);
+	}
+
+	void HandleRecognitionResultUpdated(object? sender, SpeechToTextRecognitionResultUpdatedEventArgs e)
+	{
+		RecognitionText += e.RecognitionResult;
+	}
+
+	void HandleRecognitionResultCompleted(object? sender, SpeechToTextRecognitionResultCompletedEventArgs e)
+	{
+		RecognitionText = e.RecognitionResult.IsSuccessful ? e.RecognitionResult.Text : e.RecognitionResult.Exception.Message;
+	}
+
+	void HandleSpeechToTextStateChanged(object? sender, SpeechToTextStateChangedEventArgs e)
+	{
+		OnPropertyChanged(nameof(State));
+	}
+
+	void HandleLocalesCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+	{
+		OnPropertyChanged(nameof(CurrentLocale));
+	}
+}
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/SpeechToTextViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/SpeechToTextViewModel.cs
index d219436f60..8223dc246a 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/SpeechToTextViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/SpeechToTextViewModel.cs
@@ -24,19 +24,13 @@ public partial class SpeechToTextViewModel : BaseViewModel
 
 	[ObservableProperty]
 	string? recognitionText = "Welcome to .NET MAUI Community Toolkit!";
-	
+
 	[ObservableProperty, NotifyCanExecuteChangedFor(nameof(StartListenCommand))]
 	bool canStartListenExecute = true;
 
 	[ObservableProperty, NotifyCanExecuteChangedFor(nameof(StopListenCommand))]
 	bool canStopListenExecute = false;
 
-	[ObservableProperty, NotifyCanExecuteChangedFor(nameof(StartOfflineListenCommand))]
-	bool canStartOfflineListenExecute = true;
-
-	[ObservableProperty, NotifyCanExecuteChangedFor(nameof(StopOfflineListenCommand))]
-	bool canStopOfflineListenExecute = false;
-
 	public SpeechToTextViewModel(ITextToSpeech textToSpeech, ISpeechToText speechToText)
 	{
 		this.textToSpeech = textToSpeech;
@@ -91,8 +85,6 @@ async Task Play(CancellationToken cancellationToken)
 	async Task StartListen()
 	{
 		CanStartListenExecute = false;
-		CanStartOfflineListenExecute = false;
-		CanStopOfflineListenExecute = false;
 		CanStopListenExecute = true;
 
 		var isGranted = await speechToText.RequestPermissions(CancellationToken.None);
@@ -114,8 +106,12 @@ async Task StartListen()
 
 		speechToText.RecognitionResultUpdated += HandleRecognitionResultUpdated;
 
-		await speechToText.StartListenAsync(CultureInfo.GetCultureInfo(CurrentLocale?.Language ?? defaultLanguage), CancellationToken.None);
-		
+		await speechToText.StartListenAsync(new SpeechToTextOptions()
+		{
+			Culture = CultureInfo.GetCultureInfo(CurrentLocale?.Language ?? defaultLanguage),
+			ShouldReportPartialResults = true
+		}, CancellationToken.None);
+
 		if (RecognitionText is beginSpeakingPrompt)
 		{
 			RecognitionText = string.Empty;
@@ -126,56 +122,12 @@ async Task StartListen()
 	Task StopListen()
 	{
 		CanStartListenExecute = true;
-		CanStartOfflineListenExecute = true;
-		CanStopOfflineListenExecute = false;
 		CanStopListenExecute = false;
 
 		speechToText.RecognitionResultUpdated -= HandleRecognitionResultUpdated;
 
 		return speechToText.StopListenAsync(CancellationToken.None);
 	}
-	
-	[RelayCommand(CanExecute = nameof(CanStartOfflineListenExecute))]
-	async Task StartOfflineListen()
-	{
-		CanStartListenExecute = false;
-		CanStopListenExecute = false;
-		CanStartOfflineListenExecute = false;
-		CanStopOfflineListenExecute = true;
-
-		var isGranted = await speechToText.RequestPermissions(CancellationToken.None);
-		if (!isGranted)
-		{
-			await Toast.Make("Permission not granted").Show(CancellationToken.None);
-			return;
-		}
-
-		const string beginSpeakingPrompt = "Begin speaking...";
-
-		RecognitionText = beginSpeakingPrompt;
-
-		speechToText.RecognitionResultUpdated += HandleRecognitionResultUpdated;
-
-		await speechToText.StartOfflineListenAsync(CultureInfo.GetCultureInfo(CurrentLocale?.Language ?? defaultLanguage), CancellationToken.None);
-		
-		if (RecognitionText is beginSpeakingPrompt)
-		{
-			RecognitionText = string.Empty;
-		}
-	}
-
-	[RelayCommand(CanExecute = nameof(CanStopOfflineListenExecute))]
-	Task StopOfflineListen()
-	{
-		CanStartOfflineListenExecute = true;
-		CanStartListenExecute = true;
-		CanStopListenExecute = false;
-		CanStopOfflineListenExecute = false;
-
-		speechToText.RecognitionResultUpdated -= HandleRecognitionResultUpdated;
-
-		return speechToText.StopOfflineListenAsync(CancellationToken.None);
-	}
 
 	void HandleRecognitionResultUpdated(object? sender, SpeechToTextRecognitionResultUpdatedEventArgs e)
 	{
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs
index 0de94f554a..3711882611 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs
@@ -33,9 +33,9 @@ public interface ISpeechToText : IAsyncDisposable
 	/// <remarks>
 	/// Real time speech recognition results will be surfaced via <see cref="RecognitionResultUpdated"/> and <see cref="RecognitionResultCompleted"/>
 	/// </remarks>
-	/// <param name="culture">Speak language</param>
+	/// <param name="options"><see cref="SpeechToTextOptions"/></param>
 	/// <param name="cancellationToken"><see cref="CancellationToken"/></param>
-	Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken = default);
+	Task StartListenAsync(SpeechToTextOptions options, CancellationToken cancellationToken = default);
 
 	/// <summary>
 	/// Stops the SpeechToText service
@@ -45,25 +45,6 @@ public interface ISpeechToText : IAsyncDisposable
 	/// </remarks>
 	/// <param name="cancellationToken"><see cref="CancellationToken"/></param>
 	Task StopListenAsync(CancellationToken cancellationToken = default);
-	
-	/// <summary>
-	/// Starts the Offline SpeechToText service
-	/// </summary>
-	/// <remarks>
-	/// Real time speech recognition results will be surfaced via <see cref="RecognitionResultUpdated"/> and <see cref="RecognitionResultCompleted"/>
-	/// </remarks>
-	/// <param name="culture">Speak language</param>
-	/// <param name="cancellationToken"><see cref="CancellationToken"/></param>
-	Task StartOfflineListenAsync(CultureInfo culture, CancellationToken cancellationToken = default);
-
-	/// <summary>
-	/// Stops the OfflineSpeechToText service
-	/// </summary>
-	/// <remarks>
-	/// Speech recognition results will be surfaced via <see cref="RecognitionResultCompleted"/>
-	/// </remarks>
-	/// <param name="cancellationToken"><see cref="CancellationToken"/></param>
-	Task StopOfflineListenAsync(CancellationToken cancellationToken = default);
 
 	/// <summary>
 	/// Request permissions for speech to text.
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSharedSpeechToTextImplementation.macios.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSharedSpeechToTextImplementation.macios.cs
new file mode 100644
index 0000000000..57b29ba9cf
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSharedSpeechToTextImplementation.macios.cs
@@ -0,0 +1,78 @@
+using AVFoundation;
+using Speech;
+
+namespace CommunityToolkit.Maui.Media;
+
+public sealed partial class OfflineSpeechToTextImplementation
+{
+	AVAudioEngine? audioEngine;
+	SFSpeechRecognizer? speechRecognizer;
+	SFSpeechRecognitionTask? recognitionTask;
+	SFSpeechAudioBufferRecognitionRequest? liveSpeechRequest;
+
+	/// <inheritdoc/>
+	public SpeechToTextState CurrentState => recognitionTask?.State is SFSpeechRecognitionTaskState.Running
+												? SpeechToTextState.Listening
+												: SpeechToTextState.Stopped;
+
+
+	/// <inheritdoc />
+	public ValueTask DisposeAsync()
+	{
+		audioEngine?.Dispose();
+		speechRecognizer?.Dispose();
+		liveSpeechRequest?.Dispose();
+		recognitionTask?.Dispose();
+
+		audioEngine = null;
+		speechRecognizer = null;
+		liveSpeechRequest = null;
+		recognitionTask = null;
+		return ValueTask.CompletedTask;
+	}
+
+	/// <inheritdoc />
+	public Task<bool> RequestPermissions(CancellationToken cancellationToken = default)
+	{
+		var taskResult = new TaskCompletionSource<bool>();
+
+		SFSpeechRecognizer.RequestAuthorization(status => taskResult.SetResult(status is SFSpeechRecognizerAuthorizationStatus.Authorized));
+
+		return taskResult.Task.WaitAsync(cancellationToken);
+	}
+
+	static Task<bool> IsSpeechPermissionAuthorized(CancellationToken cancellationToken)
+	{
+		cancellationToken.ThrowIfCancellationRequested();
+		return Task.FromResult(SFSpeechRecognizer.AuthorizationStatus is SFSpeechRecognizerAuthorizationStatus.Authorized);
+	}
+
+	static void InitializeAvAudioSession(out AVAudioSession sharedAvAudioSession)
+	{
+		sharedAvAudioSession = AVAudioSession.SharedInstance();
+		if (UIDevice.CurrentDevice.CheckSystemVersion(15, 0))
+		{
+			sharedAvAudioSession.SetSupportsMultichannelContent(true, out _);
+		}
+
+		sharedAvAudioSession.SetCategory(
+			AVAudioSessionCategory.PlayAndRecord,
+			AVAudioSessionCategoryOptions.DefaultToSpeaker | AVAudioSessionCategoryOptions.AllowBluetooth | AVAudioSessionCategoryOptions.AllowAirPlay | AVAudioSessionCategoryOptions.AllowBluetoothA2DP);
+	}
+
+	void StopRecording()
+	{
+		audioEngine?.InputNode.RemoveTapOnBus(0);
+		audioEngine?.Stop();
+		liveSpeechRequest?.EndAudio();
+		recognitionTask?.Cancel();
+		OnSpeechToTextStateChanged(CurrentState);
+	}
+
+	Task InternalStopListeningAsync(CancellationToken cancellationToken)
+	{
+		cancellationToken.ThrowIfCancellationRequested();
+		StopRecording();
+		return Task.CompletedTask;
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToText.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToText.shared.cs
new file mode 100644
index 0000000000..2069983bd0
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToText.shared.cs
@@ -0,0 +1,29 @@
+using System.Globalization;
+
+namespace CommunityToolkit.Maui.Media;
+
+/// <inheritdoc cref="ISpeechToText"/>
+public static class OfflineSpeechToText
+{
+	static Lazy<ISpeechToText> defaultImplementation = new(new OfflineSpeechToTextImplementation());
+
+	/// <summary>
+	/// Default implementation of <see cref="ISpeechToText"/>
+	/// </summary>
+	public static ISpeechToText Default => defaultImplementation.Value;
+
+	/// <inheritdoc cref="ISpeechToText.StartListenAsync"/>
+	public static Task StartListenAsync(SpeechToTextOptions options, CancellationToken cancellationToken = default) =>
+		Default.StartListenAsync(options, cancellationToken);
+
+	/// <inheritdoc cref="ISpeechToText.StopListenAsync"/>
+	public static Task StopListenAsync(CancellationToken cancellationToken = default) =>
+		Default.StopListenAsync(cancellationToken);
+	
+	/// <inheritdoc cref="ISpeechToText.RequestPermissions"/>
+	public static Task<bool> RequestPermissions(CancellationToken cancellationToken = default) =>
+		Default.RequestPermissions(cancellationToken);
+
+	internal static void SetDefault(ISpeechToText implementation) =>
+		defaultImplementation = new(implementation);
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.android.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.android.cs
new file mode 100644
index 0000000000..978d14b840
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.android.cs
@@ -0,0 +1,176 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Runtime.Versioning;
+using Android.Content;
+using Android.Runtime;
+using Android.Speech;
+using Microsoft.Maui.ApplicationModel;
+
+namespace CommunityToolkit.Maui.Media;
+
+/// <inheritdoc />
+public sealed partial class OfflineSpeechToTextImplementation
+{
+	SpeechRecognizer? speechRecognizer;
+	SpeechRecognitionListener? listener;
+	SpeechToTextState currentState = SpeechToTextState.Stopped;
+
+	/// <inheritdoc />
+	public SpeechToTextState CurrentState
+	{
+		get => currentState;
+		private set
+		{
+			if (currentState != value)
+			{
+				currentState = value;
+				OnSpeechToTextStateChanged(currentState);
+			}
+		}
+	}
+
+	/// <inheritdoc />
+	public ValueTask DisposeAsync()
+	{
+		listener?.Dispose();
+		speechRecognizer?.Dispose();
+
+		listener = null;
+		speechRecognizer = null;
+		return ValueTask.CompletedTask;
+	}
+
+	static Intent CreateSpeechIntent(SpeechToTextOptions options)
+	{
+		var intent = new Intent(RecognizerIntent.ActionRecognizeSpeech);
+		intent.PutExtra(RecognizerIntent.ExtraLanguagePreference, Java.Util.Locale.Default.ToString());
+		intent.PutExtra(RecognizerIntent.ExtraLanguageModel, RecognizerIntent.LanguageModelFreeForm);
+		intent.PutExtra(RecognizerIntent.ExtraCallingPackage, Application.Context.PackageName);
+		intent.PutExtra(RecognizerIntent.ExtraPartialResults, options.ShouldReportPartialResults);
+
+		var javaLocale = Java.Util.Locale.ForLanguageTag(options.Culture.Name).ToString();
+		intent.PutExtra(RecognizerIntent.ExtraLanguage, javaLocale);
+
+		return intent;
+	}
+
+	static bool IsSpeechRecognitionAvailable() => OperatingSystem.IsAndroidVersionAtLeast(33) && SpeechRecognizer.IsOnDeviceRecognitionAvailable(Application.Context);
+	
+	[MemberNotNull(nameof(speechRecognizer), nameof(listener))]
+	[SupportedOSPlatform("Android33.0")]
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
+	{
+		if (!IsSpeechRecognitionAvailable())
+		{
+			throw new FeatureNotSupportedException("Speech Recognition is not available on this device");
+		}
+
+		var recognizerIntent = CreateSpeechIntent(options);
+
+		speechRecognizer = SpeechRecognizer.CreateOnDeviceSpeechRecognizer(Application.Context);
+		speechRecognizer.TriggerModelDownload(recognizerIntent);
+
+
+		listener = new SpeechRecognitionListener(this)
+		{
+			Error = HandleListenerError,
+			PartialResults = HandleListenerPartialResults,
+			Results = HandleListenerResults
+		};
+		speechRecognizer.SetRecognitionListener(listener);
+		speechRecognizer.StartListening(recognizerIntent);
+
+		cancellationToken.ThrowIfCancellationRequested();
+
+		return Task.CompletedTask;
+	}
+
+	Task InternalStopListeningAsync(CancellationToken cancellationToken)
+	{
+		cancellationToken.ThrowIfCancellationRequested();
+		StopRecording();
+		return Task.CompletedTask;
+	}
+	
+	void HandleListenerError(SpeechRecognizerError error)
+	{
+		OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception($"Failure in speech engine - {error}")));
+	}
+
+	void HandleListenerPartialResults(string sentence)
+	{
+		OnRecognitionResultUpdated(sentence);
+	}
+
+	void HandleListenerResults(string result)
+	{
+		OnRecognitionResultCompleted(SpeechToTextResult.Success(result));
+	}
+
+	void StopRecording()
+	{
+		speechRecognizer?.StopListening();
+		speechRecognizer?.Destroy();
+		CurrentState = SpeechToTextState.Stopped;
+	}
+
+	class SpeechRecognitionListener(OfflineSpeechToTextImplementation speechToText) : Java.Lang.Object, IRecognitionListener
+	{
+		public required Action<SpeechRecognizerError> Error { get; init; }
+		public required Action<string> PartialResults { get; init; }
+		public required Action<string> Results { get; init; }
+
+		public void OnBeginningOfSpeech()
+		{
+			speechToText.CurrentState = SpeechToTextState.Listening;
+		}
+
+		public void OnBufferReceived(byte[]? buffer)
+		{
+		}
+
+		public void OnEndOfSpeech()
+		{
+			speechToText.CurrentState = SpeechToTextState.Silence;
+		}
+
+		public void OnError([GeneratedEnum] SpeechRecognizerError error)
+		{
+			Error.Invoke(error);
+			speechToText.CurrentState = SpeechToTextState.Stopped;
+		}
+
+		public void OnEvent(int eventType, Bundle? @params)
+		{
+		}
+
+		public void OnPartialResults(Bundle? partialResults)
+		{
+			SendResults(partialResults, PartialResults);
+		}
+
+		public void OnReadyForSpeech(Bundle? @params)
+		{
+		}
+
+		public void OnResults(Bundle? results)
+		{
+			SendResults(results, Results);
+		}
+
+		public void OnRmsChanged(float rmsdB)
+		{
+		}
+
+		static void SendResults(Bundle? bundle, Action<string> action)
+		{
+			var matches = bundle?.GetStringArrayList(SpeechRecognizer.ResultsRecognition);
+			if (matches is null || matches.Count == 0)
+			{
+				return;
+			}
+
+			action.Invoke(matches[0]);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.ios.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.ios.cs
new file mode 100644
index 0000000000..17fbafee58
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.ios.cs
@@ -0,0 +1,88 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Runtime.Versioning;
+using AVFoundation;
+using Speech;
+
+namespace CommunityToolkit.Maui.Media;
+
+/// <inheritdoc />
+public sealed partial class OfflineSpeechToTextImplementation
+{
+	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest))]
+	[SupportedOSPlatform("ios13.0")]
+	[SupportedOSPlatform("maccatalyst")]
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
+	{
+		if (!UIDevice.CurrentDevice.CheckSystemVersion(13, 0))
+		{
+			throw new NotSupportedException("Offline listening is supported on iOS 13 and later");
+		}
+
+		speechRecognizer = new SFSpeechRecognizer(NSLocale.FromLocaleIdentifier(options.Culture.Name));
+		speechRecognizer.SupportsOnDeviceRecognition = true;
+		
+		if (!speechRecognizer.Available)
+		{
+			throw new ArgumentException("Speech recognizer is not available");
+		}
+
+		audioEngine = new AVAudioEngine();
+		liveSpeechRequest = new SFSpeechAudioBufferRecognitionRequest()
+		{
+			ShouldReportPartialResults = options.ShouldReportPartialResults,
+			RequiresOnDeviceRecognition = true
+		};
+
+		InitializeAvAudioSession(out _);
+
+		var node = audioEngine.InputNode;
+		var recordingFormat = node.GetBusOutputFormat(0);
+		node.InstallTapOnBus(0, 1024, recordingFormat, (buffer, _) => liveSpeechRequest.Append(buffer));
+
+		audioEngine.Prepare();
+		audioEngine.StartAndReturnError(out var error);
+
+		if (error is not null)
+		{
+			throw new ArgumentException("Error starting audio engine - " + error.LocalizedDescription);
+		}
+
+		cancellationToken.ThrowIfCancellationRequested();
+
+		var currentIndex = 0;
+		recognitionTask = speechRecognizer.GetRecognitionTask(liveSpeechRequest, (result, err) =>
+		{
+			if (err is not null)
+			{
+				StopRecording();
+				OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception(err.LocalizedDescription)));
+			}
+			else
+			{
+				if (result.Final)
+				{
+					currentIndex = 0;
+					StopRecording();
+					OnRecognitionResultCompleted(SpeechToTextResult.Success(result.BestTranscription.FormattedString));
+				}
+				else
+				{
+					if (currentIndex <= 0)
+					{
+						OnSpeechToTextStateChanged(CurrentState);
+					}
+
+					for (var i = currentIndex; i < result.BestTranscription.Segments.Length; i++)
+					{
+						var s = result.BestTranscription.Segments[i].Substring;
+						currentIndex++;
+						OnRecognitionResultUpdated(s);
+					}
+				}
+			}
+		});
+
+		return Task.CompletedTask;
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.macos.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.macos.cs
new file mode 100644
index 0000000000..62cdc49335
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.macos.cs
@@ -0,0 +1,99 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using AVFoundation;
+using Speech;
+
+namespace CommunityToolkit.Maui.Media;
+
+/// <inheritdoc />
+public sealed partial class OfflineSpeechToTextImplementation
+{
+	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest))]
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
+	{
+		speechRecognizer = new SFSpeechRecognizer(NSLocale.FromLocaleIdentifier(options.Culture.Name));
+		speechRecognizer.SupportsOnDeviceRecognition = true;
+		
+		if (!speechRecognizer.Available)
+		{
+			throw new ArgumentException("Speech recognizer is not available");
+		}
+
+		audioEngine = new AVAudioEngine
+		{
+			AutoShutdownEnabled = false
+		};
+		liveSpeechRequest = new SFSpeechAudioBufferRecognitionRequest()
+		{
+			ShouldReportPartialResults = options.ShouldReportPartialResults,
+			RequiresOnDeviceRecognition = true
+		};
+
+		InitializeAvAudioSession(out var audioSession);
+
+		var mode = audioSession.AvailableModes.Contains("AVAudioSessionModeMeasurement")
+			? AVAudioSessionMode.Measurement
+			: AVAudioSessionMode.Default;
+
+		audioSession.SetMode(mode, out var audioSessionError);
+		if (audioSessionError is not null)
+		{
+			throw new Exception(audioSessionError.LocalizedDescription);
+		}
+
+		audioSession.SetActive(true, AVAudioSessionSetActiveOptions.NotifyOthersOnDeactivation, out audioSessionError);
+		if (audioSessionError is not null)
+		{
+			throw new Exception(audioSessionError.LocalizedDescription);
+		}
+
+		var node = audioEngine.InputNode;
+		var recordingFormat = node.GetBusOutputFormat(0);
+		node.InstallTapOnBus(0, 1024, recordingFormat, (buffer, _) => liveSpeechRequest.Append(buffer));
+
+		audioEngine.Prepare();
+		audioEngine.StartAndReturnError(out var error);
+
+		if (error is not null)
+		{
+			throw new Exception(error.LocalizedDescription);
+		}
+
+		cancellationToken.ThrowIfCancellationRequested();
+
+		var currentIndex = 0;
+		recognitionTask = speechRecognizer.GetRecognitionTask(liveSpeechRequest, (result, err) =>
+		{
+			if (err is not null)
+			{
+				StopRecording();
+				OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception(err.LocalizedDescription)));
+			}
+			else
+			{
+				if (result.Final)
+				{
+					currentIndex = 0;
+					StopRecording();
+					OnRecognitionResultCompleted(SpeechToTextResult.Success(result.BestTranscription.FormattedString));
+				}
+				else
+				{
+					if (currentIndex <= 0)
+					{
+						OnSpeechToTextStateChanged(CurrentState);
+					}
+
+					for (var i = currentIndex; i < result.BestTranscription.Segments.Length; i++)
+					{
+						var s = result.BestTranscription.Segments[i].Substring;
+						currentIndex++;
+						OnRecognitionResultUpdated(s);
+					}
+				}
+			}
+		});
+
+		return Task.CompletedTask;
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.net.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.net.cs
new file mode 100644
index 0000000000..be8544824c
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.net.cs
@@ -0,0 +1,26 @@
+using System.Globalization;
+
+namespace CommunityToolkit.Maui.Media;
+
+/// <inheritdoc />
+public sealed partial class OfflineSpeechToTextImplementation
+{
+	/// <inheritdoc />
+	public ValueTask DisposeAsync()
+	{
+		return ValueTask.CompletedTask;
+	}
+
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
+	{
+		throw new NotSupportedException();
+	}
+
+	Task InternalStopListeningAsync(CancellationToken cancellationToken)
+	{
+		throw new NotSupportedException();
+	}
+
+	/// <inheritdoc />
+	public SpeechToTextState CurrentState { get; } = SpeechToTextState.Stopped;
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.shared.cs
new file mode 100644
index 0000000000..b7acfe23f7
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.shared.cs
@@ -0,0 +1,80 @@
+using System.Globalization;
+using Microsoft.Maui.ApplicationModel;
+
+namespace CommunityToolkit.Maui.Media;
+
+/// <inheritdoc cref="ISpeechToText"/>
+public sealed partial class OfflineSpeechToTextImplementation : ISpeechToText
+{
+	readonly WeakEventManager recognitionResultUpdatedWeakEventManager = new();
+	readonly WeakEventManager recognitionResultCompletedWeakEventManager = new();
+	readonly WeakEventManager speechToTextStateChangedWeakEventManager = new();
+
+	/// <inheritdoc />
+	public event EventHandler<SpeechToTextRecognitionResultUpdatedEventArgs> RecognitionResultUpdated
+	{
+		add => recognitionResultUpdatedWeakEventManager.AddEventHandler(value);
+		remove => recognitionResultUpdatedWeakEventManager.RemoveEventHandler(value);
+	}
+
+	/// <inheritdoc />
+	public event EventHandler<SpeechToTextRecognitionResultCompletedEventArgs> RecognitionResultCompleted
+	{
+		add => recognitionResultCompletedWeakEventManager.AddEventHandler(value);
+		remove => recognitionResultCompletedWeakEventManager.RemoveEventHandler(value);
+	}
+
+	/// <inheritdoc />
+	public event EventHandler<SpeechToTextStateChangedEventArgs> StateChanged
+	{
+		add => speechToTextStateChangedWeakEventManager.AddEventHandler(value);
+		remove => speechToTextStateChangedWeakEventManager.RemoveEventHandler(value);
+	}
+
+	/// <inheritdoc/>
+	public async Task StartListenAsync(SpeechToTextOptions options, CancellationToken cancellationToken = default)
+	{
+		cancellationToken.ThrowIfCancellationRequested();
+
+		var isPermissionGranted = await IsSpeechPermissionAuthorized(cancellationToken).ConfigureAwait(false);
+		if (!isPermissionGranted)
+		{
+			throw new PermissionException($"{nameof(Permissions)}.{nameof(Permissions.Microphone)} Not Granted");
+		}
+
+		await InternalStartListeningAsync(options, cancellationToken).ConfigureAwait(false);
+	}
+
+	/// <inheritdoc/>
+	public Task StopListenAsync(CancellationToken cancellationToken = default) => InternalStopListeningAsync(cancellationToken);
+
+	void OnRecognitionResultUpdated(string recognitionResult)
+	{
+		recognitionResultUpdatedWeakEventManager.HandleEvent(this, new SpeechToTextRecognitionResultUpdatedEventArgs(recognitionResult), nameof(RecognitionResultUpdated));
+	}
+
+	void OnRecognitionResultCompleted(SpeechToTextResult recognitionResult)
+	{
+		recognitionResultCompletedWeakEventManager.HandleEvent(this, new SpeechToTextRecognitionResultCompletedEventArgs(recognitionResult), nameof(RecognitionResultCompleted));
+	}
+
+	void OnSpeechToTextStateChanged(SpeechToTextState speechToTextState)
+	{
+		speechToTextStateChangedWeakEventManager.HandleEvent(this, new SpeechToTextStateChangedEventArgs(speechToTextState), nameof(StateChanged));
+	}
+
+#if !MACCATALYST && !IOS
+	/// <inheritdoc/>
+	public async Task<bool> RequestPermissions(CancellationToken cancellationToken = default)
+	{
+		var status = await Permissions.RequestAsync<Permissions.Microphone>().WaitAsync(cancellationToken).ConfigureAwait(false);
+		return status is PermissionStatus.Granted;
+	}
+
+	static async Task<bool> IsSpeechPermissionAuthorized(CancellationToken cancellationToken)
+	{
+		var status = await Permissions.CheckStatusAsync<Permissions.Microphone>().WaitAsync(cancellationToken).ConfigureAwait(false);
+		return status is PermissionStatus.Granted;
+	}
+#endif
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.tizen.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.tizen.cs
new file mode 100644
index 0000000000..6832c962ce
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.tizen.cs
@@ -0,0 +1,158 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Threading;
+using Tizen.Uix.Stt;
+
+namespace CommunityToolkit.Maui.Media;
+
+/// <inheritdoc />
+public sealed partial class OfflineSpeechToTextImplementation
+{
+	SttClient? sttClient;
+	TaskCompletionSource<bool>? tcsInitialize;
+	string defaultSttEngineLocale = "en_US";
+
+	/// <inheritdoc/>
+	public SpeechToTextState CurrentState => sttClient?.CurrentState is Tizen.Uix.Stt.State.Recording
+		? SpeechToTextState.Listening
+		: SpeechToTextState.Stopped;
+
+	/// <inheritdoc />
+	public ValueTask DisposeAsync()
+	{
+		if (sttClient is not null)
+		{
+			if (sttClient.CurrentState is Tizen.Uix.Stt.State.Ready)
+			{
+				sttClient.Unprepare();
+			}
+			else
+			{
+				sttClient.Cancel();
+				sttClient.RecognitionResult -= OnRecognitionResult;
+				sttClient.ErrorOccurred -= OnErrorOccurred;
+				sttClient.StateChanged -= OnStateChanged;
+			}
+
+			sttClient.Dispose();
+
+			sttClient = null;
+		}
+
+		return ValueTask.CompletedTask;
+	}
+
+	void StopRecording(in SttClient sttClient)
+	{
+		if (sttClient.CurrentState is Tizen.Uix.Stt.State.Recording)
+		{
+			sttClient.Stop();
+		}
+
+		sttClient.RecognitionResult -= OnRecognitionResult;
+		sttClient.ErrorOccurred -= OnErrorOccurred;
+		sttClient.StateChanged -= OnStateChanged;
+	}
+
+	void OnErrorOccurred(object? sender, ErrorOccurredEventArgs e)
+	{
+		if (sttClient is not null)
+		{
+			StopRecording(sttClient);
+		}
+
+		OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception("STT failed - " + e.ErrorMessage)));
+	}
+
+	void OnRecognitionResult(object? sender, RecognitionResultEventArgs e)
+	{
+		if (e.Result is ResultEvent.Error)
+		{
+			if (sttClient is not null)
+			{
+				StopRecording(sttClient);
+			}
+
+			OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception("Failure in speech engine - " + e.Message)));
+		}
+		else if (e.Result is ResultEvent.PartialResult)
+		{
+			foreach (var d in e.Data)
+			{
+				OnRecognitionResultUpdated(d);
+			}
+		}
+		else
+		{
+			if (sttClient is not null)
+			{
+				StopRecording(sttClient);
+			}
+
+			OnRecognitionResultCompleted(SpeechToTextResult.Success(e.Data.ToString() ?? string.Empty));
+		}
+	}
+
+	void OnStateChanged(object? sender, StateChangedEventArgs e)
+	{
+		OnSpeechToTextStateChanged(CurrentState);
+	}
+
+	[MemberNotNull(nameof(sttClient))]
+	Task<bool> Initialize(CancellationToken cancellationToken)
+	{
+		if (tcsInitialize != null && sttClient != null)
+		{
+			return tcsInitialize.Task.WaitAsync(cancellationToken);
+		}
+
+		tcsInitialize = new TaskCompletionSource<bool>();
+		sttClient = new SttClient();
+
+		sttClient.StateChanged += (s, e) =>
+		{
+			if (e.Current == Tizen.Uix.Stt.State.Ready)
+			{
+				tcsInitialize.TrySetResult(true);
+			}
+		};
+
+		try
+		{
+			sttClient.Prepare();
+		}
+		catch (Exception ex)
+		{
+			OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception("STT is not available - " + ex)));
+		}
+
+		return tcsInitialize.Task.WaitAsync(cancellationToken);
+	}
+
+	async Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
+	{
+		await Initialize(cancellationToken);
+
+		sttClient.ErrorOccurred += OnErrorOccurred;
+		sttClient.RecognitionResult += OnRecognitionResult;
+		sttClient.StateChanged += OnStateChanged;
+
+		var recognitionType = sttClient.IsRecognitionTypeSupported(RecognitionType.Partial)
+			? RecognitionType.Partial
+			: RecognitionType.Free;
+
+		sttClient.Start(defaultSttEngineLocale, recognitionType);
+	}
+
+	Task InternalStopListeningAsync(CancellationToken cancellationToken)
+	{
+		cancellationToken.ThrowIfCancellationRequested();
+
+		if (sttClient is not null)
+		{
+			StopRecording(sttClient);
+		}
+
+		return Task.CompletedTask;
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.windows.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.windows.cs
new file mode 100644
index 0000000000..47f7f0fd35
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.windows.cs
@@ -0,0 +1,118 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Speech.Recognition;
+
+namespace CommunityToolkit.Maui.Media;
+
+/// <inheritdoc />
+public sealed partial class OfflineSpeechToTextImplementation
+{
+	string recognitionText = string.Empty;
+	SpeechRecognitionEngine? offlineSpeechRecognizer;
+	SpeechToTextOptions? speechToTextOptions;
+
+	/// <inheritdoc/>
+	public SpeechToTextState CurrentState
+	{
+		get
+		{
+			return offlineSpeechRecognizer?.AudioState switch
+			{
+				AudioState.Speech => SpeechToTextState.Listening,
+				AudioState.Silence => SpeechToTextState.Silence,
+				_ => SpeechToTextState.Stopped
+			};
+		}
+	}
+
+	/// <inheritdoc />
+	public ValueTask DisposeAsync()
+	{
+		StopRecording();
+
+		offlineSpeechRecognizer?.Dispose();
+		offlineSpeechRecognizer = null;
+		return ValueTask.CompletedTask;
+	}
+
+	async Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
+	{
+		await Initialize(options, cancellationToken);
+
+		offlineSpeechRecognizer.AudioStateChanged += OfflineSpeechRecognizer_StateChanged;
+		offlineSpeechRecognizer.LoadGrammar(new DictationGrammar());
+
+		offlineSpeechRecognizer.InitialSilenceTimeout = TimeSpan.MaxValue;
+		offlineSpeechRecognizer.BabbleTimeout = TimeSpan.MaxValue;
+
+		offlineSpeechRecognizer.SetInputToDefaultAudioDevice();
+
+		offlineSpeechRecognizer.RecognizeCompleted += OnRecognizeCompleted;
+		offlineSpeechRecognizer.SpeechRecognized += OnSpeechRecognized;
+		offlineSpeechRecognizer.RecognizeAsync(RecognizeMode.Multiple);
+	}
+
+	void OnRecognizeCompleted(object? sender, RecognizeCompletedEventArgs args)
+	{
+		if (args.Cancelled)
+		{
+			OnRecognitionResultCompleted(new SpeechToTextResult(recognitionText, new TaskCanceledException("Operation cancelled")));
+		}
+		else if (args.Error is not null)
+		{
+			OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception(args.Error.ToString())));
+		}
+		else
+		{
+			OnRecognitionResultCompleted(SpeechToTextResult.Success(recognitionText));
+		}
+	}
+
+	void OnSpeechRecognized(object? sender, SpeechRecognizedEventArgs args)
+	{
+		recognitionText += args.Result.Text;
+		if (speechToTextOptions?.ShouldReportPartialResults == true)
+		{
+			OnRecognitionResultUpdated(args.Result.Text);
+		}
+	}
+
+	Task InternalStopListeningAsync(CancellationToken cancellationToken)
+	{
+		StopRecording();
+		return Task.CompletedTask;
+	}
+
+	void StopRecording()
+	{
+		try
+		{
+			if (offlineSpeechRecognizer is not null)
+			{
+				offlineSpeechRecognizer.RecognizeAsyncStop();
+
+				offlineSpeechRecognizer.AudioStateChanged -= OfflineSpeechRecognizer_StateChanged;
+				offlineSpeechRecognizer.RecognizeCompleted -= OnRecognizeCompleted;
+				offlineSpeechRecognizer.SpeechRecognized -= OnSpeechRecognized;
+			}
+		}
+		catch
+		{
+			// ignored. Recording may be already stopped
+		}
+	}
+
+	[MemberNotNull(nameof(recognitionText), nameof(offlineSpeechRecognizer), nameof(speechToTextOptions))]
+	Task Initialize(SpeechToTextOptions options, CancellationToken cancellationToken)
+	{
+		speechToTextOptions = options;
+		recognitionText = string.Empty;
+		offlineSpeechRecognizer = new SpeechRecognitionEngine(options.Culture);
+		cancellationToken.ThrowIfCancellationRequested();
+		return Task.CompletedTask;
+	}
+
+	void OfflineSpeechRecognizer_StateChanged(object? sender, AudioStateChangedEventArgs e)
+	{
+		OnSpeechToTextStateChanged(CurrentState);
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToText.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToText.shared.cs
index 7b0cd35803..1b7ad3bdcb 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToText.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToText.shared.cs
@@ -13,21 +13,13 @@ public static class SpeechToText
 	public static ISpeechToText Default => defaultImplementation.Value;
 
 	/// <inheritdoc cref="ISpeechToText.StartListenAsync"/>
-	public static Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken = default) =>
-		Default.StartListenAsync(culture, cancellationToken);
+	public static Task StartListenAsync(SpeechToTextOptions options, CancellationToken cancellationToken = default) =>
+		Default.StartListenAsync(options, cancellationToken);
 
 	/// <inheritdoc cref="ISpeechToText.StopListenAsync"/>
 	public static Task StopListenAsync(CancellationToken cancellationToken = default) =>
 		Default.StopListenAsync(cancellationToken);
 
-	/// <inheritdoc cref="ISpeechToText.StartOfflineListenAsync"/>
-	public static Task StartOfflineListenAsync(CultureInfo culture, CancellationToken cancellationToken = default) =>
-		Default.StartOfflineListenAsync(culture, cancellationToken);
-
-	/// <inheritdoc cref="ISpeechToText.StopOfflineListenAsync"/>
-	public static Task StopOfflineListenAsync(CancellationToken cancellationToken = default) =>
-		Default.StopOfflineListenAsync(cancellationToken);
-
 	/// <inheritdoc cref="ISpeechToText.RequestPermissions"/>
 	public static Task<bool> RequestPermissions(CancellationToken cancellationToken = default) =>
 		Default.RequestPermissions(cancellationToken);
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.android.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.android.cs
index 0e9a4850d6..938750d827 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.android.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.android.cs
@@ -12,7 +12,6 @@ public sealed partial class SpeechToTextImplementation
 {
 	SpeechRecognizer? speechRecognizer;
 	SpeechRecognitionListener? listener;
-	CultureInfo? cultureInfo;
 	SpeechToTextState currentState = SpeechToTextState.Stopped;
 
 	/// <inheritdoc />
@@ -40,49 +39,34 @@ public ValueTask DisposeAsync()
 		return ValueTask.CompletedTask;
 	}
 
-	static Intent CreateSpeechIntent(CultureInfo culture)
+	static Intent CreateSpeechIntent(SpeechToTextOptions options)
 	{
 		var intent = new Intent(RecognizerIntent.ActionRecognizeSpeech);
 		intent.PutExtra(RecognizerIntent.ExtraLanguagePreference, Java.Util.Locale.Default.ToString());
 		intent.PutExtra(RecognizerIntent.ExtraLanguageModel, RecognizerIntent.LanguageModelFreeForm);
 		intent.PutExtra(RecognizerIntent.ExtraCallingPackage, Application.Context.PackageName);
-		intent.PutExtra(RecognizerIntent.ExtraPartialResults, true);
+		intent.PutExtra(RecognizerIntent.ExtraPartialResults, options.ShouldReportPartialResults);
 
-		var javaLocale = Java.Util.Locale.ForLanguageTag(culture.Name).ToString();
+		var javaLocale = Java.Util.Locale.ForLanguageTag(options.Culture.Name).ToString();
 		intent.PutExtra(RecognizerIntent.ExtraLanguage, javaLocale);
 
 		return intent;
 	}
 
 	static bool IsSpeechRecognitionAvailable() => SpeechRecognizer.IsRecognitionAvailable(Application.Context);
-
-	[MemberNotNull(nameof(speechRecognizer), nameof(listener))]
-	Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
-	{
-		return InternalStartListeningAsync(culture, true, cancellationToken);
-	}
 	
 	[MemberNotNull(nameof(speechRecognizer), nameof(listener))]
-	Task InternalStartListeningAsync(CultureInfo culture, bool isOnline, CancellationToken cancellationToken)
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
-		cultureInfo = culture;
 		var isSpeechRecognitionAvailable = IsSpeechRecognitionAvailable();
 		if (!isSpeechRecognitionAvailable)
 		{
 			throw new FeatureNotSupportedException("Speech Recognition is not available on this device");
 		}
 
-		var recognizerIntent = CreateSpeechIntent(cultureInfo);
+		var recognizerIntent = CreateSpeechIntent(options);
 
-		if (!isOnline && OperatingSystem.IsAndroidVersionAtLeast(33) && SpeechRecognizer.IsOnDeviceRecognitionAvailable(Application.Context))
-		{
-			speechRecognizer = SpeechRecognizer.CreateOnDeviceSpeechRecognizer(Application.Context);
-			speechRecognizer.TriggerModelDownload(recognizerIntent);
-		}
-		else
-		{
-			speechRecognizer = SpeechRecognizer.CreateSpeechRecognizer(Application.Context);
-		}
+		speechRecognizer = SpeechRecognizer.CreateSpeechRecognizer(Application.Context);
 
 		if (speechRecognizer is null)
 		{
@@ -110,16 +94,6 @@ Task InternalStopListeningAsync(CancellationToken cancellationToken)
 		return Task.CompletedTask;
 	}
 
-	Task InternalStartOfflineListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
-	{
-		return InternalStartListeningAsync(culture, isOnline: false, cancellationToken);
-	}
-
-	Task InternalStopOfflineListeningAsync(CancellationToken cancellationToken)
-	{
-		return InternalStopListeningAsync(cancellationToken);
-	}
-
 	void HandleListenerError(SpeechRecognizerError error)
 	{
 		OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception($"Failure in speech engine - {error}")));
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.ios.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.ios.cs
index 95b445acbe..433c2cf920 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.ios.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.ios.cs
@@ -9,14 +9,9 @@ namespace CommunityToolkit.Maui.Media;
 public sealed partial class SpeechToTextImplementation
 {
 	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest))]
-	Task InternalStartListeningAsync(CultureInfo culture, bool isOnline, CancellationToken cancellationToken)
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
-		speechRecognizer = new SFSpeechRecognizer(NSLocale.FromLocaleIdentifier(culture.Name));
-
-		if (isOnline && UIDevice.CurrentDevice.CheckSystemVersion(13, 0))
-		{
-			speechRecognizer.SupportsOnDeviceRecognition = true;
-		}
+		speechRecognizer = new SFSpeechRecognizer(NSLocale.FromLocaleIdentifier(options.Culture.Name));
 
 		if (!speechRecognizer.Available)
 		{
@@ -26,12 +21,8 @@ Task InternalStartListeningAsync(CultureInfo culture, bool isOnline, Cancellatio
 		audioEngine = new AVAudioEngine();
 		liveSpeechRequest = new SFSpeechAudioBufferRecognitionRequest()
 		{
-			ShouldReportPartialResults = true
+			ShouldReportPartialResults = options.ShouldReportPartialResults
 		};
-		if (isOnline && UIDevice.CurrentDevice.CheckSystemVersion(13, 0))
-		{
-			liveSpeechRequest.RequiresOnDeviceRecognition = true;
-		}
 
 		InitializeAvAudioSession(out _);
 
@@ -84,21 +75,4 @@ Task InternalStartListeningAsync(CultureInfo culture, bool isOnline, Cancellatio
 
 		return Task.CompletedTask;
 	}
-
-	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest))]
-	Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
-	{
-		return InternalStartListeningAsync(culture, true, cancellationToken);
-	}
-
-	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest))]
-	Task InternalStartOfflineListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
-	{
-		if (!UIDevice.CurrentDevice.CheckSystemVersion(13, 0))
-		{
-			throw new NotSupportedException("Offline listening is supported on iOS 13 and later");
-		}
-
-		return InternalStartListeningAsync(culture, false, cancellationToken);
-	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.macos.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.macos.cs
index 136781e3e2..4de6c17bbd 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.macos.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.macos.cs
@@ -9,15 +9,10 @@ namespace CommunityToolkit.Maui.Media;
 public sealed partial class SpeechToTextImplementation
 {
 	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest))]
-	Task InternalStartListeningAsync(CultureInfo culture, bool isOnline, CancellationToken cancellationToken)
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
-		speechRecognizer = new SFSpeechRecognizer(NSLocale.FromLocaleIdentifier(culture.Name));
+		speechRecognizer = new SFSpeechRecognizer(NSLocale.FromLocaleIdentifier(options.Culture.Name));
 
-		if (isOnline)
-		{
-			speechRecognizer.SupportsOnDeviceRecognition = true;
-		}
-		
 		if (!speechRecognizer.Available)
 		{
 			throw new ArgumentException("Speech recognizer is not available");
@@ -29,12 +24,8 @@ Task InternalStartListeningAsync(CultureInfo culture, bool isOnline, Cancellatio
 		};
 		liveSpeechRequest = new SFSpeechAudioBufferRecognitionRequest()
 		{
-			ShouldReportPartialResults = true
+			ShouldReportPartialResults = options.ShouldReportPartialResults
 		};
-		if (isOnline)
-		{
-			liveSpeechRequest.RequiresOnDeviceRecognition = true;
-		}
 
 		InitializeAvAudioSession(out var audioSession);
 
@@ -103,16 +94,4 @@ Task InternalStartListeningAsync(CultureInfo culture, bool isOnline, Cancellatio
 
 		return Task.CompletedTask;
 	}
-
-	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest))]
-	Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
-	{
-		return InternalStartListeningAsync(culture, true, cancellationToken);
-	}
-
-	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest))]
-	Task InternalStartOfflineListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
-	{
-		return InternalStartListeningAsync(culture, false, cancellationToken);
-	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.net.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.net.cs
index 97a5d91492..c4558e9443 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.net.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.net.cs
@@ -11,7 +11,7 @@ public ValueTask DisposeAsync()
 		return ValueTask.CompletedTask;
 	}
 
-	Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
 		throw new NotSupportedException();
 	}
@@ -21,16 +21,6 @@ Task InternalStopListeningAsync(CancellationToken cancellationToken)
 		throw new NotSupportedException();
 	}
 
-	Task InternalStartOfflineListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
-	{
-		throw new NotSupportedException();
-	}
-
-	Task InternalStopOfflineListeningAsync(CancellationToken cancellationToken)
-	{
-		throw new NotSupportedException();
-	}
-
 	/// <inheritdoc />
 	public SpeechToTextState CurrentState { get; } = SpeechToTextState.Stopped;
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs
index f73fb44a78..5d01647326 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs
@@ -32,7 +32,7 @@ public event EventHandler<SpeechToTextStateChangedEventArgs> StateChanged
 	}
 
 	/// <inheritdoc/>
-	public async Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken = default)
+	public async Task StartListenAsync(SpeechToTextOptions options, CancellationToken cancellationToken = default)
 	{
 		cancellationToken.ThrowIfCancellationRequested();
 
@@ -42,29 +42,12 @@ public async Task StartListenAsync(CultureInfo culture, CancellationToken cancel
 			throw new PermissionException($"{nameof(Permissions)}.{nameof(Permissions.Microphone)} Not Granted");
 		}
 
-		await InternalStartListeningAsync(culture, cancellationToken).ConfigureAwait(false);
+		await InternalStartListeningAsync(options, cancellationToken).ConfigureAwait(false);
 	}
 
 	/// <inheritdoc/>
 	public Task StopListenAsync(CancellationToken cancellationToken = default) => InternalStopListeningAsync(cancellationToken);
 
-	/// <inheritdoc/>
-	public async Task StartOfflineListenAsync(CultureInfo culture, CancellationToken cancellationToken = default)
-	{
-		cancellationToken.ThrowIfCancellationRequested();
-
-		var isPermissionGranted = await IsSpeechPermissionAuthorized(cancellationToken).ConfigureAwait(false);
-		if (!isPermissionGranted)
-		{
-			throw new PermissionException($"{nameof(Permissions)}.{nameof(Permissions.Microphone)} Not Granted");
-		}
-
-		await InternalStartOfflineListeningAsync(culture, cancellationToken).ConfigureAwait(false);
-	}
-
-	/// <inheritdoc/>
-	public Task StopOfflineListenAsync(CancellationToken cancellationToken = default) => InternalStopOfflineListeningAsync(cancellationToken);
-
 	void OnRecognitionResultUpdated(string recognitionResult)
 	{
 		recognitionResultUpdatedWeakEventManager.HandleEvent(this, new SpeechToTextRecognitionResultUpdatedEventArgs(recognitionResult), nameof(RecognitionResultUpdated));
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs
index 8cd2e26c00..e88781d099 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs
@@ -144,16 +144,6 @@ async Task InternalStartListeningAsync(CultureInfo culture, CancellationToken ca
 		sttClient.Start(defaultSttEngineLocale, recognitionType);
 	}
 
-	Task InternalStartOfflineListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
-	{
-		return Task.CompletedTask;
-	}
-
-	Task InternalStopOfflineListeningAsync(CancellationToken cancellationToken)
-	{
-		return Task.CompletedTask;
-	}
-
 	Task InternalStopListeningAsync(CancellationToken cancellationToken)
 	{
 		cancellationToken.ThrowIfCancellationRequested();
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs
index 299600a008..694eae374b 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs
@@ -15,23 +15,13 @@ public sealed partial class SpeechToTextImplementation
 
 	string recognitionText = string.Empty;
 	SpeechRecognizer? speechRecognizer;
-	SpeechRecognitionEngine? offlineSpeechRecognizer;
+	SpeechToTextOptions? speechToTextOptions;
 
 	/// <inheritdoc/>
 	public SpeechToTextState CurrentState
 	{
 		get
 		{
-			if (speechRecognizer == null)
-			{
-				return offlineSpeechRecognizer?.AudioState switch
-				{
-					AudioState.Speech => SpeechToTextState.Listening,
-					AudioState.Silence => SpeechToTextState.Silence,
-					_ => SpeechToTextState.Stopped
-				};
-			}
-
 			return speechRecognizer?.State switch
 			{
 				SpeechRecognizerState.Capturing or SpeechRecognizerState.SoundStarted or SpeechRecognizerState.SpeechDetected or SpeechRecognizerState.Processing => SpeechToTextState.Listening,
@@ -45,17 +35,13 @@ public SpeechToTextState CurrentState
 	public async ValueTask DisposeAsync()
 	{
 		await StopRecording(CancellationToken.None);
-		StopOfflineRecording();
-
-		offlineSpeechRecognizer?.Dispose();
-		offlineSpeechRecognizer = null;
 		speechRecognizer?.Dispose();
 		speechRecognizer = null;
 	}
 
-	async Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
+	async Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
-		await Initialize(culture, cancellationToken);
+		await Initialize(options, cancellationToken);
 
 		speechRecognizer.ContinuousRecognitionSession.AutoStopSilenceTimeout = TimeSpan.MaxValue;
 		speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ResultGenerated;
@@ -70,23 +56,6 @@ async Task InternalStartListeningAsync(CultureInfo culture, CancellationToken ca
 			throw new PermissionException("Online Speech Recognition Disabled in Privacy Settings");
 		}
 	}
-	
-	async Task InternalStartOfflineListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
-	{
-		await InitializeOffline(culture, cancellationToken);
-
-		offlineSpeechRecognizer.AudioStateChanged += OfflineSpeechRecognizer_StateChanged;
-		offlineSpeechRecognizer.LoadGrammar(new DictationGrammar());
-
-		offlineSpeechRecognizer.InitialSilenceTimeout = TimeSpan.MaxValue;
-		offlineSpeechRecognizer.BabbleTimeout = TimeSpan.MaxValue;
-
-		offlineSpeechRecognizer.SetInputToDefaultAudioDevice();
-
-		offlineSpeechRecognizer.RecognizeCompleted += OnOfflineCompleted;
-		offlineSpeechRecognizer.SpeechRecognized += OfflineResultGenerated;
-		offlineSpeechRecognizer.RecognizeAsync(RecognizeMode.Multiple);
-	}
 
 	void OnCompleted(SpeechContinuousRecognitionSession sender, SpeechContinuousRecognitionCompletedEventArgs args)
 	{
@@ -104,42 +73,17 @@ void OnCompleted(SpeechContinuousRecognitionSession sender, SpeechContinuousReco
 		}
 	}
 
-	void OnOfflineCompleted(object? sender, RecognizeCompletedEventArgs args)
-	{
-		if (args.Cancelled)
-		{
-			OnRecognitionResultCompleted(new SpeechToTextResult(recognitionText, new TaskCanceledException("Operation cancelled")));
-		}
-		else if (args.Error is not null)
-		{
-			OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception(args.Error.ToString())));
-		}
-		else
-		{
-			OnRecognitionResultCompleted(SpeechToTextResult.Success(recognitionText));
-		}
-	}
-
 	void ResultGenerated(SpeechContinuousRecognitionSession sender, SpeechContinuousRecognitionResultGeneratedEventArgs args)
 	{
 		recognitionText += args.Result.Text;
-		OnRecognitionResultUpdated(args.Result.Text);
-	}
-
-	void OfflineResultGenerated(object? sender, SpeechRecognizedEventArgs args)
-	{
-		recognitionText += args.Result.Text;
-		OnRecognitionResultUpdated(args.Result.Text);
+		if (speechToTextOptions?.ShouldReportPartialResults == true)
+		{
+			OnRecognitionResultUpdated(args.Result.Text);
+		}
 	}
 
 	Task InternalStopListeningAsync(CancellationToken cancellationToken) => StopRecording(cancellationToken);
-
-	Task InternalStopOfflineListeningAsync(CancellationToken cancellationToken)
-	{
-		StopOfflineRecording();
-		return Task.CompletedTask;
-	}
-
+	
 	async Task StopRecording(CancellationToken cancellationToken)
 	{
 		try
@@ -160,49 +104,17 @@ async Task StopRecording(CancellationToken cancellationToken)
 		}
 	}
 
-	void StopOfflineRecording()
-	{
-		try
-		{
-			if (offlineSpeechRecognizer is not null)
-			{
-				offlineSpeechRecognizer.RecognizeAsyncStop();
-
-				offlineSpeechRecognizer.AudioStateChanged -= OfflineSpeechRecognizer_StateChanged;
-				offlineSpeechRecognizer.RecognizeCompleted -= OnOfflineCompleted;
-				offlineSpeechRecognizer.SpeechRecognized -= OfflineResultGenerated;
-			}
-		}
-		catch
-		{
-			// ignored. Recording may be already stopped
-		}
-	}
-
-	[MemberNotNull(nameof(recognitionText), nameof(offlineSpeechRecognizer))]
-	Task InitializeOffline(CultureInfo culture, CancellationToken cancellationToken)
+	[MemberNotNull(nameof(recognitionText), nameof(speechRecognizer), nameof(speechToTextOptions))]
+	async Task Initialize(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
+		speechToTextOptions = options;
 		recognitionText = string.Empty;
-		offlineSpeechRecognizer = new SpeechRecognitionEngine(culture);
-		cancellationToken.ThrowIfCancellationRequested();
-		return Task.CompletedTask;
-	}
-
-	[MemberNotNull(nameof(recognitionText), nameof(speechRecognizer))]
-	async Task Initialize(CultureInfo culture, CancellationToken cancellationToken)
-	{
-		recognitionText = string.Empty;
-		speechRecognizer = new SpeechRecognizer(new Language(culture.IetfLanguageTag));
+		speechRecognizer = new SpeechRecognizer(new Language(options.Culture.IetfLanguageTag));
 		speechRecognizer.StateChanged += SpeechRecognizer_StateChanged;
 		cancellationToken.ThrowIfCancellationRequested();
 		await speechRecognizer.CompileConstraintsAsync().AsTask(cancellationToken);
 	}
 
-	void OfflineSpeechRecognizer_StateChanged(object? sender, AudioStateChangedEventArgs e)
-	{
-		OnSpeechToTextStateChanged(CurrentState);
-	}
-
 	void SpeechRecognizer_StateChanged(SpeechRecognizer sender, SpeechRecognizerStateChangedEventArgs args)
 	{
 		OnSpeechToTextStateChanged(CurrentState);
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextOptions.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextOptions.cs
new file mode 100644
index 0000000000..b402bf8b0a
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextOptions.cs
@@ -0,0 +1,19 @@
+using System.Globalization;
+
+namespace CommunityToolkit.Maui.Media;
+
+/// <summary>
+/// Options for configuring speech recognition.
+/// </summary>
+public class SpeechToTextOptions
+{
+	/// <summary>
+	/// The culture to use for speech recognition.
+	/// </summary>
+	public required CultureInfo Culture { get; init; }
+
+	/// <summary>
+	/// Include partial recognition results.
+	/// </summary>
+	public bool ShouldReportPartialResults { get; init; } = true;
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/Mocks/SpeechToTextImplementationMock.cs b/src/CommunityToolkit.Maui.UnitTests/Mocks/SpeechToTextImplementationMock.cs
index 714da39f05..144280529b 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Mocks/SpeechToTextImplementationMock.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Mocks/SpeechToTextImplementationMock.cs
@@ -39,7 +39,7 @@ private set
 		}
 	}
 
-	public async Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken)
+	public async Task StartListenAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
 		CurrentState = SpeechToTextState.Listening;
 		await Task.Delay(100, cancellationToken);
@@ -52,18 +52,4 @@ public async Task StopListenAsync(CancellationToken cancellationToken)
 		await Task.Delay(100, cancellationToken);
 		RecognitionResultCompleted?.Invoke(this, new SpeechToTextRecognitionResultCompletedEventArgs(SpeechToTextResult.Success(finalText)));
 	}
-
-	public async Task StartOfflineListenAsync(CultureInfo culture, CancellationToken cancellationToken)
-	{
-		CurrentState = SpeechToTextState.Listening;
-		await Task.Delay(100, cancellationToken);
-		RecognitionResultUpdated?.Invoke(this, new SpeechToTextRecognitionResultUpdatedEventArgs(partialText));
-	}
-
-	public async Task StopOfflineListenAsync(CancellationToken cancellationToken)
-	{
-		CurrentState = SpeechToTextState.Stopped;
-		await Task.Delay(100, cancellationToken);
-		RecognitionResultCompleted?.Invoke(this, new SpeechToTextRecognitionResultCompletedEventArgs(SpeechToTextResult.Success(finalText)));
-	}
 }
\ No newline at end of file