diff --git a/.github/instructions/codestyle.instructions.md b/.github/instructions/codestyle.instructions.md
index 5851398d85..71e34feb1a 100644
--- a/.github/instructions/codestyle.instructions.md
+++ b/.github/instructions/codestyle.instructions.md
@@ -235,6 +235,28 @@ This guide provides a set of best practices and coding standards for writing C#
 	}
 	```
 
+## Argument Validation:
+
+- Prefer `ArgumentNullException.ThrowIfNull` over manual null checks:
+	```csharp
+	// Good: Concise null validation
+	public void Write(byte[] buffer)
+	{
+		ArgumentNullException.ThrowIfNull(buffer);
+		// Use buffer safely here
+	}
+
+	// Avoid: Verbose manual null check
+	public void Write(byte[] buffer)
+	{
+		if (buffer is null)
+		{
+			throw new ArgumentNullException(nameof(buffer));
+		}
+		// Use buffer safely here
+	}
+	```
+
 ## Safe Operations:
 
 - Use Try methods for safer operations:
@@ -578,4 +600,4 @@ Here Key Components of the Try Pattern:
 4. Null Analysis Attribute: [NotNullWhen(true)] (or [MaybeNullWhen(false)]) informs the compiler that if the method returns true, the out parameter is guaranteed to be non-null. 
 
 This pattern allows for high-performance retrieval or parsing without throwing exceptions for expected failures. It also allows cleaner call sites by eliminating the need for null-checking the output variable within the if block, as seen in Dictionary<TKey, TValue>.TryGetValue. 
-```
+
diff --git a/samples/CommunityToolkit.Maui.Sample/AppShell.xaml.cs b/samples/CommunityToolkit.Maui.Sample/AppShell.xaml.cs
index 12721c1b46..33ced3a189 100644
--- a/samples/CommunityToolkit.Maui.Sample/AppShell.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/AppShell.xaml.cs
@@ -125,6 +125,7 @@ public partial class AppShell : Shell
 		CreateViewModelMapping<LazyViewPage, LazyViewViewModel, ViewsGalleryPage, ViewsGalleryViewModel>(),
 		CreateViewModelMapping<MapsPinsPage, MapsPinsViewModel, ViewsGalleryPage, ViewsGalleryViewModel>(),
 		CreateViewModelMapping<MediaElementPage, MediaElementViewModel, ViewsGalleryPage, ViewsGalleryViewModel>(),
+		CreateViewModelMapping<MediaElementFromStreamPage, MediaElementFromStreamViewModel, ViewsGalleryPage, ViewsGalleryViewModel>(),
 		CreateViewModelMapping<MediaElementCarouselViewPage, MediaElementCarouselViewViewModel, ViewsGalleryPage, ViewsGalleryViewModel>(),
 		CreateViewModelMapping<MediaElementCollectionViewPage, MediaElementCollectionViewViewModel, ViewsGalleryPage, ViewsGalleryViewModel>(),
 		CreateViewModelMapping<MediaElementMultipleWindowsPage, MediaElementMultipleWindowsViewModel, ViewsGalleryPage, ViewsGalleryViewModel>(),
diff --git a/samples/CommunityToolkit.Maui.Sample/MauiProgram.cs b/samples/CommunityToolkit.Maui.Sample/MauiProgram.cs
index 78f8c2bcf8..6506108af9 100644
--- a/samples/CommunityToolkit.Maui.Sample/MauiProgram.cs
+++ b/samples/CommunityToolkit.Maui.Sample/MauiProgram.cs
@@ -123,6 +123,9 @@ public static MauiApp CreateMauiApp()
 		builder.Services.AddHttpClient<ByteArrayToImageSourceConverterViewModel>()
 						.AddStandardResilienceHandler(static options => options.Retry = new MobileHttpRetryStrategyOptions());
 
+		builder.Services.AddHttpClient<MediaElementFromStreamPage>()
+			.AddStandardResilienceHandler(static options => options.Retry = new MobileHttpRetryStrategyOptions());
+
 		builder.Services.AddSingleton<AppShell>();
 
 		RegisterViewsAndViewModels(builder.Services);
@@ -252,6 +255,7 @@ static void RegisterViewsAndViewModels(in IServiceCollection services)
 		services.AddTransientWithShellRoute<LazyViewPage, LazyViewViewModel>();
 		services.AddTransientWithShellRoute<MapsPinsPage, MapsPinsViewModel>();
 		services.AddTransientWithShellRoute<MediaElementPage, MediaElementViewModel>();
