diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 905de6fc..f32064ec 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -59,7 +59,7 @@ jobs:
       # build to absorb transient feed flakiness without needing a
       # manual re-run.
       - name: Restore
-        uses: nick-fields/retry@v3
+        uses: nick-fields/retry@v4
         with:
           timeout_minutes: 10
           max_attempts: 3
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 252e5d74..05585963 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,14 @@
 
 All notable changes to Chromatics are documented here.
 
+## 4.3.4
+
+- Added new dynamic layers for Focus Target HP and Focus Target Castbar
+- Fixed a bug which caused the Experience Tracker layer to not work with Reaper and Sage.
+- Fixed the Keybinds layer misreading hotbar actions with high action ids.
+- Updated Sharlayan to latest version
+- Various performance improvements and bug fixes
+
 ## 4.2.73
 
 - Added support for FFXIV 7.51
diff --git a/Chromatics.DecoratorHarnessUI/MainViewModel.cs b/Chromatics.DecoratorHarnessUI/MainViewModel.cs
index 817d61da..fe7c4f8e 100644
--- a/Chromatics.DecoratorHarnessUI/MainViewModel.cs
+++ b/Chromatics.DecoratorHarnessUI/MainViewModel.cs
@@ -739,6 +739,18 @@ private void ApplyDefaults(EffectEntry effect)
             ParamWaveSpeed = snap.WaveSpeed; ParamWaveFreq = snap.WaveFreq;
             ParamFadeTime = snap.FadeTime; ParamGroupSize = snap.GroupSize;
             ParamBlockSize = snap.BlockSize; ParamBlocks = snap.Blocks; ParamSize = snap.Size;
+            ParamNumberOfLeds = snap.NumberOfLeds; ParamStepSpeed = snap.StepSpeed;
+            ParamSustain = snap.Sustain; ParamRelease = snap.Release; ParamRepetitions = snap.Repetitions;
+            ParamDirection = snap.Direction; ParamRandomise = snap.Randomise;
+            ParamTextureType = snap.TextureType; ParamDiagonalDir = snap.DiagonalDir; ParamFallDir = snap.FallDir;
+            ParamIntensity = snap.Intensity; ParamFlickerSpeed = snap.FlickerSpeed;
+            ParamBeamWidth = snap.BeamWidth; ParamPulseRadius = snap.PulseRadius; ParamFadeWidth = snap.FadeWidth;
+            ParamTailLength = snap.TailLength; ParamSpawnInterval = snap.SpawnInterval;
+            ParamRippleSpeed = snap.RippleSpeed; ParamLaserDir = snap.LaserDir;
+            ParamBpmSpeed = snap.BpmSpeed; ParamBeatsPerCycle = snap.BeatsPerCycle;
+            ParamSimultaneousBeams = snap.SimultaneousBeams; ParamFlickerOpacity = snap.FlickerOpacity;
+            ParamMatrixDir = snap.MatrixDir; ParamFadeBetween = snap.FadeBetween;
+            ParamAccentEvery = snap.AccentEvery; ParamDecay = snap.Decay; ParamWedgeDegrees = snap.WedgeDegrees;
             ColorBase = snap.Base;
             SetColors(snap.Colors);
             return;
@@ -1259,6 +1271,12 @@ private void SavePreset()
             ParamBpm, ParamSpeed, ParamInterval, ParamFadeSpeed, ParamDensity,
             ParamWaveSpeed, ParamWaveFreq, ParamFadeTime, ParamGroupSize,
             ParamBlockSize, ParamBlocks, ParamSize,
+            ParamNumberOfLeds, ParamStepSpeed, ParamSustain, ParamRelease, ParamRepetitions,
+            ParamDirection, ParamRandomise, ParamTextureType, ParamDiagonalDir, ParamFallDir,
+            ParamIntensity, ParamFlickerSpeed, ParamBeamWidth, ParamPulseRadius, ParamFadeWidth,
+            ParamTailLength, ParamSpawnInterval, ParamRippleSpeed, ParamLaserDir,
+            ParamBpmSpeed, ParamBeatsPerCycle, ParamSimultaneousBeams, ParamFlickerOpacity,
+            ParamMatrixDir, ParamFadeBetween, ParamAccentEvery, ParamDecay, ParamWedgeDegrees,
             ColorBase, ColorSlots.Select(s => s.Color).ToArray());
         _savedParams[name] = snap;
 
@@ -1273,6 +1291,12 @@ private record SavedParams(
         int Bpm, int Speed, double Interval, double FadeSpeed, double Density,
         double WaveSpeed, double WaveFreq, double FadeTime, int GroupSize,
         int BlockSize, int Blocks, int Size,
+        int NumberOfLeds, int StepSpeed, double Sustain, double Release, int Repetitions,
+        bool Direction, bool Randomise, string TextureType, string DiagonalDir, string FallDir,
+        double Intensity, double FlickerSpeed, double BeamWidth, double PulseRadius, double FadeWidth,
+        double TailLength, double SpawnInterval, double RippleSpeed, string LaserDir,
+        string BpmSpeed, double BeatsPerCycle, int SimultaneousBeams, double FlickerOpacity,
+        string MatrixDir, double FadeBetween, int AccentEvery, double Decay, double WedgeDegrees,
         AvColor Base, AvColor[] Colors);
 
     // ── Code snippet generator ──────────────────────────────────────────
diff --git a/Chromatics.Tests/Chromatics.Tests.csproj b/Chromatics.Tests/Chromatics.Tests.csproj
index a957dfc5..565fe1ce 100644
--- a/Chromatics.Tests/Chromatics.Tests.csproj
+++ b/Chromatics.Tests/Chromatics.Tests.csproj
@@ -38,7 +38,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Sharlayan" Version="9.0.39" />
+    <PackageReference Include="Sharlayan" Version="9.1.1-prerelease.58" />
   </ItemGroup>
 
 </Project>
diff --git a/Chromatics/Chromatics.csproj b/Chromatics/Chromatics.csproj
index 5b42a532..925d42ca 100644
--- a/Chromatics/Chromatics.csproj
+++ b/Chromatics/Chromatics.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
@@ -10,7 +10,7 @@
     <TargetFramework>net10.0-windows10.0.19041.0</TargetFramework>
     <SupportedOSPlatformVersion>10.0.17763.0</SupportedOSPlatformVersion>
     <StartupObject>Chromatics.Program</StartupObject>
-    <Version>4.2.73.0</Version>
+    <Version>4.3.4.0</Version>
     <Authors>Danielle Thompson</Authors>
     <!-- ApplicationManifest is conditional: local Debug + Release builds embed
          app.manifest (no fusion-identity <msix> element) so VS debug runs and
@@ -133,7 +133,7 @@
     <PackageReference Include="RGB.NET.Devices.Wooting" Version="3.2.0" />
     <PackageReference Include="RGB.NET.HID" Version="3.2.0" />
     <PackageReference Include="RGB.NET.Presets" Version="3.2.0" />
-    <PackageReference Include="Sharlayan" Version="9.0.39" />
+    <PackageReference Include="Sharlayan" Version="9.1.1-prerelease.58" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Chromatics/Core/GameController.cs b/Chromatics/Core/GameController.cs
index f8c8f794..700e6fa2 100644
--- a/Chromatics/Core/GameController.cs
+++ b/Chromatics/Core/GameController.cs
@@ -45,7 +45,6 @@ public static class GameController
         private static int activeProcessId = -1;
         private static bool gameConnected;
         private static bool gameSetup;
-        private static bool memoryEfficientLoop;
         private static bool _isInGame;
         private static bool _onTitle;
         private static bool wasPreviewed;
@@ -386,18 +385,6 @@ private static async Task GameLoop(CancellationToken cancellationToken)
 
                 // Wait for the interval before continuing
                 var delay = _loopInterval;
-                memoryEfficientLoop = false;
-
-                if (memoryEfficientLoop)
-                {
-                    var currentCpuUsage = SystemMonitorHelper.GetCurrentCpuUsage();
-                    var _maxCpuUsage = SystemMonitorHelper.GetMaxCpuUsage();
-
-                    if (currentCpuUsage > _maxCpuUsage)
-                    {
-                        delay += (int)(currentCpuUsage - _maxCpuUsage) * 10;
-                    }
-                }
 
                 await Task.Delay(delay, cancellationToken).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
                 if (cancellationToken.IsCancellationRequested || _isShuttingDown) break;
@@ -559,8 +546,6 @@ private static void GameProcessLayers()
                     var getCurrentPlayer = handler.Reader.GetCurrentPlayer();
                     var isLoggedIn = handler.Reader.GetGameState().IsLoggedIn;
 
-                    var runningEffects = RGBController.GetRunningEffects();
-
                     // Title-screen detection: player entity not loaded AND
                     // not logged in. Debounced via _titleStateConsecutiveTicks
                     // so a brief Entity-null window during zone-in doesn't
@@ -656,7 +641,7 @@ private static void GameProcessLayers()
                                         g?.RemoveAllDecorators();
                                         g?.Detach();
                                     }
-                                    liveGroups.Remove(layer.layerID);
+                                    liveGroups.TryRemove(layer.layerID, out _);
                                 }
                             }
                             baseProcessor.Process(layer);
@@ -679,7 +664,7 @@ private static void GameProcessLayers()
                                 {
                                     foreach (var g in prevGroups)
                                         g?.Detach();
-                                    liveGroups.Remove(layer.layerID);
+                                    liveGroups.TryRemove(layer.layerID, out _);
                                 }
                                 // Per-processor model cleanup (overridden on JobGaugeA/B/C).
                                 foreach (var p in _layerProcessorFactory.GetActiveDynamicProcessors())
@@ -753,7 +738,7 @@ private static void GameProcessLayers()
                                         g?.RemoveAllDecorators();
                                         g?.Detach();
                                     }
-                                    effectLiveGroups.Remove(layer.layerID);
+                                    effectLiveGroups.TryRemove(layer.layerID, out _);
                                 }
                             }
                             var effectProcessors = EffectLayerProcessorFactory.GetProcessors();
diff --git a/Chromatics/Core/RGBController.cs b/Chromatics/Core/RGBController.cs
index ce9309f2..da46b7a4 100644
--- a/Chromatics/Core/RGBController.cs
+++ b/Chromatics/Core/RGBController.cs
@@ -49,6 +49,7 @@ public static class RGBController
         private static readonly System.Threading.Lock _devicesLock = new();
         private static Dictionary<Guid, IRGBDevice> _devices = new Dictionary<Guid, IRGBDevice>();
 
+        private static readonly System.Threading.Lock _activeDevicesLock = new();
         private static Dictionary<IRGBDevice, bool> _activeDevices = new Dictionary<IRGBDevice, bool>();
 
         // Per-device brightness corrections, keyed by the device GUID stamped in
@@ -73,7 +74,11 @@ private static readonly System.Collections.Concurrent.ConcurrentDictionary<Guid,
         private static readonly Dictionary<string, Dictionary<Guid, ListLedGroup>> _taggedEffectsByDevice = new();
         private static readonly System.Threading.Lock _taggedEffectsLock = new();
 
-        private static Dictionary<int, ListLedGroup[]> _layergroups = new Dictionary<int, ListLedGroup[]>();
+        // ConcurrentDictionary because the game-loop thread mutates this while
+        // RaidEffectProcessor / GoldSaucerVegas read it from the RGB.NET timer
+        // thread via surface.Updating.
+        private static readonly System.Collections.Concurrent.ConcurrentDictionary<int, ListLedGroup[]> _layergroups
+            = new System.Collections.Concurrent.ConcurrentDictionary<int, ListLedGroup[]>();
 
         private static List<Led> _layergroupledcollection = new List<Led>();
 
@@ -81,6 +86,7 @@ private static readonly System.Collections.Concurrent.ConcurrentDictionary<Guid,
 
         private static EffectTypesModel _effects = new EffectTypesModel();
 
+        private static readonly System.Threading.Lock _runningEffectsLock = new();
         private static List<ListLedGroup> _runningEffects = new List<ListLedGroup>();
 
         private static bool _baseLayerEffectRunning;
@@ -700,14 +706,12 @@ public static void RemoveDevice(IRGBDevice device)
 
                 surface.Detach(device);
 
-
-                if (_activeDevices.ContainsKey(device))
-                {
-                    _activeDevices[device] = false;
-                }
-                else
+                lock (_activeDevicesLock)
                 {
-                    _activeDevices.Add(device, false);
+                    if (_activeDevices.ContainsKey(device))
+                        _activeDevices[device] = false;
+                    else
+                        _activeDevices.Add(device, false);
                 }
 
             }
@@ -825,13 +829,12 @@ public static void AddDevice(IRGBDevice device)
                 // as the surface.Update flush above lands. No equivalent
                 // power-on call needed.
 
-                if (_activeDevices.ContainsKey(device))
-                {
-                    _activeDevices[device] = true;
-                }
-                else
+                lock (_activeDevicesLock)
                 {
-                    _activeDevices.Add(device, true);
+                    if (_activeDevices.ContainsKey(device))
+                        _activeDevices[device] = true;
+                    else
+                        _activeDevices.Add(device, true);
                 }
 
             }
@@ -974,13 +977,12 @@ private static void DevicesChanged(object sender, DevicesChangedEventArgs e)
                     Logger.WriteConsole(Enums.LoggerTypes.Devices, $"Found {device.DeviceInfo.Manufacturer} {device.DeviceInfo.DeviceType}: {device.DeviceInfo.DeviceName}.");
                 #endif
 
-                if (_activeDevices.ContainsKey(device))
+                lock (_activeDevicesLock)
                 {
-                    _activeDevices[device] = !isDisabled;
-                }
-                else
-                {
-                    _activeDevices.Add(device, !isDisabled);
+                    if (_activeDevices.ContainsKey(device))
+                        _activeDevices[device] = !isDisabled;
+                    else
+                        _activeDevices.Add(device, !isDisabled);
                 }
 
                 // Hot-plug into a running startup animation: rebuild the
@@ -1031,13 +1033,12 @@ private static void DevicesChanged(object sender, DevicesChangedEventArgs e)
                         _devices.Remove(guid);
                 }
 
-                if (_activeDevices.ContainsKey(device))
+                lock (_activeDevicesLock)
                 {
-                    _activeDevices[device] = false;
-                }
-                else
-                {
-                    _activeDevices.Add(device, false);
+                    if (_activeDevices.ContainsKey(device))
+                        _activeDevices[device] = false;
+                    else
+                        _activeDevices.Add(device, false);
                 }
 
                 DeviceConnectionChanged?.Invoke(null, EventArgs.Empty);
@@ -1194,10 +1195,13 @@ public static bool LoadDeviceProvider(IRGBDeviceProvider provider, out Exception
                             hueDev.SetPerDeviceDisabled(true);
                         else if (device is Extensions.RGB.NET.Devices.QmkRawHid.QmkRawHidDevice qmkDev)
                             qmkDev.SetPerDeviceDisabled(true);
-                        if (_activeDevices.ContainsKey(device))
-                            _activeDevices[device] = false;
-                        else
-                            _activeDevices.Add(device, false);
+                        lock (_activeDevicesLock)
+                        {
+                            if (_activeDevices.ContainsKey(device))
+                                _activeDevices[device] = false;
+                            else
+                                _activeDevices.Add(device, false);
+                        }
                     }
 
                     if (_loaded)
@@ -1314,7 +1318,8 @@ public static void UnloadDeviceProvider(IRGBDeviceProvider provider, bool remove
                                 _devices.Remove(key);
                         }
 
-                        _activeDevices.Remove(device);
+                        lock (_activeDevicesLock)
+                            _activeDevices.Remove(device);
                         anyRemoved = true;
                     }
 
@@ -1469,7 +1474,8 @@ private static void SyncTaggedEffectForDevice(string tag, Guid deviceGuid, IRGBD
                     if (_taggedEffectsByDevice.TryGetValue(tag, out var byDevice))
                         byDevice.Remove(deviceGuid);
                 }
-                _runningEffects.Remove(existing);
+                lock (_runningEffectsLock)
+                    _runningEffects.Remove(existing);
                 try { existing.RemoveAllDecorators(); } catch { }
                 try { existing.Detach(); } catch { }
             }
@@ -1578,7 +1584,14 @@ public static void StopEffects(bool gameFirstConnected = false)
                 SetIdleUpdateRate(false);
             }
 
-            foreach (var effects in _runningEffects)
+            List<ListLedGroup> snapshot;
+            lock (_runningEffectsLock)
+            {
+                snapshot = new List<ListLedGroup>(_runningEffects);
+                _runningEffects.Clear();
+            }
+
+            foreach (var effects in snapshot)
             {
                 foreach (var decorator in effects.Decorators)
                 {
@@ -1589,8 +1602,6 @@ public static void StopEffects(bool gameFirstConnected = false)
                 effects.Detach();
             }
 
-            _runningEffects.Clear();
-
             // Clear all tagged-effect lists too. The groups they pointed at
             // are now detached (above), so any future StopTaggedEffects(tag)
             // would no-op anyway — but keeping the dict in sync prevents
@@ -1630,7 +1641,8 @@ public static void RegisterTaggedEffect(string tag, Guid deviceGuid, ListLedGrou
                     byDevice[deviceGuid] = group;
                 }
             }
-            _runningEffects.Add(group);
+            lock (_runningEffectsLock)
+                _runningEffects.Add(group);
         }
 
         // Tear down ONLY the groups registered under `tag` — used when the
@@ -1691,11 +1703,14 @@ public static void StopTaggedEffects(string tag)
             // Force a render so the black hits hardware before we detach.
             try { surface?.Update(); } catch { }
 
-            foreach (var g in snapshot)
+            lock (_runningEffectsLock)
             {
-                g.Detach();
-                _runningEffects.Remove(g);
+                foreach (var g in snapshot)
+                    _runningEffects.Remove(g);
             }
+
+            foreach (var g in snapshot)
+                g.Detach();
         }
 
         public static bool IsBaseLayerEffectRunning()
@@ -1708,6 +1723,10 @@ public static void SetBaseLayerEffect(bool toggle)
             _baseLayerEffectRunning = toggle;
         }
 
+        // Returns the LIVE list, not a snapshot — ReactiveWeather, RaidEffect
+        // and CutsceneAnimation register their groups by mutating it from the
+        // game-loop thread. Internal teardown paths snapshot under
+        // _runningEffectsLock so they can't crash on a concurrent mutation.
         public static List<ListLedGroup> GetRunningEffects()
         {
             return _runningEffects;
@@ -1726,7 +1745,8 @@ public static Dictionary<Guid, IRGBDevice> GetLiveDevices()
 
         public static Dictionary<IRGBDevice, bool> GetActiveDevices()
         {
-            return _activeDevices;
+            lock (_activeDevicesLock)
+                return new Dictionary<IRGBDevice, bool>(_activeDevices);
         }
 
         public static List<IRGBDeviceProvider> GetDeviceProviders()
@@ -1739,26 +1759,25 @@ public static List<Led> GetLiveLayerGroupCollection()
             return _layergroupledcollection;
         }
 
-        public static Dictionary<int, ListLedGroup[]> GetLiveLayerGroups()
+        public static System.Collections.Concurrent.ConcurrentDictionary<int, ListLedGroup[]> GetLiveLayerGroups()
         {
             return _layergroups;
         }
 
         public static void RemoveLayerGroup(int targetId)
         {
-            if (_layergroups.ContainsKey(targetId))
+            // Remove before detaching so the timer-thread readers never see a
+            // half-detached group set.
+            if (_layergroups.TryRemove(targetId, out var removedGroups))
             {
-                foreach (var layer in _layergroups[targetId])
+                foreach (var layer in removedGroups)
                 {
                     layer.RemoveAllDecorators();
                     layer.Detach();
 
-                    if (_runningEffects.Contains(layer))
+                    lock (_runningEffectsLock)
                         _runningEffects.Remove(layer);
                 }
-                
-                _layergroups.Remove(targetId);
-                               
             }
         }
 
@@ -1778,7 +1797,8 @@ public static void ResetLayerGroups()
                 mapping.Value.requestUpdate = true;
             }
 
-            _runningEffects.Clear();
+            lock (_runningEffectsLock)
+                _runningEffects.Clear();
             _layergroups.Clear();
             _layergroupledcollection.Clear();
         }
