diff --git a/CollapseLauncher/Classes/Helper/WindowUtility.cs b/CollapseLauncher/Classes/Helper/WindowUtility.cs
index 9e98f6314..4a09ee582 100644
--- a/CollapseLauncher/Classes/Helper/WindowUtility.cs
+++ b/CollapseLauncher/Classes/Helper/WindowUtility.cs
@@ -56,6 +56,7 @@ internal enum WindowBackdropKind
     internal static class WindowUtility
     {
         private static event EventHandler<RectInt32[]>? DragAreaChangeEvent;
+        internal static event Action<string[], PointInt32>? FileDropEvent;
 
         private static nint _oldMainWndProcPtr;
         private static nint _oldDesktopSiteBridgeWndProcPtr;
@@ -417,6 +418,52 @@ internal static void RegisterWindow(this Window window)
             FileDialogNative.InitHandlerPointer(CurrentWindowPtr);
         }
 
+        internal static void SetFileDropEnabled(bool isEnabled)
+        {
+            const uint WM_COPYDATA       = 0x004A;
+            const uint WM_COPYGLOBALDATA = 0x0049;
+            const uint WM_DROPFILES      = 0x0233;
+            const uint MSGFLT_RESET      = 0;
+            const uint MSGFLT_ALLOW      = 1;
+
+            nint windowHandle = CurrentWindowPtr;
+            if (windowHandle == nint.Zero)
+            {
+                return;
+            }
+
+            uint messageFilterAction = isEnabled ? MSGFLT_ALLOW : MSGFLT_RESET;
+            PInvoke.ChangeWindowMessageFilterEx(windowHandle, WM_DROPFILES,      messageFilterAction, nint.Zero);
+            PInvoke.ChangeWindowMessageFilterEx(windowHandle, WM_COPYDATA,       messageFilterAction, nint.Zero);
+            PInvoke.ChangeWindowMessageFilterEx(windowHandle, WM_COPYGLOBALDATA, messageFilterAction, nint.Zero);
+            PInvoke.DragAcceptFiles(windowHandle, isEnabled);
+        }
+
+        internal static bool TryGetExternalDragPosition(out PointInt32 dragPosition)
+        {
+            const int VK_LBUTTON = 0x01;
+            const int VK_RBUTTON = 0x02;
+            const int KeyPressed = 0x8000;
+
+            dragPosition = default;
+            nint windowHandle = CurrentWindowPtr;
+            if (windowHandle == nint.Zero)
+            {
+                return false;
+            }
+
+            bool isMouseButtonPressed = (PInvoke.GetAsyncKeyState(VK_LBUTTON) & KeyPressed) != 0 ||
+                                        (PInvoke.GetAsyncKeyState(VK_RBUTTON) & KeyPressed) != 0;
+            if (!isMouseButtonPressed || !PInvoke.GetCursorPos(out POINTL cursorPosition))
+            {
+                return false;
+            }
+
+            PInvoke.ScreenToClient(windowHandle, ref cursorPosition);
+            dragPosition = new PointInt32(cursorPosition.x, cursorPosition.y);
+            return true;
+        }
+
         #region Drag Area Handler
 
         private static void InstallDragAreaChangeMonitor()
@@ -496,6 +543,7 @@ private static nint MainWndProc(nint hwnd, uint msg, nuint wParam, nint lParam)
             const uint WM_ACTIVATE        = 0x0006;
             const uint WM_QUERYENDSESSION = 0x0011;
             const uint WM_ENDSESSION      = 0x0016;
+            const uint WM_DROPFILES       = 0x0233;
 
             switch (msg)
             {
@@ -643,6 +691,21 @@ private static nint MainWndProc(nint hwnd, uint msg, nuint wParam, nint lParam)
                         (CurrentWindow as MainWindow)?.CloseApp();
                     }
                     break;
+                case WM_DROPFILES:
+                    if (NativeFileDrop.TryHandleFileDrop((nint)wParam,
+                                                         out string[]? files,
+                                                         out POINTL dropPoint,
+                                                         out Exception? ex))
+                    {
+                        FileDropEvent?.Invoke(files, new PointInt32(dropPoint.x, dropPoint.y));
+                    }
+
+                    if (ex != null)
+                    {
+                        ErrorSender.SendException(ex);
+                        SentryHelper.ExceptionHandler(ex);
+                    }
+                    return 0;
             }
 
             return PInvoke.CallWindowProc(_oldMainWndProcPtr, hwnd, msg, wParam, lParam);
