diff --git a/samples/CommunityToolkit.Maui.Sample/AppShell.xaml.cs b/samples/CommunityToolkit.Maui.Sample/AppShell.xaml.cs
index d24ccb279f..5010fa1b96 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 b07f22205f..d4a9ebcdc9 100644
--- a/samples/CommunityToolkit.Maui.Sample/CommunityToolkit.Maui.Sample.csproj
+++ b/samples/CommunityToolkit.Maui.Sample/CommunityToolkit.Maui.Sample.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFrameworks>$(NetVersion)-ios;$(NetVersion)-android;$(NetVersion)-maccatalyst</TargetFrameworks>
diff --git a/samples/CommunityToolkit.Maui.Sample/MauiProgram.cs b/samples/CommunityToolkit.Maui.Sample/MauiProgram.cs
index f0f048a0b6..e1f0e3f671 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>();
@@ -262,7 +263,8 @@ static void RegisterEssentials(in IServiceCollection services)
 		services.AddSingleton<IFileSystem>(FileSystem.Current);
 		services.AddSingleton<IFolderPicker>(FolderPicker.Default);
 		services.AddSingleton<IBadge>(Badge.Default);
-		services.AddSingleton<ISpeechToText>(SpeechToText.Default);
+		services.AddKeyedSingleton<ISpeechToText, SpeechToTextImplementation>("Online");
+		services.AddKeyedSingleton<ISpeechToText, OfflineSpeechToTextImplementation>("Offline");
 		services.AddSingleton<ITextToSpeech>(TextToSpeech.Default);
 	}
 
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..1fec0cb133
--- /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="OfflineSpeechToText allows the user to convert speech to text in real time in offline"
+                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 f1e425a533..f3bdf5777d 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/SpeechToTextPage.xaml
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Essentials/SpeechToTextPage.xaml
@@ -31,6 +31,17 @@
                 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"/>
@@ -47,44 +58,6 @@
                 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="ListenAsync"
-                            Command="{Binding ListenCommand}"
-                            HorizontalOptions="End" />
-
-                        <Button
-                            Grid.Row="0"
-                            Grid.Column="1"
-                            Text="Cancel Token"
-                            Command="{Binding ListenCancelCommand}"
-                            HorizontalOptions="Start" />
-
-                        <Label
-                            Grid.Row="1"
-                            Grid.ColumnSpan="2"
-                            Text="The `ListenAsync` API allows you to await the final speech recognition results using async/await. `ListenAsync` is cancelled via CancellationToken."
-                            HorizontalOptions="Center"
-                            HorizontalTextAlignment="Center"
-                            FontSize="12"/>
-
-                    </Grid>
-                </Border.Content>
-            </Border>
-
             <Border
                 StrokeThickness="2"
                 Stroke="#808080"
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 b6d3143429..1f90538546 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/SpeechToTextViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Essentials/SpeechToTextViewModel.cs
@@ -20,19 +20,18 @@ public partial class SpeechToTextViewModel : BaseViewModel
 	[ObservableProperty]
 	Locale? currentLocale;
 
+	public SpeechToTextState? State => speechToText.CurrentState;
+
 	[ObservableProperty]
 	string? recognitionText = "Welcome to .NET MAUI Community Toolkit!";
 
-	[ObservableProperty, NotifyCanExecuteChangedFor(nameof(ListenCommand))]
-	bool canListenExecute = true;
-
 	[ObservableProperty, NotifyCanExecuteChangedFor(nameof(StartListenCommand))]
 	bool canStartListenExecute = true;
 
 	[ObservableProperty, NotifyCanExecuteChangedFor(nameof(StopListenCommand))]
 	bool canStopListenExecute = false;
 
-	public SpeechToTextViewModel(ITextToSpeech textToSpeech, ISpeechToText speechToText)
+	public SpeechToTextViewModel(ITextToSpeech textToSpeech, [FromKeyedServices("Online")]ISpeechToText speechToText)
 	{
 		this.textToSpeech = textToSpeech;
 		this.speechToText = speechToText;
@@ -82,67 +81,22 @@ async Task Play(CancellationToken cancellationToken)
 		}
 	}
 
-	[RelayCommand(IncludeCancelCommand = true, CanExecute = nameof(CanListenExecute))]
-	async Task Listen(CancellationToken cancellationToken)
-	{
-		CanStartListenExecute = false;
-
-		try
-		{
-			var isGranted = await speechToText.RequestPermissions(cancellationToken);
-			if (!isGranted)
-			{
-				await Toast.Make("Permission not granted").Show(cancellationToken);
-				return;
-			}
-
-			const string beginSpeakingPrompt = "Begin speaking...";
-
-			RecognitionText = beginSpeakingPrompt;
-
-			var recognitionResult = await speechToText.ListenAsync(
-				CultureInfo.GetCultureInfo(CurrentLocale?.Language ?? defaultLanguage),
-				new Progress<string>(partialText =>
-				{
-					if (RecognitionText is beginSpeakingPrompt)
-					{
-						RecognitionText = string.Empty;
-					}
-
-					RecognitionText += partialText + " ";
-				}), cancellationToken);
-
-			if (recognitionResult.IsSuccessful)
-			{
-				RecognitionText = recognitionResult.Text;
-			}
-			else
-			{
-				await Toast.Make(recognitionResult.Exception?.Message ?? "Unable to recognize speech").Show(CancellationToken.None);
-			}
-
-			if (RecognitionText is beginSpeakingPrompt)
-			{
-				RecognitionText = string.Empty;
-			}
-		}
-		finally
-		{
-			CanStartListenExecute = true;
-		}
-	}
-
 	[RelayCommand(CanExecute = nameof(CanStartListenExecute))]
