diff --git a/src/Files.App.Launcher/Files.App.Launcher.vcxproj b/src/Files.App.Launcher/Files.App.Launcher.vcxproj
index 93862737d1f1..87b940ed867a 100644
--- a/src/Files.App.Launcher/Files.App.Launcher.vcxproj
+++ b/src/Files.App.Launcher/Files.App.Launcher.vcxproj
@@ -89,7 +89,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions);_SILENCE_EXPERIMENTAL_COROUTINE_DEPRECATION_WARNINGS</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
     </ClCompile>
   </ItemDefinitionGroup>
@@ -103,7 +103,7 @@
     <ClCompile>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions);_SILENCE_EXPERIMENTAL_COROUTINE_DEPRECATION_WARNINGS</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
     </ClCompile>
     <Link>
diff --git a/src/Files.App/Data/Items/EncodingItem.cs b/src/Files.App/Data/Items/EncodingItem.cs
index 51ec61b121e9..361ffe6abe62 100644
--- a/src/Files.App/Data/Items/EncodingItem.cs
+++ b/src/Files.App/Data/Items/EncodingItem.cs
@@ -50,7 +50,7 @@ public EncodingItem(Encoding encoding, string name)
             //reference: https://en.wikipedia.org/wiki/Windows_code_page
             //East Asian
             "shift_jis",       //Japanese
-            "gb2312",          //Simplified Chinese
+            "gb18030",          //Simplified Chinese
             "big5",            //Traditional Chinese
             "ks_c_5601-1987",  //Korean
             
diff --git a/src/Files.App/Data/Models/CurrentInstanceViewModel.cs b/src/Files.App/Data/Models/CurrentInstanceViewModel.cs
index ffc6a977f291..f77555489655 100644
--- a/src/Files.App/Data/Models/CurrentInstanceViewModel.cs
+++ b/src/Files.App/Data/Models/CurrentInstanceViewModel.cs
@@ -146,6 +146,20 @@ public bool IsPageTypeLibrary
 			}
 		}
 
+		private string? zipEncodingName;
+		public string? ZipEncodingName
+		{
+			get => zipEncodingName;
+			set => SetProperty(ref zipEncodingName, value);
+		}
+
+		private bool isZipEncodingUndetermined;
+		public bool IsZipEncodingUndetermined
+		{
+			get => isZipEncodingUndetermined;
+			set => SetProperty(ref isZipEncodingUndetermined, value);
+		}
+
 		public bool CanCopyPathInPage
 		{
 			get => !isPageTypeMtpDevice && !isPageTypeRecycleBin && isPageTypeNotHome && !isPageTypeSearchResults && !IsPageTypeReleaseNotes && !IsPageTypeSettings;
diff --git a/src/Files.App/Data/Models/DirectoryPropertiesViewModel.cs b/src/Files.App/Data/Models/DirectoryPropertiesViewModel.cs
index 1109998f2b6a..9845a7fad451 100644
--- a/src/Files.App/Data/Models/DirectoryPropertiesViewModel.cs
+++ b/src/Files.App/Data/Models/DirectoryPropertiesViewModel.cs
@@ -1,6 +1,11 @@
 // Copyright (c) Files Community
 // Licensed under the MIT License.
 
+using Files.App.Data.Items;
+using Files.App.Utils.Storage;
+using Microsoft.Extensions.Logging;
+using System.ComponentModel;
+using System.Text;
 using System.Windows.Input;
 
 namespace Files.App.ViewModels.UserControls
@@ -9,6 +14,8 @@ public sealed partial class StatusBarViewModel : ObservableObject
 	{
 		private IContentPageContext ContentPageContext { get; } = Ioc.Default.GetRequiredService<IContentPageContext>();
 		private IDevToolsSettingsService DevToolsSettingsService = Ioc.Default.GetRequiredService<IDevToolsSettingsService>();
+		private readonly IStorageArchiveService StorageArchiveService = Ioc.Default.GetRequiredService<IStorageArchiveService>();
+		private CurrentInstanceViewModel? InstanceViewModel => ContentPageContext.ShellPage?.InstanceViewModel;
 
 		// The first branch will always be the active one.
 		public const int ACTIVE_BRANCH_INDEX = 0;
@@ -81,6 +88,26 @@ public string ExtendedStatusInfo
 			set => SetProperty(ref _ExtendedStatusInfo, value);
 		}
 
+		private bool _IsZipEncodingSelectorVisible;
+		public bool IsZipEncodingSelectorVisible
+		{
+			get => _IsZipEncodingSelectorVisible;
+			set => SetProperty(ref _IsZipEncodingSelectorVisible, value);
+		}
+
+		public List<EncodingItem> ZipEncodingOptions { get; } = EncodingItem.Defaults.ToList();
+
+		private EncodingItem? _SelectedZipEncoding;
+		public EncodingItem? SelectedZipEncoding
+		{
+			get => _SelectedZipEncoding;
+			set
+			{
+				if (SetProperty(ref _SelectedZipEncoding, value) && value is not null)
+					_ = OnZipEncodingChangedAsync(value);
+			}
+		}
+
 		public bool ShowOpenInIDEButton
 		{
 			get
@@ -112,6 +139,24 @@ public StatusBarViewModel()
 						break;
 				}
 			};