diff --git a/CollapseLauncher/Classes/Plugins/PluginImporter.cs b/CollapseLauncher/Classes/Plugins/PluginImporter.cs
index b8f3b496b..50b908ca8 100644
--- a/CollapseLauncher/Classes/Plugins/PluginImporter.cs
+++ b/CollapseLauncher/Classes/Plugins/PluginImporter.cs
@@ -1,5 +1,6 @@
 using Hi3Helper.Plugin.Core.Update;
 using Hi3Helper.Shared.Region;
+using CollapseLauncher.Helper.StreamUtility;
 using System;
 using System.Data;
 using System.IO;
@@ -15,6 +16,14 @@ internal static partial class PluginImporter
     public static async Task<PluginInfo> AutoGetImportFromPath(string filePath, CancellationToken token)
     {
         bool isFromPackage = filePath.EndsWith(".zip", StringComparison.OrdinalIgnoreCase);
+        bool isFromManifest = string.Equals(Path.GetFileName(filePath),
+                                            PluginManager.ManifestPrefix,
+                                            StringComparison.OrdinalIgnoreCase);
+
+        if (!isFromPackage && !isFromManifest)
+        {
+            throw new NotSupportedException($"{Path.GetFileName(filePath)} is not supported. Import a .zip package or a file named manifest.json.");
+        }
 
         using IPluginSource pluginSource = isFromPackage ?
             await ZipPluginSource.GetSourceFrom(filePath, token) :
@@ -24,6 +33,7 @@ await ZipPluginSource.GetSourceFrom(filePath, token) :
         string pluginDirName       = $"Hi3Helper.Plugin.{pluginExecNameNoExt}";
         string pluginBaseDir       = Path.Combine(LauncherConfig.AppPluginFolder, pluginDirName);
         string pluginRelName       = Path.Combine(pluginDirName, pluginSource.Manifest.MainLibraryName);
+        string pluginEntryPath     = GetContainedPath(pluginBaseDir, pluginSource.Manifest.MainLibraryName);
 
         if (PluginManager.PluginInstances.ContainsKey(pluginBaseDir) ||
             PluginManager.PluginInstances.Values
@@ -44,25 +54,64 @@ await ZipPluginSource.GetSourceFrom(filePath, token) :
             });
         }
 