-	async Task StartListen(CancellationToken cancellationToken)
+	async Task StartListen()
 	{
-		CanListenExecute = false;
 		CanStartListenExecute = false;
 		CanStopListenExecute = true;
 
-		var isGranted = await speechToText.RequestPermissions(cancellationToken);
+		var isGranted = await speechToText.RequestPermissions(CancellationToken.None);
 		if (!isGranted)
 		{
-			await Toast.Make("Permission not granted").Show(cancellationToken);
+			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;
 		}
 
@@ -150,10 +104,14 @@ async Task StartListen(CancellationToken cancellationToken)
 
 		RecognitionText = beginSpeakingPrompt;
 
-		await speechToText.StartListenAsync(CultureInfo.GetCultureInfo(CurrentLocale?.Language ?? defaultLanguage), cancellationToken);
-
 		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;
@@ -161,15 +119,14 @@ async Task StartListen(CancellationToken cancellationToken)
 	}
 
 	[RelayCommand(CanExecute = nameof(CanStopListenExecute))]
-	Task StopListen(CancellationToken cancellationToken)
+	Task StopListen()
 	{
-		CanListenExecute = true;
 		CanStartListenExecute = true;
 		CanStopListenExecute = false;
 
 		speechToText.RecognitionResultUpdated -= HandleRecognitionResultUpdated;
 
-		return speechToText.StopListenAsync(cancellationToken);
+		return speechToText.StopListenAsync(CancellationToken.None);
 	}
 
 	void HandleRecognitionResultUpdated(object? sender, SpeechToTextRecognitionResultUpdatedEventArgs e)
@@ -179,12 +136,12 @@ void HandleRecognitionResultUpdated(object? sender, SpeechToTextRecognitionResul
 
 	void HandleRecognitionResultCompleted(object? sender, SpeechToTextRecognitionResultCompletedEventArgs e)
 	{
-		RecognitionText = e.RecognitionResult;
+		RecognitionText = e.RecognitionResult.IsSuccessful ? e.RecognitionResult.Text : e.RecognitionResult.Exception.Message;
 	}
 
-	async void HandleSpeechToTextStateChanged(object? sender, SpeechToTextStateChangedEventArgs e)
+	void HandleSpeechToTextStateChanged(object? sender, SpeechToTextStateChangedEventArgs e)
 	{
-		await Toast.Make($"State Changed: {e.State}").Show(CancellationToken.None);
+		OnPropertyChanged(nameof(State));
 	}
 
 	void HandleLocalesCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/Events/SpeechToTextRecognitionResultCompletedEventArgs.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/Events/SpeechToTextRecognitionResultCompletedEventArgs.cs
index 3a08eb196c..03c3ff8596 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/Events/SpeechToTextRecognitionResultCompletedEventArgs.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/Events/SpeechToTextRecognitionResultCompletedEventArgs.cs
@@ -8,7 +8,7 @@ public class SpeechToTextRecognitionResultCompletedEventArgs : EventArgs
 	/// <summary>
 	/// Initialize a new instance of <see cref="SpeechToTextRecognitionResultCompletedEventArgs"/>
 	/// </summary>
-	public SpeechToTextRecognitionResultCompletedEventArgs(string recognitionResult)
+	public SpeechToTextRecognitionResultCompletedEventArgs(SpeechToTextResult recognitionResult)
 	{
 		RecognitionResult = recognitionResult;
 	}
@@ -16,5 +16,5 @@ public SpeechToTextRecognitionResultCompletedEventArgs(string recognitionResult)
 	/// <summary>
 	/// Speech recognition result
 	/// </summary>
-	public string RecognitionResult { get; }
+	public SpeechToTextResult RecognitionResult { get; }
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs
index c9e6964905..3711882611 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/ISpeechToText.shared.cs
@@ -27,24 +27,15 @@ public interface ISpeechToText : IAsyncDisposable
 	/// </summary>
 	SpeechToTextState CurrentState { get; }
 
-	/// <summary>
-	/// Converts speech to text in real time.
-	/// </summary>
-	/// <param name="culture">Speak language</param>
-	/// <param name="recognitionResult">Intermediate recognition result.</param>
-	/// <param name="cancellationToken"><see cref="CancellationToken"/></param>
-	/// <returns>Final recognition result</returns>
-	Task<SpeechToTextResult> ListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken = default);
-
 	/// <summary>
 	/// Starts the 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="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
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..d6f17e297f
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToText.shared.cs
@@ -0,0 +1,30 @@
+using System.Globalization;
+
+namespace CommunityToolkit.Maui.Media;
+
+/// <inheritdoc cref="ISpeechToText"/>
+/// <remarks>Offline Speech-To-Text provides offline speech recognition.</remarks>
+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..9d7f10b72b
--- /dev/null
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/OfflineSpeechToTextImplementation.tizen.cs
@@ -0,0 +1,157 @@
+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;
+
+	/// <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(SpeechToTextOptions options, CancellationToken cancellationToken)
+	{
+		await Initialize(cancellationToken);
+
+		sttClient.ErrorOccurred += OnErrorOccurred;
+		sttClient.RecognitionResult += OnRecognitionResult;
+		sttClient.StateChanged += OnStateChanged;
+
+		var recognitionType = options.ShouldReportPartialResults && sttClient.IsRecognitionTypeSupported(RecognitionType.Partial)
+			? RecognitionType.Partial
+			: RecognitionType.Free;
+
+		sttClient.Start(options.Culture.Name, 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/SharedSpeechToTextImplementation.macios.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SharedSpeechToTextImplementation.macios.cs
index 9b0b7a03eb..a87a148c65 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SharedSpeechToTextImplementation.macios.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SharedSpeechToTextImplementation.macios.cs
@@ -1,6 +1,4 @@
-using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
-using AVFoundation;
+using AVFoundation;
 using Speech;
 
 namespace CommunityToolkit.Maui.Media;
@@ -9,13 +7,9 @@ public sealed partial class SpeechToTextImplementation
 {
 	AVAudioEngine? audioEngine;
 	SFSpeechRecognizer? speechRecognizer;
-	IProgress<string>? recognitionProgress;
 	SFSpeechRecognitionTask? recognitionTask;
 	SFSpeechAudioBufferRecognitionRequest? liveSpeechRequest;
 
-	TaskCompletionSource<string>? getRecognitionTaskCompletionSource;
-	CancellationTokenRegistration? userProvidedCancellationTokenRegistration;
-
 	/// <inheritdoc/>
 	public SpeechToTextState CurrentState => recognitionTask?.State is SFSpeechRecognitionTaskState.Running
 												? SpeechToTextState.Listening
@@ -23,22 +17,18 @@ public sealed partial class SpeechToTextImplementation
 
 
 	/// <inheritdoc />
-	public async ValueTask DisposeAsync()
+	public ValueTask DisposeAsync()
 	{
-		getRecognitionTaskCompletionSource?.TrySetCanceled();
-
 		audioEngine?.Dispose();
 		speechRecognizer?.Dispose();
 		liveSpeechRequest?.Dispose();
 		recognitionTask?.Dispose();
-		await (userProvidedCancellationTokenRegistration?.DisposeAsync() ?? ValueTask.CompletedTask);
 
 		audioEngine = null;
 		speechRecognizer = null;
 		liveSpeechRequest = null;
 		recognitionTask = null;
-		getRecognitionTaskCompletionSource = null;
-		userProvidedCancellationTokenRegistration = null;
+		return ValueTask.CompletedTask;
 	}
 
 	/// <inheritdoc />
@@ -70,18 +60,9 @@ static void InitializeAvAudioSession(out AVAudioSession sharedAvAudioSession)
 			AVAudioSessionCategoryOptions.DefaultToSpeaker | AVAudioSessionCategoryOptions.AllowBluetooth | AVAudioSessionCategoryOptions.AllowAirPlay | AVAudioSessionCategoryOptions.AllowBluetoothA2DP);
 	}
 
-	async Task<string> InternalListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken)
-	{
-		recognitionProgress = recognitionResult;
-
-		await InternalStartListeningAsync(culture, cancellationToken);
-
-		return await getRecognitionTaskCompletionSource.Task.WaitAsync(cancellationToken);
-	}
-
 	void StopRecording()
 	{
-		audioEngine?.InputNode.RemoveTapOnBus(new nuint(0));
+		audioEngine?.InputNode.RemoveTapOnBus(0);
 		audioEngine?.Stop();
 		liveSpeechRequest?.EndAudio();
 		recognitionTask?.Cancel();
@@ -95,16 +76,8 @@ Task InternalStopListeningAsync(CancellationToken cancellationToken)
 		return Task.CompletedTask;
 	}
 