diff --git a/Chromatics/Core/SentryService.cs b/Chromatics/Core/SentryService.cs
index 8116bfe9..e763d58d 100644
--- a/Chromatics/Core/SentryService.cs
+++ b/Chromatics/Core/SentryService.cs
@@ -221,119 +221,127 @@ private static void StartHeartbeat()
             // Interval is every 60s — enough to populate the Performance tab
             // and provide profile samples without eating quota.
             _heartbeatTimer?.Dispose();
-            _heartbeatTimer = new System.Threading.Timer(_ =>
+            _heartbeatTimer = new System.Threading.Timer(
+                _ => _ = RunHeartbeatAsync(),
+                null,
+                TimeSpan.FromSeconds(HeartbeatInitialDelaySeconds),
+                TimeSpan.FromSeconds(HeartbeatIntervalSeconds));
+        }
+
+        private static async System.Threading.Tasks.Task RunHeartbeatAsync()
+        {
+            try
             {
+                if (!SentrySdk.IsEnabled) return;
+                // Consent gate: no telemetry during normal runtime when
+                // opted out. Transactions are also dropped by
+                // BeforeSendTransaction, but skipping the work entirely
+                // saves the allocation + profiler overhead.
+                var s = _settings;
+                if (s != null && !s.enableCrashReports) return;
+
+                // NOTE: requires the Sentry project's "Filter out health
+                // check transactions" inbound filter to be DISABLED.
+                // That filter regex-matches transaction names containing
+                // health / heart / ping / alive / ready and silently
+                // drops the entire envelope server-side regardless of
+                // transaction shape, scope binding, or measurements.
+                // If app.heartbeat events stop arriving, check that
+                // filter first (Project Settings → Inbound Filters).
+                var tx = SentrySdk.StartTransaction("app.heartbeat", "task");
+                tx.Description = "Periodic process-metrics heartbeat";
+
+                // Bind to the active scope so the transaction inherits
+                // the scope's tags (channel/language/admin from
+                // ApplySettings) and so any breadcrumbs / spans
+                // generated inside `work` automatically attach. Mirrors
+                // RunInstrumented's pattern (which is what app.startup
+                // uses).
+                SentrySdk.ConfigureScope(scope => scope.Transaction = tx);
+
+                var span = tx.StartChild("metrics.collect", "collect process metrics");
                 try
                 {
-                    if (!SentrySdk.IsEnabled) return;
-                    // Consent gate: no telemetry during normal runtime when
-                    // opted out. Transactions are also dropped by
-                    // BeforeSendTransaction, but skipping the work entirely
-                    // saves the allocation + profiler overhead.
-                    var s = _settings;
-                    if (s != null && !s.enableCrashReports) return;
-
-                    // NOTE: requires the Sentry project's "Filter out health
-                    // check transactions" inbound filter to be DISABLED.
-                    // That filter regex-matches transaction names containing
-                    // health / heart / ping / alive / ready and silently
-                    // drops the entire envelope server-side regardless of
-                    // transaction shape, scope binding, or measurements.
-                    // If app.heartbeat events stop arriving, check that
-                    // filter first (Project Settings → Inbound Filters).
-                    var tx = SentrySdk.StartTransaction("app.heartbeat", "task");
-                    tx.Description = "Periodic process-metrics heartbeat";
-
-                    // Bind to the active scope so the transaction inherits
-                    // the scope's tags (channel/language/admin from
-                    // ApplySettings) and so any breadcrumbs / spans
-                    // generated inside `work` automatically attach. Mirrors
-                    // RunInstrumented's pattern (which is what app.startup
-                    // uses).
-                    SentrySdk.ConfigureScope(scope => scope.Transaction = tx);
-
-                    var span = tx.StartChild("metrics.collect", "collect process metrics");
-                    try
+                    using var p = System.Diagnostics.Process.GetCurrentProcess();
+
+                    long workingSetMb = p.WorkingSet64 / 1024 / 1024;
+                    long privateMb = p.PrivateMemorySize64 / 1024 / 1024;
+                    long managedHeapMb = GC.GetTotalMemory(forceFullCollection: false) / 1024 / 1024;
+                    int gc0 = GC.CollectionCount(0);
+                    int gc1 = GC.CollectionCount(1);
+                    int gc2 = GC.CollectionCount(2);
+                    int threads = p.Threads.Count;
+
+                    // Measurements: numeric, unit-aware values that
+                    // Sentry plots as time series in the transaction
+                    // detail view and that are queryable via
+                    // `measurements.<name>:>=<value>` in the Trace
+                    // Explorer. Proper primitive for "stat that varies
+                    // per transaction" — the ingest-side equivalent of
+                    // a Prometheus gauge.
+                    tx.SetMeasurement("working_set_mb", workingSetMb, MeasurementUnit.Information.Megabyte);
+                    tx.SetMeasurement("private_memory_mb", privateMb, MeasurementUnit.Information.Megabyte);
+                    tx.SetMeasurement("managed_heap_mb", managedHeapMb, MeasurementUnit.Information.Megabyte);
+                    tx.SetMeasurement("gc_gen0", gc0, MeasurementUnit.None);
+                    tx.SetMeasurement("gc_gen1", gc1, MeasurementUnit.None);
+                    tx.SetMeasurement("gc_gen2", gc2, MeasurementUnit.None);
+                    tx.SetMeasurement("thread_count", threads, MeasurementUnit.None);
+
+                    // Span data: same numeric values mirrored on the
+                    // child span so the event-detail "Additional Data"
+                    // panel surfaces them in-place rather than only via
+                    // the Measurements section.
+                    span.SetData("working_set_mb", workingSetMb);
+                    span.SetData("private_memory_mb", privateMb);
+                    span.SetData("managed_heap_mb", managedHeapMb);
+                    span.SetData("gc_gen0", gc0);
+                    span.SetData("gc_gen1", gc1);
+                    span.SetData("gc_gen2", gc2);
+                    span.SetData("thread_count", threads);
+
+                    // CPU usage: percent of a single core used since the
+                    // last heartbeat. Divided by core count so 100% = one
+                    // core fully saturated, capped across many-core
+                    // machines. First sample is 0 (no baseline delta).
+                    var now = DateTime.UtcNow;
+                    var cpuTime = p.TotalProcessorTime;
+                    if (_lastSampleTime != DateTime.MinValue)
                     {
-                        using var p = System.Diagnostics.Process.GetCurrentProcess();
-
-                        long workingSetMb = p.WorkingSet64 / 1024 / 1024;
-                        long privateMb = p.PrivateMemorySize64 / 1024 / 1024;
-                        long managedHeapMb = GC.GetTotalMemory(forceFullCollection: false) / 1024 / 1024;
-                        int gc0 = GC.CollectionCount(0);
-                        int gc1 = GC.CollectionCount(1);
-                        int gc2 = GC.CollectionCount(2);
-                        int threads = p.Threads.Count;
-
-                        // Measurements: numeric, unit-aware values that
-                        // Sentry plots as time series in the transaction
-                        // detail view and that are queryable via
-                        // `measurements.<name>:>=<value>` in the Trace
-                        // Explorer. Proper primitive for "stat that varies
-                        // per transaction" — the ingest-side equivalent of
-                        // a Prometheus gauge.
-                        tx.SetMeasurement("working_set_mb", workingSetMb, MeasurementUnit.Information.Megabyte);
-                        tx.SetMeasurement("private_memory_mb", privateMb, MeasurementUnit.Information.Megabyte);
-                        tx.SetMeasurement("managed_heap_mb", managedHeapMb, MeasurementUnit.Information.Megabyte);
-                        tx.SetMeasurement("gc_gen0", gc0, MeasurementUnit.None);
-                        tx.SetMeasurement("gc_gen1", gc1, MeasurementUnit.None);
-                        tx.SetMeasurement("gc_gen2", gc2, MeasurementUnit.None);
-                        tx.SetMeasurement("thread_count", threads, MeasurementUnit.None);
-
-                        // Span data: same numeric values mirrored on the
-                        // child span so the event-detail "Additional Data"
-                        // panel surfaces them in-place rather than only via
-                        // the Measurements section.
-                        span.SetData("working_set_mb", workingSetMb);
-                        span.SetData("private_memory_mb", privateMb);
-                        span.SetData("managed_heap_mb", managedHeapMb);
-                        span.SetData("gc_gen0", gc0);
-                        span.SetData("gc_gen1", gc1);
-                        span.SetData("gc_gen2", gc2);
-                        span.SetData("thread_count", threads);
-
-                        // CPU usage: percent of a single core used since the
-                        // last heartbeat. Divided by core count so 100% = one
-                        // core fully saturated, capped across many-core
-                        // machines. First sample is 0 (no baseline delta).
-                        var now = DateTime.UtcNow;
-                        var cpuTime = p.TotalProcessorTime;
-                        if (_lastSampleTime != DateTime.MinValue)
+                        var cpuDelta = (cpuTime - _lastProcessorTime).TotalMilliseconds;
+                        var wallDelta = (now - _lastSampleTime).TotalMilliseconds;
+                        if (wallDelta > 0)
                         {
-                            var cpuDelta = (cpuTime - _lastProcessorTime).TotalMilliseconds;
-                            var wallDelta = (now - _lastSampleTime).TotalMilliseconds;
-                            if (wallDelta > 0)
-                            {
-                                var cores = Math.Max(1, Environment.ProcessorCount);
-                                var cpuPct = Math.Round(Math.Clamp((cpuDelta / (wallDelta * cores)) * 100.0, 0, 100), 1);
-                                tx.SetMeasurement("cpu_percent", cpuPct, MeasurementUnit.Fraction.Percent);
-                                span.SetData("cpu_percent", cpuPct);
-                            }
+                            var cores = Math.Max(1, Environment.ProcessorCount);
+                            var cpuPct = Math.Round(Math.Clamp((cpuDelta / (wallDelta * cores)) * 100.0, 0, 100), 1);
+                            tx.SetMeasurement("cpu_percent", cpuPct, MeasurementUnit.Fraction.Percent);
+                            span.SetData("cpu_percent", cpuPct);
                         }
-                        _lastProcessorTime = cpuTime;
-                        _lastSampleTime = now;
-
-                        // Wall-clock duration similar to app.startup (~1.5s).
-                        // Runs on the thread pool — zero impact on UI.
-                        System.Threading.Thread.Sleep(1500);
                     }
-                    catch { /* non-critical */ }
-                    span.Finish(SpanStatus.Ok);
-                    tx.Finish(SpanStatus.Ok);
-
-                    // Detach the transaction from scope so subsequent
-                    // unrelated events don't inherit a stale trace context.
-                    SentrySdk.ConfigureScope(scope => scope.Transaction = null);
-
-                    // Force-flush so the envelope leaves the process now
-                    // rather than sitting in the SDK's background queue.
-                    // For a 1/min cadence on an app that the user might
-                    // close at any moment, an explicit flush guarantees
-                    // each tick reaches the backend.
-                    try { SentrySdk.FlushAsync(TimeSpan.FromSeconds(2)).GetAwaiter().GetResult(); } catch { }
+                    _lastProcessorTime = cpuTime;
+                    _lastSampleTime = now;
+
+                    // Keep the transaction span open ~1.5s so the profiler
+                    // collects samples comparable to app.startup duration.
+                    // Uses async delay so the thread-pool thread is released
+                    // during the wait rather than blocked.
+                    await System.Threading.Tasks.Task.Delay(1500).ConfigureAwait(false);
                 }
-                catch { /* heartbeat must never throw */ }
-            }, null, TimeSpan.FromSeconds(HeartbeatInitialDelaySeconds), TimeSpan.FromSeconds(HeartbeatIntervalSeconds));
+                catch { /* non-critical */ }
+                span.Finish(SpanStatus.Ok);
+                tx.Finish(SpanStatus.Ok);
+
+                // Detach the transaction from scope so subsequent
+                // unrelated events don't inherit a stale trace context.
+                SentrySdk.ConfigureScope(scope => scope.Transaction = null);
+
+                // Force-flush so the envelope leaves the process now
+                // rather than sitting in the SDK's background queue.
+                // For a 1/min cadence on an app that the user might
+                // close at any moment, an explicit flush guarantees
+                // each tick reaches the backend.
+                try { await SentrySdk.FlushAsync(TimeSpan.FromSeconds(2)).ConfigureAwait(false); } catch { }
+            }
+            catch { /* heartbeat must never throw */ }
         }
 
         /// <summary>
diff --git a/Chromatics/Enums/LayerTypes.cs b/Chromatics/Enums/LayerTypes.cs
index ac23586b..7419ea27 100644
--- a/Chromatics/Enums/LayerTypes.cs
+++ b/Chromatics/Enums/LayerTypes.cs
@@ -69,7 +69,11 @@ public enum DynamicLayerType
         [LayerDisplay(Name = "Job Classes Highlight", Description = "Displays different colours across selected keys depending on the character's current class.\nUses highlight layer colours.", LayerTypeCompatibility = new LayerModes[]{ LayerModes.None })]
         JobClassesHighlight = 14,
         [LayerDisplay(Name = "Reactive Weather Highlight", Description = "Displays different colours across selected keys depending on current weather.\nUses highlight layer colours.", LayerTypeCompatibility = new LayerModes[]{ LayerModes.None })]
-        ReactiveWeatherHighlight = 15
+        ReactiveWeatherHighlight = 15,
+        [LayerDisplay(Name = "Focus Target HP", Description = "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]", LayerTypeCompatibility = new LayerModes[]{ LayerModes.Interpolate, LayerModes.Fade })]
+        FocusTargetHP = 16,
+        [LayerDisplay(Name = "Focus Target Castbar", Description = "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]", LayerTypeCompatibility = new LayerModes[]{ LayerModes.Interpolate, LayerModes.Fade })]
+        FocusTargetCastbar = 17
     };
     public enum EffectLayerType
     {
diff --git a/Chromatics/Extensions/RGB.NET/Decorators/ArenaLightShowDecorator.cs b/Chromatics/Extensions/RGB.NET/Decorators/ArenaLightShowDecorator.cs
index 2b7b209e..b324bf4d 100644
--- a/Chromatics/Extensions/RGB.NET/Decorators/ArenaLightShowDecorator.cs
+++ b/Chromatics/Extensions/RGB.NET/Decorators/ArenaLightShowDecorator.cs
@@ -83,9 +83,9 @@ protected override void Update(double deltaTime)
                     var color = Lerp(currentColor, nextColor, (float)intensity);
 
                     var newCol = new Color(
-                        (int)(color.R * 255 * intensity + baseColor.R * (1 - intensity)),
-                        (int)(color.G * 255 * intensity + baseColor.G * (1 - intensity)),
-                        (int)(color.B * 255 * intensity + baseColor.B * (1 - intensity))
+                        (int)(color.R * 255 * intensity + baseColor.R * 255 * (1 - intensity)),
+                        (int)(color.G * 255 * intensity + baseColor.G * 255 * (1 - intensity)),
+                        (int)(color.B * 255 * intensity + baseColor.B * 255 * (1 - intensity))
                     );
 
                     led.Color = newCol;
diff --git a/Chromatics/Extensions/RGB.NET/Decorators/PulseDecorator.cs b/Chromatics/Extensions/RGB.NET/Decorators/PulseDecorator.cs
index 1bad1304..bbbcda77 100644
--- a/Chromatics/Extensions/RGB.NET/Decorators/PulseDecorator.cs
+++ b/Chromatics/Extensions/RGB.NET/Decorators/PulseDecorator.cs
@@ -81,6 +81,9 @@ public override void OnDetached(IDecoratable decoratable)
 
         protected override void Update(double deltaTime)
         {
+            if (savedColors == null || fadingInLeds == null || fadingOutLeds == null || currentColors == null) return;
+            try
+            {
             // increment the Timing variable
             Timing += deltaTime;
 
@@ -381,7 +384,12 @@ protected override void Update(double deltaTime)
                 led.Key.Color = led.Value;
                 //Surface.Update(true);
             }
-            
+
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"Exception: {ex.Message}");
+            }
         }
 
 
