Add support for Zed code editor

#3732

Flax.flaxproj

@@ -4,7 +4,7 @@
     "Major": 1,
     "Minor": 11,
     "Revision": 0,
-    "Build": 6801
+    "Build": 6802
   },
   "Company": "Flax",
   "Copyright": "Copyright (c) 2012-2025 Wojciech Figat. All rights reserved.",

README.md

@@ -49,7 +49,7 @@ Follow the instructions below to compile and run the engine from source.
   * Fedora: `sudo dnf install dotnet-sdk-8.0`
   * Arch: `sudo pacman -S dotnet-sdk-8.0 dotnet-runtime-8.0 dotnet-targeting-pack-8.0 dotnet-host`
 * Install Vulkan SDK ([https://vulkan.lunarg.com/](https://vulkan.lunarg.com/))
-  * Ubuntu: `sudo apt install vulkan-sdk`
+  * Ubuntu: `sudo apt install vulkan-sdk` (deprecated, follow official docs)
   * Fedora: `sudo dnf install vulkan-headers vulkan-tools vulkan-validation-layers`
   * Arch: `sudo pacman -S vulkan-headers vulkan-tools vulkan-validation-layers`
 * Install Git with LFS
@@ -60,7 +60,7 @@ Follow the instructions below to compile and run the engine from source.
   * Ubuntu: `sudo apt-get install libx11-dev libxcursor-dev libxinerama-dev zlib1g-dev`
   * Fedora: `sudo dnf install libX11-devel libXcursor-devel  libXinerama-devel ghc-zlib-devel`
   * Arch: `sudo pacman -S base-devel libx11 libxcursor libxinerama zlib`
-* Install Clang compiler (version 6 or later):
+* Install Clang compiler (version 14 or later):
   * Ubuntu: `sudo apt-get install clang lldb lld`
   * Fedora: `sudo dnf install clang llvm lldb lld`
   * Arch: `sudo pacman -S clang lldb lld`

Source/Editor/Content/Proxy/AssetProxy.cs

@@ -130,6 +130,11 @@ namespace FlaxEditor.Content
             eyeAdaptation.Mode = EyeAdaptationMode.None;
             eyeAdaptation.OverrideFlags |= EyeAdaptationSettingsOverride.Mode;
             preview.PostFxVolume.EyeAdaptation = eyeAdaptation;
+
+            var antiAliasing = preview.PostFxVolume.AntiAliasing;
+            antiAliasing.Mode = AntialiasingMode.FastApproximateAntialiasing;
+            antiAliasing.OverrideFlags |= AntiAliasingSettingsOverride.Mode;
+            preview.PostFxVolume.AntiAliasing = antiAliasing;
         }
     }
 }

Source/Editor/CustomEditors/Editors/CollectionEditor.cs

@@ -71,7 +71,7 @@ namespace FlaxEditor.CustomEditors.Editors
 
                 menu.AddButton("Copy", linkedEditor.Copy);
                 var b = menu.AddButton("Duplicate", () => Editor.Duplicate(Index));
-                b.Enabled = linkedEditor.CanPaste && !Editor._readOnly && Editor._canResize;
+                b.Enabled = !Editor._readOnly && Editor._canResize;
                 b = menu.AddButton("Paste", linkedEditor.Paste);
                 b.Enabled = linkedEditor.CanPaste && !Editor._readOnly;
 
@@ -407,7 +407,7 @@ namespace FlaxEditor.CustomEditors.Editors
 
                 menu.AddButton("Copy", linkedEditor.Copy);
                 var b = menu.AddButton("Duplicate", () => Editor.Duplicate(Index));
-                b.Enabled = linkedEditor.CanPaste && !Editor._readOnly && Editor._canResize;
+                b.Enabled = !Editor._readOnly && Editor._canResize;
                 var paste = menu.AddButton("Paste", linkedEditor.Paste);
                 paste.Enabled = linkedEditor.CanPaste && !Editor._readOnly;
 

Source/Editor/GUI/Tree/Tree.cs

@@ -447,8 +447,8 @@ namespace FlaxEditor.GUI.Tree
                                 // Select previous parent child
                                 var select = nodeParent.GetChild(myIndex - 1) as TreeNode;
 
-                                // Select last child if is valid and expanded and has any children
-                                if (select != null && select.IsExpanded && select.HasAnyVisibleChild)
+                                // Get bottom most child node
+                                while (select != null && select.IsExpanded && select.HasAnyVisibleChild)
                                 {
                                     select = select.GetChild(select.ChildrenCount - 1) as TreeNode;
                                 }

Source/Editor/Modules/SourceCodeEditing/DefaultSourceCodeEditor.cs

@@ -40,10 +40,11 @@ namespace FlaxEditor.Modules.SourceCodeEditing
             var codeEditing = Editor.Instance.CodeEditing;
             var vsCode = codeEditing.GetInBuildEditor(CodeEditorTypes.VSCode);
             var rider = codeEditing.GetInBuildEditor(CodeEditorTypes.Rider);
+            var zed = codeEditing.GetInBuildEditor(CodeEditorTypes.Zed);
 
 #if PLATFORM_WINDOW
             // Favor the newest Visual Studio
-            for (int i = (int)CodeEditorTypes.VS2019; i >= (int)CodeEditorTypes.VS2008; i--)
+            for (int i = (int)CodeEditorTypes.VS2026; i >= (int)CodeEditorTypes.VS2008; i--)
             {
                 var visualStudio = codeEditing.GetInBuildEditor((CodeEditorTypes)i);
                 if (visualStudio != null)
@@ -66,6 +67,8 @@ namespace FlaxEditor.Modules.SourceCodeEditing
                 _currentEditor = vsCode;
             else if (rider != null)
                 _currentEditor = rider;
+            else if (zed != null)
+                _currentEditor = zed;
             else
                 _currentEditor = codeEditing.GetInBuildEditor(CodeEditorTypes.SystemDefault);
         }

Source/Editor/Modules/SourceCodeEditing/InBuildSourceCodeEditor.cs

@@ -66,6 +66,9 @@ namespace FlaxEditor.Modules.SourceCodeEditing
             case CodeEditorTypes.Rider:
                 Name = "Rider";
                 break;
+            case CodeEditorTypes.Zed:
+                Name = "Zed";
+                break;
             default: throw new ArgumentOutOfRangeException(nameof(type), type, null);
             }
         }
@@ -83,6 +86,7 @@ namespace FlaxEditor.Modules.SourceCodeEditing
                 case CodeEditorTypes.VSCodeInsiders:
                 case CodeEditorTypes.VSCode: return "-vscode -vs2022";
                 case CodeEditorTypes.Rider: return "-vs2022";
+                case CodeEditorTypes.Zed: return "-vs2022";
                 default: return null;
                 }
             }

Source/Editor/Scripting/CodeEditor.cpp

@@ -6,6 +6,7 @@
 #include "ScriptsBuilder.h"
 #include "CodeEditors/VisualStudioCodeEditor.h"
 #include "CodeEditors/RiderCodeEditor.h"
+#include "CodeEditors/ZedEditor.h"
 #if USE_VISUAL_STUDIO_DTE
 #include "CodeEditors/VisualStudio/VisualStudioEditor.h"
 #endif
@@ -241,6 +242,7 @@ bool CodeEditingManagerService::Init()
 #endif
     VisualStudioCodeEditor::FindEditors(&CodeEditors);
     RiderCodeEditor::FindEditors(&CodeEditors);