-	[MemberNotNull(nameof(getRecognitionTaskCompletionSource), nameof(userProvidedCancellationTokenRegistration))]
-	void ResetGetRecognitionTaskCompletionSource(CancellationToken token)
+	Task InternalStopOfflineListeningAsync(CancellationToken cancellationToken)
 	{
-		getRecognitionTaskCompletionSource?.TrySetCanceled(token);
-		getRecognitionTaskCompletionSource = new();
-
-		userProvidedCancellationTokenRegistration = token.Register(() =>
-		{
-			StopRecording();
-			getRecognitionTaskCompletionSource.TrySetCanceled(token);
-		});
+		return InternalStopListeningAsync(cancellationToken);
 	}
 }
\ 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 9a85ccd572..1b7ad3bdcb 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToText.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToText.shared.cs
@@ -12,13 +12,9 @@ public static class SpeechToText
 	/// </summary>
 	public static ISpeechToText Default => defaultImplementation.Value;
 
-	/// <inheritdoc cref="ISpeechToText.ListenAsync"/>
-	public static Task<SpeechToTextResult> ListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken = default) =>
-		Default.ListenAsync(culture, recognitionResult, cancellationToken);
-
 	/// <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) =>
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.android.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.android.cs
index 0c92a27773..938750d827 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.android.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.android.cs
@@ -12,10 +12,6 @@ public sealed partial class SpeechToTextImplementation
 {
 	SpeechRecognizer? speechRecognizer;
 	SpeechRecognitionListener? listener;
-	TaskCompletionSource<string>? speechRecognitionListenerTaskCompletionSource;
-	CancellationTokenRegistration? userProvidedCancellationTokenRegistration;
-	IProgress<string>? recognitionProgress;
-	CultureInfo? cultureInfo;
 	SpeechToTextState currentState = SpeechToTextState.Stopped;
 
 	/// <inheritdoc />
@@ -33,69 +29,58 @@ private set
 	}
 
 	/// <inheritdoc />