diff --git a/Chromatics/Extensions/RGB.NET/Decorators/StrobeDecorator.cs b/Chromatics/Extensions/RGB.NET/Decorators/StrobeDecorator.cs
index 601b7121..d25fbacb 100644
--- a/Chromatics/Extensions/RGB.NET/Decorators/StrobeDecorator.cs
+++ b/Chromatics/Extensions/RGB.NET/Decorators/StrobeDecorator.cs
@@ -75,144 +75,152 @@ public override void OnDetached(IDecoratable decoratable)
 
         protected override void Update(double deltaTime)
         {
-            // increment the Timing variable
-            Timing += deltaTime;
-
-            var minBrightness = 0;
-            var maxBrightness = 1;
-
-            if (Timing >= startDelay)
+            if (fadingInLeds == null || fadingOutLeds == null) return;
+            try
             {
-                var availableLeds = ledGroup.Where(led => !fadingInLeds.ContainsKey(led) && !fadingOutLeds.ContainsKey(led));
+                // increment the Timing variable
+                Timing += deltaTime;
 
-                foreach (var led in availableLeds)
+                var minBrightness = 0;
+                var maxBrightness = 1;
+
+                if (Timing >= startDelay)
                 {
-                    
-                    fadingInLeds.TryAdd(led, baseColor);
+                    var availableLeds = ledGroup.Where(led => !fadingInLeds.ContainsKey(led) && !fadingOutLeds.ContainsKey(led));
+
+                    foreach (var led in availableLeds)
+                    {
 
-                    var colorIndex = random.Next(colors.Length);
+                        fadingInLeds.TryAdd(led, baseColor);
 
-                    if (!currentColors.ContainsKey(led))
-                        currentColors.Add(led, colors[colorIndex]);
+                        var colorIndex = random.Next(colors.Length);
 
-                    
-                }
+                        if (!currentColors.ContainsKey(led))
+                            currentColors.Add(led, colors[colorIndex]);
 
-                // Update startDelay to be a few milliseconds earlier than the current interval
-                if (!oneshot)
-                {
-                    if (randomise)
-                    {
-                        var rng = GetRandomStartTime();
 
-                        if (GetRandomBoolean(0.35))
+                    }
+
+                    // Update startDelay to be a few milliseconds earlier than the current interval
+                    if (!oneshot)
+                    {
+                        if (randomise)
                         {
-                            startDelay = Timing + (fadeSpeed / 1000);
+                            var rng = GetRandomStartTime();
+
+                            if (GetRandomBoolean(0.35))
+                            {
+                                startDelay = Timing + (fadeSpeed / 1000);
+                            }
+                            else
+                            {
+                                startDelay = Timing + (rng / 1000);
+                            }
+
+
                         }
                         else
                         {
-                            startDelay = Timing + (rng / 1000);
+                            startDelay = Timing + (interval / 1000);
                         }
-
-                    
-                    }
-                    else
-                    {
-                        startDelay = Timing + (interval / 1000);
                     }
-                }
-                
-            }
 
-            foreach (var led in fadingInLeds)
-            {
-                // check if the current brightness of the LED is already stored in the dictionary
-                if (!currentBrightness.ContainsKey(led.Key))
-                {
-                    // if not, add the current brightness of the LED to the dictionary
-                    currentBrightness.Add(led.Key, minBrightness);
                 }
 
-                // increment the current brightness of the LED
-                currentBrightness[led.Key] += (float)(deltaTime * (maxBrightness - minBrightness) / (fadeSpeed / 1000));
-
-                // check if the current brightness of the LED has reached the max brightness
-                if (currentBrightness[led.Key] >= maxBrightness)
+                foreach (var led in fadingInLeds)
                 {
-                    // if it has, add the LED to the list of fading out LEDs
-                    fadingOutLeds.TryAdd(led.Key, currentColors[led.Key]);
+                    // check if the current brightness of the LED is already stored in the dictionary
+                    if (!currentBrightness.ContainsKey(led.Key))
+                    {
+                        // if not, add the current brightness of the LED to the dictionary
+                        currentBrightness.Add(led.Key, minBrightness);
+                    }
 
-                    // remove the LED from the list of fading in LEDs
-                    fadingInLeds.TryRemove(led);
-                }
-                else
-                {
-                    // if not, choose a random color from the passed in color array
-                    
-                    
-                    var lerpAmount = Map(currentBrightness[led.Key], minBrightness, maxBrightness, 0, 1);
-                    var color = Lerp(baseColor, currentColors[led.Key], lerpAmount);
-                    fadingInLeds[led.Key] = color;
+                    // increment the current brightness of the LED
+                    currentBrightness[led.Key] += (float)(deltaTime * (maxBrightness - minBrightness) / (fadeSpeed / 1000));
 
-                }
-            }
+                    // check if the current brightness of the LED has reached the max brightness
+                    if (currentBrightness[led.Key] >= maxBrightness)
+                    {
+                        // if it has, add the LED to the list of fading out LEDs
+                        fadingOutLeds.TryAdd(led.Key, currentColors[led.Key]);
 
-            // iterate through the list of fading out LEDs
-            foreach (var led in fadingOutLeds)
-            {
-                // check if the current brightness of the LED is already stored in the dictionary
-                if (!currentBrightness.ContainsKey(led.Key))
-                {
-                    // if not, add the current brightness of the LED to the dictionary
-                    currentBrightness.Add(led.Key, maxBrightness);
-                }
+                        // remove the LED from the list of fading in LEDs
+                        fadingInLeds.TryRemove(led);
+                    }
+                    else
+                    {
+                        // if not, choose a random color from the passed in color array
 
-                // decrement the current brightness of the LED
-                currentBrightness[led.Key] -= (float)(deltaTime * (maxBrightness - minBrightness) / (fadeSpeed / 1000));
 
-                // check if the current brightness of the LED has reached the min brightness
-                if (currentBrightness[led.Key] <= minBrightness)
-                {
-                    // if it has, remove the LED from the list of fading out LEDs
-                    fadingOutLeds.TryRemove(led);
-                    currentBrightness.Remove(led.Key);
-                    currentColors.Remove(led.Key);
-                    startTimes.Remove(led.Key);
+                        var lerpAmount = Map(currentBrightness[led.Key], minBrightness, maxBrightness, 0, 1);
+                        var color = Lerp(baseColor, currentColors[led.Key], lerpAmount);
+                        fadingInLeds[led.Key] = color;
 
-                    if (fadingInLeds.ContainsKey(led.Key))
-                        fadingInLeds.TryRemove(led);
+                    }
                 }
-                else
+
+                // iterate through the list of fading out LEDs
+                foreach (var led in fadingOutLeds)
                 {
-                    // if not, set the LED's color to the base color with the current brightness
-                    var lerpAmount = Map(currentBrightness[led.Key], minBrightness, maxBrightness, 0, 1);
-                    var color = Lerp(baseColor, currentColors[led.Key], lerpAmount);
-                    fadingOutLeds[led.Key] = color;
+                    // check if the current brightness of the LED is already stored in the dictionary
+                    if (!currentBrightness.ContainsKey(led.Key))
+                    {
+                        // if not, add the current brightness of the LED to the dictionary
+                        currentBrightness.Add(led.Key, maxBrightness);
+                    }
+
+                    // decrement the current brightness of the LED
+                    currentBrightness[led.Key] -= (float)(deltaTime * (maxBrightness - minBrightness) / (fadeSpeed / 1000));
+
+                    // check if the current brightness of the LED has reached the min brightness
+                    if (currentBrightness[led.Key] <= minBrightness)
+                    {
+                        // if it has, remove the LED from the list of fading out LEDs
+                        fadingOutLeds.TryRemove(led);
+                        currentBrightness.Remove(led.Key);
+                        currentColors.Remove(led.Key);
+                        startTimes.Remove(led.Key);
+
+                        if (fadingInLeds.ContainsKey(led.Key))
+                            fadingInLeds.TryRemove(led);
+                    }
+                    else
+                    {
+                        // if not, set the LED's color to the base color with the current brightness
+                        var lerpAmount = Map(currentBrightness[led.Key], minBrightness, maxBrightness, 0, 1);
+                        var color = Lerp(baseColor, currentColors[led.Key], lerpAmount);
+                        fadingOutLeds[led.Key] = color;
 
+                    }
                 }
-            }
 
 
-            foreach (var led in ledGroup)
-            {
-                if (fadingInLeds.ContainsKey(led))
+                foreach (var led in ledGroup)
                 {
-                    led.Color = fadingInLeds[led];
+                    if (fadingInLeds.ContainsKey(led))
+                    {
+                        led.Color = fadingInLeds[led];
+                    }
+                    else if (fadingOutLeds.ContainsKey(led))
+                    {
+                        led.Color = fadingOutLeds[led];
+                    }
+                    else
+                    {
+                        led.Color = baseColor;
+                    }
+
                 }
-                else if (fadingOutLeds.ContainsKey(led))
-                {
-                    led.Color = fadingOutLeds[led];
-                } 
-                else
+
+                if (fadingOutLeds.Count == 0 && oneshot)
                 {
-                    led.Color = baseColor;
+                    Detach();
                 }
-                    
             }
-
-            if (fadingOutLeds.Count == 0 && oneshot)
+            catch (Exception ex)
             {
-                Detach();
+                Debug.WriteLine($"Exception: {ex.Message}");
             }
         }
 
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareUpdateQueue.cs
index dc7f6e85..009d5416 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Alienware/AlienwareUpdateQueue.cs
@@ -6,6 +6,7 @@
 using RGB.NET.Core;
 using System;
 using System.Collections.Generic;
+using System.Runtime.InteropServices;
 using System.Threading;
 using Color = RGB.NET.Core.Color;
 
@@ -37,6 +38,16 @@ public class AlienwareUpdateQueue : UpdateQueue
         // per frame.
         private byte _v8BatchCounter;
 
+        // Reused per-frame dirty-index list. Cleared at the start of each
+        // Update() call. Safe to reuse because Update() runs serially
+        // under _lock on the trigger thread.
+        private readonly List<int> _dirty = new();
+
+        // Reused colour-grouping dictionary for the V4 zone send path.
+        // Cleared on each SendV4Frame call to avoid per-frame dictionary
+        // allocation. Safe because SendV4Frame runs serially under _lock.
+        private readonly Dictionary<uint, List<byte>> _v4ByColor = new();
+
         #endregion
 
         #region Constructors
@@ -109,8 +120,10 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
 
                     // Patch dirty lights into the per-light cache. Track
                     // the dirty index list so we only resend lights whose
-                    // value changed.
-                    var dirty = new List<int>(dataSet.Length);
+                    // value changed. _dirty is a pre-allocated reusable
+                    // field; it is safe because Update() runs serially
+                    // under _lock on the trigger thread.
+                    _dirty.Clear();
                     foreach (var (key, color) in dataSet)
                     {
                         int idx = ResolveLightIndex(key);
@@ -123,21 +136,21 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                         _ledBytes[off]     = r;
                         _ledBytes[off + 1] = g;
                         _ledBytes[off + 2] = b;
-                        dirty.Add(idx);
+                        _dirty.Add(idx);
                     }
 
-                    if (dirty.Count == 0) return true;
+                    if (_dirty.Count == 0) return true;
 
                     switch (_def.ApiVersion)
                     {
                         case AlienwareApiVersion.PerKeyV5:
-                            SendV5Frame(dirty);
+                            SendV5Frame(_dirty);
                             break;
                         case AlienwareApiVersion.PerKeyV8:
-                            SendV8Frame(dirty);
+                            SendV8Frame(_dirty);
                             break;
                         case AlienwareApiVersion.ZoneV4:
-                            SendV4Frame(dirty);
+                            SendV4Frame(_dirty);
                             break;
                         default:
                             // Unknown version — silent no-op so we don't
@@ -258,15 +271,17 @@ private void SendV4Frame(List<int> dirty)
 
             // Group dirty lights by colour so lights sharing a colour go
             // out in one HID write rather than N. Common case for static
-            // overlays / single-colour layers.
-            var byColor = new Dictionary<uint, List<byte>>();
+            // overlays / single-colour layers. Reuse _v4ByColor to avoid
+            // per-frame dictionary allocation. Safe because SendV4Frame
+            // runs serially under _lock on the trigger thread.
+            _v4ByColor.Clear();
             foreach (int idx in dirty)
             {
                 int off = idx * 3;
                 byte r = _ledBytes[off], g = _ledBytes[off + 1], b = _ledBytes[off + 2];
                 uint packed = (uint)((r << 16) | (g << 8) | b);
-                if (!byColor.TryGetValue(packed, out var list))
-                    byColor[packed] = list = new List<byte>(dirty.Count);
+                if (!_v4ByColor.TryGetValue(packed, out var list))
+                    _v4ByColor[packed] = list = new List<byte>(dirty.Count);
                 list.Add((byte)idx);
             }
 
@@ -274,18 +289,19 @@ private void SendV4Frame(List<int> dirty)
             // (ReportLength=34 minus 8-byte header). Split colour groups
             // larger than that across multiple writes.
             const int maxIdsPerWrite = 34 - 8;
-            foreach (var kvp in byColor)
+            foreach (var kvp in _v4ByColor)
             {
                 byte r = (byte)((kvp.Key >> 16) & 0xFF);
                 byte g = (byte)((kvp.Key >> 8) & 0xFF);
                 byte b = (byte)(kvp.Key & 0xFF);
                 var ids = kvp.Value;
+                var idsSpan = CollectionsMarshal.AsSpan(ids);
                 for (int start = 0; start < ids.Count; start += maxIdsPerWrite)
                 {
                     int chunk = Math.Min(maxIdsPerWrite, ids.Count - start);
                     AlienwareZoneV4Protocol.BuildSetColor(
                         buffer, r, g, b,
-                        new ReadOnlySpan<byte>(ids.GetRange(start, chunk).ToArray()));
+                        idsSpan.Slice(start, chunk));
                     WriteOutputReport(buffer);
                 }
             }
diff --git a/Chromatics/Extensions/RGB.NET/Devices/DynamicLighting/DynamicLightingUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/DynamicLighting/DynamicLightingUpdateQueue.cs
index fb5e2060..fe1a8239 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/DynamicLighting/DynamicLightingUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/DynamicLighting/DynamicLightingUpdateQueue.cs
@@ -143,11 +143,18 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                     // WinRT call. Cheaper than N SetSingleColor calls
                     // (one IPC trip vs N), and the WinRT layer batches
                     // the underlying HID multi-update reports for us.
-                    var indicesSlice = new int[dirtyCount];
-                    var colorsSlice = new WinColor[dirtyCount];
-                    Array.Copy(_dirtyIndicesBuffer, indicesSlice, dirtyCount);
-                    Array.Copy(_dirtyColorsBuffer, colorsSlice, dirtyCount);
-                    lampArray.SetColorsForIndices(colorsSlice, indicesSlice);
+                    // The pre-allocated buffers are passed whole to avoid a
+                    // per-frame slice allocation, so the tail beyond
+                    // dirtyCount is padded with copies of entry 0. Leaving
+                    // stale entries there instead would repaint a lamp with
+                    // an OLDER colour whenever its position in the dirty
+                    // ordering drops between frames.
+                    for (int i = dirtyCount; i < _lampCount; i++)
+                    {
+                        _dirtyIndicesBuffer[i] = _dirtyIndicesBuffer[0];
+                        _dirtyColorsBuffer[i] = _dirtyColorsBuffer[0];
+                    }
+                    lampArray.SetColorsForIndices(_dirtyColorsBuffer, _dirtyIndicesBuffer);
                     return true;
                 }
                 catch (Exception ex)
diff --git a/Chromatics/Extensions/RGB.NET/Devices/EVision/EVisionUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/EVision/EVisionUpdateQueue.cs
index 13480aa4..342d1a90 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/EVision/EVisionUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/EVision/EVisionUpdateQueue.cs
@@ -43,6 +43,12 @@ public class EVisionUpdateQueue : UpdateQueue
         // ACK buffer reused across reads.
         private readonly byte[] _ackBuffer = new byte[EVisionKeyboardProtocol.ReportLength];
 
+        // Write buffer reused across all WriteAndAck calls in a single
+        // frame. Avoids the per-call buf.ToArray() heap allocation.
+        // Safe because WriteAndAck runs serially under _lock on the
+        // trigger thread.
+        private readonly byte[] _writeBuffer = new byte[EVisionKeyboardProtocol.ReportLength];
+
         #endregion
 
         #region Constructors
@@ -165,10 +171,10 @@ private bool SendFrame()
 
         private bool WriteAndAck(ReadOnlySpan<byte> buf)
         {
-            byte[] arr = buf.ToArray();
+            buf.CopyTo(_writeBuffer);
             try
             {
-                _stream.Write(arr);
+                _stream.Write(_writeBuffer);
                 // ReadExactly because the firmware returns a fixed 64-byte
                 // ACK per packet; partial reads would mean we'd accept the
                 // next write before the device finished signalling.
diff --git a/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxUpdateQueue.cs
index 0d982d78..93b12c2b 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/LIFX/LifxUpdateQueue.cs
@@ -6,6 +6,7 @@
 using RGB.NET.Core;
 using System;
 using System.Buffers.Binary;
+using System.Collections.Generic;
 using System.Net.Sockets;
 using System.Threading;
 using System.Threading.Tasks;
@@ -241,6 +242,11 @@ public async Task RestoreOriginalStateAsync(CancellationToken ct = default)
 
         protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
         {
+            // Multizone extended chunks are collected inside the lock and
+            // sent outside it so that ResetCache (called from the Avalonia
+            // UI thread on device re-enable) doesn't wait behind the
+            // Thread.Sleep(30) pacing that sits between each chunk.
+            List<byte[]> deferredChunks = null;
             lock (_lock)
             {
                 if (_shuttingDown || _perDeviceDisable) return true;
@@ -260,18 +266,22 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
 
                     if (isMultizone)
                     {
-                        SendMultizoneFrame(dataSet, brightnessScale);
+                        // Collect packets inside the lock (patching _strip),
+                        // but send them below outside the lock so ResetCache
+                        // on the UI thread doesn't block behind the 30ms sleeps.
+                        deferredChunks = CollectMultizoneChunks(dataSet, brightnessScale);
+                        // Fall through to post-lock send.
                     }
                     else if (_product.IsMatrix)
                     {
                         SendMatrixFrame(dataSet, brightnessScale);
+                        return true;
                     }
                     else
                     {
                         SendSingleColorFrame(dataSet, brightnessScale);
+                        return true;
                     }
-
-                    return true;
                 }
                 catch (Exception ex)
                 {
@@ -279,6 +289,28 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                     return false;
                 }
             }
+
+            // Send dirty chunks with 30ms inter-chunk pacing outside _lock.
+            // Sparse updates (1-2 zones change in starfield) dirty 1 chunk →
+            // 1 packet, no sleep. Dense updates (gradient sweep) dirty all
+            // chunks → 30ms pacing keeps them under the firmware burst-drop
+            // threshold (6ms wasn't enough; 30ms × 3 = 90ms total send time
+            // leaves the trigger thread ~10ms of slack within a 100ms budget).
+            if (deferredChunks == null || deferredChunks.Count == 0) return true;
+
+            bool firstSent = true;
+            foreach (var chunk in deferredChunks)
+            {
+                if (!firstSent)
+                {
+                    if (_shuttingDown || _perDeviceDisable) return true;
+                    Thread.Sleep(30);
+                }
+                firstSent = false;
+                if (_shuttingDown || _perDeviceDisable) return true;
+                SendPacket(chunk);
+            }
+            return true;
         }
 
         private void SendSingleColorFrame(ReadOnlySpan<(object key, Color color)> dataSet, double brightnessScale)
@@ -319,7 +351,13 @@ private void SendSingleColorFrame(ReadOnlySpan<(object key, Color color)> dataSe
         private byte[] _strip;       // persistent zone HSBK state, [zoneCount * 8] bytes
         private int _stripZones;     // cached zone count for _strip's allocation
 
-        private void SendMultizoneFrame(ReadOnlySpan<(object key, Color color)> dataSet, double brightnessScale)
+        // Builds the per-chunk packets for a multizone frame and returns them
+        // for deferred sending outside _lock. The _strip state is patched
+        // here (inside the lock) so the persistent zone cache stays consistent.
+        // Returns null when the legacy (non-extended) path is used — legacy
+        // packets are sent immediately inside the lock because that path has
+        // no inter-chunk sleep.
+        private List<byte[]> CollectMultizoneChunks(ReadOnlySpan<(object key, Color color)> dataSet, double brightnessScale)
         {
             int zones = _def.ZoneCount > 0 ? _def.ZoneCount : 1;
             if (_strip == null || _stripZones != zones)
@@ -354,34 +392,29 @@ private void SendMultizoneFrame(ReadOnlySpan<(object key, Color color)> dataSet,
             }
 
             // Devices flagged as non-extended in the catalog use legacy
-            // SetColorZones (run-length-encoded over the full strip).
+            // SetColorZones (run-length-encoded over the full strip). That
+            // path sends multiple small packets without any inter-packet
+            // sleep so it can stay inside the lock.
             if (_product.IsMultizone && !_product.IsExtendedMultizone)
             {
                 bool anyDirty = false;
                 foreach (var d in chunkDirty) if (d) { anyDirty = true; break; }
                 if (anyDirty) SendLegacyMultizoneFrame(_strip, zones);
-                return;
+                return null;
             }
 
-            // Send each dirty chunk, paced. Sparse updates (1-2 zones
-            // change in starfield) typically dirty 1 chunk → 1 packet, no
-            // pacing. Dense updates (gradient sweep) dirty all chunks →
-            // 30ms pacing keeps them under the firmware's burst-drop
-            // threshold (6ms wasn't enough; 30ms × 3 = 90ms total send
-            // time leaves the trigger thread ~10ms of slack within a 100ms
-            // budget).
-            bool firstSent = true;
+            // Build each dirty chunk's packet while we still hold _lock
+            // (so _strip can't be reset mid-build). Return the list for
+            // paced sending outside _lock in Update().
+            var packets = new List<byte[]>(chunkCount);
             for (int c = 0; c < chunkCount; c++)
             {
                 if (!chunkDirty[c]) continue;
-
-                if (!firstSent) Thread.Sleep(30);
-                firstSent = false;
-
                 int start = c * ChunkSize;
                 int count = Math.Min(ChunkSize, zones - start);
-                SendExtendedChunk(_strip, start, count, durationMs: 150);
+                packets.Add(BuildExtendedChunkPacket(_strip, start, count, durationMs: 150));
             }
+            return packets;
         }
 
         private static int ZoneIndexFromKey(object key)
@@ -394,7 +427,7 @@ private static int ZoneIndexFromKey(object key)
             };
         }
 
