diff --git a/EvoSC.sln b/EvoSC.sln
index 8820dabb7..2ec61fa13 100644
--- a/EvoSC.sln
+++ b/EvoSC.sln
@@ -142,7 +142,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TeamChatModule", "src/Modul
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TeamChatModule.Tests", "tests\Modules\TeamChatModule.Tests\TeamChatModule.Tests.csproj", "{7BD60D6E-7B7E-4771-87C0-7F98FC82F990}"
 EndProject
-
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SpectatorTargetInfoModule.Tests", "tests\Modules\SpectatorTargetInfoModule.Tests\SpectatorTargetInfoModule.Tests.csproj", "{E4BF17BE-A517-4D3C-8DCA-DA99A100EBFE}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SpectatorCamModeModule", "src\Modules\SpectatorCamModeModule\SpectatorCamModeModule.csproj", "{E9806703-6E24-4F05-A728-A04F7EB31749}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SpectatorCamModeModule.Tests", "tests\Modules\SpectatorCamModeModule.Tests\SpectatorCamModeModule.Tests.csproj", "{09A88256-8008-4085-A8E6-CA6DEFAC63E3}"
+EndProject
 
 
 
@@ -430,6 +435,18 @@ Global
 		{7BD60D6E-7B7E-4771-87C0-7F98FC82F990}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{7BD60D6E-7B7E-4771-87C0-7F98FC82F990}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{7BD60D6E-7B7E-4771-87C0-7F98FC82F990}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E4BF17BE-A517-4D3C-8DCA-DA99A100EBFE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E4BF17BE-A517-4D3C-8DCA-DA99A100EBFE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E4BF17BE-A517-4D3C-8DCA-DA99A100EBFE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E4BF17BE-A517-4D3C-8DCA-DA99A100EBFE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E9806703-6E24-4F05-A728-A04F7EB31749}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E9806703-6E24-4F05-A728-A04F7EB31749}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E9806703-6E24-4F05-A728-A04F7EB31749}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E9806703-6E24-4F05-A728-A04F7EB31749}.Release|Any CPU.Build.0 = Release|Any CPU
+		{09A88256-8008-4085-A8E6-CA6DEFAC63E3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{09A88256-8008-4085-A8E6-CA6DEFAC63E3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{09A88256-8008-4085-A8E6-CA6DEFAC63E3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{09A88256-8008-4085-A8E6-CA6DEFAC63E3}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -497,5 +514,8 @@ Global
 		{4AA1890A-1423-4831-95B2-E29B9A7A58D1} = {6D75D6A2-6ECD-4DE4-96C5-CAD7D134407A}
 		{DDB0A249-BD1C-4556-BFE1-362B17EDA874} = {DC47658A-F421-4BA4-B617-090A7DFB3900}
 		{7BD60D6E-7B7E-4771-87C0-7F98FC82F990} = {6D75D6A2-6ECD-4DE4-96C5-CAD7D134407A}
+		{E4BF17BE-A517-4D3C-8DCA-DA99A100EBFE} = {6D75D6A2-6ECD-4DE4-96C5-CAD7D134407A}
+		{E9806703-6E24-4F05-A728-A04F7EB31749} = {DC47658A-F421-4BA4-B617-090A7DFB3900}
+		{09A88256-8008-4085-A8E6-CA6DEFAC63E3} = {6D75D6A2-6ECD-4DE4-96C5-CAD7D134407A}
 	EndGlobalSection
 EndGlobal
diff --git a/src/EvoSC/EvoSC.csproj b/src/EvoSC/EvoSC.csproj
index 12ca2d98b..844ecefc8 100644
--- a/src/EvoSC/EvoSC.csproj
+++ b/src/EvoSC/EvoSC.csproj
@@ -49,6 +49,7 @@
         <ProjectReference Include="..\Modules\MatchManagerModule\MatchManagerModule.csproj" />
         <ProjectReference Include="..\Modules\ASayModule\ASayModule.csproj" />
         <ProjectReference Include="..\Modules\ServerManagementModule\ServerManagementModule.csproj" />
+        <ProjectReference Include="..\Modules\SpectatorCamModeModule\SpectatorCamModeModule.csproj" />
         <ProjectReference Include="..\Modules\SpectatorTargetInfoModule\SpectatorTargetInfoModule.csproj" />
         <ProjectReference Include="..\Modules\TeamChatModule\TeamChatModule.csproj" />
         <ProjectReference Include="..\Modules\TeamInfoModule\TeamInfoModule.csproj" />
diff --git a/src/EvoSC/InternalModules.cs b/src/EvoSC/InternalModules.cs
index 94a8df479..a7fa2c43b 100644
--- a/src/EvoSC/InternalModules.cs
+++ b/src/EvoSC/InternalModules.cs
@@ -23,6 +23,7 @@
 using EvoSC.Modules.Official.Scoreboard;
 using EvoSC.Modules.Official.ServerManagementModule;
 using EvoSC.Modules.Official.SetName;
+using EvoSC.Modules.Official.SpectatorCamModeModule;
 using EvoSC.Modules.Official.SpectatorTargetInfoModule;
 using EvoSC.Modules.Official.TeamChatModule;
 using EvoSC.Modules.Official.TeamInfoModule;
@@ -37,6 +38,7 @@ public static class InternalModules
     public static readonly Type[] Modules =
     [
         //typeof(ExampleModule),
+        typeof(GameModeUiModule),
         typeof(PlayerModule),
         typeof(MapsModule),
         typeof(WorldRecordModule),
@@ -55,6 +57,7 @@ public static class InternalModules
         typeof(MatchRankingModule),
         typeof(ASayModule),
         typeof(SpectatorTargetInfoModule),
+        typeof(SpectatorCamModeModule),
         typeof(MapQueueModule),
         typeof(MapListModule),
         typeof(LocalRecordsModule),
@@ -62,7 +65,6 @@ public static class InternalModules
         typeof(TeamSettingsModule),
         typeof(ServerManagementModule),
         typeof(TeamInfoModule),
-        typeof(GameModeUiModule),
         typeof(TeamChatModule)
     ];
 
diff --git a/src/Modules/GameModeUiModule/Enums/GameModeUiComponents.cs b/src/Modules/GameModeUiModule/Enums/GameModeUiComponents.cs
new file mode 100644
index 000000000..2d871da86
--- /dev/null
+++ b/src/Modules/GameModeUiModule/Enums/GameModeUiComponents.cs
@@ -0,0 +1,20 @@
+namespace EvoSC.Modules.Official.GameModeUiModule.Enums;
+
+public static class GameModeUiComponents
+{
+    public static readonly string Chrono = "Race_Chrono";
+    public static readonly string RespawnHelper = "Race_RespawnHelper";
+    public static readonly string Checkpoint = "Race_Checkpoint";
+    public static readonly string LapsCounter = "Race_LapsCounter";
+    public static readonly string TimeGap = "Race_TimeGap";
+    public static readonly string ScoresTable = "Race_ScoresTable";
+    public static readonly string DisplayMessage = "Race_DisplayMessage";
+    public static readonly string Countdown = "Race_Countdown";
+    public static readonly string SpectatorBaseName = "Race_SpectatorBase_Name";
+    public static readonly string SpectatorBaseCommands = "Race_SpectatorBase_Commands";
+    public static readonly string Record = "Race_Record";
+    public static readonly string BigMessage = "Race_BigMessage";
+    public static readonly string BlockHelper = "Race_BlockHelper";
+    public static readonly string WarmUp = "Race_WarmUp";
+    public static readonly string BestRaceViewer = "Race_BestRaceViewer";
+}
diff --git a/src/Modules/GameModeUiModule/GameModeUiModule.cs b/src/Modules/GameModeUiModule/GameModeUiModule.cs
index 6f3146424..e89eaa919 100644
--- a/src/Modules/GameModeUiModule/GameModeUiModule.cs
+++ b/src/Modules/GameModeUiModule/GameModeUiModule.cs
@@ -7,7 +7,7 @@ namespace EvoSC.Modules.Official.GameModeUiModule;
 [Module(IsInternal = true)]
 public class GameModeUiModule(IGameModeUiModuleService gameModeUiModuleService) : EvoScModule, IToggleable
 {
-    public Task EnableAsync() => gameModeUiModuleService.ApplyConfigurationAsync();
+    public Task EnableAsync() => gameModeUiModuleService.ApplyComponentSettingsAsync(gameModeUiModuleService.GetDefaultSettings());
 
     public Task DisableAsync() => Task.CompletedTask;
 }
diff --git a/src/Modules/GameModeUiModule/GameModeUiModule.csproj b/src/Modules/GameModeUiModule/GameModeUiModule.csproj
index 5d11a594b..881d331e5 100644
--- a/src/Modules/GameModeUiModule/GameModeUiModule.csproj
+++ b/src/Modules/GameModeUiModule/GameModeUiModule.csproj
@@ -12,8 +12,6 @@
         <ProjectReference Include="..\..\EvoSC.Modules\EvoSC.Modules.csproj"/>
         <EmbeddedResource Include="Templates\**\*"/>
         <EmbeddedResource Update="Localization.resx">
-            <Generator>ResXFileCodeGenerator</Generator>
-            <LastGenOutput>Localization.Designer.cs</LastGenOutput>
         </EmbeddedResource>
     </ItemGroup>
 
diff --git a/src/Modules/GameModeUiModule/Interfaces/IGameModeUiModuleService.cs b/src/Modules/GameModeUiModule/Interfaces/IGameModeUiModuleService.cs
index 0774afd55..eb2f5dcad 100644
--- a/src/Modules/GameModeUiModule/Interfaces/IGameModeUiModuleService.cs
+++ b/src/Modules/GameModeUiModule/Interfaces/IGameModeUiModuleService.cs
@@ -1,27 +1,50 @@
-namespace EvoSC.Modules.Official.GameModeUiModule.Interfaces;
+using EvoSC.Modules.Official.GameModeUiModule.Models;
+
+namespace EvoSC.Modules.Official.GameModeUiModule.Interfaces;
 
 public interface IGameModeUiModuleService
 {
     /// <summary>
-    /// Applies the configured UI modules property values.
+    /// Applies the given game mode component settings collection.
     /// </summary>
+    /// <param name="componentSettingsList"></param>
     /// <returns></returns>
-    public Task ApplyConfigurationAsync();
+    public Task ApplyComponentSettingsAsync(IEnumerable<GameModeUiComponentSettings> componentSettingsList);
 
     /// <summary>
-    /// Returns the configured UI modules properties as JSON string.
+    /// Applies the given game mode component settings.
     /// </summary>
+    /// <param name="componentSettings"></param>
     /// <returns></returns>
-    public Task<string> GetUiModulesPropertiesJsonAsync();
+    public Task ApplyComponentSettingsAsync(GameModeUiComponentSettings componentSettings);
 
     /// <summary>
-    /// Generates a UI properties object for the given values.
+    /// Applies the given game mode component settings.
     /// </summary>
-    /// <param name="uiModuleName"></param>
+    /// <param name="name"></param>
     /// <param name="visible"></param>
     /// <param name="x"></param>
     /// <param name="y"></param>
     /// <param name="scale"></param>
     /// <returns></returns>
-    public Task<dynamic> GeneratePropertyObjectAsync(string uiModuleName, bool visible, double x, double y, double scale);
+    public Task ApplyComponentSettingsAsync(string name, bool visible, double x, double y, double scale);
+
+    /// <summary>
+    /// Returns the configured UI modules properties as JSON string.
+    /// </summary>
+    /// <returns></returns>
+    public string GetUiModulesPropertiesJson(IEnumerable<GameModeUiComponentSettings> componentSettingsList);
+
+    /// <summary>
+    /// Generates a UI properties object for the given values.
+    /// </summary>
+    /// <param name="componentSettings"></param>
+    /// <returns></returns>
+    public dynamic GeneratePropertyObject(GameModeUiComponentSettings componentSettings);
+
+    /// <summary>
+    /// Gets the default game mode component settings collection.
+    /// </summary>
+    /// <returns></returns>
+    public List<GameModeUiComponentSettings> GetDefaultSettings();
 }
diff --git a/src/Modules/GameModeUiModule/Models/GameModeUiComponentSettings.cs b/src/Modules/GameModeUiModule/Models/GameModeUiComponentSettings.cs
new file mode 100644
index 000000000..b001de740
--- /dev/null
+++ b/src/Modules/GameModeUiModule/Models/GameModeUiComponentSettings.cs
@@ -0,0 +1,44 @@
+namespace EvoSC.Modules.Official.GameModeUiModule.Models;
+
+public class GameModeUiComponentSettings(string name, bool visible, double x, double y, double scale)
+{
+    /// <summary>
+    /// The Name/ID of the game mode UI component.
+    /// </summary>
+    public string Name { get; init; } = name;
+    
+    /// <summary>
+    /// Sets whether the component should be visible.
+    /// </summary>
+    public bool Visible { get; set; } = visible;
+    
+    /// <summary>
+    /// Sets the X position of the component.
+    /// </summary>
+    public double X { get; set; } = x;
+    
+    /// <summary>
+    /// Sets the Y position of the component.
+    /// </summary>
+    public double Y { get; set; } = y;
+    
+    /// <summary>
+    /// Sets the scale of the component.
+    /// </summary>
+    public double Scale { get; set; } = scale;
+    
+    /// <summary>
+    /// Sets whether the visibility of the component should be overwritten.
+    /// </summary>
+    public bool UpdateVisible { get; set; } = true;
+    
+    /// <summary>
+    /// Sets whether the position of the component should be overwritten.
+    /// </summary>
+    public bool UpdatePosition { get; set; } = true;
+    
+    /// <summary>
+    /// Sets whether the scale of the component should be overwritten.
+    /// </summary>
+    public bool UpdateScale { get; set; } = true;
+}
diff --git a/src/Modules/GameModeUiModule/Services/GameModeUiModuleService.cs b/src/Modules/GameModeUiModule/Services/GameModeUiModuleService.cs
index 44ef2ba2c..8f87e5578 100644
--- a/src/Modules/GameModeUiModule/Services/GameModeUiModuleService.cs
+++ b/src/Modules/GameModeUiModule/Services/GameModeUiModuleService.cs
@@ -2,7 +2,9 @@
 using EvoSC.Common.Services.Attributes;
 using EvoSC.Common.Services.Models;
 using EvoSC.Modules.Official.GameModeUiModule.Config;
+using EvoSC.Modules.Official.GameModeUiModule.Enums;
 using EvoSC.Modules.Official.GameModeUiModule.Interfaces;
+using EvoSC.Modules.Official.GameModeUiModule.Models;
 using Newtonsoft.Json;
 
 namespace EvoSC.Modules.Official.GameModeUiModule.Services;
@@ -11,139 +13,148 @@ namespace EvoSC.Modules.Official.GameModeUiModule.Services;
 public class GameModeUiModuleService(IServerClient server, IGameModeUiModuleSettings settings)
     : IGameModeUiModuleService
 {
-    public async Task ApplyConfigurationAsync()
+    public Task ApplyComponentSettingsAsync(IEnumerable<GameModeUiComponentSettings> componentSettingsList) =>
+        server.Remote.TriggerModeScriptEventArrayAsync("Common.UIModules.SetProperties",
+            GetUiModulesPropertiesJson(componentSettingsList));
+
+    public Task ApplyComponentSettingsAsync(GameModeUiComponentSettings componentSettings) =>
+        ApplyComponentSettingsAsync([componentSettings]);
+
+    public Task ApplyComponentSettingsAsync(string name, bool visible, double x, double y, double scale) =>
+        ApplyComponentSettingsAsync([new GameModeUiComponentSettings(name, visible, x, y, scale)]);
+
+    public string GetUiModulesPropertiesJson(IEnumerable<GameModeUiComponentSettings> componentSettingsList)
     {
-        var uiModuleProperties = await GetUiModulesPropertiesJsonAsync();
-        await server.Remote.TriggerModeScriptEventArrayAsync("Common.UIModules.SetProperties", uiModuleProperties);
+        var propertyObjects = componentSettingsList
+            .Select(uiElement => GeneratePropertyObject(uiElement))
+            .ToList();
+
+        return JsonConvert.SerializeObject(new { uimodules = propertyObjects });
     }
 
-    public async Task<string> GetUiModulesPropertiesJsonAsync()
+    public dynamic GeneratePropertyObject(GameModeUiComponentSettings componentSettings)
     {
-        return JsonConvert.SerializeObject(new
+        return new
         {
-            uimodules = new List<dynamic>
-            {
-                await GeneratePropertyObjectAsync(
-                    "Race_Chrono",
-                    settings.ChronoVisible,
-                    settings.ChronoX,
-                    settings.ChronoY,
-                    settings.ChronoScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_RespawnHelper",
-                    settings.RespawnHelperVisible,
-                    settings.RespawnHelperX,
-                    settings.RespawnHelperY,
-                    settings.RespawnHelperScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_Checkpoint",
-                    settings.CheckpointVisible,
-                    settings.CheckpointX,
-                    settings.CheckpointY,
-                    settings.CheckpointScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_LapsCounter",
-                    settings.LapsCounterVisible,
-                    settings.LapsCounterX,
-                    settings.LapsCounterY,
-                    settings.LapsCounterScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_TimeGap",
-                    settings.TimeGapVisible,
-                    settings.TimeGapX,
-                    settings.TimeGapY,
-                    settings.TimeGapScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_ScoresTable",
-                    settings.ScoresTableVisible,
-                    settings.ScoresTableX,
-                    settings.ScoresTableY,
-                    settings.ScoresTableScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_DisplayMessage",
-                    settings.DisplayMessageVisible,
-                    settings.DisplayMessageX,
-                    settings.DisplayMessageY,
-                    settings.DisplayMessageScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_Countdown",
-                    settings.CountdownVisible,
-                    settings.CountdownX,
-                    settings.CountdownY,
-                    settings.CountdownScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_SpectatorBase_Name",
-                    settings.SpectatorBaseNameVisible,
-                    settings.SpectatorBaseNameX,
-                    settings.SpectatorBaseNameY,
-                    settings.SpectatorBaseNameScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_SpectatorBase_Commands",
-                    settings.SpectatorBaseCommandsVisible,
-                    settings.SpectatorBaseCommandsX,
-                    settings.SpectatorBaseCommandsY,
-                    settings.SpectatorBaseCommandsScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_Record",
-                    settings.RecordVisible,
-                    settings.RecordX,
-                    settings.RecordY,
-                    settings.RecordScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_BigMessage",
-                    settings.BigMessageVisible,
-                    settings.BigMessageX,
-                    settings.BigMessageY,
-                    settings.BigMessageScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_BlockHelper",
-                    settings.BlockHelperVisible,
-                    settings.BlockHelperX,
-                    settings.BlockHelperY,
-                    settings.BlockHelperScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_WarmUp",
-                    settings.WarmUpVisible,
-                    settings.WarmUpX,
-                    settings.WarmUpY,
-                    settings.WarmUpScale
-                ),
-                await GeneratePropertyObjectAsync(
-                    "Race_BestRaceViewer",
-                    settings.BestRaceViewerVisible,
-                    settings.BestRaceViewerX,
-                    settings.BestRaceViewerY,
-                    settings.BestRaceViewerScale
-                ),
-            }
-        });
+            id = componentSettings.Name,
+            position = (double[]) [componentSettings.X, componentSettings.Y],
+            visible = componentSettings.Visible,
+            scale = componentSettings.Scale,
+            position_update = componentSettings.UpdatePosition,
+            visible_update = componentSettings.UpdateVisible,
+            scale_update = componentSettings.UpdateScale,
+        };
     }
 
-    public Task<dynamic> GeneratePropertyObjectAsync(string uiModuleName, bool visible, double x, double y,
-        double scale)
+    public List<GameModeUiComponentSettings> GetDefaultSettings()
     {
-        return Task.FromResult<dynamic>(new
-        {
-            id = uiModuleName,
-            position = (double[]) [x, y],
-            visible,
-            scale,
-            position_update = true,
-            visible_update = true,
-            scale_update = true,
-        });
+        return
+        [
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.Chrono,
+                settings.ChronoVisible,
+                settings.ChronoX,
+                settings.ChronoY,
+                settings.ChronoScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.RespawnHelper,
+                settings.RespawnHelperVisible,
+                settings.RespawnHelperX,
+                settings.RespawnHelperY,
+                settings.RespawnHelperScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.Checkpoint,
+                settings.CheckpointVisible,
+                settings.CheckpointX,
+                settings.CheckpointY,
+                settings.CheckpointScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.LapsCounter,
+                settings.LapsCounterVisible,
+                settings.LapsCounterX,
+                settings.LapsCounterY,
+                settings.LapsCounterScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.TimeGap,
+                settings.TimeGapVisible,
+                settings.TimeGapX,
+                settings.TimeGapY,
+                settings.TimeGapScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.ScoresTable,
+                settings.ScoresTableVisible,
+                settings.ScoresTableX,
+                settings.ScoresTableY,
+                settings.ScoresTableScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.DisplayMessage,
+                settings.DisplayMessageVisible,
+                settings.DisplayMessageX,
+                settings.DisplayMessageY,
+                settings.DisplayMessageScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.Countdown,
+                settings.CountdownVisible,
+                settings.CountdownX,
+                settings.CountdownY,
+                settings.CountdownScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.SpectatorBaseName,
+                settings.SpectatorBaseNameVisible,
+                settings.SpectatorBaseNameX,
+                settings.SpectatorBaseNameY,
+                settings.SpectatorBaseNameScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.SpectatorBaseCommands,
+                settings.SpectatorBaseCommandsVisible,
+                settings.SpectatorBaseCommandsX,
+                settings.SpectatorBaseCommandsY,
+                settings.SpectatorBaseCommandsScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.Record,
+                settings.RecordVisible,
+                settings.RecordX,
+                settings.RecordY,
+                settings.RecordScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.BigMessage,
+                settings.BigMessageVisible,
+                settings.BigMessageX,
+                settings.BigMessageY,
+                settings.BigMessageScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.BlockHelper,
+                settings.BlockHelperVisible,
+                settings.BlockHelperX,
+                settings.BlockHelperY,
+                settings.BlockHelperScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.WarmUp,
+                settings.WarmUpVisible,
+                settings.WarmUpX,
+                settings.WarmUpY,
+                settings.WarmUpScale
+            ),
+            new GameModeUiComponentSettings(
+                GameModeUiComponents.BestRaceViewer,
+                settings.BestRaceViewerVisible,
+                settings.BestRaceViewerX,
+                settings.BestRaceViewerY,
+                settings.BestRaceViewerScale
+            )
+        ];
     }
 }
diff --git a/src/Modules/Scoreboard/Scoreboard.csproj b/src/Modules/Scoreboard/Scoreboard.csproj
index 7e97db700..b1ff40dea 100644
--- a/src/Modules/Scoreboard/Scoreboard.csproj
+++ b/src/Modules/Scoreboard/Scoreboard.csproj
@@ -9,6 +9,7 @@
 
     <ItemGroup>
       <ProjectReference Include="..\..\EvoSC.Modules\EvoSC.Modules.csproj" />
+      <ProjectReference Include="..\GameModeUiModule\GameModeUiModule.csproj" />
       <ProjectReference Include="..\MatchManagerModule\MatchManagerModule.csproj" />
     </ItemGroup>
 
diff --git a/src/Modules/Scoreboard/Services/ScoreboardService.cs b/src/Modules/Scoreboard/Services/ScoreboardService.cs
index d8e79f91b..4df4f2992 100644
--- a/src/Modules/Scoreboard/Services/ScoreboardService.cs
+++ b/src/Modules/Scoreboard/Services/ScoreboardService.cs
@@ -5,23 +5,33 @@
 using EvoSC.Common.Services.Attributes;
 using EvoSC.Common.Services.Models;
 using EvoSC.Manialinks.Interfaces;
+using EvoSC.Modules.Official.GameModeUiModule.Enums;
+using EvoSC.Modules.Official.GameModeUiModule.Interfaces;
 using EvoSC.Modules.Official.Scoreboard.Interfaces;
 
 namespace EvoSC.Modules.Official.Scoreboard.Services;
 
 [Service(LifeStyle = ServiceLifeStyle.Transient)]
-public class ScoreboardService(IManialinkManager manialinks, IServerClient server,
-        IMatchSettingsService matchSettingsService, IScoreboardTrackerService scoreboardTracker, IThemeManager themes)
+public class ScoreboardService(
+    IManialinkManager manialinks,
+    IServerClient server,
+    IMatchSettingsService matchSettingsService,
+    IScoreboardTrackerService scoreboardTracker,
+    IGameModeUiModuleService gameModeUiModuleService,
+    IThemeManager themes
+)
     : IScoreboardService
 {
+    private const string ScoreboardTemplate = "Scoreboard.Scoreboard";
+
     public async Task ShowScoreboardToAllAsync()
     {
-        await manialinks.SendPersistentManialinkAsync("Scoreboard.Scoreboard", await GetDataAsync());
+        await manialinks.SendPersistentManialinkAsync(ScoreboardTemplate, await GetDataAsync());
     }
 
     public async Task ShowScoreboardAsync(IPlayer playerLogin)
     {
-        await manialinks.SendManialinkAsync(playerLogin, "Scoreboard.Scoreboard", await GetDataAsync());
+        await manialinks.SendManialinkAsync(playerLogin, ScoreboardTemplate, await GetDataAsync());
     }
 
     private Task<dynamic> GetDataAsync()
@@ -30,49 +40,18 @@ private Task<dynamic> GetDataAsync()
         {
             scoreboardTracker.MaxPlayers,
             scoreboardTracker.RoundsPerMap,
-            PositionColors = new Dictionary<int, string> { { 1, themes.Theme.Gold }, { 2, themes.Theme.Silver }, { 3, themes.Theme.Bronze } },
+            PositionColors = new Dictionary<int, string>
+            {
+                { 1, themes.Theme.Gold }, { 2, themes.Theme.Silver }, { 3, themes.Theme.Bronze }
+            },
         });
     }
 