-	public async ValueTask DisposeAsync()
+	public ValueTask DisposeAsync()
 	{
-		speechRecognitionListenerTaskCompletionSource?.TrySetCanceled();
-
 		listener?.Dispose();
 		speechRecognizer?.Dispose();
-		await (userProvidedCancellationTokenRegistration?.DisposeAsync() ?? ValueTask.CompletedTask);
 
 		listener = null;
 		speechRecognizer = null;
-		userProvidedCancellationTokenRegistration = null;
-		speechRecognitionListenerTaskCompletionSource = null;
+		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), nameof(speechRecognitionListenerTaskCompletionSource))]
-	Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
+	
+	[MemberNotNull(nameof(speechRecognizer), nameof(listener))]
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
-		speechRecognitionListenerTaskCompletionSource?.TrySetCanceled(cancellationToken);
-		speechRecognitionListenerTaskCompletionSource = new();
-		userProvidedCancellationTokenRegistration = cancellationToken.Register(() =>
-		{
-			StopRecording();
-			speechRecognitionListenerTaskCompletionSource.TrySetCanceled(cancellationToken);
-		});
-
-		cultureInfo = culture;
 		var isSpeechRecognitionAvailable = IsSpeechRecognitionAvailable();
 		if (!isSpeechRecognitionAvailable)
 		{
 			throw new FeatureNotSupportedException("Speech Recognition is not available on this device");
 		}
 
+		var recognizerIntent = CreateSpeechIntent(options);
+
 		speechRecognizer = SpeechRecognizer.CreateSpeechRecognizer(Application.Context);
+
 		if (speechRecognizer is null)
 		{
 			throw new FeatureNotSupportedException("Speech recognizer is not available on this device");
 		}
 
-		listener = new SpeechRecognitionListener
+		listener = new SpeechRecognitionListener(this)
 		{
 			Error = HandleListenerError,
 			PartialResults = HandleListenerPartialResults,
 			Results = HandleListenerResults
 		};
 		speechRecognizer.SetRecognitionListener(listener);
-		speechRecognizer.StartListening(CreateSpeechIntent(cultureInfo));
-		CurrentState = SpeechToTextState.Listening;
+		speechRecognizer.StartListening(recognizerIntent);
 
 		cancellationToken.ThrowIfCancellationRequested();
 
@@ -109,30 +94,19 @@ Task InternalStopListeningAsync(CancellationToken cancellationToken)
 		return Task.CompletedTask;
 	}
 
-	async Task<string> InternalListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken)
-	{
-		recognitionProgress = recognitionResult;
-
-		await InternalStartListeningAsync(culture, cancellationToken);
-
-		return await speechRecognitionListenerTaskCompletionSource.Task.WaitAsync(cancellationToken);
-	}
-
 	void HandleListenerError(SpeechRecognizerError error)
 	{
-		speechRecognitionListenerTaskCompletionSource?.TrySetException(new Exception($"Failure in speech engine - {error}"));
+		OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception($"Failure in speech engine - {error}")));
 	}
 
 	void HandleListenerPartialResults(string sentence)
 	{
 		OnRecognitionResultUpdated(sentence);
-		recognitionProgress?.Report(sentence);
 	}
 
 	void HandleListenerResults(string result)
 	{
-		OnRecognitionResultCompleted(result);
-		speechRecognitionListenerTaskCompletionSource?.TrySetResult(result);
+		OnRecognitionResultCompleted(SpeechToTextResult.Success(result));
 	}
 
 	void StopRecording()
@@ -142,7 +116,7 @@ void StopRecording()
 		CurrentState = SpeechToTextState.Stopped;
 	}
 
-	class SpeechRecognitionListener : Java.Lang.Object, IRecognitionListener
+	class SpeechRecognitionListener(SpeechToTextImplementation speechToText) : Java.Lang.Object, IRecognitionListener
 	{
 		public required Action<SpeechRecognizerError> Error { get; init; }
 		public required Action<string> PartialResults { get; init; }
@@ -150,6 +124,7 @@ class SpeechRecognitionListener : Java.Lang.Object, IRecognitionListener
 
 		public void OnBeginningOfSpeech()
 		{
+			speechToText.CurrentState = SpeechToTextState.Listening;
 		}
 
 		public void OnBufferReceived(byte[]? buffer)
@@ -158,11 +133,13 @@ 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)
@@ -190,7 +167,7 @@ public void OnRmsChanged(float rmsdB)
 		static void SendResults(Bundle? bundle, Action<string> action)
 		{
 			var matches = bundle?.GetStringArrayList(SpeechRecognizer.ResultsRecognition);
-			if (matches?.Any() is not true)
+			if (matches is null || matches.Count == 0)
 			{
 				return;
 			}
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.ios.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.ios.cs
index fa1b4a373d..433c2cf920 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.ios.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.ios.cs
@@ -8,12 +8,10 @@ namespace CommunityToolkit.Maui.Media;
 /// <inheritdoc />
 public sealed partial class SpeechToTextImplementation
 {
-	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest), nameof(getRecognitionTaskCompletionSource))]
-	Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
+	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest))]
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
-		ResetGetRecognitionTaskCompletionSource(cancellationToken);
-
-		speechRecognizer = new SFSpeechRecognizer(NSLocale.FromLocaleIdentifier(culture.Name));
+		speechRecognizer = new SFSpeechRecognizer(NSLocale.FromLocaleIdentifier(options.Culture.Name));
 
 		if (!speechRecognizer.Available)
 		{
@@ -21,7 +19,10 @@ Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancella
 		}
 
 		audioEngine = new AVAudioEngine();
-		liveSpeechRequest = new SFSpeechAudioBufferRecognitionRequest();
+		liveSpeechRequest = new SFSpeechAudioBufferRecognitionRequest()
+		{
+			ShouldReportPartialResults = options.ShouldReportPartialResults
+		};
 
 		InitializeAvAudioSession(out _);
 
