diff --git a/CollapseLauncher/Classes/FileMigrationProcess/Events.cs b/CollapseLauncher/Classes/FileMigrationProcess/Events.cs
new file mode 100644
index 000000000..6c0802e75
--- /dev/null
+++ b/CollapseLauncher/Classes/FileMigrationProcess/Events.cs
@@ -0,0 +1,67 @@
+using Hi3Helper;
+using Hi3Helper.Data;
+using System;
+using System.Threading.Tasks;
+
+namespace CollapseLauncher
+{
+    internal partial class FileMigrationProcess
+    {
+        private void UpdateCountProcessed(FileMigrationProcessUIRef uiRef, string currentPathProcessed)
+        {
+            lock (this) { this.CurrentFileCountMoved++; }
+
+            string fileCountProcessedString = string.Format(Locale.Lang._Misc.PerFromTo,
+                this.CurrentFileCountMoved,
+                this.TotalFileCount);
+
+            lock (uiRef.fileCountIndicatorSubtitle)
+            {
+                this.parentUI.DispatcherQueue.TryEnqueue(() =>
+                {
+                    uiRef.fileCountIndicatorSubtitle.Text = fileCountProcessedString;
+                    uiRef.pathActivitySubtitle.Text = currentPathProcessed;
+                });
+            }
+        }
+
+        private async void UpdateSizeProcessed(FileMigrationProcessUIRef uiRef, long currentRead)
+        {
+            lock (this) { this.CurrentSizeMoved += currentRead; }
+
+            if (await CheckIfNeedRefreshStopwatch())
+            {
+                double percentage = Math.Round((double)this.CurrentSizeMoved / this.TotalFileSize * 100d, 2);
+                double speed = this.CurrentSizeMoved / this.ProcessStopwatch.Elapsed.TotalSeconds;
+
+                lock (uiRef.progressBarIndicator)
+                {
+                    this.parentUI.DispatcherQueue.TryEnqueue(() =>
+                    {
+                        string speedString = string.Format(Locale.Lang._Misc.SpeedPerSec, ConverterTool.SummarizeSizeSimple(speed));
+                        string sizeProgressString = string.Format(Locale.Lang._Misc.PerFromTo,
+                            ConverterTool.SummarizeSizeSimple(this.CurrentSizeMoved),
+                            ConverterTool.SummarizeSizeSimple(this.TotalFileSize));
+
+                        uiRef.speedIndicatorSubtitle.Text = speedString;
+                        uiRef.fileSizeIndicatorSubtitle.Text = sizeProgressString;
+                        uiRef.progressBarIndicator.Value = percentage;
+                        uiRef.progressBarIndicator.IsIndeterminate = false;
+                    });
+                }
+            }
+        }
+
+        private async ValueTask<bool> CheckIfNeedRefreshStopwatch()
+        {
+            if (this.EventsStopwatch.ElapsedMilliseconds > _refreshInterval)
+            {
+                this.EventsStopwatch.Restart();
+                return true;
+            }
+
+            await Task.Delay(_refreshInterval);
+            return false;
+        }
+    }
+}
diff --git a/CollapseLauncher/Classes/FileMigrationProcess/FileMigrationProcess.cs b/CollapseLauncher/Classes/FileMigrationProcess/FileMigrationProcess.cs
new file mode 100644
index 000000000..a431c299b
--- /dev/null
+++ b/CollapseLauncher/Classes/FileMigrationProcess/FileMigrationProcess.cs
@@ -0,0 +1,160 @@
+using Microsoft.UI.Xaml;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CollapseLauncher
+{
+    internal partial class FileMigrationProcess
+    {
+        private const int _refreshInterval = 100; // 100ms UI refresh interval
+
+        private string dialogTitle { get; set; }
+        private string inputPath { get; set; }
+        private string outputPath { get; set; }
+        private bool isFileTransfer { get; set; }
+        private UIElement parentUI { get; set; }
+        private CancellationTokenSource tokenSource { get; set; }
+
+        private long CurrentSizeMoved;
+        private long CurrentFileCountMoved;
+        private long TotalFileSize;
+        private long TotalFileCount;
+        private bool IsSameOutputDrive;
+        private Stopwatch ProcessStopwatch;
+        private Stopwatch EventsStopwatch;
+
+        private FileMigrationProcess(UIElement parentUI, string dialogTitle, string inputPath, string outputPath, bool isFileTransfer, CancellationTokenSource tokenSource)
+        {
+            this.dialogTitle = dialogTitle;
+            this.inputPath = inputPath;
+            this.outputPath = outputPath;
+            this.isFileTransfer = isFileTransfer;
+            this.parentUI = parentUI;
+            this.tokenSource = tokenSource;
+        }
+
+        internal async Task<string> StartRoutine()
+        {
+            bool isSuccess = false;
+            this.CurrentSizeMoved = 0;
+            this.CurrentFileCountMoved = 0;
+            this.TotalFileSize = 0;
+            this.TotalFileCount = 0;
+            FileMigrationProcessUIRef? uiRef = null;
+
+            try
+            {
+                if (!await IsOutputPathSpaceSufficient(this.inputPath, this.outputPath))
+                    throw new OperationCanceledException($"Disk space is not sufficient. Cancelling!");
+
+                uiRef = BuildMainMigrationUI();
+                string outputPath = await StartRoutineInner(uiRef.Value);
+                uiRef.Value.mainDialogWindow.Hide();
+                isSuccess = true;
+
+                return outputPath;
+            }
+            catch when (!isSuccess) // Throw if the isSuccess is not set to true
+            {
+                if (uiRef.HasValue && uiRef.Value.mainDialogWindow != null)
+                {
+                    uiRef.Value.mainDialogWindow.Hide();
+                    await Task.Delay(500); // Give artificial delay to give main dialog window thread to close first
+                }
+                throw;
+            }
+            finally
+            {
+                if (ProcessStopwatch != null) ProcessStopwatch.Stop();
+                if (EventsStopwatch != null) EventsStopwatch.Stop();
+            }
+        }
+
+        private async Task<string> StartRoutineInner(FileMigrationProcessUIRef uiRef)
+        {
+            this.ProcessStopwatch = Stopwatch.StartNew();
+            this.EventsStopwatch = Stopwatch.StartNew();
+            return this.isFileTransfer ? await MoveFile(uiRef) : await MoveDirectory(uiRef);
+        }
+
+        private async Task<string> MoveFile(FileMigrationProcessUIRef uiRef)
+        {
+            FileInfo inputPathInfo = new FileInfo(this.inputPath);
+            FileInfo outputPathInfo = new FileInfo(this.outputPath);
+
+            string inputPathDir = Path.GetDirectoryName(inputPathInfo.FullName);
+            string outputPathDir = Path.GetDirectoryName(outputPathInfo.FullName);
+
+            if (!Directory.Exists(outputPathDir))
+                Directory.CreateDirectory(outputPathDir);
+
+            // Update path display
+            string inputFileBasePath = inputPathInfo.FullName.Substring(inputPathDir.Length + 1);
+            UpdateCountProcessed(uiRef, inputFileBasePath);
+
+            if (this.IsSameOutputDrive)
+            {
+                // Logger.LogWriteLine($"[FileMigrationProcess::MoveFile()] Moving file in the same drive from: {inputPathInfo.FullName} to {outputPathInfo.FullName}", LogType.Default, true);
+                inputPathInfo.MoveTo(outputPathInfo.FullName);
+                UpdateSizeProcessed(uiRef, inputPathInfo.Length);
+            }
+            else
+            {
+                // Logger.LogWriteLine($"[FileMigrationProcess::MoveFile()] Moving file across different drives from: {inputPathInfo.FullName} to {outputPathInfo.FullName}", LogType.Default, true);
+                await MoveWriteFile(uiRef, inputPathInfo, outputPathInfo, this.tokenSource == null ? default : this.tokenSource.Token);
+            }
+
+            return outputPathInfo.FullName;
+        }
+
+        private async Task<string> MoveDirectory(FileMigrationProcessUIRef uiRef)
+        {
+            DirectoryInfo inputPathInfo = new DirectoryInfo(this.inputPath);
+            if (!Directory.Exists(this.outputPath))
+                Directory.CreateDirectory(this.outputPath);
+
+            DirectoryInfo outputPathInfo = new DirectoryInfo(this.outputPath);
+
+            int parentInputPathLength = inputPathInfo.Parent.FullName.Length + 1;
+            string outputDirBaseNamePath = inputPathInfo.FullName.Substring(parentInputPathLength);
+            string outputDirPath = Path.Combine(this.outputPath, outputDirBaseNamePath);
+
+            await Parallel.ForEachAsync(
+                inputPathInfo.EnumerateFiles("*", SearchOption.AllDirectories),
+                this.tokenSource?.Token ?? default,
+                async (inputFileInfo, cancellationToken) =>
+                {
+                    int parentInputPathLength = inputPathInfo.Parent.FullName.Length + 1;
+                    string inputFileBasePath = inputFileInfo.FullName.Substring(parentInputPathLength);
+
+                    // Update path display
+                    UpdateCountProcessed(uiRef, inputFileBasePath);
+
+                    string outputTargetPath = Path.Combine(outputPathInfo.FullName, inputFileBasePath);
+                    string outputTargetDirPath = Path.GetDirectoryName(outputTargetPath);
+
+                    if (!Directory.Exists(outputTargetDirPath))
+                        Directory.CreateDirectory(outputTargetDirPath);
+
+                    if (this.IsSameOutputDrive)
+                    {
+                        // Logger.LogWriteLine($"[FileMigrationProcess::MoveDirectory()] Moving directory content in the same drive from: {inputFileInfo.FullName} to {outputTargetPath}", LogType.Default, true);
+                        inputFileInfo.MoveTo(outputTargetPath);
+                        UpdateSizeProcessed(uiRef, inputFileInfo.Length);
+                    }
+                    else
+                    {
+                        // Logger.LogWriteLine($"[FileMigrationProcess::MoveDirectory()] Moving directory content across different drives from: {inputFileInfo.FullName} to {outputTargetPath}", LogType.Default, true);
+                        FileInfo outputFileInfo = new FileInfo(outputTargetPath);
+                        await MoveWriteFile(uiRef, inputFileInfo, outputFileInfo, cancellationToken);
+                    }
+                });
+
+            inputPathInfo.Delete(true);
+            return outputDirPath;
+        }
+    }
+}
diff --git a/CollapseLauncher/Classes/FileMigrationProcess/FileMigrationProcessRef.cs b/CollapseLauncher/Classes/FileMigrationProcess/FileMigrationProcessRef.cs
new file mode 100644
index 000000000..9e8b7cb02
--- /dev/null
+++ b/CollapseLauncher/Classes/FileMigrationProcess/FileMigrationProcessRef.cs
@@ -0,0 +1,16 @@
+using CollapseLauncher.CustomControls;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Documents;
+
+namespace CollapseLauncher
+{
+    internal struct FileMigrationProcessUIRef
+    {
+        internal ContentDialogCollapse mainDialogWindow;
+        internal TextBlock pathActivitySubtitle;
+        internal Run speedIndicatorSubtitle;
+        internal Run fileCountIndicatorSubtitle;
+        internal Run fileSizeIndicatorSubtitle;
+        internal ProgressBar progressBarIndicator;
+    }
+}
diff --git a/CollapseLauncher/Classes/FileMigrationProcess/IO.cs b/CollapseLauncher/Classes/FileMigrationProcess/IO.cs
new file mode 100644
index 000000000..38e8fe750
--- /dev/null
+++ b/CollapseLauncher/Classes/FileMigrationProcess/IO.cs
@@ -0,0 +1,140 @@
+using CollapseLauncher.CustomControls;
+using CollapseLauncher.Dialogs;
+using Hi3Helper;
+using Hi3Helper.Data;
+using Microsoft.UI.Xaml.Controls;
+using System;
+using System.Buffers;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CollapseLauncher
+{
+    internal partial class FileMigrationProcess
+    {
+        private async Task MoveWriteFile(FileMigrationProcessUIRef uiRef, FileInfo inputFile, FileInfo outputFile, CancellationToken token)
+        {
+            int bufferSize = 1 << 18; // 256 kB Buffer
+
+            if (inputFile.Length < bufferSize)
+                bufferSize = (int)inputFile.Length;
+
+            bool isUseArrayPool = Environment.ProcessorCount * bufferSize > 2 << 20;
+            byte[] buffer = isUseArrayPool ? ArrayPool<byte>.Shared.Rent(bufferSize) : new byte[bufferSize];
+
+            try
+            {
+                await using (FileStream inputStream = inputFile.OpenRead())
+                await using (FileStream outputStream = outputFile.Exists && outputFile.Length <= inputFile.Length ? outputFile.Open(FileMode.Open) : outputFile.Create())
+                {
+                    // Just in-case if the previous move is incomplete, then update and seek to the last position.
+                    if (outputFile.Length <= inputStream.Length && outputFile.Length >= bufferSize)
+                    {
+                        // Do check by comparing the first and last 128K data of the file
+                        Memory<byte> firstCompareInputBytes = new byte[bufferSize];
+                        Memory<byte> firstCompareOutputBytes = new byte[bufferSize];
+                        Memory<byte> lastCompareInputBytes = new byte[bufferSize];
+                        Memory<byte> lastCompareOutputBytes = new byte[bufferSize];
+
+                        // Seek to the first data
+                        inputStream.Position = 0;
+                        await inputStream.ReadExactlyAsync(firstCompareInputBytes);
+                        outputStream.Position = 0;
+                        await outputStream.ReadExactlyAsync(firstCompareOutputBytes);
+
+                        // Seek to the last data
+                        long lastPos = outputStream.Length - bufferSize;
+                        inputStream.Position = lastPos;
+                        await inputStream.ReadExactlyAsync(lastCompareInputBytes);
+                        outputStream.Position = lastPos;
+                        await outputStream.ReadExactlyAsync(lastCompareOutputBytes);
+
+                        bool isMatch = firstCompareInputBytes.Span.SequenceEqual(firstCompareOutputBytes.Span)
+                            && lastCompareInputBytes.Span.SequenceEqual(lastCompareOutputBytes.Span);
+
+                        // If the buffers don't match, then start the copy from the beginning
+                        if (!isMatch)
+                        {
+                            inputStream.Position = 0;
+                            outputStream.Position = 0;
+                        }
+                        else
+                        {
+                            UpdateSizeProcessed(uiRef, outputStream.Length);
+                        }
+                    }
+
+                    await MoveWriteFileInner(uiRef, inputStream, outputStream, buffer, token);
+                }
+
+                inputFile.IsReadOnly = false;
+                inputFile.Delete();
+            }
+            catch { throw; } // Re-throw to 
+            finally
+            {
+                if (isUseArrayPool) ArrayPool<byte>.Shared.Return(buffer);
+            }
+        }
+
+        private async Task MoveWriteFileInner(FileMigrationProcessUIRef uiRef, FileStream inputStream, FileStream outputStream, byte[] buffer, CancellationToken token)
+        {
+            int read;
+            while ((read = await inputStream.ReadAsync(buffer, 0, buffer.Length, token)) > 0)
+            {
+                await outputStream.WriteAsync(buffer, 0, read, token);
+                UpdateSizeProcessed(uiRef, read);
+            }
+        }
+
+        private async ValueTask<bool> IsOutputPathSpaceSufficient(string inputPath, string outputPath)
+        {
+            DriveInfo inputDriveInfo = new DriveInfo(Path.GetPathRoot(inputPath));
+            DriveInfo outputDriveInfo = new DriveInfo(Path.GetPathRoot(outputPath));
+
+            this.TotalFileSize = await Task.Run(() =>
+            {
+                if (this.isFileTransfer)
+                {
+                    FileInfo fileInfo = new FileInfo(inputPath);
+                    return fileInfo.Length;
+                }
+
+                DirectoryInfo directoryInfo = new DirectoryInfo(inputPath);
+                long returnSize = directoryInfo.EnumerateFiles("*", SearchOption.AllDirectories).Sum(x =>
+                {
+                    this.TotalFileCount++;
+                    return x.Length;
+                });
+                return returnSize;
+            });
+
+            if (IsSameOutputDrive = inputDriveInfo.Name == outputDriveInfo.Name)
+                return true;
+
+            bool isSpaceSufficient = outputDriveInfo.TotalFreeSpace < this.TotalFileSize;
+            if (!isSpaceSufficient)
+            {
+                string errStr = $"Free Space on {outputDriveInfo.Name} is not sufficient! (Free space: {outputDriveInfo.TotalFreeSpace}, Req. Space: {this.TotalFileSize}, Drive: {outputDriveInfo.Name})";
+                Logger.LogWriteLine(errStr, LogType.Error, true);
+                await SimpleDialogs.SpawnDialog(
+                        string.Format(Locale.Lang._Dialogs.OperationErrorDiskSpaceInsufficientTitle, outputDriveInfo.Name),
+                        string.Format(Locale.Lang._Dialogs.OperationErrorDiskSpaceInsufficientMsg,
+                                      ConverterTool.SummarizeSizeSimple(outputDriveInfo.TotalFreeSpace),
+                                      ConverterTool.SummarizeSizeSimple(this.TotalFileSize),
+                                      outputDriveInfo.Name),
+                        parentUI,
+                        null,
+                        Locale.Lang._Misc.Okay,
+                        null,
+                        ContentDialogButton.Primary,
+                        ContentDialogTheme.Error
+                );
+            }
+
+            return isSpaceSufficient;
+        }
+    }
+}
diff --git a/CollapseLauncher/Classes/FileMigrationProcess/Statics.cs b/CollapseLauncher/Classes/FileMigrationProcess/Statics.cs
new file mode 100644
index 000000000..3add3c2bd
--- /dev/null
+++ b/CollapseLauncher/Classes/FileMigrationProcess/Statics.cs
@@ -0,0 +1,55 @@
+using CollapseLauncher.Dialogs;
+using Hi3Helper.Data;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace CollapseLauncher
+{
+    internal partial class FileMigrationProcess
+    {
+        internal static async Task<FileMigrationProcess> CreateJob(UIElement parentUI, string dialogTitle, string inputPath, string outputPath = null, CancellationTokenSource token = default, bool showWarningMessage = true)
+        {
+            // Normalize Path (also normalize path from '/' separator)
+            inputPath = ConverterTool.NormalizePath(inputPath);
+
+            // Check whether the input is a file or not.
+            bool isFileTransfer = File.Exists(inputPath) && !inputPath.StartsWith('\\');
+            outputPath = await InitializeAndCheckOutputPath(parentUI, dialogTitle, inputPath, outputPath, isFileTransfer);
+            if (outputPath == null) return null;
+
+            if (showWarningMessage)
+                if (await ShowNotCancellableProcedureMessage(parentUI) == ContentDialogResult.None)
+                    return null;
+
+            return new FileMigrationProcess(parentUI, dialogTitle, inputPath, outputPath, isFileTransfer, token);
+        }
+
+        private static async ValueTask<string> InitializeAndCheckOutputPath(UIElement parentUI, string dialogTitle, string inputPath, string outputPath, bool isFileTransfer)
+        {
+            if (!string.IsNullOrEmpty(outputPath)
+                && ConverterTool.IsUserHasPermission(outputPath)
+                && !IsOutputPathSameAsInput(inputPath, outputPath, isFileTransfer))
+                return outputPath;
+
+            return await BuildCheckOutputPathUI(parentUI, dialogTitle, inputPath, outputPath, isFileTransfer);
+        }
+
+        private static bool IsOutputPathSameAsInput(string inputPath, string outputPath, bool isFilePath)
+        {
+            bool isStringEmpty = string.IsNullOrEmpty(outputPath);
+
+            if (!isFilePath) inputPath = Path.GetDirectoryName(inputPath);
+            bool isPathEqual = inputPath.AsSpan().TrimEnd('\\').SequenceEqual(outputPath.AsSpan().TrimEnd('\\'));
+
+            if (isStringEmpty) return true;
+            return isPathEqual;
+        }
+
+        private static async Task<ContentDialogResult> ShowNotCancellableProcedureMessage(UIElement parentUI) => await SimpleDialogs.Dialog_WarningOperationNotCancellable(parentUI);
+
+    }
+}
diff --git a/CollapseLauncher/Classes/FileMigrationProcess/UIBuilder.cs b/CollapseLauncher/Classes/FileMigrationProcess/UIBuilder.cs
new file mode 100644
index 000000000..2f7d21023
--- /dev/null
+++ b/CollapseLauncher/Classes/FileMigrationProcess/UIBuilder.cs
@@ -0,0 +1,235 @@
+using CollapseLauncher.CustomControls;
+using CollapseLauncher.FileDialogCOM;
+using Hi3Helper;
+using Hi3Helper.Data;
+using Microsoft.UI.Text;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Data;
+using Microsoft.UI.Xaml.Documents;
+using Microsoft.UI.Xaml.Media;
+using System;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace CollapseLauncher
+{
+    internal partial class FileMigrationProcess
+    {
+        private static async ValueTask<string> BuildCheckOutputPathUI(UIElement parentUI, string dialogTitle, string inputPath, string outputPath, bool isFileTransfer)
+        {
+            ContentDialogCollapse mainDialogWindow = new ContentDialogCollapse(ContentDialogTheme.Informational)
+            {
+                Title = dialogTitle,
+                CloseButtonText = Locale.Lang._Misc.Cancel,
+                PrimaryButtonText = null,
+                SecondaryButtonText = null,
+                DefaultButton = ContentDialogButton.Primary,
+                XamlRoot = parentUI.XamlRoot
+            };
+
+            Grid mainGrid = new Grid();
+            mainGrid.AddGridRows(3);
+            mainGrid.AddGridColumns(1, new GridLength(1.0, GridUnitType.Star));
+            mainGrid.AddGridColumns(1);
+
+            TextBlock locateFolderSubtitle = mainGrid.AddElementToGridColumn(new TextBlock
+            {
+                FontSize = 16d,
+                HorizontalAlignment = HorizontalAlignment.Stretch,
+                TextWrapping = TextWrapping.Wrap,
+                Text = Locale.Lang._FileMigrationProcess.LocateFolderSubtitle
+            }, 0, 2);
+
+            TextBox choosePathTextBox = mainGrid.AddElementToGridRow(new TextBox
+            {
+                Margin = new Thickness(0d, 12d, 0d, 0d),
+                IsSpellCheckEnabled = false,
+                IsRightTapEnabled = false,
+                Width = 500,
+                PlaceholderText = Locale.Lang._FileMigrationProcess.ChoosePathTextBoxPlaceholder,
+                Text = string.IsNullOrEmpty(outputPath) ? null : outputPath
+            }, 1);
+
+            Button choosePathButton = mainGrid
+                .AddElementToGridRowColumn(UIElementExtensions
+                    .CreateButtonWithIcon<Button>(Locale.Lang._FileMigrationProcess.ChoosePathButton, "", "FontAwesome", "AccentButtonStyle"),
+                    1, 1);
+            choosePathButton.Margin = new Thickness(8d, 12d, 0d, 0d);
+
+            TextBlock warningText = mainGrid.AddElementToGridRowColumn(new TextBlock
+            {
+                FontStyle = Windows.UI.Text.FontStyle.Italic,
+                FontWeight = FontWeights.SemiBold,
+                Foreground = new SolidColorBrush(Windows.UI.Color.FromArgb(255, 255, 0, 0)),
+                Margin = new Thickness(0d, 12d, 0d, 0d),
+                Visibility = Visibility.Collapsed,
+                TextWrapping = TextWrapping.Wrap,
+                Text = ""
+            }, 2, 0, 0, 2);
+
+            mainDialogWindow.Content = mainGrid;
+
+            if (!string.IsNullOrEmpty(outputPath))
+                ToggleOrCheckPathWarning(outputPath);
+
+            choosePathButton.Click += async (sender, args) =>
+            {
+                string pathResult = isFileTransfer ? await FileDialogNative.GetFileSavePicker(null, dialogTitle) :
+                                                       await FileDialogNative.GetFolderPicker(dialogTitle);
+
+                choosePathTextBox.Text = string.IsNullOrEmpty(pathResult) ? null : pathResult;
+            };
+            choosePathTextBox.TextChanged += (sender, args) => ToggleOrCheckPathWarning(((TextBox)sender).Text);
+
+            void ToggleOrCheckPathWarning(string path)
+            {
+                string parentPath = path;
+                if (isFileTransfer) parentPath = Path.GetDirectoryName(path);
+
+                if (string.IsNullOrEmpty(parentPath))
+                {
+                    ToggleWarningText(Locale.Lang._FileMigrationProcess.ChoosePathErrorPathUnselected);
+                    return;
+                }
+                if (!(File.Exists(parentPath) || Directory.Exists(parentPath)))
+                {
+                    ToggleWarningText(Locale.Lang._FileMigrationProcess.ChoosePathErrorPathNotExist);
+                    return;
+                }
+                if (!ConverterTool.IsUserHasPermission(parentPath) || IsOutputPathSameAsInput(inputPath, path, isFileTransfer))
+                {
+                    ToggleWarningText(Locale.Lang._FileMigrationProcess.ChoosePathErrorPathNoPermission);
+                    return;
+                }
+                ToggleWarningText();
+            }
+
+            void ToggleWarningText(string text = null)
+            {
+                bool canContinue = string.IsNullOrEmpty(text);
+                warningText.Visibility = canContinue ? Visibility.Collapsed : Visibility.Visible;
+                warningText.Text = text;
+                mainDialogWindow.PrimaryButtonText = canContinue ? Locale.Lang._Misc.Next : null;
+            }
+
+            ContentDialogResult mainDialogWindowResult = await mainDialogWindow.ShowAsync();
+            return mainDialogWindowResult == ContentDialogResult.Primary ? choosePathTextBox.Text : null;
+        }
+
+        private FileMigrationProcessUIRef BuildMainMigrationUI()
+        {
+            ContentDialogCollapse mainDialogWindow = new ContentDialogCollapse(ContentDialogTheme.Informational)
+            {
+                Title = this.dialogTitle,
+                CloseButtonText = null,
+                PrimaryButtonText = null,
+                SecondaryButtonText = null,
+                DefaultButton = ContentDialogButton.Primary,
+                XamlRoot = this.parentUI.XamlRoot
+            };
+
+            Grid mainGrid = new Grid { Width = 500d };
+            mainGrid.AddGridColumns(2, new GridLength(1.0d, GridUnitType.Star));
+            mainGrid.AddGridRows(1, new GridLength(1.0d, GridUnitType.Auto));
+            mainGrid.AddGridRows(3, new GridLength(20d, GridUnitType.Pixel));
+
+            // Build path indicator
+            StackPanel pathActivityPanel = mainGrid.AddElementToGridRowColumn(
+                new StackPanel { Margin = new Thickness(0, 0, 0, 8d) },
+                0, 0, 0, 2
+                );
+            _ = pathActivityPanel.AddElementToStackPanel(
+                new TextBlock
+                {
+                    FontWeight = FontWeights.Bold,
+                    Text = Locale.Lang._FileMigrationProcess.PathActivityPanelTitle
+                });
+            TextBlock pathActivitySubtitle = pathActivityPanel.AddElementToStackPanel(
+                new TextBlock {
+                    Text = Locale.Lang._Misc.Idle,
+                    FontSize = 18d,
+                    TextTrimming = TextTrimming.CharacterEllipsis
+                });
+
+            // Build speed indicator
+            TextBlock speedIndicator = mainGrid.AddElementToGridRow(
+                new TextBlock { FontWeight = FontWeights.Bold },
+                1);
+            Run speedIndicatorTitle = new Run { Text = Locale.Lang._FileMigrationProcess.SpeedIndicatorTitle, FontWeight = FontWeights.Medium };
+            Run speedIndicatorSubtitle = new Run { Text = "-" };
+            speedIndicator.Inlines.Add(speedIndicatorTitle);
+            speedIndicator.Inlines.Add(speedIndicatorSubtitle);
+
+            // Build file count indicator
+            TextBlock fileCountIndicator = mainGrid.AddElementToGridRow(
+                new TextBlock { FontWeight = FontWeights.Bold },
+                2);
+            Run fileCountIndicatorTitle = new Run { Text = Locale.Lang._FileMigrationProcess.FileCountIndicatorTitle, FontWeight = FontWeights.Medium };
+            Run fileCountIndicatorSubtitle = new Run { Text = Locale.Lang._Misc.PerFromToPlaceholder };
+            fileCountIndicator.Inlines.Add(fileCountIndicatorTitle);
+            fileCountIndicator.Inlines.Add(fileCountIndicatorSubtitle);
+
+            // Build file size indicator
+            TextBlock fileSizeIndicator = mainGrid.AddElementToGridRowColumn(
+                new TextBlock
+                {
+                    FontWeight = FontWeights.Bold,
+                    HorizontalAlignment = HorizontalAlignment.Right,
+                    HorizontalTextAlignment = TextAlignment.Right
+                },
+                1, 1);
+            Run fileSizeIndicatorSubtitle = new Run { Text = Locale.Lang._Misc.PerFromToPlaceholder };
+            fileSizeIndicator.Inlines.Add(fileSizeIndicatorSubtitle);
+
+            // Build progress percentage indicator
+            StackPanel progressTextIndicator = mainGrid.AddElementToGridRowColumn(
+                new StackPanel
+                {
+                    Orientation = Orientation.Horizontal,
+                    HorizontalAlignment = HorizontalAlignment.Right
+                },
+                2, 1);
+            TextBlock progressTextIndicatorSubtitle = progressTextIndicator.AddElementToStackPanel(
+                new TextBlock { Text = "0", FontWeight = FontWeights.Bold });
+            _ = progressTextIndicator.AddElementToStackPanel(
+                new TextBlock { Text = "%", FontWeight = FontWeights.Bold });
+
+            // Build progress bar indicator
+            ProgressBar progressBarIndicator = mainGrid.AddElementToGridRowColumn(
+                new ProgressBar
+                {
+                    HorizontalAlignment = HorizontalAlignment.Stretch,
+                    VerticalAlignment = VerticalAlignment.Bottom,
+                    Value = 0d,
+                    Maximum = 100d,
+                    IsIndeterminate = true
+                },
+                3, 0, 0, 2);
+
+            // Set progress percentage indicator subtitle with progress bar value
+            BindingOperations.SetBinding(progressTextIndicatorSubtitle, TextBlock.TextProperty, new Binding()
+            {
+                Source = progressBarIndicator,
+                Path = new PropertyPath("Value"),
+                Mode = BindingMode.OneWay,
+                UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged
+            });
+
+            // Set the main dialog content
+            mainDialogWindow.Content = mainGrid;
+            _ = mainDialogWindow.ShowAsync();
+
+            // Return the 
+            return new FileMigrationProcessUIRef
+            {
+                mainDialogWindow = mainDialogWindow,
+                pathActivitySubtitle = pathActivitySubtitle,
+                fileCountIndicatorSubtitle = fileCountIndicatorSubtitle,
+                fileSizeIndicatorSubtitle = fileSizeIndicatorSubtitle,
+                progressBarIndicator = progressBarIndicator,
+                speedIndicatorSubtitle = speedIndicatorSubtitle,
+            };
+        }
+    }
+}
diff --git a/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.cs b/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.cs
index 5c76bc5a8..04a61d3d2 100644
--- a/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.cs
+++ b/CollapseLauncher/Classes/InstallManagement/BaseClass/InstallManagerBase.cs
@@ -40,6 +40,7 @@ protected struct UninstallGameProperty
             public string[] foldersToDelete;
             public string[] foldersToKeepInData;
         }
