diff --git a/AssetEditor.sln b/AssetEditor.sln
index b59bb2955..d3895a800 100644
--- a/AssetEditor.sln
+++ b/AssetEditor.sln
@@ -98,6 +98,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Editors.AnimationMeta", "Ed
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Test.AnimationMeta", "Editors\AnimationMeta\Test.AnimationMeta\Test.AnimationMeta.csproj", "{E759BE6D-E0A4-46B8-A02A-E8573F579E2F}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AssetEditorUpdater", "AssetEditorUpdater\AssetEditorUpdater.csproj", "{24483A6F-DBD6-4415-B4D8-1A2FB86A2A12}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -228,6 +230,10 @@ Global
 		{E759BE6D-E0A4-46B8-A02A-E8573F579E2F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{E759BE6D-E0A4-46B8-A02A-E8573F579E2F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{E759BE6D-E0A4-46B8-A02A-E8573F579E2F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{24483A6F-DBD6-4415-B4D8-1A2FB86A2A12}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{24483A6F-DBD6-4415-B4D8-1A2FB86A2A12}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{24483A6F-DBD6-4415-B4D8-1A2FB86A2A12}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{24483A6F-DBD6-4415-B4D8-1A2FB86A2A12}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/AssetEditor/App.xaml.cs b/AssetEditor/App.xaml.cs
index fb81397e0..1c05f5b9d 100644
--- a/AssetEditor/App.xaml.cs
+++ b/AssetEditor/App.xaml.cs
@@ -1,15 +1,17 @@
 using System;
 using System.Diagnostics;
+using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Threading;
 using AssetEditor.Services;
+using AssetEditor.UiCommands;
 using AssetEditor.ViewModels;
 using AssetEditor.Views;
-using AssetEditor.Views.Settings;
 using Microsoft.Extensions.DependencyInjection;
 using Shared.Core.DependencyInjection;
 using Shared.Core.DevConfig;
 using Shared.Core.ErrorHandling;
+using Shared.Core.Events;
 using Shared.Core.PackFiles;
 using Shared.Core.PackFiles.Utility;
 using Shared.Core.Services;
@@ -29,7 +31,6 @@ protected override void OnStartup(StartupEventArgs e)
             PackFileLog.IsLoggingEnabled = false;
 
             ShutdownMode = ShutdownMode.OnExplicitShutdown;
-            VersionChecker.CheckVersion();
             Current.DispatcherUnhandledException += new DispatcherUnhandledExceptionEventHandler(DispatcherUnhandledExceptionHandler);
 
             var forceValidateServiceScopes = Debugger.IsAttached;
@@ -38,6 +39,8 @@ protected override void OnStartup(StartupEventArgs e)
             _ = _serviceProvider.GetRequiredService<RecentFilesTracker>(); // Force instance of the RecentFilesTracker
             _ = _serviceProvider.GetRequiredService<IScopeRepository>();  // Force instance of the IScopeRepository
 
+            var uiCommandFactory = _serviceProvider.GetRequiredService<IUiCommandFactory>();
+
             var settingsService = _serviceProvider.GetRequiredService<ApplicationSettingsService>();
             settingsService.AllowSettingsUpdate = true;
             settingsService.Load();
@@ -48,14 +51,7 @@ protected override void OnStartup(StartupEventArgs e)
 
             // Show the settings window if its the first time the tool is ran
             if (settingsService.CurrentSettings.IsFirstTimeStartingApplication)
-            {
-                var settingsWindow = _serviceProvider.GetRequiredService<SettingsWindow>();
-                settingsWindow.DataContext = _serviceProvider.GetRequiredService<SettingsViewModel>();
-                settingsWindow.ShowDialog();
-
-                settingsService.CurrentSettings.IsFirstTimeStartingApplication = false;
-                settingsService.Save();
-            }
+                HandleFirstTimeSettings(uiCommandFactory, settingsService);
 
             var devConfigManager = _serviceProvider.GetRequiredService<DevelopmentConfigurationManager>();
             devConfigManager.Initialize(e);
@@ -63,25 +59,38 @@ protected override void OnStartup(StartupEventArgs e)
 
             // Load all packfiles
             if (settingsService.CurrentSettings.LoadCaPacksByDefault)
-            {
-                var gamePath = settingsService.GetGamePathForCurrentGame();
-                if (gamePath != null)
-                {
-                    var packfileService = _serviceProvider.GetRequiredService<IPackFileService>();
-                    var containerLoader = _serviceProvider.GetRequiredService<IPackFileContainerLoader>();
-                    var loadRes = containerLoader.LoadAllCaFiles(settingsService.CurrentSettings.CurrentGame);
-
-                    if (loadRes == null)
-                        MessageBox.Show($"Unable to load all CA packfiles in {gamePath}");
-                    else
-                        packfileService.AddContainer(loadRes);
-                }
-            }
+                LoadCAPackFiles(settingsService);
 
             devConfigManager.CreateTestPackFiles();
             devConfigManager.OpenFileOnLoad();
 
             ShowMainWindow();
+
+            _ = CheckVersion(uiCommandFactory);
+        }
+
+        private static void HandleFirstTimeSettings(IUiCommandFactory uiCommandFactory, ApplicationSettingsService settingsService)
+        {
+            uiCommandFactory.Create<OpenSettingsDialogCommand>().Execute();
+
+            settingsService.CurrentSettings.IsFirstTimeStartingApplication = false;
+            settingsService.Save();
+        }
+
+        private void LoadCAPackFiles(ApplicationSettingsService settingsService)
+        {
+            var gamePath = settingsService.GetGamePathForCurrentGame();
+            if (gamePath != null)
+            {
+                var packfileService = _serviceProvider.GetRequiredService<IPackFileService>();
+                var containerLoader = _serviceProvider.GetRequiredService<IPackFileContainerLoader>();
+                var loadRes = containerLoader.LoadAllCaFiles(settingsService.CurrentSettings.CurrentGame);
+
+                if (loadRes == null)
+                    MessageBox.Show($"Unable to load all CA packfiles in {gamePath}");
+                else
+                    packfileService.AddContainer(loadRes);
+            }
         }
 
         void ShowMainWindow()
@@ -94,7 +103,7 @@ void ShowMainWindow()
             mainWindow.Closed += OnMainWindowClosed;
             mainWindow.Show();
 
-            // Ensure the window doesn't cover up the windows bar.
+            // Ensure the window doesn't cover up the windows bar
             mainWindow.MaxHeight = SystemParameters.MaximizedPrimaryScreenHeight;
             mainWindow.MaxWidth = SystemParameters.MaximizedPrimaryScreenWidth;
 
@@ -109,6 +118,13 @@ private void OnMainWindowClosed(object sender, EventArgs e)
             Shutdown();
         }
 
+        private static async Task CheckVersion(IUiCommandFactory uiCommandFactory)
+        {
+            var newerReleases = await VersionChecker.GetNewerReleases();
+            if (newerReleases != null)
+                uiCommandFactory.Create<OpenUpdaterWindowCommand>().Execute(newerReleases);
+        }
+
         void DispatcherUnhandledExceptionHandler(object sender, DispatcherUnhandledExceptionEventArgs args)
         {
             Logging.Create<App>().Here().Fatal(args.Exception.ToString());
diff --git a/AssetEditor/AssetEditor.csproj b/AssetEditor/AssetEditor.csproj
index 551719983..7c9a7c601 100644
--- a/AssetEditor/AssetEditor.csproj
+++ b/AssetEditor/AssetEditor.csproj
@@ -46,6 +46,7 @@
         <PackageProjectUrl>https://github.com/donkeyProgramming/TheAssetEditor</PackageProjectUrl>
         <RepositoryUrl>https://github.com/donkeyProgramming/TheAssetEditor</RepositoryUrl>
         <PackageId>AssetEditor</PackageId>
+        <Version>0.68.0</Version>
         <AnalysisLevel>6.0</AnalysisLevel>
     </PropertyGroup>
 
@@ -53,6 +54,10 @@
         <None Include="..\.editorconfig" />
     </ItemGroup>
 
+    <ItemGroup>
+      <PackageReference Include="MdXaml" Version="1.27.0" />
+    </ItemGroup>
+
     <ItemGroup>
       <Resource Include="AssetEditorIcon.png" />
     </ItemGroup>
@@ -77,4 +82,13 @@
         <GenerateDocumentationFile>False</GenerateDocumentationFile>
         <NoWarn>$(NoWarn),1573,1591,1712</NoWarn>
     </PropertyGroup>
+
+    <Target Name="PublishUpdater" AfterTargets="ComputeFilesToPublish">
+        <PropertyGroup>
+            <UpdaterProject>$(MSBuildProjectDirectory)\..\AssetEditorUpdater\AssetEditorUpdater.csproj</UpdaterProject>
+            <AbsolutePublishDir>$([System.IO.Path]::GetFullPath('$(PublishDir)'))</AbsolutePublishDir>
+        </PropertyGroup>
+
+        <MSBuild Projects="$(UpdaterProject)" Targets="Restore;Publish" Properties="PublishDir=$(AbsolutePublishDir);Configuration=$(Configuration);RuntimeIdentifier=$(RuntimeIdentifier);SelfContained=$(SelfContained);PublishSingleFile=$(PublishSingleFile);PublishReadyToRun=$(PublishReadyToRun)" />
+    </Target>
 </Project>
\ No newline at end of file
diff --git a/AssetEditor/DependencyInjectionContainer.cs b/AssetEditor/DependencyInjectionContainer.cs
index 21fa86b00..9633f055f 100644
--- a/AssetEditor/DependencyInjectionContainer.cs
+++ b/AssetEditor/DependencyInjectionContainer.cs
@@ -3,6 +3,7 @@
 using AssetEditor.ViewModels;
 using AssetEditor.Views;
 using AssetEditor.Views.Settings;
+using AssetEditor.Views.Updater;
 using Microsoft.Extensions.DependencyInjection;
 using Shared.Core.DependencyInjection;
 using Shared.Core.DevConfig;
@@ -24,6 +25,7 @@ public override void Register(IServiceCollection serviceCollection)
             serviceCollection.AddTransient<OpenGamePackCommand>();
             serviceCollection.AddTransient<OpenPackFileCommand>();
             serviceCollection.AddTransient<OpenSettingsDialogCommand>();
+            serviceCollection.AddTransient<OpenUpdaterWindowCommand>();
             serviceCollection.AddTransient<OpenWebpageCommand>();
             serviceCollection.AddTransient<PrintScopesCommand>();
             serviceCollection.AddTransient<OpenEditorCommand>();
@@ -31,6 +33,8 @@ public override void Register(IServiceCollection serviceCollection)
 
             serviceCollection.AddTransient<SettingsWindow>();
             serviceCollection.AddTransient<SettingsViewModel>();
+            serviceCollection.AddTransient<UpdaterWindow>();
+            serviceCollection.AddTransient<UpdaterViewModel>();
             serviceCollection.AddScoped<MenuBarViewModel>();
 
             serviceCollection.AddScoped<MainWindow>();
diff --git a/AssetEditor/UiCommands/OpenUpdaterWindowCommand.cs b/AssetEditor/UiCommands/OpenUpdaterWindowCommand.cs
new file mode 100644
index 000000000..c2047ae4e
--- /dev/null
+++ b/AssetEditor/UiCommands/OpenUpdaterWindowCommand.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using AssetEditor.ViewModels;
+using AssetEditor.Views.Updater;
+using Microsoft.Extensions.DependencyInjection;
+using Octokit;
+using Shared.Core.Events;
+
+namespace AssetEditor.UiCommands
+{
+    public class OpenUpdaterWindowCommand(IServiceProvider serviceProvider) : IUiCommand
+    {
+        private readonly IServiceProvider _serviceProvider = serviceProvider;
+
+        public void Execute(List<Release> newerReleases)
+        {
+            var window = _serviceProvider.GetRequiredService<UpdaterWindow>();
+            var viewModel = _serviceProvider.GetRequiredService<UpdaterViewModel>();
+            viewModel.SetReleaseInfo(newerReleases);
+            viewModel.SetCloseAction(window.Close);
+            window.DataContext = viewModel;
+            window.ShowDialog();
+        }
+    }
+}
+
diff --git a/AssetEditor/ViewModels/MainViewModel.cs b/AssetEditor/ViewModels/MainViewModel.cs
index e225e1429..f9ee1739c 100644
--- a/AssetEditor/ViewModels/MainViewModel.cs
+++ b/AssetEditor/ViewModels/MainViewModel.cs
@@ -55,7 +55,7 @@ public MainViewModel(
 
             ToolsFactory = toolFactory;
 
-            ApplicationTitle = $"AssetEditor v{VersionChecker.CurrentVersion}";
+            ApplicationTitle = $"AssetEditor v{VersionChecker.GetCurrentVersion()}";
             CurrentGame = $"Current Game: {GameInformationDatabase.GetGameById(applicationSettingsService.CurrentSettings.CurrentGame).DisplayName}";
         }
 
diff --git a/AssetEditor/ViewModels/UpdaterViewModel.cs b/AssetEditor/ViewModels/UpdaterViewModel.cs
new file mode 100644
index 000000000..6d5a0aad9
--- /dev/null
+++ b/AssetEditor/ViewModels/UpdaterViewModel.cs
@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.IO;
+using System.Text;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Octokit;
+using Serilog;
+using Shared.Core.ErrorHandling;
+using Shared.Core.Misc;
+using Shared.Core.Services;
+using Application = System.Windows.Application;
+
+namespace AssetEditor.ViewModels
+{
+    public class ReleaseNoteItem(Release release)
+    {
+        public string ReleaseName { get; } = release.Name;
+        public string PublishedAt { get; } = $"Published {release.PublishedAt.Value:dd MMM yyyy}";
+        public string ReleaseNotes { get; } = release.Body;
+    }
+
+    partial class UpdaterViewModel : ObservableObject
+    {
+        private readonly ILogger _logger = Logging.Create<UpdaterViewModel>();
+        private Action _closeAction;
+
+        private const string AssetEditorUpdaterExe = "AssetEditorUpdater.exe";
+
+        private List<Release> _newerReleases = [];
+
+        [ObservableProperty] private ObservableCollection<ReleaseNoteItem> _releaseNotesItems = [];
+
+        [ObservableProperty] private string _latestVersionInfo;
+
+        public void SetReleaseInfo(List<Release> newerReleases)
+        {
+            _newerReleases = newerReleases;
+
+            var currentVersion = VersionChecker.GetCurrentVersion();
+            var latestRelease = _newerReleases[0];
+            var latestVersion = VersionChecker.ParseReleaseVersion(latestRelease.TagName);
+
+            var stringBuilder = new StringBuilder();
+            stringBuilder.AppendLine($"A new version of AssetEditor is available! The AssetEditor donkeys have been busy...");
+            stringBuilder.AppendLine();
+            stringBuilder.AppendLine($"Your current version is {currentVersion}. The latest verison is {latestVersion}.");
+            stringBuilder.AppendLine();
+            stringBuilder.AppendLine("Update to get the changes detailed in the release notes below.");
+            LatestVersionInfo = stringBuilder.ToString();
+
+            ReleaseNotesItems.Clear();
+            foreach (var release in _newerReleases)
+                ReleaseNotesItems.Add(new ReleaseNoteItem(release));
+        }
+
+        [RelayCommand] public void Update()
+        {
+            if (Debugger.IsAttached)
+                return;
+
+            var currentVersion = VersionChecker.GetCurrentVersion();
+            var latestRelease = _newerReleases[0];
+            var latestVersion = VersionChecker.ParseReleaseVersion(latestRelease.TagName);
+            _logger.Information($"Updating AssetEditor from version {currentVersion} to version {latestVersion}");
+
+            DeleteUpdateDirectory();
+
+            LaunchUpdater();
+
+            Application.Current.Shutdown();
+        }
+
+        public static void DeleteUpdateDirectory()
+        {
+            var updateDirectory = DirectoryHelper.UpdateDirectory;
+            if (Directory.Exists(updateDirectory))
+                Directory.Delete(updateDirectory, true);
+        }
+
+        public static void LaunchUpdater()
+        {
+            var currentDirectory = AppContext.BaseDirectory;
+            var updaterPath = Path.Combine(currentDirectory, AssetEditorUpdaterExe);
+
+            var processStartInfo = new ProcessStartInfo
+            {
+                FileName = updaterPath,
+                WorkingDirectory = currentDirectory,
+                UseShellExecute = true,
+            };
+
+            if (UpdaterRequiresAdministratorPrivileges())
+                processStartInfo.Verb = "runas";
+
+            Process.Start(processStartInfo);
+        }
+
+        public static bool UpdaterRequiresAdministratorPrivileges()
+        {
+            try
+            {
+                var currentDirectory = AppContext.BaseDirectory;
+                var testFilePath = Path.Combine(currentDirectory, $"updater_admin_privileges_test{Guid.NewGuid():N}.tmp");
+
+                using (File.Create(testFilePath, 1, FileOptions.DeleteOnClose))
+                {
+                }
+
+                return false;
+            }
+            catch (UnauthorizedAccessException)
+            {
+                return true;
+            }
+        }
+
+        [RelayCommand] public void CloseWindowAction() => _closeAction?.Invoke();
+
+
+        public void SetCloseAction(Action closeAction) => _closeAction = closeAction;
+    }
+}
diff --git a/AssetEditor/Views/Updater/UpdaterWindow.xaml b/AssetEditor/Views/Updater/UpdaterWindow.xaml
new file mode 100644
index 000000000..e1781fb56
--- /dev/null
+++ b/AssetEditor/Views/Updater/UpdaterWindow.xaml
@@ -0,0 +1,121 @@
+<Window
+    x:Class="AssetEditor.Views.Updater.UpdaterWindow"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:Updater="clr-namespace:AssetEditor.Views.Updater"
+    xmlns:MdXaml="clr-namespace:MdXaml;assembly=MdXaml"
+    xmlns:ViewModels="clr-namespace:AssetEditor.ViewModels" 
+    d:DataContext="{d:DesignInstance Type=ViewModels:UpdaterViewModel}"
+    mc:Ignorable="d"
+    Style="{StaticResource CustomWindowStyle}"
+    Closed="OnClosed"
+    ResizeMode="NoResize"   
+    WindowStartupLocation="CenterScreen"
+    Height="545" 
+    Width="800"
+    Title="Asset Editor Updater">
+
+    <Grid
+        Margin="15, 15, 15, 15">
+
+        <Grid.RowDefinitions>
+            <RowDefinition 
+                Height="Auto"/>
+            <RowDefinition 
+                Height="Auto"/>
+            <RowDefinition 
+                Height="Auto"/>
+            <RowDefinition 
+                Height="Auto"/>
+            <RowDefinition 
+                Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <TextBlock
+            Grid.Row="0"
+            Text="{Binding LatestVersionInfo}"
+            FontSize="14"/>
+
+        <TextBlock
+            Grid.Row="1"
+            Text="Release Notes"
+            FontSize="20"
+            FontWeight="SemiBold"/>
+
+        <Border
+            Grid.Row="2"
+            BorderThickness="1"
+            BorderBrush="{DynamicResource App.Border}"
+            Margin="0, 10, 0, 0"
+            Height="300">
+
+            <ScrollViewer 
+                VerticalScrollBarVisibility="Auto"
+                Padding="10, 10, 10, 10">
+
+                <ItemsControl 
+                    ItemsSource="{Binding ReleaseNotesItems}">
+                    <ItemsControl.ItemTemplate>
+                        <DataTemplate>
+                            <Border 
+                                Padding="0, 0, 0, 20">
+                                <StackPanel>
+
+                                    <TextBlock
+                                        Text="{Binding ReleaseName}"
+                                        FontSize="18"
+                                        FontWeight="SemiBold"/>
+
+                                    <TextBlock
+                                        Margin="0,4,0,12"
+                                        Text="{Binding PublishedAt}"
+                                        FontSize="14"/>
+
+                                    <!-- Disable VerticalScrollBarVisibility as we don't won't loads of mini scroll viewers... -->
+                                    <MdXaml:MarkdownScrollViewer
+                                        Markdown="{Binding ReleaseNotes}"
+                                        VerticalAlignment="Stretch"
+                                        HorizontalAlignment="Stretch"
+                                        VerticalScrollBarVisibility="Disabled"
+                                        PreviewMouseWheel="OnMarkdownScrollViewerPreviewMouseWheel">
+
+                                        <MdXaml:MarkdownScrollViewer.Resources>
+                                            <Style 
+                                                TargetType="{x:Type List}">
+                                                <Setter 
+                                                    Property="FontSize" 
+                                                    Value="14"/>
+                                            </Style>
+                                        </MdXaml:MarkdownScrollViewer.Resources>
+                                    </MdXaml:MarkdownScrollViewer>
+                                </StackPanel>
+                            </Border>
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                </ItemsControl>
+            </ScrollViewer>
+        </Border>
+
+        <StackPanel 
+            Grid.Row="3" 
+            Orientation="Horizontal" 
+            HorizontalAlignment="Right" 
+            Margin="10, 10, 0, 10">
+
+            <Button 
+                Content="Update"
+                Width="75"
+                Height="25"
+                Margin="0, 0, 5, 0"
+                Command="{Binding UpdateCommand}"/>
+
+            <Button 
+                Content="Cancel" 
+                Width="75"
+                Margin="5, 0, 0, 0" 
+                Command="{Binding CloseWindowActionCommand}"/>
+        </StackPanel>
+    </Grid>
+</Window>
diff --git a/AssetEditor/Views/Updater/UpdaterWindow.xaml.cs b/AssetEditor/Views/Updater/UpdaterWindow.xaml.cs
new file mode 100644
index 000000000..70a04626a
--- /dev/null
+++ b/AssetEditor/Views/Updater/UpdaterWindow.xaml.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using AssetEditor.ViewModels;
+
+namespace AssetEditor.Views.Updater
+{
+    public partial class UpdaterWindow : Window
+    {
+        public UpdaterWindow()
+        {
+            InitializeComponent();
+            Loaded += OnWindowLoaded;
+        }
+
+        private void OnMarkdownScrollViewerPreviewMouseWheel(object sender, MouseWheelEventArgs e)
+        {
+            var scrollViewer = FindParentScrollViewer(sender as DependencyObject);
+            if (scrollViewer == null)
+                return;
+
+            e.Handled = true;
+
+            var eventArgs = new MouseWheelEventArgs(e.MouseDevice, e.Timestamp, e.Delta)
+            {
+                RoutedEvent = MouseWheelEvent,
+                Source = sender
+            };
+
+            scrollViewer.RaiseEvent(eventArgs);
+        }
+
+        private static ScrollViewer FindParentScrollViewer(DependencyObject element)
+        {
+            while (element != null)
+            {
+                if (element is ScrollViewer scrollViewer)
+                    return scrollViewer;
+
+                element = VisualTreeHelper.GetParent(element);
+            }
+
+            return null;
+        }
+
+        private void OnWindowLoaded(object sender, RoutedEventArgs e)
+        {
+            if (DataContext is UpdaterViewModel viewModel)
+                viewModel.SetCloseAction(this.Close);
+        }
+
+        private void OnClosed(object sender, EventArgs e)
+        {
+            if (DataContext is UpdaterViewModel viewModel)
+                viewModel.CloseWindowAction();
+        }
+    }
+}
diff --git a/AssetEditorUpdater/AssetEditorUpdater.cs b/AssetEditorUpdater/AssetEditorUpdater.cs
new file mode 100644
index 000000000..8ca9d3a66
--- /dev/null
+++ b/AssetEditorUpdater/AssetEditorUpdater.cs
@@ -0,0 +1,236 @@
+using System.Diagnostics;
+using Octokit;
+using SharpCompress.Archives;
+using FileMode = System.IO.FileMode;
+
+namespace AssetEditorUpdater
+{
+    public class AssetEditorUpdater
+    {
+        private const string GitHubOwner = "donkeyProgramming";
+        private const string GitHubRepository = "TheAssetEditor";
+        private const string AssetEditorExe = "AssetEditor.exe";
+        private const string AssetEditorUpdaterExe = "AssetEditorUpdater.exe";
+        // We assume the release RAR contains a single folder named AssetEditor with all the files for the update in it
+        private const string UpdateFilesDirectoryName = "AssetEditor";
+        private const string InstallationUpdateBackupDirectoryName = "UpdateBackup";
+         
+        public static async Task Main(string[] args)
+        {
+            // The first time the updater is run it should be from the installation directory (with no args)
+            // so we use the app's base directory to get the installation directory. When we rerun the updater
+            // from the update directory we pass the installation directory as an arg and access it that way.
+
+            var currentDirectory = AppContext.BaseDirectory;
+            var userDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+            var updateDirectory = Path.Combine(userDirectory, "AssetEditor", "Temp", "Update");
+
+            var isInitialLaunch = args.Length == 0;
+            var installationDirectory = isInitialLaunch ? currentDirectory : args[0];
+
+            Console.WriteLine($"Running updater from {currentDirectory}.");
+
+            if (isInitialLaunch)
+                RelaunchFromUpdateDirectory(updateDirectory, installationDirectory);
+            else
+                await UpdateAsync(installationDirectory, updateDirectory);
+        }
+
+        private static void RelaunchFromUpdateDirectory(string updateDirectory, string installationDirectory)
+        {
+            Console.WriteLine($"Copying updater to {updateDirectory} and relaunching...");
+
+            if (!Directory.Exists(updateDirectory))
+                Directory.CreateDirectory(updateDirectory);
+
+            var currentUpdaterPath = Path.Combine(installationDirectory, AssetEditorUpdaterExe);
+            var newUpdaterPath = Path.Combine(updateDirectory, AssetEditorUpdaterExe);
+            File.Copy(currentUpdaterPath, newUpdaterPath, true);
+
+            LaunchUpdater(newUpdaterPath, updateDirectory, installationDirectory);
+        }
+
+        private static void LaunchUpdater(string updaterPath, string workingDirectory, string installationDirectory)
+        {
+            var processStartInfo = new ProcessStartInfo
+            {
+                FileName = updaterPath,
+                WorkingDirectory = workingDirectory,
+                UseShellExecute = false,
+                ArgumentList = { installationDirectory }
+            };
+            Process.Start(processStartInfo);
+        }
+
+        private static async Task UpdateAsync(string installationDirectory, string updateDirectory)
+        {
+            var latestRelease = await GetLatestReleaseAsync();
+            if (latestRelease == null)
+                return;
+
+            var installedVersion = GetAssetEditorVersion(installationDirectory);
+            var latestVersion = ParseReleaseVersion(latestRelease.TagName);
+            if (installedVersion >= latestVersion)
+            {
+                Console.WriteLine("No update required.");
+                return;
+            }
+
+            Console.WriteLine($"Updating AssetEditor from version {installedVersion} to {latestVersion}.");
+
+            var asset = GetAsset(latestRelease);
+            var assetPath = Path.Combine(updateDirectory, asset.Name);
+            var downloadResult = await DownloadAssetAsync(asset.BrowserDownloadUrl, assetPath);
+            if (downloadResult == false)
+                return;
+
+            BackupOldFiles(installationDirectory);
+
+            ExtractRar(assetPath, installationDirectory);
+
+            var assetEditorPath = Path.Combine(installationDirectory, AssetEditorExe);
+            if (File.Exists(assetEditorPath))
+                LaunchAssetEditor(installationDirectory, assetEditorPath);
+            else
+                Console.WriteLine("Uh oh something with the update went wrong.");
+
+            Console.WriteLine("Press any key to close.");
+            Console.ReadKey();
+        }
+
+        private static async Task<Release?> GetLatestReleaseAsync()
+        {
+            try
+            {
+                var gitHubClient = new GitHubClient(new ProductHeaderValue("AssetEditor"));
+                var releases = await gitHubClient.Repository.Release.GetAll(GitHubOwner, GitHubRepository);
+                return releases.Count > 0 ? releases[0] : null;
+            }
+            catch (ApiException exception)
+            {
+                Console.WriteLine($"Unable to retrieve latest release from GitHub: {exception.Message}");
+                return null;
+            }
+        }
+
+        private static Version GetAssetEditorVersion(string installationDirectory)
+        {
+            var assetEditorPath = Path.Combine(installationDirectory, AssetEditorExe);
+            var versionInfo = FileVersionInfo.GetVersionInfo(assetEditorPath);
+            if (string.IsNullOrWhiteSpace(versionInfo.FileVersion))
+                return new Version();
+
+            var parsedVersion = new Version(versionInfo.FileVersion);
+            if (parsedVersion.Build == 0 && parsedVersion.Revision == 0)
+                return new Version(parsedVersion.Major, parsedVersion.Minor);
+
+            if (parsedVersion.Revision == 0)
+                return new Version(parsedVersion.Major, parsedVersion.Minor, parsedVersion.Build);
+
+            return parsedVersion;
+        }
+
+        private static Version ParseReleaseVersion(string tagName)
+        {
+            var cleanedVersion = tagName.Trim().TrimStart('v', 'V');
+            return new Version(cleanedVersion);
+        }
+
+        private static ReleaseAsset GetAsset(Release latestRelease)
+        {
+            if (latestRelease.Assets.Count != 1)
+                throw new InvalidOperationException($"Expected 1 asset, found {latestRelease.Assets.Count}.");
+
+            var asset = latestRelease.Assets[0];
+            var extension = Path.GetExtension(asset.Name);
+            if (extension != ".rar")
+                throw new InvalidOperationException($"Asset has extension {extension}, expected .rar.");
+
+            return asset;
+        }
+
+        private static async Task<bool> DownloadAssetAsync(string downloadUrl, string downloadPath)
+        {
+            Console.WriteLine("Downloading the latest release...");
+
+            try
+            {
+                using var client = new HttpClient();
+                client.DefaultRequestHeaders.UserAgent.ParseAdd("AssetEditor_instance");
+
+                using var response = await client.GetAsync(downloadUrl, HttpCompletionOption.ResponseHeadersRead);
+                response.EnsureSuccessStatusCode();
+
+                await using var responseStream = await response.Content.ReadAsStreamAsync();
+                await using var fileStream = new FileStream(downloadPath, FileMode.Create, FileAccess.Write, FileShare.None);
+                await responseStream.CopyToAsync(fileStream);
+                
+                return true;
+            }
+            catch
+            {
+                Console.WriteLine("Unable to download latest release from Github.");
+                return false;
+            }
+        }
+
+        private static void BackupOldFiles(string installationDirectory)
+        {
+            var updateBackupDirectory = Path.Combine(installationDirectory, InstallationUpdateBackupDirectoryName);
+            if (Directory.Exists(updateBackupDirectory))
+                Directory.Delete(updateBackupDirectory, true);
+            Directory.CreateDirectory(updateBackupDirectory);
+
+            Console.WriteLine($"Backing up files from {installationDirectory} to {updateBackupDirectory}...");
+
+            foreach (var entryPath in Directory.EnumerateFileSystemEntries(installationDirectory))
+            {
+                var entryName = Path.GetFileName(entryPath);
+                if (entryName == InstallationUpdateBackupDirectoryName)
+                    continue;
+
+                var destinationPath = Path.Combine(updateBackupDirectory, entryName);
+                if (Directory.Exists(entryPath))
+                    Directory.Move(entryPath, destinationPath);
+                else
+                    File.Move(entryPath, destinationPath);
+            }
+        }
+
+        private static void ExtractRar(string rarPath, string installationDirectory)
+        {
+            Console.WriteLine($"Extracting update files from {rarPath} to {installationDirectory}...");
+
+            var prefix = UpdateFilesDirectoryName + Path.DirectorySeparatorChar;
+
+            using var archive = ArchiveFactory.OpenArchive(rarPath);
+            foreach (var entry in archive.Entries)
+            {
+                if (entry.Key == null || entry.Key == UpdateFilesDirectoryName || entry.IsDirectory)
+                    continue;
+
+                var entryKeyWithoutPrefix = entry.Key[prefix.Length..];
+                var destinationPath = Path.Combine(installationDirectory, entryKeyWithoutPrefix);
+                Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
+                entry.WriteToFile(destinationPath);
+            }
+        }
+
+        private static void LaunchAssetEditor(string installationDirectory, string assetEditorPath)
+        {
+            Console.WriteLine("Update complete.");
+            Console.WriteLine("Relaunching AssetEditor...");
+
+            // We launch using explorer.exe as that ensures admin priveliges aren't used as they
+            // would otherwise automatically be used if the AssetEditorUpdater.exe required them.
+            var processStartInfo = new ProcessStartInfo
+            {
+                FileName = "explorer.exe",
+                WorkingDirectory = installationDirectory,
+                UseShellExecute = true,
+                Arguments = $"\"{assetEditorPath}\"".Trim()
+            };
+            Process.Start(processStartInfo);
+        }
+    }
+}
diff --git a/AssetEditorUpdater/AssetEditorUpdater.csproj b/AssetEditorUpdater/AssetEditorUpdater.csproj
new file mode 100644
index 000000000..2ec76ef0e
--- /dev/null
+++ b/AssetEditorUpdater/AssetEditorUpdater.csproj
@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0-windows</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Octokit" Version="14.0.0" />
+    <PackageReference Include="Serilog" Version="4.3.1" />
+    <PackageReference Include="SharpCompress" Version="0.46.3" />
+  </ItemGroup>
+
+</Project>
diff --git a/Shared/SharedCore/ErrorHandling/Exceptions/BasicExceptionInformationProvider.cs b/Shared/SharedCore/ErrorHandling/Exceptions/BasicExceptionInformationProvider.cs
index c9b6f3c16..e82a5ee92 100644
--- a/Shared/SharedCore/ErrorHandling/Exceptions/BasicExceptionInformationProvider.cs
+++ b/Shared/SharedCore/ErrorHandling/Exceptions/BasicExceptionInformationProvider.cs
@@ -42,7 +42,7 @@ void CreateGeneralInfo(ExceptionInformation extendedException)
             extendedException.Settings = _settingsService.CurrentSettings;
             extendedException.NumberOfOpenedEditors = ApplicationStateRecorder.GetNumberOfOpenedEditors();
             extendedException.RunTimeInSeconds = ApplicationStateRecorder.GetApplicationRunTimeInSec();
-            extendedException.AssetEditorVersion = VersionChecker.CurrentVersion;
+            extendedException.AssetEditorVersion = VersionChecker.GetCurrentVersion().ToString();
         }
 
         void CreateContext(ExceptionInformation extendedException)
diff --git a/Shared/SharedCore/Misc/DirectoryHelper.cs b/Shared/SharedCore/Misc/DirectoryHelper.cs
index 2d07fc7f3..aae7fb888 100644
--- a/Shared/SharedCore/Misc/DirectoryHelper.cs
+++ b/Shared/SharedCore/Misc/DirectoryHelper.cs
@@ -9,6 +9,7 @@ public class DirectoryHelper
         public static string ReportsDirectory { get { return ApplicationDirectory + "\\Reports"; } }
         public static string Applications { get { return ApplicationDirectory + "\\Applications"; } }
         public static string Temp { get { return ApplicationDirectory + "\\Temp"; } }
+        public static string UpdateDirectory { get { return Temp + "\\Update"; } }
         public static string AnimationIndexMappingDirectory { get { return ApplicationDirectory + "\\Animation\\BoneIndexMapping"; } }
 
         public static void EnsureCreated()
diff --git a/Shared/SharedCore/Services/VersionChecker.cs b/Shared/SharedCore/Services/VersionChecker.cs
index 36a0d2068..8e54fd627 100644
--- a/Shared/SharedCore/Services/VersionChecker.cs
+++ b/Shared/SharedCore/Services/VersionChecker.cs
@@ -1,98 +1,75 @@
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Windows;
+using System.Reflection;
 using Octokit;
+using Shared.Core.ErrorHandling;
 
 namespace Shared.Core.Services
 {
     public class VersionChecker
     {
-        private static readonly string s_gitHubLink = @"https://github.com/donkeyProgramming/TheAssetEditor/releases/latest";
-        public static string CurrentVersion { get => "0.69"; }
+        private static readonly ILogger s_logger = Logging.Create<VersionChecker>();
 
-        public static void CheckVersion()
-        {
-            if (Debugger.IsAttached)
-                return;
+        private const string GitHubOwner = "donkeyProgramming";
+        private const string GitHubRepository = "TheAssetEditor";
 
-            try
-            {
-                var client = new GitHubClient(new ProductHeaderValue("AssetEditor_instance"));
+        public static async Task<List<Release>?> GetNewerReleases()
+        {
+            var releases = await GetReleasesAsync();
+            if (releases == null || releases.Count == 0)
+                return null;
 
-                client.Repository.Release.GetAll("donkeyProgramming", "TheAssetEditor").ContinueWith(
-                    task =>
-                    {
-                        try
-                        {
-                            if (task.IsFaulted)
-                            {
-                                Exception? ex = task.Exception;
-                                while (ex is AggregateException && ex.InnerException != null)
-                                    ex = ex.InnerException;
-                                if (ex != null)
-                                    throw ex;
-                            }
+            var currentVersion = GetCurrentVersion();
+            var newerReleases = GetReleasesSinceCurrentVersion(releases, currentVersion);
+            if (newerReleases.Count > 0)
+                return newerReleases;
 
-                            var releases = task.Result;
-                            var latest = releases.First();
-                            var currentVersion = "v" + CurrentVersion;
+            return null;
+        }
 
-                            if (!latest.TagName.Contains(currentVersion, StringComparison.InvariantCultureIgnoreCase))
-                            {
-                                ProcessMessage(latest, currentVersion);
-                            }
-                        }
-                        catch
-                        {
-                            MessageBox.Show("Unable to contact Github to check for later version");
-                        }
-                    }
-                );
+        private static async Task<IReadOnlyList<Release>?> GetReleasesAsync()
+        {
+            try
+            {
+                var gitHubClient = new GitHubClient(new ProductHeaderValue("AssetEditor"));
+                var releases = await gitHubClient.Repository.Release.GetAll(GitHubOwner, GitHubRepository);
+                return releases.Count > 0 ? releases : null;
             }
-            catch
+            catch (ApiException exception)
             {
-                MessageBox.Show("Unable to contact Github to check for later version");
+                s_logger.Information($"Unable to retrieve latest release from GitHub: {exception.Message}");
+                return null;
             }
         }
 
-        private static void ProcessMessage(Release lastRelease, string currentVersion)
+        private static List<Release> GetReleasesSinceCurrentVersion(IReadOnlyList<Release> releases, Version currentVersion)
         {
-            var changes = "\n" + lastRelease.Body;
-            var changesIndented = changes.Replace("\n", "\n\t");
-            var message = $"You are using an old version {currentVersion}, please go to\n{s_gitHubLink} to download {lastRelease.TagName} \n\nChanges:{changesIndented}\n\nGo to download page now?";
+            var newerReleases = new List<Release>();
+            foreach (var release in releases)
+            {
+                var releaseVersion = ParseReleaseVersion(release.TagName);
+                if (releaseVersion > currentVersion)
+                    newerReleases.Add(release);
+                else
+                    break;
+            }
+            return newerReleases;
+        }
+
+        public static Version GetCurrentVersion()
+        {
+            var version = Assembly.GetEntryAssembly()?.GetName().Version;
+            if (version == null)
+                throw new Exception("Current version is unknown.");
 
-            var messageBoxResult = MessageBox.Show(message, "Version checker", MessageBoxButton.YesNo);
-            if (messageBoxResult == MessageBoxResult.Yes)
-                OpenUrl(s_gitHubLink);
+            if (version.Build == 0 && version.Revision == 0)
+                return new Version(version.Major, version.Minor);
+
+            return new Version(version.Major, version.Minor, version.Build);
         }
 
-        private static void OpenUrl(string url)
+        public static Version ParseReleaseVersion(string tagName)
         {
-            try
-            {
-                Process.Start(url);
-            }
-            catch
-            {
-                // hack because of this: https://github.com/dotnet/corefx/issues/10361
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                {
-                    url = url.Replace("&", "^&");
-                    Process.Start(new ProcessStartInfo("cmd", $"/c start {url}") { CreateNoWindow = true });
-                }
-                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-                {
-                    Process.Start("xdg-open", url);
-                }
-                else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-                {
-                    Process.Start("open", url);
-                }
-                else
-                {
-                    throw;
-                }
-            }
+            var cleanedVersion = tagName.Trim().TrimStart('v', 'V');
+            return new Version(cleanedVersion);
         }
     }
 }