-    public async Task HideNadeoScoreboardAsync()
-    {
-        var hudSettings = new List<string>
-        {
-            @"{
-    ""uimodules"": [
-        {
-            ""id"": ""Race_ScoresTable"",
-            ""position"": [-50,0],
-            ""scale"": 1,
-            ""visible"": false,
-            ""visible_update"": true
-        }
-    ]
-}"
-        };
+    public Task HideNadeoScoreboardAsync() =>
+        gameModeUiModuleService.ApplyComponentSettingsAsync(GameModeUiComponents.ScoresTable, false, 0, 0, 1);
 
-        await server.Remote.TriggerModeScriptEventArrayAsync("Common.UIModules.SetProperties", hudSettings.ToArray());
-    }
-
-    public async Task ShowNadeoScoreboardAsync()
-    {
-        var hudSettings = new List<string>
-        {
-            @"{
-    ""uimodules"": [
-        {
-            ""id"": ""Race_ScoresTable"",
-            ""position"": [-50,0],
-            ""scale"": 1,
-            ""visible"": true,
-            ""visible_update"": true
-        }
-    ]
-}"
-        };
-
-        await server.Remote.TriggerModeScriptEventArrayAsync("Common.UIModules.SetProperties", hudSettings.ToArray());
-    }
+    public Task ShowNadeoScoreboardAsync() =>
+        gameModeUiModuleService.ApplyComponentSettingsAsync(GameModeUiComponents.ScoresTable, false, -50, 0, 1);
 
     public async Task SendRequiredAdditionalInfoAsync()
     {
@@ -88,14 +67,15 @@ public async Task LoadAndSendRequiredAdditionalInfoAsync()
         {
             return;
         }
-        
+
         var roundsPerMap = -1;
         var pointsLimit = -1;
-        
+
         if (settings.TryGetValue("S_RoundsPerMap", out var rounds))
         {
             roundsPerMap = (int)rounds;
         }
+
         if (settings.TryGetValue("S_PointsLimit", out var pointsLimitValue))
         {
             pointsLimit = (int)pointsLimitValue;
@@ -104,7 +84,7 @@ public async Task LoadAndSendRequiredAdditionalInfoAsync()
         scoreboardTracker.MaxPlayers = (await server.Remote.GetMaxPlayersAsync()).CurrentValue;
         scoreboardTracker.RoundsPerMap = roundsPerMap;
         scoreboardTracker.PointsLimit = pointsLimit;
-        
+
         await SendRequiredAdditionalInfoAsync();
     }
 
diff --git a/src/Modules/Scoreboard/info.toml b/src/Modules/Scoreboard/info.toml
index f3c9a1dae..d957e2580 100644
--- a/src/Modules/Scoreboard/info.toml
+++ b/src/Modules/Scoreboard/info.toml
@@ -4,3 +4,6 @@ title = "Scoreboard"
 summary = "Custom EvoSC Scoreboards."
 version = "1.0.0"
 author = "Evo"
+
+[dependencies]
+GameModeUiModule = "1.0.0"
diff --git a/src/Modules/SpectatorCamModeModule/Config/ISpectatorCamModeSettings.cs b/src/Modules/SpectatorCamModeModule/Config/ISpectatorCamModeSettings.cs
new file mode 100644
index 000000000..d1e36d61c
--- /dev/null
+++ b/src/Modules/SpectatorCamModeModule/Config/ISpectatorCamModeSettings.cs
@@ -0,0 +1,20 @@
+using System.ComponentModel;
+using Config.Net;
+using EvoSC.Common.Util.Manialinks;
+using EvoSC.Modules.Attributes;
+
+namespace EvoSC.Modules.Official.SpectatorCamModeModule.Config;
+
+[Settings]
+public interface ISpectatorCamModeSettings
+{
+    [Option(DefaultValue = "right"),
+     Description("Specifies the alignment of the widget, allowed values are: left, right and center.")]
+    public WidgetPosition Alignment { get; set; }
+
+    [Option(DefaultValue = 158.0), Description("Defines the horizontal position of the widget.")]
+    public double X { get; set; }
+
+    [Option(DefaultValue = -82.5), Description("Defines the vertical position of the widget.")]
+    public double Y { get; set; }
+}
diff --git a/src/Modules/SpectatorCamModeModule/Controllers/SpectatorCamModeEventController.cs b/src/Modules/SpectatorCamModeModule/Controllers/SpectatorCamModeEventController.cs
new file mode 100644
index 000000000..c253972b6
--- /dev/null
+++ b/src/Modules/SpectatorCamModeModule/Controllers/SpectatorCamModeEventController.cs
@@ -0,0 +1,22 @@
+using EvoSC.Common.Controllers;
+using EvoSC.Common.Controllers.Attributes;
+using EvoSC.Common.Controllers.Context;
+using EvoSC.Common.Events.Attributes;
+using EvoSC.Common.Remote;
+using EvoSC.Common.Remote.EventArgsModels;
+using EvoSC.Modules.Official.SpectatorCamModeModule.Interfaces;
+
+namespace EvoSC.Modules.Official.SpectatorCamModeModule.Controllers;
+
+[Controller]
+public class SpectatorCamModeEventController(ISpectatorCamModeService camModeService)
+    : EvoScController<EventControllerContext>
+{
+    [Subscribe(ModeScriptEvent.EndRoundStart)]
+    public Task OnEndRoundStartAsync(object sender, RoundEventArgs eventArgs) =>
+        camModeService.HideCamModeWidgetAsync();
+    
+    [Subscribe(ModeScriptEvent.StartRoundStart)]
+    public Task OnStartRoundStartAsync(object sender, RoundEventArgs eventArgs) =>
+        camModeService.SendPersistentCamModeWidgetAsync();
+}
diff --git a/src/Modules/SpectatorCamModeModule/Interfaces/ISpectatorCamModeService.cs b/src/Modules/SpectatorCamModeModule/Interfaces/ISpectatorCamModeService.cs
new file mode 100644
index 000000000..7ffac03a6
--- /dev/null
+++ b/src/Modules/SpectatorCamModeModule/Interfaces/ISpectatorCamModeService.cs
@@ -0,0 +1,30 @@
+using EvoSC.Modules.Official.GameModeUiModule.Models;
+
+namespace EvoSC.Modules.Official.SpectatorCamModeModule.Interfaces;
+
+public interface ISpectatorCamModeService
+{
+    /// <summary>
+    /// Sends a persistent cam mode selection widget.
+    /// </summary>
+    /// <returns></returns>
+    public Task SendPersistentCamModeWidgetAsync();
+
+    /// <summary>
+    /// Hides the previously send widget.
+    /// </summary>
+    /// <returns></returns>
+    public Task HideCamModeWidgetAsync();
+    
+    /// <summary>
+    /// Hides the default UI provided by the game mode.
+    /// </summary>
+    /// <returns></returns>
+    public Task HideGameModeUiAsync();
+
+    /// <summary>
+    /// Gets the settings to hide the default UI component.
+    /// </summary>
+    /// <returns></returns>
+    public GameModeUiComponentSettings GetGameModeUiSettings();
+}
diff --git a/src/Modules/SpectatorCamModeModule/Localization.resx b/src/Modules/SpectatorCamModeModule/Localization.resx
new file mode 100644
index 000000000..02cf34b4b
--- /dev/null
+++ b/src/Modules/SpectatorCamModeModule/Localization.resx
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" id="root">
+    <xsd:element name="root" msdata:IsDataSet="true">
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>1.3</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
\ No newline at end of file
diff --git a/src/Modules/SpectatorCamModeModule/Services/SpectatorCamModeService.cs b/src/Modules/SpectatorCamModeModule/Services/SpectatorCamModeService.cs
new file mode 100644
index 000000000..69212135b
--- /dev/null
+++ b/src/Modules/SpectatorCamModeModule/Services/SpectatorCamModeService.cs
@@ -0,0 +1,41 @@
+using EvoSC.Common.Services.Attributes;
+using EvoSC.Common.Services.Models;
+using EvoSC.Manialinks.Interfaces;
+using EvoSC.Modules.Official.GameModeUiModule.Enums;
+using EvoSC.Modules.Official.GameModeUiModule.Interfaces;
+using EvoSC.Modules.Official.GameModeUiModule.Models;
+using EvoSC.Modules.Official.SpectatorCamModeModule.Config;
+using EvoSC.Modules.Official.SpectatorCamModeModule.Interfaces;
+
+namespace EvoSC.Modules.Official.SpectatorCamModeModule.Services;
+
+[Service(LifeStyle = ServiceLifeStyle.Transient)]
+public class SpectatorCamModeService(
+    IManialinkManager manialinks,
+    IGameModeUiModuleService gameModeUiModuleService,
+    ISpectatorCamModeSettings settings
+)
+    : ISpectatorCamModeService
+{
+    private const string WidgetTemplate = "SpectatorCamModeModule.SpectatorMode";
+
+    public Task SendPersistentCamModeWidgetAsync() =>
+        manialinks.SendPersistentManialinkAsync(WidgetTemplate, new { settings });
+
+    public Task HideCamModeWidgetAsync() =>
+        manialinks.HideManialinkAsync(WidgetTemplate);
+
+    public Task HideGameModeUiAsync() =>
+        gameModeUiModuleService.ApplyComponentSettingsAsync(GetGameModeUiSettings());
+
+    public GameModeUiComponentSettings GetGameModeUiSettings()
+    {
+        return new GameModeUiComponentSettings(
+            GameModeUiComponents.SpectatorBaseCommands,
+            false,
+            0.0,
+            0.0,
+            1.0
+        );
+    }
+}
diff --git a/src/Modules/SpectatorCamModeModule/SpectatorCamModeModule.cs b/src/Modules/SpectatorCamModeModule/SpectatorCamModeModule.cs
new file mode 100644
index 000000000..68fe0079c
--- /dev/null
+++ b/src/Modules/SpectatorCamModeModule/SpectatorCamModeModule.cs
@@ -0,0 +1,17 @@
+using EvoSC.Modules.Attributes;
+using EvoSC.Modules.Interfaces;
+using EvoSC.Modules.Official.SpectatorCamModeModule.Interfaces;
+
+namespace EvoSC.Modules.Official.SpectatorCamModeModule;
+
+[Module(IsInternal = true)]
+public class SpectatorCamModeModule(ISpectatorCamModeService spectatorCamModeService) : EvoScModule, IToggleable
+{
+    public async Task EnableAsync()
+    {
+        await spectatorCamModeService.SendPersistentCamModeWidgetAsync();
+        await spectatorCamModeService.HideGameModeUiAsync();
+    }
+
+    public Task DisableAsync() => Task.CompletedTask;
+}
diff --git a/src/Modules/SpectatorCamModeModule/SpectatorCamModeModule.csproj b/src/Modules/SpectatorCamModeModule/SpectatorCamModeModule.csproj
new file mode 100644
index 000000000..fa7c64cbc
--- /dev/null
+++ b/src/Modules/SpectatorCamModeModule/SpectatorCamModeModule.csproj
@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <RootNamespace>EvoSC.Modules.Official.SpectatorCamModeModule</RootNamespace>
+        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+        <AssemblyName>SpectatorCamModeModule</AssemblyName>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\..\EvoSC.Modules\EvoSC.Modules.csproj" />
+        <ProjectReference Include="..\GameModeUiModule\GameModeUiModule.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\..\EvoSC.Modules.SourceGeneration\EvoSC.Modules.SourceGeneration.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
+        <EmbeddedResource Include="Templates\**\*" />
+        <EmbeddedResource Update="Localization.resx">
+        <Generator>ResXFileCodeGenerator</Generator>
+        <LastGenOutput>Localization.Designer.cs</LastGenOutput>
+      </EmbeddedResource>
+    </ItemGroup>
+</Project>
diff --git a/src/Modules/SpectatorCamModeModule/Templates/Scripts/SpectatorMode.ms b/src/Modules/SpectatorCamModeModule/Templates/Scripts/SpectatorMode.ms
new file mode 100644
index 000000000..843927ebf
--- /dev/null
+++ b/src/Modules/SpectatorCamModeModule/Templates/Scripts/SpectatorMode.ms
@@ -0,0 +1,302 @@
+<!--
+#Include "TextLib" as TextLib
+#Include "ColorLib" as ColorLib
+#Include "Libs/Nadeo/CMGame/Utils/Icons.Script.txt" as Icons
+
+#Const C_CamModes_Replay 0
+#Const C_CamModes_Follow 1
+#Const C_CamModes_FollowAll 2
+#Const C_CamModes_Free 3
+
+declare Boolean G_SelectedFollowAll;
+
+Void SetCamModeNameAndIcon(Integer _CamMode, CMlFrame camModeFrame) {
+    declare camModeLabel <=> (camModeFrame.GetFirstChild("cam_mode_label") as CMlLabel);
+    declare camModeBg <=> (camModeFrame.GetFirstChild("cam_mode_bg") as CMlQuad);
+    declare camModeQuad <=> (camModeFrame.GetFirstChild("cam_mode_icon") as CMlQuad);
+    declare Text Text_CamMode = "";
+    declare Text Icon_CamMode = "";
+    
+    switch (_CamMode) {
+        case C_CamModes_Follow: {
+            //L16N Used when spectating a single target, seeing its point of view. In opposition with spectating all players from above "All".
+            Text_CamMode = _("|Camera|Follow");
+            Icon_CamMode = Icons::C_Icon_128x128_Cam_Follow;
+        }
+        case C_CamModes_FollowAll: {
+            //L16N Used when spectating all players, seeing them from above. In opposition with seeing a single player point of view "Single".
+            Text_CamMode = _("|Camera|Follow all");
+            Icon_CamMode = Icons::C_Icon_128x128_Cam_All;
+        }
+        case C_CamModes_Free: {
+            Text_CamMode = _("|Camera|Free");
+            Icon_CamMode = Icons::C_Icon_128x128_Cam_Free;
+        }
+        case C_CamModes_Replay: {
+            Text_CamMode = _("|Camera|Replay");
+            Icon_CamMode = Icons::C_Icon_128x128_Cam_Replay;
+        }
+    }
+    
+    declare Real spacing = 1.0;
+    declare Real offset = 0.0;
+    declare Real width = 0.0;
+    if (camModeLabel != Null){
+        camModeLabel.Value = TextLib::ToUpperCase(Text_CamMode);
+        offset = spacing * 2.0 + camModeLabel.ComputeWidth(camModeLabel.Value);
+        width = spacing * 2.0 + camModeLabel.ComputeWidth(camModeLabel.Value);
+    }
+    if (camModeQuad != Null){
+        camModeQuad.ImageUrl = Icon_CamMode;
+        camModeQuad.RelativePosition_V3.X = offset + spacing;
+        width = width + spacing + camModeQuad.Size.X;
+    }
+    width = width + spacing * 2.0;
+    camModeFrame.Size.X = width;
+    camModeBg.Size.X = width;
+    
+    declare Integer targetCamMode for camModeFrame;
+    targetCamMode = _CamMode;
+    
+    if({{ settings.Alignment == WidgetPosition.Right ? "True" : "False" }}){
+        camModeFrame.RelativePosition_V3.X = width * -1.0;
+    }else if({{ settings.Alignment == WidgetPosition.Center ? "True" : "False" }}){
+        camModeFrame.RelativePosition_V3.X = width / -2.0;
+    }
+}
+
+/**
+ * Copied from "Libs/Nadeo/TMGame/Modes/Base/UIModules/SpectatorBase_Client.Script.txt"
+ */
+Integer SetCamMode(Integer _CamMode, CMlFrame camModeFrame) {
+    /* NB ClientUI.SpectatorForceCameraType:
+     * 1: Script has 2 states
+     *			Forced -> will act as ForcedTarget specifies
+     *			Default -> input can focus a player or allplayers
+     * 2: Free camera, player cannot use inputs
+     * 15: same as 1 but player can escape in free camera (script totaly loses control)
+
+     * After checking C++ with FlorentT it appears that
+     * 0 is Replay
+     * 1 is Follow
+     * 2 is Free
+     * 14 is FollowForced
+     * 15 is DontChange
+
+     * EDIT New API available, see Playground.SetWantedSpectatorCameraType(...)
+     */
+    declare Integer CamMode = _CamMode;
+    ClientUI.Spectator_SetForcedTarget_Clear();
+    G_SelectedFollowAll = False;
+    if (CamMode == C_CamModes_FollowAll) {
+        Playground.SetWantedSpectatorCameraType(CPlaygroundClient::ESpectatorCameraType::Follow); // SetWantedSpectatorCameraType changes "desired" camera, which means player can still change it with inputs (instead of "forced")
+        ClientUI.Spectator_SetForcedTarget_AllPlayers();
+        G_SelectedFollowAll = True;
+    } else if (CamMode == C_CamModes_Follow || CamMode == C_CamModes_Replay) {
+        // Check if there are players to follow
+        declare Boolean CanFollowPlayer = False;
+        foreach (Player in Players) {
+            if (Player.SpawnStatus != CSmPlayer::ESpawnStatus::NotSpawned) {
+                CanFollowPlayer = True;
+                break;
+            }
+        }
+        // If there are no players to follow switch to follow all
+        if (!CanFollowPlayer) {
+            CamMode = SetCamMode(C_CamModes_FollowAll, camModeFrame);
+        } else {
+            if (CamMode == C_CamModes_Follow) {
+                Playground.SetWantedSpectatorCameraType(CPlaygroundClient::ESpectatorCameraType::Follow);
+            } else if (CamMode == C_CamModes_Replay) {
+                Playground.SetWantedSpectatorCameraType(CPlaygroundClient::ESpectatorCameraType::Replay);
+            }
+        }
+    } else if (CamMode == C_CamModes_Free) {
+        Playground.SetWantedSpectatorCameraType(CPlaygroundClient::ESpectatorCameraType::Free);
+    }
+    
+    SetCamModeNameAndIcon(CamMode, camModeFrame);
+
+    return CamMode;
+}
+
+Void AnimateOpacity(CMlQuad quad, Real targetOpacity){
+    AnimMgr.Flush(quad);
+    AnimMgr.Add(quad, "<anim opacity=\"" ^ targetOpacity ^ "\"/>", 200, CAnimManager::EAnimManagerEasing::ExpOut);
+}
+
+Void AnimateColorize(CMlQuad icon, Text targetColorHex){
+    AnimMgr.Flush(icon);
+    AnimMgr.Add(icon, "<anim colorize=\"" ^ targetColorHex ^ "\"/>", 200, CAnimManager::EAnimManagerEasing::ExpOut);
+}
+
+Integer GetAssumedCamMode(Integer camMode){
+    declare Integer AssumedCamMode = camMode;
+        
+    if (Playground.GetSpectatorCameraType() == CPlaygroundClient::ESpectatorCameraType::Free) {
+        AssumedCamMode = C_CamModes_Free;
+    } else if (
+        Playground.GetSpectatorCameraType() == CPlaygroundClient::ESpectatorCameraType::Follow ||
+        Playground.GetSpectatorCameraType() == CPlaygroundClient::ESpectatorCameraType::FollowForced
+    ) {
+        switch (Playground.GetSpectatorTargetType()) {
+            case CPlaygroundClient::ESpectatorTargetType::None: {
+                AssumedCamMode = C_CamModes_FollowAll;
+            }
+            case CPlaygroundClient::ESpectatorTargetType::Single: {
+                AssumedCamMode = C_CamModes_Follow;
+            }
+            case CPlaygroundClient::ESpectatorTargetType::AllPlayers: {
+                AssumedCamMode = C_CamModes_Follow;
+            }
+        }
+    } else if (Playground.GetSpectatorCameraType() == CPlaygroundClient::ESpectatorCameraType::Replay) {
+        AssumedCamMode = C_CamModes_Replay;
+        switch (Playground.GetSpectatorTargetType()) {
+            case CPlaygroundClient::ESpectatorTargetType::AllPlayers: {
+                AssumedCamMode = C_CamModes_FollowAll;
+            }
+        }
+    }
+    
+    return AssumedCamMode;
+}
+
+Void AnimateExpandWrapper(CMlFrame modesWrapper){
+    modesWrapper.Show();
+}
+
+Void AnimateCloseWrapper(CMlFrame modesWrapper){
+    modesWrapper.Hide();
+}
+
+Void AnimateButtonMouseOver(CMlQuad bgTrigger){
+    declare camModeIcon <=> (bgTrigger.Parent.GetFirstChild("cam_mode_icon") as CMlQuad);
+    AnimateOpacity(bgTrigger, 0.8);
+    AnimateColorize(camModeIcon, "{{ Theme.UI_AccentPrimary }}");
+}
+
+Void AnimateButtonMouseOut(CMlQuad bgTrigger){
+    declare camModeIcon <=> (bgTrigger.Parent.GetFirstChild("cam_mode_icon") as CMlQuad);
+    AnimateOpacity(bgTrigger, {{ opacityUnfocused }});
+    AnimateColorize(camModeIcon, "{{ Theme.UI_TextPrimary }}");
+}
+
+Void SetupModesDropUp(CMlFrame wrapperFrame){
+    for(i, 0, 3){
+        declare modeButtonFrame = (wrapperFrame.Controls[i] as CMlFrame);
+        SetCamModeNameAndIcon(i, modeButtonFrame);
+        modeButtonFrame.RelativePosition_V3.Y = {{ -height }} * i;
+    
+        if({{ settings.Alignment == WidgetPosition.Right ? "True" : "False" }}){
+            modeButtonFrame.RelativePosition_V3.X = {{ width }} - modeButtonFrame.Size.X;
+        }else if({{ settings.Alignment == WidgetPosition.Center ? "True" : "False" }}){
+            modeButtonFrame.RelativePosition_V3.X = {{ width }} - modeButtonFrame.Size.X / 2.0;
+        }
+    }
+    
+    if({{ settings.Alignment == WidgetPosition.Right ? "True" : "False" }}){
+        wrapperFrame.RelativePosition_V3.X = {{ width }} * -1.0;
+    }else if({{ settings.Alignment == WidgetPosition.Center ? "True" : "False" }}){
+        wrapperFrame.RelativePosition_V3.X = {{ width }} / -2.0;
+    }
+}
+
+Void HideCurrentlySelectedModeAndRearrange(CMlFrame wrapperFrame, Integer selectedCamMode){
+    declare offset = 0;
+    for(i, 0, 3){
+        declare modeButtonFrame = (wrapperFrame.Controls[i] as CMlFrame);
+        
+        if(selectedCamMode == i){
+            modeButtonFrame.Hide();
+            continue;
+        }
+        
+        modeButtonFrame.RelativePosition_V3.Y = {{ -height }} * offset;
+        modeButtonFrame.Show();
+        offset += 1;
+    }
+}
+
+main(){
+    declare mainFrame <=> (Page.MainFrame.GetFirstChild("main_frame") as CMlFrame);
+    declare camModeFrame <=> (Page.MainFrame.GetFirstChild("cam_mode_frame") as CMlFrame);
+    declare modesWrapperFrame <=> (Page.MainFrame.GetFirstChild("modes_wrapper") as CMlFrame);
+
+    declare netread Integer Net_Race_SpectatorBase_CamMode for UI;
+    declare netread Integer Net_Race_SpectatorBase_CamUpdate for UI;
+    
+    declare lastCamUpdate = Net_Race_SpectatorBase_CamUpdate;
+    declare camMode = SetCamMode(Net_Race_SpectatorBase_CamMode, camModeFrame);
+    declare isExpanded = False;
+    
+    SetupModesDropUp(modesWrapperFrame);
+    HideCurrentlySelectedModeAndRearrange(modesWrapperFrame, camMode);
+    
+    while(True){
+        yield;
+        
+        declare shouldBeDisplayed = InputPlayer != Null && InputPlayer.SpawnStatus == CSmPlayer::ESpawnStatus::NotSpawned;
+        
+        if(!shouldBeDisplayed){
+            if(mainFrame.Visible){
+                mainFrame.Hide();
+            }
+            sleep(500);
+            continue;
+        }
+        
+        if(!mainFrame.Visible){
+            mainFrame.Show();
+        }
+        
+        declare Integer AssumedCamMode = GetAssumedCamMode(camMode);
+        
+        if (camMode != AssumedCamMode) {
+            camMode = AssumedCamMode;
+            SetCamModeNameAndIcon(camMode, camModeFrame);
+        }
+        
+        if(lastCamUpdate != Net_Race_SpectatorBase_CamUpdate){
+            camMode = SetCamMode(Net_Race_SpectatorBase_CamMode, camModeFrame);
+            lastCamUpdate = Net_Race_SpectatorBase_CamUpdate;
+        }
+        
+        foreach(Event in PendingEvents){
+            if(Event.Type == CMlScriptEvent::Type::MouseClick){
+                if(Event.Control.Parent.ControlId == "cam_mode_frame"){
+                    camMode = SetCamMode((camMode + 1) % 4, camModeFrame);
+                }else{
+                    declare Integer targetCamMode for Event.Control.Parent = 0;
+                    camMode = SetCamMode(targetCamMode, camModeFrame);
+                }
+                
+                if(isExpanded){
+                    AnimateCloseWrapper(modesWrapperFrame);
+                    isExpanded = False;
+                }
+    
+                continue;
+            }
+            if(Event.Type == CMlScriptEvent::Type::MouseRightClick && Event.Control.Parent.ControlId == "cam_mode_frame"){
+                if(isExpanded){
+                    AnimateCloseWrapper(modesWrapperFrame);
+                }else{
+                    HideCurrentlySelectedModeAndRearrange(modesWrapperFrame, camMode);
+                    AnimateExpandWrapper(modesWrapperFrame);
+                }
+                isExpanded = !isExpanded;
+                continue;
+            }
+            if(Event.Type == CMlScriptEvent::Type::MouseOver){
+                AnimateButtonMouseOver(Event.Control as CMlQuad);
+                continue;
+            }
+            if(Event.Type == CMlScriptEvent::Type::MouseOut){
+                AnimateButtonMouseOut(Event.Control as CMlQuad);
+                continue;
+            }
+        }
+    }
+}
+-->
\ No newline at end of file
diff --git a/src/Modules/SpectatorCamModeModule/Templates/SpectatorMode.mt b/src/Modules/SpectatorCamModeModule/Templates/SpectatorMode.mt
new file mode 100644
index 000000000..41d138210
--- /dev/null
+++ b/src/Modules/SpectatorCamModeModule/Templates/SpectatorMode.mt
@@ -0,0 +1,55 @@
+<component>
+    <using namespace="EvoSC.Modules.Official.SpectatorCamModeModule.Config"/>
+    <using namespace="EvoSC.Common.Util.Manialinks"/>
+
+    <import component="EvoSC.Style.UIStyle" as="UIStyle"/>
+    <import component="EvoSC.Drawing.Rectangle" as="Rectangle"/>
+
+    <property type="ISpectatorCamModeSettings" name="settings"/>
+    <property type="double" name="width" default="32.0"/>
+    <property type="double" name="height" default="5.5"/>
+    <property type="double" name="opacityUnfocused" default="0.1"/>
+
+    <template>
+        <UIStyle/>
+
+        <framemodel id="option">
+            <quad id="cam_mode_bg"
+                  size="{{ width }} {{ height }}"
+                  bgcolor="{{ Theme.UI_SurfaceBgPrimary }}"
+                  opacity="{{ opacityUnfocused }}"
+                  scriptevents="1"
+            />
+            <label id="cam_mode_label"
+                   class="text-primary"
+                   pos="2 {{ height / -2.0 - 0.25 }}"
+                   textsize="{{ Theme.UI_FontSize*1.5 }}"
+                   textfont="{{ Font.Bold }}"
+                   text="CAM MODE"
+                   valign="center2"
+            />
+            <quad id="cam_mode_icon"
+                  size="3.5 3.5"
+                  pos="{{ width - 6.0 }} {{ height / -2.0 }}"
+                  valign="center2"
+                  colorize="{{ Theme.UI_TextPrimary }}"
+            />
+        </framemodel>
+
+        <frame id="main_frame" pos="{{ settings.X }} {{ settings.Y }}" hidden="1">
+            <frameinstance id="cam_mode_frame" modelid="option"/>
+            <frame id="modes_wrapper" 
+                   pos="0 {{ height * 3.0 }}"
+                   size="{{ width }} {{ height * 3.0 }}"
+                   hidden="1"
+            >
+                <frameinstance modelid="option"/>
+                <frameinstance modelid="option"/>
+                <frameinstance modelid="option"/>
+                <frameinstance modelid="option"/>
+            </frame>
+        </frame>
+    </template>
+
+    <script resource="SpectatorCamModeModule.Scripts.SpectatorMode" main="true" />
+</component>
diff --git a/src/Modules/SpectatorCamModeModule/info.toml b/src/Modules/SpectatorCamModeModule/info.toml
new file mode 100644
index 000000000..8d6803e66
--- /dev/null
+++ b/src/Modules/SpectatorCamModeModule/info.toml
@@ -0,0 +1,9 @@
+[info]
+name = "SpectatorCamModeModule"
+title = "Spectator Cam Mode"
+summary = "Shows and allows changing the cam mode."
+version = "1.0.0"
+author = "Evo"
+
+[dependencies]
+GameModeUiModule = "1.0.0"
diff --git a/src/Modules/SpectatorTargetInfoModule/Config/ISpectatorTargetInfoSettings.cs b/src/Modules/SpectatorTargetInfoModule/Config/ISpectatorTargetInfoSettings.cs
new file mode 100644
index 000000000..f48adad55
--- /dev/null
+++ b/src/Modules/SpectatorTargetInfoModule/Config/ISpectatorTargetInfoSettings.cs
@@ -0,0 +1,12 @@
+using System.ComponentModel;
+using Config.Net;
+using EvoSC.Modules.Attributes;
+
+namespace EvoSC.Modules.Official.SpectatorTargetInfoModule.Config;
+
+[Settings]
+public interface ISpectatorTargetInfoSettings
+{
+    [Option(DefaultValue = -57.0), Description("Defines the vertical position of the widget.")]
+    public double Y { get; set; }
+}
diff --git a/src/Modules/SpectatorTargetInfoModule/Controllers/SpectatorTargetInfoEventController.cs b/src/Modules/SpectatorTargetInfoModule/Controllers/SpectatorTargetInfoEventController.cs
index e6d35e4f3..5afc8f94b 100644
--- a/src/Modules/SpectatorTargetInfoModule/Controllers/SpectatorTargetInfoEventController.cs
+++ b/src/Modules/SpectatorTargetInfoModule/Controllers/SpectatorTargetInfoEventController.cs
@@ -1,31 +1,38 @@
 using EvoSC.Common.Controllers;
 using EvoSC.Common.Controllers.Attributes;
-using EvoSC.Common.Controllers.Context;
 using EvoSC.Common.Events.Attributes;
+using EvoSC.Common.Interfaces.Controllers;
 using EvoSC.Common.Remote;
 using EvoSC.Common.Remote.EventArgsModels;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Interfaces;
 using GbxRemoteNet.Events;
-using SpectatorTargetInfo.Interfaces;
 
 namespace EvoSC.Modules.Official.SpectatorTargetInfoModule.Controllers;
 
 [Controller]
-public class SpectatorTargetInfoEventController
-    (ISpectatorTargetInfoService spectatorTargetInfoService) : EvoScController<EventControllerContext>
+public class SpectatorTargetInfoEventController(ISpectatorTargetInfoService spectatorTargetInfoService)
+    : EvoScController<IEventControllerContext>
 {
-    [Subscribe(GbxRemoteEvent.PlayerConnect)]
-    public Task OnPlayerConnectAsync(object x, PlayerConnectGbxEventArgs args) =>
-        spectatorTargetInfoService.SendManiaLinkAsync(args.Login);
+    [Subscribe(GbxRemoteEvent.PlayerDisconnect)]
+    public Task OnPlayerDisconnectAsync(object sender, PlayerGbxEventArgs eventArgs) =>
+        spectatorTargetInfoService.RemovePlayerFromSpectatorsListAsync(eventArgs.Login);
+
+    [Subscribe(GbxRemoteEvent.BeginMap)]
+    public Task OnBeginMapAsync(object sender, MapGbxEventArgs eventArgs) =>
+        spectatorTargetInfoService.UpdateIsTeamsModeAsync();
 
     [Subscribe(ModeScriptEvent.WayPoint)]
     public Task OnWayPointAsync(object sender, WayPointEventArgs wayPointEventArgs) =>
-        spectatorTargetInfoService.ForwardCheckpointTimeToClientsAsync(wayPointEventArgs);
+        spectatorTargetInfoService.AddCheckpointAsync(
+            wayPointEventArgs.Login,
+            wayPointEventArgs.CheckpointInLap,
+            wayPointEventArgs.LapTime
+        );
 
     [Subscribe(ModeScriptEvent.StartRoundStart)]
-    public Task OnNewRoundAsync(object sender, RoundEventArgs roundEventArgs) =>
-        spectatorTargetInfoService.ResetCheckpointTimesAsync();
-
-    [Subscribe(ModeScriptEvent.GiveUp)]
-    public Task OnPlayerGiveUpAsync(object sender, PlayerUpdateEventArgs playerUpdateEventArgs) =>
-        spectatorTargetInfoService.ForwardDnfToClientsAsync(playerUpdateEventArgs);
+    public async Task OnNewRoundAsync(object sender, RoundEventArgs roundEventArgs)
+    {
+        await spectatorTargetInfoService.ClearCheckpointsAsync();
+        await spectatorTargetInfoService.FetchAndCacheTeamInfoAsync();
+    }
 }
diff --git a/src/Modules/SpectatorTargetInfoModule/Controllers/SpectatorTargetInfoManialinkController.cs b/src/Modules/SpectatorTargetInfoModule/Controllers/SpectatorTargetInfoManialinkController.cs
new file mode 100644
index 000000000..04b17fb77
--- /dev/null
+++ b/src/Modules/SpectatorTargetInfoModule/Controllers/SpectatorTargetInfoManialinkController.cs
@@ -0,0 +1,26 @@
+using EvoSC.Common.Controllers.Attributes;
+using EvoSC.Common.Util;
+using EvoSC.Manialinks;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Interfaces;
+
+namespace EvoSC.Modules.Official.SpectatorTargetInfoModule.Controllers;
+
+[Controller]
+public class SpectatorTargetInfoManialinkController(ISpectatorTargetInfoService spectatorTargetInfoService)
+    : ManialinkController
+{
+    public async Task ReportSpectatorTargetAsync(string targetLogin)
+    {
+        var spectatorLogin = Context.Player.GetLogin();
+
+        if (targetLogin != "" && targetLogin != spectatorLogin)
+        {
+            await spectatorTargetInfoService.SetSpectatorTargetAndSendAsync(spectatorLogin, targetLogin);
+        }
+        else
+        {
+            await spectatorTargetInfoService.RemovePlayerFromSpectatorsListAsync(spectatorLogin);
+            await spectatorTargetInfoService.HideSpectatorInfoWidgetAsync(spectatorLogin);
+        }
+    }
+}
diff --git a/src/Modules/SpectatorTargetInfoModule/Interfaces/ISpectatorTargetInfoService.cs b/src/Modules/SpectatorTargetInfoModule/Interfaces/ISpectatorTargetInfoService.cs
index 32d2d9148..3be2de777 100644
--- a/src/Modules/SpectatorTargetInfoModule/Interfaces/ISpectatorTargetInfoService.cs
+++ b/src/Modules/SpectatorTargetInfoModule/Interfaces/ISpectatorTargetInfoService.cs
@@ -1,46 +1,179 @@
-using EvoSC.Common.Remote.EventArgsModels;
+using EvoSC.Common.Interfaces.Models;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Models;
 
-namespace SpectatorTargetInfo.Interfaces;
+namespace EvoSC.Modules.Official.SpectatorTargetInfoModule.Interfaces;
 
 public interface ISpectatorTargetInfoService
 {
     /// <summary>
-    /// Sends the manialink to all players.
+    /// Initialize the module on controller start.
     /// </summary>
-    public Task SendManiaLinkAsync();
-    
+    /// <returns></returns>
+    public Task InitializeAsync();
+
     /// <summary>
-    /// Sends the manialink to a specific player.
+    /// Register a new checkpoint time for the ongoing round.
     /// </summary>
-    public Task SendManiaLinkAsync(string playerLogin);
-    
+    /// <param name="playerLogin"></param>
+    /// <param name="checkpointIndex"></param>
+    /// <param name="checkpointTime"></param>
+    /// <returns></returns>
+    public Task AddCheckpointAsync(string playerLogin, int checkpointIndex, int checkpointTime);
+
     /// <summary>
-    /// Hides the manialink for all players.
+    /// Clears all registered checkpoint times.
     /// </summary>
-    public Task HideManiaLinkAsync();
+    /// <returns></returns>
+    public Task ClearCheckpointsAsync();
     
     /// <summary>
-    /// Hides the default spectator info.
+    /// Retrieve an IOnlinePlayer instance by their login.
+    /// </summary>
+    /// <param name="playerLogin"></param>
+    /// <returns></returns>
+    public Task<IOnlinePlayer> GetOnlinePlayerByLoginAsync(string playerLogin);
+
+    /// <summary>
+    /// Get the login of a player by their dedicated server ID.
     /// </summary>
-    public Task HideNadeoSpectatorInfoAsync();
+    /// <param name="targetPlayerIdDedicated"></param>
+    /// <returns></returns>
+    public Task<string?> GetLoginOfDedicatedPlayerAsync(int targetPlayerIdDedicated);
+
+    /// <summary>
+    /// Set the spectator target for a player.
+    /// </summary>
+    /// <param name="spectatorLogin"></param>
+    /// <param name="targetLogin"></param>
+    /// <returns></returns>
+    public Task<IOnlinePlayer?> SetSpectatorTargetAsync(string spectatorLogin, string targetLogin);
     
     /// <summary>
-    /// Shows the default spectator info.
+    /// Set the spectator target for a player and display the widget to them.
+    /// </summary>
+    /// <param name="spectatorLogin"></param>
+    /// <param name="targetLogin"></param>
+    /// <returns></returns>
+    public Task SetSpectatorTargetAndSendAsync(string spectatorLogin, string targetLogin);
+
+    /// <summary>
+    /// Remove a player from the spectators list.
     /// </summary>
-    public Task ShowNadeoSpectatorInfoAsync();
+    /// <param name="spectatorLogin"></param>
+    /// <returns></returns>
+    public Task RemovePlayerFromSpectatorsListAsync(string spectatorLogin);
+
+    /// <summary>
+    /// Gets the logins of a players spectating the given target.
+    /// </summary>
+    /// <param name="targetPlayer"></param>
+    /// <returns></returns>
+    public IEnumerable<string> GetLoginsOfPlayersSpectatingTarget(IOnlinePlayer targetPlayer);
+
+    /// <summary>
+    /// Calculates the time difference between two given times in milliseconds.
+    /// </summary>
+    /// <param name="leadingCheckpointTime"></param>
+    /// <param name="targetCheckpointTime"></param>
+    /// <returns></returns>
+    public int GetTimeDifference(int leadingCheckpointTime, int targetCheckpointTime);
+
+    /// <summary>
+    /// Gets the hex team color for the given team.
+    /// </summary>
+    /// <param name="team"></param>
+    /// <returns></returns>
+    public string GetTeamColor(PlayerTeam team);
+
+    /// <summary>
+    /// Gets the highest checkpoint ID the given player has reached in the ongoing round.
+    /// </summary>
+    /// <param name="player"></param>
+    /// <returns></returns>
+    public int GetLastCheckpointIndexOfPlayer(IOnlinePlayer player);
     
     /// <summary>
-    /// Maps wayPointEventArgs and sends data to clients.
+    /// Returns the CheckpointGroups for all collected checkpoints.
+    /// </summary>
+    /// <returns></returns>
+    public Dictionary<int, CheckpointsGroup> GetCheckpointTimes();
+
+    /// <summary>
+    /// Resets the widget for all spectating players.
+    /// </summary>
+    /// <returns></returns>
+    public Task ResetWidgetForSpectatorsAsync();
+
+    /// <summary>
+    /// Send the widget to the given player.
+    /// </summary>
+    /// <param name="spectatorLogin"></param>
+    /// <param name="targetPlayer"></param>
+    /// <returns></returns>
+    public Task SendSpectatorInfoWidgetAsync(string spectatorLogin, IOnlinePlayer targetPlayer);
+
+    /// <summary>
+    /// Send the widget to the given players.
+    /// </summary>
+    /// <param name="spectatorLogins"></param>
+    /// <param name="targetPlayer"></param>
+    /// <param name="targetPlayerRank"></param>
+    /// <param name="timeDifference"></param>
+    /// <returns></returns>
+    public Task SendSpectatorInfoWidgetAsync(IEnumerable<string> spectatorLogins, IOnlinePlayer targetPlayer, int targetPlayerRank, int timeDifference);
+
+    /// <summary>
+    /// Send the widget to the given player.
+    /// </summary>
+    /// <param name="spectatorLogin"></param>
+    /// <param name="targetPlayer"></param>
+    /// <param name="widgetData"></param>
+    /// <returns></returns>
+    public Task SendSpectatorInfoWidgetAsync(string spectatorLogin, IOnlinePlayer targetPlayer, object widgetData);
+
+    /// <summary>
+    /// Gets the data that's passed to the widget.
     /// </summary>
-    public Task ForwardCheckpointTimeToClientsAsync(WayPointEventArgs wayPointEventArgs);
+    /// <param name="player"></param>
+    /// <param name="rank"></param>
+    /// <param name="timeDifference"></param>
+    /// <returns></returns>
+    public object GetWidgetData(IOnlinePlayer player, int rank, int timeDifference);
     
     /// <summary>
-    /// Clears the checkpoint times for the clients.
+    /// Hides the widget for all players.
+    /// </summary>
+    /// <returns></returns>
+    public Task HideSpectatorInfoWidgetAsync();
+
+    /// <summary>
+    /// Hides the widget for the given player.
+    /// </summary>
+    /// <param name="playerLogin"></param>
+    /// <returns></returns>
+    public Task HideSpectatorInfoWidgetAsync(string playerLogin);
+
+    /// <summary>
+    /// Sends the script responsible for reporting back the current spectator target from the player to the module.
     /// </summary>
-    public Task ResetCheckpointTimesAsync();
+    /// <returns></returns>
+    public Task SendReportSpectatorTargetManialinkAsync();
+
+    /// <summary>
+    /// Retrieve and cache the latest team infos.
+    /// </summary>
+    /// <returns></returns>
+    public Task FetchAndCacheTeamInfoAsync();
     
     /// <summary>
-    /// Sends players DNF to clients.
+    /// Updates whether team mode is active or not.
+    /// </summary>
+    /// <returns></returns>
+    public Task UpdateIsTeamsModeAsync();
+
+    /// <summary>
+    /// Hides the default game mode UI.
     /// </summary>
-    public Task ForwardDnfToClientsAsync(PlayerUpdateEventArgs playerUpdateEventArgs);
+    /// <returns></returns>
+    public Task HideGameModeUiAsync();
 }
diff --git a/src/Modules/SpectatorTargetInfoModule/Localization.resx b/src/Modules/SpectatorTargetInfoModule/Localization.resx
new file mode 100644
index 000000000..02cf34b4b
--- /dev/null
+++ b/src/Modules/SpectatorTargetInfoModule/Localization.resx
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <xsd:schema xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" id="root">
+    <xsd:element name="root" msdata:IsDataSet="true">
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>1.3</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
\ No newline at end of file
diff --git a/src/Modules/SpectatorTargetInfoModule/Models/CheckpointData.cs b/src/Modules/SpectatorTargetInfoModule/Models/CheckpointData.cs
new file mode 100644
index 000000000..11a604d3d
--- /dev/null
+++ b/src/Modules/SpectatorTargetInfoModule/Models/CheckpointData.cs
@@ -0,0 +1,5 @@
+using EvoSC.Common.Interfaces.Models;
+
+namespace EvoSC.Modules.Official.SpectatorTargetInfoModule.Models;
+
+public record CheckpointData(IOnlinePlayer player, int time);
diff --git a/src/Modules/SpectatorTargetInfoModule/Models/CheckpointsGroup.cs b/src/Modules/SpectatorTargetInfoModule/Models/CheckpointsGroup.cs
new file mode 100644
index 000000000..07f882846
--- /dev/null
+++ b/src/Modules/SpectatorTargetInfoModule/Models/CheckpointsGroup.cs
@@ -0,0 +1,26 @@
+using EvoSC.Common.Util;
+
+namespace EvoSC.Modules.Official.SpectatorTargetInfoModule.Models;
+
+public class CheckpointsGroup : List<CheckpointData>
+{
+    public CheckpointData? GetPlayerCheckpointData(string playerLogin)
+    {
+        return this.Find(cpData => cpData.player.GetLogin() == playerLogin);
+    }
+
+    public int GetRank(string playerLogin)
+    {
+        var rank = 1;
+        foreach (var checkpointData in this)
+        {
+            if (checkpointData.player.GetLogin() == playerLogin)
+            {
+                return rank;
+            }
+            rank++;
+        }
+
+        return rank;
+    }
+}
diff --git a/src/Modules/SpectatorTargetInfoModule/Services/SpectatorTargetInfoService.cs b/src/Modules/SpectatorTargetInfoModule/Services/SpectatorTargetInfoService.cs
index 3ba7e5144..9af83f349 100644
--- a/src/Modules/SpectatorTargetInfoModule/Services/SpectatorTargetInfoService.cs
+++ b/src/Modules/SpectatorTargetInfoModule/Services/SpectatorTargetInfoService.cs
@@ -1,99 +1,250 @@
 using EvoSC.Common.Interfaces;
+using EvoSC.Common.Interfaces.Models;
 using EvoSC.Common.Interfaces.Services;
-using EvoSC.Common.Remote.EventArgsModels;
+using EvoSC.Common.Interfaces.Themes;
 using EvoSC.Common.Services.Attributes;
 using EvoSC.Common.Services.Models;
 using EvoSC.Common.Util;
+using EvoSC.Common.Util.MatchSettings;
 using EvoSC.Manialinks.Interfaces;
-using SpectatorTargetInfo.Interfaces;
+using EvoSC.Modules.Official.GameModeUiModule.Enums;
+using EvoSC.Modules.Official.GameModeUiModule.Interfaces;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Config;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Interfaces;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Models;
+using GbxRemoteNet.Structs;
+using LinqToDB.Common;
+using Microsoft.Extensions.Logging;
 
 namespace EvoSC.Modules.Official.SpectatorTargetInfoModule.Services;
 
 [Service(LifeStyle = ServiceLifeStyle.Singleton)]
-public class SpectatorTargetInfoService
-    (IManialinkManager manialinks, IServerClient server, IPlayerManagerService playerManagerService) : ISpectatorTargetInfoService
+public class SpectatorTargetInfoService(
+    IManialinkManager manialinks,
+    IServerClient server,
+    IPlayerManagerService playerManagerService,
+    IMatchSettingsService matchSettingsService,
+    ISpectatorTargetInfoSettings settings,
+    IThemeManager theme,
+    IGameModeUiModuleService gameModeUiModuleService,
+    ILogger<SpectatorTargetInfoService> logger
+) : ISpectatorTargetInfoService
 {
+    private const string ReportTargetTemplate = "SpectatorTargetInfoModule.ReportSpecTarget";
     private const string WidgetTemplate = "SpectatorTargetInfoModule.SpectatorTargetInfo";
 
-    public async Task SendManiaLinkAsync() =>
-        await manialinks.SendManialinkAsync(WidgetTemplate);
+    private readonly Dictionary<int, CheckpointsGroup> _checkpointTimes = new(); // cp-id -> CheckpointsGroup
+    private readonly Dictionary<string, IOnlinePlayer> _spectatorTargets = new(); // login -> IOnlinePlayer
+    private readonly Dictionary<PlayerTeam, TmTeamInfo> _teamInfos = new();
+    private bool _isTeamsMode;
 
+    public async Task InitializeAsync()
+    {
+        await UpdateIsTeamsModeAsync();
+        await FetchAndCacheTeamInfoAsync();
+        await SendReportSpectatorTargetManialinkAsync();
+        await HideGameModeUiAsync();
+    }
+
+    public Task<IOnlinePlayer> GetOnlinePlayerByLoginAsync(string playerLogin)
+        => playerManagerService.GetOnlinePlayerAsync(PlayerUtils.ConvertLoginToAccountId(playerLogin));
+
+    public async Task AddCheckpointAsync(string playerLogin, int checkpointIndex, int checkpointTime)
+    {
+        var player = await GetOnlinePlayerByLoginAsync(playerLogin);
+        var newCheckpointData = new CheckpointData(player, checkpointTime);
+
+        if (!_checkpointTimes.TryGetValue(checkpointIndex, out var checkpointGroup))
+        {
+            checkpointGroup = [];
+            _checkpointTimes.Add(checkpointIndex, checkpointGroup);
+        }
+
+        checkpointGroup.Add(newCheckpointData);
+        _checkpointTimes[checkpointIndex] = checkpointGroup;
 
-    public async Task SendManiaLinkAsync(string playerLogin)
+        var spectatorLogins = GetLoginsOfPlayersSpectatingTarget(player).ToList();
+        if (spectatorLogins.IsNullOrEmpty())
+        {
+            return;
+        }
+
+        var leadingCheckpointData = checkpointGroup.First();
+        var timeDifference = GetTimeDifference(leadingCheckpointData.time, newCheckpointData.time);
+
+        await SendSpectatorInfoWidgetAsync(spectatorLogins, player, checkpointGroup.GetRank(playerLogin),
+            timeDifference);
+    }
+
+    public Task ClearCheckpointsAsync()
     {
-        var player = await playerManagerService.GetOnlinePlayerAsync(PlayerUtils.ConvertLoginToAccountId(playerLogin));
-        await manialinks.SendManialinkAsync(player, WidgetTemplate);
+        _checkpointTimes.Clear();
+
+        return Task.CompletedTask;
     }
 
-    public async Task HideManiaLinkAsync() =>
-        await manialinks.HideManialinkAsync(WidgetTemplate);
+    public async Task<string?> GetLoginOfDedicatedPlayerAsync(int targetPlayerIdDedicated)
+    {
+        var serverPlayers = await server.Remote.GetPlayerListAsync();
+
+        return serverPlayers.Where(player => player.PlayerId == targetPlayerIdDedicated)
+            .Select(player => player.Login)
+            .FirstOrDefault();
+    }
 
-    public Task HideNadeoSpectatorInfoAsync()
+    public async Task<IOnlinePlayer?> SetSpectatorTargetAsync(string spectatorLogin, string targetLogin)
     {
-        var hudSettings = new List<string>
+        if (spectatorLogin == targetLogin)
         {
-            @"{""uimodules"": [
-                {
-                    ""id"": ""Race_SpectatorBase_Name"",
-                    ""visible"": false,
-                    ""visible_update"": true,
-                },
-                {
-                    ""id"": ""Race_SpectatorBase_Commands"",
-                    ""visible"": true,
-                    ""visible_update"": true,
-                }
-            ]}"
-        };
+            return null; //Can't spec yourself
+        }
+
+        var targetPlayer = await GetOnlinePlayerByLoginAsync(targetLogin);
+
+        if (_spectatorTargets.TryGetValue(spectatorLogin, out var target) && target == targetPlayer)
+        {
+            return null; //Player is already spectating target
+        }
+
+        _spectatorTargets[spectatorLogin] = targetPlayer;
 