+		services.AddTransientWithShellRoute<MediaElementFromStreamPage, MediaElementFromStreamViewModel>();
 		services.AddTransientWithShellRoute<MediaElementCarouselViewPage, MediaElementCarouselViewViewModel>();
 		services.AddTransientWithShellRoute<MediaElementCollectionViewPage, MediaElementCollectionViewViewModel>();
 		services.AddTransientWithShellRoute<MediaElementMultipleWindowsPage, MediaElementMultipleWindowsViewModel>();
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementFromStreamPage.xaml b/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementFromStreamPage.xaml
new file mode 100644
index 0000000000..ac60242731
--- /dev/null
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementFromStreamPage.xaml
@@ -0,0 +1,160 @@
+<?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"
+             xmlns:toolkit="http://schemas.microsoft.com/dotnet/2022/maui/toolkit"
+             xmlns:constants="clr-namespace:CommunityToolkit.Maui.Sample.Constants"
+             xmlns:viewModels="clr-namespace:CommunityToolkit.Maui.Sample.ViewModels.Views"
+             xmlns:converters="clr-namespace:CommunityToolkit.Maui.Sample.Converters"
+             x:TypeArguments="viewModels:MediaElementFromStreamViewModel"
+             x:DataType="viewModels:MediaElementFromStreamViewModel"
+             x:Class="CommunityToolkit.Maui.Sample.Pages.Views.MediaElementFromStreamPage"
+             Title="MediaElement">
+    <pages:BasePage.Resources>
+        <converters:SecondsToStringConverter x:Key="SecondsToStringConverter" />
+    </pages:BasePage.Resources>
+
+    <ScrollView>
+        <Grid>
+            <Grid.RowDefinitions>
+                <RowDefinition Height="220" />
+                <RowDefinition Height="50" />
+                <RowDefinition Height="Auto" />
+                <RowDefinition Height="Auto" />
+                <RowDefinition Height="Auto" />
+                <RowDefinition Height="Auto" />
+                <RowDefinition Height="Auto" />
+                <RowDefinition Height="Auto" />
+                <RowDefinition Height="Auto" />
+            </Grid.RowDefinitions>
+            <toolkit:MediaElement
+                x:Name="MediaElement"
+                ShouldAutoPlay="True"
+                MediaEnded="OnMediaEnded"
+                MediaFailed="OnMediaFailed"
+                MediaOpened="OnMediaOpened"
+                PositionChanged="OnPositionChanged"
+                StateChanged="OnStateChanged"
+                SeekCompleted="OnSeekCompleted"/>
+            <HorizontalStackLayout Grid.Row="1" Padding="0,0,0,15">
+                <Label HorizontalOptions="Center" x:DataType="toolkit:MediaElement">
+                    <Label.Text>
+                        <MultiBinding StringFormat="{}Current State: {0} - Dimensions: {1}x{2}">
+                            <Binding Path="CurrentState" Source="{x:Reference MediaElement}" />
+                            <Binding Path="MediaWidth" Source="{x:Reference MediaElement}" />
+                            <Binding Path="MediaHeight" Source="{x:Reference MediaElement}" />
+                        </MultiBinding>
+                    </Label.Text>
+                </Label>
+
+            </HorizontalStackLayout>
+
+            <Grid Grid.Row="2" Padding="0,10,0,10" ColumnDefinitions="*,*,*,*" ColumnSpacing="5">
+                <Button Grid.Column="0" Text="Play" Clicked="OnPlayClicked" />
+                <Button Grid.Column="1" Text="Pause" Clicked="OnPauseClicked" />
+                <Button Grid.Column="2" Text="Stop" Clicked="OnStopClicked" />
+                <Button Grid.Column="3" Text="Mute" Clicked="OnMuteClicked">
+                    <Button.Triggers>
+                        <DataTrigger TargetType="Button"
+                                     x:DataType="toolkit:MediaElement"
+                                     Binding="{Binding ShouldMute, Source={x:Reference MediaElement}}"
+                                     Value="True">
+                            <Setter Property="Text" Value="Unmute" />
+                        </DataTrigger>
+                        <DataTrigger TargetType="Button"
+                                     x:DataType="toolkit:MediaElement"
+                                     Binding="{Binding ShouldMute, Source={x:Reference MediaElement}}"
+                                     Value="False">
+                            <Setter Property="Text" Value="Mute" />
+                        </DataTrigger>
+                    </Button.Triggers>
+                </Button>
+            </Grid>
+
+            <Slider
+                x:Name="PositionSlider"
+                Grid.Row="3"
+                MinimumTrackColor="Gray"
+                DragStarted="Slider_DragStarted"
+                DragCompleted="Slider_DragCompleted"/>
+
+            <Grid Grid.Row="4" HorizontalOptions="Fill">
+                <Label HorizontalOptions="Start" x:DataType="toolkit:MediaElement" Text="{Binding Position, Source={x:Reference MediaElement}, Converter={StaticResource SecondsToStringConverter}}" />
+                <Label HorizontalOptions="End" HorizontalTextAlignment="End" x:DataType="toolkit:MediaElement" Text="{Binding Duration, Source={x:Reference MediaElement}, Converter={StaticResource SecondsToStringConverter}}" />
+            </Grid>
+
+            <VerticalStackLayout Padding="0,20,0,0" Grid.Row="5" Spacing="5">
+                <HorizontalStackLayout Spacing="5" HorizontalOptions="Center">
+                    <Button Text="Open Video" Clicked="OnOpenVideoClicked" HorizontalOptions="Fill" />
+
+                    <Button Text="Record Video" Clicked="OnRecordVideoClicked" HorizontalOptions="Fill" />
+                </HorizontalStackLayout>
+                <Button Text="Change Aspect" Clicked="ChangeAspectClicked" />
+            </VerticalStackLayout>
+
+            <HorizontalStackLayout Grid.Row="6" Padding="0,10,0,10" Spacing="5">
+                <Label Margin="20,10" x:DataType="toolkit:MediaElement">
+                    <Label.FormattedText>
+                        <FormattedString>
+                            <Span Text="Speed:" />
+                            <Span Text="{Binding Source={x:Reference MediaElement}, Path=Speed}" />
+                        </FormattedString>
+                    </Label.FormattedText>
+                </Label>
+
+                <Button Text="-" Clicked="OnSpeedMinusClicked" />
+                <Button Text="+" Clicked="OnSpeedPlusClicked" />
+            </HorizontalStackLayout>
+
+            <HorizontalStackLayout Grid.Row="7" Padding="0,10,0,10" Spacing="5">
+                <Label Margin="20,10" x:DataType="toolkit:MediaElement">
+                    <Label.FormattedText>
+                        <FormattedString>
+                            <Span Text="Volume:" />
+                            <Span Text="{Binding Source={x:Reference MediaElement}, Path=Volume, StringFormat='{}{0:P0}'}" />
+                        </FormattedString>
+                    </Label.FormattedText>
+                </Label>
+
+                <Button Text="-" Clicked="OnVolumeMinusClicked" />
+                <Button Text="+" Clicked="OnVolumePlusClicked" />
+            </HorizontalStackLayout>
+
+            <VerticalStackLayout Grid.Row="8">
+                <HorizontalStackLayout Padding="0,0,0,10">
+                    <Switch
+                        Margin="0,0,5,0"
+                        ThumbColor="White"
+                        OnColor="LimeGreen"
+                        x:DataType="toolkit:MediaElement"
+                        IsToggled="{Binding Source={x:Reference MediaElement}, Path=ShouldShowPlaybackControls}" />
+                    <Label
+                        VerticalOptions="Center"
+                        Text="Show playback controls" />
+                </HorizontalStackLayout>
+                <HorizontalStackLayout Padding="0,0,0,10">
+                    <Switch
+                        Margin="0,0,5,0"
+                        ThumbColor="White"
+                        OnColor="LimeGreen"
+                        x:DataType="toolkit:MediaElement"
+                        IsToggled="{Binding Source={x:Reference MediaElement}, Path=ShouldLoopPlayback}" />
+                    <Label
+                        VerticalOptions="Center"
+                        Text="Loop media" />
+                </HorizontalStackLayout>
+                <HorizontalStackLayout>
+                    <Switch
+                        Margin="0,0,5,0"
+                        ThumbColor="White"
+                        OnColor="LimeGreen"
+                        x:DataType="toolkit:MediaElement"
+                        IsToggled="{Binding Source={x:Reference MediaElement}, Path=ShouldKeepScreenOn}" />
+                    <Label
+                        VerticalOptions="Center"
+                        Text="Keep screen on" />
+                </HorizontalStackLayout>
+            </VerticalStackLayout>
+        </Grid>
+    </ScrollView>
+</pages:BasePage>
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementFromStreamPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementFromStreamPage.xaml.cs
new file mode 100644
index 0000000000..3b22fbfc36
--- /dev/null
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/MediaElement/MediaElementFromStreamPage.xaml.cs
@@ -0,0 +1,271 @@
+using System.ComponentModel;
+using CommunityToolkit.Maui.Alerts;
+using CommunityToolkit.Maui.Core;
+using CommunityToolkit.Maui.Sample.Constants;
+using CommunityToolkit.Maui.Sample.ViewModels.Views;
+using CommunityToolkit.Maui.Views;
+using Microsoft.Extensions.Logging;
+
+namespace CommunityToolkit.Maui.Sample.Pages.Views;
+
+public sealed partial class MediaElementFromStreamPage : BasePage<MediaElementFromStreamViewModel>, IAsyncDisposable
+{
+	readonly ILogger logger;
+	readonly HttpClient httpClient;
+	readonly SemaphoreSlim sourceStreamSemaphore = new(1, 1);
+
+	MemoryStream? sourceStream;
+
+	public MediaElementFromStreamPage(
+		HttpClient httpClient,
+		MediaElementFromStreamViewModel viewModel,
+		ILogger<MediaElementFromStreamPage> logger) : base(viewModel)
+	{
+		InitializeComponent();
+
+		this.logger = logger;
+		this.httpClient = httpClient;
+		MediaElement.PropertyChanged += MediaElement_PropertyChanged;
+	}
+
+	public async ValueTask DisposeAsync()
+	{
+		GC.SuppressFinalize(this);
+		await ReleaseSourceStream();
+	}
+
+	protected override void OnNavigatedFrom(NavigatedFromEventArgs args)
+	{
+		base.OnNavigatedFrom(args);
+		MediaElement.Stop();
+		MediaElement.Handler?.DisconnectHandler();
+	}
+
+	protected override async void OnDisappearing()
+	{
+		base.OnDisappearing();
+
+		// In production, consider warning the user before navigating away
+		// if an unsaved stream is loaded (e.g. after video capture).
+		// Here we simply release the stream on disappearing for simplicity.
+		await ReleaseSourceStream();
+	}
+
+	protected override async void OnAppearing()
+	{
+		base.OnAppearing();
+
+		await using var networkStream = await httpClient.GetStreamAsync(StreamingUrls.BuckBunny);
+		await UpdateSourceStream(networkStream);
+	}
+
+	void MediaElement_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+	{
+		if (e.PropertyName == MediaElement.DurationProperty.PropertyName)
+		{
+			logger.LogInformation("Duration: {NewDuration}", MediaElement.Duration);
+			PositionSlider.Maximum = MediaElement.Duration.TotalSeconds;
+		}
+	}
+
+	void OnMediaOpened(object? sender, EventArgs? e) => logger.LogInformation("Media opened.");
+
+	void OnStateChanged(object? sender, MediaStateChangedEventArgs e) =>
+		logger.LogInformation("Media State Changed. Old State: {PreviousState}, New State: {NewState}", e.PreviousState, e.NewState);
+
+	void OnMediaFailed(object? sender, MediaFailedEventArgs e) => logger.LogInformation("Media failed. Error: {ErrorMessage}", e.ErrorMessage);
+
+	void OnMediaEnded(object? sender, EventArgs? e) => logger.LogInformation("Media ended.");
+
+	void OnPositionChanged(object? sender, MediaPositionChangedEventArgs e)
+	{
+		logger.LogInformation("Position changed to {Position}", e.Position);
+		PositionSlider.Value = e.Position.TotalSeconds;
+	}
+
+	void OnSeekCompleted(object? sender, EventArgs? e) => logger.LogInformation("Seek completed.");
+
+	void OnSpeedMinusClicked(object? sender, EventArgs? e)
+	{
+		if (MediaElement.Speed >= 1)
+		{
+			MediaElement.Speed -= 1;
+		}
+	}
+
+	void OnSpeedPlusClicked(object? sender, EventArgs? e)
+	{
+		if (MediaElement.Speed < 10)
+		{
+			MediaElement.Speed += 1;
+		}
+	}
+
+	void OnVolumeMinusClicked(object? sender, EventArgs? e)
+	{
+		if (MediaElement.Volume >= 0)
+		{
+			if (MediaElement.Volume < .1)
+			{
+				MediaElement.Volume = 0;
+
+				return;
+			}
+
+			MediaElement.Volume -= .1;
+		}
+	}
+
+	void OnVolumePlusClicked(object? sender, EventArgs? e)
+	{
+		if (MediaElement.Volume < 1)
+		{
+			if (MediaElement.Volume > .9)
+			{
+				MediaElement.Volume = 1;
+
+				return;
+			}
+
+			MediaElement.Volume += .1;
+		}
+	}
+
+	void OnPlayClicked(object? sender, EventArgs? e)
+	{
+		MediaElement.Play();
+	}
+
+	void OnPauseClicked(object? sender, EventArgs? e)
+	{
+		MediaElement.Pause();
+	}
+
+	void OnStopClicked(object? sender, EventArgs? e)
+	{
+		MediaElement.Stop();
+	}
+
+	void OnMuteClicked(object? sender, EventArgs? e)
+	{
+		MediaElement.ShouldMute = !MediaElement.ShouldMute;
+	}
+
+	async void Slider_DragCompleted(object? sender, EventArgs? e)
+	{
+		ArgumentNullException.ThrowIfNull(sender);
+
+		var newValue = ((Slider)sender).Value;
+		await MediaElement.SeekTo(TimeSpan.FromSeconds(newValue), CancellationToken.None);
+
+		MediaElement.Play();
+	}
+
+	void Slider_DragStarted(object? sender, EventArgs? e)
+	{
+		MediaElement.Pause();
+	}
+
+	async Task UpdateSourceStream(Stream stream)
+	{
+		try
+		{
+			await ReleaseSourceStream();
+			sourceStream = new MemoryStream();
+			await stream.CopyToAsync(sourceStream);
+			sourceStream.Position = 0;
+
+			MediaElement.Source = MediaSource.FromStream(sourceStream);
+		}
+		catch (Exception ex)
+		{
+			logger.LogError(ex, "Failed to stream video");
+			await Toast.Make("Failed to stream video").Show();
+		}
+	}
+
+	async void OnOpenVideoClicked(object? sender, EventArgs? e)
+	{
+		var pickerOptions = new MediaPickerOptions
+		{
+			Title = "Please select a video file",
+			SelectionLimit = 1
+		};
+
+		var result = await MediaPicker.Default.PickVideosAsync(pickerOptions);
+
+		if (result is null || result.Count == 0)
+		{
+			await Toast.Make("No video selected").Show();
+			return;
+		}
+
+		var videoFile = result[0];
+
+		await using var stream = await videoFile.OpenReadAsync();
+
+		await UpdateSourceStream(stream);
+	}
+
+	async void OnRecordVideoClicked(object? sender, EventArgs? e)
+	{
+		var videoResult = await MediaPicker.Default.CaptureVideoAsync(new MediaPickerOptions
+		{
+			Title = "Capture Video"
+		});
+
+		if (videoResult is null)
+		{
+			return;
+		}
+
+		await using var stream = await videoResult.OpenReadAsync();
+		await UpdateSourceStream(stream);
+	}
+
+	async void ChangeAspectClicked(object? sender, EventArgs? e)
+	{
+		const string cancel = "Cancel";
+
+		var resultAspect = await DisplayActionSheetAsync(
+			"Choose aspect ratio",
+			cancel,
+			null,
+			nameof(Aspect.AspectFit),
+			nameof(Aspect.AspectFill),
+			nameof(Aspect.Fill));
+
+		if (resultAspect is null or cancel)
+		{
+			return;
+		}
+
+		if (!Enum.TryParse(typeof(Aspect), resultAspect, true, out var aspectEnum))
+		{
+			await DisplayAlertAsync("Error", "There was an error determining the selected aspect", "OK");
+
+			return;
+		}
+
+		MediaElement.Aspect = (Aspect)aspectEnum;
+	}
+
+	async ValueTask ReleaseSourceStream()
+	{
+		if (sourceStream is null)
+		{
+			return;
+		}
+
+		try
+		{
+			await sourceStreamSemaphore.WaitAsync();
+			await (sourceStream?.DisposeAsync() ?? ValueTask.CompletedTask);
+			sourceStream = null;
+		}
+		finally
+		{
+			sourceStreamSemaphore.Release();
+		}
+	}
+}
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/PopupsPage.xaml.cs b/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/PopupsPage.xaml.cs
index 9bc18a4cd2..9ff83329dd 100644
--- a/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/PopupsPage.xaml.cs
+++ b/samples/CommunityToolkit.Maui.Sample/Pages/Views/Popup/PopupsPage.xaml.cs
@@ -37,7 +37,7 @@ protected override async void OnNavigatedFrom(NavigatedFromEventArgs args)
 			await Toast.Make("Popup Opened").Show();
 		}
 	}