+
+			SubscribeToShellPage();
+			ContentPageContext.PropertyChanged += OnContentPageContextPropertyChanged;
+		}
+
+		private void OnContentPageContextPropertyChanged(object? sender, PropertyChangedEventArgs e)
+		{
+			if (e.PropertyName == nameof(ContentPageContext.ShellPage))
+			{
+				UnsubscribeFromInstanceViewModel();
+				SubscribeToShellPage();
+			}
+		}
+
+		private void SubscribeToShellPage()
+		{
+			SubscribeToInstanceViewModel();
+			_ = UpdateZipEncodingStateAsync();
 		}
 
 		public void UpdateGitInfo(bool isGitRepository, string? repositoryPath, BranchItem? head)
@@ -164,5 +209,97 @@ public Task ExecuteDeleteBranch(string? branchName)
 		{
 			return GitHelpers.DeleteBranchAsync(_gitRepositoryPath, GitBranchDisplayName, branchName);
 		}
+
+		public async Task UpdateZipEncodingStateAsync()
+		{
+			var instanceVM = InstanceViewModel;
+			if (instanceVM is null)
+				return;
+
+			if (!instanceVM.IsPageTypeZipFolder)
+			{
+				IsZipEncodingSelectorVisible = false;
+				ZipStorageFolder.CurrentEncoding = null;
+				return;
+			}
+
+			var workingDir = ContentPageContext.ShellPage?.ShellViewModel.WorkingDirectory;
+			if (string.IsNullOrEmpty(workingDir) || !ZipStorageFolder.IsZipPath(workingDir))
+				return;
+
+			try
+			{
+				var isUndetermined = await StorageArchiveService.IsEncodingUndeterminedAsync(workingDir);
+				instanceVM.IsZipEncodingUndetermined = isUndetermined;
+
+				if (!isUndetermined)
+				{
+					IsZipEncodingSelectorVisible = false;
+					return;
+				}
+
+				var detected = await StorageArchiveService.DetectEncodingAsync(workingDir);
+				if (detected is not null)
+				{
+					instanceVM.ZipEncodingName = detected.WebName;
+					EncodingItem? ZipEncodingItem = ZipEncodingOptions.FirstOrDefault(e =>
+						e.Encoding?.WebName.Equals(detected.WebName, StringComparison.OrdinalIgnoreCase) == true);
+					if(ZipEncodingItem == null)
+					{
+						ZipEncodingItem = new EncodingItem(detected, detected.EncodingName);
+					}
+				    ZipEncodingOptions.Add(ZipEncodingItem);
+					SelectedZipEncoding = ZipEncodingItem;
+				}
+				else
+				{
+					instanceVM.ZipEncodingName = null;
+					SelectedZipEncoding = ZipEncodingOptions.FirstOrDefault(e => e.Encoding is null);
+				}
+
+				IsZipEncodingSelectorVisible = true;
+			}
+			catch (Exception ex)
+			{
+				App.Logger.LogError(ex, "Error checking zip encoding.");
+				IsZipEncodingSelectorVisible = false;
+			}
+		}
+
+		private async Task OnZipEncodingChangedAsync(EncodingItem encodingItem)
+		{
+			if (ContentPageContext.ShellPage is null)
+				return;
+
+			var workingDir = ContentPageContext.ShellPage.ShellViewModel.WorkingDirectory;
+			if (string.IsNullOrEmpty(workingDir))
+				return;
+
+			ZipStorageFolder.CurrentEncoding = encodingItem.Encoding;
+
+			ContentPageContext.ShellPage.ShellViewModel.RefreshItems(null);
+		}
+
+		internal void SubscribeToInstanceViewModel()
+		{
+			var instanceVM = InstanceViewModel;
+			if (instanceVM is not null)
+				instanceVM.PropertyChanged += OnInstanceViewModelPropertyChanged;
+		}
+
+		internal void UnsubscribeFromInstanceViewModel()
+		{
+			var instanceVM = InstanceViewModel;
+			if (instanceVM is not null)
+				instanceVM.PropertyChanged -= OnInstanceViewModelPropertyChanged;
+		}
+
+		private void OnInstanceViewModelPropertyChanged(object? sender, PropertyChangedEventArgs e)
+		{
+			if (e.PropertyName is nameof(CurrentInstanceViewModel.IsPageTypeZipFolder))
+			{
+				_ = UpdateZipEncodingStateAsync();
+			}
+		}
 	}
 }