-        return server.Remote.TriggerModeScriptEventArrayAsync("Common.UIModules.SetProperties", hudSettings.ToArray());
+        logger.LogTrace("Updated spectator target {spectatorLogin} -> {targetLogin}.", spectatorLogin,
+            targetLogin);
+
+        return targetPlayer;
     }
 
-    public Task ShowNadeoSpectatorInfoAsync()
+    public async Task SetSpectatorTargetAndSendAsync(string spectatorLogin, string targetLogin)
     {
-        var hudSettings = new List<string>
+        var targetPlayer = await SetSpectatorTargetAsync(spectatorLogin, targetLogin);
+        if (targetPlayer != null)
         {
-            @"{""uimodules"": [
-                {
-                    ""id"": ""Race_SpectatorBase_Name"",
-                    ""visible"": true,
-                    ""visible_update"": true,
-                },
-                {
-                    ""id"": ""Race_SpectatorBase_Commands"",
-                    ""visible"": true,
-                    ""visible_update"": true,
-                }
-            ]}"
-        };
+            await SendSpectatorInfoWidgetAsync(spectatorLogin, targetPlayer);
+        }
+    }
+
+    public Task RemovePlayerFromSpectatorsListAsync(string spectatorLogin)
+    {
+        if (_spectatorTargets.Remove(spectatorLogin))
+        {
+            logger.LogTrace("Removed spectator {spectatorLogin}.", spectatorLogin);
+        }
+
+        return Task.CompletedTask;
+    }
+
+    public IEnumerable<string> GetLoginsOfPlayersSpectatingTarget(IOnlinePlayer targetPlayer)
+    {
+        return _spectatorTargets.Where(specTarget => specTarget.Value.AccountId == targetPlayer.AccountId)
+            .Select(specTarget => specTarget.Key);
+    }
+
+    public int GetTimeDifference(int leadingCheckpointTime, int targetCheckpointTime)
+    {
+        return targetCheckpointTime - leadingCheckpointTime;
+    }
 