+    ZedEditor::FindEditors(&CodeEditors);
     CodeEditors.Add(New<SystemDefaultCodeEditor>());
 
     return false;

Source/Editor/Scripting/CodeEditor.h

@@ -77,6 +77,11 @@ API_ENUM(Namespace="FlaxEditor", Attributes="HideInEditor") enum class CodeEdito
     /// </summary>
     VSCodeInsiders,
 
+    /// <summary>
+    /// Zed
+    /// </summary>
+    Zed,
+
     /// <summary>
     /// Rider
     /// </summary>

Source/Editor/Scripting/CodeEditors/ZedEditor.cpp

@@ -0,0 +1,171 @@
+// Copyright (c) Wojciech Figat. All rights reserved.
+
+#include "ZedEditor.h"
+#include "Engine/Platform/FileSystem.h"
+#include "Engine/Platform/CreateProcessSettings.h"
+#include "Engine/Core/Log.h"
+#include "Editor/Editor.h"
+#include "Editor/ProjectInfo.h"
+#include "Editor/Scripting/ScriptsBuilder.h"
+#include "Engine/Engine/Globals.h"
+#if PLATFORM_LINUX
+#include <stdio.h>
+#elif PLATFORM_WINDOWS
+#include "Engine/Platform/Win32/IncludeWindowsHeaders.h"
+#elif PLATFORM_MAC
+#include "Engine/Platform/Apple/AppleUtils.h"
+#include <AppKit/AppKit.h>
+#endif
+
+ZedEditor::ZedEditor(const String& execPath)
+    : _execPath(execPath)
+    , _workspacePath(Globals::ProjectFolder)
+{
+}
+
+void ZedEditor::FindEditors(Array<CodeEditor*>* output)
+{
+#if PLATFORM_WINDOWS
+    String cmd;
+    if (Platform::ReadRegValue(HKEY_CURRENT_USER, TEXT("SOFTWARE\\Classes\\Applications\\Zed.exe\\shell\\open\\command"), TEXT(""), &cmd) || cmd.IsEmpty())
+    {
+        if (Platform::ReadRegValue(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Classes\\Applications\\Zed.exe\\shell\\open\\command"), TEXT(""), &cmd) || cmd.IsEmpty())
+        {
+            // No hits in registry, try default path instead
+        }
+    }
+    String path;
+    if (cmd.IsEmpty())
+    {
+        path = cmd.Substring(1, cmd.Length() - String(TEXT("\" \"%1\"")).Length() - 1);
+    }
+    else
+    {
+        String localAppDataPath;
+        FileSystem::GetSpecialFolderPath(SpecialFolder::LocalAppData, localAppDataPath);
+        path = localAppDataPath / TEXT("Programs/Zed/Zed.exe");
+    }
+    if (FileSystem::FileExists(path))
+    {
+        output->Add(New<ZedEditor>(path));
+    }
+#elif PLATFORM_LINUX
+    char buffer[128];
+    FILE* pipe = popen("/bin/bash -c \"type -p code\"", "r");
+    if (pipe)
+    {
+        StringAnsi pathAnsi;
+        while (fgets(buffer, sizeof(buffer), pipe) != NULL)
+            pathAnsi += buffer;
+        pclose(pipe);
+        const String path(pathAnsi.Get(), pathAnsi.Length() != 0 ? pathAnsi.Length() - 1 : 0);
+        if (FileSystem::FileExists(path))
+        {
+            output->Add(New<VisualStudioCodeEditor>(path, false));
+            return;
+        }
+    }
+    {
+        const String path(TEXT("/usr/bin/code"));
+        if (FileSystem::FileExists(path))
+        {
+            output->Add(New<VisualStudioCodeEditor>(path, false));
+            return;
+        }
+    }
+
+    // Detect Flatpak installations
+    {
+        CreateProcessSettings procSettings;
+        procSettings.FileName = TEXT("/bin/bash -c \"flatpak list --app --columns=application | grep com.visualstudio.code -c\"");
+        procSettings.HiddenWindow = true;
+        if (Platform::CreateProcess(procSettings) == 0)
+        {
+            const String runPath(TEXT("flatpak run com.visualstudio.code"));
+            output->Add(New<VisualStudioCodeEditor>(runPath, false));
+            return;
+        }
+    }
+#elif PLATFORM_MAC
+    // System installed app
+    NSURL* AppURL = [[NSWorkspace sharedWorkspace]URLForApplicationWithBundleIdentifier:@"com.microsoft.VSCode"];
+    if (AppURL != nullptr)
+    {
+        const String path = AppleUtils::ToString((CFStringRef)[AppURL path]);
+        output->Add(New<VisualStudioCodeEditor>(path, false));
+        return;
+    }
+
+    // Predefined locations
+    String userFolder;
+    FileSystem::GetSpecialFolderPath(SpecialFolder::Documents, userFolder);
+    String paths[3] =
+    {
+        TEXT("/Applications/Visual Studio Code.app"),
+        userFolder + TEXT("/../Visual Studio Code.app"),
+        userFolder + TEXT("/../Downloads/Visual Studio Code.app"),
+    };
+    for (const String& path : paths)
+    {
+        if (FileSystem::DirectoryExists(path))
+        {
+            output->Add(New<VisualStudioCodeEditor>(path, false));
+            break;
+        }
+    }
+#endif
+}
+
+CodeEditorTypes ZedEditor::GetType() const
+{
+    return CodeEditorTypes::Zed;
+}
+
+String ZedEditor::GetName() const
+{
+    return TEXT("Zed");
+}
+
+void ZedEditor::OpenFile(const String& path, int32 line)
+{
+    // Generate VS solution files for intellisense
+    if (!FileSystem::FileExists(Globals::ProjectFolder / Editor::Project->Name + TEXT(".sln")))
+    {
+        ScriptsBuilder::GenerateProject(TEXT("-vs2022"));
+    }
+
+    // Open file
+    line = line > 0 ? line : 1;
+    CreateProcessSettings procSettings;
+    procSettings.FileName = _execPath;
+    procSettings.Arguments = String::Format(TEXT("\"{0}\" \"{1}:{2}\""), _workspacePath, path, line);
+    procSettings.HiddenWindow = false;
+    procSettings.WaitForEnd = false;
+    procSettings.LogOutput = false;
+    procSettings.ShellExecute = true;
+    Platform::CreateProcess(procSettings);
+}
+
+void ZedEditor::OpenSolution()
+{
+    // Generate VS solution files for intellisense
+    if (!FileSystem::FileExists(Globals::ProjectFolder / Editor::Project->Name + TEXT(".sln")))
+    {
+        ScriptsBuilder::GenerateProject(TEXT("-vs2022"));
+    }
+
+    // Open solution
+    CreateProcessSettings procSettings;
+    procSettings.FileName = _execPath;
+    procSettings.Arguments = String::Format(TEXT("\"{0}\""), _workspacePath);
+    procSettings.HiddenWindow = false;
+    procSettings.WaitForEnd = false;
+    procSettings.LogOutput = false;
+    procSettings.ShellExecute = true;
+    Platform::CreateProcess(procSettings);
+}
+
+bool ZedEditor::UseAsyncForOpen() const
+{
+    return false;
+}

Source/Editor/Scripting/CodeEditors/ZedEditor.h

@@ -0,0 +1,41 @@
+// Copyright (c) Wojciech Figat. All rights reserved.
+
+#pragma once
+
+#include "Editor/Scripting/CodeEditor.h"
+
+/// <summary>
+/// Implementation of code editor utility that is using Microsoft Visual Studio Code.
+/// </summary>
+class ZedEditor : public CodeEditor
+{
+private:
+
+    String _execPath;
+    String _workspacePath;
+
+public:
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="VisualStudioEditor"/> class.
+    /// </summary>
+    /// <param name="execPath">Executable file path</param>
+    ZedEditor(const String& execPath);
+
+public:
+
+    /// <summary>
+    /// Tries to find installed Visual Studio Code instance. Adds them to the result list.
+    /// </summary>
+    /// <param name="output">The output editors.</param>
+    static void FindEditors(Array<CodeEditor*>* output);
+
+public:
+
+    // [CodeEditor]
+    CodeEditorTypes GetType() const override;
+    String GetName() const override;
+    void OpenFile(const String& path, int32 line) override;
+    void OpenSolution() override;
+    bool UseAsyncForOpen() const override;
+};

Source/Editor/Viewport/PrefabWindowViewport.cs

@@ -74,7 +74,7 @@ namespace FlaxEditor.Viewport
         private PrefabUIEditorRoot _uiRoot;
         private bool _showUI = false;
 
-        private int _defaultScaleActiveIndex = 0;
+        private int _defaultScaleActiveIndex = -1;
         private int _customScaleActiveIndex = -1;
         private ContextMenuButton _uiModeButton;
         private ContextMenuChildMenu _uiViewOptions;

Source/Editor/Windows/SceneTreeWindow.cs

@@ -319,22 +319,22 @@ namespace FlaxEditor.Windows
         {
             if (assetItem.IsOfType<SceneAsset>())
                 return true;
-            return assetItem.OnEditorDrag(this);
+            return assetItem.OnEditorDrag(this) && Level.IsAnySceneLoaded;
         }
 
         private static bool ValidateDragActorType(ScriptType actorType)
         {
-            return Editor.Instance.CodeEditing.Actors.Get().Contains(actorType);
+            return Editor.Instance.CodeEditing.Actors.Get().Contains(actorType) && Level.IsAnySceneLoaded;
         }
 
         private static bool ValidateDragControlType(ScriptType controlType)
         {
-            return Editor.Instance.CodeEditing.Controls.Get().Contains(controlType);
+            return Editor.Instance.CodeEditing.Controls.Get().Contains(controlType) && Level.IsAnySceneLoaded;
         }
 
         private static bool ValidateDragScriptItem(ScriptItem script)
         {
-            return Editor.Instance.CodeEditing.Actors.Get(script) != ScriptType.Null;
+            return Editor.Instance.CodeEditing.Actors.Get(script) != ScriptType.Null && Level.IsAnySceneLoaded;
         }
 
         /// <inheritdoc />
@@ -490,6 +490,7 @@ namespace FlaxEditor.Windows
             if (result == DragDropEffect.None)
             {
                 _isDropping = true;
+
                 // Drag assets
                 if (_dragAssets != null && _dragAssets.HasValidDrag)
                 {
@@ -504,7 +505,7 @@ namespace FlaxEditor.Windows
                         }
                         var actor = item.OnEditorDrop(this);
                         actor.Name = item.ShortName;
-                        Level.SpawnActor(actor);
+                        Editor.SceneEditing.Spawn(actor);
                         var graphNode = Editor.Scene.GetActorNode(actor.ID);
                         if (graphNode != null)
                             graphNodes.Add(graphNode);
@@ -527,7 +528,7 @@ namespace FlaxEditor.Windows
                             continue;
                         }
                         actor.Name = item.Name;
-                        Level.SpawnActor(actor);
+                        Editor.SceneEditing.Spawn(actor);
                         Editor.Scene.MarkSceneEdited(actor.Scene);
                     }
                     result = DragDropEffect.Move;
@@ -549,7 +550,7 @@ namespace FlaxEditor.Windows
                             Control = control,
                             Name = item.Name,
                         };