-        string pluginEntryPath = Path.Combine(pluginBaseDir, pluginSource.Manifest.MainLibraryName);
-        foreach (PluginManifestAssetInfo asset in pluginSource.Manifest.Assets)
+        Directory.CreateDirectory(LauncherConfig.AppPluginFolder);
+        string stagingDir = Path.Combine(LauncherConfig.AppPluginFolder, $".import-{Guid.NewGuid():N}");
+        string cleanupDir = stagingDir;
+
+        try
         {
-            string  assetFullPath = Path.Combine(pluginBaseDir, asset.FilePath);
-            string? assetFullDir  = Path.GetDirectoryName(assetFullPath);
+            foreach (PluginManifestAssetInfo asset in pluginSource.Manifest.Assets)
+            {
+                string  assetFullPath = GetContainedPath(stagingDir, asset.FilePath);
+                string? assetFullDir  = Path.GetDirectoryName(assetFullPath);
+
+                if (!string.IsNullOrEmpty(assetFullDir))
+                {
+                    Directory.CreateDirectory(assetFullDir);
+                }
+
+                await using FileStream assetStream             = File.Create(assetFullPath);
+                await using Stream     assetPluginSourceStream = await pluginSource.GetAssetStream(asset, token);
+
+                await assetPluginSourceStream.CopyToAsync(assetStream, token);
+            }
+
+            Directory.Move(stagingDir, pluginBaseDir);
+            cleanupDir = pluginBaseDir;
 
-            if (!string.IsNullOrEmpty(assetFullDir))
+            PluginInfo pluginInfo = new(pluginEntryPath,
+                                         pluginRelName,
+                                         pluginSource.Manifest);
+            cleanupDir = string.Empty;
+            return pluginInfo;
+        }
+        catch
+        {
+            if (!string.IsNullOrEmpty(cleanupDir))
             {
-                Directory.CreateDirectory(assetFullDir);
+                new DirectoryInfo(cleanupDir).TryDeleteDirectory(true);
             }
 
-            await using FileStream assetStream             = File.Create(assetFullPath);
-            await using Stream     assetPluginSourceStream = await pluginSource.GetAssetStream(asset, token);
+            throw;
+        }
+    }
+
+    private static string GetContainedPath(string baseDirectory, string relativePath)
+    {
+        if (string.IsNullOrWhiteSpace(relativePath))
+        {
+            throw new InvalidDataException("The plugin manifest contains an empty file path.");
+        }
 
-            await assetPluginSourceStream.CopyToAsync(assetStream, token);
+        string baseFullPath = Path.TrimEndingDirectorySeparator(Path.GetFullPath(baseDirectory));
+        string fileFullPath = Path.GetFullPath(relativePath, baseFullPath);
+        string basePrefix   = baseFullPath + Path.DirectorySeparatorChar;
+
+        if (!fileFullPath.StartsWith(basePrefix, StringComparison.OrdinalIgnoreCase))
+        {
+            throw new InvalidDataException($"The plugin manifest path '{relativePath}' points outside the plugin directory.");
         }
 
-        return new PluginInfo(pluginEntryPath,
-                              pluginRelName,
-                              pluginSource.Manifest);
+        return fileFullPath;
     }
 }
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.Background.cs b/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.Background.cs
index 126c7a41c..e238a62fd 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.Background.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.Background.cs
@@ -148,8 +148,8 @@ private bool IsInMultiBackgroundPipsPagerGridHoverArea(PointerRoutedEventArgs? a
         }
         else
         {
-            PInvoke.GetCursorPos(out pointerPos).ThrowOnFailure();
-            PInvoke.ScreenToClient(WindowUtility.CurrentWindowPtr, ref pointerPos).ThrowOnFailure();
+            PInvoke.GetCursorPos(out pointerPos);
+            PInvoke.ScreenToClient(WindowUtility.CurrentWindowPtr, ref pointerPos);
         }
 
         double xFrom = gridPos.X;
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml b/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml
index 249ce132e..d3e2c4773 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml
@@ -823,12 +823,17 @@
                 </ResourceDictionary>
             </Grid.Resources>
             <Button x:Name="ImportBoxButton"
+                    AllowDrop="True"
                     HorizontalAlignment="Stretch"
                     VerticalAlignment="Stretch"
                     extension:UIElementExtensions.CursorType="Hand"
                     Background="{StaticResource ImportBoxButtonBackground}"
                     Click="OnClickImportButton"
-                    CornerRadius="20">
+                    CornerRadius="20"
+                    DragEnter="OnDragEnterImportBox"
+                    DragLeave="OnDragLeaveImportBox"
+                    DragOver="OnDragOverImportBox"
+                    Drop="OnDropImportBox">
                 <interactivity:Interaction.Behaviors>
                     <interactivity:EventTriggerBehavior EventName="PointerEntered">
                         <behaviors:StartAnimationAction Animation="{x:Bind ImportBoxPlusGridEnterAnimation}" />
@@ -906,7 +911,7 @@
                             </animations:AnimationSet>
                         </animations:Explicit.Animations>
 
-                        <FontIcon FontSize="48z"
+                        <FontIcon FontSize="48"
                                   Glyph="&#xE710;" />
                     </Button>
                     <StackPanel Grid.Row="1"
@@ -938,6 +943,24 @@
                     </StackPanel>
                 </Grid>
             </Button>
+            <Grid x:Name="ImportDropIndicator"
+                  IsHitTestVisible="False"
+                  Opacity="0">
+                <Grid.OpacityTransition>
+                    <ScalarTransition Duration="0:0:.18" />
+                </Grid.OpacityTransition>
+                <Border Margin="3"
+                        Background="{ThemeResource AccentFillColorDefaultBrush}"
+                        CornerRadius="17"
+                        Opacity=".08" />
+                <Rectangle Margin="2"
+                           RadiusX="18"
+                           RadiusY="18"
+                           Stroke="{ThemeResource AccentColor}"
+                           StrokeDashArray="1,2"
+                           StrokeDashCap="Round"
+                           StrokeThickness="3" />
+            </Grid>
         </Grid>
         <Button x:Name="OpenPluginCatalogBottomLeftButton"
                 Grid.Column="0"
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs
index 6313bfe88..6733815ec 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/PluginManagerPage.xaml.cs
@@ -1,7 +1,9 @@
 using CollapseLauncher.Dialogs;
 using CollapseLauncher.Helper;