-        private void SendExtendedChunk(byte[] frame, int start, int count, uint durationMs)
+        private byte[] BuildExtendedChunkPacket(byte[] frame, int start, int count, uint durationMs)
         {
             byte[] payload = new byte[8 + count * 8];
             BinaryPrimitives.WriteUInt32LittleEndian(payload.AsSpan(0, 4), durationMs);
@@ -402,9 +435,12 @@ private void SendExtendedChunk(byte[] frame, int start, int count, uint duration
             BinaryPrimitives.WriteUInt16LittleEndian(payload.AsSpan(5, 2), (ushort)start);
             payload[7] = (byte)count;
             Array.Copy(frame, start * 8, payload, 8, count * 8);
+            return BuildPacket(LifxMessageTypes.SetExtendedColorZones, payload);
+        }
 
-            byte[] packet = BuildPacket(LifxMessageTypes.SetExtendedColorZones, payload);
-            SendPacket(packet);
+        private void SendExtendedChunk(byte[] frame, int start, int count, uint durationMs)
+        {
+            SendPacket(BuildExtendedChunkPacket(frame, start, count, durationMs));
         }
 
         // Legacy SetColorZones path: one packet per run of consecutive
diff --git a/Chromatics/Extensions/RGB.NET/Devices/QmkRawHid/QmkRawHidUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/QmkRawHid/QmkRawHidUpdateQueue.cs
index 49f2dd9a..1728d83b 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/QmkRawHid/QmkRawHidUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/QmkRawHid/QmkRawHidUpdateQueue.cs
@@ -52,6 +52,11 @@ public class QmkRawHidUpdateQueue : UpdateQueue
         private readonly int _inputReportByteLength;
         private readonly int _payloadOutBytes;
 
+        // Pre-allocated output buffer for the VIA path. Only ever written on
+        // the update thread (inside _lock), so no additional synchronisation
+        // is needed.
+        private byte[] _outBuf;
+
         #endregion
 
         #region Constructors
@@ -67,6 +72,7 @@ public QmkRawHidUpdateQueue(IDeviceUpdateTrigger trigger, QmkRawHidClientDefinit
             _ledIndexByLedId = new Dictionary<LedId, int>(def.Layout.Count);
             for (int i = 0; i < def.Layout.Count; i++)
                 _ledIndexByLedId[def.Layout[i].PreferredLedId] = def.Layout[i].FirmwareIndex;
+            _outBuf = new byte[_outputReportByteLength];
         }
 
         #endregion
@@ -124,6 +130,10 @@ public void SetPerDeviceBrightness(PerDeviceBrightnessCorrection correction)
 
         protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
         {
+            // For OpenRGB-QMK, dirty chunks are collected inside the lock
+            // and sent outside it so that ResetCache / BeginShutdown don't
+            // block behind the 1ms inter-chunk pacing sleeps.
+            OpenRgbPendingWrite pending = default;
             lock (_lock)
             {
                 if (_shuttingDown || _perDeviceDisable) return true;
@@ -136,11 +146,15 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                     double brightnessScale = (globalPct / 100.0) * (perDevicePct / 100.0);
 
                     if (_def.Protocol == QmkRawHidProtocolMode.OpenRgbQmk)
-                        SendOpenRgbQmkFrame(dataSet, brightnessScale);
+                    {
+                        pending = CollectOpenRgbQmkChunks(dataSet, brightnessScale);
+                        // Fall through to send pending packets outside the lock.
+                    }
                     else
+                    {
                         SendViaFrame(dataSet, brightnessScale);
-
-                    return true;
+                        return true;
+                    }
                 }
                 catch (Exception ex)
                 {
@@ -148,6 +162,30 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                     return false;
                 }
             }
+
+            if (pending.Packets == null) return true;
+
+            for (int i = 0; i < pending.Packets.Length; i++)
+            {
+                if (_shuttingDown || _perDeviceDisable) return true;
+                if (i > 0) Thread.Sleep(1);
+                WritePayload(pending.Packets[i]);
+            }
+
+            if (pending.LogFirst)
+                Logger.WriteVerbose(
+                    $"[QMK] {_def.Product}: first paint frame — {pending.Packets.Length} SET_LEDS packet(s), {pending.ChunkSize} LEDs/packet, first LED RGB = ({pending.FirstR}, {pending.FirstG}, {pending.FirstB}).");
+
+            return true;
+        }
+
+        // Deferred write descriptor for the OpenRGB-QMK chunked path.
+        private struct OpenRgbPendingWrite
+        {
+            public byte[][] Packets;
+            public int ChunkSize;
+            public bool LogFirst;
+            public byte FirstR, FirstG, FirstB;
         }
 
         // ── VIA path (Tier 1: single representative colour) ──────────
@@ -163,7 +201,7 @@ private void SendViaFrame(ReadOnlySpan<(object key, Color color)> dataSet, doubl
             if (hash == _lastViaHsbHash) return;
             _lastViaHsbHash = hash;
 
-            byte[] outBuf = new byte[_outputReportByteLength];
+            byte[] outBuf = _outBuf;
 
             ViaProtocol.BuildSetRgbMatrixEffect(new Span<byte>(outBuf, 1, _payloadOutBytes), ViaProtocol.Effect_SolidColor);
             WritePayload(outBuf);
@@ -177,10 +215,15 @@ private void SendViaFrame(ReadOnlySpan<(object key, Color color)> dataSet, doubl
 
         // ── OpenRGB-QMK path (Tier 2: per-LED) ───────────────────────
 
-        private void SendOpenRgbQmkFrame(ReadOnlySpan<(object key, Color color)> dataSet, double brightnessScale)
+        // Collect all dirty-chunk packets under the caller's lock. The actual
+        // I/O + inter-chunk pacing happens in Update() after the lock is
+        // released, keeping ResetCache / BeginShutdown from blocking behind
+        // the sleep loop.
+        private OpenRgbPendingWrite CollectOpenRgbQmkChunks(
+            ReadOnlySpan<(object key, Color color)> dataSet, double brightnessScale)
         {
             int total = _def.LedCount;
-            if (total <= 0) return;
+            if (total <= 0) return default;
 
             if (_ledBytes == null) _ledBytes = new byte[total * 3];
 
@@ -215,31 +258,42 @@ private void SendOpenRgbQmkFrame(ReadOnlySpan<(object key, Color color)> dataSet
                 dirty[idx / chunkSize] = true;
             }
 
-            byte[] outBuf = new byte[_outputReportByteLength];
-            bool first = true;
-            int packetsSent = 0;
+            int dirtyCount = 0;
+            for (int c = 0; c < chunkCount; c++)
+                if (dirty[c]) dirtyCount++;
+
+            if (dirtyCount == 0) return default;
+
+            bool logFirst = !_firstFrameLogged;
+            if (logFirst) _firstFrameLogged = true;
+
+            // Build the pre-filled packet array under the lock. Each packet
+            // is a separate byte[] so the caller can send them with arbitrary
+            // pacing without holding the lock or re-entering it.
+            byte[][] packets = new byte[dirtyCount][];
+            int pIdx = 0;
             for (int c = 0; c < chunkCount; c++)
             {
                 if (!dirty[c]) continue;
-                if (!first) Thread.Sleep(1);
-                first = false;
-
                 int start = c * chunkSize;
                 int count = Math.Min(chunkSize, total - start);
+                byte[] pkt = new byte[_outputReportByteLength];
                 OpenRgbQmkProtocol.BuildDirectModeSetLeds(
-                    new Span<byte>(outBuf, 1, _payloadOutBytes),
+                    new Span<byte>(pkt, 1, _payloadOutBytes),
                     (byte)start, (byte)count,
                     new ReadOnlySpan<byte>(_ledBytes, start * 3, count * 3));
-                WritePayload(outBuf);
-                packetsSent++;
+                packets[pIdx++] = pkt;
             }
 
-            if (!_firstFrameLogged && packetsSent > 0)
+            return new OpenRgbPendingWrite
             {
-                _firstFrameLogged = true;
-                Logger.WriteVerbose(
-                    $"[QMK] {_def.Product}: first paint frame — {packetsSent} SET_LEDS packet(s), {chunkSize} LEDs/packet, first LED RGB = ({_ledBytes[0]}, {_ledBytes[1]}, {_ledBytes[2]}).");
-            }
+                Packets   = packets,
+                ChunkSize = chunkSize,
+                LogFirst  = logFirst,
+                FirstR    = _ledBytes[0],
+                FirstG    = _ledBytes[1],
+                FirstB    = _ledBytes[2],
+            };
         }
 
         private bool _firstFrameLogged;
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Redragon/RedragonUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/Redragon/RedragonUpdateQueue.cs
index c395011f..283c885f 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Redragon/RedragonUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Redragon/RedragonUpdateQueue.cs
@@ -35,6 +35,11 @@ public class RedragonUpdateQueue : UpdateQueue
         private volatile bool _perDeviceDisable;
         private bool _initialized;
 
+        // Pre-allocated staging buffer for HID feature reports. HidSharp's
+        // SetFeature requires a byte[]; we copy the stackalloc span into this
+        // buffer instead of allocating a new array on every write.
+        private readonly byte[] _featureReportBuffer = new byte[RedragonMouseProtocol.ReportLength];
+
         private PerDeviceBrightnessCorrection _perDeviceBrightness;
 
         // Last frame's RGB triplet. Used to skip the two-report HID write
@@ -166,16 +171,16 @@ private bool SendColorFrame(byte r, byte g, byte b)
             return SendFeatureReport(buf);
         }
 
-        // HidSharp's SetFeature wants a byte[]. Allocate once per write —
-        // single-LED firmware writes are infrequent enough that pooling
-        // would be overkill. Returns false on any I/O failure so the
-        // caller can short-circuit the rest of the frame.
+        // HidSharp's SetFeature wants a byte[]. Copy into _featureReportBuffer
+        // to avoid a heap allocation on every write.
+        // Returns false on any I/O failure so the caller can short-circuit
+        // the rest of the frame.
         private bool SendFeatureReport(ReadOnlySpan<byte> buf)
         {
-            byte[] arr = buf.ToArray();
+            buf.CopyTo(_featureReportBuffer);
             try
             {
-                _stream.SetFeature(arr);
+                _stream.SetFeature(_featureReportBuffer);
                 return true;
             }
             catch (System.IO.IOException ex)
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Yeelight/Protocol/YeelightConnection.cs b/Chromatics/Extensions/RGB.NET/Devices/Yeelight/Protocol/YeelightConnection.cs
index b7082df8..aa7b7588 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Yeelight/Protocol/YeelightConnection.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Yeelight/Protocol/YeelightConnection.cs
@@ -120,7 +120,7 @@ public async Task<bool> EnterMusicModeAsync(IPAddress localAddress, TimeSpan acc
                 using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                 cts.CancelAfter(acceptTimeout);
 
-                Task<TcpClient> acceptTask = listener.AcceptTcpClientAsync();
+                Task<TcpClient> acceptTask = listener.AcceptTcpClientAsync(cts.Token).AsTask();
                 Task winner = await Task.WhenAny(acceptTask, Task.Delay(acceptTimeout, cts.Token)).ConfigureAwait(false);
 
                 if (winner == acceptTask && acceptTask.IsCompletedSuccessfully)
@@ -131,6 +131,12 @@ public async Task<bool> EnterMusicModeAsync(IPAddress localAddress, TimeSpan acc
                     return true;
                 }
 
+                // Accept lost the race — observe the task and discard any
+                // late-arriving connection so the socket isn't leaked.
+                _ = acceptTask.ContinueWith(
+                    t => { try { t.Result?.Dispose(); } catch { /* discard */ } },
+                    TaskContinuationOptions.OnlyOnRanToCompletion);
+
                 // Reverse connect didn't happen in time. Tell the bulb to
                 // turn Music Mode back off so we don't sit in a half-state.
                 try
diff --git a/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightUpdateQueue.cs b/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightUpdateQueue.cs
index b0283c9c..719d5e66 100644
--- a/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightUpdateQueue.cs
+++ b/Chromatics/Extensions/RGB.NET/Devices/Yeelight/YeelightUpdateQueue.cs
@@ -25,6 +25,11 @@ public class YeelightUpdateQueue : UpdateQueue
         // dropped while the user has the bulb disabled in the Mapping tab.
         private volatile bool _perDeviceDisable;
 
+        // Latches after the first failed send is surfaced so a bulb that
+        // stays unreachable doesn't repeat the device error every retry
+        // interval. Cleared by the next successful send.
+        private bool _sendFaultSurfaced;
+
         private PerDeviceBrightnessCorrection _perDeviceBrightness;
 
         // Throttle: Yeelight LAN protocol caps outbound commands at 60 per
@@ -157,7 +162,13 @@ protected override bool Update(ReadOnlySpan<(object key, Color color)> dataSet)
                             byte r = (byte)((_lastSentRgbMain >> 16) & 0xFF);
                             byte g = (byte)((_lastSentRgbMain >> 8) & 0xFF);
                             byte b = (byte)(_lastSentRgbMain & 0xFF);
-                            _ = _connection.SetRgbAsync(r, g, b);
+                            _connection.SetRgbAsync(r, g, b).ContinueWith(t =>
+                            {
+                                if (t.IsCompletedSuccessfully)
+                                    lock (_lock) _sendFaultSurfaced = false;
+                                else
+                                    SurfaceSendFault(t.Exception);
+                            }, TaskContinuationOptions.ExecuteSynchronously);
                         }
                     }
                     return true;
@@ -210,9 +221,28 @@ private static YeelightDevice.LightChannel ResolveChannel(object key)
             return YeelightDevice.LightChannel.MainLight;
         }
 
+        // Surfaces a failed send through the provider error path, at most
+        // once per outage so a bulb that stays unreachable doesn't repeat
+        // the error every retry interval.
+        private void SurfaceSendFault(AggregateException ex)
+        {
+            lock (_lock)
+            {
+                if (_sendFaultSurfaced) return;
+                _sendFaultSurfaced = true;
+            }
+            if (ex != null)
+                YeelightRGBDeviceProvider.Instance?.Throw(ex.InnerException ?? ex);
+        }
+
         // Send one channel (main or bg). Returns through `sent` whether any
         // network traffic actually fired; caller uses this for the keep-alive
         // and lastSendMs bookkeeping.