-	
+
 	protected override async void OnNavigatingFrom(NavigatingFromEventArgs args)
 	{
 		base.OnNavigatingFrom(args);
diff --git a/samples/CommunityToolkit.Maui.Sample/Platforms/MacCatalyst/Info.plist b/samples/CommunityToolkit.Maui.Sample/Platforms/MacCatalyst/Info.plist
index c342a6fa06..1ace496d70 100644
--- a/samples/CommunityToolkit.Maui.Sample/Platforms/MacCatalyst/Info.plist
+++ b/samples/CommunityToolkit.Maui.Sample/Platforms/MacCatalyst/Info.plist
@@ -39,5 +39,7 @@
 		<string>bluetooth-central</string>
 		<string>audio</string>
 	</array>
+	<key>NSPhotoLibraryAddUsageDescription</key>
+	<string>This sample needs permission to save captured photos and videos to your photo library.</string>
 </dict>
 </plist>
diff --git a/samples/CommunityToolkit.Maui.Sample/Platforms/iOS/Info.plist b/samples/CommunityToolkit.Maui.Sample/Platforms/iOS/Info.plist
index d0245bf261..580e00dbbc 100644
--- a/samples/CommunityToolkit.Maui.Sample/Platforms/iOS/Info.plist
+++ b/samples/CommunityToolkit.Maui.Sample/Platforms/iOS/Info.plist
@@ -40,5 +40,7 @@
 	<array>
 		<string>audio</string>
 	</array>
+	<key>NSPhotoLibraryAddUsageDescription</key>
+	<string>This sample needs permission to save photos and videos to your photo library.</string>
 </dict>
 </plist>
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/MediaElement/MediaElementFromStreamViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/MediaElement/MediaElementFromStreamViewModel.cs
new file mode 100644
index 0000000000..20477ab1dd
--- /dev/null
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/MediaElement/MediaElementFromStreamViewModel.cs
@@ -0,0 +1,6 @@
+namespace CommunityToolkit.Maui.Sample.ViewModels.Views;
+
+public partial class MediaElementFromStreamViewModel : BaseViewModel
+{
+
+}
\ No newline at end of file
diff --git a/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/ViewsGalleryViewModel.cs b/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/ViewsGalleryViewModel.cs
index ea038112a0..3728a49f1e 100644
--- a/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/ViewsGalleryViewModel.cs
+++ b/samples/CommunityToolkit.Maui.Sample/ViewModels/Views/ViewsGalleryViewModel.cs
@@ -22,6 +22,7 @@ public sealed partial class ViewsGalleryViewModel() : BaseGalleryViewModel(
 	SectionModel.Create<LazyViewViewModel>("LazyView", Colors.Red, "LazyView is a view that allows you to load its children in a delayed manner."),
 	SectionModel.Create<MapsPinsViewModel>("Maps Pins Page", Colors.Red, "A page demonstrating .NET MAUI Maps with Pins."),
 	SectionModel.Create<MediaElementViewModel>("MediaElement", Colors.Red, "MediaElement is a view for playing video and audio"),
+	SectionModel.Create<MediaElementFromStreamViewModel>("MediaElement from Stream", Colors.Red, "MediaElement can load media from a Stream source"),
 	SectionModel.Create<MediaElementCarouselViewViewModel>("MediaElement in CarouselView", Colors.Red, "MediaElement can be used inside a DataTemplate in a CarouselView"),
 	SectionModel.Create<MediaElementCollectionViewViewModel>("MediaElement in CollectionView", Colors.Red, "MediaElement can be used inside a DataTemplate in a CollectionView"),
 	SectionModel.Create<MediaElementMultipleWindowsViewModel>("MediaElement in a Multi-Window Application", Colors.Red, "Demonstrates that MediaElement can be used inside a DataTemplate simultaneously on multiple windows"),
diff --git a/src/CommunityToolkit.Maui.MediaElement/Converters/MediaSourceConverter.shared.cs b/src/CommunityToolkit.Maui.MediaElement/Converters/MediaSourceConverter.shared.cs
index 60ad208bd1..4f79689d61 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Converters/MediaSourceConverter.shared.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Converters/MediaSourceConverter.shared.cs
@@ -54,6 +54,7 @@ public override bool CanConvertTo(ITypeDescriptorContext? context, Type? destina
 		UriMediaSource uriMediaSource => uriMediaSource.ToString(),
 		FileMediaSource fileMediaSource => fileMediaSource.ToString(),
 		ResourceMediaSource resourceMediaSource => resourceMediaSource.ToString(),
+		StreamMediaSource streamMediaSource => streamMediaSource.ToString(),
 		MediaSource => string.Empty,
 		_ => throw new ArgumentException($"Invalid Media Source", nameof(value))
 	};
diff --git a/src/CommunityToolkit.Maui.MediaElement/Extensions/StreamExtensions.shared.cs b/src/CommunityToolkit.Maui.MediaElement/Extensions/StreamExtensions.shared.cs
new file mode 100644
index 0000000000..cd3e324796
--- /dev/null
+++ b/src/CommunityToolkit.Maui.MediaElement/Extensions/StreamExtensions.shared.cs
@@ -0,0 +1,164 @@
+namespace CommunityToolkit.Maui.Core.Extensions;
+
+/// <summary>
+/// Extension methods for <see cref="Stream"/> on Windows platform.
+/// </summary>
+static class StreamExtensions
+{
+	const string defaultMimeType = "application/octet-stream";
+
+	/// <summary>
+	/// Gets the MIME type for a stream by inspecting its leading bytes (magic numbers).
+	/// </summary>
+	/// <param name="stream">The stream to get the MIME type for.</param>
+	/// <returns>
+	/// A MIME type string that matches the detected media container/codec, or
+	/// <c>"application/octet-stream"</c> when the type cannot be determined.
+	/// </returns>
+	/// <remarks>
+	/// When the stream is seekable, the original position is restored after inspection.
+	/// Non-seekable streams cannot be sniffed and will return the default MIME type.
+	/// </remarks>
+	internal static string GetMimeType(this Stream stream)
+	{
+		ArgumentNullException.ThrowIfNull(stream);
+
+		if (!stream.CanRead || !stream.CanSeek)
+		{
+			return defaultMimeType;
+		}
+
+		const int headerSize = 16;
+		var originalPosition = stream.Position;
+
+		try
+		{
+			stream.Position = 0;
+
+			Span<byte> header = stackalloc byte[headerSize];
+			var bytesRead = stream.Read(header);
+			if (bytesRead < 4)
+			{
+				return defaultMimeType;
+			}
+
+			header = header[..bytesRead];
+			return DetectMimeType(header);
+		}
+		catch (IOException)
+		{
+			return defaultMimeType;
+		}
+		catch (NotSupportedException)
+		{
+			return defaultMimeType;
+		}
+		finally
+		{
+			try
+			{
+				stream.Position = originalPosition;
+			}
+			catch (IOException)
+			{
+			}
+			catch (NotSupportedException)
+			{
+			}
+		}
+	}
+
+	static string DetectMimeType(ReadOnlySpan<byte> header)
+	{
+		// MP4 / M4A / 3GP / QuickTime: bytes 4-7 == "ftyp"
+		if (header.Length >= 12
+			&& header[4] is (byte)'f' && header[5] is (byte)'t' && header[6] is (byte)'y' && header[7] is (byte)'p')
+		{
+			var brand = System.Text.Encoding.ASCII.GetString(header.Slice(8, 4)).TrimEnd();
+
+			return brand switch
+			{
+				"M4A" or "M4B" or "M4P" => "audio/mp4",
+				"qt" => "video/quicktime",
+				"3gp4" or "3gp5" or "3gp6" or "3gp7" or "3gpp" => "video/3gpp",
+				"3g2a" or "3g2b" or "3g2c" => "video/3gpp2",
+				_ => "video/mp4",
+			};
+		}
+
+		// WebM / Matroska (EBML): 1A 45 DF A3
+		if (header.Length >= 4 && header[0] is 0x1A && header[1] is 0x45 && header[2] is 0xDF && header[3] is 0xA3)
+		{
+			return "video/webm";
+		}
+
+		// RIFF containers: AVI ("AVI ") or WAV ("WAVE")
+		if (header.Length >= 12
+			&& header[0] is (byte)'R' && header[1] is (byte)'I' && header[2] is (byte)'F' && header[3] is (byte)'F')
+		{
+			if (header[8] is (byte)'A' && header[9] is (byte)'V' && header[10] is (byte)'I' && header[11] is (byte)' ')
+			{
+				return "video/x-msvideo";
+			}
+
+			if (header[8] is (byte)'W' && header[9] is (byte)'A' && header[10] is (byte)'V' && header[11] is (byte)'E')
+			{
+				return "audio/wav";
+			}
+		}
+
+		// OGG: "OggS"
+		if (header.Length >= 4
+			&& header[0] is (byte)'O' && header[1] is (byte)'g' && header[2] is (byte)'g' && header[3] is (byte)'S')
+		{
+			return "application/ogg";
+		}
+
+		// FLAC: "fLaC"
+		if (header.Length >= 4
+			&& header[0] is (byte)'f' && header[1] is (byte)'L' && header[2] is (byte)'a' && header[3] is (byte)'C')
+		{
+			return "audio/flac";
+		}
+
+		// MP3: ID3 tag or MPEG audio frame sync (0xFF 0xEx/0xFx)
+		if (header.Length >= 3
+			&& header[0] is (byte)'I' && header[1] is (byte)'D' && header[2] is (byte)'3')
+		{
+			return "audio/mpeg";
+		}
+
+		if (header.Length >= 2 && header[0] is 0xFF && (header[1] & 0xE0) is 0xE0)
+		{
+			return "audio/mpeg";
+		}
+
+		// MPEG-PS / MPEG-TS
+		if (header.Length >= 4 && header[0] is 0x00 && header[1] is 0x00 && header[2] is 0x01 && header[3] is 0xBA)
+		{
+			return "video/mpeg";
+		}
+
+		if (header.Length >= 1 && header[0] is 0x47)
+		{
+			return "video/mp2t";
+		}
+
+		// ASF / WMV / WMA: 30 26 B2 75 8E 66 CF 11
+		if (header.Length >= 8
+			&& header[0] is 0x30 && header[1] is 0x26 && header[2] is 0xB2 && header[3] is 0x75
+			&& header[4] is 0x8E && header[5] is 0x66 && header[6] is 0xCF && header[7] is 0x11)
+		{
+			return "video/x-ms-asf";
+		}
+
+		// FLV: "FLV"
+		if (header.Length >= 3
+			&& header[0] is (byte)'F' && header[1] is (byte)'L' && header[2] is (byte)'V')
+		{
+			return "video/x-flv";
+		}
+
+		return defaultMimeType;
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.MediaElement/MediaSource/FileMediaSource.shared.cs b/src/CommunityToolkit.Maui.MediaElement/MediaSource/FileMediaSource.shared.cs
index 7c8c281761..8fda9b28fa 100644
--- a/src/CommunityToolkit.Maui.MediaElement/MediaSource/FileMediaSource.shared.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/MediaSource/FileMediaSource.shared.cs
@@ -16,6 +16,16 @@ public sealed partial class FileMediaSource : MediaSource
 	public static readonly BindableProperty PathProperty
 		= BindableProperty.Create(nameof(Path), typeof(string), typeof(FileMediaSource), propertyChanged: OnFileMediaSourceChanged);
 
+	/// <summary>
+	/// Gets or sets the full path to the local file to use as a media source.
+	/// This is a bindable property.
+	/// </summary>
+	public string? Path
+	{
+		get => (string?)GetValue(PathProperty);
+		set => SetValue(PathProperty, value);
+	}
+
 	/// <summary>
 	/// An implicit operator to convert a string value into a <see cref="FileMediaSource"/>.
 	/// </summary>
@@ -28,15 +38,6 @@ public static readonly BindableProperty PathProperty
 	/// <param name="fileMediaSource">A <see cref="FileMediaSource"/> instance to convert to a string value.</param>
 	public static implicit operator string?(FileMediaSource? fileMediaSource) => fileMediaSource?.Path;
 
-	/// <summary>
-	/// Gets or sets the full path to the local file to use as a media source.
-	/// This is a bindable property.
-	/// </summary>
-	public string? Path
-	{
-		get => (string?)GetValue(PathProperty);
-		set => SetValue(PathProperty, value);
-	}
 
 	/// <inheritdoc/>
 	public override string ToString() => $"File: {Path}";
diff --git a/src/CommunityToolkit.Maui.MediaElement/MediaSource/MediaSource.shared.cs b/src/CommunityToolkit.Maui.MediaElement/MediaSource/MediaSource.shared.cs
index c9a6f61223..3b1cd0620b 100644
--- a/src/CommunityToolkit.Maui.MediaElement/MediaSource/MediaSource.shared.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/MediaSource/MediaSource.shared.cs
@@ -55,6 +55,13 @@ public static implicit operator MediaSource(string source) =>
 	/// <returns>A <see cref="FileMediaSource"/> instance.</returns>
 	public static MediaSource FromFile(string path) => new FileMediaSource { Path = path };
 
+	/// <summary>
+	/// Creates a <see cref="StreamMediaSource"/> from a <see cref="Stream"/>.
+	/// </summary>
+	/// <param name="stream">The stream to use as a media source.</param>
+	/// <returns>A <see cref="StreamMediaSource"/> instance.</returns>
+	public static StreamMediaSource FromStream(Stream stream) => new StreamMediaSource { Stream = stream };
+
 	/// <summary>
 	/// Creates a <see cref="UriMediaSource"/> from an absolute URI.
 	/// </summary>
diff --git a/src/CommunityToolkit.Maui.MediaElement/MediaSource/ResourceMediaSource.shared.cs b/src/CommunityToolkit.Maui.MediaElement/MediaSource/ResourceMediaSource.shared.cs
index 22c5809f82..f048012dec 100644
--- a/src/CommunityToolkit.Maui.MediaElement/MediaSource/ResourceMediaSource.shared.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/MediaSource/ResourceMediaSource.shared.cs
@@ -16,18 +16,6 @@ public sealed partial class ResourceMediaSource : MediaSource
 	public static readonly BindableProperty PathProperty
 		= BindableProperty.Create(nameof(Path), typeof(string), typeof(ResourceMediaSource), propertyChanged: OnResourceMediaSourceMediaSourceChanged);
 
-	/// <summary>
-	/// An implicit operator to convert a string value into a <see cref="ResourceMediaSource"/>.
-	/// </summary>
-	/// <param name="path">Full path to the resource file, relative to the application's resources folder.</param>
-	public static implicit operator ResourceMediaSource(string path) => (ResourceMediaSource)FromFile(path);
-
-	/// <summary>
-	/// An implicit operator to convert a <see cref="ResourceMediaSource"/> into a string value.
-	/// </summary>
-	/// <param name="resourceMediaSource">A <see cref="ResourceMediaSource"/> instance to convert to a string value.</param>
-	public static implicit operator string?(ResourceMediaSource? resourceMediaSource) => resourceMediaSource?.Path;
-
 	/// <summary>
 	/// Gets or sets the full path to the resource file to use as a media source.
 	/// This is a bindable property.
@@ -42,6 +30,18 @@ public string? Path
 		set => SetValue(PathProperty, value);
 	}
 
+	/// <summary>
+	/// An implicit operator to convert a string value into a <see cref="ResourceMediaSource"/>.
+	/// </summary>
+	/// <param name="path">Full path to the resource file, relative to the application's resources folder.</param>
+	public static implicit operator ResourceMediaSource(string path) => (ResourceMediaSource)FromFile(path);
+
+	/// <summary>
+	/// An implicit operator to convert a <see cref="ResourceMediaSource"/> into a string value.
+	/// </summary>
+	/// <param name="resourceMediaSource">A <see cref="ResourceMediaSource"/> instance to convert to a string value.</param>
+	public static implicit operator string?(ResourceMediaSource? resourceMediaSource) => resourceMediaSource?.Path;
+
 	/// <inheritdoc/>
 	public override string ToString() => $"Resource: {Path}";
 
diff --git a/src/CommunityToolkit.Maui.MediaElement/MediaSource/StreamMediaSource.shared.cs b/src/CommunityToolkit.Maui.MediaElement/MediaSource/StreamMediaSource.shared.cs
new file mode 100644
index 0000000000..d63fb2b8d3
--- /dev/null
+++ b/src/CommunityToolkit.Maui.MediaElement/MediaSource/StreamMediaSource.shared.cs
@@ -0,0 +1,42 @@
+namespace CommunityToolkit.Maui.Views;
+
+/// <summary>
+/// Represents a source, loaded from a <see cref="System.IO.Stream"/>, that can be played by <see cref="MediaElement"/>.
+/// </summary>
+public sealed partial class StreamMediaSource : MediaSource
+{
+	/// <summary>
+	/// Backing store for the <see cref="Stream"/> property.
+	/// </summary>
+	public static readonly BindableProperty StreamProperty
+		= BindableProperty.Create(nameof(Stream), typeof(Stream), typeof(StreamMediaSource), propertyChanged: OnStreamMediaSourceChanged);
+
+	/// <summary>
+	/// Gets or sets the stream to use as a media source.
+	/// This is a bindable property.
+	/// </summary>
+	public Stream? Stream
+	{
+		get => (Stream?)GetValue(StreamProperty);
+		set => SetValue(StreamProperty, value);
+	}
+
+	/// <summary>
+	/// An implicit operator to convert a <see cref="System.IO.Stream"/> value into a <see cref="StreamMediaSource"/>.
+	/// </summary>
+	/// <param name="stream">The stream to use as a media source.</param>
+	public static implicit operator StreamMediaSource?(Stream? stream) => stream is not null ? FromStream(stream) : null;
+
+	/// <summary>
+	/// An implicit operator to convert a <see cref="StreamMediaSource"/> into a <see cref="System.IO.Stream"/> value.
+	/// </summary>
+	/// <param name="streamMediaSource">A <see cref="StreamMediaSource"/> instance to convert to a <see cref="System.IO.Stream"/> value.</param>
+	public static implicit operator Stream?(StreamMediaSource? streamMediaSource) => streamMediaSource?.Stream;
+
+
+	/// <inheritdoc/>
+	public override string ToString() => $"Stream: {Stream?.GetType().Name ?? "null"}";
+
+	static void OnStreamMediaSourceChanged(BindableObject bindable, object oldValue, object newValue) =>
+		((StreamMediaSource)bindable).OnSourceChanged();
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.MediaElement/MediaSource/UriMediaSource.shared.cs b/src/CommunityToolkit.Maui.MediaElement/MediaSource/UriMediaSource.shared.cs
index 31d7960457..a8a87cefdf 100644
--- a/src/CommunityToolkit.Maui.MediaElement/MediaSource/UriMediaSource.shared.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/MediaSource/UriMediaSource.shared.cs
@@ -25,18 +25,6 @@ public UriMediaSource()
 		((ObservableDictionary<string, string>)HttpHeaders).ContentsChanged += HandleHeadersContentsChanged;
 	}
 
-	/// <summary>
-	/// An implicit operator to convert a string value into a <see cref="UriMediaSource"/>.
-	/// </summary>
-	/// <param name="uri">The URI string to convert into a <see cref="UriMediaSource"/>.</param>
-	public static implicit operator UriMediaSource(string uri) => (UriMediaSource)FromUri(uri);
-
-	/// <summary>
-	/// An implicit operator to convert a <see cref="UriMediaSource"/> into a string value.
-	/// </summary>
-	/// <param name="uriMediaSource">A <see cref="UriMediaSource"/> instance to convert to a string value.</param>
-	public static implicit operator string?(UriMediaSource? uriMediaSource) => uriMediaSource?.Uri?.ToString();
-
 	/// <summary>
 	/// Gets the HTTP headers to include in the request when loading the media from <see cref="Uri"/>.
 	/// </summary>
@@ -59,6 +47,18 @@ public Uri? Uri
 		set => SetValue(UriProperty, value);
 	}
 
+	/// <summary>
+	/// An implicit operator to convert a string value into a <see cref="UriMediaSource"/>.
+	/// </summary>
+	/// <param name="uri">The URI string to convert into a <see cref="UriMediaSource"/>.</param>
+	public static implicit operator UriMediaSource(string uri) => (UriMediaSource)FromUri(uri);
+
+	/// <summary>
+	/// An implicit operator to convert a <see cref="UriMediaSource"/> into a string value.
+	/// </summary>
+	/// <param name="uriMediaSource">A <see cref="UriMediaSource"/> instance to convert to a string value.</param>
+	public static implicit operator string?(UriMediaSource? uriMediaSource) => uriMediaSource?.Uri?.ToString();
+
 	/// <inheritdoc/>
 	public override string ToString() => $"Uri: {Uri}";
 
diff --git a/src/CommunityToolkit.Maui.MediaElement/Primitives/StreamAssetResourceLoader.macios.cs b/src/CommunityToolkit.Maui.MediaElement/Primitives/StreamAssetResourceLoader.macios.cs
new file mode 100644
index 0000000000..2ef6691724
--- /dev/null
+++ b/src/CommunityToolkit.Maui.MediaElement/Primitives/StreamAssetResourceLoader.macios.cs
@@ -0,0 +1,90 @@
+using AVFoundation;
+using Foundation;
+
+namespace CommunityToolkit.Maui.Core;
+
+/// <summary>
+/// Custom AVAssetResourceLoader that provides data from a .NET Stream.
+/// </summary>
+sealed class StreamAssetResourceLoader : AVAssetResourceLoaderDelegate
+{
+	public const string DefaultContentType = "public.mpeg-4";
+	
+	readonly Stream stream;
+	readonly string contentType;
+
+	public StreamAssetResourceLoader(Stream stream, string contentType = DefaultContentType)
+	{
+		ArgumentNullException.ThrowIfNull(stream);
+		this.stream = stream;
+		this.contentType = contentType;
+	}
+
+	public override bool ShouldWaitForLoadingOfRequestedResource(AVAssetResourceLoader resourceLoader, AVAssetResourceLoadingRequest loadingRequest)
+	{
+		if (loadingRequest.ContentInformationRequest is not null)
+		{
+			FillContentInformation(loadingRequest.ContentInformationRequest);
+		}
+
+		if (loadingRequest.DataRequest is not null)
+		{
+			FillDataRequest(loadingRequest.DataRequest);
+		}
+
+		loadingRequest.FinishLoading();
+		return true;
+	}
+
+	void FillContentInformation(AVAssetResourceLoadingContentInformationRequest contentInformationRequest)
+	{
+		contentInformationRequest.ContentType = contentType;
+		contentInformationRequest.ContentLength = stream.CanSeek ? stream.Length : 0;
+		contentInformationRequest.ByteRangeAccessSupported = stream.CanSeek;
+	}
+
+	void FillDataRequest(AVAssetResourceLoadingDataRequest dataRequest)
+	{
+		try
+		{
+			var requestedOffset = dataRequest.RequestedOffset;
+			var requestedLength = (int)dataRequest.RequestedLength;
+
+			// If CurrentOffset is not 0, we're resuming a request
+			if (dataRequest.CurrentOffset != 0)
+			{
+				requestedOffset = dataRequest.CurrentOffset;
+			}
+
+			// Seek to the requested position if the stream supports seeking
+			if (stream.CanSeek && stream.Position != requestedOffset)
+			{
+				stream.Seek(requestedOffset, SeekOrigin.Begin);
+			}
+
+			// Read the requested data
+			var buffer = new byte[requestedLength];
+			var bytesRead = stream.Read(buffer, 0, requestedLength);
+
+			if (bytesRead > 0)
+			{
+				var data = NSData.FromArray(buffer[..bytesRead]);
+				dataRequest.Respond(data);
+			}
+		}
+		catch (Exception ex)
+		{
+			// Log error but don't throw - let AVFoundation handle it
+			System.Diagnostics.Debug.WriteLine($"Error reading stream data: {ex.Message}");
+		}
+	}
+
+	protected override void Dispose(bool disposing)
+	{
+		if (disposing)
+		{
+			// Don't dispose the stream here - let the caller manage its lifetime
+		}
+		base.Dispose(disposing);
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.MediaElement/Primitives/StreamDataSourceFactory.android.cs b/src/CommunityToolkit.Maui.MediaElement/Primitives/StreamDataSourceFactory.android.cs
new file mode 100644
index 0000000000..2853ff965f
--- /dev/null
+++ b/src/CommunityToolkit.Maui.MediaElement/Primitives/StreamDataSourceFactory.android.cs
@@ -0,0 +1,125 @@
+using AndroidX.Media3.Common;
+using AndroidX.Media3.DataSource;
+
+namespace CommunityToolkit.Maui.Core;
+
+/// <summary>
+/// Factory for creating StreamDataSource instances.
+/// </summary>
+sealed class StreamDataSourceFactory : Java.Lang.Object, IDataSourceFactory
+{
+	readonly Stream stream;
+
+	public StreamDataSourceFactory(Stream stream)
+	{
+		ArgumentNullException.ThrowIfNull(stream);
+		this.stream = stream;
+	}
+
+	public IDataSource CreateDataSource()
+	{
+		return new StreamDataSource(stream);
+	}
+
+	sealed class StreamDataSource : Java.Lang.Object, IDataSource
+	{
+		readonly Stream stream;
+		readonly long length;
+		long bytesRemaining;
+
+		public StreamDataSource(Stream stream)
+		{
+			ArgumentNullException.ThrowIfNull(stream);
+
+			this.stream = stream;
+			length = stream.CanSeek ? stream.Length : C.LengthUnset;
+			bytesRemaining = 0;
+		}
+
+		public IDictionary<string, IList<string>>? ResponseHeaders { get; } = new Dictionary<string, IList<string>>();
+
+		public Android.Net.Uri? Uri { get; private set; }
+
+		public void AddTransferListener(ITransferListener? transferListener)
+		{
+			// No-op: transfer listeners not supported for stream sources
+		}
+
+		public long Open(DataSpec? dataSpec)
+		{
+			ArgumentNullException.ThrowIfNull(dataSpec);
+
+			Uri = dataSpec.Uri;
+
+			if (stream.CanSeek)
+			{
+				stream.Seek(dataSpec.Position, SeekOrigin.Begin);
+			}
+			else if (dataSpec.Position > 0)
+			{
+				throw new InvalidOperationException("Cannot open a non-seekable stream at a non-zero position.");
+			}
+
+			bytesRemaining = dataSpec.Length != C.LengthUnset
+				? dataSpec.Length
+				: (length != C.LengthUnset ? length - dataSpec.Position : C.LengthUnset);
+
+			if (bytesRemaining < 0)
+			{
+				throw new ArgumentOutOfRangeException(nameof(dataSpec),
+					$"Position {dataSpec.Position} exceeds stream length {length}.");
+			}
+
+			return bytesRemaining;
+		}
+
+		public int Read(byte[]? buffer, int offset, int length)
+		{
+			ArgumentNullException.ThrowIfNull(buffer);
+
+			if (length == 0)
+			{
+				return 0;
+			}
+
+			if (bytesRemaining == 0)
+			{
+				return C.ResultEndOfInput;
+			}
+
+			int bytesToRead = bytesRemaining != C.LengthUnset
+				? (int)Math.Min(bytesRemaining, length)
+				: length;
+
+			int bytesRead = stream.Read(buffer, offset, bytesToRead);
+
+			if (bytesRead == 0)
+			{
+				return C.ResultEndOfInput;
+			}
+
+			if (bytesRemaining != C.LengthUnset)
+			{
+				bytesRemaining -= bytesRead;
+			}
+
+			return bytesRead;
+		}
+
+		public void Close()
+		{
+			Uri = null;
+			// Don't dispose the stream here - let the caller manage its lifetime
+		}
+
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing)
+			{
+				Close();
+			}
+
+			base.Dispose(disposing);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.android.cs b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.android.cs
index bdfbcc3cdc..86f569b0b8 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.android.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.android.cs
@@ -29,7 +29,7 @@ public partial class MediaManager : Java.Lang.Object, IPlayerListener
 	const int readyState = 3;
 	const int endedState = 4;
 
-	static readonly HttpClient client = new();
+	readonly HttpClient client = new();
 	readonly SemaphoreSlim seekToSemaphoreSlim = new(1, 1);
 	bool isAndroidForegroundServiceEnabled = false;
 
@@ -41,6 +41,7 @@ public partial class MediaManager : Java.Lang.Object, IPlayerListener
 	MediaSession? session;
 	MediaItem.Builder? mediaItem;
 	BoundServiceConnection? connection;
+	StreamDataSourceFactory? currentStreamDataSourceFactory;
 
 	/// <summary>
 	/// The platform native counterpart of <see cref="MediaElement"/>.
@@ -368,9 +369,19 @@ protected virtual async partial ValueTask PlatformUpdateSource()
 			MediaElement.Duration = TimeSpan.Zero;
 			MediaElement.CurrentStateChanged(MediaElementState.None);
 
+			currentStreamDataSourceFactory?.Dispose();
+			currentStreamDataSourceFactory = null;
+
 			return;
 		}
 
+		// Clear previous stream data source if switching sources
+		if (MediaElement.Source is not StreamMediaSource)
+		{
+			currentStreamDataSourceFactory?.Dispose();
+			currentStreamDataSourceFactory = null;
+		}
+
 		MediaElement.CurrentStateChanged(MediaElementState.Opening);
 		Player.PlayWhenReady = MediaElement.ShouldAutoPlay;
 		cancellationTokenSource ??= new();
@@ -380,7 +391,14 @@ protected virtual async partial ValueTask PlatformUpdateSource()
 
 		if (item?.MediaMetadata is not null)
 		{
-			if (MediaElement.Source is UriMediaSource uriMediaSource && uriMediaSource.HttpHeaders.Count > 0)
+			// If we have a custom stream data source, we need to set the media source differently
+			if (currentStreamDataSourceFactory is not null && MediaElement.Source is StreamMediaSource)
+			{
+				var mediaSource = new AndroidX.Media3.ExoPlayer.Source.ProgressiveMediaSource.Factory(currentStreamDataSourceFactory)
+					.CreateMediaSource(item);
+				Player.SetMediaSource(mediaSource);
+			}
+			else if (MediaElement.Source is UriMediaSource uriMediaSource && uriMediaSource.HttpHeaders.Count > 0)
 			{
 				var httpDataSourceFactory = new DefaultHttpDataSource.Factory();
 				httpDataSourceFactory.SetDefaultRequestProperties(uriMediaSource.HttpHeaders);
@@ -405,6 +423,7 @@ protected virtual async partial ValueTask PlatformUpdateSource()
 			{
 				MediaElement.MediaOpened();
 			}
+
 			if (isAndroidForegroundServiceEnabled)
 			{
 				UpdateNotifications();
@@ -557,11 +576,14 @@ protected override void Dispose(bool disposing)
 				connection = null;
 			}
 
+			currentStreamDataSourceFactory?.Dispose();
+			currentStreamDataSourceFactory = null;
+
 			client.Dispose();
 		}
 	}
 
-	static async Task<byte[]> GetBytesFromMetadataArtworkUrl(string url, CancellationToken cancellationToken = default)
+	async Task<byte[]> GetBytesFromMetadataArtworkUrl(string url, CancellationToken cancellationToken = default)
 	{
 		if (string.IsNullOrWhiteSpace(url))
 		{
@@ -592,7 +614,7 @@ static async Task<byte[]> GetBytesFromMetadataArtworkUrl(string url, Cancellatio
 			{
 				var normalizedFilePath = NormalizeFilePath(url);
 
-				stream = File.Open(normalizedFilePath, FileMode.Create);
+				stream = File.OpenRead(normalizedFilePath);
 				contentLength = await GetByteCountFromStream(stream, cancellationToken);
 			}
 			// Relative File Path
@@ -661,6 +683,7 @@ void StartService()
 		{
 			return;
 		}
+
 		var intent = new Intent(global::Android.App.Application.Context, typeof(MediaControlsService));
 		connection = new BoundServiceConnection(this);
 		connection.MediaControlsServiceTaskRemoved += HandleMediaControlsServiceTaskRemoved;
@@ -675,6 +698,7 @@ void StopService(in BoundServiceConnection boundServiceConnection)
 		{
 			return;
 		}
+
 		boundServiceConnection.MediaControlsServiceTaskRemoved -= HandleMediaControlsServiceTaskRemoved;
 
 		var serviceIntent = new Intent(Platform.AppContext, typeof(MediaControlsService));
@@ -723,6 +747,15 @@ void StopService(in BoundServiceConnection boundServiceConnection)
 						return await CreateMediaItem(assetFilePath, cancellationToken).ConfigureAwait(false);
 					}
 
+					break;
+				}
+			case StreamMediaSource streamMediaSource:
+				{
+					if (streamMediaSource.Stream is not null)
+					{
+						return await CreateMediaItemFromStream(streamMediaSource.Stream, cancellationToken).ConfigureAwait(false);
+					}
+
 					break;
 				}
 			default:
@@ -751,36 +784,150 @@ void StopService(in BoundServiceConnection boundServiceConnection)
 		return mediaItem;
 	}
 
+	async Task<MediaItem.Builder> CreateMediaItemFromStream(Stream stream, CancellationToken cancellationToken)
+	{
+		MediaMetadata.Builder mediaMetaData = new();
+		mediaMetaData.SetArtist(MediaElement.MetadataArtist);
+		mediaMetaData.SetTitle(MediaElement.MetadataTitle);
+		var data = await GetBytesFromMetadataArtworkUrl(MediaElement.MetadataArtworkUrl, cancellationToken).ConfigureAwait(true);
+		if (data is not null && data.Length > 0)
+		{
+			mediaMetaData.SetArtworkData(data, (Java.Lang.Integer)MediaMetadata.PictureTypeFrontCover);
+		}
+
+		// Create MediaItem with metadata
+		// The stream will be handled via custom data source factory when needed
+		mediaItem = new MediaItem.Builder();
+		mediaItem.SetUri("stream://media");
+		mediaItem.SetMediaId("stream://media");
+		mediaItem.SetMediaMetadata(mediaMetaData.Build());
+		currentStreamDataSourceFactory?.Dispose();
+		currentStreamDataSourceFactory = null;
+
+		// Store the stream for later use with custom MediaSource
+		currentStreamDataSourceFactory = new StreamDataSourceFactory(stream);
+
+		return mediaItem;
+	}
+
 	#region PlayerListener implementation method stubs
-	public void OnAudioAttributesChanged(AudioAttributes? audioAttributes) { }
-	public void OnAudioSessionIdChanged(int audioSessionId) { }
-	public void OnAvailableCommandsChanged(PlayerCommands? player) { }
-	public void OnCues(CueGroup? cues) { }
-	public void OnDeviceInfoChanged(DeviceInfo? deviceInfo) { }
-	public void OnDeviceVolumeChanged(int volume, bool muted) { }
-	public void OnEvents(IPlayer? player, PlayerEvents? playerEvents) { }
-	public void OnIsLoadingChanged(bool isLoading) { }
-	public void OnIsPlayingChanged(bool isPlaying) { }
-	public void OnLoadingChanged(bool isLoading) { }
-	public void OnMaxSeekToPreviousPositionChanged(long maxSeekToPreviousPositionMs) { }
-	public void OnMediaItemTransition(MediaItem? mediaItem, int reason) { }
-	public void OnMediaMetadataChanged(MediaMetadata? mediaMetadata) { }
-	public void OnMetadata(Metadata? metadata) { }
-	public void OnPlayWhenReadyChanged(bool playWhenReady, int reason) { }
-	public void OnPositionDiscontinuity(PlayerPositionInfo? oldPosition, PlayerPositionInfo? newPosition, int reason) { }
-	public void OnPlaybackSuppressionReasonChanged(int playbackSuppressionReason) { }
-	public void OnPlayerErrorChanged(PlaybackException? error) { }
-	public void OnPlaylistMetadataChanged(MediaMetadata? mediaMetadata) { }
-	public void OnRenderedFirstFrame() { }
-	public void OnRepeatModeChanged(int repeatMode) { }
-	public void OnSeekBackIncrementChanged(long seekBackIncrementMs) { }
-	public void OnSeekForwardIncrementChanged(long seekForwardIncrementMs) { }
-	public void OnShuffleModeEnabledChanged(bool shuffleModeEnabled) { }
-	public void OnSkipSilenceEnabledChanged(bool skipSilenceEnabled) { }
-	public void OnSurfaceSizeChanged(int width, int height) { }
-	public void OnTimelineChanged(Timeline? timeline, int reason) { }
-	public void OnTrackSelectionParametersChanged(TrackSelectionParameters? trackSelectionParameters) { }
-	public void OnTracksChanged(Tracks? tracks) { }
+
+	public void OnAudioAttributesChanged(AudioAttributes? audioAttributes)
+	{
+	}
+
+	public void OnAudioSessionIdChanged(int audioSessionId)
+	{
+	}
+
+	public void OnAvailableCommandsChanged(PlayerCommands? player)
+	{
+	}
+
+	public void OnCues(CueGroup? cues)
+	{
+	}
+
+	public void OnDeviceInfoChanged(DeviceInfo? deviceInfo)
+	{
+	}
+
+	public void OnDeviceVolumeChanged(int volume, bool muted)
+	{
+	}
+
+	public void OnEvents(IPlayer? player, PlayerEvents? playerEvents)
+	{
+	}
+
+	public void OnIsLoadingChanged(bool isLoading)
+	{
+	}
+
+	public void OnIsPlayingChanged(bool isPlaying)
+	{
+	}
+
+	public void OnLoadingChanged(bool isLoading)
+	{
+	}
+
+	public void OnMaxSeekToPreviousPositionChanged(long maxSeekToPreviousPositionMs)
+	{
+	}
+
+	public void OnMediaItemTransition(MediaItem? mediaItem, int reason)
+	{
+	}
+
+	public void OnMediaMetadataChanged(MediaMetadata? mediaMetadata)
+	{
+	}
+
+	public void OnMetadata(Metadata? metadata)
+	{
+	}
+
+	public void OnPlayWhenReadyChanged(bool playWhenReady, int reason)
+	{
+	}
+
+	public void OnPositionDiscontinuity(PlayerPositionInfo? oldPosition, PlayerPositionInfo? newPosition, int reason)
+	{
+	}
+
+	public void OnPlaybackSuppressionReasonChanged(int playbackSuppressionReason)
+	{
+	}
+
+	public void OnPlayerErrorChanged(PlaybackException? error)
+	{
+	}
+
+	public void OnPlaylistMetadataChanged(MediaMetadata? mediaMetadata)
+	{
+	}
+
+	public void OnRenderedFirstFrame()
+	{
+	}
+
+	public void OnRepeatModeChanged(int repeatMode)
+	{
+	}
+
+	public void OnSeekBackIncrementChanged(long seekBackIncrementMs)
+	{
+	}
+
+	public void OnSeekForwardIncrementChanged(long seekForwardIncrementMs)
+	{
+	}
+
+	public void OnShuffleModeEnabledChanged(bool shuffleModeEnabled)
+	{
+	}
+
+	public void OnSkipSilenceEnabledChanged(bool skipSilenceEnabled)
+	{
+	}
+
+	public void OnSurfaceSizeChanged(int width, int height)
+	{
+	}
+
+	public void OnTimelineChanged(Timeline? timeline, int reason)
+	{
+	}
+
+	public void OnTrackSelectionParametersChanged(TrackSelectionParameters? trackSelectionParameters)
+	{
+	}
+
+	public void OnTracksChanged(Tracks? tracks)
+	{
+	}
+
 	#endregion
 
 	static class PlaybackState
@@ -799,6 +946,4 @@ static class PlaybackState
 		public const int StateStopped = 1;
 		public const int StateError = 7;
 	}
-
-
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.macios.cs b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.macios.cs
index 15cc3dc02c..beaab1516a 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.macios.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.macios.cs
@@ -14,6 +14,7 @@ namespace CommunityToolkit.Maui.Core.Views;
 public partial class MediaManager : IDisposable
 {
 	Metadata? metaData;
+	StreamAssetResourceLoader? streamResourceLoader;
 
 	// Media would still start playing when Speed was set although ShouldAutoPlay=False
 	// This field was added to overcome that.
@@ -220,6 +221,13 @@ protected virtual async partial ValueTask PlatformUpdateSource()
 			return;
 		}
 
+		// Clean up previous stream resource loader if switching sources
+		if (MediaElement.Source is not StreamMediaSource)
+		{
+			streamResourceLoader?.Dispose();
+			streamResourceLoader = null;
+		}
+
 		metaData ??= new(Player);
 		Metadata.ClearNowPlaying();
 		PlayerViewController?.ContentOverlayView?.Subviews.FirstOrDefault()?.RemoveFromSuperview();
@@ -274,6 +282,27 @@ protected virtual async partial ValueTask PlatformUpdateSource()
 				Logger.LogWarning("Invalid file path for ResourceMediaSource.");
 			}
 		}
+		else if (MediaElement.Source is StreamMediaSource streamMediaSource)
+		{
+			if (streamMediaSource.Stream is not null)
+			{
+				// Create a custom URL scheme for the stream
+				var streamUrl = new NSUrl("stream://media");
+
+				// Create an AVURLAsset with the custom scheme
+				var urlAsset = new AVUrlAsset(streamUrl);
+
+				// Create and set up the resource loader
+				streamResourceLoader?.Dispose();
+				streamResourceLoader = new StreamAssetResourceLoader(streamMediaSource.Stream, GetStreamContentType(streamMediaSource.Stream));
+
+				// Assign the resource loader delegate to a serial background queue to avoid blocking the UI thread
+				var resourceLoaderQueue = new DispatchQueue("CommunityToolkit.Maui.MediaElement.StreamResourceLoader");
+				urlAsset.ResourceLoader.SetDelegate(streamResourceLoader, resourceLoaderQueue);
+
+				asset = urlAsset;
+			}
+		}
 
 		PlayerItem = asset is not null
 			? new AVPlayerItem(asset)
@@ -467,11 +496,55 @@ protected virtual void Dispose(bool disposing)
 				Player = null;
 			}
 