diff --git a/src/Files.App/Services/Storage/StorageArchiveService.cs b/src/Files.App/Services/Storage/StorageArchiveService.cs
index 991519dc89ef..3ecd0a9dde89 100644
--- a/src/Files.App/Services/Storage/StorageArchiveService.cs
+++ b/src/Files.App/Services/Storage/StorageArchiveService.cs
@@ -361,7 +361,9 @@ public async Task<bool> IsEncodingUndeterminedAsync(string archiveFilePath)
 			{
 				using (ZipFile zipFile = new ZipFile(archiveFilePath))
 				{
-					return !zipFile.Cast<ZipEntry>().All(entry => entry.IsUnicodeText);
+					return !zipFile.Cast<ZipEntry>().All(
+						entry => entry.IsUnicodeText || entry.Name.All(c => char.IsAscii(c))
+					);
 				}
 			}
 			catch (Exception ex)
diff --git a/src/Files.App/UserControls/StatusBar.xaml b/src/Files.App/UserControls/StatusBar.xaml
index 95d7f9e32fde..510e0611f968 100644
--- a/src/Files.App/UserControls/StatusBar.xaml
+++ b/src/Files.App/UserControls/StatusBar.xaml
@@ -30,6 +30,7 @@
 			<ColumnDefinition />
 			<ColumnDefinition Width="Auto" />
 			<ColumnDefinition Width="Auto" />
+			<ColumnDefinition Width="Auto" />
 		</Grid.ColumnDefinitions>
 
 		<!--  Folder and selection info  -->
@@ -193,10 +194,57 @@
 				Background="{ThemeResource DividerStrokeColorDefaultBrush}" />
 		</StackPanel>
 