+        //
+        // Dedup state is only updated on successful I/O: the ContinueWith
+        // continuations write the new value on success, or reset the cached
+        // value on failure so the next frame retries. Both paths surface
+        // exceptions through the provider error route without blocking.
         private void SendChannel(Color color, double brightnessScale, bool isBackground,
                                  ref uint lastSentRgb, ref int lastSentBrightness, out bool sent)
         {
@@ -226,16 +256,62 @@ private void SendChannel(Color color, double brightnessScale, bool isBackground,
 
             if (changedRgb)
             {
-                if (isBackground) _ = _connection.SetBackgroundRgbAsync(r, g, b);
-                else              _ = _connection.SetRgbAsync(r, g, b);
-                lastSentRgb = packed;
+                Task rgbTask = isBackground
+                    ? _connection.SetBackgroundRgbAsync(r, g, b)
+                    : _connection.SetRgbAsync(r, g, b);
+                uint capturedPacked = packed;
+                rgbTask.ContinueWith(t =>
+                {
+                    if (t.IsCompletedSuccessfully)
+                    {
+                        lock (_lock)
+                        {
+                            if (isBackground) _lastSentRgbBg    = capturedPacked;
+                            else              _lastSentRgbMain   = capturedPacked;
+                            _sendFaultSurfaced = false;
+                        }
+                    }
+                    else
+                    {
+                        // Reset so the next frame retries rather than silently
+                        // skipping a colour the bulb never received.
+                        lock (_lock)
+                        {
+                            if (isBackground) _lastSentRgbBg    = uint.MaxValue;
+                            else              _lastSentRgbMain   = uint.MaxValue;
+                        }
+                        SurfaceSendFault(t.Exception);
+                    }
+                }, TaskContinuationOptions.ExecuteSynchronously);
                 sent = true;
             }
             if (changedBright)
             {
-                if (isBackground) _ = _connection.SetBackgroundBrightnessAsync(brightnessPct);
-                else              _ = _connection.SetBrightnessAsync(brightnessPct);
-                lastSentBrightness = brightnessPct;
+                Task brightTask = isBackground
+                    ? _connection.SetBackgroundBrightnessAsync(brightnessPct)
+                    : _connection.SetBrightnessAsync(brightnessPct);
+                int capturedBrightness = brightnessPct;
+                brightTask.ContinueWith(t =>
+                {
+                    if (t.IsCompletedSuccessfully)
+                    {
+                        lock (_lock)
+                        {
+                            if (isBackground) _lastSentBrightnessBg   = capturedBrightness;
+                            else              _lastSentBrightnessMain  = capturedBrightness;
+                            _sendFaultSurfaced = false;
+                        }
+                    }
+                    else
+                    {
+                        lock (_lock)
+                        {
+                            if (isBackground) _lastSentBrightnessBg   = -1;
+                            else              _lastSentBrightnessMain  = -1;
+                        }
+                        SurfaceSendFault(t.Exception);
+                    }
+                }, TaskContinuationOptions.ExecuteSynchronously);
                 sent = true;
             }
         }
diff --git a/Chromatics/Extensions/RGB.NET/Gradients/RectangularGradient.cs b/Chromatics/Extensions/RGB.NET/Gradients/RectangularGradient.cs
index bc456ef1..d67b6e62 100644
--- a/Chromatics/Extensions/RGB.NET/Gradients/RectangularGradient.cs
+++ b/Chromatics/Extensions/RGB.NET/Gradients/RectangularGradient.cs
@@ -28,7 +28,7 @@ public RectangularGradient(System.Drawing.Color topLeft, System.Drawing.Color to
         public override Color GetColor(float value) 
         {
             var x = value % 1;
-            var y = (int)value / 1;
+            var y = value % 1;
             System.Drawing.Color c1 = System.Drawing.Color.FromArgb(
                 (int) (topLeft.R + (topRight.R - topLeft.R) * x),
                 (int) (topLeft.G + (topRight.G - topLeft.G) * x),
diff --git a/Chromatics/Helpers/DictionaryConverter.cs b/Chromatics/Helpers/DictionaryConverter.cs
index f92b54f6..6d941c50 100644
--- a/Chromatics/Helpers/DictionaryConverter.cs
+++ b/Chromatics/Helpers/DictionaryConverter.cs
@@ -76,7 +76,7 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
                                      : dictionaryTypes.Where(z => z.IsGenericTypeDefinition)
                                                       .FirstOrDefault();
 
-                if (dictionaryType == null) dictionaryTypes.First();
+                if (dictionaryType == null) dictionaryType = dictionaryTypes.First();
 
                 keyType = !dictionaryType.IsGenericType
                               ? typeof(object)
diff --git a/Chromatics/Helpers/FileOperationsHelper.cs b/Chromatics/Helpers/FileOperationsHelper.cs
index 447a363d..f32262fb 100644
--- a/Chromatics/Helpers/FileOperationsHelper.cs
+++ b/Chromatics/Helpers/FileOperationsHelper.cs
@@ -285,7 +285,7 @@ public static void SaveLayerMappings(ConcurrentDictionary<int, Layer> mappings,
 
                 var wrapper = new MappingFileV3
                 {
-                    schemaVersion = 5,
+                    schemaVersion = 6,
                     layers = layersSnapshot,
                     deviceLayouts = layoutsSnapshot,
                     deviceBrightness = brightnessSnapshot,
@@ -644,7 +644,7 @@ public static void ExportLayerMappingsToPath(ConcurrentDictionary<int, Layer> la
 
                 var wrapper = new MappingFileV3
                 {
-                    schemaVersion = 5,
+                    schemaVersion = 6,
                     layers = layersCopy,
                     deviceLayouts = deviceLayouts != null
                         ? new Dictionary<Guid, Dictionary<RGB.NET.Core.LedId, DeviceKeyPosition>>(deviceLayouts)
@@ -714,19 +714,7 @@ public static void SaveColorMappings(PaletteColorModel palette)
 
             try
             {
-                using (var sw = new StreamWriter(path, false))
-                {
-                    var serializer = new JsonSerializer
-                    {
-                        NullValueHandling = NullValueHandling.Ignore
-                    };
-
-                    serializer.Serialize(sw, palette);
-                    sw.WriteLine();
-                    sw.Close();
-                }
-
-
+                WriteJsonAtomic(path, palette);
             }
             catch (Exception ex)
             {
@@ -911,19 +899,7 @@ public static void SaveEffectSettings(EffectTypesModel palette)
 
             try
             {
-                using (var sw = new StreamWriter(path, false))
-                {
-                    var serializer = new JsonSerializer
-                    {
-                        NullValueHandling = NullValueHandling.Ignore
-                    };
-
-                    serializer.Serialize(sw, palette);
-                    sw.WriteLine();
-                    sw.Close();
-                }
-
-
+                WriteJsonAtomic(path, palette);
             }
             catch (Exception ex)
             {
@@ -973,19 +949,7 @@ public static void SaveSettings(SettingsModel settings)
 
             try
             {
-                using (var sw = new StreamWriter(path, false))
-                {
-                    var serializer = new JsonSerializer
-                    {
-                        NullValueHandling = NullValueHandling.Ignore
-                    };
-
-                    serializer.Serialize(sw, settings);
-                    sw.WriteLine();
-                    sw.Close();
-                }
-
-
+                WriteJsonAtomic(path, settings);
             }
             catch (Exception ex)
             {
diff --git a/Chromatics/Helpers/GameHelper.cs b/Chromatics/Helpers/GameHelper.cs
index d3d8a5ca..e9aa8cd2 100644
--- a/Chromatics/Helpers/GameHelper.cs
+++ b/Chromatics/Helpers/GameHelper.cs
@@ -90,9 +90,9 @@ public static Color GetJobClassColor(Actor.Job job, PaletteColorModel colorPalet
                         return ColorHelper.ColorToRGBColor(colorPalette.JobCPTHighlight.Color);
                 case Actor.Job.BSM:
                     if (!highlight)
-                        return ColorHelper.ColorToRGBColor(colorPalette.JobBLMBase.Color);
+                        return ColorHelper.ColorToRGBColor(colorPalette.JobBSMBase.Color);
                     else
-                        return ColorHelper.ColorToRGBColor(colorPalette.JobBLMHighlight.Color);
+                        return ColorHelper.ColorToRGBColor(colorPalette.JobBSMHighlight.Color);
                 case Actor.Job.ARM:
                     if (!highlight)
                         return ColorHelper.ColorToRGBColor(colorPalette.JobARMBase.Color);
diff --git a/Chromatics/Helpers/SystemMonitorHelper.cs b/Chromatics/Helpers/SystemMonitorHelper.cs
index 60755cb0..b01a7b33 100644
--- a/Chromatics/Helpers/SystemMonitorHelper.cs
+++ b/Chromatics/Helpers/SystemMonitorHelper.cs
@@ -20,11 +20,7 @@ public static float GetCurrentCpuUsage()
 
         public static int GetMaxCpuUsage()
         {
-            var counter = new PerformanceCounter("Memory", "Available Mbytes");
-            var memUsage = counter.NextValue();
-            var maxCpuUsage = (int)(100 - memUsage);
-            _maxCpuUsage = maxCpuUsage;
-
+            _maxCpuUsage = (int)_cpuCounter.NextValue();
             return _maxCpuUsage;
         }
     }
diff --git a/Chromatics/Layers/BaseLayers/AudioVisualizer.cs b/Chromatics/Layers/BaseLayers/AudioVisualizer.cs
index ea1f4b0c..f2ae6b51 100644
--- a/Chromatics/Layers/BaseLayers/AudioVisualizer.cs
+++ b/Chromatics/Layers/BaseLayers/AudioVisualizer.cs
@@ -93,7 +93,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 layergroup.Detach();
             }
 
diff --git a/Chromatics/Layers/BaseLayers/BattleStance.cs b/Chromatics/Layers/BaseLayers/BattleStance.cs
index c13b0fb7..71fbe80c 100644
--- a/Chromatics/Layers/BaseLayers/BattleStance.cs
+++ b/Chromatics/Layers/BaseLayers/BattleStance.cs
@@ -15,6 +15,7 @@ public class BaseBattleStanceProcessor : LayerProcessor
         private static BaseBattleStanceProcessor _instance;
         private bool _disposed = false;
         private Dictionary<int, HashSet<Led>> _layergroupledcollections = new Dictionary<int, HashSet<Led>>();
+        private readonly Dictionary<int, SolidColorBrush> _brushCache = new Dictionary<int, SolidColorBrush>();
 
         // Private constructor to prevent direct instantiation
         private BaseBattleStanceProcessor() { }
@@ -71,7 +72,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
             }
 
             if (!layer.Enabled)
@@ -111,7 +112,15 @@ public override void Process(IMappingLayer layer)
             }
 
             // Apply lighting
-            var brush = new SolidColorBrush(engaged_color);
+            if (!_brushCache.TryGetValue(layer.layerID, out var brush))
+            {
+                brush = new SolidColorBrush(engaged_color);
+                _brushCache[layer.layerID] = brush;
+            }
+            else
+            {
+                brush.Color = engaged_color;
+            }
             layergroup.Brush = brush;
             _init = true;
             layer.requestUpdate = false;
@@ -124,6 +133,7 @@ protected override void Dispose(bool disposing)
                 if (disposing)
                 {
                     // Dispose managed resources
+                    _brushCache.Clear();
                     _layergroupledcollections.Clear();
                     var _layergroups = RGBController.GetLiveLayerGroups();
                     foreach (var layergroup in _layergroups.Values.SelectMany(lg => lg))
diff --git a/Chromatics/Layers/BaseLayers/JobClasses.cs b/Chromatics/Layers/BaseLayers/JobClasses.cs
index 437196b2..3fc1c7bb 100644
--- a/Chromatics/Layers/BaseLayers/JobClasses.cs
+++ b/Chromatics/Layers/BaseLayers/JobClasses.cs
@@ -15,6 +15,7 @@ public class JobClassesProcessor : LayerProcessor
         private static JobClassesProcessor _instance;
         private bool _disposed = false;
         private Dictionary<int, HashSet<Led>> _layergroupledcollections = new Dictionary<int, HashSet<Led>>();
+        private readonly Dictionary<int, SolidColorBrush> _brushCache = new Dictionary<int, SolidColorBrush>();
 
         // Private constructor to prevent direct instantiation
         private JobClassesProcessor() { }
@@ -69,7 +70,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
             }
 
             var highlight_col = Color.Transparent;
@@ -107,7 +108,15 @@ public override void Process(IMappingLayer layer)
             }
 
             // Apply lighting
-            var brush = new SolidColorBrush(highlight_col);
+            if (!_brushCache.TryGetValue(layer.layerID, out var brush))
+            {
+                brush = new SolidColorBrush(highlight_col);
+                _brushCache[layer.layerID] = brush;
+            }
+            else
+            {
+                brush.Color = highlight_col;
+            }
             layergroup.Brush = brush;
             _init = true;
             layer.requestUpdate = false;
@@ -120,6 +129,7 @@ protected override void Dispose(bool disposing)
                 if (disposing)
                 {
                     // Dispose managed resources
+                    _brushCache.Clear();
                     _layergroupledcollections.Clear();
                     var _layergroups = RGBController.GetLiveLayerGroups();
                     foreach (var layergroup in _layergroups.Values.SelectMany(lg => lg))
diff --git a/Chromatics/Layers/BaseLayers/ReactiveWeather.cs b/Chromatics/Layers/BaseLayers/ReactiveWeather.cs
index f25ecca0..e69dee96 100644
--- a/Chromatics/Layers/BaseLayers/ReactiveWeather.cs
+++ b/Chromatics/Layers/BaseLayers/ReactiveWeather.cs
@@ -137,7 +137,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
 
                 layergroup.Brush = weather_brush;
                 layergroup.Detach();
diff --git a/Chromatics/Layers/BaseLayers/ScreenCapture.cs b/Chromatics/Layers/BaseLayers/ScreenCapture.cs
index 94a48340..d4dd3047 100644
--- a/Chromatics/Layers/BaseLayers/ScreenCapture.cs
+++ b/Chromatics/Layers/BaseLayers/ScreenCapture.cs
@@ -39,7 +39,7 @@ public override void Process(IMappingLayer layer)
             else
             {
                 layergroup = new ListLedGroup(surface, ledArray) { ZIndex = layer.zindex };
-                _layergroups.Add(layer.layerID, new[] { layergroup });
+                _layergroups[layer.layerID] = new[] { layergroup };
                 layergroup.Detach();
             }
 
diff --git a/Chromatics/Layers/BaseLayers/Static.cs b/Chromatics/Layers/BaseLayers/Static.cs
index 5344b34a..e5890c10 100644
--- a/Chromatics/Layers/BaseLayers/Static.cs
+++ b/Chromatics/Layers/BaseLayers/Static.cs
@@ -70,7 +70,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
             }
 
             if (!layer.Enabled)
diff --git a/Chromatics/Layers/DynamicLayers/BattleStance.cs b/Chromatics/Layers/DynamicLayers/BattleStance.cs
index 57771b99..e0f34353 100644
--- a/Chromatics/Layers/DynamicLayers/BattleStance.cs
+++ b/Chromatics/Layers/DynamicLayers/BattleStance.cs
@@ -13,6 +13,7 @@ public class DynamicBattleStanceProcessor : LayerProcessor
     {
         private static DynamicBattleStanceProcessor _instance;
         private bool _disposed = false;
+        private readonly Dictionary<int, SolidColorBrush> _brushCache = new Dictionary<int, SolidColorBrush>();
 
         // Private constructor to prevent direct instantiation
         private DynamicBattleStanceProcessor() { }
@@ -65,7 +66,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { updatedLayerGroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 updatedLayerGroup.Detach();
             }
 
@@ -77,7 +78,16 @@ public override void Process(IMappingLayer layer)
 
             // Process data from FFXIV
             var _memoryHandler = GameController.GetGameData();
-            var brush = new SolidColorBrush(engaged_color);
+
+            if (!_brushCache.TryGetValue(layer.layerID, out var brush))
+            {
+                brush = new SolidColorBrush(engaged_color);
+                _brushCache[layer.layerID] = brush;
+            }
+            else
+            {
+                brush.Color = engaged_color;
+            }
 
             if (_memoryHandler?.Reader != null && _memoryHandler.Reader.CanGetActors())
             {
@@ -105,6 +115,7 @@ protected override void Dispose(bool disposing)
             {
                 if (disposing)
                 {
+                    _brushCache.Clear();
                     var _layergroups = RGBController.GetLiveLayerGroups();
                     if (_layergroups != null)
                     {
diff --git a/Chromatics/Layers/DynamicLayers/Castbar.cs b/Chromatics/Layers/DynamicLayers/Castbar.cs
index 4b0afdac..3ce3b634 100644
--- a/Chromatics/Layers/DynamicLayers/Castbar.cs
+++ b/Chromatics/Layers/DynamicLayers/Castbar.cs
@@ -181,7 +181,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/EnmityTracker.cs b/Chromatics/Layers/DynamicLayers/EnmityTracker.cs
index 560e524f..1ad56635 100644
--- a/Chromatics/Layers/DynamicLayers/EnmityTracker.cs
+++ b/Chromatics/Layers/DynamicLayers/EnmityTracker.cs
@@ -254,7 +254,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/ExperienceTracker.cs b/Chromatics/Layers/DynamicLayers/ExperienceTracker.cs
index 5ee22061..3009e0c1 100644
--- a/Chromatics/Layers/DynamicLayers/ExperienceTracker.cs
+++ b/Chromatics/Layers/DynamicLayers/ExperienceTracker.cs
@@ -211,7 +211,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/FocusTargetCastbar.cs b/Chromatics/Layers/DynamicLayers/FocusTargetCastbar.cs
new file mode 100644
index 00000000..696cc7e3
--- /dev/null
+++ b/Chromatics/Layers/DynamicLayers/FocusTargetCastbar.cs
@@ -0,0 +1,221 @@
+using Chromatics.Core;
+using Chromatics.Enums;
+using Chromatics.Extensions.RGB.NET;
+using Chromatics.Helpers;
+using Chromatics.Interfaces;
+using RGB.NET.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using static Chromatics.Helpers.MathHelper;
+
+namespace Chromatics.Layers
+{
+    public class FocusTargetCastbarProcessor : LayerProcessor
+    {
+        private static FocusTargetCastbarProcessor _instance;
+        private static Dictionary<int, FocusTargetCastbarDynamicModel> layerProcessorModel = new Dictionary<int, FocusTargetCastbarDynamicModel>();
+        private bool _disposed = false;
+
+        private FocusTargetCastbarProcessor() { }
+
+        public static FocusTargetCastbarProcessor Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new FocusTargetCastbarProcessor();
+                }
+                return _instance;
+            }
+        }
+
+        public override void Process(IMappingLayer layer)
+        {
+            if (_disposed) return;
+
+            FocusTargetCastbarDynamicModel model;
+
+            if (!layerProcessorModel.ContainsKey(layer.layerID))
+            {
+                model = new FocusTargetCastbarDynamicModel();
+                layerProcessorModel.Add(layer.layerID, model);
+            }
+            else
+            {
+                model = layerProcessorModel[layer.layerID];
+            }
+
+            // Focus Target Castbar Layer Implementation
+            var _colorPalette = RGBController.GetActivePalette();
+            var _layergroups = RGBController.GetLiveLayerGroups();
+            var ledArray = GetLedSortedArray(layer);
+            var countKeys = ledArray.Count();
+
+            if (model.init && (layer.requestUpdate || !layer.Enabled))
+            {
+                DetachAndClearGroups(model._localgroups);
+
+                if (!layer.Enabled)
+                    return;
+            }
+
+            // Process data from FFXIV
+            var _memoryHandler = GameController.GetGameData();
+
+            if (_memoryHandler?.Reader != null && _memoryHandler.Reader.CanGetTargetInfo())
+            {
+                var getTargetInfo = _memoryHandler.Reader.GetTargetInfo().TargetInfo;
+                if (getTargetInfo == null) return;
+
+                var focusTarget = getTargetInfo.FocusTarget;
+                uint targetId = focusTarget?.ID ?? 0;
+
+                var full_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetCastbar.Color);
+                var empty_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetCastbarEmpty.Color); // Bleed layer
+
+                model.full_brush ??= new SolidColorBrush(full_col);
+                model.full_brush.Color = full_col;
+
+                model.empty_brush ??= new SolidColorBrush(layer.allowBleed ? Color.Transparent : empty_col);
+                model.empty_brush.Color = layer.allowBleed ? Color.Transparent : empty_col;
+
+                if (targetId != model._targetId)
+                {
+                    DetachAndClearGroups(model._localgroups);
+                    model._targetReset = true;
+                    model._targetId = targetId;
+                }
+
+                // Check if layer mode has changed
+                if (model._currentMode != layer.layerModes)
+                {
+                    DetachAndClearGroups(model._localgroups);
+                    model._currentMode = layer.layerModes;
+                }
+
+                // No focus target set: paint the empty bar instead of
+                // returning, so the selected keys hold the negative colour
+                // (or bleed) rather than freezing on the last cast state.
+                var currentVal = targetId != 0 ? focusTarget.CastingPercentage : 0.0;
+                var minVal = 0.0;
+                var maxVal = 1.0;
+
+                if (layer.layerModes == Enums.LayerModes.Interpolate)
+                {
+                    // Interpolate implementation
+                    var currentVal_Interpolate = Convert.ToInt32(LinearInterpolation.Interpolate(currentVal, minVal, maxVal, 0, countKeys));
+                    currentVal_Interpolate = Math.Max(0, Math.Min(countKeys, currentVal_Interpolate));
+
+                    // Process Lighting
+                    if (currentVal_Interpolate != model._interpolateValue || model._targetReset || layer.requestUpdate)
+                    {
+                        var ledGroups = new List<ListLedGroup>();
+
+                        for (int i = 0; i < countKeys; i++)
+                        {
+                            var ledGroup = new ListLedGroup(surface, ledArray[i])
+                            {
+                                ZIndex = layer.zindex,
+                            };
+
+                            ledGroup.Detach();
+
+                            ledGroup.Brush = i < currentVal_Interpolate ? model.full_brush : model.empty_brush;
+                            ledGroups.Add(ledGroup);
+                        }
+
+                        DetachAndClearGroups(model._localgroups);
+                        model._localgroups = ledGroups;
+                        model._interpolateValue = currentVal_Interpolate;
+                    }
+                }
+                else if (layer.layerModes == Enums.LayerModes.Fade)
+                {
+                    // Fade implementation
+                    var currentVal_Fader = ColorHelper.GetInterpolatedColor(currentVal, minVal, maxVal, model.empty_brush.Color, model.full_brush.Color);
+
+                    if (currentVal_Fader != model._faderValue || model._targetReset || layer.requestUpdate)
+                    {
+                        var ledGroup = new ListLedGroup(surface, ledArray)
+                        {
+                            ZIndex = layer.zindex,
+                            Brush = new SolidColorBrush(currentVal_Fader)
+                        };
+
+                        ledGroup.Detach();
+
+                        DetachAndClearGroups(model._localgroups);
+                        model._localgroups.Add(ledGroup);
+                        model._faderValue = currentVal_Fader;
+                    }
+                }
+
+                // Send layers to _layergroups Dictionary to be tracked outside this method
+                var lg = model._localgroups.ToArray();
+
+                if (_layergroups.ContainsKey(layer.layerID))
+                {
+                    _layergroups[layer.layerID] = lg;
+                }
+                else
+                {
+                    _layergroups[layer.layerID] = lg;
+                }
+            }
+
+            // Apply lighting
+            foreach (var layergroup in model._localgroups)
+            {
+                layergroup.Attach(surface);
+            }
+
+            model.init = true;
+            model._targetReset = false;
+            layer.requestUpdate = false;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    foreach (var model in layerProcessorModel.Values)
+                    {
+                        DetachAndClearGroups(model._localgroups);
+                    }
+                    layerProcessorModel.Clear();
+                }
+
+                _disposed = true;
+            }
+
+            base.Dispose(disposing);
+            _instance = null;
+        }
+
+        private void DetachAndClearGroups(List<ListLedGroup> groups)
+        {
+            foreach (var group in groups)
+            {
+                group?.Detach();
+            }
+            groups.Clear();
+        }
+
+        private class FocusTargetCastbarDynamicModel
+        {
+            public List<ListLedGroup> _localgroups { get; set; } = new List<ListLedGroup>();
+            public SolidColorBrush empty_brush { get; set; }
+            public SolidColorBrush full_brush { get; set; }
+            public LayerModes _currentMode { get; set; }
+            public int _interpolateValue { get; set; }
+            public Color _faderValue { get; set; }
+            public uint _targetId { get; set; }
+            public bool _targetReset { get; set; }
+            public bool init { get; set; }
+        }
+    }
+}
diff --git a/Chromatics/Layers/DynamicLayers/FocusTargetHP.cs b/Chromatics/Layers/DynamicLayers/FocusTargetHP.cs
new file mode 100644
index 00000000..eaf87d1a
--- /dev/null
+++ b/Chromatics/Layers/DynamicLayers/FocusTargetHP.cs
@@ -0,0 +1,239 @@
+using Chromatics.Core;
+using Chromatics.Enums;
+using Chromatics.Extensions.RGB.NET;
+using Chromatics.Helpers;
+using Chromatics.Interfaces;
+using RGB.NET.Core;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using static Chromatics.Helpers.MathHelper;
+
+namespace Chromatics.Layers
+{
+    public class FocusTargetHPProcessor : LayerProcessor
+    {
+        private static FocusTargetHPProcessor _instance;
+        private static Dictionary<int, FocusTargetHPDynamicModel> layerProcessorModel = new Dictionary<int, FocusTargetHPDynamicModel>();
+        private bool _disposed = false;
+
+        private FocusTargetHPProcessor() { }
+
+        public static FocusTargetHPProcessor Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    _instance = new FocusTargetHPProcessor();
+                }
+                return _instance;
+            }
+        }
+
+        public override void Process(IMappingLayer layer)
+        {
+            if (_disposed) return;
+
+            FocusTargetHPDynamicModel model;
+
+            if (!layerProcessorModel.ContainsKey(layer.layerID))
+            {
+                model = new FocusTargetHPDynamicModel();
+                layerProcessorModel.Add(layer.layerID, model);
+            }
+            else
+            {
+                model = layerProcessorModel[layer.layerID];
+            }
+
+            // Focus Target HP Tracker Dynamic Layer Implementation
+            var _colorPalette = RGBController.GetActivePalette();
+
+            var _layergroups = RGBController.GetLiveLayerGroups();
+            var ledArray = GetLedSortedArray(layer);
+            var countKeys = ledArray.Count();
+
+            if (model.init && (layer.requestUpdate || !layer.Enabled))
+            {
+                DetachAndClearGroups(model._localgroups);
+
+                if (!layer.Enabled)
+                    return;
+            }
+
+            // Process data from FFXIV
+            var _memoryHandler = GameController.GetGameData();
+
+            if (_memoryHandler?.Reader != null && _memoryHandler.Reader.CanGetTargetInfo())
+            {
+                var full_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetHpClaimed.Color);
+                var friendly_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetHpFriendly.Color);
+                var idle_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetHpIdle.Color);
+                var empty_col = ColorHelper.ColorToRGBColor(_colorPalette.FocusTargetHpEmpty.Color); // Bleed layer
+
+                model.full_brush = model.full_brush ?? new SolidColorBrush(full_col);
+                model.empty_brush = model.empty_brush ?? new SolidColorBrush(empty_col);
+
+                model.empty_brush.Color = layer.allowBleed ? Color.Transparent : empty_col;
+
+                var getTargetInfo = _memoryHandler.Reader.GetTargetInfo();
+                if (getTargetInfo.TargetInfo == null) return;
+
+                var focusTarget = getTargetInfo.TargetInfo.FocusTarget;
+                uint targetId = focusTarget?.ID ?? 0;
+
+                if (targetId != model._targetId)
+                {
+                    DetachAndClearGroups(model._localgroups);
+                    model._targetReset = true;
+                    model._targetId = targetId;
+                }
+
+                if (targetId == 0 || !model.init)
+                {
+                    if (model._targetReset || !model.init)
+                    {
+                        var ledGroup = new ListLedGroup(surface, ledArray)
+                        {
+                            ZIndex = layer.zindex,
+                            Brush = model.empty_brush
+                        };
+
+                        ledGroup.Detach();
+                        model._localgroups.Add(ledGroup);
+                    }
+                }
+                else
+                {
+                    var currentVal = focusTarget.HPCurrent;
+                    var maxVal = focusTarget.HPMax;
+
+                    if (maxVal <= 0) maxVal = currentVal + 1;
+
+                    model.full_brush.Color = focusTarget.InCombat
+                        ? (focusTarget.IsAggressive ? full_col : friendly_col)
+                        : idle_col;
+
+                    if (model._currentMode != layer.layerModes)
+                    {
+                        DetachAndClearGroups(model._localgroups);
+                        model._currentMode = layer.layerModes;
+                    }
+
+                    if (layer.layerModes == Enums.LayerModes.Interpolate)
+                    {
+                        var currentVal_Interpolate = LinearInterpolation.Interpolate(currentVal, 0, maxVal, 0, countKeys);
+                        currentVal_Interpolate = Math.Max(0, Math.Min(countKeys, currentVal_Interpolate));
+
+                        if (currentVal_Interpolate != model._interpolateValue || model._targetReset || layer.requestUpdate)
+                        {
+                            var ledGroups = new List<ListLedGroup>();
+
+                            for (int i = 0; i < countKeys; i++)
+                            {
+                                var ledGroup = new ListLedGroup(surface, ledArray[i])
+                                {
+                                    ZIndex = layer.zindex,
+                                };
+
+                                ledGroup.Detach();
+
+                                ledGroup.Brush = i < currentVal_Interpolate ? model.full_brush : model.empty_brush;
+
+                                ledGroups.Add(ledGroup);
+                            }
+
+                            DetachAndClearGroups(model._localgroups);
+
+                            model._localgroups = ledGroups;
+                            model._interpolateValue = currentVal_Interpolate;
+                        }
+                    }
+                    else if (layer.layerModes == Enums.LayerModes.Fade)
+                    {
+                        var currentVal_Fader = ColorHelper.GetInterpolatedColor(currentVal, 0, maxVal, model.empty_brush.Color, model.full_brush.Color);
+
+                        if (currentVal_Fader != model._faderValue || model._targetReset || layer.requestUpdate)
+                        {
+                            var ledGroup = new ListLedGroup(surface, ledArray)
+                            {
+                                ZIndex = layer.zindex,
+                                Brush = new SolidColorBrush(currentVal_Fader)
+                            };
+
+                            ledGroup.Detach();
+
+                            DetachAndClearGroups(model._localgroups);
+                            model._localgroups.Add(ledGroup);
+                            model._faderValue = currentVal_Fader;
+                        }
+                    }
+                }
+
+                var lg = model._localgroups.ToArray();
+
+                if (_layergroups.ContainsKey(layer.layerID))
+                {
+                    _layergroups[layer.layerID] = lg;
+                }
+                else
+                {
+                    _layergroups[layer.layerID] = lg;
+                }
+            }
+
+            // Apply lighting
+            foreach (var layergroup in model._localgroups)
+            {
+                layergroup.Attach(surface);
+            }
+
+            model.init = true;
+            model._targetReset = false;
+            layer.requestUpdate = false;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing)
+                {
+                    foreach (var model in layerProcessorModel.Values)
+                    {
+                        DetachAndClearGroups(model._localgroups);
+                    }
+                    layerProcessorModel.Clear();
+                }
+
+                _disposed = true;
+            }
+
+            base.Dispose(disposing);
+            _instance = null;
+        }
+
+        private void DetachAndClearGroups(List<ListLedGroup> groups)
+        {
+            foreach (var group in groups)
+            {
+                group?.Detach();
+            }
+            groups.Clear();
+        }
+
+        private class FocusTargetHPDynamicModel
+        {
+            public List<ListLedGroup> _localgroups { get; set; } = new List<ListLedGroup>();
+            public SolidColorBrush empty_brush { get; set; }
+            public SolidColorBrush full_brush { get; set; }
+            public LayerModes _currentMode { get; set; }
+            public int _interpolateValue { get; set; }
+            public Color _faderValue { get; set; }
+            public uint _targetId { get; set; }
+            public bool _targetReset { get; set; }
+            public bool init { get; set; }
+        }
+    }
+}
diff --git a/Chromatics/Layers/DynamicLayers/HPTracker.cs b/Chromatics/Layers/DynamicLayers/HPTracker.cs
index 553d5e4a..f974e757 100644
--- a/Chromatics/Layers/DynamicLayers/HPTracker.cs
+++ b/Chromatics/Layers/DynamicLayers/HPTracker.cs
@@ -171,7 +171,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/Highlight.cs b/Chromatics/Layers/DynamicLayers/Highlight.cs
index 5b40087e..4e127fdd 100644
--- a/Chromatics/Layers/DynamicLayers/Highlight.cs
+++ b/Chromatics/Layers/DynamicLayers/Highlight.cs
@@ -13,6 +13,7 @@ public class HighlightProcessor : LayerProcessor
     {
         private static HighlightProcessor _instance;
         private bool _disposed = false;
+        private readonly Dictionary<int, SolidColorBrush> _brushCache = new Dictionary<int, SolidColorBrush>();
 
         // Private constructor to prevent direct instantiation
         private HighlightProcessor() { }
@@ -59,7 +60,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { updatedLayerGroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 updatedLayerGroup.Detach();
             }
 
@@ -77,7 +78,15 @@ public override void Process(IMappingLayer layer)
                 }
             }
 