-                        Level.SpawnActor(uiControl);
+                        Editor.SceneEditing.Spawn(uiControl);
                         Editor.Scene.MarkSceneEdited(uiControl.Scene);
                     }
                     result = DragDropEffect.Move;
@@ -571,7 +572,7 @@ namespace FlaxEditor.Windows
                                 continue;
                             }
                             actor.Name = actorType.Name;
-                            Level.SpawnActor(actor);
+                            Editor.SceneEditing.Spawn(actor);
                             var graphNode = Editor.Scene.GetActorNode(actor.ID);
                             if (graphNode != null)
                                 graphNodes.Add(graphNode);

Source/Engine/Core/Memory/Allocation.h

@@ -208,7 +208,7 @@ public:
         typedef typename FallbackAllocation::template Data<T> FallbackData;
 
         bool _useFallback = false;
-        byte _data[Capacity * sizeof(T)];
+        alignas(sizeof(void*)) byte _data[Capacity * sizeof(T)];
         FallbackData _fallback;
 
     public:

Source/Engine/GraphicsDevice/DirectX/DX12/GPUContextDX12.cpp

@@ -491,7 +491,7 @@ void GPUContextDX12::flushUAVs()
     ASSERT(uaCount <= GPU_MAX_UA_BINDED);
 
     // Fill table with source descriptors