-        return server.Remote.TriggerModeScriptEventArrayAsync("Common.UIModules.SetProperties", hudSettings.ToArray());
+    public string GetTeamColor(PlayerTeam team)
+    {
+        return _isTeamsMode ? _teamInfos[team].RGB : (string)theme.Theme.UI_AccentPrimary;
     }
 
-    public Task ForwardCheckpointTimeToClientsAsync(WayPointEventArgs wayPointEventArgs)
+    public int GetLastCheckpointIndexOfPlayer(IOnlinePlayer player)
     {
-        return manialinks.SendManialinkAsync("SpectatorTargetInfoModule.NewCpTime",
-            new
+        var playerLogin = player.GetLogin();
+        foreach (var (checkpointIndex, checkpointsGroup) in _checkpointTimes.Reverse())
+        {
+            if (checkpointsGroup.GetPlayerCheckpointData(playerLogin) != null)
             {
-                accountId = wayPointEventArgs.AccountId,
-                time = wayPointEventArgs.RaceTime,
-                cpIndex = wayPointEventArgs.CheckpointInRace
-            });
+                return checkpointIndex;
+            }
+        }
+
+        return -1;
+    }
+
+    public Dictionary<int, CheckpointsGroup> GetCheckpointTimes() =>
+        _checkpointTimes;
+
+    public async Task ResetWidgetForSpectatorsAsync()
+    {
+        foreach (var (spectatorLogin, targetPlayer) in _spectatorTargets)
+        {
+            var widgetData = GetWidgetData(targetPlayer, 1, 0);
+            await SendSpectatorInfoWidgetAsync(spectatorLogin, targetPlayer, widgetData);
+        }
+    }
+
+    public async Task SendSpectatorInfoWidgetAsync(string spectatorLogin, IOnlinePlayer targetPlayer)
+    {
+        var targetLogin = targetPlayer.GetLogin();
+        var checkpointIndex = GetLastCheckpointIndexOfPlayer(targetPlayer);
+        var targetRank = 1;
+        var timeDifference = 0;
+
+        if (_checkpointTimes.TryGetValue(checkpointIndex, out var checkpointsGroup))
+        {
+            var leadingCpData = checkpointsGroup.First();
+            var targetCpData = checkpointsGroup.GetPlayerCheckpointData(targetLogin);
+            targetRank = checkpointsGroup.GetRank(targetLogin);
+            timeDifference = GetTimeDifference(leadingCpData.time, targetCpData?.time ?? 0);
+        }
+
+        var widgetData = GetWidgetData(targetPlayer, targetRank, timeDifference);
+        await SendSpectatorInfoWidgetAsync(spectatorLogin, targetPlayer, widgetData);
     }
 