-            var brush = new SolidColorBrush(highlight_col);
+            if (!_brushCache.TryGetValue(layer.layerID, out var brush))
+            {
+                brush = new SolidColorBrush(highlight_col);
+                _brushCache[layer.layerID] = brush;
+            }
+            else
+            {
+                brush.Color = highlight_col;
+            }
             updatedLayerGroup.Brush = brush;
             updatedLayerGroup.Attach(surface);
             _init = true;
@@ -90,6 +99,7 @@ protected override void Dispose(bool disposing)
             {
                 if (disposing)
                 {
+                    _brushCache.Clear();
                     var _layergroups = RGBController.GetLiveLayerGroups();
                     if (_layergroups != null)
                     {
diff --git a/Chromatics/Layers/DynamicLayers/JobClassesHighlight.cs b/Chromatics/Layers/DynamicLayers/JobClassesHighlight.cs
index 14bd8424..869a5660 100644
--- a/Chromatics/Layers/DynamicLayers/JobClassesHighlight.cs
+++ b/Chromatics/Layers/DynamicLayers/JobClassesHighlight.cs
@@ -14,6 +14,7 @@ public class JobClassesHighlightProcessor : LayerProcessor
     {
         private static JobClassesHighlightProcessor _instance;
         private bool _disposed = false;
+        private readonly Dictionary<int, SolidColorBrush> _brushCache = new Dictionary<int, SolidColorBrush>();
 
         // Private constructor to prevent direct instantiation
         private JobClassesHighlightProcessor() { }
@@ -63,7 +64,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { updatedLayerGroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 updatedLayerGroup.Detach();
             }
 
@@ -94,7 +95,15 @@ public override void Process(IMappingLayer layer)
             }
 
             // Apply lighting
-            var brush = new SolidColorBrush(highlight_col);
+            if (!_brushCache.TryGetValue(layer.layerID, out var brush))
+            {
+                brush = new SolidColorBrush(highlight_col);
+                _brushCache[layer.layerID] = brush;
+            }
+            else
+            {
+                brush.Color = highlight_col;
+            }
             updatedLayerGroup.Brush = brush;
             updatedLayerGroup.Attach(surface);
             _init = true;
@@ -117,6 +126,7 @@ protected override void Dispose(bool disposing)
                 if (disposing)
                 {
                     // Dispose managed resources
+                    _brushCache.Clear();
                     var _layergroups = RGBController.GetLiveLayerGroups();
                     if (_layergroups != null && _layergroups.Values != null)
                     {
diff --git a/Chromatics/Layers/DynamicLayers/JobGaugeA.cs b/Chromatics/Layers/DynamicLayers/JobGaugeA.cs
index 3bb5ab0d..7db855f2 100644
--- a/Chromatics/Layers/DynamicLayers/JobGaugeA.cs
+++ b/Chromatics/Layers/DynamicLayers/JobGaugeA.cs
@@ -113,25 +113,29 @@ public override void Process(IMappingLayer layer)
                         // Interpolate implementation
                         var currentVal_Interpolate = LinearInterpolation.Interpolate<double>(jobGauge.currentValue, jobGauge.minValue, jobGauge.maxValue, 0, countKeys + jobGauge.offset);
 
-                        // Process Lighting
-                        var ledGroups = new List<ListLedGroup>();
-
-                        for (int i = 0; i < countKeys; i++)
+                        // Only rebuild groups when the interpolated position or a forced update changes
+                        if (currentVal_Interpolate != model._interpolateValue || layer.requestUpdate)
                         {
-                            var ledGroup = new ListLedGroup(surface, ledArray[i])
+                            var ledGroups = new List<ListLedGroup>();
+
+                            for (int i = 0; i < countKeys; i++)
                             {
-                                ZIndex = layer.zindex,
-                            };
+                                var ledGroup = new ListLedGroup(surface, ledArray[i])
+                                {
+                                    ZIndex = layer.zindex,
+                                };
 
-                            ledGroup.Detach();
+                                ledGroup.Detach();
 
-                            ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
+                                ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
 
-                            ledGroups.Add(ledGroup);
-                        }
+                                ledGroups.Add(ledGroup);
+                            }
 
-                        DetachAndClearGroups(model._localgroups);
-                        model._localgroups = ledGroups;
+                            DetachAndClearGroups(model._localgroups);
+                            model._localgroups = ledGroups;
+                            model._interpolateValue = currentVal_Interpolate;
+                        }
                     }
                     else if (layer.layerModes == Enums.LayerModes.Fade)
                     {
@@ -164,7 +168,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
@@ -768,7 +772,7 @@ private class JobGaugeADynamicModel
             public SolidColorBrush empty_brush { get; set; }
             public SolidColorBrush highlight_brush { get; set; }
             public LayerModes _currentMode { get; set; }
-            public int _interpolateValue { get; set; } = -1;
+            public double _interpolateValue { get; set; } = -1;
             public Color _faderValue { get; set; }
             public Actor.Job _currentJob { get; set; }
             public bool init { get; set; }
diff --git a/Chromatics/Layers/DynamicLayers/JobGaugeB.cs b/Chromatics/Layers/DynamicLayers/JobGaugeB.cs
index 4c767fce..0be7be4b 100644
--- a/Chromatics/Layers/DynamicLayers/JobGaugeB.cs
+++ b/Chromatics/Layers/DynamicLayers/JobGaugeB.cs
@@ -109,24 +109,28 @@ public override void Process(IMappingLayer layer)
                         // Interpolate implementation
                         var currentVal_Interpolate = LinearInterpolation.Interpolate<double>(jobGauge.currentValue, jobGauge.minValue, jobGauge.maxValue, 0, countKeys + jobGauge.offset);
 
-                        // Process Lighting
-                        var ledGroups = new List<ListLedGroup>();
-
-                        for (int i = 0; i < countKeys; i++)
+                        // Only rebuild groups when the interpolated position or a forced update changes
+                        if (currentVal_Interpolate != model._interpolateValue || layer.requestUpdate)
                         {
-                            var ledGroup = new ListLedGroup(surface, ledArray[i])
+                            var ledGroups = new List<ListLedGroup>();
+
+                            for (int i = 0; i < countKeys; i++)
                             {
-                                ZIndex = layer.zindex,
-                            };
+                                var ledGroup = new ListLedGroup(surface, ledArray[i])
+                                {
+                                    ZIndex = layer.zindex,
+                                };
 
-                            ledGroup.Detach();
+                                ledGroup.Detach();
 
-                            ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
-                            ledGroups.Add(ledGroup);
-                        }
+                                ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
+                                ledGroups.Add(ledGroup);
+                            }
 
-                        DetachAndClearGroups(model._localgroups);
-                        model._localgroups = ledGroups;
+                            DetachAndClearGroups(model._localgroups);
+                            model._localgroups = ledGroups;
+                            model._interpolateValue = currentVal_Interpolate;
+                        }
                     }
                     else if (layer.layerModes == Enums.LayerModes.Fade)
                     {
@@ -159,7 +163,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
@@ -458,7 +462,7 @@ private static JobGaugeResponse ReturnJobGauge(CurrentPlayerResult currentPlayer
                     // immediate next play while Gauge A keeps the currently-active arcana.
                     {
                         var ast = jobResources.JobResourcesContainer.Astrologian;
-                        var nextCard = ast.DrawnCards != null && ast.DrawnCards.Count > 0
+                        var nextCard = ast.DrawnCards != null && ast.DrawnCards.Length > 0
                             ? ast.DrawnCards[0]
                             : AstrologianCard.None;
 
@@ -713,7 +717,7 @@ private class JobGaugeBDynamicModel
             public SolidColorBrush empty_brush { get; set; }
             public SolidColorBrush highlight_brush { get; set; }
             public LayerModes _currentMode { get; set; }
-            public int _interpolateValue { get; set; } = -1;
+            public double _interpolateValue { get; set; } = -1;
             public Color _faderValue { get; set; }
             public Actor.Job _currentJob { get; set; }
             public bool init { get; set; }
diff --git a/Chromatics/Layers/DynamicLayers/JobGaugeC.cs b/Chromatics/Layers/DynamicLayers/JobGaugeC.cs
index 1443386b..ffe27095 100644
--- a/Chromatics/Layers/DynamicLayers/JobGaugeC.cs
+++ b/Chromatics/Layers/DynamicLayers/JobGaugeC.cs
@@ -103,23 +103,28 @@ public override void Process(IMappingLayer layer)
                     {
                         var currentVal_Interpolate = LinearInterpolation.Interpolate<double>(jobGauge.currentValue, jobGauge.minValue, jobGauge.maxValue, 0, countKeys + jobGauge.offset);
 
-                        var ledGroups = new List<ListLedGroup>();
-
-                        for (int i = 0; i < countKeys; i++)
+                        // Only rebuild groups when the interpolated position or a forced update changes
+                        if (currentVal_Interpolate != model._interpolateValue || layer.requestUpdate)
                         {
-                            var ledGroup = new ListLedGroup(surface, ledArray[i])
+                            var ledGroups = new List<ListLedGroup>();
+
+                            for (int i = 0; i < countKeys; i++)
                             {
-                                ZIndex = layer.zindex,
-                            };
+                                var ledGroup = new ListLedGroup(surface, ledArray[i])
+                                {
+                                    ZIndex = layer.zindex,
+                                };
 
-                            ledGroup.Detach();
+                                ledGroup.Detach();
 
-                            ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
-                            ledGroups.Add(ledGroup);
-                        }
+                                ledGroup.Brush = i <= currentVal_Interpolate ? model.highlight_brush : model.empty_brush;
+                                ledGroups.Add(ledGroup);
+                            }
 
-                        DetachAndClearGroups(model._localgroups);
-                        model._localgroups = ledGroups;
+                            DetachAndClearGroups(model._localgroups);
+                            model._localgroups = ledGroups;
+                            model._interpolateValue = currentVal_Interpolate;
+                        }
                     }
                     else if (layer.layerModes == Enums.LayerModes.Fade)
                     {
@@ -150,7 +155,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
@@ -269,7 +274,7 @@ private static JobGaugeResponse ReturnJobGauge(CurrentPlayerResult currentPlayer
                     // Draw cycle. Full-fill on the active colour; negative when no card is held.
                     {
                         var hasCard = container.Astrologian.CurrentArcana != AstrologianCard.None
-                                      || container.Astrologian.DrawnCards.Count > 0;
+                                      || container.Astrologian.DrawnCards.Length > 0;
 
                         jobGauge.emptyColor = ColorHelper.ColorToRGBColor(_colorPalette.JobASTNegative.Color);
                         jobGauge.minValue = 0;
@@ -437,7 +442,7 @@ private class JobGaugeCDynamicModel
             public SolidColorBrush empty_brush { get; set; }
             public SolidColorBrush highlight_brush { get; set; }
             public LayerModes _currentMode { get; set; }
-            public int _interpolateValue { get; set; } = -1;
+            public double _interpolateValue { get; set; } = -1;
             public Color _faderValue { get; set; }
             public Actor.Job _currentJob { get; set; }
             public bool init { get; set; }
diff --git a/Chromatics/Layers/DynamicLayers/Keybinds.cs b/Chromatics/Layers/DynamicLayers/Keybinds.cs
index cc1e207c..0847152b 100644
--- a/Chromatics/Layers/DynamicLayers/Keybinds.cs
+++ b/Chromatics/Layers/DynamicLayers/Keybinds.cs
@@ -22,6 +22,7 @@ public class KeybindsProcessor : LayerProcessor
     {
         private static KeybindsProcessor _instance;
         private Dictionary<Led, ListLedGroup> _localgroups = new Dictionary<Led, ListLedGroup>();
+        private readonly Dictionary<string, Color> _specialActionColors = new Dictionary<string, Color>(19);
         private SolidColorBrush keybind_cd_brush;
         private SolidColorBrush keybind_na_brush;
         private SolidColorBrush keybind_outranged_brush;
@@ -81,29 +82,28 @@ public override void Process(IMappingLayer layer)
 
                 UpdateBrushColors(layer, _colorPalette);
 
-                // Define special action colors
-                var specialActionColors = new Dictionary<string, Color>
-                {
-                    {"Map", ColorHelper.ColorToRGBColor(_colorPalette.KeybindMap.Color)},
-                    {"Aether Currents", ColorHelper.ColorToRGBColor(_colorPalette.KeybindAetherCurrents.Color)},
-                    {"Signs", ColorHelper.ColorToRGBColor(_colorPalette.KeybindSigns.Color)},
-                    {"Waymarks", ColorHelper.ColorToRGBColor(_colorPalette.KeybindWaymarks.Color)},
-                    {"Record Ready Check", ColorHelper.ColorToRGBColor(_colorPalette.KeybindRecordReadyCheck.Color)},
-                    {"Ready Check", ColorHelper.ColorToRGBColor(_colorPalette.KeybindReadyCheck.Color)},
-                    {"Countdown", ColorHelper.ColorToRGBColor(_colorPalette.KeybindCountdown.Color)},
-                    {"Emotes", ColorHelper.ColorToRGBColor(_colorPalette.KeybindEmotes.Color)},
-                    {"Linkshells", ColorHelper.ColorToRGBColor(_colorPalette.KeybindLinkshells.Color)},
-                    {"Cross-world Linkshell", ColorHelper.ColorToRGBColor(_colorPalette.KeybindCrossWorldLS.Color)},
-                    {"Contacts", ColorHelper.ColorToRGBColor(_colorPalette.KeybindContacts.Color)},
-                    {"Sprint", ColorHelper.ColorToRGBColor(_colorPalette.KeybindSprint.Color)},
-                    {"Teleport", ColorHelper.ColorToRGBColor(_colorPalette.KeybindTeleport.Color)},
-                    {"Return", ColorHelper.ColorToRGBColor(_colorPalette.KeybindReturn.Color)},
-                    {"Limit Break", ColorHelper.ColorToRGBColor(_colorPalette.KeybindLimitBreak.Color)},
-                    {"Duty Action", ColorHelper.ColorToRGBColor(_colorPalette.KeybindDutyAction.Color)},
-                    {"Repair", ColorHelper.ColorToRGBColor(_colorPalette.KeybindRepair.Color)},
-                    {"Dig", ColorHelper.ColorToRGBColor(_colorPalette.KeybindDig.Color)},
-                    {"Inventory", ColorHelper.ColorToRGBColor(_colorPalette.KeybindInventory.Color)}
-                };
+                // Repopulate the reusable special-action color map for this tick
+                _specialActionColors.Clear();
+                _specialActionColors["Map"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindMap.Color);
+                _specialActionColors["Aether Currents"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindAetherCurrents.Color);
+                _specialActionColors["Signs"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindSigns.Color);
+                _specialActionColors["Waymarks"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindWaymarks.Color);
+                _specialActionColors["Record Ready Check"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindRecordReadyCheck.Color);
+                _specialActionColors["Ready Check"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindReadyCheck.Color);
+                _specialActionColors["Countdown"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindCountdown.Color);
+                _specialActionColors["Emotes"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindEmotes.Color);
+                _specialActionColors["Linkshells"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindLinkshells.Color);
+                _specialActionColors["Cross-world Linkshell"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindCrossWorldLS.Color);
+                _specialActionColors["Contacts"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindContacts.Color);
+                _specialActionColors["Sprint"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindSprint.Color);
+                _specialActionColors["Teleport"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindTeleport.Color);
+                _specialActionColors["Return"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindReturn.Color);
+                _specialActionColors["Limit Break"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindLimitBreak.Color);
+                _specialActionColors["Duty Action"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindDutyAction.Color);
+                _specialActionColors["Repair"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindRepair.Color);
+                _specialActionColors["Dig"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindDig.Color);
+                _specialActionColors["Inventory"] = ColorHelper.ColorToRGBColor(_colorPalette.KeybindInventory.Color);
+                var specialActionColors = _specialActionColors;
 
                 InitializeLedGroups(ledArray, layer.zindex);
 
@@ -128,7 +128,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/MPTracker.cs b/Chromatics/Layers/DynamicLayers/MPTracker.cs
index 53c48c0f..914cf2d8 100644
--- a/Chromatics/Layers/DynamicLayers/MPTracker.cs
+++ b/Chromatics/Layers/DynamicLayers/MPTracker.cs
@@ -171,7 +171,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/ReactiveWeatherHighlight.cs b/Chromatics/Layers/DynamicLayers/ReactiveWeatherHighlight.cs
index f15b59b2..b9c2f51e 100644
--- a/Chromatics/Layers/DynamicLayers/ReactiveWeatherHighlight.cs
+++ b/Chromatics/Layers/DynamicLayers/ReactiveWeatherHighlight.cs
@@ -85,7 +85,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
 
                 layergroup.Brush = weather_brush;
                 layergroup.Detach();
diff --git a/Chromatics/Layers/DynamicLayers/TargetCastbar.cs b/Chromatics/Layers/DynamicLayers/TargetCastbar.cs
index 106c6fff..9bd3673c 100644
--- a/Chromatics/Layers/DynamicLayers/TargetCastbar.cs
+++ b/Chromatics/Layers/DynamicLayers/TargetCastbar.cs
@@ -36,6 +36,8 @@ public static TargetCastbarProcessor Instance
 
         public override void Process(IMappingLayer layer)
         {
+            if (_disposed) return;
+
             TargetCastbarDynamicModel model;
 
             if (!layerProcessorModel.ContainsKey(layer.layerID))
@@ -78,10 +80,11 @@ public override void Process(IMappingLayer layer)
                 var full_col = ColorHelper.ColorToRGBColor(_colorPalette.TargetCastbar.Color);
                 var empty_col = ColorHelper.ColorToRGBColor(_colorPalette.TargetCastbarEmpty.Color); // Bleed layer
 
-                model.full_brush = model.full_brush ?? new SolidColorBrush(full_col);
-                model.empty_brush = layer.allowBleed
-                    ? new SolidColorBrush(Color.Transparent)
-                    : new SolidColorBrush(empty_col);
+                model.full_brush ??= new SolidColorBrush(full_col);
+                model.full_brush.Color = full_col;
+
+                model.empty_brush ??= new SolidColorBrush(layer.allowBleed ? Color.Transparent : empty_col);
+                model.empty_brush.Color = layer.allowBleed ? Color.Transparent : empty_col;
 
                 // Check if layer mode has changed
                 if (model._currentMode != layer.layerModes)
@@ -149,7 +152,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/DynamicLayers/TargetHP.cs b/Chromatics/Layers/DynamicLayers/TargetHP.cs
index 5ab6d351..2528c8e1 100644
--- a/Chromatics/Layers/DynamicLayers/TargetHP.cs
+++ b/Chromatics/Layers/DynamicLayers/TargetHP.cs
@@ -183,7 +183,7 @@ public override void Process(IMappingLayer layer)
                 }
                 else
                 {
-                    _layergroups.Add(layer.layerID, lg);
+                    _layergroups[layer.layerID] = lg;
                 }
             }
 
diff --git a/Chromatics/Layers/EffectLayers/CutsceneAnimation.cs b/Chromatics/Layers/EffectLayers/CutsceneAnimation.cs
index 7f57f59d..6f58a80b 100644
--- a/Chromatics/Layers/EffectLayers/CutsceneAnimation.cs
+++ b/Chromatics/Layers/EffectLayers/CutsceneAnimation.cs
@@ -76,7 +76,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 layergroup.Detach();
             }
 
@@ -154,7 +154,6 @@ public override void Process(IMappingLayer layer)
                 new GradientStop(1.00f, baseColor));
 
             var gradientMove = new MoveGradientDecorator(surface, 80, true);
-            var animation = new StarfieldDecorator(layergroup, (layergroup.Count() / 4), 10, 500, highlightColors, surface, false, baseColor);
 
             // Process data from FFXIV
             var _memoryHandler = GameController.GetGameData();
diff --git a/Chromatics/Layers/EffectLayers/DamageFlash.cs b/Chromatics/Layers/EffectLayers/DamageFlash.cs
index b8119306..e21771d7 100644
--- a/Chromatics/Layers/EffectLayers/DamageFlash.cs
+++ b/Chromatics/Layers/EffectLayers/DamageFlash.cs
@@ -95,30 +95,11 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 layergroup.Detach();
             }
 
             var highlight_col = ColorHelper.ColorToRGBColor(_colorPalette.DamageFlashAnimation.Color);
-            // Opacity 1.0 so peak-envelope renders at full alpha. RGB.NET's
-            // Led.Color setter alpha-blends via Color+, so a 0.5 default would
-            // only produce a ~50% tint over a bright raid decorator write —
-            // visually swamped. ShotFlashDecorator modulates A through its
-            // ADSR envelope, ramping in/out smoothly.
-            var highlight_brush = new SolidColorBrush(highlight_col)
-            {
-                Opacity = 1.0f
-            };
-
-            var flash = new ShotFlashDecorator(surface)
-            {
-                IsEnabled = true,
-                Order = 100,
-                Attack = 0.15f,
-                Release = 0.15f,
-                Sustain = 0.1f,
-                Repetitions = 1
-            };
 
             // Process data from FFXIV
             var _memoryHandler = GameController.GetGameData();
@@ -144,6 +125,26 @@ public override void Process(IMappingLayer layer)
                         const float autoAttackThreshold = 0.015f;
                         if (damageRatio >= autoAttackThreshold)
                         {
+                            // Opacity 1.0 so peak-envelope renders at full alpha. RGB.NET's
+                            // Led.Color setter alpha-blends via Color+, so a 0.5 default would
+                            // only produce a ~50% tint over a bright raid decorator write —
+                            // visually swamped. ShotFlashDecorator modulates A through its
+                            // ADSR envelope, ramping in/out smoothly.
+                            var highlight_brush = new SolidColorBrush(highlight_col)
+                            {
+                                Opacity = 1.0f
+                            };
+
+                            var flash = new ShotFlashDecorator(surface)
+                            {
+                                IsEnabled = true,
+                                Order = 100,
+                                Attack = 0.15f,
+                                Release = 0.15f,
+                                Sustain = 0.1f,
+                                Repetitions = 1
+                            };
+
                             // Scale flash opacity depending on how much damage taken. More damage = brighter flash
                             if (effectSettings.effect_damageflash_scaledamage)
                             {
@@ -152,7 +153,7 @@ public override void Process(IMappingLayer layer)
 
                                 var minOpacity = effectSettings.effect_damageflash_min_flash;
                                 if (minOpacity > 1) minOpacity = 1;
-                                if (minOpacity < 1) minOpacity = 0;
+                                if (minOpacity < 0) minOpacity = 0;
 
                                 var opacity = Math.Max((float)minOpacity, (float)damageRatio);
                                 highlight_brush.Opacity = opacity;
diff --git a/Chromatics/Layers/EffectLayers/DutyFinderBell.cs b/Chromatics/Layers/EffectLayers/DutyFinderBell.cs
index 22218f1f..996c12c3 100644
--- a/Chromatics/Layers/EffectLayers/DutyFinderBell.cs
+++ b/Chromatics/Layers/EffectLayers/DutyFinderBell.cs
@@ -69,7 +69,7 @@ public override void Process(IMappingLayer layer)
                 };
 
                 var lg = new ListLedGroup[] { layergroup };
-                _layergroups.Add(layer.layerID, lg);
+                _layergroups[layer.layerID] = lg;
                 layergroup.Detach();
             }
 
diff --git a/Chromatics/Layers/LayerProcessor.cs b/Chromatics/Layers/LayerProcessor.cs
index 72b5c53c..d34bc09c 100644
--- a/Chromatics/Layers/LayerProcessor.cs
+++ b/Chromatics/Layers/LayerProcessor.cs
@@ -31,7 +31,8 @@ internal Led[] GetLedArray(IMappingLayer layer)
                 return Array.Empty<Led>();
             }
 
