templates: generate .slnx for new projects

dotnet new / GameStudio new-game now synthesize MyTemplate.slnx (each
platform exec marked DefaultStartup since .slnx ignores file order for
the startup project). Editor SolutionExtension and 'stride new' discovery
follow. Existing .sln projects keep their format (solution serialization
picks by extension on save).

Author: xen2

sources/assets/Stride.Core.Assets/PackageSession.cs

@@ -1200,6 +1200,10 @@ public void Save(ILogger log, PackageSaveParameters? saveParameters = null)
             // callback snapshots the .sln only when Save actually rewrites it.
             if (packagesSaved && !string.IsNullOrEmpty(VSSolution.FullPath))
             {
+                // Mark the host/Windows exec as the startup project so the saved .slnx gets a DefaultStartup
+                // (slnx ignores project order, and SolutionPersistence can't model the attribute). ??= so a
+                // startup already read from the existing .slnx isn't overridden — it round-trips.
+                VSSolution.StartupProjectGuid ??= CurrentProject is { Type: ProjectType.Executable } exec ? exec.Id : null;
                 VSSolution.Save(path => UpgradeBackup?.Snapshot(path));
             }
             saveCompletion?.SetResult(0);

sources/core/Stride.Core.Design.Tests/TestSolutionSerialization.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.IO;
+using System.Linq;
 using Stride.Core.Solutions;
 using Xunit;
 
@@ -119,6 +120,40 @@ public void SlnxRoundTripsAsXml()
         }
     }
 
+    [Fact]
+    public void SlnxOmitsIdsAndRoundTripsTheStartupProject()
+    {
+        var dir = NewTempDir();
+        try
+        {
+            var slnxPath = Path.Combine(dir, "Game.slnx");
+            var solution = new Solution { FullPath = slnxPath };
+            solution.Projects.Add(new Project(
+                Guid.NewGuid(), KnownProjectTypeGuid.CSharp,
+                "Game", Path.Combine(dir, "Game", "Game.csproj"), Guid.Empty, [], [], []));
+            var windowsGuid = Guid.NewGuid();
+            solution.Projects.Add(new Project(
+                windowsGuid, KnownProjectTypeGuid.CSharp,
+                "Game.Windows", Path.Combine(dir, "Game.Windows", "Game.Windows.csproj"), Guid.Empty, [], [], []));
+            solution.StartupProjectGuid = windowsGuid;
+            solution.Save();
+
+            var written = File.ReadAllText(slnxPath);
+            Assert.Contains("DefaultStartup=\"true\"", written);
+            Assert.DoesNotContain("Id=\"", written);   // .slnx carries no project ids
+            Assert.DoesNotContain("Type=\"", written);  // nor an explicit project type (inferred from .csproj)
+
+            // The startup project survives a reload, matched back by its path.
+            var reloaded = Solution.FromFile(slnxPath);
+            var startup = reloaded.Projects.First(project => project.Guid == reloaded.StartupProjectGuid);
+            Assert.EndsWith("Game.Windows.csproj", startup.FullPath.Replace('\\', '/'));
+        }
+        finally
+        {
+            Directory.Delete(dir, recursive: true);
+        }
+    }
+
     [Fact]
     public void SolutionFilterResolvesToUnderlyingSolution()
     {

sources/core/Stride.Core.Design/Solutions/Solution.cs

@@ -86,6 +86,12 @@ public static bool IsSolutionFile(string path)
     /// <value>The full path.</value>
     public string FullPath { get; set; }
 
+    /// <summary>
+    /// The id of the project to mark as the solution's default startup (the <c>.slnx</c>
+    /// <c>DefaultStartup</c> attribute); null to leave it unset.
+    /// </summary>
+    public Guid? StartupProjectGuid { get; set; }
+
     /// <summary>
     /// The model this solution was loaded from, used on save to preserve everything it already
     /// contained; null for a solution that was not loaded from disk.

sources/core/Stride.Core.Design/Solutions/SolutionSerialization.cs

@@ -2,6 +2,7 @@
 // Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
 
 using System.Text.Json;
+using System.Xml;
 using Microsoft.VisualStudio.SolutionPersistence.Model;
 using Microsoft.VisualStudio.SolutionPersistence.Serializer;
 
@@ -29,7 +30,9 @@ public static Solution Read(string solutionFullPath)
         var serializer = SolutionSerializers.GetSerializerByMoniker(solutionFullPath)
             ?? throw new SolutionFileException($"Unsupported solution file format: '{solutionFullPath}'.");
         var model = serializer.OpenAsync(solutionFullPath, CancellationToken.None).GetAwaiter().GetResult();
-        return ToSolution(model, solutionFullPath);
+        var solution = ToSolution(model, solutionFullPath);
+        ReadDefaultStartup(solution, solutionFullPath);
+        return solution;
     }
 
     // The .sln a solution filter (.slnf) points at, resolved relative to the filter file.