+			streamResourceLoader?.Dispose();
+			streamResourceLoader = null;
+
 			PlayerViewController?.Dispose();
 			PlayerViewController = null;
 		}
 	}
 
+	static string GetStreamContentType(Stream stream)
+	{
+		// Try to detect content type from magic bytes
+		if (stream is not { CanSeek: true, Length: > 12 })
+		{
+			return StreamAssetResourceLoader.DefaultContentType;
+		}
+
+		var originalPosition = stream.Position;
+		try
+		{
+			stream.Position = 0;
+			var buffer = new byte[12];
+			var bytesRead = stream.Read(buffer, 0, 12);
+
+			if (bytesRead >= 12)
+			{
+				// Check for MP4/M4V/MOV signature (ftyp box at offset 4)
+				if (buffer[4] == 0x66 && buffer[5] == 0x74 && buffer[6] == 0x79 && buffer[7] == 0x70)
+				{
+					// Check specific brand
+					var brand = System.Text.Encoding.ASCII.GetString(buffer, 8, 4);
+
+					// Most iOS videos will be either mp4, m4v, or qt (QuickTime)
+					// For AVFoundation, we should use UTI: "public.mpeg-4" or "com.apple.quicktime-movie"
+					return brand.StartsWith("qt", StringComparison.Ordinal)
+						? "com.apple.quicktime-movie"
+						: StreamAssetResourceLoader.DefaultContentType;
+				}
+			}
+		}
+		finally
+		{
+			stream.Position = originalPosition;
+		}
+
+		// Default to MPEG-4 (MP4) - covers most cases
+		// Using UTI format for iOS/macOS
+		return "public.mpeg-4";
+	}
+
 	static TimeSpan ConvertTime(CMTime cmTime) => TimeSpan.FromSeconds(double.IsNaN(cmTime.Seconds) ? 0 : cmTime.Seconds);
 
 	static async Task<(int Width, int Height)> GetVideoDimensions(AVPlayerItem avPlayerItem)