-            return device.Where(led => layer.deviceLeds.Any(v => v.Value.Equals(led.Id))).ToArray();
+            var ledSet = new HashSet<LedId>(layer.deviceLeds.Values);
+            return device.Where(led => ledSet.Contains(led.Id)).ToArray();
         }
 
         internal Led[] GetLedSortedArray(IMappingLayer layer)
@@ -59,7 +60,8 @@ internal Led[] GetLedBaseArray(IMappingLayer layer, Layer baseLayer)
                 return Array.Empty<Led>();
             }
 
-            return device.Where(led => baseLayer.deviceLeds.Any(v => v.Value.Equals(led.Id))).ToArray();
+            var ledSet = new HashSet<LedId>(baseLayer.deviceLeds.Values);
+            return device.Where(led => ledSet.Contains(led.Id)).ToArray();
         }
 
         internal IRGBDevice GetDevice(IMappingLayer layer)
@@ -169,24 +171,13 @@ protected override void Dispose(bool disposing)
 
 
 
-    public static class BaseLayerProcessorFactory
-    {
-        private static readonly Dictionary<BaseLayerType, LayerProcessor> layerProcessors = new Dictionary<BaseLayerType, LayerProcessor>
-        {
-            { BaseLayerType.Static, StaticProcessor.Instance },
-            { BaseLayerType.ReactiveWeather, ReactiveWeatherProcessor.Instance },
-            { BaseLayerType.BattleStance, BaseBattleStanceProcessor.Instance },
-            { BaseLayerType.JobClasses, JobClassesProcessor.Instance },
-            { BaseLayerType.ScreenCapture, ScreenCaptureProcessor.Instance },
-        };
-
-        public static Dictionary<BaseLayerType, LayerProcessor> GetProcessors()
-        {
-            return layerProcessors;
-        }
-    }
-
-
+    // The matching BaseLayerProcessorFactory and DynamicLayerProcessorFactory
+    // maps were deleted: nothing called them, and their static initialisers
+    // eagerly built every processor singleton while the entries drifted out
+    // of date (missing AudioVisualizer, JobGaugeC, the focus-target layers).
+    // GameController dispatches base + dynamic layers through
+    // LayerProcessorFactory.GetProcessor instead. EffectLayerProcessorFactory
+    // stays - GameController iterates its map for effect-layer dispatch.
     public static class EffectLayerProcessorFactory
     {
         private static readonly Dictionary<EffectLayerType, LayerProcessor> layerProcessors = new Dictionary<EffectLayerType, LayerProcessor>
@@ -205,33 +196,4 @@ public static Dictionary<EffectLayerType, LayerProcessor> GetProcessors()
     }
 
 
-    public static class DynamicLayerProcessorFactory
-    {
-        private static readonly Dictionary<DynamicLayerType, LayerProcessor> layerProcessors = new Dictionary<DynamicLayerType, LayerProcessor>
-        {
-            { DynamicLayerType.None, NoneProcessor.Instance },
-            { DynamicLayerType.Highlight, HighlightProcessor.Instance },
-            { DynamicLayerType.Keybinds, KeybindsProcessor.Instance },
-            { DynamicLayerType.EnmityTracker, EnmityTrackerProcessor.Instance },
-            { DynamicLayerType.TargetHP, TargetHPProcessor.Instance },
-            { DynamicLayerType.TargetCastbar, TargetCastbarProcessor.Instance },
-            { DynamicLayerType.HPTracker, HPTrackerProcessor.Instance },
-            { DynamicLayerType.MPTracker, MPTrackerProcessor.Instance },
-            { DynamicLayerType.JobGaugeA, JobGaugeAProcessor.Instance },
-            { DynamicLayerType.JobGaugeB, JobGaugeBProcessor.Instance },
-            { DynamicLayerType.ExperienceTracker, ExperienceTrackerProcessor.Instance },
-            { DynamicLayerType.BattleStance, DynamicBattleStanceProcessor.Instance },
-            { DynamicLayerType.Castbar, CastbarProcessor.Instance },
-            { DynamicLayerType.JobClassesHighlight, JobClassesHighlightProcessor.Instance },
-            { DynamicLayerType.ReactiveWeatherHighlight, ReactiveWeatherHighlightProcessor.Instance }
-        };
-
-        public static Dictionary<DynamicLayerType, LayerProcessor> GetProcessors()
-        {
-            return layerProcessors;
-        }
-    }
-
-
-
 }
diff --git a/Chromatics/Layers/LayerProcessorFactory.cs b/Chromatics/Layers/LayerProcessorFactory.cs
index 86ffacc4..474cf47e 100644
--- a/Chromatics/Layers/LayerProcessorFactory.cs
+++ b/Chromatics/Layers/LayerProcessorFactory.cs
@@ -104,6 +104,8 @@ private LayerProcessor CreateDynamicProcessor(DynamicLayerType type)
                 DynamicLayerType.Castbar => CastbarProcessor.Instance,
                 DynamicLayerType.JobClassesHighlight => JobClassesHighlightProcessor.Instance,
                 DynamicLayerType.ReactiveWeatherHighlight => ReactiveWeatherHighlightProcessor.Instance,
+                DynamicLayerType.FocusTargetHP => FocusTargetHPProcessor.Instance,
+                DynamicLayerType.FocusTargetCastbar => FocusTargetCastbarProcessor.Instance,
                 _ => throw new ArgumentException("Unknown DynamicLayerType")
             };
         }
diff --git a/Chromatics/Layers/MappingLayers.cs b/Chromatics/Layers/MappingLayers.cs
index cd7be629..6294bc6d 100644
--- a/Chromatics/Layers/MappingLayers.cs
+++ b/Chromatics/Layers/MappingLayers.cs
@@ -395,6 +395,8 @@ public static bool LoadMappings(bool over = false)
             var (tempLayers, tempDeviceLayouts, tempDeviceBrightness, tempDisabledDevices) = FileOperationsHelper.LoadLayerMappings();
             if (tempLayers == null) return false;
 
+            SanitizeLayerTypeIndexes(tempLayers);
+
             // Device layout overrides live in a separate top-level field in the
             // V3 file, so they come through as-is without going near the layer
             // migration path. Always replace wholesale — partial merges would
@@ -484,12 +486,46 @@ public static bool SaveMappings()
             return true;
         }
 