@@ -45,7 +46,7 @@ Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancella
 			if (err is not null)
 			{
 				StopRecording();
-				getRecognitionTaskCompletionSource.TrySetException(new Exception(err.LocalizedDescription));
+				OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception(err.LocalizedDescription)));
 			}
 			else
 			{
@@ -53,8 +54,7 @@ Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancella
 				{
 					currentIndex = 0;
 					StopRecording();
-					OnRecognitionResultCompleted(result.BestTranscription.FormattedString);
-					getRecognitionTaskCompletionSource.TrySetResult(result.BestTranscription.FormattedString);
+					OnRecognitionResultCompleted(SpeechToTextResult.Success(result.BestTranscription.FormattedString));
 				}
 				else
 				{
@@ -67,7 +67,6 @@ Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancella
 					{
 						var s = result.BestTranscription.Segments[i].Substring;
 						currentIndex++;
-						recognitionProgress?.Report(s);
 						OnRecognitionResultUpdated(s);
 					}
 				}
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.macos.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.macos.cs
index 0bbd119e76..4de6c17bbd 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.macos.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.macos.cs
@@ -8,20 +8,24 @@ namespace CommunityToolkit.Maui.Media;
 /// <inheritdoc />
 public sealed partial class SpeechToTextImplementation
 {
-	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest), nameof(getRecognitionTaskCompletionSource))]
-	Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
+	[MemberNotNull(nameof(audioEngine), nameof(recognitionTask), nameof(liveSpeechRequest))]
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
-		speechRecognizer = new SFSpeechRecognizer(NSLocale.FromLocaleIdentifier(culture.Name));
-
-		ResetGetRecognitionTaskCompletionSource(cancellationToken);
+		speechRecognizer = new SFSpeechRecognizer(NSLocale.FromLocaleIdentifier(options.Culture.Name));
 
 		if (!speechRecognizer.Available)
 		{
 			throw new ArgumentException("Speech recognizer is not available");
 		}
 
-		audioEngine = new AVAudioEngine();
-		liveSpeechRequest = new SFSpeechAudioBufferRecognitionRequest();
+		audioEngine = new AVAudioEngine
+		{
+			AutoShutdownEnabled = false
+		};
+		liveSpeechRequest = new SFSpeechAudioBufferRecognitionRequest()
+		{
+			ShouldReportPartialResults = options.ShouldReportPartialResults
+		};
 
 		InitializeAvAudioSession(out var audioSession);
 
@@ -61,7 +65,7 @@ Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancella
 			if (err is not null)
 			{
 				StopRecording();
-				getRecognitionTaskCompletionSource.TrySetException(new Exception(err.LocalizedDescription));
+				OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception(err.LocalizedDescription)));
 			}
 			else
 			{
@@ -69,8 +73,7 @@ Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancella
 				{
 					currentIndex = 0;
 					StopRecording();
-					OnRecognitionResultCompleted(result.BestTranscription.FormattedString);
-					getRecognitionTaskCompletionSource.TrySetResult(result.BestTranscription.FormattedString);
+					OnRecognitionResultCompleted(SpeechToTextResult.Success(result.BestTranscription.FormattedString));
 				}
 				else
 				{
@@ -83,7 +86,6 @@ Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancella
 					{
 						var s = result.BestTranscription.Segments[i].Substring;
 						currentIndex++;
-						recognitionProgress?.Report(s);
 						OnRecognitionResultUpdated(s);
 					}
 				}
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.net.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.net.cs
index 35355be2a6..c4558e9443 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.net.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.net.cs
@@ -11,13 +11,7 @@ public ValueTask DisposeAsync()
 		return ValueTask.CompletedTask;
 	}
 
-	Task<string> InternalListenAsync(CultureInfo culture, IProgress<string>? recognitionResult,
-		CancellationToken cancellationToken)
-	{
-		throw new NotSupportedException();
-	}
-
-	Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
+	Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
 		throw new NotSupportedException();
 	}
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs
index 35291f26ab..5d01647326 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.shared.cs
@@ -31,29 +31,8 @@ public event EventHandler<SpeechToTextStateChangedEventArgs> StateChanged
 		remove => speechToTextStateChangedWeakEventManager.RemoveEventHandler(value);
 	}
 
-
-	/// <inheritdoc/>
-	public async Task<SpeechToTextResult> ListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken = default)
-	{
-		try
-		{
-			var isPermissionGranted = await IsSpeechPermissionAuthorized(cancellationToken).ConfigureAwait(false);
-			if (!isPermissionGranted)
-			{
-				return new SpeechToTextResult(null, new Exception("Speech Recognizer Permission not granted"));
-			}
-
-			var finalResult = await InternalListenAsync(culture, recognitionResult, cancellationToken).ConfigureAwait(false);
-			return new SpeechToTextResult(finalResult, null);
-		}
-		catch (Exception e)
-		{
-			return new SpeechToTextResult(null, e);
-		}
-	}
-
 	/// <inheritdoc/>
-	public async Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken = default)
+	public async Task StartListenAsync(SpeechToTextOptions options, CancellationToken cancellationToken = default)
 	{
 		cancellationToken.ThrowIfCancellationRequested();
 
@@ -63,7 +42,7 @@ 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/>
@@ -74,7 +53,7 @@ void OnRecognitionResultUpdated(string recognitionResult)
 		recognitionResultUpdatedWeakEventManager.HandleEvent(this, new SpeechToTextRecognitionResultUpdatedEventArgs(recognitionResult), nameof(RecognitionResultUpdated));
 	}
 