+		<!--  ZIP Encoding Selector  -->
+		<Button
+			x:Name="ZipEncodingSelector"
+			Grid.Column="2"
+			Height="24"
+			Padding="8,0,8,0"
+			Background="Transparent"
+			BorderBrush="Transparent"
+			ToolTipService.ToolTip="{helpers:ResourceString Name=Encoding}"
+			Visibility="{x:Bind StatusBarViewModel.IsZipEncodingSelectorVisible, Mode=OneWay}">
+
+			<!--  Encoding Name  -->
+			<TextBlock Text="{x:Bind StatusBarViewModel.SelectedZipEncoding.Name, Mode=OneWay, FallbackValue='', TargetNullValue=''}" />
+
+			<Button.Flyout>
+				<Flyout x:Name="ZipEncodingFlyout">
+					<Grid
+						Width="240"
+						Height="300"
+						Margin="-16">
+
+						<!--  Encodings List  -->
+						<ListView
+							x:Name="ZipEncodingList"
+							Padding="4"
+							Background="{ThemeResource CardBackgroundFillColorDefaultBrush}"
+							IsItemClickEnabled="True"
+							ItemClick="ZipEncodingList_ItemClick"
+							ItemsSource="{x:Bind StatusBarViewModel.ZipEncodingOptions, Mode=OneWay}"
+							SelectedItem="{x:Bind StatusBarViewModel.SelectedZipEncoding, Mode=TwoWay}"
+							SelectionMode="Single">
+
+							<ListView.ItemTemplate>
+								<DataTemplate x:DataType="data:EncodingItem">
+									<TextBlock
+										VerticalAlignment="Center"
+										Text="{x:Bind Name}"
+										TextTrimming="CharacterEllipsis" />
+								</DataTemplate>
+							</ListView.ItemTemplate>
+
+						</ListView>
+					</Grid>
+				</Flyout>
+			</Button.Flyout>
+		</Button>
+
 		<!--  Use visibility because it causes a crash to use a TwoWay x:Bind on an element that is inside an element with x:Load (#12589, #12599)  -->
 		<Button
 			x:Name="GitBranch"
-			Grid.Column="2"
+			Grid.Column="3"
 			Height="24"
 			Margin="4,0,0,0"
 			Padding="8,0,8,0"
diff --git a/src/Files.App/UserControls/StatusBar.xaml.cs b/src/Files.App/UserControls/StatusBar.xaml.cs
index 4c44d33d1cfa..e45dc3102742 100644
--- a/src/Files.App/UserControls/StatusBar.xaml.cs
+++ b/src/Files.App/UserControls/StatusBar.xaml.cs
@@ -60,6 +60,11 @@ private void BranchesList_ItemClick(object sender, ItemClickEventArgs e)
 			BranchesFlyout.Hide();
 		}
 