diff --git a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.tizen.cs b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.tizen.cs
index f0f95fbdb7..574b448848 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.tizen.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.tizen.cs
@@ -186,6 +186,13 @@ protected virtual partial ValueTask PlatformUpdateSource()
 				IsUriStreaming = false;
 			}
 		}
+		else if (MediaElement.Source is StreamMediaSource streamMediaSource)
+		{
+			if (streamMediaSource.Stream is not null)
+			{
+				throw new NotSupportedException($"{nameof(StreamMediaSource)} is not yet supported on Tizen. Consider using a FileMediaSource or UriMediaSource instead.");
+			}
+		}
 
 		if (Player.IsSourceSet)
 		{
diff --git a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.windows.cs b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.windows.cs
index 635e28839b..4f0d74a6b7 100644
--- a/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.windows.cs
+++ b/src/CommunityToolkit.Maui.MediaElement/Views/MediaManager.windows.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Numerics;
+using CommunityToolkit.Maui.Core.Extensions;
 using CommunityToolkit.Maui.Core.Primitives;
 using CommunityToolkit.Maui.Extensions;
 using CommunityToolkit.Maui.Views;
@@ -335,6 +336,14 @@ protected virtual async partial ValueTask PlatformUpdateSource()
 				Player.MediaPlayer.SetUriSource(new Uri(path));
 			}
 		}