-	void OnRecognitionResultCompleted(string recognitionResult)
+	void OnRecognitionResultCompleted(SpeechToTextResult recognitionResult)
 	{
 		recognitionResultCompletedWeakEventManager.HandleEvent(this, new SpeechToTextRecognitionResultCompletedEventArgs(recognitionResult), nameof(RecognitionResultCompleted));
 	}
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs
index a112f959e0..7572b31831 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.tizen.cs
@@ -10,9 +10,6 @@ public sealed partial class SpeechToTextImplementation
 {
 	SttClient? sttClient;
 	TaskCompletionSource<bool>? tcsInitialize;
-	TaskCompletionSource<string>? taskResult;
-	IProgress<string>? recognitionProgress;
-	string defaultSttEngineLocale = "ko_KR";
 
 	/// <inheritdoc/>
 	public SpeechToTextState CurrentState => sttClient?.CurrentState is Tizen.Uix.Stt.State.Recording
@@ -35,6 +32,7 @@ public ValueTask DisposeAsync()
 				sttClient.ErrorOccurred -= OnErrorOccurred;
 				sttClient.StateChanged -= OnStateChanged;
 			}
+
 			sttClient.Dispose();
 
 			sttClient = null;
@@ -55,30 +53,6 @@ void StopRecording(in SttClient sttClient)
 		sttClient.StateChanged -= OnStateChanged;
 	}
 
-	[MemberNotNull(nameof(taskResult))]
-	async Task<string> InternalListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken)
-	{
-		recognitionProgress = recognitionResult;
-		
-		taskResult?.TrySetCanceled(cancellationToken);
-		taskResult = new TaskCompletionSource<string>();
-
-		await InternalStartListeningAsync(culture, cancellationToken);
-
-		await using (cancellationToken.Register(() =>
-		{
-			if (sttClient is not null)
-			{
-				StopRecording(sttClient);
-			}
-
-			taskResult.TrySetCanceled(cancellationToken);
-		}))
-		{
-			return await taskResult.Task.WaitAsync(cancellationToken);
-		}
-	}
-
 	void OnErrorOccurred(object? sender, ErrorOccurredEventArgs e)
 	{
 		if (sttClient is not null)
@@ -86,7 +60,7 @@ void OnErrorOccurred(object? sender, ErrorOccurredEventArgs e)
 			StopRecording(sttClient);
 		}
 
-		taskResult?.TrySetException(new Exception("STT failed - " + e.ErrorMessage));
+		OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception("STT failed - " + e.ErrorMessage)));
 	}
 
 	void OnRecognitionResult(object? sender, RecognitionResultEventArgs e)
@@ -98,14 +72,13 @@ void OnRecognitionResult(object? sender, RecognitionResultEventArgs e)
 				StopRecording(sttClient);
 			}
 
-			taskResult?.TrySetException(new Exception("Failure in speech engine - " + e.Message));
+			OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception("Failure in speech engine - " + e.Message)));
 		}
 		else if (e.Result is ResultEvent.PartialResult)
 		{
-			foreach(var d in e.Data)
+			foreach (var d in e.Data)
 			{
 				OnRecognitionResultUpdated(d);
-				recognitionProgress?.Report(d);
 			}
 		}
 		else
@@ -115,8 +88,7 @@ void OnRecognitionResult(object? sender, RecognitionResultEventArgs e)
 				StopRecording(sttClient);
 			}
 
-			OnRecognitionResultCompleted(e.Data.ToString() ?? string.Empty);
-			taskResult?.TrySetResult(e.Data.ToString() ?? string.Empty);
+			OnRecognitionResultCompleted(SpeechToTextResult.Success(e.Data.ToString() ?? string.Empty));
 		}
 	}
 
@@ -150,13 +122,13 @@ Task<bool> Initialize(CancellationToken cancellationToken)
 		}
 		catch (Exception ex)
 		{
-			taskResult?.TrySetException(new Exception("STT is not available - " + ex));
+			OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception("STT is not available - " + ex)));
 		}
 
 		return tcsInitialize.Task.WaitAsync(cancellationToken);
 	}
 
-	async Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
+	async Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
 		await Initialize(cancellationToken);
 
@@ -164,11 +136,11 @@ async Task InternalStartListeningAsync(CultureInfo culture, CancellationToken ca
 		sttClient.RecognitionResult += OnRecognitionResult;
 		sttClient.StateChanged += OnStateChanged;
 
-		var recognitionType = sttClient.IsRecognitionTypeSupported(RecognitionType.Partial)
+		var recognitionType = options.ShouldReportPartialResults && sttClient.IsRecognitionTypeSupported(RecognitionType.Partial)
 			? RecognitionType.Partial
 			: RecognitionType.Free;
 
-		sttClient.Start(defaultSttEngineLocale, recognitionType);
+		sttClient.Start(options.Culture.Name, recognitionType);
 	}
 
 	Task InternalStopListeningAsync(CancellationToken cancellationToken)
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs
index 49154997f5..694eae374b 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextImplementation.windows.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
+using System.Speech.Recognition;
 using Microsoft.Maui.ApplicationModel;
 using Windows.Globalization;
 using Windows.Media.SpeechRecognition;
@@ -14,30 +15,33 @@ public sealed partial class SpeechToTextImplementation
 
 	string recognitionText = string.Empty;
 	SpeechRecognizer? speechRecognizer;
-	IProgress<string>? recognitionProgress;
-	TaskCompletionSource<string>? speechRecognitionTaskCompletionSource;
+	SpeechToTextOptions? speechToTextOptions;
 
 	/// <inheritdoc/>