+		private void ZipEncodingList_ItemClick(object sender, ItemClickEventArgs e)
+		{
+			ZipEncodingFlyout.Hide();
+		}
+
 		private void BranchesFlyout_Closing(object _, object e)
 		{
 			if (StatusBarViewModel is null)
diff --git a/src/Files.App/Utils/Storage/StorageItems/ZipStorageFile.cs b/src/Files.App/Utils/Storage/StorageItems/ZipStorageFile.cs
index dff6b9dc7d93..58be04266bc9 100644
--- a/src/Files.App/Utils/Storage/StorageItems/ZipStorageFile.cs
+++ b/src/Files.App/Utils/Storage/StorageItems/ZipStorageFile.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using Files.Shared.Helpers;
+using ICSharpCode.SharpZipLib.Zip;
 using SevenZip;
 using System.IO;
 using System.Runtime.InteropServices.WindowsRuntime;
@@ -95,6 +96,9 @@ public static IAsyncOperation<BaseStorageFile> FromPathAsync(string path)
 
 		public override IAsyncOperation<IRandomAccessStream> OpenAsync(FileAccessMode accessMode)
 		{
+			if (ZipStorageFolder.CurrentEncoding is not null && Path != containerPath)
+				return OpenWithEncodingAsync(accessMode);
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.Wrap<IRandomAccessStream>(async () =>
 			{
 				bool rw = accessMode is FileAccessMode.ReadWrite;
@@ -136,11 +140,53 @@ public override IAsyncOperation<IRandomAccessStream> OpenAsync(FileAccessMode ac
 				throw new NotSupportedException("Can't open zip file as RW");
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
+		private IAsyncOperation<IRandomAccessStream> OpenWithEncodingAsync(FileAccessMode accessMode)
+		{
+			return AsyncInfo.Run((cancellationToken) =>
+			{
+				return Task.Run<IRandomAccessStream>(() =>
+				{
+					bool rw = accessMode is FileAccessMode.ReadWrite;
+					if (rw)
+						throw new NotSupportedException("Can't open zip file as RW");
+
+					using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(ZipStorageFolder.CurrentEncoding!));
+
+					if (!string.IsNullOrEmpty(Credentials.Password))
+						zipFile.Password = Credentials.Password;
+
+					var targetName = GetEntryRelativePath();
+
+					foreach (ZipEntry entry in zipFile)
+					{
+						if (!entry.IsFile)
+							continue;
+
+						if (string.Equals(entry.Name.Replace('\\', '/'), targetName, StringComparison.OrdinalIgnoreCase))
+						{
+							var ms = new MemoryStream();
+							using (var zipStream = zipFile.GetInputStream(entry))
+							{
+								zipStream.CopyTo(ms);
+							}
+							ms.Position = 0;
+							return new NonSeekableRandomAccessStreamForRead(ms, (ulong)entry.Size);
+						}
+					}
+
+					return null;
+				});
+			});
+		}
+
 		public override IAsyncOperation<IRandomAccessStream> OpenAsync(FileAccessMode accessMode, StorageOpenOptions options)
 			=> OpenAsync(accessMode);
 
 		public override IAsyncOperation<IRandomAccessStreamWithContentType> OpenReadAsync()
 		{
+			if (ZipStorageFolder.CurrentEncoding is not null && Path != containerPath)
+				return OpenReadWithEncodingAsync();
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.Wrap<IRandomAccessStreamWithContentType>(async () =>
 			{
 				if (Path == containerPath)
@@ -178,8 +224,47 @@ public override IAsyncOperation<IRandomAccessStreamWithContentType> OpenReadAsyn
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
 
+		private IAsyncOperation<IRandomAccessStreamWithContentType> OpenReadWithEncodingAsync()
+		{
+			return AsyncInfo.Run((cancellationToken) =>
+			{
+				return Task.Run<IRandomAccessStreamWithContentType>(() =>
+				{
+					using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(ZipStorageFolder.CurrentEncoding!));
+
+					if (!string.IsNullOrEmpty(Credentials.Password))
+						zipFile.Password = Credentials.Password;
+
+					var targetName = GetEntryRelativePath();
+
+					foreach (ZipEntry entry in zipFile)
+					{
+						if (!entry.IsFile)
+							continue;
+
+						if (string.Equals(entry.Name.Replace('\\', '/'), targetName, StringComparison.OrdinalIgnoreCase))
+						{
+							var ms = new MemoryStream();
+							using (var zipStream = zipFile.GetInputStream(entry))
+							{
+								zipStream.CopyTo(ms);
+							}
+							ms.Position = 0;
+							var nsStream = new NonSeekableRandomAccessStreamForRead(ms, (ulong)entry.Size);
+							return new StreamWithContentType(nsStream);
+						}
+					}
+
+					return null;
+				});
+			});
+		}
+
 		public override IAsyncOperation<IInputStream> OpenSequentialReadAsync()
 		{
+			if (ZipStorageFolder.CurrentEncoding is not null && Path != containerPath)
+				return OpenSequentialReadWithEncodingAsync();
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.Wrap<IInputStream>(async () =>
 			{
 				if (Path == containerPath)
@@ -215,6 +300,41 @@ public override IAsyncOperation<IInputStream> OpenSequentialReadAsync()
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
 
+		private IAsyncOperation<IInputStream> OpenSequentialReadWithEncodingAsync()
+		{
+			return AsyncInfo.Run((cancellationToken) =>
+			{
+				return Task.Run<IInputStream>(() =>
+				{
+					using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(ZipStorageFolder.CurrentEncoding!));
+
+					if (!string.IsNullOrEmpty(Credentials.Password))
+						zipFile.Password = Credentials.Password;
+
+					var targetName = GetEntryRelativePath();
+
+					foreach (ZipEntry entry in zipFile)
+					{
+						if (!entry.IsFile)
+							continue;
+
+						if (string.Equals(entry.Name.Replace('\\', '/'), targetName, StringComparison.OrdinalIgnoreCase))
+						{
+							var ms = new MemoryStream();
+							using (var zipStream = zipFile.GetInputStream(entry))
+							{
+								zipStream.CopyTo(ms);
+							}
+							ms.Position = 0;
+							return new NonSeekableRandomAccessStreamForRead(ms, (ulong)entry.Size);
+						}
+					}
+
+					return null;
+				});
+			});
+		}
+
 		public override IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync()
 			=> throw new NotSupportedException();
 		public override IAsyncOperation<StorageStreamTransaction> OpenTransactedWriteAsync(StorageOpenOptions options)
@@ -226,6 +346,9 @@ public override IAsyncOperation<BaseStorageFile> CopyAsync(IStorageFolder destin
 			=> CopyAsync(destinationFolder, desiredNewName, NameCollisionOption.FailIfExists);
 		public override IAsyncOperation<BaseStorageFile> CopyAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
 		{
+			if (ZipStorageFolder.CurrentEncoding is not null && Path != containerPath)
+				return CopyWithEncodingAsync(destinationFolder, desiredNewName, option);
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.Wrap<BaseStorageFile>(async () =>
 			{
 				using SevenZipExtractor zipFile = await OpenZipFileAsync();
@@ -264,8 +387,57 @@ await SafetyExtensions.WrapAsync(() => zipFile.ExtractFileAsync(entry.Index, out
 				}
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
+
+		private IAsyncOperation<BaseStorageFile> CopyWithEncodingAsync(IStorageFolder destinationFolder, string desiredNewName, NameCollisionOption option)
+		{
+			return AsyncInfo.Run(async (cancellationToken) =>
+			{
+				using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(ZipStorageFolder.CurrentEncoding!));
+
+				if (!string.IsNullOrEmpty(Credentials.Password))
+					zipFile.Password = Credentials.Password;
+
+				var targetName = GetEntryRelativePath();
+
+				foreach (ZipEntry entry in zipFile)
+				{
+					if (!entry.IsFile)
+						continue;
+
+					if (string.Equals(entry.Name.Replace('\\', '/'), targetName, StringComparison.OrdinalIgnoreCase))
+					{
+						var ms = new MemoryStream();
+						using (var zipStream = zipFile.GetInputStream(entry))
+						{
+							zipStream.CopyTo(ms);
+						}
+						ms.Position = 0;
+
+						var destFolder = destinationFolder.AsBaseStorageFolder();
+						if (destFolder is ICreateFileWithStream cwsf)
+						{
+							using var inStream = new NonSeekableRandomAccessStreamForRead(ms, (ulong)entry.Size);
+							return await cwsf.CreateFileAsync(inStream.AsStreamForRead(), desiredNewName, option.Convert());
+						}
+						else
+						{
+							var destFile = await destFolder.CreateFileAsync(desiredNewName, option.Convert());
+							await using var outStream = await destFile.OpenStreamForWriteAsync();
+							ms.Position = 0;
+							ms.CopyTo(outStream);
+							return destFile;
+						}
+					}
+				}
+
+				return null;
+			});
+		}
 		public override IAsyncAction CopyAndReplaceAsync(IStorageFile fileToReplace)
 		{
+			if (ZipStorageFolder.CurrentEncoding is not null && Path != containerPath)
+				return CopyAndReplaceWithEncodingAsync(fileToReplace);
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.WrapAsync(async () =>
 			{
 				using SevenZipExtractor zipFile = await OpenZipFileAsync();
@@ -288,6 +460,36 @@ public override IAsyncAction CopyAndReplaceAsync(IStorageFile fileToReplace)
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
 
+		private IAsyncAction CopyAndReplaceWithEncodingAsync(IStorageFile fileToReplace)
+		{
+			return AsyncInfo.Run(async (cancellationToken) =>
+			{
+				using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(ZipStorageFolder.CurrentEncoding!));
+
+				if (!string.IsNullOrEmpty(Credentials.Password))
+					zipFile.Password = Credentials.Password;
+
+				var targetName = GetEntryRelativePath();
+
+				foreach (ZipEntry entry in zipFile)
+				{
+					if (!entry.IsFile)
+						continue;
+
+					if (string.Equals(entry.Name.Replace('\\', '/'), targetName, StringComparison.OrdinalIgnoreCase))
+					{
+						using var hDestFile = fileToReplace.CreateSafeFileHandle(FileAccess.ReadWrite);
+						await using (var outStream = new FileStream(hDestFile, FileAccess.Write))
+						using (var zipStream = zipFile.GetInputStream(entry))
+						{
+							zipStream.CopyTo(outStream);
+						}
+						return;
+					}
+				}
+			});
+		}
+
 		public override IAsyncAction MoveAsync(IStorageFolder destinationFolder)
 			=> throw new NotSupportedException();
 		public override IAsyncAction MoveAsync(IStorageFolder destinationFolder, string desiredNewName)
@@ -399,6 +601,12 @@ public override IAsyncOperation<StorageItemThumbnail> GetThumbnailAsync(Thumbnai
 		public override IAsyncOperation<StorageItemThumbnail> GetThumbnailAsync(ThumbnailMode mode, uint requestedSize, ThumbnailOptions options)
 			=> Task.FromResult<StorageItemThumbnail>(null).AsAsyncOperation();
 
+		private string GetEntryRelativePath()
+		{
+			var relative = Path.Substring(containerPath.Length).Trim('\\', '/');
+			return relative.Replace('\\', '/');
+		}
+
 		private static bool CheckAccess(string path)
 		{
 			try
diff --git a/src/Files.App/Utils/Storage/StorageItems/ZipStorageFolder.cs b/src/Files.App/Utils/Storage/StorageItems/ZipStorageFolder.cs
index cca4acadd169..c413124c5315 100644
--- a/src/Files.App/Utils/Storage/StorageItems/ZipStorageFolder.cs
+++ b/src/Files.App/Utils/Storage/StorageItems/ZipStorageFolder.cs
@@ -2,10 +2,12 @@
 // Licensed under the MIT License.
 
 using Files.Shared.Helpers;
+using ICSharpCode.SharpZipLib.Zip;
 using SevenZip;
 using System.Collections.Concurrent;
 using System.IO;
 using System.Runtime.InteropServices.WindowsRuntime;
+using System.Text;
 using Windows.ApplicationModel;
 using Windows.Foundation;
 using Windows.Storage;
@@ -21,6 +23,12 @@ public sealed partial class ZipStorageFolder : BaseStorageFolder, ICreateFileWit
 		private readonly string containerPath;
 		private BaseStorageFile backingFile;
 
+		/// <summary>
+		/// Gets or sets the encoding to use when browsing ZIP files.
+		/// When set, SharpZipLib is used instead of SevenZipSharp.
+		/// </summary>
+		internal Encoding? CurrentEncoding { get; set; }
+
 		public override string Path { get; }
 		public override string Name { get; }
 		public override string DisplayName => Name;
@@ -170,6 +178,9 @@ public override IAsyncOperation<BaseBasicProperties> GetBasicPropertiesAsync()
 
 		public override IAsyncOperation<IStorageItem> GetItemAsync(string name)
 		{
+			if (CurrentEncoding is not null)
+				return GetItemWithEncodingAsync(name);
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.Wrap<IStorageItem>(async () =>
 			{
 				using SevenZipExtractor zipFile = await OpenZipFileAsync();
@@ -200,6 +211,59 @@ public override IAsyncOperation<IStorageItem> GetItemAsync(string name)
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
 
+		private IAsyncOperation<IStorageItem> GetItemWithEncodingAsync(string name)
+		{
+			return AsyncInfo.Run((cancellationToken) =>
+			{
+				return Task.Run<IStorageItem>(() =>
+				{
+					using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(CurrentEncoding!));
+
+					if (!string.IsNullOrEmpty(Credentials.Password))
+						zipFile.Password = Credentials.Password;
+
+					var targetPath = System.IO.Path.Combine(Path, name);
+					var normalizedTarget = targetPath.TrimEnd('\\', '/');
+					bool foundChild = false;
+
+					foreach (ZipEntry entry in zipFile)
+					{
+						var entryPath = System.IO.Path.Combine(System.IO.Path.GetFullPath(containerPath), entry.Name.Replace("/", "\\"));
+						var normalizedEntry = entryPath.TrimEnd('\\', '/');
+
+						if (normalizedEntry == normalizedTarget)
+						{
+							if (entry.IsDirectory)
+							{
+								var folder = new ZipStorageFolder(targetPath, containerPath, backingFile);
+								((IPasswordProtectedItem)folder).CopyFrom(this);
+								return folder;
+							}
+							else
+							{
+								var file = new ZipStorageFile(targetPath, containerPath, backingFile);
+								((IPasswordProtectedItem)file).CopyFrom(this);
+								return file;
+							}
+						}
+
+						if (!foundChild && normalizedEntry.StartsWith(normalizedTarget + "\\", StringComparison.OrdinalIgnoreCase))
+							foundChild = true;
+					}
+
+					// No exact match found; check if target is an implicit directory
+					if (foundChild)
+					{
+						var folder = new ZipStorageFolder(targetPath, containerPath, backingFile);
+						((IPasswordProtectedItem)folder).CopyFrom(this);
+						return folder;
+					}
+
+					return null;
+				});
+			});
+		}
+
 		public override IAsyncOperation<IStorageItem> TryGetItemAsync(string name)
 		{
 			return AsyncInfo.Run(async (cancellationToken) =>
@@ -216,6 +280,9 @@ public override IAsyncOperation<IStorageItem> TryGetItemAsync(string name)
 		}
 		public override IAsyncOperation<IReadOnlyList<IStorageItem>> GetItemsAsync()
 		{
+			if (CurrentEncoding is not null)
+				return GetItemsWithEncodingAsync();
+
 			return AsyncInfo.Run((cancellationToken) => SafetyExtensions.Wrap<IReadOnlyList<IStorageItem>>(async () =>
 			{
 				using SevenZipExtractor zipFile = await OpenZipFileAsync();
@@ -255,6 +322,54 @@ public override IAsyncOperation<IReadOnlyList<IStorageItem>> GetItemsAsync()
 				return items;
 			}, ((IPasswordProtectedItem)this).RetryWithCredentialsAsync));
 		}
+
+		private IAsyncOperation<IReadOnlyList<IStorageItem>> GetItemsWithEncodingAsync()
+		{
+			return AsyncInfo.Run((cancellationToken) =>
+			{
+				return Task.Run<IReadOnlyList<IStorageItem>>(() =>
+				{
+					using var zipFile = new ZipFile(containerPath, StringCodec.FromEncoding(CurrentEncoding!));
+
+					if (!string.IsNullOrEmpty(Credentials.Password))
+						zipFile.Password = Credentials.Password;
+
+					var items = new List<IStorageItem>();
+					var dirPaths = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
+					var dirPrefix = Path.WithEnding("\\");
+
+					foreach (ZipEntry entry in zipFile)
+					{
+						string winPath = System.IO.Path.Combine(System.IO.Path.GetFullPath(containerPath), entry.Name.Replace("/", "\\"));
+						if (!winPath.StartsWith(dirPrefix, StringComparison.Ordinal))
+							continue;
+
+						var split = winPath.Substring(Path.Length).Split('\\', StringSplitOptions.RemoveEmptyEntries);
+						if (split.Length <= 0)
+							continue;
+
+						if (entry.IsDirectory || split.Length > 1) // Not all folders have a ZipEntry
+						{
+							var itemPath = System.IO.Path.Combine(Path, split[0]);
+							if (!items.Any(x => x.Path == itemPath))
+							{
+								var folder = new ZipStorageFolder(itemPath, containerPath, backingFile);
+								((IPasswordProtectedItem)folder).CopyFrom(this);
+								items.Add(folder);
+							}
+						}
+						else
+						{
+							var file = new ZipStorageFile(winPath, containerPath, backingFile);
+							((IPasswordProtectedItem)file).CopyFrom(this);
+							items.Add(file);
+						}
+						
+					}
+					return items;
+				});
+			});
+		}
 		public override IAsyncOperation<IReadOnlyList<IStorageItem>> GetItemsAsync(uint startIndex, uint maxItemsToRetrieve)
 			=> AsyncInfo.Run<IReadOnlyList<IStorageItem>>(async (cancellationToken)
 				=> (await GetItemsAsync()).Skip((int)startIndex).Take((int)maxItemsToRetrieve).ToList()