+using CollapseLauncher.XAMLs.Theme.ContentDialog;
 using CollapseLauncher.Plugins;
 using Hi3Helper;
+using Hi3Helper.LocaleSourceGen;
 using Hi3Helper.SentryHelper;
 using Hi3Helper.Win32.FileDialogCOM;
 using Microsoft.UI.Xaml;
@@ -9,10 +11,16 @@
 using Microsoft.UI.Xaml.Input;
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Windows.ApplicationModel.DataTransfer;
+using Windows.Foundation;
+using Windows.Graphics;
+using Windows.Storage;
 // ReSharper disable CheckNamespace
 
 #nullable enable
@@ -23,10 +31,36 @@ public sealed partial class PluginManagerPage
         public static PluginManagerPageContext Context { get; }              = new();
         public static PluginManagerPage        This    { get; private set; } = null!;
 
+        private readonly DispatcherTimer _fileDragIndicatorTimer = new()
+        {
+            Interval = TimeSpan.FromMilliseconds(50)
+        };
+        private bool _isWinUiFileDragActive;
+        private bool _isDropIndicatorVisible;
+
         public PluginManagerPage()
         {
             This = this;
             InitializeComponent();
+            _fileDragIndicatorTimer.Tick += OnFileDragIndicatorTimerTick;
+            Loaded += OnPluginManagerPageLoaded;
+            Unloaded += OnPluginManagerPageUnloaded;
+        }
+
+        private void OnPluginManagerPageLoaded(object sender, RoutedEventArgs e)
+        {
+            WindowUtility.FileDropEvent += OnNativeFileDrop;
+            WindowUtility.SetFileDropEnabled(true);
+            _fileDragIndicatorTimer.Start();
+        }
+
+        private void OnPluginManagerPageUnloaded(object sender, RoutedEventArgs e)
+        {
+            _fileDragIndicatorTimer.Stop();
+            _isWinUiFileDragActive = false;
+            SetImportDropIndicator(false);
+            WindowUtility.SetFileDropEnabled(false);
+            WindowUtility.FileDropEvent -= OnNativeFileDrop;
         }
 
         private void OnListViewRightClickUpdate(object sender, RightTappedRoutedEventArgs e)