@@ -63,18 +66,24 @@ public static void Write(Solution solution, string outputPath, Action<string>? o
         // Pick the serializer from the output extension so a .slnx round-trips as XML and a .sln as classic format.
         var serializer = SolutionSerializers.GetSerializerByMoniker(outputPath) ?? SolutionSerializers.SlnFileV12;
 
-        if (!File.Exists(outputPath))
-        {
-            serializer.SaveAsync(outputPath, model, CancellationToken.None).GetAwaiter().GetResult();
-            return;
-        }
+        // SolutionPersistence can't model the .slnx DefaultStartup attribute, so stamp it in after writing.
+        var startupPath = StartupRelativePath(solution, outputPath);
 
         // Write to a sibling temp file first and only replace the solution when its content changed, so
         // Visual Studio doesn't reload an unchanged solution.
         var tempPath = outputPath + ".tmp";
         try
         {
             serializer.SaveAsync(tempPath, model, CancellationToken.None).GetAwaiter().GetResult();
+            if (startupPath is { } path)
+                StampDefaultStartup(tempPath, path);
+
+            if (!File.Exists(outputPath))
+            {
+                File.Move(tempPath, outputPath);
+                return;
+            }
+
             if (!File.ReadAllBytes(outputPath).AsSpan().SequenceEqual(File.ReadAllBytes(tempPath)))
             {
                 onBeforeOverwrite?.Invoke(outputPath);
@@ -88,6 +97,63 @@ public static void Write(Solution solution, string outputPath, Action<string>? o
         }
     }
 
+    // The flip side of StampDefaultStartup: SolutionPersistence drops the .slnx DefaultStartup attribute on
+    // read, so pick it back up from the XML and map it (by project path) back to a project. Lets the startup
+    // project survive a load/save round-trip.
+    private static void ReadDefaultStartup(Solution solution, string solutionFullPath)
+    {
+        if (!Path.GetExtension(solutionFullPath).Equals(".slnx", StringComparison.OrdinalIgnoreCase) || !File.Exists(solutionFullPath))
+            return;
+
+        try
+        {
+            var document = new XmlDocument();
+            document.Load(solutionFullPath);
+            var solutionDirectory = Path.GetDirectoryName(solutionFullPath) ?? string.Empty;
+            foreach (XmlElement project in document.GetElementsByTagName("Project"))
+            {
+                if (!string.Equals(project.GetAttribute("DefaultStartup"), "true", StringComparison.OrdinalIgnoreCase))
+                    continue;
+                var fullPath = Path.GetFullPath(Path.Combine(solutionDirectory, project.GetAttribute("Path").Replace('/', Path.DirectorySeparatorChar)));
+                if (solution.Projects.FirstOrDefault(p => !p.IsSolutionFolder && string.Equals(p.FullPath, fullPath, StringComparison.OrdinalIgnoreCase)) is { } match)
+                    solution.StartupProjectGuid = match.Guid;
+                return;
+            }
+        }
+        catch
+        {
+            // Best-effort: a malformed or locked file just leaves the startup project unset.
+        }
+    }
+
+    // The solution-relative path of the startup project, or null when there's none (or the target isn't a .slnx).
+    private static string? StartupRelativePath(Solution solution, string outputPath)
+    {
+        if (!Path.GetExtension(outputPath).Equals(".slnx", StringComparison.OrdinalIgnoreCase) || solution.StartupProjectGuid is not { } guid)
+            return null;
+        if (solution.Projects.FirstOrDefault(p => !p.IsSolutionFolder && p.Guid == guid) is not { } project)
+            return null;
+        return GetRelativePath(Path.GetDirectoryName(outputPath) ?? string.Empty, project.FullPath).Replace('\\', '/');
+    }
+
+    // SolutionPersistence (1.0.52) has no model for the .slnx DefaultStartup attribute, so add it to the startup
+    // project's element. PreserveWhitespace keeps the rest of the file byte-identical (no BOM, same formatting),
+    // so the unchanged-content check above still skips needless VS reloads.
+    private static void StampDefaultStartup(string slnxPath, string projectRelativePath)
+    {
+        var document = new XmlDocument { PreserveWhitespace = true };
+        document.Load(slnxPath);
+        foreach (XmlElement project in document.GetElementsByTagName("Project"))
+        {
+            if (string.Equals(project.GetAttribute("Path"), projectRelativePath, StringComparison.OrdinalIgnoreCase))
+            {
+                project.SetAttribute("DefaultStartup", "true");
+                document.Save(slnxPath);
+                return;
+            }
+        }
+    }
+
     private static SolutionModel NewModel(Solution solution)
     {
         var model = new SolutionModel();
@@ -107,6 +173,7 @@ private static SolutionModel NewModel(Solution solution)
     private static void Reconcile(SolutionModel model, Solution solution, string outputPath)
     {
         var solutionDirectory = Path.GetDirectoryName(outputPath) ?? string.Empty;
+        var isSlnx = Path.GetExtension(outputPath).Equals(".slnx", StringComparison.OrdinalIgnoreCase);
 
         var projectIds = solution.Projects.Where(project => !project.IsSolutionFolder).Select(project => project.Guid).ToHashSet();
         var folderIds = solution.Projects.Where(project => project.IsSolutionFolder).Select(project => project.Guid).ToHashSet();
@@ -135,8 +202,15 @@ private static void Reconcile(SolutionModel model, Solution solution, string out
             // Forward slashes: SolutionPersistence's portable form (it writes '\' for .sln, '/' for .slnx).
             // Backslash isn't a path separator on Linux, so forcing it leaves '\' literal in the .slnx.
             var relativePath = GetRelativePath(solutionDirectory, project.FullPath).Replace('\\', '/');
-            var added = model.AddProject(relativePath, ProjectTypeName(project), parent);
-            added.Id = project.Guid;
+            // .slnx infers the C# type from the .csproj (keep it clean); a .sln would infer the legacy guid, so keep it there.
+            var typeName = isSlnx && relativePath.EndsWith(".csproj", StringComparison.OrdinalIgnoreCase)
+                ? null
+                : ProjectTypeName(project);
+            var added = model.AddProject(relativePath, typeName, parent);
+            // .slnx omits the project id — SolutionPersistence regenerates a stable one from the path on load
+            // and Stride reconciles by that; a .sln needs the explicit guid, so keep writing it there.
+            if (!isSlnx)
+                added.Id = project.Guid;
         }
     }
 

sources/editor/Stride.Core.Assets.Editor/ViewModel/EditorViewModel.cs

@@ -24,7 +24,7 @@ namespace Stride.Core.Assets.Editor.ViewModel
     public abstract class EditorViewModel : ViewModelBase
     {
         public const string PackageFileExtension = Package.PackageFileExtension;
-        public const string SolutionFileExtension = ".sln";
+        public const string SolutionFileExtension = ".slnx";
         private SessionViewModel session;
 
         protected EditorViewModel(IViewModelServiceProvider serviceProvider, MostRecentlyUsedFileCollection mru, string editorName, string editorVersionMajor)

sources/editor/Stride.Core.Assets.Editor/ViewModel/SessionViewModel.cs

@@ -41,7 +41,7 @@ public class SessionViewModel : DirtiableEditableViewModel, IAssetFinder
     {
         public static string StorePackageCategoryName = Tr._("External packages");
         public static string LocalPackageCategoryName = Tr._("Local packages");
-        public const string SolutionExtension = ".sln";
+        public const string SolutionExtension = ".slnx";
         public const int SaveIrreversibleSourceFileOperationsMessageCount = 5;
 
         private readonly IUndoRedoService undoRedoService;

sources/engine/Stride.Assets/Templates/DotNetNewTemplateGenerator.cs

@@ -261,8 +261,8 @@ private static void RegisterPerPlatformExecutables(SessionTemplateGeneratorParam
             // Package.LoadProject returns a SolutionProject with an empty placeholder Package
             // (no sibling .sdpkg). Type/Platform stay at default until dep-resolution evaluates
             // the MSBuild project, but the session's RegisterProject already uses them for
-            // VS-startup ordering — set them explicitly so .sln save lists per-platform projects
-            // in the same order the preprocessor's GenerateSlnIfMissing produces.
+            // VS-startup ordering — set them explicitly so solution save lists per-platform projects
+            // in the same order the preprocessor's GenerateSlnxIfMissing produces.
             var execProject = (SolutionProject)Package.LoadProject(log, csproj);
             execProject.Type = ProjectType.Executable;
             execProject.Platform = match.Type;
@@ -276,7 +276,7 @@ private static void RegisterPerPlatformExecutables(SessionTemplateGeneratorParam
         // Make Session.CurrentProject point at a runnable exec (host platform if among the
         // generated set, else Windows as the GameStudio-only fallback). Without this the
         // Run/LivePlay button can't dispatch (it asserts CurrentProject.Type == Executable),
-        // and the .sln on save loses the startup-project hint that RegisterProject sets via
+        // and the solution on save loses the startup-project hint that RegisterProject sets via
         // the Windows-first VSSolution insertion.
         var startupProject = hostPlatformProject ?? windowsProject;
         if (startupProject != null)

sources/launcher/Stride.Cli/NewCommand.cs

@@ -120,7 +120,9 @@ public static Command Create(StrideVersionManager manager)
 
                 // Upgrade to the resolved version when the template targets an older engine; skipped (no
                 // restore) when it already matches.
-                var solutionFile = Directory.EnumerateFiles(output, "*.sln", SearchOption.TopDirectoryOnly).FirstOrDefault();
+                var solutionFile = Directory.EnumerateFiles(output, "*.slnx", SearchOption.TopDirectoryOnly)
+                    .Concat(Directory.EnumerateFiles(output, "*.sln", SearchOption.TopDirectoryOnly))
+                    .FirstOrDefault();
                 var templateVersion = ReadGeneratedEngineVersion(output);
                 if (solutionFile is not null && templateVersion is not null && IsOlderThan(templateVersion, version))
                 {