after merge from remote

src/Nitload.Benchmark/HlsfAllocatorBench.cs

@@ -6,14 +6,14 @@
 // -----------------------------------------------------------------------------
 
 using BenchmarkDotNet.Attributes;
-using StgSharp.HighPerformance.Memory;
+using Nitload.Common.HighPerformance.Memory;
 using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
 
-using Tlsf = StgSharp.HighPerformance.Memory.TwoLayerSegregatedFitAllocator;
+using Tlsf = Nitload.Common.HighPerformance.Memory.TwoLayerSegregatedFitAllocator;
 
-namespace StgSharp.Benchmark
+namespace Nitload.Benchmark
 {
     [MemoryDiagnoser]
     public class TlsfAllocatorBench

src/Nitload.Benchmark/Nitload.Benchmark.csproj

@@ -10,12 +10,12 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\StgSharp.Common\StgSharp.Common.csproj" Properties="DisablePostBuildCopy=true" />
+    <ProjectReference Include="..\Nitload.Common\Nitload.Common.csproj" Properties="DisablePostBuildCopy=true" />
   </ItemGroup>
 
   <ItemGroup>
-    <NativeArtifacts Include="$(SolutionDir)build\**\StgSharp.Native*.dll" />
-    <NativeArtifacts Include="$(SolutionDir)build\**\StgSharp.Native*.pdb" />
+    <NativeArtifacts Include="$(SolutionDir)build\**\Nitload.Native*.dll" />
+    <NativeArtifacts Include="$(SolutionDir)build\**\Nitload.Native*.pdb" />
   </ItemGroup>
 
   <Target Name="CopyNativeArtifacts" AfterTargets="Build" Condition="'$(DisableNativeCopy)'!='true'">

src/Nitload.Benchmark/Program.cs

@@ -10,7 +10,7 @@ using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Running;
 using BenchmarkDotNet.Toolchains.InProcess.Emit;
-using StgSharp.Benchmark;
+using Nitload.Benchmark;
 
 IConfig config = ManualConfig.Create(DefaultConfig.Instance)
                              .AddLogger(ConsoleLogger.Default)

src/Nitload.Benchmark/SwissBenchmark.cs

@@ -6,12 +6,12 @@
 // -----------------------------------------------------------------------------
 
 using BenchmarkDotNet.Attributes;
-using StgSharp.Collections;
+using Nitload.Common.Collections;
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 
-namespace StgSharp.Benchmark
+namespace Nitload.Benchmark
 {
     /// <summary>
     ///   Benchmark comparing SwissTable against <see cref="Dictionary{TKey, TValue}" /> under

src/Nitload.Common/Collections/BidirectionalDictionary.cs

@@ -11,7 +11,7 @@ using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     public sealed class BidirectionalDictionary<TFirst, TSecond> : IBidirectionalDictionary<TFirst, TSecond>
         where TFirst : notnull

src/Nitload.Common/Collections/CapacityFixedBag.cs

@@ -10,7 +10,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     public sealed class CapacityFixedBag<T> : IEnumerable<T>
     {

src/Nitload.Common/Collections/CapacityFixedList.cs

@@ -10,7 +10,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     public static class CapacityFixedListBuilder
     {

src/Nitload.Common/Collections/CapacityFixedStack.cs

@@ -13,7 +13,7 @@ using System.Runtime.CompilerServices;
 using System.Security.Cryptography;
 using System.Threading;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     [CollectionBuilder(typeof(CapacityFixedStackBuilder), nameof(CapacityFixedStackBuilder.Create))]
     public class CapacityFixedStack<T> : IEnumerable<T>

src/Nitload.Common/Collections/ConcurrentCapacityFixedStack.cs

@@ -11,7 +11,7 @@ using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Threading;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     /// <summary>
     ///   Lock-free, fixed-capacity stack implemented on top of an array using atomic index

src/Nitload.Common/Collections/ConcurrentFlexibleArray.cs

@@ -11,7 +11,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     public class ConcurrentFlexibleArray<T>(
                  int capacity = 4

src/Nitload.Common/Collections/IBidirectionalDictionary.cs

@@ -7,7 +7,7 @@
 
 using System.Collections.Generic;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     public interface IBidirectionalDictionary<TFirst, TSecond> : IDictionary<TFirst, TSecond>
     {

src/Nitload.Common/Collections/LinearBag.cs

@@ -9,7 +9,7 @@ using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     public static class LinearBagBuilder
     {

src/Nitload.Common/Collections/ListSegment.cs

@@ -14,7 +14,7 @@ using System.Text;
 using System.Threading.Tasks;
 using System.Xml.Serialization;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     /// <summary>
     ///   Part of a collection. This contains a direct reference to _origin collection, so all

src/Nitload.Common/Collections/RandomAccessibleStack.cs

@@ -9,7 +9,7 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     public class RandomAccessibleStack<T> : IEnumerable<T>
     {

src/Nitload.Common/Collections/SwissTable.X86.cs

@@ -10,7 +10,7 @@ using System.Numerics;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     public partial class SwissTable
     {

src/Nitload.Common/Collections/SwissTable.cs

@@ -12,7 +12,7 @@ using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics.Arm;
 using System.Runtime.Intrinsics.X86;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     /// <summary>
     ///

src/Nitload.Common/Collections/UnmanagedArray.cs

@@ -12,7 +12,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     /// <summary>
     ///   Zero-overhead view over a contiguous region of unmanaged memory. Does not own the memory —

src/Nitload.Common/Collections/UnmanagedStack.cs

@@ -11,7 +11,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Collections
+namespace Nitload.Common.Collections
 {
     public unsafe class UnmanagedStack<T>(
                         T* address,

src/Nitload.Common/Environment/Dialogue.cs

@@ -16,7 +16,7 @@ using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
 
-namespace StgSharp
+namespace Nitload
 {
     public static class Dialogue
     {
@@ -92,7 +92,7 @@ namespace StgSharp
             }
 
             string consoleRoute = Path.Combine(
-                path, @"StgSharp.TerminalDialogue", $@"StgSharp.TerminalDialogue{exeName}");
+                path, @"Nitload.TerminalDialogue", $@"Nitload.TerminalDialogue{exeName}");
 
             _dialogueProcessInfo = new ProcessStartInfo
             {

src/Nitload.Common/Environment/ErrorDefine.cs

@@ -11,7 +11,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp
+namespace Nitload
 {
     public class UniformEmptyReferenceException : Exception
     {

src/Nitload.Common/Environment/GlobalSetting.cs

@@ -14,7 +14,7 @@ using System.Security.Cryptography;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp
+namespace Nitload
 {
     public static unsafe partial class World
     {

src/Nitload.Common/Environment/IStaticModule.cs

@@ -9,7 +9,7 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 
-namespace StgSharp
+namespace Nitload
 {
     /// <summary>
     ///   Represents a statically activated module that can be registered and initialized as part of

src/Nitload.Common/Environment/Platform.cs

@@ -5,15 +5,15 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.HighPerformance;
-using StgSharp.HighPerformance.ProcessorAbstraction;
-using StgSharp.Timing;
+using Nitload.Common.HighPerformance;
+using Nitload.Common.HighPerformance.ProcessorAbstraction;
+using Nitload.Common.Timing;
 using System;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-namespace StgSharp
+namespace Nitload
 {
     internal enum GraphicAPI : byte
     {

src/Nitload.Common/Global.cs

@@ -5,14 +5,14 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-global using StgSharp.Internal;
+global using Nitload.Common.Internal;
 
 global using System;
 global using System.Runtime.CompilerServices;
 global using System.Threading;
 
-[assembly: InternalsVisibleTo("StgSharp.HighPerformance")]
-[assembly: InternalsVisibleTo("StgSharp.RegularAnalysis")]
-[assembly: InternalsVisibleTo("StgSharp.Graphics")]
-[assembly: InternalsVisibleTo("StgSharp.Mathematics")]
+[assembly: InternalsVisibleTo("Nitload.Common.HighPerformance")]
+[assembly: InternalsVisibleTo("Nitload.RegularAnalysis")]
+[assembly: InternalsVisibleTo("Nitload.Graphics")]
+[assembly: InternalsVisibleTo("Nitload.Mathematics")]
 [assembly: InternalsVisibleTo("StgSharpDebug")]

src/Nitload.Common/HighPerformance/IdMultiplexer.cs

@@ -11,7 +11,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance
+namespace Nitload.Common.HighPerformance
 {
     public class IdMultiplexer { }
 }

src/Nitload.Common/HighPerformance/Memory/BufferStack.cs

@@ -10,7 +10,7 @@ using System.Buffers;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     [CollectionBuilder(typeof(BufferStackBuilder), nameof(BufferStackBuilder.Create))]
     public unsafe class BufferStack<T> : IDisposable where T : unmanaged
@@ -94,22 +94,19 @@ namespace StgSharp.HighPerformance.Memory
         }
 
         /// <summary>
-        /// Fills the stack in place via a caller-supplied callback, mirroring
-        /// <c>CapacityFixedStack&lt;T&gt;.FillRange</c>.
+        ///   Fills the stack in place via a caller-supplied callback, mirroring <c>
+        ///   CapacityFixedStack&lt;T&gt;.FillRange </c>.
         /// </summary>
         /// <remarks>
-        /// Preferred over building a temporary span and handing it to
-        /// <see cref="BufferStackBuilder.Create{T}(ReadOnlySpan{T})"/>:
-        /// <list type="bullet">
-        /// <item>The caller no longer needs a scratch buffer at all — the
-        /// callback writes straight into this stack's native storage, so there
-        /// is no <c>stackalloc</c> to size and no copy afterwards.</item>
-        /// <item><c>Span&lt;T&gt;</c> does not implicitly convert to
-        /// <c>ReadOnlySpan&lt;T&gt;</c> in a way that participates in generic
-        /// type inference before C# 14, so <c>Create(span)</c> fails with
-        /// CS0411 on older compilers. Passing the element type through the
-        /// enclosing instance sidesteps inference entirely.</item>
-        /// </list>
+        ///   Preferred over building a temporary span and handing it to <see
+        ///   cref="BufferStackBuilder.Create{T}(ReadOnlySpan{T})" />: <list type="bullet"> ///
+        ///   <item> The caller no longer needs a scratch buffer at all — the /// callback writes
+        ///   straight into this stack's native storage, so there /// is no <c> stackalloc </c> to
+        ///   size and no copy afterwards. </item> /// <item><c> Span&lt;T&gt; </c> does not
+        ///   implicitly convert to /// <c> ReadOnlySpan&lt;T&gt; </c> in a way that participates in
+        ///   generic /// type inference before C# 14, so <c> Create(span) </c> fails with ///
+        ///   CS0411 on older compilers. Passing the element type through the /// enclosing instance
+        ///   sidesteps inference entirely. </item> ///</list>
         /// </remarks>
         internal unsafe void FillRange(
                              SpanAction<T, nuint> filling,
@@ -191,4 +188,4 @@ namespace StgSharp.HighPerformance.Memory
         }
 
     }
-}
+}

src/Nitload.Common/HighPerformance/Memory/ConcurrentBufferStack.cs

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Threading;
+using Nitload.Threading;
 
 using System;
 using System.Buffers;
@@ -14,7 +14,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     public static class BufferStackBuilder
     {

src/Nitload.Common/HighPerformance/Memory/L4.CacheLine.cs

@@ -5,10 +5,10 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.HighPerformance.ProcessorAbstraction;
+using Nitload.Common.HighPerformance.ProcessorAbstraction;
 using System.Runtime.InteropServices;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     public partial class L4
     {

src/Nitload.Common/HighPerformance/Memory/L4.Debug.cs

@@ -11,7 +11,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     /**/
     public partial class L4

src/Nitload.Common/HighPerformance/Memory/L4.Evict.cs

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     public partial class L4
     {

src/Nitload.Common/HighPerformance/Memory/L4.Exceptions.cs

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
 #pragma warning disable CA1032 // Implement standard exception constructors
 

src/Nitload.Common/HighPerformance/Memory/L4.Predict.cs

@@ -5,8 +5,8 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Collections;
-using StgSharp.HighPerformance.Memory;
+using Nitload.Common.Collections;
+using Nitload.Common.HighPerformance.Memory;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
@@ -14,7 +14,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     public partial class L4
     {

src/Nitload.Common/HighPerformance/Memory/L4.Predictor.cs

@@ -12,7 +12,7 @@ using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     [Flags]
     public enum PredictResult

src/Nitload.Common/HighPerformance/Memory/L4.Prefetch.cs

@@ -8,7 +8,7 @@
 using System.ComponentModel;
 using System.Numerics;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     public unsafe partial class L4
     {

src/Nitload.Common/HighPerformance/Memory/L4.Tlsf.cs

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.HighPerformance.ProcessorAbstraction;
+using Nitload.Common.HighPerformance.ProcessorAbstraction;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -14,7 +14,7 @@ using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     public partial class L4
     {

src/Nitload.Common/HighPerformance/Memory/L4.cs

@@ -5,13 +5,13 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Collections;
-using StgSharp.HighPerformance.Memory;
-using StgSharp.HighPerformance.ProcessorAbstraction;
+using Nitload.Common.Collections;
+using Nitload.Common.HighPerformance.Memory;
+using Nitload.Common.HighPerformance.ProcessorAbstraction;
 using System.Data;
 using System.Runtime.InteropServices;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     public sealed unsafe partial class L4 : IDisposable
     {

src/Nitload.Common/HighPerformance/Memory/Ptr64.cs

@@ -14,7 +14,7 @@ using System.Numerics;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
 #pragma warning disable CA2225
 

src/Nitload.Common/HighPerformance/Memory/SlabAllocationHandle.cs

@@ -8,7 +8,7 @@
 using System;
 using System.Runtime.CompilerServices;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     public unsafe struct SlabAllocationHandle<T> : IDisposable where T : unmanaged
     {

src/Nitload.Common/HighPerformance/Memory/SlabAllocator.Chunked.cs

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Threading;
+using Nitload.Threading;
 
 using System;
 using System.Collections.Generic;
@@ -13,7 +13,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     internal sealed unsafe class ChunkedSlabAllocator<T> : SlabAllocator<T> where T : unmanaged
     {

src/Nitload.Common/HighPerformance/Memory/SlabAllocator.ChunkedConcurrent.cs

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Threading;
+using Nitload.Threading;
 
 using System;
 using System.Collections.Generic;
@@ -16,7 +16,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     internal sealed unsafe class ConcurrentChunkedSlabAllocator<T> : SlabAllocator<T>
         where T : unmanaged

src/Nitload.Common/HighPerformance/Memory/SlabAllocator.Fixed.cs

@@ -5,9 +5,9 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Collections;
-using StgSharp.HighPerformance.Memory;
-using StgSharp.Threading;
+using Nitload.Common.Collections;
+using Nitload.Common.HighPerformance.Memory;
+using Nitload.Threading;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -15,7 +15,7 @@ using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     internal unsafe class FixedSlabAllocator<T> : SlabAllocator<T> where T : unmanaged
     {

src/Nitload.Common/HighPerformance/Memory/SlabAllocator.SequencialConcurrent.cs

@@ -5,14 +5,14 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Threading;
+using Nitload.Threading;
 
 using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Threading;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     public sealed unsafe class ConcurrentSequentialSlabAllocator<T> : SlabAllocator<T>
         where T : unmanaged

src/Nitload.Common/HighPerformance/Memory/SlabAllocator.cs

@@ -5,10 +5,10 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.HighPerformance.Memory;
+using Nitload.Common.HighPerformance.Memory;
 using System;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     public static class SlabAllocator
     {

src/Nitload.Common/HighPerformance/Memory/TwoLayerSegregatedFitAllocator.cs

@@ -5,8 +5,8 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.HighPerformance.Memory;
-using StgSharp.HighPerformance.ProcessorAbstraction;
+using Nitload.Common.HighPerformance.Memory;
+using Nitload.Common.HighPerformance.ProcessorAbstraction;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
@@ -18,9 +18,9 @@ using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 using System.Xml;
-using static StgSharp.HighPerformance.Memory.TwoLayerSegregatedFitAllocator;
+using static Nitload.Common.HighPerformance.Memory.TwoLayerSegregatedFitAllocator;
 
-namespace StgSharp.HighPerformance.Memory
+namespace Nitload.Common.HighPerformance.Memory
 {
     public unsafe class TwoLayerSegregatedFitAllocator : IDisposable
     {

src/Nitload.Common/HighPerformance/ProcessorAbstraction/IRegisterType.cs

@@ -12,7 +12,7 @@ using System.Numerics;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.ProcessorAbstraction
+namespace Nitload.Common.HighPerformance.ProcessorAbstraction
 {
     /// <summary>
     ///   Abstraction for a wide SIMD register or equivalent packed numeric storage. Provides raw

src/Nitload.Common/HighPerformance/ProcessorAbstraction/LogicalCore.cs

@@ -11,7 +11,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.ProcessorAbstraction
+namespace Nitload.Common.HighPerformance.ProcessorAbstraction
 {
     public readonly struct LogicalCore
     {

src/Nitload.Common/HighPerformance/ProcessorAbstraction/M128.cs

@@ -16,7 +16,7 @@ using System.Runtime.Intrinsics.X86;
 
 using System.Text;
 
-namespace StgSharp.HighPerformance.ProcessorAbstraction
+namespace Nitload.Common.HighPerformance.ProcessorAbstraction
 {
     [StructLayout(LayoutKind.Explicit, Pack = 16)]
     public unsafe struct M128 : IRegisterPresentation

src/Nitload.Common/HighPerformance/ProcessorAbstraction/M256.cs

@@ -15,7 +15,7 @@ using System.Runtime.Intrinsics;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.ProcessorAbstraction
+namespace Nitload.Common.HighPerformance.ProcessorAbstraction
 {
     [StructLayout(LayoutKind.Explicit, Pack = 16)]
     public unsafe struct M256 : IRegisterPresentation

src/Nitload.Common/HighPerformance/ProcessorAbstraction/M512.cs

@@ -15,7 +15,7 @@ using System.Runtime.Intrinsics;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.ProcessorAbstraction
+namespace Nitload.Common.HighPerformance.ProcessorAbstraction
 {
     [StructLayout(LayoutKind.Explicit, Size = 64, Pack = 64)]
     public unsafe struct M512 : IRegisterPresentation

src/Nitload.Common/HighPerformance/ProcessorAbstraction/M64.cs

@@ -10,7 +10,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics;
 
-namespace StgSharp.HighPerformance.ProcessorAbstraction
+namespace Nitload.Common.HighPerformance.ProcessorAbstraction
 {
     [StructLayout(LayoutKind.Explicit, Pack = 8)]
     public unsafe struct M64 : IRegisterPresentation

src/Nitload.Common/HighPerformance/ProcessorAbstraction/Numa.cs

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.HighPerformance.Memory;
+using Nitload.Common.HighPerformance.Memory;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.Contracts;
@@ -14,7 +14,7 @@ using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.ProcessorAbstraction
+namespace Nitload.Common.HighPerformance.ProcessorAbstraction
 {
     public static partial class Numa
     {

src/Nitload.Common/HighPerformance/ProcessorAbstraction/NumaNode.cs

@@ -12,7 +12,7 @@ using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.HighPerformance.ProcessorAbstraction
+namespace Nitload.Common.HighPerformance.ProcessorAbstraction
 {
     public class NumaNode
     {

src/Nitload.Common/Internal/DefaultLog.cs

@@ -10,7 +10,7 @@ using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading;
 
-namespace StgSharp.Internal
+namespace Nitload.Common.Internal
 {
     internal static unsafe partial class DefaultLog
     {

src/Nitload.Common/Internal/Native.cs

@@ -11,13 +11,13 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Internal
+namespace Nitload.Common.Internal
 {
     internal static unsafe partial class Native
     {
 
         internal const string LibName =
-            "StgSharp.Native";
+            "Nitload.Native";
 
         internal const string LogPath =
             "SS_error.log";

src/Nitload.Common/Internal/public.cs

@@ -11,7 +11,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp
+namespace Nitload
 {
     public enum LogType
     {

src/Nitload.Common/PipeLine/CrossFramePipelineNode.cs

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.PipeLine;
+using Nitload.Common.PipeLine;
 
 using System;
 using System.Collections.Generic;
@@ -13,7 +13,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.PipeLine
+namespace Nitload.Common.PipeLine
 {
     public class CrossFrameOperation : IConvertableToPipelineNode
     {

src/Nitload.Common/PipeLine/IConvertableToPipelineNode.cs

@@ -10,7 +10,7 @@ using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Text;
 
-namespace StgSharp.PipeLine
+namespace Nitload.Common.PipeLine
 {
     public delegate void PipelineNodeOperation(
                          in Dictionary<string, PipelineNodeInPort> input,

src/Nitload.Common/PipeLine/PipeLineRunner.cs

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Threading;
+using Nitload.Threading;
 
 using System;
 using System.Collections.Concurrent;
@@ -18,7 +18,7 @@ using System.Threading;
 
 using System.Threading.Tasks;
 
-namespace StgSharp.PipeLine
+namespace Nitload.Common.PipeLine
 {
     public static class PipeLineRunner
     {

src/Nitload.Common/PipeLine/PipelineMarshal.cs

@@ -13,7 +13,7 @@ using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.PipeLine
+namespace Nitload.Common.PipeLine
 {
     public static class PipelineMarshal
     {

src/Nitload.Common/PipeLine/PipelineNode.cs

@@ -16,7 +16,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.PipeLine
+namespace Nitload.Common.PipeLine
 {
     /// <summary>
     ///

src/Nitload.Common/PipeLine/PipelineNodeLabel.cs

@@ -13,7 +13,7 @@ using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.PipeLine
+namespace Nitload.Common.PipeLine
 {
     public abstract record class PipelineNodeLabel
     {

src/Nitload.Common/PipeLine/PipelineNodePort.cs

@@ -13,7 +13,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.PipeLine
+namespace Nitload.Common.PipeLine
 {
     public class PipelineNodeInPort
     {

src/Nitload.Common/PipeLine/PipelineScheduler.cs

@@ -14,7 +14,7 @@ using System.Threading;
 using System.Xml;
 using System.Xml.Linq;
 
-namespace StgSharp.PipeLine
+namespace Nitload.Common.PipeLine
 {
     /// <summary>
     ///   A sets of complex logic designed for running in multi threads environment. Warning: do not

src/Nitload.Common/PipeLine/PortArgs.cs

@@ -15,7 +15,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.PipeLine
+namespace Nitload.Common.PipeLine
 {
     public class PipelineConnector
     {

src/Nitload.Common/PipeLine/SideNode.cs

@@ -14,7 +14,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.PipeLine
+namespace Nitload.Common.PipeLine
 {
     internal sealed class BeginningNode : PipelineNode
     {

src/Nitload.Common/State/ISimpleStateMachine.cs

@@ -12,7 +12,7 @@ using System.Numerics;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.State
+namespace Nitload.State
 {
     public interface ISimpleStateMachine<TStateNode, TStateLabel, TStateContext>
         where TStateNode : SimpleStateMachineNode<TStateNode, TStateLabel, TStateContext>

src/Nitload.Common/State/SimpleStateMachineNode.cs

@@ -13,7 +13,7 @@ using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.State
+namespace Nitload.State
 {
     public abstract class SimpleStateMachineNode<TSelf, TLabel, TStateContext>
         where TSelf : SimpleStateMachineNode<TSelf, TLabel, TStateContext>

src/Nitload.Common/State/StateContext.cs

@@ -11,7 +11,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.State
+namespace Nitload.State
 {
     public abstract class StateContext { }
 }

src/Nitload.Common/Threading/BufferExpansionLock.cs

@@ -13,7 +13,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Threading
+namespace Nitload.Threading
 {
     /// <summary>
     ///   Provide a lock for managing concurrent access to a buffer that can be expanded and use a

src/Nitload.Common/Threading/CancellableTask.cs

@@ -13,7 +13,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Threading
+namespace Nitload.Threading
 {
     public class CancellableTask : IDisposable
     {

src/Nitload.Common/Threading/SingleConsumerBell.cs

@@ -8,7 +8,7 @@
 using System;
 using System.Threading;
 
-namespace StgSharp.Threading
+namespace Nitload.Threading
 {
     /// <summary>
     ///   A single-consumer bell/signal primitive.

src/Nitload.Common/Threading/ThreadHelper.cs

@@ -5,13 +5,13 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.HighPerformance.ProcessorAbstraction;
+using Nitload.Common.HighPerformance.ProcessorAbstraction;
 using System;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Threading;
 
-namespace StgSharp.Threading
+namespace Nitload.Threading
 {
     public static partial class ThreadHelper
     {

src/Nitload.Common/Threading/VariableCapacitySemaphore.cs

@@ -9,7 +9,7 @@ using System;
 using System.Runtime.CompilerServices;
 using System.Threading;
 
-namespace StgSharp.Threading
+namespace Nitload.Threading
 {
     /// <summary>
     ///   A counting semaphore with adjustable maximum capacity at runtime. Implemented using one or

src/Nitload.Common/Timing/StgSharpTime.cs

@@ -5,14 +5,14 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Collections;
-using StgSharp.HighPerformance.ProcessorAbstraction;
-using StgSharp.Timing;
+using Nitload.Common.Collections;
+using Nitload.Common.HighPerformance.ProcessorAbstraction;
+using Nitload.Common.Timing;
 using System;
 using System.Diagnostics;
 using System.Threading;
 
-namespace StgSharp
+namespace Nitload
 {
     public static partial class World
     {

src/Nitload.Common/Timing/TimeSequence.cs

@@ -5,11 +5,11 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Timing;
+using Nitload.Common.Timing;
 using System;
 using System.Runtime.CompilerServices;
 
-namespace StgSharp.Timing
+namespace Nitload.Common.Timing
 {
     public abstract class TimeSequence
     {

src/Nitload.Common/Timing/TimeSourceProvider.cs

@@ -5,13 +5,13 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp;
-using StgSharp.HighPerformance.ProcessorAbstraction;
+using Nitload;
+using Nitload.Common.HighPerformance.ProcessorAbstraction;
 using System;
 using System.Linq;
 using System.Threading;
 
-namespace StgSharp.Timing
+namespace Nitload.Common.Timing
 {
     public class TimeSourceStartupConfiguration(
                  nuint bindedNumaNode = 0,

src/Nitload.Common/Timing/TimeSpanProvider.Awaiting.cs

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.HighPerformance.Memory;
+using Nitload.Common.HighPerformance.Memory;
 
 using System;
 using System.Collections.Concurrent;
@@ -13,7 +13,7 @@ using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Timing
+namespace Nitload.Common.Timing
 {
     public partial class TimeSpanProvider
     {

src/Nitload.Common/Timing/TimeSpanProvider.cs

@@ -5,12 +5,12 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Timing;
+using Nitload.Common.Timing;
 using System;
 using System.Runtime.CompilerServices;
 using System.Threading;
 
-namespace StgSharp.Timing
+namespace Nitload.Common.Timing
 {
     /// <summary>
     ///   TimeSpanProvider: uses a bound TimeSequence and TimeSourceProviderBase to publish span

src/Nitload.Graphics/.discard/CPUanimation.IImageProvider.cs.old

@@ -9,7 +9,7 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 
-namespace StgSharp.Graphics
+namespace Nitload.Graphics
 {
     public interface IImageProvider
     {

src/Nitload.Graphics/.discard/CPUanimation.ImageHelper.cs.old

@@ -10,7 +10,7 @@ using System.Collections.Generic;
 using System.ComponentModel;
 using System.Text;
 
-namespace StgSharp.Graphics
+namespace Nitload.Graphics
 {
     public static class ImageHelper
     {

src/Nitload.Graphics/.discard/Define.BufferObjectBase.cs.old

@@ -5,15 +5,15 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Graphics;
-using StgSharp.Graphics.OpenGL;
+using Nitload.Graphics;
+using Nitload.Graphics.OpenGL;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Graphics
+namespace Nitload.Graphics
 {
     /// <summary>
     ///   Interface of all kinds OpenGL BufferHandle objects

src/Nitload.Graphics/.discard/GraphicInitializer.cs.old

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp;
+using Nitload;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -13,7 +13,7 @@ using System.Text;
 
 using System.Threading.Tasks;
 
-namespace StgSharp.Graphics
+namespace Nitload.Graphics
 {
     public class GraphicModuel : IStaticModule
     {

src/Nitload.Graphics/.discard/Image.Native.cs.old

@@ -5,12 +5,12 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Internal;
+using Nitload.Common.Internal;
 
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
-namespace StgSharp.Graphics
+namespace Nitload.Graphics
 {
     internal static unsafe partial class GraphicFramework
     {

src/Nitload.Graphics/.discard/Image.cs.old

@@ -5,12 +5,12 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Graphics.OpenGL;
+using Nitload.Graphics.OpenGL;
 
 using System;
 using System.Runtime.CompilerServices;
 
-namespace StgSharp.Graphics
+namespace Nitload.Graphics
 {
     public class Image : IImageProvider
     {

src/Nitload.Graphics/.discard/ImageInfo.cs.old

@@ -5,14 +5,14 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Graphics.OpenGL;
+using Nitload.Graphics.OpenGL;
 using System;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 
-namespace StgSharp.Graphics
+namespace Nitload.Graphics
 {
     [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
     public delegate IntPtr ImageLoader(

src/Nitload.Graphics/.discard/OpenGL.Buffer.AutoTexture.cs.old

@@ -5,8 +5,8 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Collections;
-using StgSharp.Graphics;
+using Nitload.Common.Collections;
+using Nitload.Graphics;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
@@ -16,7 +16,7 @@ using System.Text;
 
 using System.Threading.Tasks;
 
-namespace StgSharp.Graphics.OpenGL
+namespace Nitload.Graphics.OpenGL
 {
     /// <summary>
     ///   A collection of a sets of OpenGL textures. The collection can automatically select one of

src/Nitload.Graphics/.discard/OpenGL.Buffer.GLBufferObjectBase.cs.old

@@ -5,13 +5,13 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Graphics.OpenGL;
+using Nitload.Graphics.OpenGL;
 
 using System;
 using System.Collections.Generic;
 using System.Text;
 
-namespace StgSharp.Graphics.OpenGL
+namespace Nitload.Graphics.OpenGL
 {
     public abstract class GlBufferObjectBase : BufferObjectBase
     {

src/Nitload.Graphics/.discard/OpenGL.Generated.GlCommandHistory.g.cs.old

@@ -1,12 +1,12 @@
-// <auto-generated>
-// Generated by StgSharp.GenerateGL on 2026-08-25 09:22:55Z
+// <auto-generated>
+// Generated by Nitload.GenerateGL on 2026-08-25 09:22:55Z
 // Command availability history
 // </auto-generated>
 using System;
 using System.Collections.Frozen;
 using System.Collections.Generic;
 
-namespace StgSharp.Graphics.OpenGL
+namespace Nitload.Graphics.OpenGL
 {
     internal enum CommandHistoryAction { Added, Removed }
 

src/Nitload.Graphics/.discard/OpenGL.ShaderEdit.IglConvertable.cs.old

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Graphics.OpenGL;
+using Nitload.Graphics.OpenGL;
 
 using System;
 using System.Collections.Generic;
@@ -13,7 +13,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Graphics.ShaderEdit
+namespace Nitload.Graphics.ShaderEdit
 {
     public interface IglConvertable
     {

src/Nitload.Graphics/.discard/OpenGL.glApiManager.Const.cs.old

@@ -9,7 +9,7 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 
-namespace StgSharp.Graphics.OpenGL
+namespace Nitload.Graphics.OpenGL
 {
     public static partial class glManager
     {

src/Nitload.Graphics/.discard/OpenGL.glApiManager.cs.old

@@ -5,9 +5,9 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-using StgSharp.Internal;
-using StgSharp.Mathematics;
-using StgSharp.Mathematics;
+using Nitload.Common.Internal;
+using Nitload.Mathematics;
+using Nitload.Mathematics;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -15,7 +15,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 
-namespace StgSharp.Graphics.OpenGL
+namespace Nitload.Graphics.OpenGL
 {
     public static partial class glManager
     {

src/Nitload.Graphics/.discard/OpenGL.glRenderObjectGenrator.cs.old

@@ -13,7 +13,7 @@ using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Graphics.OpenGL
+namespace Nitload.Graphics.OpenGL
 {
     public partial class glRender
     {

src/Nitload.Graphics/.discard/OpenGL.glRenderStream.ThreadSecurity.cs.old

@@ -13,7 +13,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Graphics.OpenGL
+namespace Nitload.Graphics.OpenGL
 {
     public partial class glRender
     {

src/Nitload.Graphics/.discard/OpenGL.glType.cs.old

@@ -11,7 +11,7 @@ using System.Collections.ObjectModel;
 using System.Runtime.InteropServices;
 using System.Text;
 
-namespace StgSharp.Graphics.OpenGL
+namespace Nitload.Graphics.OpenGL
 {
     internal delegate void GLVULKANPROCNV();
 

src/Nitload.Graphics/.discard/Pixels.cs.old

@@ -10,7 +10,7 @@ using System.Collections.Generic;
 using System.Runtime.InteropServices;
 using System.Text;
 
-namespace StgSharp.Graphics
+namespace Nitload.Graphics
 {
     public interface IPixel
     {

src/Nitload.Graphics/.discard/ShaderEdit.InternalShaderType.cs.old

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: MIT
 // -----------------------------------------------------------------------------
 
-namespace StgSharp.Graphics.ShaderEdit
+namespace Nitload.Graphics.ShaderEdit
 {
     // Temporary compatibility type for ShaderStruct. The new shader model will replace it.
     public enum InternalShaderType