+        // Resets any layer whose layerTypeindex this build doesn't recognise.
+        // A layers.chromatics4 written by a newer Chromatics can carry layer
+        // positions beyond this build's enums (the 4.3.3 focus-target dynamic
+        // layers at positions 16 / 17 are the first case). Without the reset
+        // the stored position flows into GameController's
+        // (DynamicLayerType)layer.layerTypeindex cast and
+        // LayerProcessorFactory throws "Unknown DynamicLayerType" on every
+        // frame. Resetting to position 0 (None for dynamic layers) keeps the
+        // rest of the file loadable and shows the layer as None in the
+        // Mappings tab for the user to reassign.
+        private static void SanitizeLayerTypeIndexes(ConcurrentDictionary<int, Layer> layers)
+        {
+            if (layers == null) return;
+            foreach (var layer in layers.Values)
+            {
+                bool known = layer.rootLayerType switch
+                {
+                    LayerType.BaseLayer => Enum.IsDefined(typeof(BaseLayerType), layer.layerTypeindex),
+                    LayerType.DynamicLayer => Enum.IsDefined(typeof(DynamicLayerType), layer.layerTypeindex),
+                    LayerType.EffectLayer => Enum.IsDefined(typeof(EffectLayerType), layer.layerTypeindex),
+                    _ => false
+                };
+
+                if (!known)
+                {
+                    Logger.WriteConsole(Enums.LoggerTypes.System,
+                        $"Layer {layer.layerID} uses layer type {layer.layerTypeindex}, which this version of Chromatics doesn't support. The layer was reset to None.");
+                    layer.layerTypeindex = 0;
+                    layer.requestUpdate = true;
+                }
+            }
+        }
+
         public static bool ImportMappings(ConcurrentDictionary<int, Layer> importedLayer = null, bool empty = false)
         {
             var layers = importedLayer;
 
             if (layers != null)
             {
+                SanitizeLayerTypeIndexes(layers);
 
 
                 var migratedLayers = new Dictionary<int, Layer>();
@@ -658,9 +694,13 @@ public class DeviceKeyPosition
     //   v5: + disabledDevices (set of GUIDs the user disabled in the
     //       Mapping tab; persisted across launches so the device stays
     //       detached from the surface until re-enabled)
+    //   v6: no shape change. Marks files that can carry the focus-target
+    //       dynamic layer positions (16 / 17) added in 4.3.3, paired with
+    //       the SanitizeLayerTypeIndexes guard that resets unknown
+    //       positions on load / import.
     public class MappingFileV3
     {
-        public int schemaVersion { get; set; } = 5;
+        public int schemaVersion { get; set; } = 6;
         public ConcurrentDictionary<int, Layer> layers { get; set; } = new ConcurrentDictionary<int, Layer>();
         public Dictionary<Guid, Dictionary<LedId, DeviceKeyPosition>> deviceLayouts { get; set; }
             = new Dictionary<Guid, Dictionary<LedId, DeviceKeyPosition>>();
diff --git a/Chromatics/Models/PaletteColorModel.cs b/Chromatics/Models/PaletteColorModel.cs
index fc0fb505..7ea5541b 100644
--- a/Chromatics/Models/PaletteColorModel.cs
+++ b/Chromatics/Models/PaletteColorModel.cs
@@ -67,6 +67,12 @@ public class PaletteColorModel
         public ColorMapping TargetHpClaimed = new("Target HP (Claimed)", PaletteTypes.TargetEnemy, Color.Red);
         public ColorMapping TargetHpEmpty = new("Target HP (Empty)", PaletteTypes.TargetEnemy, Color.Black);
         public ColorMapping TargetHpIdle = new("Target HP (Idle)", PaletteTypes.TargetEnemy, Color.Yellow);
+        public ColorMapping FocusTargetCastbar = new("Focus Target Cast Bar Charge Build", PaletteTypes.TargetEnemy, Color.Orange);
+        public ColorMapping FocusTargetCastbarEmpty = new("Focus Target Cast Bar Charge Empty", PaletteTypes.TargetEnemy, Color.Black);
+        public ColorMapping FocusTargetHpFriendly = new("Focus Target HP (Friendly)", PaletteTypes.TargetEnemy, Color.Lime);
+        public ColorMapping FocusTargetHpClaimed = new("Focus Target HP (Claimed)", PaletteTypes.TargetEnemy, Color.Red);
+        public ColorMapping FocusTargetHpEmpty = new("Focus Target HP (Empty)", PaletteTypes.TargetEnemy, Color.Black);
+        public ColorMapping FocusTargetHpIdle = new("Focus Target HP (Idle)", PaletteTypes.TargetEnemy, Color.Yellow);
 
         //Status Effects
         public ColorMapping Amnesia = new("Amnesia", PaletteTypes.StatusEffects, Color.Snow);
diff --git a/Chromatics/ViewModels/ConsoleViewModel.cs b/Chromatics/ViewModels/ConsoleViewModel.cs
index ae027fd6..2ada8dc0 100644
--- a/Chromatics/ViewModels/ConsoleViewModel.cs
+++ b/Chromatics/ViewModels/ConsoleViewModel.cs
@@ -50,8 +50,15 @@ private void Append(OnConsoleLoggedEventArgs e)
 
             if (Entries.Count > MaxEntries)
             {
-                for (int i = 0; i < TrimChunk && Entries.Count > 0; i++)
-                    Entries.RemoveAt(0);
+                // Snapshot the entries we keep, then rebuild via Clear +
+                // re-Add. Each RemoveAt(0) shifts the whole backing array,
+                // so trimming 500 entries cost ~500 full-list shifts; the
+                // rebuild appends instead, trading the Remove notifications
+                // for one Reset plus the re-Adds.
+                var retained = Entries.Skip(TrimChunk).ToList();
+                Entries.Clear();
+                foreach (var entry in retained)
+                    Entries.Add(entry);
             }
 
             EntryAdded?.Invoke(this, EventArgs.Empty);
diff --git a/Chromatics/ViewModels/CopyLayersDialogViewModel.cs b/Chromatics/ViewModels/CopyLayersDialogViewModel.cs
index ad42aa3c..4a6c29da 100644
--- a/Chromatics/ViewModels/CopyLayersDialogViewModel.cs
+++ b/Chromatics/ViewModels/CopyLayersDialogViewModel.cs
@@ -269,6 +269,8 @@ private static string BuildLayerDisplayName(Layer layer)
             DynamicLayerType.Castbar,
             DynamicLayerType.JobClassesHighlight,
             DynamicLayerType.ReactiveWeatherHighlight,
+            DynamicLayerType.FocusTargetHP,
+            DynamicLayerType.FocusTargetCastbar,
         };
 
         private static DynamicLayerType DynamicLayerTypeFromComboIndex(int index)
diff --git a/Chromatics/ViewModels/HueAdoptionDialogViewModel.cs b/Chromatics/ViewModels/HueAdoptionDialogViewModel.cs
index 82774347..e64a569c 100644
--- a/Chromatics/ViewModels/HueAdoptionDialogViewModel.cs
+++ b/Chromatics/ViewModels/HueAdoptionDialogViewModel.cs
@@ -10,7 +10,7 @@
 
 namespace Chromatics.ViewModels
 {
-    public partial class HueAdoptionDialogViewModel : ViewModelBase
+    public partial class HueAdoptionDialogViewModel : ViewModelBase, IDisposable
     {
         public ObservableCollection<HueBulbItem> Bulbs { get; } = new();
 
@@ -42,6 +42,11 @@ private void UpdateStatus()
                 StatusText = string.Format(LocalizationService.Instance["{0} Hue light(s) on this bridge."], Bulbs.Count);
         }
 
+        public void Dispose()
+        {
+            LocalizationService.Instance.PropertyChanged -= OnLocaleChanged;
+        }
+
         // Query the bridge for its lights, merging with the user's already-
         // adopted set so previously-adopted bulbs come back pre-checked. New
         // lights since the last adoption are unchecked by default.
@@ -54,8 +59,8 @@ public async Task LoadBulbsAsync(string bridgeIp, string bridgeKey, IReadOnlyDic
             try
             {
                 var api = new LocalHueApi(bridgeIp, bridgeKey);
-                var lights = await api.Light.GetAllAsync().ConfigureAwait(false);
-                var devices = await api.Device.GetAllAsync().ConfigureAwait(false);
+                var lights = await api.Light.GetAllAsync();
+                var devices = await api.Device.GetAllAsync();
 
                 var modelByDevice = new Dictionary<Guid, string>();
                 foreach (var d in devices.Data)
diff --git a/Chromatics/ViewModels/LifxAdoptionDialogViewModel.cs b/Chromatics/ViewModels/LifxAdoptionDialogViewModel.cs
index db232149..99c444fa 100644
--- a/Chromatics/ViewModels/LifxAdoptionDialogViewModel.cs
+++ b/Chromatics/ViewModels/LifxAdoptionDialogViewModel.cs
@@ -10,7 +10,7 @@
 
 namespace Chromatics.ViewModels
 {
-    public partial class LifxAdoptionDialogViewModel : ViewModelBase
+    public partial class LifxAdoptionDialogViewModel : ViewModelBase, IDisposable
     {
         // Discovered + already-adopted bulbs are merged into a single list,
         // pre-checked for any MAC that's already adopted. The dialog reads
@@ -45,6 +45,11 @@ private void UpdateStatus()
                 StatusText = string.Format(LocalizationService.Instance["{0} LIFX device(s) found."], Bulbs.Count);
         }
 
+        public void Dispose()
+        {
+            LocalizationService.Instance.PropertyChanged -= OnLocaleChanged;
+        }
+
         // Run discovery, merging results with the supplied list of already-
         // adopted MACs. Pre-existing devices stay pre-checked; newly-found
         // devices are unchecked; devices that were adopted but aren't on the
diff --git a/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs b/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs
index 0c9611da..395bcd54 100644
--- a/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs
+++ b/Chromatics/ViewModels/Mapping/LayerItemViewModel.cs
@@ -22,7 +22,7 @@ namespace Chromatics.ViewModels.Mapping
     // Wraps a single Layer in MappingLayers. Mutations commit straight back
     // through MappingLayers.UpdateLayer so the VM and persistence stay in
     // sync without a separate save step per property.
-    public sealed partial class LayerItemViewModel : ObservableObject
+    public sealed partial class LayerItemViewModel : ObservableObject, IDisposable
     {
         private readonly Layer _layer;
         private readonly Action<int> _onDelete;
@@ -251,6 +251,11 @@ public string HelpText
             { (Actor.Job.AST, DynamicLayerType.JobGaugeC), "Draw Type (Astral / Umbral). Indicates which side of the draw cycle is currently active." },
         };
 
+        public void Dispose()
+        {
+            LocService.Instance.PropertyChanged -= OnLocaleVersionChanged;
+        }
+
         public void RefreshHelpText() => OnPropertyChanged(nameof(HelpText));
 
         [RelayCommand] private void Edit() => _onEdit?.Invoke(_layer.layerID);
@@ -278,6 +283,8 @@ public string HelpText
             DynamicLayerType.Castbar,
             DynamicLayerType.JobClassesHighlight,
             DynamicLayerType.ReactiveWeatherHighlight,
+            DynamicLayerType.FocusTargetHP,
+            DynamicLayerType.FocusTargetCastbar,
         ];
 
         private static IReadOnlyList<LayerTypeOption> BuildTypeOptions(LayerType layerType) => layerType switch
diff --git a/Chromatics/ViewModels/Mapping/MappingViewModel.cs b/Chromatics/ViewModels/Mapping/MappingViewModel.cs
index e7a635a2..babe9951 100644
--- a/Chromatics/ViewModels/Mapping/MappingViewModel.cs
+++ b/Chromatics/ViewModels/Mapping/MappingViewModel.cs
@@ -328,6 +328,8 @@ private static void CreateDefaultLayers(Guid deviceId, IRGBDevice device)
 
         public void RefreshLayers()
         {
+            foreach (var item in Layers)
+                item.Dispose();
             Layers.Clear();
             if (SelectedDevice == null) return;
 
@@ -378,6 +380,7 @@ public void RemoveLayer(int layerId)
 
             if (_selectedLayerIdForDisplay == layerId) _selectedLayerIdForDisplay = -1;
 
+            vm.Dispose();
             Layers.Remove(vm);
             MappingLayers.RemoveLayer(layerId);
             MappingLayers.SaveMappings();
diff --git a/Chromatics/ViewModels/SettingsViewModel.cs b/Chromatics/ViewModels/SettingsViewModel.cs
index 7b601ac3..5556cfd5 100644
--- a/Chromatics/ViewModels/SettingsViewModel.cs
+++ b/Chromatics/ViewModels/SettingsViewModel.cs
@@ -41,8 +41,6 @@ namespace Chromatics.ViewModels
 {
     public sealed class SettingsViewModel : ViewModelBase
     {
-        private readonly RegistryKey _runKey = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run", true);
-
         public ObservableCollection<DeviceToggleItem> DeviceToggles { get; } = new();
         public ObservableCollection<ThemeOption> ThemeOptions { get; } = new();
         public ObservableCollection<LanguageOption> LanguageOptions { get; } = new();
@@ -1010,10 +1008,11 @@ public bool TrayOnStartup
 
                     try
                     {
+                        using var runKey = Registry.CurrentUser.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Run", true);
                         if (value)
-                            _runKey?.SetValue("Chromatics4", Environment.ProcessPath ?? Assembly.GetExecutingAssembly().Location);
+                            runKey?.SetValue("Chromatics4", Environment.ProcessPath ?? Assembly.GetExecutingAssembly().Location);
                         else
-                            _runKey?.DeleteValue("Chromatics4", false);
+                            runKey?.DeleteValue("Chromatics4", false);
                     }
                     catch (Exception ex)
                     {
diff --git a/Chromatics/ViewModels/YeelightAdoptionDialogViewModel.cs b/Chromatics/ViewModels/YeelightAdoptionDialogViewModel.cs
index 9627181e..0b3a8adf 100644
--- a/Chromatics/ViewModels/YeelightAdoptionDialogViewModel.cs
+++ b/Chromatics/ViewModels/YeelightAdoptionDialogViewModel.cs
@@ -11,7 +11,7 @@
 
 namespace Chromatics.ViewModels
 {
-    public partial class YeelightAdoptionDialogViewModel : ViewModelBase
+    public partial class YeelightAdoptionDialogViewModel : ViewModelBase, IDisposable
     {
         // Discovered + already-adopted bulbs are merged into a single list,
         // pre-checked for any Id that's already adopted. The dialog reads
@@ -46,6 +46,11 @@ private void UpdateStatus()
                 StatusText = string.Format(LocalizationService.Instance["{0} Yeelight device(s) found."], Bulbs.Count);
         }
 
+        public void Dispose()
+        {
+            LocalizationService.Instance.PropertyChanged -= OnLocaleChanged;
+        }
+
         public async Task StartDiscoveryAsync(IReadOnlyDictionary<string, YeelightAdoptedDevice> alreadyAdopted, CancellationToken ct)
         {
             IsDiscovering = true;
diff --git a/Chromatics/Views/HueAdoptionDialog.axaml.cs b/Chromatics/Views/HueAdoptionDialog.axaml.cs
index 71ba4925..80d979b9 100644
--- a/Chromatics/Views/HueAdoptionDialog.axaml.cs
+++ b/Chromatics/Views/HueAdoptionDialog.axaml.cs
@@ -37,6 +37,7 @@ public HueAdoptionDialog(string bridgeIp, string bridgeKey, IReadOnlyDictionary<
             {
                 _cts?.Cancel();
                 _cts?.Dispose();
+                _vm.Dispose();
             };
         }
 
diff --git a/Chromatics/Views/LifxAdoptionDialog.axaml.cs b/Chromatics/Views/LifxAdoptionDialog.axaml.cs
index d56965f1..ea78344d 100644
--- a/Chromatics/Views/LifxAdoptionDialog.axaml.cs
+++ b/Chromatics/Views/LifxAdoptionDialog.axaml.cs
@@ -35,6 +35,7 @@ public LifxAdoptionDialog(IReadOnlyDictionary<string, LifxAdoptedDevice> already
             {
                 _cts?.Cancel();
                 _cts?.Dispose();
+                _vm.Dispose();
             };
         }
 
diff --git a/Chromatics/Views/YeelightAdoptionDialog.axaml.cs b/Chromatics/Views/YeelightAdoptionDialog.axaml.cs
index 0ecc6635..5b64bc58 100644
--- a/Chromatics/Views/YeelightAdoptionDialog.axaml.cs
+++ b/Chromatics/Views/YeelightAdoptionDialog.axaml.cs
@@ -34,6 +34,7 @@ public YeelightAdoptionDialog(IReadOnlyDictionary<string, YeelightAdoptedDevice>
             {
                 _cts?.Cancel();
                 _cts?.Dispose();
+                _vm.Dispose();
             };
         }
 
diff --git a/Chromatics/locale/de.json b/Chromatics/locale/de.json
index f8457fc4..5457b153 100644
--- a/Chromatics/locale/de.json
+++ b/Chromatics/locale/de.json
@@ -978,5 +978,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "1 Hervorhebungsebene referenziert Tasten anhand ihres aufgedruckten Buchstabens. Soll sie übertragen werden, damit dieselben Buchstaben auf Ihrem neuen Layout weiterhin leuchten?",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "{0} Hervorhebungsebenen referenzieren Tasten anhand ihres aufgedruckten Buchstabens. Sollen sie übertragen werden, damit dieselben Buchstaben auf Ihrem neuen Layout weiterhin leuchten?",
   "Update layers": "Ebenen aktualisieren",
-  "Keep as-is": "Unverändert beibehalten"
+  "Keep as-is": "Unverändert beibehalten",
+  "Focus Target HP": "LP des Fokusziels",
+  "Focus Target Castbar": "Zauberleiste des Fokusziels",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "Zeigt die LP deines Fokusziels über die ausgewählten Tasten an.\n[Unterstützte Modi: Interpolieren, Verblassen]",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "Zeigt den Zauberfortschritt deines Fokusziels über die ausgewählten Tasten an.\n[Unterstützte Modi: Interpolieren, Verblassen]"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/en.json b/Chromatics/locale/en.json
index 11daebbf..4585a7f0 100644
--- a/Chromatics/locale/en.json
+++ b/Chromatics/locale/en.json
@@ -993,5 +993,9 @@
     "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?":  "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?",
     "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?":  "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?",
     "Update layers":  "Update layers",
-    "Keep as-is":  "Keep as-is"
+    "Keep as-is":  "Keep as-is",
+    "Focus Target HP":  "Focus Target HP",
+    "Focus Target Castbar":  "Focus Target Castbar",
+    "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]":  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]",
+    "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]":  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/es.json b/Chromatics/locale/es.json
index a77e21c7..b9d9c6cb 100644
--- a/Chromatics/locale/es.json
+++ b/Chromatics/locale/es.json
@@ -978,5 +978,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "1 capa de resaltado hace referencia a las teclas por la letra impresa. ¿Traducirla para que las mismas letras permanezcan iluminadas en tu nueva distribución?",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "{0} capas de resaltado hacen referencia a las teclas por la letra impresa. ¿Traducirlas para que las mismas letras permanezcan iluminadas en tu nueva distribución?",
   "Update layers": "Actualizar capas",
-  "Keep as-is": "Mantener tal cual"
+  "Keep as-is": "Mantener tal cual",
+  "Focus Target HP": "PS del objetivo de foco",
+  "Focus Target Castbar": "Barra de lanzamiento del objetivo de foco",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "Muestra los PS de tu objetivo de foco en las teclas seleccionadas.\n[Modos compatibles: Interpolar, Desvanecer]",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "Muestra el progreso de lanzamiento de tu objetivo de foco en las teclas seleccionadas.\n[Modos compatibles: Interpolar, Desvanecer]"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/fr.json b/Chromatics/locale/fr.json
index cc2584a8..1661ef35 100644
--- a/Chromatics/locale/fr.json
+++ b/Chromatics/locale/fr.json
@@ -978,5 +978,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "1 calque de surbrillance fait référence aux touches d’après leur lettre imprimée. Le transposer pour que les mêmes lettres restent allumées sur votre nouvelle disposition ?",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "{0} calques de surbrillance font référence aux touches d’après leur lettre imprimée. Les transposer pour que les mêmes lettres restent allumées sur votre nouvelle disposition ?",
   "Update layers": "Mettre à jour les calques",
-  "Keep as-is": "Conserver tel quel"
+  "Keep as-is": "Conserver tel quel",
+  "Focus Target HP": "PV de la cible focalisée",
+  "Focus Target Castbar": "Barre d’incantation de la cible focalisée",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "Affiche les PV de votre cible focalisée sur les touches sélectionnées.\n[Modes pris en charge : Interpolation, Fondu]",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "Affiche la progression de l’incantation de votre cible focalisée sur les touches sélectionnées.\n[Modes pris en charge : Interpolation, Fondu]"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/ja.json b/Chromatics/locale/ja.json
index 1b99a8b6..a683c6dc 100644
--- a/Chromatics/locale/ja.json
+++ b/Chromatics/locale/ja.json
@@ -979,5 +979,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "1つのハイライトレイヤーが、印字された文字でキーを参照しています。新しいレイアウトでも同じ文字のキーが点灯するように変換しますか？",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "{0}個のハイライトレイヤーが、印字された文字でキーを参照しています。新しいレイアウトでも同じ文字のキーが点灯するように変換しますか？",
   "Update layers": "レイヤーを更新",
-  "Keep as-is": "そのままにする"
+  "Keep as-is": "そのままにする",
+  "Focus Target HP": "フォーカスターゲットのHP",
+  "Focus Target Castbar": "フォーカスターゲットのキャストバー",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "選択したキー上にフォーカスターゲットのHPを表示します。\n［対応モード：補間、フェード］",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "選択したキー上にフォーカスターゲットのキャスト進行状況を表示します。\n［対応モード：補間、フェード］"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/ko.json b/Chromatics/locale/ko.json
index 3758b3cf..9e6b79fb 100644
--- a/Chromatics/locale/ko.json
+++ b/Chromatics/locale/ko.json
@@ -979,5 +979,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "하이라이트 레이어 1개가 키에 인쇄된 글자를 기준으로 키를 참조합니다. 새 레이아웃에서도 같은 글자가 켜지도록 변환하시겠습니까?",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "하이라이트 레이어 {0}개가 키에 인쇄된 글자를 기준으로 키를 참조합니다. 새 레이아웃에서도 같은 글자가 켜지도록 변환하시겠습니까?",
   "Update layers": "레이어 업데이트",
-  "Keep as-is": "그대로 유지"
+  "Keep as-is": "그대로 유지",
+  "Focus Target HP": "주시 대상 HP",
+  "Focus Target Castbar": "주시 대상 시전 바",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "선택한 키 전반에 주시 대상의 HP를 표시합니다.\n[지원 모드: 보간, 페이드]",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "선택한 키 전반에 주시 대상의 시전 진행도를 표시합니다.\n[지원 모드: 보간, 페이드]"
 }
\ No newline at end of file
diff --git a/Chromatics/locale/zh_CN.json b/Chromatics/locale/zh_CN.json
index e76136cb..7ba9f29f 100644
--- a/Chromatics/locale/zh_CN.json
+++ b/Chromatics/locale/zh_CN.json
@@ -978,5 +978,9 @@
   "1 Highlight layer references keys by their printed letter. Translate it so the same letters stay lit on your new layout?": "1 个高亮层按键是按其印刷字母引用的。要转换它，以便在新布局上相同的字母保持点亮吗？",
   "{0} Highlight layers reference keys by their printed letter. Translate them so the same letters stay lit on your new layout?": "{0} 个高亮层按键是按其印刷字母引用的。要转换它们，以便在新布局上相同的字母保持点亮吗？",
   "Update layers": "更新层",
-  "Keep as-is": "保持原样"
+  "Keep as-is": "保持原样",
+  "Focus Target HP": "焦点目标生命值",
+  "Focus Target Castbar": "焦点目标施法条",
+  "Shows your focus target's HP across selected keys.\n[Supported Modes: Interpolate, Fade]": "在选定按键上显示你的焦点目标生命值。\n[支持模式：插值、渐隐]",
+  "Shows your focus target's cast progress across selected keys.\n[Supported Modes: Interpolate, Fade]": "在选定按键上显示你的焦点目标施法进度。\n[支持模式：插值、渐隐]"
 }
\ No newline at end of file