+        protected enum MigrateFromLauncherType { Official, BetterHi3Launcher, Steam, Unknown }
         #endregion
 
         #region Properties
@@ -628,9 +629,17 @@ public virtual async ValueTask<bool> IsPreloadCompleted(CancellationToken token)
             // So checking the fully downloaded single package is unnecessary.
         }
 
-        public async Task MoveGameLocation()
+        public async ValueTask<bool> MoveGameLocation()
         {
+            // Get the Game folder
+            string GameFolder = ConverterTool.NormalizePath(_gamePath);
+
+            // Initialize and run the FileMigration utility
+            int migrationOptionReturn = await PerformMigrationOption(GameFolder, MigrateFromLauncherType.Unknown, true);
+            if (migrationOptionReturn == -1) return false;
 
+            // If all the operation is complete, then return true as completed
+            return true;
         }
 
         public async ValueTask<bool> UninstallGame()
@@ -1025,6 +1034,11 @@ private async ValueTask<int> CheckExistingSteamInstallation()
             string pathOnSteam = "";
             if (TryGetExistingSteamPath(ref pathOnSteam))
             {
+                // If the "Use current directory" option is chosen (migrationOptionReturn == 1), then proceed to another routine.
+                // If not, then return the migrationOptionReturn value.
+                int migrationOptionReturn = await PerformMigrationOption(_gameVersionManager.GamePreset.ActualGameDataLocation, MigrateFromLauncherType.Official);
+                if (migrationOptionReturn != 1) return migrationOptionReturn;
+
                 switch (await Dialog_ExistingInstallationSteam(_parentUI))
                 {
                     // If action to migrate was taken, then update the game path (but don't save it to the config file)
@@ -1050,6 +1064,11 @@ private async ValueTask<int> CheckExistingBHI3LInstallation()
             string pathOnBHi3L = "";
             if (TryGetExistingBHI3LPath(ref pathOnBHi3L))
             {
+                // If the "Use current directory" option is chosen (migrationOptionReturn == 1), then proceed to another routine.
+                // If not, then return the migrationOptionReturn value.
+                int migrationOptionReturn = await PerformMigrationOption(_gameVersionManager.GamePreset.ActualGameDataLocation, MigrateFromLauncherType.Official);
+                if (migrationOptionReturn != 1) return migrationOptionReturn;
+
                 switch (await Dialog_ExistingInstallationBetterLauncher(_parentUI, pathOnBHi3L))
                 {
                     // If action to migrate was taken, then update the game path (but don't save it to the config file)
@@ -1073,11 +1092,16 @@ private async ValueTask<int> CheckExistingOfficialInstallation()
         {
             if (_gameVersionManager.GamePreset.CheckExistingGame())
             {
+                // If the "Use current directory" option is chosen (migrationOptionReturn == 1), then proceed to another routine.
+                // If not, then return the migrationOptionReturn value.
+                int migrationOptionReturn = await PerformMigrationOption(_gameVersionManager.GamePreset.ActualGameDataLocation, MigrateFromLauncherType.Official);
+                if (migrationOptionReturn != 1) return migrationOptionReturn;
+
                 switch (await Dialog_ExistingInstallation(_parentUI, _gameVersionManager.GamePreset.ActualGameDataLocation))
                 {
                     // If action to migrate was taken, then update the game path (but don't save it to the config file)
                     case ContentDialogResult.Primary:
-                        _gameVersionManager.UpdateGamePath(_gameVersionManager.GamePreset.ActualGameDataLocation.Replace('\\', '/'), false);
+                        _gameVersionManager.UpdateGamePath(_gameVersionManager.GamePreset.ActualGameDataLocation, false);
                         return 0;
                     // If action to fresh install was taken, then return 2 (selecting path)
                     case ContentDialogResult.Secondary:
@@ -1092,6 +1116,50 @@ private async ValueTask<int> CheckExistingOfficialInstallation()
             return 1;
         }
 
+        private async ValueTask<int> PerformMigrationOption(string pathIfUseExistingSelected, MigrateFromLauncherType launcherType, bool isMoveOperation = false)
+        {
+            string launcherName = launcherType switch
+            {
+                MigrateFromLauncherType.Official => Lang._Misc.LauncherNameOfficial,
+                MigrateFromLauncherType.Steam => Lang._Misc.LauncherNameSteam,
+                MigrateFromLauncherType.BetterHi3Launcher => Lang._Misc.LauncherNameBHI3L,
+                _ => Lang._Misc.LauncherNameUnknown,
+            };
+
+            if (!isMoveOperation)
+            {
+                ContentDialogResult dialogResult = await Dialog_MigrationChoiceDialog(
+                    this._parentUI,
+                    pathIfUseExistingSelected,
+                    this._gameVersionManager.GamePreset.GameName,
+                    this._gameVersionManager.GamePreset.ZoneName,
+                    launcherName);
+
+                if (dialogResult == ContentDialogResult.None) return -1; // Cancel the installation
+                if (dialogResult == ContentDialogResult.Primary) return 1; // Use an existing path or continue to another routine
+            }
+
+            // If secondary option is selected, then do the directory migration
+            string translatedGameFullname = string.Format("{0} - {1}",
+                InnerLauncherConfig.GetGameTitleRegionTranslationString(this._gameVersionManager.GamePreset.GameName, Lang._GameClientTitles),
+                InnerLauncherConfig.GetGameTitleRegionTranslationString(this._gameVersionManager.GamePreset.ZoneName, Lang._GameClientRegions)
+                );
+
+            FileMigrationProcess migrationProcessTool = await FileMigrationProcess.CreateJob(
+                this._parentUI,
+                string.Format(Lang._Dialogs.MigrateExistingMoveDirectoryTitle, translatedGameFullname),
+                pathIfUseExistingSelected);
+
+            // If the migration tool is null (meaning that it's cancelled), then return -1 as cancelled.
+            if (migrationProcessTool == null) return -1;
+            string newDirectoryPath = await migrationProcessTool.StartRoutine();
+
+            // If it's finished, then set the game data location to the new one
+            _gameVersionManager.UpdateGamePath(newDirectoryPath, false);
+
+            return 0; // Return 0 as completed.
+        }
+
         private bool TryGetExistingSteamPath(ref string OutputPath)
         {
             // If the game preset doesn't have SteamGameID, then return false
diff --git a/CollapseLauncher/Classes/Interfaces/IGameInstallManager.cs b/CollapseLauncher/Classes/Interfaces/IGameInstallManager.cs
index 2b8b744c7..158e62b5f 100644
--- a/CollapseLauncher/Classes/Interfaces/IGameInstallManager.cs
+++ b/CollapseLauncher/Classes/Interfaces/IGameInstallManager.cs
@@ -13,7 +13,7 @@ internal interface IGameInstallManager : IBackgroundActivity, IDisposable
         Task StartPostInstallVerification();
         void ApplyGameConfig(bool forceUpdateToLatest = false);
 
-        Task MoveGameLocation();
+        ValueTask<bool> MoveGameLocation();
         ValueTask<bool> UninstallGame();
         void Flush();
         ValueTask<bool> IsPreloadCompleted(CancellationToken token = default);
diff --git a/CollapseLauncher/Classes/UIElementExtensions.cs b/CollapseLauncher/Classes/UIElementExtensions.cs
new file mode 100644
index 000000000..dde45fe73
--- /dev/null
+++ b/CollapseLauncher/Classes/UIElementExtensions.cs
@@ -0,0 +1,120 @@
+using Microsoft.UI.Text;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Controls.Primitives;
+using Microsoft.UI.Xaml.Documents;
+using Microsoft.UI.Xaml.Media;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using Windows.UI.Text;
+
+namespace CollapseLauncher
+{
+    internal static class UIElementExtensions
+    {
+        internal static TButtonBase CreateButtonWithIcon<TButtonBase>(string text, string iconGlyph, string iconFontFamily = "FontAwesome", string buttonStyle = "DefaultButtonStyle")
+            where TButtonBase : ButtonBase, new()
+        {
+            TButtonBase buttonReturn = new TButtonBase();
+            StackPanel contentPanel = new StackPanel { Orientation = Orientation.Horizontal };
+            contentPanel.Children.Add(new FontIcon
+            {
+                Glyph = iconGlyph,
+                FontSize = 16,
+                Margin = new Thickness(0d, 1d, 0d, 0d),
+                FontFamily = GetApplicationResource<FontFamily>(iconFontFamily)
+            }); ;
+            contentPanel.Children.Add(new TextBlock
+            {
+                Text = text,
+                FontWeight = FontWeights.SemiBold,
+                Margin = new Thickness(8d, 0d, 0d, 0d)
+            });
+            buttonReturn.CornerRadius = new CornerRadius(14);
+            buttonReturn.Content = contentPanel;
+            buttonReturn.Style = GetApplicationResource<Style>(buttonStyle);
+            return buttonReturn;
+        }
+
+        internal static ref TElement AddElementToStackPanel<TElement>(this StackPanel stackPanel, TElement element)
+            where TElement : FrameworkElement
+        {
+            stackPanel.Children.Add(element);
+            return ref Unsafe.AsRef(ref element);
+        }
+
+        internal static void AddGridColumns(this Grid grid, int count, GridLength? columnWidth = null)
+        {
+            for (; count > 0; count--) grid.ColumnDefinitions.Add(new ColumnDefinition()
+            {
+                Width = columnWidth ?? GridLength.Auto
+            });
+        }
+
+        internal static void AddGridRows(this Grid grid, int count, GridLength? columnHeight = null)
+        {
+            for (; count > 0; count--) grid.RowDefinitions.Add(new RowDefinition()
+            {
+                Height = columnHeight ?? GridLength.Auto
+            });
+        }
+
+        internal static ref TElement AddElementToGridRowColumn<TElement>(this Grid grid, TElement element, int rowIndex, int columnIndex, int rowSpan = 0, int columnSpan = 0)
+            where TElement : FrameworkElement
+        {
+            grid.Children.Add(element);
+            SetElementGridRowPosition(element, rowIndex, rowSpan);
+            SetElementGridColumnPosition(element, columnIndex, columnSpan);
+            return ref Unsafe.AsRef(ref element);
+        }
+
+        internal static ref TElement AddElementToGridRow<TElement>(this Grid grid, TElement element, int index, int span = 0)
+            where TElement : FrameworkElement
+        {
+            grid.Children.Add(element);
+            SetElementGridRowPosition(element, index, span);
+            return ref Unsafe.AsRef(ref element);
+        }
+
+        internal static ref TElement AddElementToGridColumn<TElement>(this Grid grid, TElement element, int index, int span = 0)
+            where TElement : FrameworkElement
+        {
+            grid.Children.Add(element);
+            SetElementGridColumnPosition(element, index, span);
+            return ref Unsafe.AsRef(ref element);
+        }
+
+        internal static void SetElementGridRowPosition<TElement>(TElement element, int index, int span = 0)
+            where TElement : FrameworkElement
+        {
+            Grid.SetRow(element, index);
+            if (span > 0) Grid.SetRowSpan(element, span);
+        }
+
+        internal static void SetElementGridColumnPosition<TElement>(TElement element, int index, int span = 0)
+            where TElement : FrameworkElement
+        {
+            Grid.SetColumn(element, index);
+            if (span > 0) Grid.SetColumnSpan(element, span);
+        }
+
+        internal static void AddTextBlockNewLine(this TextBlock textBlock, int count = 1)
+        {
+            while (count-- > 0) { textBlock.Inlines.Add(new LineBreak()); }
+        }
+
+        internal static void AddTextBlockLine(this TextBlock textBlock, string message, FontWeight? weight = null, double size = 14d)
+        {
+            if (!weight.HasValue) weight = FontWeights.Normal;
+            textBlock.Inlines.Add(new Run { Text = message, FontWeight = weight.Value, FontSize = size });
+        }
+
+        internal static TReturnType GetApplicationResource<TReturnType>(string resourceKey)
+        {
+            if (!Application.Current.Resources.ContainsKey(resourceKey))
+                throw new KeyNotFoundException($"Application resource with key: {resourceKey} does not exist!");
+
+            return (TReturnType)Application.Current.Resources[resourceKey];
+        }
+    }
+}
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/Dialogs/InstallationConvert.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/Dialogs/InstallationConvert.xaml.cs
index 947ac0e64..81f5242c8 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/Dialogs/InstallationConvert.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/Dialogs/InstallationConvert.xaml.cs
@@ -239,6 +239,9 @@ public bool IsSourceGameExist(PresetConfigV2 Profile)
             PresetConfigV2 SourceRet = null;
             PresetConfigV2 TargetRet = null;
 
+            if (SourceGame.SelectedItem == null || TargetGame.SelectedItem == null)
+                throw new OperationCanceledException();
+
             string sourceGameRegionString = InnerLauncherConfig.GetComboBoxGameRegionValue(SourceGame.SelectedItem);
             string targetGameRegionString = InnerLauncherConfig.GetComboBoxGameRegionValue(TargetGame.SelectedItem);
 
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/Dialogs/SimpleDialogs.cs b/CollapseLauncher/XAMLs/MainApp/Pages/Dialogs/SimpleDialogs.cs
index d3e67bd51..1d7af3704 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/Dialogs/SimpleDialogs.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/Dialogs/SimpleDialogs.cs
@@ -287,6 +287,29 @@ await SpawnDialog(
                         ContentDialogTheme.Informational
             );
 
+
+        public static async Task<ContentDialogResult> Dialog_MigrationChoiceDialog(UIElement Content, string existingGamePath, string gameTitle, string gameRegion, string launcherName)
+        {
+            string gameFullnameString = $"{InnerLauncherConfig.GetGameTitleRegionTranslationString(gameTitle, Lang._GameClientTitles)} - {InnerLauncherConfig.GetGameTitleRegionTranslationString(gameRegion, Lang._GameClientRegions)}";
+
+            TextBlock contentTextBlock = new TextBlock { TextWrapping = TextWrapping.Wrap };
+            contentTextBlock.AddTextBlockLine(string.Format(Lang._Dialogs.MigrateExistingInstallChoiceSubtitle1, launcherName));
+            contentTextBlock.AddTextBlockNewLine(2);
+            contentTextBlock.AddTextBlockLine(existingGamePath, FontWeights.SemiBold);
+            contentTextBlock.AddTextBlockNewLine(2);
+            contentTextBlock.AddTextBlockLine(string.Format(Lang._Dialogs.MigrateExistingInstallChoiceSubtitle2, launcherName));
+
+            return await SpawnDialog(
+                string.Format(Lang._Dialogs.MigrateExistingInstallChoiceTitle, gameFullnameString),
+                contentTextBlock,
+                Content,
+                Lang._Misc.Cancel,
+                Lang._Misc.UseCurrentDir,
+                Lang._Misc.MoveToDifferentDir,
+                ContentDialogButton.Primary,
+                ContentDialogTheme.Informational
+            );
+        }
         public static async Task<ContentDialogResult> Dialog_SteamConversionNoPermission(UIElement Content) =>
             await SpawnDialog(
                         Lang._Dialogs.SteamConvertNeedMigrateTitle,
@@ -414,6 +437,29 @@ await SpawnDialog(
                         ContentDialogTheme.Error
                 );
 
+        public static async Task<ContentDialogResult> Dialog_WarningOperationNotCancellable(UIElement Content)
+        {
+            TextBlock warningMessage = new TextBlock { TextWrapping = TextWrapping.Wrap };
+            warningMessage.AddTextBlockLine(Lang._Dialogs.OperationWarningNotCancellableMsg1);
+            warningMessage.AddTextBlockLine(Lang._Dialogs.OperationWarningNotCancellableMsg2, FontWeights.Bold);
+            warningMessage.AddTextBlockLine(Lang._Dialogs.OperationWarningNotCancellableMsg3);
+            warningMessage.AddTextBlockLine(Lang._Misc.Yes, FontWeights.SemiBold);
+            warningMessage.AddTextBlockLine(Lang._Dialogs.OperationWarningNotCancellableMsg4);
+            warningMessage.AddTextBlockLine(Lang._Misc.NoCancel, FontWeights.SemiBold);
+            warningMessage.AddTextBlockLine(Lang._Dialogs.OperationWarningNotCancellableMsg5);
+
+            return await SpawnDialog(
+                        Lang._Dialogs.OperationWarningNotCancellableTitle,
+                        warningMessage,
+                        Content,
+                        Lang._Misc.NoCancel,
+                        Lang._Misc.Yes,
+                        null,
+                        ContentDialogButton.Primary,
+                        ContentDialogTheme.Warning
+                );
+        }
+
         public static async Task<ContentDialogResult> Dialog_RelocateFolder(UIElement Content) =>
             await SpawnDialog(
                         Lang._Dialogs.RelocateFolderTitle,
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.xaml b/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.xaml
index 8aabdc4c2..e4cb2790e 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.xaml
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.xaml
@@ -712,6 +712,14 @@
                                                     </StackPanel>
                                                 </Button.Content>
                                             </Button>
+                                            <Button x:Name="MoveGameLocationButton" Margin="0,8" CornerRadius="14" HorizontalAlignment="Stretch" HorizontalContentAlignment="Left" Click="MoveGameLocationButton_Click">
+                                                <Button.Content>
+                                                    <StackPanel Orientation="Horizontal" Margin="4,0">
+                                                        <TextBlock FontFamily="{ThemeResource FontAwesomeSolid}" Text="&#xf56e;" FontSize="18"/>
+                                                        <TextBlock Text="{x:Bind helper:Locale.Lang._HomePage.GameSettings_Panel2MoveGameLocationGame}" Margin="8,0,0,0"/>
+                                                    </StackPanel>
+                                                </Button.Content>
+                                            </Button>
                                             <Button x:Name="StopGameButton" Margin="0,8" CornerRadius="14" HorizontalAlignment="Stretch" HorizontalContentAlignment="Left" Click="StopGameButton_Click">
                                                 <Button.Content>
                                                     <StackPanel Orientation="Horizontal" Margin="4,0">
diff --git a/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.xaml.cs b/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.xaml.cs
index dfdd74ee1..c618e8d78 100644
--- a/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.xaml.cs
+++ b/CollapseLauncher/XAMLs/MainApp/Pages/HomePage.xaml.cs
@@ -756,6 +756,10 @@ private void GetCurrentGameState()
                         ConvertVersionButton.IsEnabled = false;
                         CustomArgsTextBox.IsEnabled = false;
                         OpenScreenshotFolderButton.IsEnabled = false;
+                        ConvertVersionButton.Visibility = Visibility.Collapsed;
+                        RepairGameButton.Visibility = Visibility.Collapsed;
+                        UninstallGameButton.Visibility = Visibility.Collapsed;
+                        MoveGameLocationButton.Visibility = Visibility.Collapsed;
                     }
                     break;
             }
@@ -824,6 +828,7 @@ private async void CheckRunningGameInstance(CancellationToken Token)
                         UninstallGameButton.IsEnabled = false;
                         ConvertVersionButton.IsEnabled = false;
                         CustomArgsTextBox.IsEnabled = false;
+                        MoveGameLocationButton.IsEnabled = false;
                         StopGameButton.IsEnabled = true;
 
                         PlaytimeIdleStack.Visibility = Visibility.Collapsed;
@@ -846,6 +851,7 @@ private async void CheckRunningGameInstance(CancellationToken Token)
 
                     //GameStartupSetting.IsEnabled = true;
                     RepairGameButton.IsEnabled = true;
+                    MoveGameLocationButton.IsEnabled = true;
                     UninstallGameButton.IsEnabled = true;
                     ConvertVersionButton.IsEnabled = true;
                     CustomArgsTextBox.IsEnabled = true;
@@ -1663,6 +1669,23 @@ private async void StopGameButton_Click(object sender, RoutedEventArgs e)
             if (await Dialog_StopGame(this) != ContentDialogResult.Primary) return;
             StopGame(CurrentGameProperty._GameVersion.GamePreset);
         }
+
+        private async void MoveGameLocationButton_Click(object sender, RoutedEventArgs e)
+        {
+            try
+            {
+                if (await CurrentGameProperty._GameInstall.MoveGameLocation())
+                {
+                    CurrentGameProperty._GameInstall.ApplyGameConfig();
+                    ReturnToHomePage();
+                }
+            }
+            catch (Exception ex)
+            {
+                LogWriteLine($"Error has occurred while running Move Game Location tool!\r\n{ex}", LogType.Error, true);
+                ErrorSender.SendException(ex, ErrorType.Unhandled);
+            }
+        }
         #endregion
 
         #region Playtime Buttons
diff --git a/CollapseLauncher/XAMLs/Theme/ContentDialogCollapse.xaml b/CollapseLauncher/XAMLs/Theme/ContentDialogCollapse.xaml
index 7a2f4b235..56c233086 100644
--- a/CollapseLauncher/XAMLs/Theme/ContentDialogCollapse.xaml
+++ b/CollapseLauncher/XAMLs/Theme/ContentDialogCollapse.xaml
@@ -16,7 +16,7 @@
 
             <x:Double x:Key="ContentDialogMinWidth">320</x:Double>
             <x:Double x:Key="ContentDialogMaxWidth">640</x:Double>
-            <x:Double x:Key="ContentDialogMinHeight">184</x:Double>
+            <x:Double x:Key="ContentDialogMinHeight">64</x:Double>
             <x:Double x:Key="ContentDialogMaxHeight">756</x:Double>
 
             <GridLength x:Key="ContentDialogButtonSpacing">8</GridLength>
@@ -35,7 +35,7 @@
 
             <x:Double x:Key="ContentDialogMinWidth">320</x:Double>
             <x:Double x:Key="ContentDialogMaxWidth">640</x:Double>
-            <x:Double x:Key="ContentDialogMinHeight">184</x:Double>
+            <x:Double x:Key="ContentDialogMinHeight">64</x:Double>
             <x:Double x:Key="ContentDialogMaxHeight">756</x:Double>
 
             <GridLength x:Key="ContentDialogButtonSpacing">8</GridLength>
@@ -55,7 +55,7 @@
 
             <x:Double x:Key="ContentDialogMinWidth">320</x:Double>
             <x:Double x:Key="ContentDialogMaxWidth">640</x:Double>
-            <x:Double x:Key="ContentDialogMinHeight">184</x:Double>
+            <x:Double x:Key="ContentDialogMinHeight">64</x:Double>
             <x:Double x:Key="ContentDialogMaxHeight">756</x:Double>
 
             <GridLength x:Key="ContentDialogButtonSpacing">8</GridLength>
@@ -326,11 +326,11 @@
                                         Background="{TemplateBinding Background}">
                                         <Grid HorizontalAlignment="Center">
                                             <Grid.ColumnDefinitions>
-                                                <ColumnDefinition x:Name="PrimaryColumn" Width="*" />
+                                                <ColumnDefinition x:Name="PrimaryColumn" Width="Auto" />
                                                 <ColumnDefinition x:Name="FirstSpacer" Width="0" />
-                                                <ColumnDefinition x:Name="SecondaryColumn" Width="0" />
+                                                <ColumnDefinition x:Name="SecondaryColumn" Width="Auto" />
                                                 <ColumnDefinition x:Name="SecondSpacer" Width="{ThemeResource ContentDialogButtonSpacing}" />
-                                                <ColumnDefinition x:Name="CloseColumn" Width="*" />
+                                                <ColumnDefinition x:Name="CloseColumn" Width="Auto" />
                                             </Grid.ColumnDefinitions>
                                             <Button
                                             x:Name="PrimaryButton"
diff --git a/Hi3Helper.Core/Lang/Locale/LangDialogs.cs b/Hi3Helper.Core/Lang/Locale/LangDialogs.cs
index 9a14cf43f..c6f59420a 100644
--- a/Hi3Helper.Core/Lang/Locale/LangDialogs.cs
+++ b/Hi3Helper.Core/Lang/Locale/LangDialogs.cs
@@ -32,6 +32,10 @@ public sealed class LangDialogs
                 public string RepairCompletedSubtitleNoBroken { get; set; } = LangFallback?._Dialogs.RepairCompletedSubtitleNoBroken;
                 public string ExtremeGraphicsSettingsWarnTitle { get; set; } = LangFallback?._Dialogs.ExtremeGraphicsSettingsWarnTitle;
                 public string ExtremeGraphicsSettingsWarnSubtitle { get; set; } = LangFallback?._Dialogs.ExtremeGraphicsSettingsWarnSubtitle;
+                public string MigrateExistingMoveDirectoryTitle { get; set; } = LangFallback?._Dialogs.MigrateExistingMoveDirectoryTitle;
+                public string MigrateExistingInstallChoiceTitle { get; set; } = LangFallback?._Dialogs.MigrateExistingInstallChoiceTitle;
+                public string MigrateExistingInstallChoiceSubtitle1 { get; set; } = LangFallback?._Dialogs.MigrateExistingInstallChoiceSubtitle1;
+                public string MigrateExistingInstallChoiceSubtitle2 { get; set; } = LangFallback?._Dialogs.MigrateExistingInstallChoiceSubtitle2;
                 public string ExistingInstallTitle { get; set; } = LangFallback?._Dialogs.ExistingInstallTitle;
                 public string ExistingInstallSubtitle { get; set; } = LangFallback?._Dialogs.ExistingInstallSubtitle;
                 public string ExistingInstallBHI3LTitle { get; set; } = LangFallback?._Dialogs.ExistingInstallBHI3LTitle;
@@ -121,6 +125,14 @@ public sealed class LangDialogs
                 public string SteamShortcutCreationSuccessSubtitle3 { get; set; } = LangFallback?._Dialogs.SteamShortcutCreationSuccessSubtitle3;
                 public string SteamShortcutCreationSuccessSubtitle4 { get; set; } = LangFallback?._Dialogs.SteamShortcutCreationSuccessSubtitle4;
                 public string SteamShortcutCreationSuccessSubtitle5 { get; set; } = LangFallback?._Dialogs.SteamShortcutCreationSuccessSubtitle5;
+                public string OperationErrorDiskSpaceInsufficientTitle { get; set; } = LangFallback?._Dialogs.OperationErrorDiskSpaceInsufficientTitle;
+                public string OperationErrorDiskSpaceInsufficientMsg { get; set; } = LangFallback?._Dialogs.OperationErrorDiskSpaceInsufficientMsg;
+                public string OperationWarningNotCancellableTitle { get; set; } = LangFallback?._Dialogs.OperationWarningNotCancellableTitle;
+                public string OperationWarningNotCancellableMsg1 { get; set; } = LangFallback?._Dialogs.OperationWarningNotCancellableMsg1;
+                public string OperationWarningNotCancellableMsg2 { get; set; } = LangFallback?._Dialogs.OperationWarningNotCancellableMsg2;
+                public string OperationWarningNotCancellableMsg3 { get; set; } = LangFallback?._Dialogs.OperationWarningNotCancellableMsg3;
+                public string OperationWarningNotCancellableMsg4 { get; set; } = LangFallback?._Dialogs.OperationWarningNotCancellableMsg4;
+                public string OperationWarningNotCancellableMsg5 { get; set; } = LangFallback?._Dialogs.OperationWarningNotCancellableMsg5;
             }
         }
         #endregion
diff --git a/Hi3Helper.Core/Lang/Locale/LangFileMigrationProcess.cs b/Hi3Helper.Core/Lang/Locale/LangFileMigrationProcess.cs
new file mode 100644
index 000000000..37bdde9cd
--- /dev/null
+++ b/Hi3Helper.Core/Lang/Locale/LangFileMigrationProcess.cs
@@ -0,0 +1,24 @@
+namespace Hi3Helper
+{
+    public sealed partial class Locale
+    {
+        #region FileMigrationProcess
+        public sealed partial class LocalizationParams
+        {
+            public LangFileMigrationProcess _FileMigrationProcess { get; set; } = LangFallback?._FileMigrationProcess;
+            public sealed class LangFileMigrationProcess
+            {
+                public string PathActivityPanelTitle { get; set; } = LangFallback?._FileMigrationProcess.PathActivityPanelTitle;
+                public string SpeedIndicatorTitle { get; set; } = LangFallback?._FileMigrationProcess.SpeedIndicatorTitle;
+                public string FileCountIndicatorTitle { get; set; } = LangFallback?._FileMigrationProcess.FileCountIndicatorTitle;
+                public string LocateFolderSubtitle { get; set; } = LangFallback?._FileMigrationProcess.LocateFolderSubtitle;
+                public string ChoosePathTextBoxPlaceholder { get; set; } = LangFallback?._FileMigrationProcess.ChoosePathTextBoxPlaceholder;
+                public string ChoosePathButton { get; set; } = LangFallback?._FileMigrationProcess.ChoosePathButton;
+                public string ChoosePathErrorPathUnselected { get; set; } = LangFallback?._FileMigrationProcess.ChoosePathErrorPathUnselected;
+                public string ChoosePathErrorPathNotExist { get; set; } = LangFallback?._FileMigrationProcess.ChoosePathErrorPathNotExist;
+                public string ChoosePathErrorPathNoPermission { get; set; } = LangFallback?._FileMigrationProcess.ChoosePathErrorPathNoPermission;
+            }
+        }
+        #endregion
+    }
+}
diff --git a/Hi3Helper.Core/Lang/Locale/LangHomePage.cs b/Hi3Helper.Core/Lang/Locale/LangHomePage.cs
index ef8525c05..4a0c6f7b4 100644
--- a/Hi3Helper.Core/Lang/Locale/LangHomePage.cs
+++ b/Hi3Helper.Core/Lang/Locale/LangHomePage.cs
@@ -41,6 +41,7 @@ public sealed class LangHomePage
                 public string GameSettings_Panel2RepairGame { get; set; } = LangFallback?._HomePage.GameSettings_Panel2RepairGame;
                 public string GameSettings_Panel2UninstallGame { get; set; } = LangFallback?._HomePage.GameSettings_Panel2UninstallGame;
                 public string GameSettings_Panel2ConvertVersion { get; set; } = LangFallback?._HomePage.GameSettings_Panel2ConvertVersion;
+                public string GameSettings_Panel2MoveGameLocationGame { get; set; } = LangFallback?._HomePage.GameSettings_Panel2MoveGameLocationGame;
                 public string GameSettings_Panel2StopGame { get; set; } = LangFallback?._HomePage.GameSettings_Panel2StopGame;
                 public string GameSettings_Panel3 { get; set; } = LangFallback?._HomePage.GameSettings_Panel3;
                 public string GameSettings_Panel4 { get; set; } = LangFallback?._HomePage.GameSettings_Panel4;
diff --git a/Hi3Helper.Core/Lang/Locale/LangMisc.cs b/Hi3Helper.Core/Lang/Locale/LangMisc.cs
index 374a1ac67..57e414b20 100644
--- a/Hi3Helper.Core/Lang/Locale/LangMisc.cs
+++ b/Hi3Helper.Core/Lang/Locale/LangMisc.cs
@@ -23,6 +23,7 @@ public sealed class LangMisc
                 public string Cancel { get; set; } = LangFallback?._Misc.Cancel;
                 public string Close { get; set; } = LangFallback?._Misc.Close;
                 public string Skip { get; set; } = LangFallback?._Misc.Skip;
+                public string MoveToDifferentDir { get; set; } = LangFallback?._Misc.MoveToDifferentDir;
                 public string UseCurrentDir { get; set; } = LangFallback?._Misc.UseCurrentDir;
                 public string UseDefaultDir { get; set; } = LangFallback?._Misc.UseDefaultDir;
                 public string LocateDir { get; set; } = LangFallback?._Misc.LocateDir;
@@ -103,6 +104,11 @@ public sealed class LangMisc
                 public string Taskbar_ShowConsole { get; set; } = LangFallback?._Misc.Taskbar_ShowConsole;
                 public string Taskbar_HideConsole { get; set; } = LangFallback?._Misc.Taskbar_HideConsole;
                 public string Taskbar_ExitApp     { get; set; } = LangFallback?._Misc.Taskbar_ExitApp;
+
+                public string LauncherNameOfficial { get; set; } = LangFallback?._Misc.LauncherNameOfficial;
+                public string LauncherNameBHI3L { get; set; } = LangFallback?._Misc.LauncherNameBHI3L;
+                public string LauncherNameSteam { get; set; } = LangFallback?._Misc.LauncherNameSteam;
+                public string LauncherNameUnknown { get; set; } = LangFallback?._Misc.LauncherNameUnknown;
             }
         }
         #endregion