-    public Task ResetCheckpointTimesAsync()
+    public async Task SendSpectatorInfoWidgetAsync(IEnumerable<string> spectatorLogins, IOnlinePlayer targetPlayer,
+        int targetPlayerRank, int timeDifference)
     {
-        manialinks.HideManialinkAsync("SpectatorTargetInfoModule.NewCpTime");
-        return manialinks.SendManialinkAsync("SpectatorTargetInfoModule.ResetCpTimes");
+        var widgetData = GetWidgetData(targetPlayer, targetPlayerRank, timeDifference);
+        foreach (var spectatorLogin in spectatorLogins)
+        {
+            await SendSpectatorInfoWidgetAsync(spectatorLogin, targetPlayer, widgetData);
+        }
     }
 
-    public Task ForwardDnfToClientsAsync(PlayerUpdateEventArgs playerUpdateEventArgs)
+    public Task SendSpectatorInfoWidgetAsync(string spectatorLogin, IOnlinePlayer targetPlayer, object widgetData) =>
+        manialinks.SendManialinkAsync(spectatorLogin, WidgetTemplate, widgetData);
+
+    public object GetWidgetData(IOnlinePlayer player, int rank, int timeDifference)
     {
-        return manialinks.SendManialinkAsync("SpectatorTargetInfoModule.NewCpTime", new
+        return new
         {
-            accountId = playerUpdateEventArgs.AccountId,
-            time = 0,
-            cpIndex = -1
-        });
+            settings,
+            timeDifference,
+            playerRank = rank,
+            playerName = player.NickName,
+            playerTeam = player.Team,
+            playerLogin = player.GetLogin(),
+            teamColorCode = new ColorUtils().Opacity(GetTeamColor(player.Team), 80)
+        };
+    }
+
+    public Task HideSpectatorInfoWidgetAsync()
+        => manialinks.HideManialinkAsync(WidgetTemplate);
+
+    public Task HideSpectatorInfoWidgetAsync(string playerLogin)
+        => manialinks.HideManialinkAsync(playerLogin, WidgetTemplate);
+
+    public Task SendReportSpectatorTargetManialinkAsync() =>
+        manialinks.SendPersistentManialinkAsync(ReportTargetTemplate);
+
+    public async Task FetchAndCacheTeamInfoAsync()
+    {
+        _teamInfos[PlayerTeam.Team1] = await server.Remote.GetTeamInfoAsync((int)PlayerTeam.Team1 + 1);
+        _teamInfos[PlayerTeam.Team2] = await server.Remote.GetTeamInfoAsync((int)PlayerTeam.Team2 + 1);
+    }
+
+    public async Task UpdateIsTeamsModeAsync()
+    {
+        _isTeamsMode =
+            await matchSettingsService.GetCurrentModeAsync() is DefaultModeScriptName.Teams
+                or DefaultModeScriptName.TmwtTeams;
+
+        logger.LogInformation("Team mode is {state}", _isTeamsMode ? "active" : "not active");
     }
+
+    public Task HideGameModeUiAsync() =>
+        gameModeUiModuleService.ApplyComponentSettingsAsync(GameModeUiComponents.SpectatorBaseName, false, 0, 0, 1);
 }
diff --git a/src/Modules/SpectatorTargetInfoModule/SpectatorTargetInfoModule.cs b/src/Modules/SpectatorTargetInfoModule/SpectatorTargetInfoModule.cs
index d96983417..75cc8b7ab 100644
--- a/src/Modules/SpectatorTargetInfoModule/SpectatorTargetInfoModule.cs
+++ b/src/Modules/SpectatorTargetInfoModule/SpectatorTargetInfoModule.cs
@@ -1,18 +1,15 @@
 using EvoSC.Modules.Attributes;
 using EvoSC.Modules.Interfaces;
-using SpectatorTargetInfo.Interfaces;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Interfaces;
 
 namespace EvoSC.Modules.Official.SpectatorTargetInfoModule;
 
 [Module(IsInternal = true)]
-public class SpectatorTargetInfoModule(ISpectatorTargetInfoService spectatorTargetInfoService) : EvoScModule,
-    IToggleable
+public class SpectatorTargetInfoModule(ISpectatorTargetInfoService spectatorTargetInfoService)
+    : EvoScModule, IToggleable
 {
-    public Task EnableAsync()
-    {
-        spectatorTargetInfoService.HideNadeoSpectatorInfoAsync();
-        return spectatorTargetInfoService.SendManiaLinkAsync();
-    }
+    public Task EnableAsync() =>
+        spectatorTargetInfoService.InitializeAsync();
 
-    public Task DisableAsync() => spectatorTargetInfoService.ShowNadeoSpectatorInfoAsync();
+    public Task DisableAsync() => Task.CompletedTask;
 }
diff --git a/src/Modules/SpectatorTargetInfoModule/SpectatorTargetInfoModule.csproj b/src/Modules/SpectatorTargetInfoModule/SpectatorTargetInfoModule.csproj
index 11821d888..1a6292958 100644
--- a/src/Modules/SpectatorTargetInfoModule/SpectatorTargetInfoModule.csproj
+++ b/src/Modules/SpectatorTargetInfoModule/SpectatorTargetInfoModule.csproj
@@ -5,14 +5,21 @@
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
         <RootNamespace>EvoSC.Modules.Official.SpectatorTargetInfoModule</RootNamespace>
+        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+        <AssemblyName>SpectatorTargetInfoModule</AssemblyName>
     </PropertyGroup>
 
     <ItemGroup>
       <ProjectReference Include="..\..\EvoSC.Modules\EvoSC.Modules.csproj" />
+      <ProjectReference Include="..\GameModeUiModule\GameModeUiModule.csproj" />
     </ItemGroup>
 
     <ItemGroup>
         <ProjectReference Include="..\..\EvoSC.Modules.SourceGeneration\EvoSC.Modules.SourceGeneration.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false" />
         <EmbeddedResource Include="Templates\**\*" />
+        <EmbeddedResource Update="Localization.resx">
+          <Generator>ResXFileCodeGenerator</Generator>
+          <LastGenOutput>Localization.Designer.cs</LastGenOutput>
+        </EmbeddedResource>
     </ItemGroup>
 </Project>
diff --git a/src/Modules/SpectatorTargetInfoModule/Templates/NewCpTime.mt b/src/Modules/SpectatorTargetInfoModule/Templates/NewCpTime.mt
deleted file mode 100644
index 49ecc4b76..000000000
--- a/src/Modules/SpectatorTargetInfoModule/Templates/NewCpTime.mt
+++ /dev/null
@@ -1,24 +0,0 @@
-<component>
-    <property type="string" name="accountId" />
-    <property type="int" name="cpIndex" />
-    <property type="int" name="time" />
-    
-    <template>
-    </template>
-    
-    <script><!--
-    #Struct EvoSC_CheckpointTime {
-        Text AccountId;
-        Integer CpIndex;
-        Integer Time;
-    }
-    
-    main() {
-        declare EvoSC_CheckpointTime[Text] EvoCheckpointTimes for UI;
-        declare Integer EvoCheckpointTimesUpdate for UI;
-        
-        EvoCheckpointTimes["{{ accountId }}"] = EvoSC_CheckpointTime{ AccountId = "{{ accountId }}", Time = {{ time }}, CpIndex = {{ cpIndex }} };
-        EvoCheckpointTimesUpdate = Now;
-    }
-    --></script>
-</component>
\ No newline at end of file
diff --git a/src/Modules/SpectatorTargetInfoModule/Templates/ReportSpecTarget.mt b/src/Modules/SpectatorTargetInfoModule/Templates/ReportSpecTarget.mt
new file mode 100644
index 000000000..1fedbce88
--- /dev/null
+++ b/src/Modules/SpectatorTargetInfoModule/Templates/ReportSpecTarget.mt
@@ -0,0 +1,28 @@
+<component>
+    <template/>
+    <script><!--
+    Text ReportSpecTarget(Text targetLogin){
+        TriggerPageAction("SpectatorTargetInfoManialinkController/ReportSpectatorTarget/" ^ targetLogin);
+        return targetLogin;
+    }
+    
+    main() {
+        declare Text previousTarget = "";
+        declare Text currentTarget = "";
+    
+        while(True){
+            yield;
+            sleep(100);
+            
+            if(GUIPlayer == Null || GUIPlayer.User == LocalUser){
+                currentTarget = "";
+            }else{
+                currentTarget = GUIPlayer.User.Login;
+            }
+            
+            if(currentTarget == previousTarget) continue;
+            previousTarget = ReportSpecTarget(currentTarget);
+        }
+    }
+    --></script>
+</component>
diff --git a/src/Modules/SpectatorTargetInfoModule/Templates/ResetCpTimes.mt b/src/Modules/SpectatorTargetInfoModule/Templates/ResetCpTimes.mt
deleted file mode 100644
index d2b90dad5..000000000
--- a/src/Modules/SpectatorTargetInfoModule/Templates/ResetCpTimes.mt
+++ /dev/null
@@ -1,22 +0,0 @@
-<component>
-    <template>
-    </template>
-    
-    <script><!--
-    #Struct EvoSC_CheckpointTime {
-        Text AccountId;
-        Integer CpIndex;
-        Integer Time;
-    }
-    
-    main() {
-        declare EvoSC_CheckpointTime[Text] EvoCheckpointTimes for UI;
-        declare Integer EvoCheckpointTimesUpdate for UI;
-        declare Boolean EvoCheckpointTimesReset for UI = False;
-        
-        EvoCheckpointTimes = EvoSC_CheckpointTime[Text];
-        EvoCheckpointTimesUpdate = Now;
-        EvoCheckpointTimesReset = True;
-    }
-    --></script>
-</component>
\ No newline at end of file
diff --git a/src/Modules/SpectatorTargetInfoModule/Templates/Scripts/SpectatorTargetInfo.ms b/src/Modules/SpectatorTargetInfoModule/Templates/Scripts/SpectatorTargetInfo.ms
new file mode 100644
index 000000000..3bc6f9edc
--- /dev/null
+++ b/src/Modules/SpectatorTargetInfoModule/Templates/Scripts/SpectatorTargetInfo.ms
@@ -0,0 +1,143 @@
+<!--
+#Include "Libs/Nadeo/CMGame/Utils/Icons.Script.txt" as Icons
+#Include "TextLib" as TextLib
+
+CSmPlayer GetNextSpawnedPlayer() {
+    if (GUIPlayer == Null) return Null;
+
+    declare CSmPlayer TargetPlayer;
+    declare Boolean CanSelectNextPlayer = False;
+
+    foreach (Player in Players) {
+        if (Player == GUIPlayer) {
+            CanSelectNextPlayer = True;
+        } else if (
+            Player.SpawnStatus != CSmPlayer::ESpawnStatus::NotSpawned &&
+            Player.User != Null
+        ) {
+            if (CanSelectNextPlayer) {
+                TargetPlayer <=> Player;
+                break;
+            } else if (TargetPlayer == Null) {
+                TargetPlayer <=> Player;
+            }
+        }
+    }
+    return TargetPlayer;
+}
+
+CSmPlayer GetPrevSpawnedPlayer() {
+    if (GUIPlayer == Null) return Null;
+
+    declare CSmPlayer TargetPlayer;
+    declare Boolean CanSelectPrevPlayer = False;
+
+    // Read the Players array in the reverse order to fin the previous spawned player
+    for (I, 0, Players.count-1, -1) {
+        declare CSmPlayer Player <=> Players[I];
+        if (Player == GUIPlayer) {
+            CanSelectPrevPlayer = True;
+        } else if (
+            Player.SpawnStatus != CSmPlayer::ESpawnStatus::NotSpawned &&
+            Player.User != Null
+        ) {
+            if (CanSelectPrevPlayer) {
+                TargetPlayer <=> Player;
+                break;
+            } else if (TargetPlayer == Null) {
+                TargetPlayer <=> Player;
+            }
+        }
+    }
+
+    return TargetPlayer;
+}
+
+Void AnimateOpacity(CMlLabel button, Real targetOpacity){
+    AnimMgr.Flush(button);
+    AnimMgr.Add(button, "<anim opacity=\"" ^ targetOpacity ^ "\"/>", 200, CAnimManager::EAnimManagerEasing::ExpOut);
+}
+
+Void AnimatePop(CMlLabel button){
+    AnimMgr.Flush(button);
+    AnimMgr.Add(button, "<anim scale=\"1.2\" opacity=\"1.0\"/>", 200, CAnimManager::EAnimManagerEasing::ExpOut);
+    AnimMgr.AddChain(button, "<anim scale=\"1.0\" opacity=\"0.5\"/>", 200, CAnimManager::EAnimManagerEasing::ExpOut);
+}
+
+Void FocusPlayer(CSmPlayer _Player) {
+    if (_Player != Null && _Player.SpawnStatus != CSmPlayer::ESpawnStatus::NotSpawned && _Player.User != Null) {
+        SetSpectateTarget(_Player.User.Login);
+    }
+}
+
+Text SpecPrevious(CMlLabel button, Boolean focus){
+    AnimatePop(button);
+    declare CSmPlayer target <=> GetNextSpawnedPlayer();
+    if(focus){
+        FocusPlayer(target);
+    }
+    return target.User.Login;
+}
+
+Text SpecNext(CMlLabel button, Boolean focus){
+    AnimatePop(button);
+    declare CSmPlayer target <=> GetNextSpawnedPlayer();
+    if(focus){
+        FocusPlayer(target);
+    }
+    return target.User.Login;
+}
+
+main() {
+    declare mainFrame <=> (Page.MainFrame.GetFirstChild("main_frame") as CMlFrame);
+    declare previousButton <=> (Page.MainFrame.GetFirstChild("left_button") as CMlLabel);
+    declare nextButton <=> (Page.MainFrame.GetFirstChild("right_button") as CMlLabel);
+    declare targetLogin = "{{ playerLogin }}";
+    
+    while(True){
+        yield;
+        
+        if(GUIPlayer == Null){
+            if(mainFrame.Visible){
+                mainFrame.Hide();
+            }
+            continue;
+        }
+        
+        if(!mainFrame.Visible){
+            mainFrame.Show();
+        }
+        
+        foreach (InputEvent in Input.PendingEvents) {
+            if(InputEvent.Button == CInputEvent::EButton::Left){
+                SpecPrevious(previousButton, InputEvent.Pad.Type == CInputPad::EPadType::Keyboard);
+                continue;
+            }
+            if(InputEvent.Button == CInputEvent::EButton::Right){
+                SpecNext(nextButton, InputEvent.Pad.Type == CInputPad::EPadType::Keyboard);
+                continue;
+            }
+        }
+        
+        foreach(Event in PendingEvents){
+            if(Event.Type == CMlScriptEvent::Type::MouseClick){
+                if(Event.Control == previousButton){
+                    targetLogin = SpecPrevious(previousButton, True);
+                    continue;
+                }else if(Event.Control == nextButton){
+                    targetLogin = SpecNext(nextButton, True);
+                    continue;
+                }
+            }
+            if(Event.Type == CMlScriptEvent::Type::MouseOver){
+                AnimateOpacity(Event.Control as CMlLabel, 1.0);
+                continue;
+            }
+            if(Event.Type == CMlScriptEvent::Type::MouseOut){
+                AnimateOpacity(Event.Control as CMlLabel, 0.5);
+                continue;
+            }
+        }
+    }
+}
+-->
\ No newline at end of file
diff --git a/src/Modules/SpectatorTargetInfoModule/Templates/SpectatorTargetInfo.mt b/src/Modules/SpectatorTargetInfoModule/Templates/SpectatorTargetInfo.mt
index 2728ff2bc..4d7e5dabf 100644
--- a/src/Modules/SpectatorTargetInfoModule/Templates/SpectatorTargetInfo.mt
+++ b/src/Modules/SpectatorTargetInfoModule/Templates/SpectatorTargetInfo.mt
@@ -1,280 +1,111 @@
 <component>
+    <using namespace="EvoSC.Modules.Official.SpectatorTargetInfoModule.Config"/>
+
     <import component="EvoSC.Advanced.ClubTag" as="ClubTag"/>
-    
-    <property type="string" name="backgroundColor"/>
-    <property type="string" name="headerColor"/>
-    <property type="string" name="primaryColor"/>
+    <import component="EvoSC.Style.UIStyle" as="UIStyle"/>
+    <import component="EvoSC.Drawing.Rectangle" as="Rectangle"/>
+
+    <property type="ISpectatorTargetInfoSettings" name="settings"/>
+    <property type="int" name="timeDifference" default="0"/>
+    <property type="int" name="playerRank" default="0"/>
+    <property type="int" name="playerTeam" default="-1"/>
+    <property type="string" name="playerName" default="unknown"/>
+    <property type="string" name="playerLogin" default="unknown"/>
+    <property type="string" name="teamColorCode" default="000"/>
 
-    <property type="string" name="bgDark" default="1c1d24"/>
-    <property type="double" name="h" default="10.0"/>
-    <property type="double" name="y" default="-76.0"/>
-    <property type="double" name="centerBoxWidth" default="60.0"/>
-    <property type="double" name="smallBoxWidth" default="19.0"/>
+    <property type="double" name="centerBoxWidth" default="50.0"/>
+    <property type="double" name="h" default="6.0"/>
 
     <template>