@@ -63,10 +97,8 @@ private void OnRestoreUninstalledPlugin(object sender, RoutedEventArgs e)
 
         private async void OnClickImportButton(object sender, RoutedEventArgs e)
         {
-            int imported = 0;
             try
             {
-                ImportBoxButton.IsEnabled = false;
                 Dictionary<string, string> supportedFiles = new()
                 {
                     { Locale.Current.Lang?._PluginManagerPage?.FileDialogFileFilter1 ?? "", "*.zip;manifest.json" }
@@ -79,7 +111,129 @@ private async void OnClickImportButton(object sender, RoutedEventArgs e)
                     return;
                 }
 
-                List<Exception> exceptions = [];
+                await ImportPlugins(selectedFiles);
+            }
+            catch (Exception ex)
+            {
+                ErrorSender.SendException(ex.WrapPluginException(Locale.Current.Lang?._PluginManagerPage?.Error_NoPluginImported));
+            }
+        }
+
+        private void OnDragEnterImportBox(object sender, DragEventArgs e)
+        {
+            if (ImportBoxButton.IsEnabled && e.DataView.Contains(StandardDataFormats.StorageItems))
+            {
+                _isWinUiFileDragActive = true;
+                SetImportDropIndicator(true);
+                e.AcceptedOperation = DataPackageOperation.Copy;
+            }
+        }
+
+        private void OnDragLeaveImportBox(object sender, DragEventArgs e)
+        {
+            Point position = e.GetPosition(ImportBoxButton);
+            if (position.X >= 0 && position.X <= ImportBoxButton.ActualWidth &&
+                position.Y >= 0 && position.Y <= ImportBoxButton.ActualHeight)
+            {
+                return;
+            }
+
+            _isWinUiFileDragActive = false;
+            SetImportDropIndicator(false);
+        }
+
+        private void OnDragOverImportBox(object sender, DragEventArgs e)
+        {
+            if (ImportBoxButton.IsEnabled && e.DataView.Contains(StandardDataFormats.StorageItems))
+            {
+                _isWinUiFileDragActive = true;
+                SetImportDropIndicator(true);
+                e.AcceptedOperation = DataPackageOperation.Copy;
+            }
+        }
+
+        private async void OnDropImportBox(object sender, DragEventArgs e)
+        {
+            try
+            {
+                _isWinUiFileDragActive = false;
+                SetImportDropIndicator(false);
+
+                IReadOnlyList<IStorageItem> storageItems = await e.DataView.GetStorageItemsAsync();
+                string[] selectedFiles = [.. storageItems.OfType<StorageFile>().Select(file => file.Path)];
+                await ImportPlugins(selectedFiles);
+            }
+            catch (Exception ex)
+            {
+                ErrorSender.SendException(ex.WrapPluginException(Locale.Current.Lang?._PluginManagerPage?.Error_NoPluginImported));
+            }
+        }
+
+        private async void OnNativeFileDrop(string[] selectedFiles, PointInt32 dropPoint)
+        {
+            try
+            {
+                _isWinUiFileDragActive = false;
+                SetImportDropIndicator(false);
+
+                if (!IsPointInDropArea(dropPoint))
+                {
+                    return;
+                }
+
+                await ImportPlugins(selectedFiles);
+            }
+            catch (Exception ex)
+            {
+                ErrorSender.SendException(ex);
+            }
+        }
+
+        private void OnFileDragIndicatorTimerTick(object? sender, object e)
+        {
+            bool isExternalDragOverDropArea =
+                WindowUtility.TryGetExternalDragPosition(out PointInt32 dragPosition) &&
+                IsPointInDropArea(dragPosition);
+            SetImportDropIndicator(_isWinUiFileDragActive || isExternalDragOverDropArea);
+        }
+
+        private bool IsPointInDropArea(PointInt32 point)
+        {
+            Rect dropAreaBounds = ImportBoxButton.TransformToVisual(null)
+                                                     .TransformBounds(new Rect(0,
+                                                                               0,
+                                                                               ImportBoxButton.ActualWidth,
+                                                                               ImportBoxButton.ActualHeight));
+            double scaleFactor = WindowUtility.CurrentWindowMonitorScaleFactor;
+            return point.X >= dropAreaBounds.Left * scaleFactor &&
+                   point.X <= dropAreaBounds.Right * scaleFactor &&
+                   point.Y >= dropAreaBounds.Top * scaleFactor &&
+                   point.Y <= dropAreaBounds.Bottom * scaleFactor;
+        }
+
+        private void SetImportDropIndicator(bool isVisible)
+        {
+            if (_isDropIndicatorVisible == isVisible)
+            {
+                return;
+            }
+
+            _isDropIndicatorVisible = isVisible;
+            ImportDropIndicator.Opacity = isVisible ? 1 : 0;
+        }
+
+        private async Task ImportPlugins(string[] selectedFiles)
+        {
+            if (selectedFiles.Length == 0)
+            {
+                return;
+            }
+
+            int imported = 0;
+            List<(string FilePath, Exception Exception)> failures = [];
+            try
+            {
+                ImportBoxButton.IsEnabled = false;
 
                 foreach (string filePath in selectedFiles)
                 {
@@ -91,27 +245,54 @@ private async void OnClickImportButton(object sender, RoutedEventArgs e)
                     }
                     catch (Exception exception)
                     {
-                        exceptions.Add(exception);
+                        failures.Add((filePath, exception));
+                        Logger.LogWriteLine($"[PluginManagerPage::ImportPlugins] Failed to import: {filePath}\r\n{exception}",
+                                            LogType.Error,
+                                            true);
                     }
                 }
-
-                if (exceptions.Count > 0)
-                {
-                    throw new AggregateException(exceptions);
-                }
-            }
-            catch (Exception ex)
-            {
-                string messageHead = imported > 0 ?
-                    $"{imported} plugin(s) have been imported! But some error has occurred while importing other plugins:" :
-                    "No plugin has been imported due to following error:";
-
-                ErrorSender.SendException(ex.WrapPluginException(messageHead));
             }
             finally
             {
                 ImportBoxButton.IsEnabled = true;
             }