-    DxShaderHeader& header = _currentCompute ? ((GPUShaderProgramCSDX12*)_currentCompute)->Header : _currentState->Header;
+    DxShaderHeader& header = _isCompute ? ((GPUShaderProgramCSDX12*)_currentCompute)->Header : _currentState->Header;
     D3D12_CPU_DESCRIPTOR_HANDLE srcDescriptorRangeStarts[GPU_MAX_UA_BINDED];
     for (uint32 i = 0; i < uaCount; i++)
     {

Source/Engine/GraphicsDevice/Vulkan/GPUContextVulkan.cpp

@@ -114,7 +114,7 @@ GPUContextVulkan::GPUContextVulkan(GPUDeviceVulkan* device, QueueVulkan* queue)
 #if GPU_ENABLE_TRACY
 #if VK_EXT_calibrated_timestamps && VK_EXT_host_query_reset && !PLATFORM_SWITCH
     // Use calibrated timestamps extension
-    if (vkResetQueryPoolEXT && vkGetCalibratedTimestampsEXT)
+    if (vkResetQueryPoolEXT && vkGetCalibratedTimestampsEXT && _device->PhysicalDeviceFeatures12.hostQueryReset)
     {
         _tracyContext = tracy::CreateVkContext(_device->Adapter->Gpu, _device->Device, vkResetQueryPoolEXT, vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, vkGetCalibratedTimestampsEXT);
     }

Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.cpp

@@ -1568,7 +1568,15 @@ bool GPUDeviceVulkan::Init()
     vkGetPhysicalDeviceQueueFamilyProperties(gpu, &queueCount, QueueFamilyProps.Get());
 
     // Query device features
+    RenderToolsVulkan::ZeroStruct(PhysicalDeviceFeatures12, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES);
     vkGetPhysicalDeviceFeatures(gpu, &PhysicalDeviceFeatures);
+    if (vkGetPhysicalDeviceFeatures2)
+    {
+        VkPhysicalDeviceFeatures2 features2;
+        RenderToolsVulkan::ZeroStruct(features2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
+        features2.pNext = &PhysicalDeviceFeatures12;
+        vkGetPhysicalDeviceFeatures2(gpu, &features2);
+    }
 
     // Get extensions and layers
     Array<const char*> deviceExtensions;
@@ -1671,6 +1679,16 @@ bool GPUDeviceVulkan::Init()
     VulkanPlatform::RestrictEnabledPhysicalDeviceFeatures(PhysicalDeviceFeatures, enabledFeatures);
     deviceInfo.pEnabledFeatures = &enabledFeatures;
 
+#if GPU_ENABLE_TRACY && VK_EXT_calibrated_timestamps && VK_EXT_host_query_reset
+    VkPhysicalDeviceHostQueryResetFeatures resetFeatures;
+    if (PhysicalDeviceFeatures12.hostQueryReset)
+    {
+        RenderToolsVulkan::ZeroStruct(resetFeatures, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES);
+        resetFeatures.hostQueryReset = VK_TRUE;
+        deviceInfo.pNext = &resetFeatures;
+    }
+#endif
+
     // Create the device
     VALIDATE_VULKAN_RESULT(vkCreateDevice(gpu, &deviceInfo, nullptr, &Device));
 

Source/Engine/GraphicsDevice/Vulkan/GPUDeviceVulkan.h

@@ -496,6 +496,7 @@ public:
     /// The physical device enabled features.
     /// </summary>
     VkPhysicalDeviceFeatures PhysicalDeviceFeatures;
+    VkPhysicalDeviceVulkan12Features PhysicalDeviceFeatures12;
 
     Array<BufferedQueryPoolVulkan*> TimestampQueryPools;
     Array<BufferedQueryPoolVulkan*> OcclusionQueryPools;

Source/Engine/Physics/PhysX/PhysicsBackendPhysX.cpp

@@ -1969,6 +1969,7 @@ void PhysicsBackend::EndSimulateScene(void* scene)
         scenePhysX->EventsCallback.SendTriggerEvents();
         scenePhysX->EventsCallback.SendCollisionEvents();
         scenePhysX->EventsCallback.SendJointEvents();
+        scenePhysX->EventsCallback.Clear();
     }
 
     // Clear delta after simulation ended
@@ -4466,14 +4467,14 @@ void PhysicsBackend::FlushRequests(void* scene)
     }
     if (scenePhysX->RemoveColliders.HasItems())
     {
-        for (int32 i = 0; i < scenePhysX->RemoveColliders.Count(); i++)
-            scenePhysX->EventsCallback.OnColliderRemoved(scenePhysX->RemoveColliders[i]);
+        for (PhysicsColliderActor* e : scenePhysX->RemoveColliders)
+            scenePhysX->EventsCallback.OnColliderRemoved(e);
         scenePhysX->RemoveColliders.Clear();
     }
     if (scenePhysX->RemoveJoints.HasItems())
     {
-        for (int32 i = 0; i < scenePhysX->RemoveJoints.Count(); i++)
-            scenePhysX->EventsCallback.OnJointRemoved(scenePhysX->RemoveJoints[i]);
+        for (Joint* e : scenePhysX->RemoveJoints)
+            scenePhysX->EventsCallback.OnJointRemoved(e);
         scenePhysX->RemoveJoints.Clear();
     }
 

Source/Engine/Platform/Windows/WindowsPlatform.cpp

@@ -543,11 +543,9 @@ void WindowsPlatform::ReleaseMutex()
     }
 }
 
-void WindowsPlatform::PreInit(void* hInstance)
+PRAGMA_DISABLE_OPTIMIZATION;
+void CheckInstructionSet()
 {
-    ASSERT(hInstance);
-    Instance = hInstance;
-
 #if PLATFORM_ARCH_X86 || PLATFORM_ARCH_X64
     // Check the minimum vector instruction set support
     int32 cpuInfo[4] = { -1 };
@@ -597,10 +595,19 @@ void WindowsPlatform::PreInit(void* hInstance)
     {
         // Not supported CPU
         CPUBrand cpu;
-        Error(String::Format(TEXT("Cannot start program due to lack of CPU feature {}.\n\n{}"), missingFeature, String(cpu.Buffer)));
+        Platform::Error(String::Format(TEXT("Cannot start program due to lack of CPU feature {}.\n\n{}"), missingFeature, String(cpu.Buffer)));
         exit(-1);
     }
 #endif
+}
+PRAGMA_ENABLE_OPTIMIZATION;
+
+void WindowsPlatform::PreInit(void* hInstance)
+{
+    ASSERT(hInstance);
+    Instance = hInstance;
+
+    CheckInstructionSet();
 
     // Disable the process from being showing "ghosted" while not responding messages during slow tasks
     DisableProcessWindowsGhosting();

Source/Engine/Renderer/ColorGradingPass.cpp

@@ -47,6 +47,9 @@ public:
     Data CachedData;
     ToneMappingMode Mode = ToneMappingMode::None;
     Texture* LutTexture = nullptr;
+#if COMPILE_WITH_DEV_ENV
+    uint64 FrameRendered = 0;
+#endif
 
     ~ColorGradingCustomBuffer()
     {
@@ -54,6 +57,17 @@ public:
     }
 };
 