-        <frame id="main_frame" pos="0 {{ y }}" hidden="1">
-            <frame id="rounded_box_left" pos="{{ centerBoxWidth / -2.0 - smallBoxWidth }}">
-                <frame size="{{ smallBoxWidth }} {{ h }}">
-                    <quad pos="0 0.2"
-                          size="{{ smallBoxWidth + 2.0 }} {{ h + 0.4 }}"
-                          colorize="{{ Theme.SpectatorTargetInfoModule_SpectatorTargetInfo_BgGrad2 }}"
-                          style="UICommon64_1"
-                          substyle="BgFrame2"
-                          opacity="0.9"
-                    />
-                </frame>
-                <!-- GRADIENT -->
-                <quad pos="{{ smallBoxWidth }} {{ -h }}"
-                      size="{{ smallBoxWidth / 2.0 }} {{ h }}"
-                      image="file://Media/Painter/Stencils/15-Stripes/_Stripe0Grad/Brush.tga"
-                      modulatecolor="{{ Theme.SpectatorTargetInfoModule_SpectatorTargetInfo_BgGrad1 }}"
-                      rot="180"
-                      opacity="0.5"
-                />
-                <label id="position_label"
-                       pos="{{ smallBoxWidth / 2.0 }} {{ h / -2.0 }}"
-                       size="{{ smallBoxWidth - 6.0 }} {{ h }}"
-                       textsize="2.8"
-                       textfont="{{ Font.Regular }}"
-                       text="-1"
-                       halign="center"
-                       valign="center2"
-                />
-            </frame>
+        <UIStyle/>
+        <frame id="main_frame" pos="{{ (h*4.4+centerBoxWidth) / -2.0 }} {{ settings.Y }}">
+            <Rectangle width="{{ h*1.6 }}"
+                       height="{{ h }}"
+                       bgColor="{{ Theme.UI_AccentSecondary }}cc"
+                       cornerRadius="0.5"
+                       corners='TopLeft'
+            />
+            <quad pos="{{ h * 1.6 }}"
+                  size="{{ h * 3.0 }} {{ h }}"
+                  bgcolor="{{ teamColorCode }}"
+                  opacity="0.8"
+            />
+            <Rectangle x="{{ h*4.6  }}"
+                       width="{{ centerBoxWidth }}"
+                       height="{{ h }}"
+                       bgColor="{{ Theme.UI_BgPrimary }}cc"
+                       cornerRadius="0.5"
+                       corners='TopRight'
+            />
+
+            <label id="position_label"
+                   class="text-primary"
+                   pos="{{ (h*1.6) / 2.0 }} {{ h / -2.0 }}"
+                   size="{{ h * 0.8 }} {{ h * 0.8 }}"
+                   textsize="{{ Theme.UI_FontSize*2 }}"
+                   textcolor="{{ Theme.Black }}"
+                   text='{{ playerRank }}'
+                   halign="center"
+                   valign="center2"
+            />
+            <label id="diff_label"
+                   pos="{{ h*1.6+h*1.5 }} {{ h / -2.0 }}"
+                   size="{{ (h*3.4)*0.8 }} {{ h }}"
+                   textsize="{{ Theme.UI_FontSize*2 }}"
+                   textfont="{{ Font.Regular }}"
+                   text='{{ timeDifference > 0 ? RaceTime.FromMilliseconds(timeDifference) : "000" }}'
+                   textprefix="+"
+                   halign="center"
+                   valign="center2"
+            />
 
-            <frame id="rounded_box_right" pos="{{ centerBoxWidth / 2.0 }}">
-                <frame size="{{ smallBoxWidth }} {{ h }}">
-                    <quad pos="-2 0.2"
-                          size="{{ smallBoxWidth + 2.0 }} {{ h + 0.4 }}"
-                          colorize="{{ Theme.SpectatorTargetInfoModule_SpectatorTargetInfo_BgGrad2 }}"
-                          style="UICommon64_1"
-                          substyle="BgFrame2"
-                          opacity="0.9"
-                    />
-                </frame>
-                <!-- GRADIENT -->
-                <quad pos="0 0"
-                      size="{{ smallBoxWidth / 2.0 }} {{ h }}"
-                      image="file://Media/Painter/Stencils/15-Stripes/_Stripe0Grad/Brush.tga"
-                      modulatecolor="{{ Theme.SpectatorTargetInfoModule_SpectatorTargetInfo_BgGrad1 }}"
-                      opacity="0.5"
+            <frame id="name_box" pos="{{ h*4.6 }} {{ h / -2.0 }}">
+                <label id="left_button"
+                       class="text-primary"
+                       pos="4 -0.25"
+                       size="{{ h }} {{ h }}"
+                       textsize="{{ Theme.UI_FontSize*2 }}"
+                       text="{{ Icons.ArrowCircleLeft }}"
+                       valign="center2"
+                       halign="center"
+                       opacity="0.5"
+                       scriptevents="1"
+                       focusareacolor1="0000"
+                       focusareacolor2="0000"
                 />
-                <label id="diff_label"
-                       pos="{{ smallBoxWidth / 2.0 }} {{ h / -2.0 }}"
-                       size="{{ smallBoxWidth - 6.0 }} {{ h }}"
-                       textsize="2"
-                       textfont="{{ Font.Regular }}"
-                       text="-1"
+                <label id="name_label"
+                       class="text-primary"
+                       pos="{{ centerBoxWidth/2.0 }} 0"
+                       size="{{ centerBoxWidth - 14.0 }} {{ h }}"
+                       textsize="{{ Theme.UI_FontSize*2 }}"
+                       text="{{ playerName }}"
+                       valign="center2"
                        halign="center"
+                />
+                <label id="right_button"
+                       class="text-primary"
+                       pos="{{ centerBoxWidth - 4 }} -0.25"
+                       size="{{ h }} {{ h }}"
+                       textsize="{{ Theme.UI_FontSize*2 }}"
+                       text="{{ Icons.ArrowCircleRight }}"
                        valign="center2"
+                       halign="center"
+                       opacity="0.5"
+                       scriptevents="1"
+                       focusareacolor1="0000"
+                       focusareacolor2="0000"
                 />
             </frame>
 
-            <!-- BOX MIDDLE -->
-            <quad size="{{ centerBoxWidth }} {{ h }}"
-                  halign="center"
-                  bgcolor="{{ Theme.SpectatorTargetInfoModule_SpectatorTargetInfo_Bg }}"
+            <Rectangle y="{{ -h }}"
+                       width="{{ h*4.6+centerBoxWidth }}"
+                       height="0.75"
+                       bgColor="{{ teamColorCode }}"
+                       cornerRadius="0.5"
+                       corners='BottomRight,BottomLeft'
             />
-            
-            <frame id="name_box" pos="0 {{ h / -2.0 }}">
-                <ClubTag h="{{ h / 2.0 }}" 
-                         hidden="{{ true }}"
-                />
-                <label id="name_label"
-                       size="{{ centerBoxWidth - 10.0 }} {{ h }}"
-                       textsize="2.8"
-                       textfont="{{ Font.Regular }}"
-                       text="-1"
-                       valign="center2"
-                />
-            </frame>
         </frame>
     </template>
-    
-    <script><!--
-    #Include "MathLib" as ML
-    #Include "TextLib" as TL
-        
-    #Const C_Status_Disconnected	0
-    #Const C_Status_Spawned			1
-    #Const C_Status_NotSpawned		2
-    #Const C_Status_Spectating		3
-    
-    #Struct EvoSC_CheckpointTime {
-        Text AccountId;
-        Integer CpIndex;
-        Integer Time;
-    }
-    
-    declare Integer FirstPositionTime;
-    declare Integer LocalPositionTime;
-        
-    Integer[CSmScore] GetSortedScores() {
-        declare persistent Boolean[Text] LibScoresTable2_Settings for This;
-        declare SortedScores = Integer[CSmScore];
-        declare c = 0;
-
-        foreach (Score in Scores) {
-            declare LibST_Status for Score.User = C_Status_Disconnected;
-            declare Weight = c;
-            if (
-                LibScoresTable2_Settings.existskey("SortSpec") &&
-                LibScoresTable2_Settings["SortSpec"] &&
-                LibST_Status == C_Status_Spectating
-            ) Weight += Scores.count;
-            if (
-                LibScoresTable2_Settings.existskey("SortDisco") &&
-                LibScoresTable2_Settings["SortDisco"] &&
-                LibST_Status == C_Status_Disconnected
-            ) Weight += 2 * Scores.count;
-            SortedScores[Score] = Weight;
-            c += 1;
-        }
 
-        return SortedScores.sort();
-    }
-    
-    Integer GetCurrentCheckpointTime(CSmPlayer player) {
-        if(player != Null && player.CurrentLapWaypointTimes.count > 0){
-            return player.CurrentLapWaypointTimes[player.CurrentLapWaypointTimes.count - 1];
-        }
-        
-        return 0;
-    }
-    
-    Integer GetPlayerRank(Integer[Text] ranksByAccountId, CSmPlayer player) {
-        declare accountId = player.User.WebServicesUserId;
-    
-        if(ranksByAccountId.existskey(accountId)){
-            return ranksByAccountId[accountId];
-        }
-        
-        return -1;
-    }
-    
-    Integer[Text] CalculatePlayerDiffs(Integer[Text] ranksByAccountId) {
-        declare Integer[Text] scoresByAccountId;
-        declare Integer[Text] diffsByAccountId;
-        declare Integer bestTime = -1;
-        
-        foreach(player in Players){
-            scoresByAccountId[player.User.WebServicesUserId] = GetCurrentCheckpointTime(player);
-        }
-    
-        foreach(rank in ranksByAccountId){
-            declare accountId = ranksByAccountId.keyof(rank);
-            
-            if(scoresByAccountId.existskey(accountId)){
-                if(bestTime == -1){
-                    bestTime = scoresByAccountId[accountId];
-                }
-                
-                diffsByAccountId[accountId] = ML::Abs(scoresByAccountId[accountId] - bestTime);
-            }
-        }
-        
-        return diffsByAccountId;
-    }
-        
-    Text StripLeadingZeroes(Text input) {
-        return TL::RegexReplace("^[0:]+", input, "", "");
-    }
-    
-    Integer[Text] GetRanksForAccountIds(EvoSC_CheckpointTime[Text] checkpointTimes){
-        declare Integer[Text][Integer] timesByCheckpoints;
-        
-        foreach(cpTime in checkpointTimes){
-            declare index = cpTime.CpIndex;
-        
-            if(!timesByCheckpoints.existskey(index)){
-                timesByCheckpoints[index] = Integer[Text];
-            }
-        
-            timesByCheckpoints[index][cpTime.AccountId] = cpTime.Time;
-        }
-        
-        declare Integer[Text] sortedTimes;
-        declare Integer rank = 1;
-        
-        foreach(checkpointsTimes in timesByCheckpoints.sortkeyreverse()){
-            foreach(cpTime in checkpointsTimes.sort()){
-                declare accountId = checkpointsTimes.keyof(cpTime);
-                sortedTimes[accountId] = rank;
-                rank += 1;
-            }
-        }
-        
-        return sortedTimes;
-    }
-    
-    main() {
-        declare mainFrame <=> (Page.MainFrame.GetFirstChild("main_frame") as CMlFrame);
-        declare nameBoxFrame <=> (Page.MainFrame.GetFirstChild("name_box") as CMlFrame);
-        declare positionLabel <=> (Page.MainFrame.GetFirstChild("position_label") as CMlLabel);
-        declare diffLabel <=> (Page.MainFrame.GetFirstChild("diff_label") as CMlLabel);
-        declare nameLabel <=> (Page.MainFrame.GetFirstChild("name_label") as CMlLabel);
-        declare clubTagBgQuad <=> (Page.MainFrame.GetFirstChild("club_bg") as CMlQuad);
-        declare clubTagLabel <=> (Page.MainFrame.GetFirstChild("club") as CMlLabel);
-        declare lastAssignUpdate = 0;
-        
-        declare EvoSC_CheckpointTime[Text] EvoCheckpointTimes for UI;
-        declare Integer EvoCheckpointTimesUpdate for UI;
-        declare Boolean EvoCheckpointTimesReset for UI = False;
-        declare Integer lastCheckpointUpdateCheck = 0;
-        declare Integer[Text] ranksByAccountId;
-        declare Integer[Text] diffs;
-        
-        FirstPositionTime = 0;
-        LocalPositionTime = 0;
-        
-        while(True) {
-            yield;
-            
-            if(EvoCheckpointTimesReset){
-                ranksByAccountId = Integer[Text];
-                EvoCheckpointTimesReset = False;
-            }
-            
-            if(GUIPlayer == Null || GUIPlayer.User == LocalUser){
-                sleep(100);
-                if(mainFrame.Visible){
-                    mainFrame.Hide();
-                }
-                continue;
-            }
-            
-            if(lastCheckpointUpdateCheck != EvoCheckpointTimesUpdate){
-                lastCheckpointUpdateCheck = EvoCheckpointTimesUpdate;
-                ranksByAccountId = GetRanksForAccountIds(EvoCheckpointTimes);
-                diffs = CalculatePlayerDiffs(ranksByAccountId);
-            }
-            
-            if(!mainFrame.Visible){
-                mainFrame.Show();
-            }
-            
-            declare Integer timeDifference = 0;
-            if(diffs.existskey(GUIPlayer.User.WebServicesUserId)){
-                timeDifference = diffs[GUIPlayer.User.WebServicesUserId];
-            }
-            
-            nameLabel.Value = GUIPlayer.User.Name;
-            diffLabel.Value = "+" ^ StripLeadingZeroes(TL::TimeToText(timeDifference, True, True));
-            positionLabel.Value = GetPlayerRank(ranksByAccountId, GUIPlayer) ^ ".";
-            clubTagLabel.Value = GUIPlayer.User.ClubTag;
-            
-            if(GUIPlayer.User.ClubTag != ""){
-                nameLabel.RelativePosition_V3.X = clubTagBgQuad.Size.X + 1.0;
-                nameBoxFrame.RelativePosition_V3.X = (clubTagBgQuad.Size.X + 1.0 + nameLabel.ComputeWidth(nameLabel.Value)) / -2.0;
-                clubTagBgQuad.Show();
-                clubTagLabel.Show();
-            }else{
-                nameLabel.RelativePosition_V3.X = 0.0;
-                nameBoxFrame.RelativePosition_V3.X = nameLabel.ComputeWidth(nameLabel.Value) / -2.0;
-                clubTagBgQuad.Hide();
-                clubTagLabel.Hide();
-            }
-        }
-    }
-    --></script>
+    <script resource="SpectatorTargetInfoModule.Scripts.SpectatorTargetInfo" main="true" />
 </component>
\ No newline at end of file
diff --git a/src/Modules/SpectatorTargetInfoModule/info.toml b/src/Modules/SpectatorTargetInfoModule/info.toml
index b3b1fdd7b..9fc9498f6 100644
--- a/src/Modules/SpectatorTargetInfoModule/info.toml
+++ b/src/Modules/SpectatorTargetInfoModule/info.toml
@@ -4,3 +4,6 @@ title = "Spectator Target Info"
 summary = "Shows player info in spectator mode."
 version = "1.0.0"
 author = "Evo"
+
+[dependencies]
+GameModeUiModule = "1.0.0"
diff --git a/tests/Modules/GameModeUiModule.Tests/Services/GameModeUiModuleServiceTests.cs b/tests/Modules/GameModeUiModule.Tests/Services/GameModeUiModuleServiceTests.cs
index 0f2fadff6..c871b7eb9 100644
--- a/tests/Modules/GameModeUiModule.Tests/Services/GameModeUiModuleServiceTests.cs
+++ b/tests/Modules/GameModeUiModule.Tests/Services/GameModeUiModuleServiceTests.cs
@@ -2,6 +2,7 @@
 using EvoSC.Common.Interfaces.Services;
 using EvoSC.Modules.Official.GameModeUiModule.Config;
 using EvoSC.Modules.Official.GameModeUiModule.Interfaces;
+using EvoSC.Modules.Official.GameModeUiModule.Models;
 using EvoSC.Modules.Official.GameModeUiModule.Services;
 using EvoSC.Testing;
 using GbxRemoteNet.Interfaces;
@@ -27,10 +28,11 @@ private IGameModeUiModuleService UiModuleServiceMock()
     [InlineData("UnitTest", true, 0.0, 0.0, 1.0)]
     [InlineData("UnitTest", false, -160.0, 80.0, 2.0)]
     [InlineData("UnitTest", false, 160.0, -80.0, 0.5)]