+		else if (MediaElement.Source is StreamMediaSource streamMediaSource)
+		{
+			if (streamMediaSource.Stream is not null)
+			{
+				var randomAccessStream = streamMediaSource.Stream.AsRandomAccessStream();
+				Player.Source = WinMediaSource.CreateFromStream(randomAccessStream, streamMediaSource.Stream.GetMimeType());
+			}
+		}
 	}
 
 	async Task SetUriSourceWithHeaders(Uri uri, IDictionary<string, string> headers)
diff --git a/src/CommunityToolkit.Maui.UnitTests/Extensions/StreamExtensionsTests.cs b/src/CommunityToolkit.Maui.UnitTests/Extensions/StreamExtensionsTests.cs
new file mode 100644
index 0000000000..46c70e4657
--- /dev/null
+++ b/src/CommunityToolkit.Maui.UnitTests/Extensions/StreamExtensionsTests.cs
@@ -0,0 +1,283 @@
+using CommunityToolkit.Maui.Core.Extensions;
+using FluentAssertions;
+using Xunit;
+
+namespace CommunityToolkit.Maui.UnitTests.Extensions;
+
+public class StreamExtensionsTests : BaseTest
+{
+	const string defaultMimeType = "application/octet-stream";
+
+	[Fact]
+	public void GetMimeType_NullStream_ThrowsArgumentNullException()
+	{
+		Stream? stream = null;
+		Assert.Throws<ArgumentNullException>(() => stream!.GetMimeType());
+	}
+
+	[Fact]
+	public void GetMimeType_EmptyStream_ReturnsDefault()
+	{
+		using var stream = new MemoryStream([]);
+		stream.GetMimeType().Should().Be(defaultMimeType);
+	}
+
+	[Fact]
+	public void GetMimeType_StreamSmallerThanFourBytes_ReturnsDefault()
+	{
+		using var stream = new MemoryStream([0x01, 0x02, 0x03]);
+		stream.GetMimeType().Should().Be(defaultMimeType);
+	}
+
+	[Fact]
+	public void GetMimeType_UnknownHeader_ReturnsDefault()
+	{
+		using var stream = new MemoryStream([0xDE, 0xAD, 0xBE, 0xEF, 0x01, 0x02, 0x03, 0x04]);
+		stream.GetMimeType().Should().Be(defaultMimeType);
+	}
+
+	[Fact]
+	public void GetMimeType_NonReadableStream_ReturnsDefault()
+	{
+		using var stream = new NonReadableStream();
+		stream.GetMimeType().Should().Be(defaultMimeType);
+	}
+
+	[Fact]
+	public void GetMimeType_NonSeekableStream_ReturnsDefault()
+	{
+		using var inner = new MemoryStream(BuildFtypHeader("isom"));
+		using var stream = new NonSeekableStream(inner);
+		stream.GetMimeType().Should().Be(defaultMimeType);
+	}
+
+	[Fact]
+	public void GetMimeType_RestoresOriginalStreamPosition()
+	{
+		using var stream = new MemoryStream(BuildFtypHeader("isom"));
+		stream.Position = 5;
+
+		stream.GetMimeType();
+
+		stream.Position.Should().Be(5);
+	}
+
+	[Fact]
+	public void GetMimeType_DoesNotRewindWhenAtZero()
+	{
+		using var stream = new MemoryStream(BuildFtypHeader("isom"));
+		stream.Position = 0;
+
+		stream.GetMimeType().Should().Be("video/mp4");
+
+		stream.Position.Should().Be(0);
+	}
+
+	[Theory]
+	[InlineData("isom", "video/mp4")]
+	[InlineData("mp42", "video/mp4")]
+	[InlineData("avc1", "video/mp4")]
+	[InlineData("M4A ", "audio/mp4")]
+	[InlineData("M4B ", "audio/mp4")]
+	[InlineData("M4P ", "audio/mp4")]
+	[InlineData("qt  ", "video/quicktime")]
+	[InlineData("3gp4", "video/3gpp")]
+	[InlineData("3gp5", "video/3gpp")]
+	[InlineData("3gp6", "video/3gpp")]
+	[InlineData("3gp7", "video/3gpp")]
+	[InlineData("3gpp", "video/3gpp")]
+	[InlineData("3g2a", "video/3gpp2")]
+	[InlineData("3g2b", "video/3gpp2")]
+	[InlineData("3g2c", "video/3gpp2")]
+	public void GetMimeType_FtypBrand_ReturnsExpectedMimeType(string brand, string expected)
+	{
+		using var stream = new MemoryStream(BuildFtypHeader(brand));
+		stream.GetMimeType().Should().Be(expected);
+	}
+
+	[Fact]
+	public void GetMimeType_WebMHeader_ReturnsVideoWebm()
+	{
+		using var stream = new MemoryStream([0x1A, 0x45, 0xDF, 0xA3, 0x01, 0x02, 0x03, 0x04]);
+		stream.GetMimeType().Should().Be("video/webm");
+	}
+
+	[Fact]
+	public void GetMimeType_AviRiffHeader_ReturnsVideoXMsVideo()
+	{
+		byte[] header =
+		[
+			(byte)'R', (byte)'I', (byte)'F', (byte)'F',
+			0x00, 0x00, 0x00, 0x00,
+			(byte)'A', (byte)'V', (byte)'I', (byte)' '
+		];
+		using var stream = new MemoryStream(header);
+		stream.GetMimeType().Should().Be("video/x-msvideo");
+	}
+
+	[Fact]
+	public void GetMimeType_WaveRiffHeader_ReturnsAudioWav()
+	{
+		byte[] header =
+		[
+			(byte)'R', (byte)'I', (byte)'F', (byte)'F',
+			0x00, 0x00, 0x00, 0x00,
+			(byte)'W', (byte)'A', (byte)'V', (byte)'E'
+		];
+		using var stream = new MemoryStream(header);
+		stream.GetMimeType().Should().Be("audio/wav");
+	}
+
+	[Fact]
+	public void GetMimeType_RiffWithUnknownSubtype_ReturnsDefault()
+	{
+		byte[] header =
+		[
+			(byte)'R', (byte)'I', (byte)'F', (byte)'F',
+			0x00, 0x00, 0x00, 0x00,
+			(byte)'X', (byte)'X', (byte)'X', (byte)'X'
+		];
+		using var stream = new MemoryStream(header);
+		stream.GetMimeType().Should().Be(defaultMimeType);
+	}
+
+	[Fact]
+	public void GetMimeType_OggHeader_ReturnsApplicationOgg()
+	{
+		byte[] header = [(byte)'O', (byte)'g', (byte)'g', (byte)'S', 0x00, 0x02, 0x00, 0x00];
+		using var stream = new MemoryStream(header);
+		stream.GetMimeType().Should().Be("application/ogg");
+	}
+
+	[Fact]
+	public void GetMimeType_FlacHeader_ReturnsAudioFlac()
+	{
+		byte[] header = [(byte)'f', (byte)'L', (byte)'a', (byte)'C', 0x00, 0x00, 0x00, 0x22];
+		using var stream = new MemoryStream(header);
+		stream.GetMimeType().Should().Be("audio/flac");
+	}
+
+	[Fact]
+	public void GetMimeType_Mp3WithId3Header_ReturnsAudioMpeg()
+	{
+		byte[] header = [(byte)'I', (byte)'D', (byte)'3', 0x04, 0x00, 0x00, 0x00, 0x00];
+		using var stream = new MemoryStream(header);
+		stream.GetMimeType().Should().Be("audio/mpeg");
+	}
+
+	[Theory]
+	[InlineData(0xE0)]
+	[InlineData(0xE3)]
+	[InlineData(0xF0)]
+	[InlineData(0xFB)]
+	[InlineData(0xFF)]
+	public void GetMimeType_Mp3FrameSync_ReturnsAudioMpeg(byte secondByte)
+	{
+		byte[] header = [0xFF, secondByte, 0x00, 0x00];
+		using var stream = new MemoryStream(header);
+		stream.GetMimeType().Should().Be("audio/mpeg");
+	}
+
+	[Fact]
+	public void GetMimeType_MpegProgramStream_ReturnsVideoMpeg()
+	{
+		byte[] header = [0x00, 0x00, 0x01, 0xBA, 0x44, 0x00, 0x04, 0x00];
+		using var stream = new MemoryStream(header);
+		stream.GetMimeType().Should().Be("video/mpeg");
+	}
+
+	[Fact]
+	public void GetMimeType_MpegTransportStream_ReturnsVideoMp2t()
+	{
+		byte[] header = [0x47, 0x40, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00];
+		using var stream = new MemoryStream(header);
+		stream.GetMimeType().Should().Be("video/mp2t");
+	}
+
+	[Fact]
+	public void GetMimeType_AsfHeader_ReturnsVideoXMsAsf()
+	{
+		byte[] header =
+		[
+			0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11,
+			0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C
+		];
+		using var stream = new MemoryStream(header);
+		stream.GetMimeType().Should().Be("video/x-ms-asf");
+	}
+
+	[Fact]
+	public void GetMimeType_FlvHeader_ReturnsVideoXFlv()
+	{
+		byte[] header = [(byte)'F', (byte)'L', (byte)'V', 0x01, 0x05, 0x00, 0x00, 0x00];
+		using var stream = new MemoryStream(header);
+		stream.GetMimeType().Should().Be("video/x-flv");
+	}
+
+	[Fact]
+	public void GetMimeType_StreamThrowingIOException_ReturnsDefault()
+	{
+		using var stream = new ThrowingStream(new IOException("boom"));
+		stream.GetMimeType().Should().Be(defaultMimeType);
+	}
+
+	[Fact]
+	public void GetMimeType_StreamThrowingNotSupportedException_ReturnsDefault()
+	{
+		using var stream = new ThrowingStream(new NotSupportedException("boom"));
+		stream.GetMimeType().Should().Be(defaultMimeType);
+	}
+
+	static byte[] BuildFtypHeader(string brand)
+	{
+		if (brand.Length is not 4)
+		{
+			throw new ArgumentException("Brand must be 4 characters", nameof(brand));
+		}
+
+		return
+		[
+			0x00, 0x00, 0x00, 0x20,
+			(byte)'f', (byte)'t', (byte)'y', (byte)'p',
+			(byte)brand[0], (byte)brand[1], (byte)brand[2], (byte)brand[3],
+			0x00, 0x00, 0x02, 0x00
+		];
+	}
+
+	sealed class NonReadableStream : MemoryStream
+	{
+		public override bool CanRead => false;
+	}
+
+	sealed class NonSeekableStream(Stream inner) : Stream
+	{
+		public override bool CanRead => inner.CanRead;
+		public override bool CanSeek => false;
+		public override bool CanWrite => false;
+		public override long Length => throw new NotSupportedException();
+		public override long Position
+		{
+			get => throw new NotSupportedException();
+			set => throw new NotSupportedException();
+		}
+		public override void Flush() => inner.Flush();
+		public override int Read(byte[] buffer, int offset, int count) => inner.Read(buffer, offset, count);
+		public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+		public override void SetLength(long value) => throw new NotSupportedException();
+		public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+	}
+
+	sealed class ThrowingStream(Exception exceptionToThrow) : Stream
+	{
+		public override bool CanRead => true;
+		public override bool CanSeek => true;
+		public override bool CanWrite => false;
+		public override long Length => 1024;
+		public override long Position { get; set; }
+		public override void Flush() { }
+		public override int Read(byte[] buffer, int offset, int count) => throw exceptionToThrow;
+		public override long Seek(long offset, SeekOrigin origin) => Position = offset;
+		public override void SetLength(long value) => throw new NotSupportedException();
+		public override void Write(byte[] buffer, int offset, int count) => throw new NotSupportedException();
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit.Maui.UnitTests/Views/LazyView/LazyViewTests.cs b/src/CommunityToolkit.Maui.UnitTests/Views/LazyView/LazyViewTests.cs
index fc38b93516..cfc10a72af 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Views/LazyView/LazyViewTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Views/LazyView/LazyViewTests.cs
@@ -20,7 +20,10 @@ public async Task LoadViewAsync_CancellationTokenExpired()
 		var lazyView = new LazyView<Button>();
 
 		// Ensure CancellationToken Expired
-		await Task.Delay(100, TestContext.Current.CancellationToken);
+		while (!cts.Token.IsCancellationRequested)
+		{
+			await Task.Delay(1, TestContext.Current.CancellationToken);
+		}
 
 		await Assert.ThrowsAsync<OperationCanceledException>(async () => await lazyView.LoadViewAsync(cts.Token));
 	}
diff --git a/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceTests.cs b/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceTests.cs
index dc87f8094b..af7439c7ce 100644
--- a/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceTests.cs
+++ b/src/CommunityToolkit.Maui.UnitTests/Views/MediaElement/MediaSourceTests.cs
@@ -38,4 +38,13 @@ public void MediaSourceFromFileShouldBeFileMediaSource()
 
 		mediaSource.Should().BeAssignableTo<FileMediaSource>();
 	}
+
+	[Fact]
+	public void MediaSourceFromStreamShouldBeStreamMediaSource()
+	{
+		using var stream = new System.IO.MemoryStream();
+		var mediaSource = MediaSource.FromStream(stream);
+
+		mediaSource.Should().BeAssignableTo<StreamMediaSource>();
+	}
 }
\ No newline at end of file