+
+            if (failures.Count == 0)
+            {
+                return;
+            }
+
+            string messageHead = imported > 0 ?
+                $"{imported} plugin(s) were imported, but {failures.Count} file(s) could not be imported:" :
+                "No plugins were imported:";
+            string failureMessages = string.Join(Environment.NewLine,
+                                                 failures.Select(failure =>
+                                                     $"- {Path.GetFileName(failure.FilePath)}: {GetFriendlyImportError(failure.FilePath, failure.Exception)}"));
+
+            string warningMessage = $"{messageHead}{Environment.NewLine}{Environment.NewLine}{failureMessages}";
+            await SimpleDialogs.SpawnDialog(Locale.Current.Lang?._UnhandledExceptionPage?.UnhandledTitle4 ?? "Warning",
+                                            warningMessage,
+                                            ImportBoxButton,
+                                            Locale.Current.Lang?._Misc?.Close,
+                                            dialogTheme: ContentDialogTheme.Warning);
+        }
+
+        private static string? GetFriendlyImportError(string filePath, Exception exception)
+        {
+            LangParamsPluginManagerPage? locale    = Locale.Current.Lang?._PluginManagerPage;
+            bool                         isFileZip = filePath.EndsWith(".zip", StringComparison.OrdinalIgnoreCase);
+
+            return exception switch
+            {
+                NotSupportedException       => exception.Message,
+                DuplicateNameException      => exception.Message,
+                UnauthorizedAccessException => locale?.Error_AccessDeniedPluginInstall,
+                FileNotFoundException       => locale?.Error_PluginPackageMissingManifest,
+                InvalidDataException        => locale?.Error_PluginPackageInvalidManifest,
+                IOException when isFileZip  => locale?.Error_IOErrorCannotBeInstalled,
+                IOException                 => locale?.Error_IOErrorCannotBeRead,
+                _                           => locale?.Error_PluginNotSupportedOrInvalid
+            };
         }
 
         internal static async void AskLauncherRestart(object? sender, RoutedEventArgs? e)
diff --git a/Hi3Helper.Core/Lang/en_US.json b/Hi3Helper.Core/Lang/en_US.json
index 271407c0d..525a17dec 100644
--- a/Hi3Helper.Core/Lang/en_US.json
+++ b/Hi3Helper.Core/Lang/en_US.json
@@ -837,10 +837,18 @@
     "ListViewFooterWarning1": "You need to restart your launcher in order to apply the changes!",
     "ListViewFooterRestartButton": "Restart the Launcher",
 
-    "RightPanelImportTitle1": "Click to add the",
+    "RightPanelImportTitle1": "Click to Browse or drop a",
     "RightPanelImportTitle2": "or",
-    "RightPanelImportTitle3": "here",
-    "RightPanelImportTitle4": "Anywhere in the box is fine!"
+    "RightPanelImportTitle3": "",
+    "RightPanelImportTitle4": "Drop plugin files anywhere in this panel",
+
+    "Error_NoPluginImported": "No plugin has been imported due to following error:",
+    "Error_AccessDeniedPluginInstall": "Permission was denied while reading or installing the plugin.",
+    "Error_PluginPackageMissingManifest": "The package is missing its manifest or another required file.",
+    "Error_PluginPackageInvalidManifest": "The archive or manifest is invalid.",
+    "Error_IOErrorCannotBeInstalled": "The archive could not be read or installed.",
+    "Error_IOErrorCannotBeRead": "The manifest or one of its referenced files could not be read.",
+    "Error_PluginNotSupportedOrInvalid": "The file is not a valid or supported plugin."
   },
 
   "_Misc": {
diff --git a/Hi3Helper.Win32 b/Hi3Helper.Win32
index 70f0dc24b..10be369e1 160000
--- a/Hi3Helper.Win32
+++ b/Hi3Helper.Win32
@@ -1 +1 @@
-Subproject commit 70f0dc24bc480f5e7b7dca003d4c4d42806eeb02
+Subproject commit 10be369e176e0127a886d89d3a6edb491911da31