-	public SpeechToTextState CurrentState => speechRecognizer?.State switch
+	public SpeechToTextState CurrentState
 	{
-		SpeechRecognizerState.Idle => SpeechToTextState.Stopped,
-		_ => SpeechToTextState.Listening,
-	};
+		get
+		{
+			return speechRecognizer?.State switch
+			{
+				SpeechRecognizerState.Capturing or SpeechRecognizerState.SoundStarted or SpeechRecognizerState.SpeechDetected or SpeechRecognizerState.Processing => SpeechToTextState.Listening,
+				SpeechRecognizerState.SoundEnded => SpeechToTextState.Silence,
+				_ => SpeechToTextState.Stopped,
+			};
+		}
+	}
 
 	/// <inheritdoc />
 	public async ValueTask DisposeAsync()
 	{
 		await StopRecording(CancellationToken.None);
-
 		speechRecognizer?.Dispose();
 		speechRecognizer = null;
 	}
 
-	async Task InternalStartListeningAsync(CultureInfo culture, CancellationToken cancellationToken)
+	async Task InternalStartListeningAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
-		ResetSpeechRecognitionTaskCompletionSource(cancellationToken);
-
-		await Initialize(culture, cancellationToken);
+		await Initialize(options, cancellationToken);
 
 		speechRecognizer.ContinuousRecognitionSession.AutoStopSilenceTimeout = TimeSpan.MaxValue;
 		speechRecognizer.ContinuousRecognitionSession.ResultGenerated += ResultGenerated;
@@ -58,14 +62,13 @@ void OnCompleted(SpeechContinuousRecognitionSession sender, SpeechContinuousReco
 		switch (args.Status)
 		{
 			case SpeechRecognitionResultStatus.Success:
-				OnRecognitionResultCompleted(recognitionText);
-				speechRecognitionTaskCompletionSource?.TrySetResult(recognitionText);
+				OnRecognitionResultCompleted(SpeechToTextResult.Success(recognitionText));
 				break;
 			case SpeechRecognitionResultStatus.UserCanceled:
-				speechRecognitionTaskCompletionSource?.TrySetCanceled();
+				OnRecognitionResultCompleted(new SpeechToTextResult(recognitionText, new TaskCanceledException("Operation cancelled")));
 				break;
 			default:
-				speechRecognitionTaskCompletionSource?.TrySetException(new Exception(args.Status.ToString()));
+				OnRecognitionResultCompleted(SpeechToTextResult.Failed(new Exception(args.Status.ToString())));
 				break;
 		}
 	}
@@ -73,22 +76,14 @@ void OnCompleted(SpeechContinuousRecognitionSession sender, SpeechContinuousReco
 	void ResultGenerated(SpeechContinuousRecognitionSession sender, SpeechContinuousRecognitionResultGeneratedEventArgs args)
 	{
 		recognitionText += args.Result.Text;
-		recognitionProgress?.Report(args.Result.Text);
-		OnRecognitionResultUpdated(args.Result.Text);
+		if (speechToTextOptions?.ShouldReportPartialResults == true)
+		{
+			OnRecognitionResultUpdated(args.Result.Text);
+		}
 	}
 
 	Task InternalStopListeningAsync(CancellationToken cancellationToken) => StopRecording(cancellationToken);
-
-	async Task<string> InternalListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken)
-	{
-		ResetSpeechRecognitionTaskCompletionSource(cancellationToken);
-
-		recognitionProgress = recognitionResult;
-		await StartListenAsync(culture, cancellationToken);
-
-		return await speechRecognitionTaskCompletionSource.Task.WaitAsync(cancellationToken);
-	}
-
+	
 	async Task StopRecording(CancellationToken cancellationToken)
 	{
 		try
@@ -109,25 +104,12 @@ async Task StopRecording(CancellationToken cancellationToken)
 		}
 	}
 
-	[MemberNotNull(nameof(speechRecognitionTaskCompletionSource))]
-	void ResetSpeechRecognitionTaskCompletionSource(CancellationToken token)
-	{
-		speechRecognitionTaskCompletionSource?.TrySetCanceled(token);
-		speechRecognitionTaskCompletionSource = new();
-
-		token.Register(async () =>
-		{
-			await StopRecording(token);
-			speechRecognitionTaskCompletionSource.TrySetCanceled(token);
-		});
-	}
-
-
-	[MemberNotNull(nameof(recognitionText), nameof(speechRecognizer))]
-	async Task Initialize(CultureInfo culture, CancellationToken cancellationToken)
+	[MemberNotNull(nameof(recognitionText), nameof(speechRecognizer), nameof(speechToTextOptions))]
+	async Task Initialize(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
+		speechToTextOptions = options;
 		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);
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.Core/Essentials/SpeechToText/SpeechToTextResult.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextResult.shared.cs
index 6bba67e4f3..a6f523ec3c 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextResult.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextResult.shared.cs
@@ -51,4 +51,8 @@ public void EnsureSuccess()
 			throw Exception;
 		}
 	}
+
+	internal static SpeechToTextResult Failed(Exception exception) => new(null, exception);
+
+	internal static SpeechToTextResult Success(string text) => new(text, null);
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextState.shared.cs b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextState.shared.cs
index 9ae1aa970d..b504f2dd20 100644
--- a/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextState.shared.cs
+++ b/src/CommunityToolkit.Maui.Core/Essentials/SpeechToText/SpeechToTextState.shared.cs
@@ -13,5 +13,10 @@ public enum SpeechToTextState
 	/// <summary>
 	/// Listening is active
 	/// </summary>
-	Listening
+	Listening,
+
+	/// <summary>
+	/// Listening is active, but no sound is detected
+	/// </summary>
+	Silence
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/Essentials/SpeechToTextTests.cs b/src/CommunityToolkit.Maui.UnitTests/Essentials/SpeechToTextTests.cs
index 1ffb9ffa3e..b2ef5f8736 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Essentials/SpeechToTextTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Essentials/SpeechToTextTests.cs
@@ -18,20 +18,11 @@ public void SpeechToTextTestsSetDefaultUpdatesInstance()
 		speechToText.Should().BeSameAs(speechToTextImplementationMock);
 	}
 