-    public async Task Generates_Property_Object(string id, bool visible, double x, double y, double scale)
+    public Task Generates_Property_Object(string id, bool visible, double x, double y, double scale)
     {
         var uiModuleService = UiModuleServiceMock();
-        var uiModulePropertyObject = await uiModuleService.GeneratePropertyObjectAsync(id, visible, x, y, scale);
+        var uiModulePropertyObject =
+            uiModuleService.GeneratePropertyObject(new GameModeUiComponentSettings(id, visible, x, y, scale));
 
         var idProperty = uiModulePropertyObject.GetType().GetProperty("id");
         Assert.Equal(id, idProperty.GetValue(uiModulePropertyObject, null));
@@ -55,25 +57,44 @@ public async Task Generates_Property_Object(string id, bool visible, double x, d
 
         var scaleUpdateProperty = uiModulePropertyObject.GetType().GetProperty("scale_update");
         Assert.True(scaleUpdateProperty.GetValue(uiModulePropertyObject, null));
+
+        return Task.CompletedTask;
     }
 
     [Fact]
-    public async Task Gets_Ui_Module_Properties_As_Json()
+    public Task Gets_Ui_Module_Properties_As_Json()
     {
         var uiModuleService = UiModuleServiceMock();
-        var uiModuleProperties = await uiModuleService.GetUiModulesPropertiesJsonAsync();
+        var uiModuleProperties = uiModuleService.GetUiModulesPropertiesJson(uiModuleService.GetDefaultSettings());
 
         Assert.IsType<string>(uiModuleProperties);
         JToken.Parse(uiModuleProperties);
+
+        return Task.CompletedTask;
     }
 
     [Fact]
     public async Task Applies_Ui_Modules_Configuration()
     {
         var uiModuleService = UiModuleServiceMock();
-        var uiModuleProperties = await uiModuleService.GetUiModulesPropertiesJsonAsync();
+        var uiModuleProperties = uiModuleService.GetUiModulesPropertiesJson(uiModuleService.GetDefaultSettings());
+
+        await uiModuleService.ApplyComponentSettingsAsync(uiModuleService.GetDefaultSettings());
+
+        _server.Remote.Verify(
+            remote => remote.TriggerModeScriptEventArrayAsync("Common.UIModules.SetProperties", uiModuleProperties),
+            Times.Once
+        );
+    }
+
+    [Fact]
+    public async Task Creates_And_Applies_Ui_Settings_From_Single_Arguments()
+    {
+        var uiModuleService = UiModuleServiceMock();
+        var uiComponentSettings = new GameModeUiComponentSettings("UnitTest", true, 123.0, 123.0, 1.0);
+        var uiModuleProperties = uiModuleService.GetUiModulesPropertiesJson([uiComponentSettings]);
 
-        await uiModuleService.ApplyConfigurationAsync();
+        await uiModuleService.ApplyComponentSettingsAsync("UnitTest", true, 123.0, 123.0, 1.0);
 
         _server.Remote.Verify(
             remote => remote.TriggerModeScriptEventArrayAsync("Common.UIModules.SetProperties", uiModuleProperties),
diff --git a/tests/Modules/SpectatorCamModeModule.Tests/Services/SpectatorCamModeServiceTests.cs b/tests/Modules/SpectatorCamModeModule.Tests/Services/SpectatorCamModeServiceTests.cs
new file mode 100644
index 000000000..6e2420dba
--- /dev/null
+++ b/tests/Modules/SpectatorCamModeModule.Tests/Services/SpectatorCamModeServiceTests.cs
@@ -0,0 +1,68 @@
+using EvoSC.Manialinks.Interfaces;
+using EvoSC.Modules.Official.GameModeUiModule.Enums;
+using EvoSC.Modules.Official.GameModeUiModule.Interfaces;
+using EvoSC.Modules.Official.GameModeUiModule.Models;
+using EvoSC.Modules.Official.SpectatorCamModeModule.Config;
+using EvoSC.Modules.Official.SpectatorCamModeModule.Interfaces;
+using EvoSC.Modules.Official.SpectatorCamModeModule.Services;
+using Moq;
+using Xunit;
+
+namespace EvoSC.Modules.Official.SpectatorCamModeModule.Tests.Services;
+
+public class SpectatorCamModeServiceTests
+{
+    private readonly Mock<IManialinkManager> _manialinkManager = new();
+    private readonly Mock<IGameModeUiModuleService> _gameModeUiModule = new();
+    private readonly Mock<ISpectatorCamModeSettings> _settings = new();
+
+    private ISpectatorCamModeService CamModeServiceMock()
+    {
+        return new SpectatorCamModeService(
+            _manialinkManager.Object,
+            _gameModeUiModule.Object,
+            _settings.Object
+        );
+    }
+
+    [Fact]
+    public async Task SendsPersistentCamModeWidget()
+    {
+        var camModeService = CamModeServiceMock();
+        await camModeService.SendPersistentCamModeWidgetAsync();
+
+        _manialinkManager.Verify(m =>
+            m.SendPersistentManialinkAsync("SpectatorCamModeModule.SpectatorMode", It.IsAny<object>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task HidesCamModeWidget()
+    {
+        var camModeService = CamModeServiceMock();
+        await camModeService.HideCamModeWidgetAsync();
+
+        _manialinkManager.Verify(m =>
+            m.HideManialinkAsync("SpectatorCamModeModule.SpectatorMode"), Times.Once);
+    }
+
+    [Fact]
+    public async Task HidesDefaultGameModeUi()
+    {
+        var camModeService = CamModeServiceMock();
+        await camModeService.HideGameModeUiAsync();
+
+        _gameModeUiModule.Verify(s => s.ApplyComponentSettingsAsync(It.IsAny<GameModeUiComponentSettings>()));
+    }
+
+    [Fact]
+    public Task GameModeUiSettingsHideCorrectComponent()
+    {
+        var camModeService = CamModeServiceMock();
+        var gameModeUiSettings = camModeService.GetGameModeUiSettings();
+        
+        Assert.Equal(GameModeUiComponents.SpectatorBaseCommands, gameModeUiSettings.Name);
+        Assert.False(gameModeUiSettings.Visible);
+
+        return Task.CompletedTask;
+    }
+}
diff --git a/tests/Modules/SpectatorCamModeModule.Tests/SpectatorCamModeModule.Tests.csproj b/tests/Modules/SpectatorCamModeModule.Tests/SpectatorCamModeModule.Tests.csproj
new file mode 100644
index 000000000..8c0e86491
--- /dev/null
+++ b/tests/Modules/SpectatorCamModeModule.Tests/SpectatorCamModeModule.Tests.csproj
@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <RootNamespace>EvoSC.Modules.Official.SpectatorCamModeModule.Tests</RootNamespace>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
+        <PackageReference Include="xunit" Version="2.8.1" />
+        <ProjectReference Include="..\..\..\src\EvoSC.Manialinks\EvoSC.Manialinks.csproj" />
+        <ProjectReference Include="..\..\..\src\EvoSC.Testing\EvoSC.Testing.csproj" />
+        <ProjectReference Include="..\..\..\src\Modules\SpectatorCamModeModule\SpectatorCamModeModule.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\..\..\src\EvoSC.Testing\EvoSC.Testing.csproj"/>
+    </ItemGroup>
+    
+</Project>
diff --git a/tests/Modules/SpectatorTargetInfoModule.Tests/Controllers/SpectatorTargetEventControllerTests.cs b/tests/Modules/SpectatorTargetInfoModule.Tests/Controllers/SpectatorTargetEventControllerTests.cs
new file mode 100644
index 000000000..a74ff90b4
--- /dev/null
+++ b/tests/Modules/SpectatorTargetInfoModule.Tests/Controllers/SpectatorTargetEventControllerTests.cs
@@ -0,0 +1,76 @@
+using EvoSC.Common.Interfaces.Controllers;
+using EvoSC.Common.Remote.EventArgsModels;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Controllers;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Interfaces;
+using EvoSC.Testing.Controllers;
+using GbxRemoteNet.Events;
+using Moq;
+using Xunit;
+
+namespace EvoSC.Modules.Official.SpectatorTargetInfoModule.Tests.Controllers;
+
+public class
+    SpectatorTargetEventControllerTests : ControllerMock<SpectatorTargetInfoEventController, IEventControllerContext>
+{
+    private Mock<ISpectatorTargetInfoService> _spectatorTargetService = new();
+
+    public SpectatorTargetEventControllerTests()
+    {
+        InitMock(_spectatorTargetService);
+    }
+
+    [Fact]
+    public async Task Removes_Player_From_Spectators_On_Disconnect()
+    {
+        var login = "*fakeplayer_unittest*";
+
+        await Controller.OnPlayerDisconnectAsync(null, new PlayerGbxEventArgs { Login = login });
+
+        _spectatorTargetService.Verify(sts => sts.RemovePlayerFromSpectatorsListAsync(login));
+    }
+
+    [Fact]
+    public async Task Updates_Team_Mode_On_New_Map()
+    {
+        await Controller.OnBeginMapAsync(null, new MapGbxEventArgs());
+
+        _spectatorTargetService.Verify(sts => sts.UpdateIsTeamsModeAsync());
+    }
+
+    [Fact]
+    public async Task Registers_Ceckpoint_Times()
+    {
+        var login = "*fakeplayer_unittest*";
+        var checkpointId = 3;
+        var lapTime = 1234;
+
+        await Controller.OnWayPointAsync(null,
+            new WayPointEventArgs
+            {
+                Login = login,
+                AccountId = login,
+                RaceTime = 0,
+                LapTime = lapTime,
+                CheckpointInRace = 0,
+                CheckpointInLap = checkpointId,
+                IsEndRace = false,
+                IsEndLap = false,
+                CurrentRaceCheckpoints = null,
+                CurrentLapCheckpoints = null,
+                BlockId = null,
+                Speed = 0,
+                Time = 0
+            });
+
+        _spectatorTargetService.Verify(sts => sts.AddCheckpointAsync(login, checkpointId, lapTime));
+    }
+
+    [Fact]
+    public async Task Resets_Collected_Data_On_New_Round()
+    {
+        await Controller.OnNewRoundAsync(null, new RoundEventArgs { Count = 0, Time = 0 });
+
+        _spectatorTargetService.Verify(sts => sts.ClearCheckpointsAsync());
+        _spectatorTargetService.Verify(sts => sts.FetchAndCacheTeamInfoAsync());
+    }
+}
diff --git a/tests/Modules/SpectatorTargetInfoModule.Tests/Controllers/SpectatorTargetInfoManialinkControllerTests.cs b/tests/Modules/SpectatorTargetInfoModule.Tests/Controllers/SpectatorTargetInfoManialinkControllerTests.cs
new file mode 100644
index 000000000..355a7f8cb
--- /dev/null
+++ b/tests/Modules/SpectatorTargetInfoModule.Tests/Controllers/SpectatorTargetInfoManialinkControllerTests.cs
@@ -0,0 +1,71 @@
+using EvoSC.Common.Interfaces.Models;
+using EvoSC.Common.Util;
+using EvoSC.Manialinks.Interfaces.Models;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Controllers;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Interfaces;
+using EvoSC.Testing.Controllers;
+using Moq;
+using Xunit;
+
+namespace EvoSC.Modules.Official.SpectatorTargetInfoModule.Tests.Controllers;
+
+public class
+    SpectatorTargetInfoManialinkControllerTests : ManialinkControllerTestBase<SpectatorTargetInfoManialinkController>
+{
+    private Mock<ISpectatorTargetInfoService> _spectatorTargetService = new();
+    private Mock<IManialinkActionContext> _manialinkActionContext = new();
+    private Mock<IOnlinePlayer> _actor = new();
+
+    public SpectatorTargetInfoManialinkControllerTests()
+    {
+        InitMock(_actor.Object, _manialinkActionContext.Object, _spectatorTargetService.Object);
+    }
+
+    [Fact]
+    public async Task SetsSpectatorTargetIfGivenLoginIsValid()
+    {
+        _actor.Setup(actor => actor.AccountId)
+            .Returns("*fakeplayer_spectator*");
+
+        var spectatorLogin = _actor.Object.GetLogin();
+        var targetLogin = "*fakeplayer_target*";
+
+        await Controller.ReportSpectatorTargetAsync(targetLogin);
+
+        _spectatorTargetService.Verify(st => st.SetSpectatorTargetAndSendAsync(spectatorLogin, targetLogin), Times.Once);
+        _spectatorTargetService.Verify(st => st.RemovePlayerFromSpectatorsListAsync(spectatorLogin), Times.Never);
+        _spectatorTargetService.Verify(st => st.HideSpectatorInfoWidgetAsync(spectatorLogin), Times.Never);
+    }
+
+    [Fact]
+    public async Task RemoveSpectatorIfTargetIsEmpty()
+    {
+        _actor.Setup(actor => actor.AccountId)
+            .Returns("*fakeplayer_spectator*");
+
+        var spectatorLogin = _actor.Object.GetLogin();
+        var targetLogin = "";
+
+        await Controller.ReportSpectatorTargetAsync(targetLogin);
+
+        _spectatorTargetService.Verify(st => st.SetSpectatorTargetAndSendAsync(spectatorLogin, targetLogin), Times.Never);
+        _spectatorTargetService.Verify(st => st.RemovePlayerFromSpectatorsListAsync(spectatorLogin), Times.Once);
+        _spectatorTargetService.Verify(st => st.HideSpectatorInfoWidgetAsync(spectatorLogin), Times.Once);
+    }
+
+    [Fact]
+    public async Task RemoveSpectatorIfTargetIsSpectatorThemselvesEmpty()
+    {
+        _actor.Setup(actor => actor.AccountId)
+            .Returns("*fakeplayer_spectator*");
+
+        var spectatorLogin = _actor.Object.GetLogin();
+        var targetLogin = "*fakeplayer_spectator*";
+
+        await Controller.ReportSpectatorTargetAsync(targetLogin);
+
+        _spectatorTargetService.Verify(st => st.SetSpectatorTargetAndSendAsync(spectatorLogin, targetLogin), Times.Never);
+        _spectatorTargetService.Verify(st => st.RemovePlayerFromSpectatorsListAsync(spectatorLogin), Times.Once);
+        _spectatorTargetService.Verify(st => st.HideSpectatorInfoWidgetAsync(spectatorLogin), Times.Once);
+    }
+}
diff --git a/tests/Modules/SpectatorTargetInfoModule.Tests/Models/CheckpointsGroupTests.cs b/tests/Modules/SpectatorTargetInfoModule.Tests/Models/CheckpointsGroupTests.cs
new file mode 100644
index 000000000..4d8c077fc
--- /dev/null
+++ b/tests/Modules/SpectatorTargetInfoModule.Tests/Models/CheckpointsGroupTests.cs
@@ -0,0 +1,101 @@
+using EvoSC.Common.Interfaces.Models.Enums;
+using EvoSC.Common.Models.Players;
+using EvoSC.Common.Util;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Models;
+using Xunit;
+
+namespace EvoSC.Modules.Official.SpectatorTargetInfoModule.Tests.Models;
+
+public class CheckpointsGroupTests
+{
+    [Fact]
+    public Task Gets_Player_Data_From_Group()
+    {
+        var checkpointsGroup = new CheckpointsGroup();
+        var targetPlayer = new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer1*" };
+
+        checkpointsGroup.Add(
+            new CheckpointData(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer10*" }, 0));
+        checkpointsGroup.Add(new CheckpointData(targetPlayer, 1));
+        checkpointsGroup.Add(
+            new CheckpointData(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer12*" }, 2));
+
+        var time = checkpointsGroup.GetPlayerCheckpointData(targetPlayer.GetLogin())?.time;
+        
+        Assert.Equal(1, time);
+
+        return Task.CompletedTask;
+    }
+
+    [Fact]
+    public Task Returns_Null_For_Non_Existent_Player_data()
+    {
+        var checkpointsGroup = new CheckpointsGroup();
+        var checkpointData = checkpointsGroup.GetPlayerCheckpointData("*fakeplayer1*");
+
+        Assert.Null(checkpointData);
+
+        return Task.CompletedTask;
+    }
+
+    [Fact]
+    public Task Gets_Rank_Of_Player()
+    {
+        var checkpointsGroup = new CheckpointsGroup();
+        var targetPlayer = new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer1*" };
+
+        checkpointsGroup.Add(
+            new CheckpointData(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer10*" }, 0));
+        checkpointsGroup.Add(new CheckpointData(targetPlayer, 1));
+        checkpointsGroup.Add(
+            new CheckpointData(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer12*" }, 2));
+
+        var rank = checkpointsGroup.GetRank(targetPlayer.AccountId);
+        
+        Assert.Equal(2, rank);
+
+        return Task.CompletedTask;
+    }
+
+    [Fact]
+    public Task Gets_Rank_Of_Player_Correctly_If_Another_Player_Has_The_Same_Time_Before()
+    {
+        var checkpointsGroup = new CheckpointsGroup();
+        var targetPlayer = new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer1*" };
+
+        checkpointsGroup.Add(
+            new CheckpointData(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer10*" }, 0));
+        checkpointsGroup.Add(
+            new CheckpointData(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer11*" }, 1));
+        checkpointsGroup.Add(new CheckpointData(targetPlayer, 1));
+        checkpointsGroup.Add(
+            new CheckpointData(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer12*" }, 2));
+
+        var rank = checkpointsGroup.GetRank(targetPlayer.AccountId);
+        
+        Assert.Equal(3, rank);
+
+        return Task.CompletedTask;
+    }
+
+    [Fact]
+    public Task Gets_Rank_Of_Player_Correctly_If_Another_Player_Has_The_Same_Time_After()
+    {
+        var checkpointsGroup = new CheckpointsGroup();
+        var targetPlayer = new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer1*" };
+
+        checkpointsGroup.Add(
+            new CheckpointData(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer10*" }, 0));
+        checkpointsGroup.Add(new CheckpointData(targetPlayer, 1));
+        checkpointsGroup.Add(
+            new CheckpointData(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer11*" }, 1));
+        checkpointsGroup.Add(
+            new CheckpointData(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer12*" }, 2));
+
+        var rank = checkpointsGroup.GetRank(targetPlayer.AccountId);
+        
+        Assert.Equal(2, rank);
+
+        return Task.CompletedTask;
+    }
+}
diff --git a/tests/Modules/SpectatorTargetInfoModule.Tests/Services/SpectatorTargetInfoServiceTests.cs b/tests/Modules/SpectatorTargetInfoModule.Tests/Services/SpectatorTargetInfoServiceTests.cs
new file mode 100644
index 000000000..66f1e7f8e
--- /dev/null
+++ b/tests/Modules/SpectatorTargetInfoModule.Tests/Services/SpectatorTargetInfoServiceTests.cs
@@ -0,0 +1,439 @@
+using EvoSC.Common.Interfaces;
+using EvoSC.Common.Interfaces.Models;
+using EvoSC.Common.Interfaces.Models.Enums;
+using EvoSC.Common.Interfaces.Services;
+using EvoSC.Common.Interfaces.Themes;
+using EvoSC.Common.Models.Players;
+using EvoSC.Common.Util;
+using EvoSC.Common.Util.MatchSettings;
+using EvoSC.Manialinks.Interfaces;
+using EvoSC.Modules.Official.GameModeUiModule.Enums;
+using EvoSC.Modules.Official.GameModeUiModule.Interfaces;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Config;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Interfaces;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Models;
+using EvoSC.Modules.Official.SpectatorTargetInfoModule.Services;
+using EvoSC.Testing;
+using GbxRemoteNet.Interfaces;
+using GbxRemoteNet.Structs;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Xunit;
+
+namespace EvoSC.Modules.Official.SpectatorTargetInfoModule.Tests.Services;
+
+public class SpectatorTargetInfoServiceTests
+{
+    private readonly Mock<IManialinkManager> _manialinkManager = new();
+    private readonly Mock<IMatchSettingsService> _matchSettingsService = new();
+    private readonly Mock<ISpectatorTargetInfoSettings> _settings = new();
+    private readonly Mock<IPlayerManagerService> _playerManager = new();
+    private readonly Mock<IGameModeUiModuleService> _gameModeUiModuleService = new();
+    private readonly Mock<ILogger<SpectatorTargetInfoService>> _logger = new();
+    private readonly Mock<IThemeManager> _theme = new();
+
+    private readonly (Mock<IServerClient> Client, Mock<IGbxRemoteClient> Remote, Mock<IChatService> Chat) _server =
+        Mocking.NewServerClientMock();
+
+    private ISpectatorTargetInfoService ServiceMock()
+    {
+        return new SpectatorTargetInfoService(
+            _manialinkManager.Object,
+            _server.Client.Object,
+            _playerManager.Object,
+            _matchSettingsService.Object,
+            _settings.Object,
+            _theme.Object,
+            _gameModeUiModuleService.Object,
+            _logger.Object
+        );
+    }
+
+    [Fact]
+    public async Task Adds_And_Clears_Checkpoint_Data()
+    {
+        var spectatorTargetService = ServiceMock();
+        _playerManager.Setup(s => s.GetOnlinePlayerAsync(It.IsAny<string>()))
+            .ReturnsAsync(new OnlinePlayer { State = PlayerState.Spectating, });
+
+        await spectatorTargetService.AddCheckpointAsync("*fakeplayer4*", 1, 1000);
+        await spectatorTargetService.AddCheckpointAsync("*fakeplayer3*", 2, 1000);
+        await spectatorTargetService.AddCheckpointAsync("*fakeplayer2*", 2, 1200);
+        await spectatorTargetService.AddCheckpointAsync("*fakeplayer1*", 2, 1400);
+
+        var cpTimes = spectatorTargetService.GetCheckpointTimes();
+        Assert.Equal(2, cpTimes.Count);
+        Assert.Single(cpTimes[1]);
+        Assert.Equal(1000, cpTimes[1][0].time);
+        Assert.Equal(3, cpTimes[2].Count);
+        Assert.Equal(1000, cpTimes[2][0].time);
+        Assert.Equal(1200, cpTimes[2][1].time);
+        Assert.Equal(1400, cpTimes[2][2].time);
+
+        await spectatorTargetService.ClearCheckpointsAsync();
+        var checkpointTime = spectatorTargetService.GetCheckpointTimes();
+        
+        Assert.Empty(checkpointTime);
+    }
+
+    [Fact]
+    public async Task Gets_Online_Player_By_Login()
+    {
+        var login = "*fakeplayer1*";
+        var spectatorTargetService = ServiceMock();
+        var expectedPlayer = new OnlinePlayer { State = PlayerState.Playing, AccountId = login };
+
+        _playerManager.Setup(pm => pm.GetOnlinePlayerAsync(login))
+            .ReturnsAsync(expectedPlayer);
+
+        var player = await spectatorTargetService.GetOnlinePlayerByLoginAsync(login);
+
+        Assert.Equal(login, player.GetLogin());
+    }
+
+    [Fact]
+    public async Task Gets_Login_By_Dedicated_Player_Id()
+    {
+        var spectatorTargetService = ServiceMock();
+        _server.Remote.Setup(s => s.GetPlayerListAsync())
+            .ReturnsAsync([
+                new TmPlayerInfo { PlayerId = 22, Login = "UnitTest" }
+            ]);
+
+        var login = await spectatorTargetService.GetLoginOfDedicatedPlayerAsync(22);
+        Assert.Equal("UnitTest", login);
+    }
+
+    [Fact]
+    public async Task Updates_Spectator_Target_With_Dedicated_Player_Id()
+    {
+        var spectatorTargetService = ServiceMock();
+
+        _playerManager.Setup(pm => pm.GetOnlinePlayerAsync("*fakeplayer_unittest*"))
+            .ReturnsAsync(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer_unittest*" });
+
+        await spectatorTargetService.SetSpectatorTargetAsync("*fakeplayer1*", "*fakeplayer_unittest*");
+
+        var fakePlayer = new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer_unittest*" };
+        var spectatorOfPlayer = spectatorTargetService.GetLoginsOfPlayersSpectatingTarget(fakePlayer).ToList();
+
+        Assert.Single(spectatorOfPlayer);
+        Assert.Contains("*fakeplayer1*", spectatorOfPlayer);
+    }
+
+    [Fact]
+    public async Task Removes_Spectator_If_Target_Login_Is_Null()
+    {
+        var spectatorTargetService = ServiceMock();
+
+        _playerManager.Setup(pm => pm.GetOnlinePlayerAsync("*fakeplayer_UnitTest*"))
+            .ReturnsAsync(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer_UnitTest*" });
+        _playerManager.Setup(pm => pm.GetOnlinePlayerAsync("*fakeplayer_SomeOtherPlayer*"))
+            .ReturnsAsync(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer_SomeOtherPlayer*" });
+
+        await spectatorTargetService.SetSpectatorTargetAsync("*fakeplayer1*", "*fakeplayer_UnitTest*");
+        await spectatorTargetService.SetSpectatorTargetAsync("*fakeplayer1*", "*fakeplayer_SomeOtherPlayer*");
+
+        var fakePlayer = new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer_UnitTest*" };
+
+        var spectatorOfPlayer =
+            spectatorTargetService.GetLoginsOfPlayersSpectatingTarget(fakePlayer).ToList();
+
+        Assert.Empty(spectatorOfPlayer);
+        Assert.DoesNotContain("*fakeplayer1*", spectatorOfPlayer);
+    }
+
+    [Fact]
+    public async Task Gets_Logins_Spectating_The_Given_Target()
+    {
+        var spectatorTargetService = ServiceMock();
+
+        _playerManager.Setup(pm => pm.GetOnlinePlayerAsync("*fakeplayer10*"))
+            .ReturnsAsync(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer10*" });
+        _playerManager.Setup(pm => pm.GetOnlinePlayerAsync("*fakeplayer99*"))
+            .ReturnsAsync(new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer99*" });
+
+        await spectatorTargetService.SetSpectatorTargetAsync("*fakeplayer1*", "*fakeplayer10*");
+        await spectatorTargetService.SetSpectatorTargetAsync("*fakeplayer2*", "*fakeplayer10*");
+        await spectatorTargetService.SetSpectatorTargetAsync("*fakeplayer3*", "*fakeplayer99*");
+
+        var fakePlayer10 = new OnlinePlayer { State = PlayerState.Playing, AccountId = "*fakeplayer10*" };
+        var spectatorOfPlayer = spectatorTargetService.GetLoginsOfPlayersSpectatingTarget(fakePlayer10).ToList();
+
+        Assert.Equal(2, spectatorOfPlayer.Count);
+        Assert.Contains("*fakeplayer1*", spectatorOfPlayer);
+        Assert.Contains("*fakeplayer2*", spectatorOfPlayer);
+        Assert.DoesNotContain("*fakeplayer3*", spectatorOfPlayer);
+    }
+
+    [Fact]
+    public Task Gets_Rank_From_Sorted_Checkpoints_List()
+    {
+        var checkpointsList = new CheckpointsGroup
+        {
+            new CheckpointData(
+                new OnlinePlayer
+                {
+                    AccountId = PlayerUtils.ConvertLoginToAccountId("*fakeplayer1*"), State = PlayerState.Spectating
+                }, 1_000
+            ),
+            new CheckpointData(
+                new OnlinePlayer
+                {
+                    AccountId = PlayerUtils.ConvertLoginToAccountId("*fakeplayer2*"), State = PlayerState.Spectating
+                }, 1_000
+            ),
+            new CheckpointData(
+                new OnlinePlayer
+                {
+                    AccountId = PlayerUtils.ConvertLoginToAccountId("*fakeplayer4*"), State = PlayerState.Spectating
+                }, 1_001
+            ),
+            new CheckpointData(
+                new OnlinePlayer
+                {
+                    AccountId = PlayerUtils.ConvertLoginToAccountId("*fakeplayer3*"), State = PlayerState.Spectating
+                }, 1_111
+            ),
+        };
+
+        var player1Rank = checkpointsList.GetRank("*fakeplayer1*");
+        var player2Rank = checkpointsList.GetRank("*fakeplayer2*");
+        var player3Rank = checkpointsList.GetRank("*fakeplayer3*");
+        var player4Rank = checkpointsList.GetRank("*fakeplayer4*");
+        
+        Assert.Equal(1, player1Rank);
+        Assert.Equal(2, player2Rank);
+        Assert.Equal(4, player3Rank);
+        Assert.Equal(3, player4Rank);
+
+        return Task.CompletedTask;
+    }
+
+    [Theory]
+    [InlineData(900, 1_000, 100)]
+    [InlineData(100, 999, 899)]
+    [InlineData(400, 200, -200)]
+    public Task Calculates_Time_Difference(int leadingTime, int trailingTime, int expectedTime)
+    {
+        var spectatorTargetService = ServiceMock();
+        var timeDifference = spectatorTargetService.GetTimeDifference(leadingTime, trailingTime);
+
+        Assert.Equal(expectedTime, timeDifference);
+
+        return Task.CompletedTask;
+    }
+
+    [Fact]
+    public async Task Hides_Widget_For_Everyone()
+    {
+        var spectatorTargetService = ServiceMock();
+        await spectatorTargetService.HideSpectatorInfoWidgetAsync();
+
+        _manialinkManager.Verify(mm => mm.HideManialinkAsync("SpectatorTargetInfoModule.SpectatorTargetInfo"));
+    }
+
+    [Fact]
+    public async Task Hides_Widget_For_The_Given_Player()
+    {
+        var login = "*fakeplayer1*";
+        var spectatorTargetService = ServiceMock();
+        await spectatorTargetService.HideSpectatorInfoWidgetAsync(login);
+
+        _manialinkManager.Verify(mm => mm.HideManialinkAsync(login, "SpectatorTargetInfoModule.SpectatorTargetInfo"));
+    }
+
+    [Fact]
+    public async Task Sends_Spec_Status_Report_Script()
+    {
+        var spectatorTargetService = ServiceMock();
+
+        await spectatorTargetService.SendReportSpectatorTargetManialinkAsync();
+
+        _manialinkManager.Verify(mm => mm.SendPersistentManialinkAsync("SpectatorTargetInfoModule.ReportSpecTarget"));
+    }
+
+    [Fact]
+    public async Task Gets_The_Team_Color()
+    {
+        var spectatorTargetService = ServiceMock();
+
+        _matchSettingsService.Setup(mss => mss.GetCurrentModeAsync())
+            .ReturnsAsync(DefaultModeScriptName.Teams);
+        _server.Remote.Setup(remote => remote.GetTeamInfoAsync(1))
+            .ReturnsAsync(new TmTeamInfo { RGB = "FF0066" });
+        _server.Remote.Setup(remote => remote.GetTeamInfoAsync(2))
+            .ReturnsAsync(new TmTeamInfo { RGB = "111111" });
+
+        await spectatorTargetService.UpdateIsTeamsModeAsync();
+        await spectatorTargetService.FetchAndCacheTeamInfoAsync();
+
+        var team1Color = spectatorTargetService.GetTeamColor(PlayerTeam.Team1);
+        var team2Color = spectatorTargetService.GetTeamColor(PlayerTeam.Team2);
+        
+        Assert.Equal("FF0066", team1Color);
+        Assert.Equal("111111", team2Color);
+    }
+
+    [Fact]
+    public async Task Hides_Default_Game_Mode_Ui()
+    {
+        await ServiceMock().HideGameModeUiAsync();
+
+        _gameModeUiModuleService.Verify(gmums => gmums.ApplyComponentSettingsAsync(
+            GameModeUiComponents.SpectatorBaseName,
+            false,
+            It.IsAny<double>(),
+            It.IsAny<double>(),
+            It.IsAny<double>()
+        ));
+    }
+
+    [Fact]
+    public async Task Sends_The_Widget_To_The_Given_Player_With_Arguments()
+    {
+        var spectatorLogin = "*fakeplayer1*";
+        var targetPlayer = new OnlinePlayer
+        {
+            State = PlayerState.Playing, AccountId = "*fakeplayer2*", NickName = "UnitTest", Team = PlayerTeam.Team1
+        };
+
+        _matchSettingsService.Setup(mss => mss.GetCurrentModeAsync())
+            .ReturnsAsync(DefaultModeScriptName.Teams);
+        _server.Remote.Setup(remote => remote.GetTeamInfoAsync(1))
+            .ReturnsAsync(new TmTeamInfo { RGB = "FF0066" });
+
+        var spectatorTargetService = ServiceMock();
+        await spectatorTargetService.UpdateIsTeamsModeAsync();
+        await spectatorTargetService.FetchAndCacheTeamInfoAsync();
+        var widgetData = spectatorTargetService.GetWidgetData(targetPlayer, 2, 150);
+        await spectatorTargetService.SendSpectatorInfoWidgetAsync(spectatorLogin, targetPlayer, widgetData);
+
+        _manialinkManager.Verify(mm => mm.SendManialinkAsync(spectatorLogin, "SpectatorTargetInfoModule.SpectatorTargetInfo",widgetData));
+    }
+
+    [Fact]
+    public async Task Sends_The_Widget_To_The_Given_Players_With_Arguments()
+    {
+        var spectatorLogins = new List<string> { "*fakeplayer1*", "*fakeplayer2*", };
+        var targetPlayer = new OnlinePlayer
+        {
+            State = PlayerState.Playing,
+            AccountId = "*fakeplayer99*",
+            NickName = "UnitTest",
+            Team = PlayerTeam.Team1
+        };
+
+        _matchSettingsService.Setup(mss => mss.GetCurrentModeAsync())
+            .ReturnsAsync(DefaultModeScriptName.Teams);
+        _server.Remote.Setup(remote => remote.GetTeamInfoAsync(1))
+            .ReturnsAsync(new TmTeamInfo { RGB = "FF0066" });
+        _server.Remote.Setup(remote => remote.GetTeamInfoAsync(2))
+            .ReturnsAsync(new TmTeamInfo { RGB = "111111" });
+
+        var spectatorTargetService = ServiceMock();
+        await spectatorTargetService.UpdateIsTeamsModeAsync();
+        await spectatorTargetService.FetchAndCacheTeamInfoAsync();
+        await spectatorTargetService.SendSpectatorInfoWidgetAsync(spectatorLogins, targetPlayer, 2, 150);
+
+        _manialinkManager.Verify(mm =>
+            mm.SendManialinkAsync("*fakeplayer1*", "SpectatorTargetInfoModule.SpectatorTargetInfo",
+                It.IsAny<object>()));
+        _manialinkManager.Verify(mm =>
+            mm.SendManialinkAsync("*fakeplayer2*", "SpectatorTargetInfoModule.SpectatorTargetInfo",
+                It.IsAny<object>()));
+    }
+
+    [Fact]
+    public async Task Sends_The_Widget_To_The_Given_Player_Without_Time_And_Checkpoint_Index()
+    {
+        var spectatorLogin = "*fakeplayer1*";
+        var targetPlayer = new OnlinePlayer
+        {
+            State = PlayerState.Playing,
+            AccountId = "*fakeplayer99*",
+            NickName = "UnitTest",
+            Team = PlayerTeam.Team1
+        };
+        var otherPlayer = new OnlinePlayer
+        {
+            State = PlayerState.Playing,
+            AccountId = "*fakeplayer98*",
+            NickName = "UnitTestOpponent",
+            Team = PlayerTeam.Team2
+        };
+
+        _matchSettingsService.Setup(mss => mss.GetCurrentModeAsync())
+            .ReturnsAsync(DefaultModeScriptName.Teams);
+        _server.Remote.Setup(remote => remote.GetTeamInfoAsync(1))
+            .ReturnsAsync(new TmTeamInfo { RGB = "FF0066" });
+        _playerManager.Setup(pm => pm.GetOnlinePlayerAsync(targetPlayer.AccountId))
+            .ReturnsAsync(targetPlayer);
+        _playerManager.Setup(pm => pm.GetOnlinePlayerAsync(otherPlayer.AccountId))
+            .ReturnsAsync(otherPlayer);
+
+        var spectatorTargetService = ServiceMock();
+        await spectatorTargetService.UpdateIsTeamsModeAsync();
+        await spectatorTargetService.FetchAndCacheTeamInfoAsync();
+
+        await spectatorTargetService.AddCheckpointAsync(otherPlayer.GetLogin(), 2, 1000);
+        await spectatorTargetService.AddCheckpointAsync(targetPlayer.GetLogin(), 2, 1234);
+        await spectatorTargetService.SendSpectatorInfoWidgetAsync(spectatorLogin, targetPlayer);
+        
+        _manialinkManager.Verify(mm =>
+            mm.SendManialinkAsync(spectatorLogin, "SpectatorTargetInfoModule.SpectatorTargetInfo", It.IsAny<object>()), Times.Once);
+    }
+
+    [Fact]
+    public async Task Resets_Widget_For_Spectators()
+    {
+        var spectatorLogin = "*fakeplayer1*";
+        var targetPlayer = new OnlinePlayer
+        {
+            State = PlayerState.Playing,
+            AccountId = "*fakeplayer99*",
+            NickName = "UnitTest",
+            Team = PlayerTeam.Team1
+        };
+
+        _matchSettingsService.Setup(mss => mss.GetCurrentModeAsync())
+            .ReturnsAsync(DefaultModeScriptName.Teams);
+        _server.Remote.Setup(remote => remote.GetTeamInfoAsync(1))
+            .ReturnsAsync(new TmTeamInfo { RGB = "FF0066" });
+        _playerManager.Setup(pm => pm.GetOnlinePlayerAsync(targetPlayer.AccountId))
+            .ReturnsAsync(targetPlayer);
+
+        var spectatorTargetService = ServiceMock();
+        await spectatorTargetService.UpdateIsTeamsModeAsync();
+        await spectatorTargetService.FetchAndCacheTeamInfoAsync();
+        await spectatorTargetService.SetSpectatorTargetAsync(spectatorLogin, targetPlayer.GetLogin());
+        await spectatorTargetService.ResetWidgetForSpectatorsAsync();
+
+        _manialinkManager.Verify(mm => mm.SendManialinkAsync(spectatorLogin,
+            "SpectatorTargetInfoModule.SpectatorTargetInfo",
+            It.IsAny<object>()));
+    }
+
+    [Fact]
+    public async Task Gets_Last_Checkpoint_Index_Of_Player()
+    {
+        var targetPlayer = new OnlinePlayer
+        {
+            State = PlayerState.Playing,
+            AccountId = "*fakeplayer99*",
+            NickName = "UnitTest",
+            Team = PlayerTeam.Team1
+        };
+
+        _playerManager.Setup(pm => pm.GetOnlinePlayerAsync(targetPlayer.AccountId))
+            .ReturnsAsync(targetPlayer);
+
+        var spectatorTargetService = ServiceMock();
+        await spectatorTargetService.AddCheckpointAsync(targetPlayer.GetLogin(), 1, 1000);
+        await spectatorTargetService.AddCheckpointAsync(targetPlayer.GetLogin(), 2, 2000);
+        await spectatorTargetService.AddCheckpointAsync(targetPlayer.GetLogin(), 3, 3000);
+        var checkpointIndex = spectatorTargetService.GetLastCheckpointIndexOfPlayer(targetPlayer);
+
+        Assert.Equal(3, checkpointIndex);
+    }
+}
diff --git a/tests/Modules/SpectatorTargetInfoModule.Tests/SpectatorTargetInfoModule.Tests.csproj b/tests/Modules/SpectatorTargetInfoModule.Tests/SpectatorTargetInfoModule.Tests.csproj
new file mode 100644
index 000000000..365d2c953
--- /dev/null
+++ b/tests/Modules/SpectatorTargetInfoModule.Tests/SpectatorTargetInfoModule.Tests.csproj
@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <RootNamespace>EvoSC.Modules.Official.SpectatorTargetInfoModule.Tests</RootNamespace>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0"/>
+        <PackageReference Include="xunit" Version="2.8.1"/>
+        <ProjectReference Include="..\..\..\src\EvoSC.Manialinks\EvoSC.Manialinks.csproj"/>
+        <ProjectReference Include="..\..\..\src\EvoSC.Testing\EvoSC.Testing.csproj"/>
+        <ProjectReference Include="..\..\..\src\Modules\SpectatorTargetInfoModule\SpectatorTargetInfoModule.csproj"/>
+    </ItemGroup>
+
+</Project>
diff --git a/tests/Modules/TeamChatModule.Tests/TeamChatModule.Tests.csproj b/tests/Modules/TeamChatModule.Tests/TeamChatModule.Tests.csproj
index 5532a94f2..c5823fc9d 100644
--- a/tests/Modules/TeamChatModule.Tests/TeamChatModule.Tests.csproj
+++ b/tests/Modules/TeamChatModule.Tests/TeamChatModule.Tests.csproj
@@ -1,35 +1,30 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
 
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-  </PropertyGroup>
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+    </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0"/>
-    <PackageReference Include="xunit" Version="2.4.2"/>
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.0">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-  </ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0"/>
+        <PackageReference Include="xunit" Version="2.4.2"/>
+        <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+        <PackageReference Include="coverlet.collector" Version="6.0.0">
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <PrivateAssets>all</PrivateAssets>
+        </PackageReference>
+    </ItemGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\..\..\src\Modules\TeamChatModule\TeamChatModule.csproj" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <Reference Include="Moq">
-      <HintPath>..\..\..\..\..\..\.nuget\packages\moq\4.20.70\lib\net6.0\Moq.dll</HintPath>
-    </Reference>
-  </ItemGroup>
+    <ItemGroup>
+        <ProjectReference Include="..\..\..\src\EvoSC.Testing\EvoSC.Testing.csproj"/>
+        <ProjectReference Include="..\..\..\src\Modules\TeamChatModule\TeamChatModule.csproj"/>
+    </ItemGroup>
 
 </Project>
diff --git a/tests/Modules/TeamInfoModule.Tests/Controllers/TeamInfoEventControllerTests.cs b/tests/Modules/TeamInfoModule.Tests/Controllers/TeamInfoEventControllerTests.cs
index 902fbbbc5..6d5597870 100644
--- a/tests/Modules/TeamInfoModule.Tests/Controllers/TeamInfoEventControllerTests.cs
+++ b/tests/Modules/TeamInfoModule.Tests/Controllers/TeamInfoEventControllerTests.cs
@@ -4,10 +4,12 @@
 using EvoSC.Common.Remote.EventArgsModels;
 using EvoSC.Modules.Official.TeamInfoModule.Controllers;
 using EvoSC.Modules.Official.TeamInfoModule.Interfaces;
+using EvoSC.Modules.Official.TeamInfoModule.Services;
 using EvoSC.Modules.Official.TeamSettingsModule.Events.EventArgs;
 using EvoSC.Modules.Official.TeamSettingsModule.Models;
 using EvoSC.Testing.Controllers;
 using GbxRemoteNet.Events;
+using Microsoft.Extensions.Logging;
 using Moq;
 using Xunit;