+#if COMPILE_WITH_DEV_ENV
+
+void ColorGradingPass::OnShaderReloading(Asset* obj)
+{
+    _psLut.Release();
+    invalidateResources();
+    _reloadedFrame = Engine::FrameCount;
+}
+
+#endif
+
 String ColorGradingPass::ToString() const
 {
     return TEXT("ColorGradingPass");
@@ -194,6 +208,9 @@ GPUTexture* ColorGradingPass::RenderLUT(RenderContext& renderContext)
     // Check if LUT parameter hasn't been changed since the last time
     if (Platform::MemoryCompare(&colorGradingBuffer.CachedData , &data, sizeof(Data)) == 0 &&
         colorGradingBuffer.Mode == toneMapping.Mode &&
+#if COMPILE_WITH_DEV_ENV
+        colorGradingBuffer.FrameRendered > _reloadedFrame &&
+#endif
         Engine::FrameCount > 30 && // Skip caching when engine is starting TODO: find why this hack is needed
         colorGradingBuffer.LutTexture == lutTexture)
     {
@@ -203,6 +220,9 @@ GPUTexture* ColorGradingPass::RenderLUT(RenderContext& renderContext)
     colorGradingBuffer.CachedData = data;
     colorGradingBuffer.Mode = toneMapping.Mode;
     colorGradingBuffer.LutTexture = lutTexture;
+#if COMPILE_WITH_DEV_ENV
+    colorGradingBuffer.FrameRendered = Engine::FrameCount;
+#endif
 
     // Render LUT
     PROFILE_GPU("Color Grading LUT");

Source/Engine/Renderer/ColorGradingPass.h

@@ -25,11 +25,8 @@ public:
 
 private:
 #if COMPILE_WITH_DEV_ENV
-    void OnShaderReloading(Asset* obj)
-    {
-        _psLut.Release();
-        invalidateResources();
-    }
+    uint64 _reloadedFrame = 0;
+    void OnShaderReloading(Asset* obj);
 #endif
 
 public:

Source/Engine/Renderer/EyeAdaptationPass.cpp

@@ -98,6 +98,7 @@ void EyeAdaptationPass::Render(RenderContext& renderContext, GPUTexture* colorBu
     if (mode == EyeAdaptationMode::Manual)
     {
         // Apply fixed manual exposure
+        context->ResetSR();
         context->SetRenderTarget(*colorBuffer);
         context->SetViewportAndScissors((float)colorBuffer->Width(), (float)colorBuffer->Height());
         context->SetState(_psManual);

Source/Engine/Renderer/MotionBlurPass.cpp

@@ -30,6 +30,9 @@ GPU_CB_STRUCT(Data {
 
     Float2 Input0SizeInv;
     Float2 Input2SizeInv;
+
+    Float3 PrevWorldOriginOffset;
+    float Dummy1;
     });
 
 MotionBlurPass::MotionBlurPass()
@@ -194,6 +197,7 @@ void MotionBlurPass::RenderMotionVectors(RenderContext& renderContext)
     Matrix::Transpose(renderContext.View.ViewProjection(), data.CurrentVP);
     Matrix::Transpose(renderContext.View.PrevViewProjection, data.PreviousVP);
     data.TemporalAAJitter = renderContext.View.TemporalAAJitter;
+    data.PrevWorldOriginOffset = renderContext.View.Origin - renderContext.View.PrevOrigin;
     auto cb = _shader->GetShader()->GetCB(0);
     context->UpdateCB(cb, &data);
     context->BindCB(0, cb);

Source/Engine/Scripting/Runtime/DotNet.cpp

@@ -1798,6 +1798,33 @@ bool InitHostfxr()
         get_hostfxr_params.dotnet_root = dotnetRoot.Get();
     }
 #endif
+    String platformStr;
+    switch (PLATFORM_TYPE)
+    {
+    case PlatformType::Windows:
+    case PlatformType::UWP:
+        if (PLATFORM_ARCH == ArchitectureType::x64)
+            platformStr = "Windows x64";
+        else if (PLATFORM_ARCH == ArchitectureType::ARM64)
+            platformStr = "Windows ARM64";
+        else
+            platformStr = "Windows x86";
+        break;
+    case PlatformType::Linux:
+        platformStr = PLATFORM_ARCH_ARM64 ? "Linux ARM64" : PLATFORM_ARCH_ARM ? "Linux Arm32" : PLATFORM_64BITS ? "Linux x64" : "Linux x86";
+        break;
+    case PlatformType::Mac:
+        platformStr = PLATFORM_ARCH_ARM || PLATFORM_ARCH_ARM64 ? "macOS ARM64" : PLATFORM_64BITS ? "macOS x64" : "macOS x86";
+        break;
+    default:
+        if (PLATFORM_ARCH == ArchitectureType::x64)
+            platformStr = "x64";
+        else if (PLATFORM_ARCH == ArchitectureType::ARM64)
+            platformStr = "ARM64";
+        else
+            platformStr = "x86";
+    }
+
     char_t hostfxrPath[1024];
     size_t hostfxrPathSize = sizeof(hostfxrPath) / sizeof(char_t);
     int rc = get_hostfxr_path(hostfxrPath, &hostfxrPathSize, &get_hostfxr_params);
@@ -1810,9 +1837,9 @@ bool InitHostfxr()
         Platform::OpenUrl(TEXT("https://dotnet.microsoft.com/en-us/download/dotnet"));
 #endif
 #if USE_EDITOR
-        LOG(Fatal, "Missing .NET 8 or later SDK installation required to run Flax Editor.");
+        LOG(Fatal, "Missing .NET 8 or later SDK installation for {0} is required to run Flax Editor.", platformStr);
 #else
-        LOG(Fatal, "Missing .NET 8 or later Runtime installation required to run this application.");
+        LOG(Fatal, "Missing .NET 8 or later Runtime installation for {0} is required to run this application.", platformStr);
 #endif
         return true;
     }
@@ -1870,27 +1897,6 @@ bool InitHostfxr()
         hostfxr_close(handle);
         if (rc == 0x80008096) // FrameworkMissingFailure
         {
-            String platformStr;
-            switch (PLATFORM_TYPE)
-            {
-            case PlatformType::Windows:
-            case PlatformType::UWP:
-                if (PLATFORM_ARCH == ArchitectureType::x64)
-                    platformStr = "Windows x64";
-                else if (PLATFORM_ARCH == ArchitectureType::ARM64)
-                    platformStr = "Windows ARM64";
-                else
-                    platformStr = "Windows x86";
-                break;
-            case PlatformType::Linux:
-                platformStr = PLATFORM_ARCH_ARM64 ? "Linux ARM64" : PLATFORM_ARCH_ARM ? "Linux Arm32" : PLATFORM_64BITS ? "Linux x64" : "Linux x86";
-                break;
-            case PlatformType::Mac:
-                platformStr = PLATFORM_ARCH_ARM || PLATFORM_ARCH_ARM64 ? "macOS ARM64" : PLATFORM_64BITS ? "macOS x64" : "macOS x86";
-                break;
-            default:;
-                platformStr = "";
-            }
             LOG(Fatal, "Failed to resolve compatible .NET runtime version in '{0}'. Make sure the correct platform version for runtime is installed ({1})", platformStr, String(init_params.dotnet_root));
         }
         else

Source/Engine/Scripting/Scripting.Build.cs

@@ -32,7 +32,7 @@ public class Scripting : EngineModule
                 options.ScriptingAPI.Defines.Add("NET");
                 AddFrameworkDefines("NET{0}_{1}", dotnetSdk.Version.Major, 0); // "NET7_0"
                 for (int i = 5; i <= dotnetSdk.Version.Major; i++)
-                    AddFrameworkDefines("NET{0}_{1}_OR_GREATER", dotnetSdk.Version.Major, 0); // "NET7_0_OR_GREATER"
+                    AddFrameworkDefines("NET{0}_{1}_OR_GREATER", i, 0); // "NET7_0_OR_GREATER"
                 options.ScriptingAPI.Defines.Add("NETCOREAPP");
                 AddFrameworkDefines("NETCOREAPP{0}_{1}_OR_GREATER", 3, 1); // "NETCOREAPP3_1_OR_GREATER"
                 AddFrameworkDefines("NETCOREAPP{0}_{1}_OR_GREATER", 2, 2);

Source/Engine/Scripting/ScriptingType.h

@@ -563,8 +563,8 @@ FORCE_INLINE int32 GetVTableIndex(void** vtable, int32 entriesCount, void* func)
             offset = ((*op & 0x3FFC00) >> 10) * ((*op & 0x40000000) != 0 ? 8 : 4);
             return offset / sizeof(void*);
         }
-        CRASH;
     }
+    CRASH;
 #elif defined(__clang__)
     // On Clang member function pointer represents the offset from the vtable begin.
     return (int32)(intptr)func / sizeof(void*);

Source/Engine/Tools/TextureTool/TextureTool.stb.cpp

@@ -65,6 +65,8 @@
 
 #endif
 