-	[Fact(Timeout = (int)TestDuration.Short)]
-	public async Task ListenAsyncFailsOnNet()
-	{
-		SpeechToText.SetDefault(new SpeechToTextImplementation());
-		var result = await SpeechToText.ListenAsync(CultureInfo.CurrentCulture, null, CancellationToken.None);
-		result.Text.Should().BeNull();
-		result.Exception.Should().BeOfType<NotImplementedInReferenceAssemblyException>();
-	}
-
 	[Fact(Timeout = (int)TestDuration.Short)]
 	public async Task StartListenAsyncFailsOnNet()
 	{
 		SpeechToText.SetDefault(new SpeechToTextImplementation());
-		await Assert.ThrowsAsync<NotImplementedInReferenceAssemblyException>(() => SpeechToText.StartListenAsync(CultureInfo.CurrentCulture, CancellationToken.None));
+		await Assert.ThrowsAsync<NotImplementedInReferenceAssemblyException>(() => SpeechToText.StartListenAsync(new SpeechToTextOptions { Culture = CultureInfo.CurrentCulture }, CancellationToken.None));
 	}
 
 	[Fact(Timeout = (int)TestDuration.Long)]
@@ -40,7 +31,7 @@ public async Task StartStopListenAsyncShouldChangeState()
 		SpeechToText.SetDefault(new SpeechToTextImplementationMock(string.Empty, string.Empty));
 		SpeechToText.Default.StateChanged += OnStateChanged;
 		SpeechToText.Default.CurrentState.Should().Be(SpeechToTextState.Stopped);
-		await SpeechToText.StartListenAsync(CultureInfo.CurrentCulture, CancellationToken.None);
+		await SpeechToText.StartListenAsync(new SpeechToTextOptions{Culture = CultureInfo.CurrentCulture}, CancellationToken.None);
 		SpeechToText.Default.CurrentState.Should().Be(SpeechToTextState.Listening);
 		await SpeechToText.StopListenAsync(CancellationToken.None);
 		SpeechToText.Default.CurrentState.Should().Be(SpeechToTextState.Stopped);
@@ -48,7 +39,7 @@ public async Task StartStopListenAsyncShouldChangeState()
 		void OnStateChanged(object? sender, SpeechToTextStateChangedEventArgs args)
 		{
 			testOutputHelper.WriteLine(args.State.ToString());
-		};
+		}
 	}
 
 	[Fact(Timeout = (int)TestDuration.Long)]
@@ -61,7 +52,7 @@ public async Task StartStopListenAsyncShouldChangeRecognitionText()
 		SpeechToText.SetDefault(new SpeechToTextImplementationMock(expectedPartialText, expectedFinalText));
 		SpeechToText.Default.RecognitionResultUpdated += OnRecognitionTextUpdated;
 		SpeechToText.Default.RecognitionResultCompleted += OnRecognitionTextCompleted;
-		await SpeechToText.StartListenAsync(CultureInfo.CurrentCulture, CancellationToken.None);
+		await SpeechToText.StartListenAsync(new SpeechToTextOptions { Culture = CultureInfo.CurrentCulture }, CancellationToken.None);
 		await Task.Delay(500);
 		await SpeechToText.StopListenAsync(CancellationToken.None);
 		SpeechToText.Default.RecognitionResultUpdated -= OnRecognitionTextUpdated;
@@ -75,7 +66,7 @@ void OnRecognitionTextUpdated(object? sender, SpeechToTextRecognitionResultUpdat
 		};
 		void OnRecognitionTextCompleted(object? sender, SpeechToTextRecognitionResultCompletedEventArgs args)
 		{
-			currentFinalText = args.RecognitionResult;
+			currentFinalText = args.RecognitionResult.Text;
 		};
 	}
 
diff --git a/src/CommunityToolkit.Maui.UnitTests/Mocks/SpeechToTextImplementationMock.cs b/src/CommunityToolkit.Maui.UnitTests/Mocks/SpeechToTextImplementationMock.cs
index 6a5787affe..144280529b 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Mocks/SpeechToTextImplementationMock.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Mocks/SpeechToTextImplementationMock.cs
@@ -39,22 +39,17 @@ private set
 		}
 	}
 
-	Task<SpeechToTextResult> ISpeechToText.ListenAsync(CultureInfo culture, IProgress<string>? recognitionResult, CancellationToken cancellationToken)
-	{
-		throw new NotImplementedException();
-	}
-
-	public async Task StartListenAsync(CultureInfo culture, CancellationToken cancellationToken)
+	public async Task StartListenAsync(SpeechToTextOptions options, CancellationToken cancellationToken)
 	{
 		CurrentState = SpeechToTextState.Listening;
-		await Task.Delay(1000, cancellationToken);
+		await Task.Delay(100, cancellationToken);
 		RecognitionResultUpdated?.Invoke(this, new SpeechToTextRecognitionResultUpdatedEventArgs(partialText));
 	}
 
 	public async Task StopListenAsync(CancellationToken cancellationToken)
 	{
 		CurrentState = SpeechToTextState.Stopped;
-		await Task.Delay(1000, cancellationToken);
-		RecognitionResultCompleted?.Invoke(this, new SpeechToTextRecognitionResultCompletedEventArgs(finalText));
+		await Task.Delay(100, cancellationToken);
+		RecognitionResultCompleted?.Invoke(this, new SpeechToTextRecognitionResultCompletedEventArgs(SpeechToTextResult.Success(finalText)));
 	}
 }
\ No newline at end of file