+#undef MessageBox
+
 static void stbWrite(void* context, void* data, int size)
 {
     auto file = (FileWriteStream*)context;

Source/Shaders/ColorGrading.shader

@@ -164,16 +164,14 @@ float3 TonemapACES(float3 linearColor)
 	// The code was originally written by Stephen Hill (@self_shadow).
 
 	// sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
-	static const float3x3 ACESInputMat =
-	{
+	static const float3x3 ACESInputMat = {
 		{0.59719, 0.35458, 0.04823},
 		{0.07600, 0.90834, 0.01566},
 		{0.02840, 0.13383, 0.83777}
 	};
 
 	// ODT_SAT => XYZ => D60_2_D65 => sRGB
-	static const float3x3 ACESOutputMat =
-	{
+	static const float3x3 ACESOutputMat = {
 		{ 1.60475, -0.53108, -0.07367},
 		{-0.10208,  1.10813, -0.00605},
 		{-0.00327, -0.07276,  1.07602}
@@ -188,6 +186,7 @@ float3 TonemapACES(float3 linearColor)
 	color = a / b;
 
 	color = mul(ACESOutputMat, color);
+
 	return saturate(color);
 }
 

Source/Shaders/GammaCorrectionCommon.hlsl

@@ -37,7 +37,7 @@ float4 FastTonemapInvert(float4 c)
     return float4(FastTonemapInvert(c.rgb), c.a);
 }
 
-float LinearToSrgbChannel(float linearColor)
+float LinearToSrgb(float linearColor)
 {
     if (linearColor < 0.00313067)
         return linearColor * 12.92;
@@ -46,10 +46,7 @@ float LinearToSrgbChannel(float linearColor)
 
 float3 LinearToSrgb(float3 linearColor)
 {
-    return float3(
-        LinearToSrgbChannel(linearColor.r),
-        LinearToSrgbChannel(linearColor.g),
-        LinearToSrgbChannel(linearColor.b));
+    return float3(LinearToSrgb(linearColor.r), LinearToSrgb(linearColor.g), LinearToSrgb(linearColor.b));
 }
 
 float3 sRGBToLinear(float3 color)

Source/Shaders/MotionBlur.shader

@@ -21,6 +21,8 @@ int MaxBlurSamples;
 uint VariableTileLoopCount;
 float2 Input0SizeInv;
 float2 Input2SizeInv;
+float3 PrevWorldOriginOffset;
+float Dummy1;
 META_CB_END
 
 DECLARE_GBUFFERDATA_ACCESS(GBuffer)
@@ -39,7 +41,7 @@ float4 PS_CameraMotionVectors(Quad_VS2PS input) : SV_Target
 	GBufferData gBufferData = GetGBufferData();
 	float4 worldPos = float4(GetWorldPos(gBufferData, input.TexCoord, deviceDepth), 1);
 
-	float4 prevClipPos = mul(worldPos, PreviousVP);
+	float4 prevClipPos = mul(worldPos + float4(PrevWorldOriginOffset, 0), PreviousVP);
 	float4 curClipPos = mul(worldPos, CurrentVP);
 	float2 prevHPos = prevClipPos.xy / prevClipPos.w;
 	float2 curHPos = curClipPos.xy / curClipPos.w;

Source/ThirdParty/detex/detex.h

@@ -72,7 +72,11 @@ __BEGIN_DECLS
 #include <stdint.h>
 #include <stdbool.h>
 
+#if defined(_MSC_VER)
+#define DETEX_INLINE_ONLY __forceinline
+#else
 #define DETEX_INLINE_ONLY __attribute__((always_inline)) inline
+#endif
 #define DETEX_RESTRICT __restrict
 
 /* Maximum uncompressed block size in bytes. */

Source/ThirdParty/tracy/client/TracyAlloc.cpp

@@ -6,6 +6,10 @@
 
 #include "../common/TracyYield.hpp"
 
+#if PLATFORM_WINDOWS
+extern void CheckInstructionSet();
+#endif
+
 namespace tracy
 {
 
@@ -18,6 +22,10 @@ tracy_no_inline static void InitRpmallocPlumbing()
     const auto done = RpInitDone.load( std::memory_order_acquire );
     if( !done )
     {
+#if PLATFORM_WINDOWS
+        // Check instruction set before executing any code (Tracy init static vars before others)
+        CheckInstructionSet();
+#endif
         int expected = 0;
         while( !RpInitLock.compare_exchange_weak( expected, 1, std::memory_order_release, std::memory_order_relaxed ) ) { expected = 0; YieldThread(); }
         const auto done = RpInitDone.load( std::memory_order_acquire );

Source/Tools/Flax.Build/Build/DotNet/DotNetSdk.cs

@@ -115,7 +115,7 @@ namespace Flax.Build
             /// Init with a proper message.
             /// </summary>
             public MissingException()
-            : base(string.IsNullOrEmpty(Configuration.Dotnet) ? $"Missing .NET SDK {MinimumVersion} (or higher)." : $"Missing .NET SDK {Configuration.Dotnet}.")
+            : base(string.IsNullOrEmpty(Configuration.Dotnet) ? $"Missing .NET SDK {MinimumVersion} (or higher) for {Platform.BuildTargetPlatform} {Platform.BuildTargetArchitecture}." : $"Missing .NET SDK {Configuration.Dotnet}.")
             {
             }
         }
@@ -135,7 +135,7 @@ namespace Flax.Build
         /// <summary>
         /// The maximum SDK version.
         /// </summary>
-        public static Version MaximumVersion => new Version(9, 0);
+        public static Version MaximumVersion => new Version(10, 0);
 
         /// <inheritdoc />
         public override TargetPlatform[] Platforms
@@ -218,8 +218,8 @@ namespace Flax.Build
                     using RegistryKey runtimeKey = baseKey.OpenSubKey(@$"SOFTWARE\WOW6432Node\dotnet\Setup\InstalledVersions\{arch}\sharedfx\Microsoft.NETCore.App");
                     using RegistryKey hostKey = baseKey.OpenSubKey(@$"SOFTWARE\dotnet\Setup\InstalledVersions\{arch}\sharedhost");
                     dotnetPath = (string)hostKey.GetValue("Path");
-                    dotnetSdkVersions = sdkVersionsKey.GetValueNames();
-                    dotnetRuntimeVersions = runtimeKey.GetValueNames();
+                    dotnetSdkVersions = sdkVersionsKey?.GetValueNames() ?? Enumerable.Empty<string>();
+                    dotnetRuntimeVersions = runtimeKey?.GetValueNames() ?? Enumerable.Empty<string>();
                 }
 #pragma warning restore CA1416
                 break;

Source/Tools/Flax.Build/Deps/Dependencies/Assimp.cs

@@ -127,11 +127,12 @@ namespace Flax.Deps.Dependencies
                         { "CC", "clang-" + Configuration.LinuxClangMinVer },
                         { "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer },
                         { "CXX", "clang++-" + Configuration.LinuxClangMinVer },
+                        { "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
                     };
 
                     // Build for Linux
                     RunCmake(root, platform, TargetArchitecture.x64, " -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF " + globalConfig, envVars);
-                    Utilities.Run("make", null, null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
+                    Utilities.Run("make", null, null, root, Utilities.RunOptions.DefaultTool, envVars);
                     configHeaderFilePath = Path.Combine(root, "include", "assimp", "config.h");
                     var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
                     Utilities.FileCopy(Path.Combine(root, "lib", "libassimp.a"), Path.Combine(depsFolder, "libassimp.a"));
@@ -143,11 +144,11 @@ namespace Flax.Deps.Dependencies
                     foreach (var architecture in new[] { TargetArchitecture.x64, TargetArchitecture.ARM64 })
                     {
                         RunCmake(root, platform, architecture, " -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF " + globalConfig);
-                        Utilities.Run("make", null, null, root, Utilities.RunOptions.ThrowExceptionOnError);
+                        Utilities.Run("make", null, null, root, Utilities.RunOptions.DefaultTool);
                         configHeaderFilePath = Path.Combine(root, "include", "assimp", "config.h");
                         var depsFolder = GetThirdPartyFolder(options, platform, architecture);
                         Utilities.FileCopy(Path.Combine(root, "lib", "libassimp.a"), Path.Combine(depsFolder, "libassimp.a"));
-                        Utilities.Run("make", "clean", null, root, Utilities.RunOptions.ThrowExceptionOnError);
+                        Utilities.Run("make", "clean", null, root, Utilities.RunOptions.DefaultTool);
                     }
                     break;
                 }

Source/Tools/Flax.Build/Deps/Dependencies/NvCloth.cs

@@ -115,6 +115,7 @@ namespace Flax.Deps.Dependencies
             var buildFolder = Path.Combine(nvCloth, "compiler", platform.ToString() + '_' + architecture.ToString());
             var envVars = new Dictionary<string, string>();
             envVars["GW_DEPS_ROOT"] = root;
+            envVars["CMAKE_BUILD_PARALLEL_LEVEL"] = CmakeBuildParallel;
             switch (platform)
             {
             case TargetPlatform.Windows:
@@ -166,6 +167,8 @@ namespace Flax.Deps.Dependencies
                 cmakeArgs += " -DTARGET_BUILD_PLATFORM=linux";
                 cmakeName = "linux";
                 binariesPrefix = "lib";
+                envVars.Add("CC", "clang-" + Configuration.LinuxClangMinVer);
+                envVars.Add("CXX", "clang++-" + Configuration.LinuxClangMinVer);
                 break;
             default: throw new InvalidPlatformException(platform);
             }

Source/Tools/Flax.Build/Deps/Dependencies/OpenAL.cs

@@ -123,6 +123,7 @@ namespace Flax.Deps.Dependencies
                     {
                         { "CC", "clang-" + Configuration.LinuxClangMinVer },
                         { "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer },
+                        { "CXX", "clang++-" + Configuration.LinuxClangMinVer },
                         { "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
                     };
                     var config = $"-DALSOFT_REQUIRE_ALSA=ON " +

Source/Tools/Flax.Build/Deps/Dependencies/PhysX.cs

@@ -238,6 +238,8 @@ namespace Flax.Deps.Dependencies
             case TargetPlatform.Linux:
                 envVars.Add("CC", "clang-" + Configuration.LinuxClangMinVer);
                 envVars.Add("CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer);
+                envVars.Add("CXX", "clang++-" + Configuration.LinuxClangMinVer);
+                envVars.Add("CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel);
                 break;
             case TargetPlatform.Mac: break;
             default: throw new InvalidPlatformException(BuildPlatform);
@@ -258,7 +260,7 @@ namespace Flax.Deps.Dependencies
             Log.Info("Building PhysX version " + File.ReadAllText(Path.Combine(root, "physx", "version.txt")) + " to " + binariesSubDir);
 
             // Generate project files
-            Utilities.Run(projectGenPath, preset, null, projectGenDir, Utilities.RunOptions.ThrowExceptionOnError, envVars);
+            Utilities.Run(projectGenPath, preset, null, projectGenDir, Utilities.RunOptions.DefaultTool, envVars);
 
             switch (targetPlatform)
             {
@@ -304,10 +306,10 @@ namespace Flax.Deps.Dependencies
                 }
                 break;
             case TargetPlatform.Linux:
-                Utilities.Run("make", null, null, Path.Combine(projectGenDir, "compiler", "linux-" + configuration), Utilities.RunOptions.ConsoleLogOutput);
+                Utilities.Run("make", null, null, Path.Combine(projectGenDir, "compiler", "linux-" + configuration), Utilities.RunOptions.ConsoleLogOutput, envVars);
                 break;
             case TargetPlatform.Mac:
-                Utilities.Run("xcodebuild", "-project PhysXSDK.xcodeproj -alltargets -configuration " + configuration, null, Path.Combine(projectGenDir, "compiler", preset), Utilities.RunOptions.ConsoleLogOutput);
+                Utilities.Run("xcodebuild", "-project PhysXSDK.xcodeproj -alltargets -configuration " + configuration, null, Path.Combine(projectGenDir, "compiler", preset), Utilities.RunOptions.ConsoleLogOutput, envVars);
                 break;
             default: throw new InvalidPlatformException(BuildPlatform);
             }

Source/Tools/Flax.Build/Deps/Dependencies/curl.cs

@@ -107,13 +107,14 @@ namespace Flax.Deps.Dependencies
                     {
                         { "CC", "clang-" + Configuration.LinuxClangMinVer },
                         { "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer },
+                        { "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
                     };
                     var buildDir = Path.Combine(root, "build");
                     SetupDirectory(buildDir, true);
-                    Utilities.Run("chmod", "+x configure", null, root, Utilities.RunOptions.ThrowExceptionOnError);
-                    Utilities.Run(Path.Combine(root, "configure"), string.Join(" ", settings) + " --prefix=\"" + buildDir + "\"", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
-                    Utilities.Run("make", null, null, root, Utilities.RunOptions.ThrowExceptionOnError);
-                    Utilities.Run("make", "install", null, root, Utilities.RunOptions.ThrowExceptionOnError);
+                    Utilities.Run("chmod", "+x configure", null, root, Utilities.RunOptions.DefaultTool);
+                    Utilities.Run(Path.Combine(root, "configure"), string.Join(" ", settings) + " --prefix=\"" + buildDir + "\"", null, root, Utilities.RunOptions.DefaultTool, envVars);
+                    Utilities.Run("make", null, null, root, Utilities.RunOptions.DefaultTool);
+                    Utilities.Run("make", "install", null, root, Utilities.RunOptions.DefaultTool);
                     var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
                     var filename = "libcurl.a";
                     Utilities.FileCopy(Path.Combine(buildDir, "lib", filename), Path.Combine(depsFolder, filename));
@@ -153,11 +154,11 @@ namespace Flax.Deps.Dependencies
                         };
                         var buildDir = Path.Combine(root, "build");
                         SetupDirectory(buildDir, true);
-                        Utilities.Run("chmod", "+x configure", null, root, Utilities.RunOptions.ThrowExceptionOnError);
-                        Utilities.Run("chmod", "+x install-sh", null, root, Utilities.RunOptions.ThrowExceptionOnError);
-                        Utilities.Run(Path.Combine(root, "configure"), string.Join(" ", settings) + " --host=" + archName + " --prefix=\"" + buildDir + "\"", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
-                        Utilities.Run("make", null, null, root, Utilities.RunOptions.ThrowExceptionOnError);
-                        Utilities.Run("make", "install", null, root, Utilities.RunOptions.ThrowExceptionOnError);
+                        Utilities.Run("chmod", "+x configure", null, root, Utilities.RunOptions.DefaultTool);
+                        Utilities.Run("chmod", "+x install-sh", null, root, Utilities.RunOptions.DefaultTool);
+                        Utilities.Run(Path.Combine(root, "configure"), string.Join(" ", settings) + " --host=" + archName + " --prefix=\"" + buildDir + "\"", null, root, Utilities.RunOptions.DefaultTool, envVars);
+                        Utilities.Run("make", null, null, root, Utilities.RunOptions.DefaultTool);
+                        Utilities.Run("make", "install", null, root, Utilities.RunOptions.DefaultTool);
                         var depsFolder = GetThirdPartyFolder(options, platform, architecture);
                         var filename = "libcurl.a";
                         Utilities.FileCopy(Path.Combine(buildDir, "lib", filename), Path.Combine(depsFolder, filename));

Source/Tools/Flax.Build/Deps/Dependencies/freetype.cs

@@ -114,19 +114,22 @@ namespace Flax.Deps.Dependencies
                 }
                 case TargetPlatform.Linux:
                 {
-                    var envVars = new Dictionary<string, string>
+                            var envVars = new Dictionary<string, string>
                     {
                         { "CC", "clang-" + Configuration.LinuxClangMinVer },
-                        { "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer }
+                        { "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer },
+                        { "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
                     };
 
                     // Fix scripts
-                    Utilities.Run("sed", "-i -e \'s/\r$//\' autogen.sh", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
-                    Utilities.Run("sed", "-i -e \'s/\r$//\' configure", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
+                    Utilities.Run("dos2unix", "autogen.sh", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
+                    Utilities.Run("dos2unix", "configure", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
+                    //Utilities.Run("sed", "-i -e \'s/\r$//\' autogen.sh", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
+                    //Utilities.Run("sed", "-i -e \'s/\r$//\' configure", null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
                     Utilities.Run("chmod", "+x autogen.sh", null, root, Utilities.RunOptions.ThrowExceptionOnError);
                     Utilities.Run("chmod", "+x configure", null, root, Utilities.RunOptions.ThrowExceptionOnError);
 
-                    Utilities.Run(Path.Combine(root, "autogen.sh"), null, null, root, Utilities.RunOptions.Default, envVars);
+                    Utilities.Run(Path.Combine(root, "autogen.sh"), null, null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
 
                     // Disable using libpng even if it's found on the system
                     var cmakeFile = Path.Combine(root, "CMakeLists.txt");
@@ -140,8 +143,8 @@ namespace Flax.Deps.Dependencies
                     // Build for Linux
                     SetupDirectory(buildDir, true);
                     var toolchain = UnixToolchain.GetToolchainName(platform, TargetArchitecture.x64);
-                    Utilities.Run("cmake", string.Format("-G \"Unix Makefiles\" -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DFT_WITH_BZIP2=OFF -DFT_WITH_ZLIB=OFF -DFT_WITH_PNG=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER_TARGET={0} ..", toolchain), null, buildDir, Utilities.RunOptions.ThrowExceptionOnError, envVars);
-                    Utilities.Run("cmake", "--build .", null, buildDir, Utilities.RunOptions.ThrowExceptionOnError, envVars);
+                    Utilities.Run("cmake", string.Format("-G \"Unix Makefiles\" -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DFT_WITH_BZIP2=OFF -DFT_WITH_ZLIB=OFF -DFT_WITH_PNG=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER_TARGET={0} ..", toolchain), null, buildDir, Utilities.RunOptions.DefaultTool, envVars);
+                    Utilities.Run("cmake", "--build .", null, buildDir, Utilities.RunOptions.DefaultTool, envVars);
                     var depsFolder = GetThirdPartyFolder(options, platform, TargetArchitecture.x64);
                     Utilities.FileCopy(Path.Combine(buildDir, libraryFileName), Path.Combine(depsFolder, libraryFileName));
 

Source/Tools/Flax.Build/Deps/Dependencies/nethost.cs

@@ -303,9 +303,9 @@ namespace Flax.Deps.Dependencies
             }
 
             // Ensure to have dependencies installed
-            Utilities.Run("ninja", "--version", null, null, Utilities.RunOptions.ThrowExceptionOnError);
-            Utilities.Run("cmake", "--version", null, null, Utilities.RunOptions.ThrowExceptionOnError);
-            Utilities.Run("python", "--version", null, null, Utilities.RunOptions.ThrowExceptionOnError);
+            Utilities.Run("ninja", "--version", null, null, Utilities.RunOptions.DefaultTool);
+            Utilities.Run("cmake", "--version", null, null, Utilities.RunOptions.DefaultTool);
+            Utilities.Run("python", "--version", null, null, Utilities.RunOptions.DefaultTool);
 
             // Get the source
             if (!Directory.Exists(Path.Combine(root, ".git")))

Source/Tools/Flax.Build/Deps/Dependencies/vorbis.cs

@@ -366,15 +366,17 @@ namespace Flax.Deps.Dependencies
                     var envVars = new Dictionary<string, string>
                     {
                         { "CC", "clang-" + Configuration.LinuxClangMinVer },
-                        { "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer }
+                        { "CC_FOR_BUILD", "clang-" + Configuration.LinuxClangMinVer },
+                        { "CXX", "clang++-" + Configuration.LinuxClangMinVer },
+                        { "CMAKE_BUILD_PARALLEL_LEVEL", CmakeBuildParallel },
                     };
                     var buildDir = Path.Combine(root, "build");
 
-                    Utilities.Run(Path.Combine(root, "autogen.sh"), null, null, root, Utilities.RunOptions.Default, envVars);
+                    Utilities.Run(Path.Combine(root, "autogen.sh"), null, null, root, Utilities.RunOptions.DefaultTool, envVars);
 
                     // Build for Linux
                     var toolchain = UnixToolchain.GetToolchainName(platform, TargetArchitecture.x64);
-                    Utilities.Run(Path.Combine(root, "configure"), string.Format("--host={0}", toolchain), null, root, Utilities.RunOptions.Default, envVars);
+                    Utilities.Run(Path.Combine(root, "configure"), string.Format("--host={0}", toolchain), null, root, Utilities.RunOptions.ThrowExceptionOnError, envVars);
                     SetupDirectory(buildDir, true);
                     Utilities.Run("cmake", "-G \"Unix Makefiles\" -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCMAKE_BUILD_TYPE=Release ..", null, buildDir, Utilities.RunOptions.ConsoleLogOutput, envVars);
                     Utilities.Run("cmake", "--build .", null, buildDir, Utilities.RunOptions.ConsoleLogOutput, envVars);

Source/Tools/Flax.Build/Deps/Dependency.cs

@@ -456,7 +456,7 @@ namespace Flax.Deps
             case TargetPlatform.Mac: break;
             default: throw new InvalidPlatformException(BuildPlatform);
             }
-            Utilities.Run(path, args, null, workspace, Utilities.RunOptions.ThrowExceptionOnError, envVars);
+            Utilities.Run(path, args, null, workspace, Utilities.RunOptions.DefaultTool, envVars);
         }
 
         internal bool GetMsBuildForPlatform(TargetPlatform targetPlatform, out VisualStudioVersion vsVersion, out string msBuildPath)

Source/Tools/Flax.Build/Log.cs

@@ -65,7 +65,10 @@ namespace Flax.Build
                     if (ApplyConsoleColors)
                         Console.ForegroundColor = color;
 
-                    Console.WriteLine(Indent + message);
+                    if (color != ConsoleColor.Red)
+                        Console.WriteLine(Indent + message);
+                    else
+                        Console.Error.WriteLine(Indent + message);
 
                     if (ApplyConsoleColors)
                         Console.ResetColor();

Source/Tools/Flax.Build/Platforms/Linux/LinuxToolchain.cs

@@ -14,7 +14,7 @@ namespace Flax.Build
         /// Specifies the minimum Clang compiler version to use on Linux (eg. 10).
         /// </summary>
         [CommandLine("linuxClangMinVer", "<version>", "Specifies the minimum Clang compiler version to use on Linux (eg. 10).")]
-        public static string LinuxClangMinVer = "13";
+        public static string LinuxClangMinVer = "14";
     }
 }
 

Source/Tools/Flax.Build/Platforms/Windows/WindowsToolchain.cs

@@ -20,7 +20,7 @@ namespace Flax.Build
         /// Specifies the minimum CPU architecture type to support (on x86/x64).
         /// </summary>
         [CommandLine("winCpuArch", "<arch>", "Specifies the minimum CPU architecture type to support (om x86/x64).")]
-        public static CpuArchitecture WindowsCpuArch = CpuArchitecture.AVX2; // 94.48% support on PC according to Steam Hardware & Software Survey: May 2025 (https://store.steampowered.com/hwsurvey/)
+        public static CpuArchitecture WindowsCpuArch = CpuArchitecture.SSE4_2; // 99.78% support on PC according to Steam Hardware & Software Survey: September 2025 (https://store.steampowered.com/hwsurvey/)
     }
 }