diff --git a/cla/cla-1.0.0.md b/cla/cla-1.0.0.md
index c4489434e..a5532c8c2 100644
--- a/cla/cla-1.0.0.md
+++ b/cla/cla-1.0.0.md
@@ -98,19 +98,21 @@ IF THE DISCLAIMER AND DAMAGE WAIVER MENTIONED IN SECTION 4. AND SECTION 5. CANNO
 I have read this Agreement, and fully agree to it by signing it with my GitHub username:
 
 - @abcminiuser
+- @benedekkupper
+- @bodograumann
+- @dancek
 - @eltang
+- @ert78gb
+- @hxv
 - @kareltucek
+- @kenhys
 - @Lauszus
 - @mondalaci
 - @santiagogf89
 - @soraxas
+- @steamraven
+- @stephengroat
 - @tastyger
 - @xdever
-- @stephengroat
-- @ert78gb
 - @xxxajk
-- @dancek
-- @steamraven
-- @benedekkupper
-- @hxv
 - @Zynh0722
diff --git a/doc-dev/reference-manual.md b/doc-dev/reference-manual.md
index f7ac09d2a..6d3598f21 100644
--- a/doc-dev/reference-manual.md
+++ b/doc-dev/reference-manual.md
@@ -46,7 +46,7 @@ The following grammar is supported:
     COMMAND = holdKeymapLayerMax KEYMAPID LAYERID <time in ms (NUMBER)>
     COMMAND = resolveSecondary <time in ms (NUMBER)> [<time in ms (NUMBER)>] <primary action macro action index (ADDRESS)> <secondary action macro action index (ADDRESS)>
     COMMAND = resolveNextKeyId
-    COMMAND = activateKeyPostponed [atLayer LAYERID] KEYID
+    COMMAND = activateKeyPostponed [atLayer LAYERID] [append | prepend]  KEYID
     COMMAND = consumePending <number of keys (NUMBER)>
     COMMAND = postponeNext <number of commands (NUMER)>
     COMMAND = break
@@ -119,7 +119,7 @@ The following grammar is supported:
     COMMAND = set backlight.constantRgb.rgb <number 0-255 (NUMBER)> <number 0-255 (NUMBER)> <number 0-255 (NUMBER)><number 0-255 (NUMBER)>
     COMMAND = set leds.enabled BOOLEAN
     COMMAND = set leds.brightness <0-1 multiple of default (FLOAT)>
-    COMMAND = set leds.fadeTimeout <minutes to fade after (NUMBER)>
+    COMMAND = set leds.fadeTimeout <seconds to fade after (NUMBER)>
     COMMAND = set modifierLayerTriggers.{shift|alt|super|ctrl} {left|right|both}
     CONDITION = {ifShortcut | ifNotShortcut} [IFSHORTCUTFLAGS]* [KEYID]+
     CONDITION = {ifGesture | ifNotGesture} [IFSHORTCUTFLAGS]* [KEYID]+
@@ -320,7 +320,7 @@ We allow postponing key activations in order to allow deciding between some scen
 - `ifPendingKeyReleased/ifNotPendingKeyReleased <queue idx>` is true if the key pending at `idx` in queue has been released. I.e., if there exists matching release event in the queue.
 - `ifKeyPendingAt/ifNotKeyPendingAt <idx> <keyId>` looks into postponing queue at `idx`th waiting key nad compares it to the `keyId`.
 - `consumePending <n>` will remove n records from the queue.
-- `activateKeyPostponed KEYID` will add tap of KEYID at the end of queue. If `atLayer LAYERID` is specified, action will be taken from that layer rather than current one.
+- `activateKeyPostponed KEYID` will add tap of KEYID at the end of queue. If `atLayer LAYERID` is specified, action will be taken from that layer rather than current one. If `prepend` option is specified, event will be place at the beginning of the queue.
 - `resolveSecondary` allows resolution of secondary roles depending on the next key - this allows us to accurately distinguish random press from intentional press of shortcut via secondary role. See `resolveSecondary` entry under Layer switching. Implicitly applies `postponeKeys` modifier.
 - `ifPrimary/ifSecondary` act as an abreviation for `resolveSecondary`. They use postponing mechanism and allow distinguishing between primary and secondary roles.
 - `ifShortcut/ifNotShortcut/ifGesture/ifNotGesture [IFSHORTCUTFLAGS]* [KEYID]*` will wait for next keypresses until sufficient number of keys has been pressed. If the next keypresses correspond to the provided arguments (hardware ids), the keypresses are consumed and the condition is performed. Consuming takes place in both `if` and `ifNot` versions if the full list is matched. E.g., `ifShortcut 090 089 final tapKey C-V; holdKey v`.
@@ -513,6 +513,11 @@ For the purpose of toggling functionality on and off, and for global constants m
     - `backlight.strategy { functional | constantRgb }` sets backlight strategy.
     - `backlight.constantRgb.rgb NUMBER NUMBER NUMBER` allows setting custom constant colour for entire keyboard. E.g.: `set backlight.strategy constantRgb; set backlight.constantRgb.rgb 255 0 0` to make entire keyboard shine red.
 
+- general led configuration:
+    - `leds.enabled BOOLEAN` turns on/off all keyboard leds: i.e., backlight, indicator leds, segment display
+    - `leds.brightness <0-1 multiple of default (FLOAT)>` allows scaling default brightness. E.g., `0.5` will dim entire keyboard to half of the default values that are configured in Agent
+    - `leds.fadeTimeout <seconds to fade after (NUMBER)>` will turn off leds after configured interval.
+
 - modifier layer triggers:
     - `set modifierLayerTriggers.{shift|alt|super|ctrl} {left|right|both}` controls whether modifier layers are triggered by left or right or either of the modifiers.
 
diff --git a/doc-dev/user-guide.md b/doc-dev/user-guide.md
index 8bb8eeedd..96c83f770 100644
--- a/doc-dev/user-guide.md
+++ b/doc-dev/user-guide.md
@@ -139,7 +139,7 @@ releaseKey a
 
 Complex key sequences can be achieved using `tapKeySeq`. For instance, following emoji macro (uses linux  Ctrl+U notation) will produce a shrugging person.
 ```
-tapKeySeq CS-u 1 f 6 0 5 space
+tapKeySeq CS-u 1 f 9 3 7 space
 ```
 
 With these commands, modifiers are encoded using `CSAG`, with optional `LR` for left and right side. E.g., `LC-a` means `left control + a`.
@@ -290,7 +290,7 @@ holdLayer mouse
 ifNotInterrupted tapKey enter
 ```
 
-Regular secondary role with prevention of accidential key taps: (Activates the secondary role immediately, but activates the primary role only if the key has been pressed for at least a certain amount of time. This could be used to emulate the [Space Cadet Shift feature](https://beta.docs.qmk.fm/using-qmk/advanced-keycodes/feature_space_cadet).)
+Regular secondary role with prevention of accidential key taps: (Activates the secondary role immediately, but activates the primary role only if the key has been pressed for at least a certain amount of time. This could be used to emulate the [Space Cadet Shift feature](https://docs.qmk.fm/#/feature_space_cadet).)
 
 ```
 holdKey leftShift
diff --git a/right/src/keymap.c b/right/src/keymap.c
index b51575e75..cd5972766 100644
--- a/right/src/keymap.c
+++ b/right/src/keymap.c
@@ -1,6 +1,7 @@
 #include "arduino_hid/ConsumerAPI.h"
 #include "arduino_hid/SystemAPI.h"
 #include "keymap.h"
+#include "layer_switcher.h"
 #include "led_display.h"
 #include "ledmap.h"
 #include "config_parser/parse_keymap.h"
@@ -27,7 +28,9 @@ void SwitchKeymapById(uint8_t index)
     ParseKeymap(&ValidatedUserConfigBuffer, index, AllKeymapsCount, AllMacrosCount);
     LedDisplay_UpdateText();
     UpdateLayerLeds();
+    MacroEvent_RegisterLayerMacros();
     MacroEvent_OnKeymapChange(index);
+    MacroEvent_OnLayerChange(ActiveLayer);
 }
 
 uint8_t FindKeymapByAbbreviation(uint8_t length, const char *abbrev) {
diff --git a/right/src/layer_switcher.c b/right/src/layer_switcher.c
index e71553b48..67914fca0 100644
--- a/right/src/layer_switcher.c
+++ b/right/src/layer_switcher.c
@@ -1,6 +1,7 @@
 #include "layer_switcher.h"
 #include "layer.h"
 #include "ledmap.h"
+#include "macro_events.h"
 #include "timer.h"
 #include "macros.h"
 #include "debug.h"
@@ -53,6 +54,7 @@ void updateActiveLayer() {
     // beware lower-upper case typos!
 
     // apply stock layer switching
+    layer_id_t previousLayer = ActiveLayer;
     layer_id_t activeLayer = NONE;
     bool activeLayerHeld = false;
     if(activeLayer == NONE) {
@@ -77,8 +79,12 @@ void updateActiveLayer() {
     //(write actual ActiveLayer atomically, so that random observer is not confused)
     ActiveLayer = activeLayer;
     ActiveLayerHeld = activeLayerHeld;
-    UpdateLayerLeds();
     LedDisplay_SetLayer(ActiveLayer);
+
+    if (ActiveLayer != previousLayer) {
+        UpdateLayerLeds();
+        MacroEvent_OnLayerChange(activeLayer);
+    }
 }
 
 /*
diff --git a/right/src/macro_events.c b/right/src/macro_events.c
index 2a8255bce..b418c020c 100644
--- a/right/src/macro_events.c
+++ b/right/src/macro_events.c
@@ -1,3 +1,5 @@
+#include "layer.h"
+#include "string.h"
 #include "str_utils.h"
 #include "macro_events.h"
 #include "config_parser/parse_macro.h"
@@ -6,6 +8,11 @@
 #include "led_display.h"
 #include "debug.h"
 
+
+static macro_index_t anyLayerChangeMacro = MacroIndex_None;
+static macro_index_t layerChangeMacro[LayerId_Count];
+static macro_index_t keymapLayerChangeMacro[LayerId_Count];
+
 /**
  * Future possible extensions:
  * - generalize change to always handle "in" and "out" events
@@ -26,7 +33,15 @@ void MacroEvent_OnInit()
     }
 }
 
-void processOnKeymapChange(const char* curAbbrev, const char* curAbbrevEnd)
+static void startMacroInSlot(macro_index_t macroIndex, uint8_t* slotId) {
+    if (*slotId != 255 && MacroState[*slotId].ms.macroPlaying) {
+        *slotId = Macros_QueueMacro(macroIndex, NULL, *slotId);
+    } else {
+        *slotId = Macros_StartMacro(macroIndex, NULL, 255, false);
+    }
+}
+
+static void processOnKeymapChange(const char* curAbbrev, const char* curAbbrevEnd)
 {
     for (int i = 0; i < AllMacrosCount; i++) {
         const char *thisName, *thisNameEnd;
@@ -36,18 +51,13 @@ void processOnKeymapChange(const char* curAbbrev, const char* curAbbrevEnd)
             const char* macroArg = NextTok(thisName,thisNameEnd);
 
             if (TokenMatches2(macroArg, thisNameEnd, curAbbrev, curAbbrevEnd)) {
-                if (previousEventMacroSlot != 255 && MacroState[previousEventMacroSlot].ms.macroPlaying) {
-                    previousEventMacroSlot = Macros_QueueMacro(i, NULL, previousEventMacroSlot);
-                } else {
-                    previousEventMacroSlot = Macros_StartMacro(i, NULL, 255, false);
-                }
+                startMacroInSlot(i, &previousEventMacroSlot);
             }
         }
     }
 
 }
 
-
 void MacroEvent_OnKeymapChange(uint8_t keymapIdx)
 {
     keymap_reference_t *keymap = AllKeymaps + keymapIdx;
@@ -58,6 +68,63 @@ void MacroEvent_OnKeymapChange(uint8_t keymapIdx)
 
     processOnKeymapChange(any, any + strlen(any));
     processOnKeymapChange(curAbbrev, curAbbrevEnd);
+}
+
+void MacroEvent_RegisterLayerMacros()
+{
+    keymap_reference_t *keymap = AllKeymaps + CurrentKeymapIndex;
+    const char* curAbbrev = keymap->abbreviation;
+    const char* curAbbrevEnd = keymap->abbreviation + keymap->abbreviationLen;
+
+    anyLayerChangeMacro = MacroIndex_None;
+    memset(layerChangeMacro, MacroIndex_None, sizeof layerChangeMacro);
+    memset(keymapLayerChangeMacro, MacroIndex_None, sizeof layerChangeMacro);
+
+    bool oldParserStatus = Macros_ParserError;
+    Macros_ParserError = false;
+
+    for (int i = 0; i < AllMacrosCount; i++) {
+        const char *thisName, *thisNameEnd;
+        FindMacroName(&AllMacros[i], &thisName, &thisNameEnd);
+
+        if (TokenMatches(thisName, thisNameEnd, "$onKeymapLayerChange")) {
+            const char* macroArg = NextTok(thisName,thisNameEnd);
+            const char* macroArg2 = NextTok(macroArg,thisNameEnd);
+            const layer_id_t layerId = Macros_ParseLayerId(macroArg2, thisNameEnd);
+
+            if (TokenMatches2(macroArg, thisNameEnd, curAbbrev, curAbbrevEnd) && !Macros_ParserError) {
+                keymapLayerChangeMacro[layerId] = i;
+            }
+        }
+
+        if (TokenMatches(thisName, thisNameEnd, "$onLayerChange")) {
+            const char* macroArg = NextTok(thisName,thisNameEnd);
+            if (TokenMatches(macroArg, thisNameEnd, "any") && !Macros_ParserError) {
+                anyLayerChangeMacro = i;
+            } else {
+                const layer_id_t layerId = Macros_ParseLayerId(macroArg, thisNameEnd);
+                if (!Macros_ParserError) {
+                    layerChangeMacro[layerId] = i;
+                }
+            }
+        }
+        Macros_ParserError = false;
+    }
+
+    Macros_ParserError = oldParserStatus;
+}
+
+void MacroEvent_OnLayerChange(layer_id_t layerId)
+{
+    macro_index_t macrosToTry[3] = {
+        anyLayerChangeMacro,
+        layerChangeMacro[layerId],
+        keymapLayerChangeMacro[layerId],
+    };
+
+    for (uint8_t i = 0; i < sizeof macrosToTry; i++) {
+        startMacroInSlot(macrosToTry[i], &previousEventMacroSlot);
+    }
 
     previousEventMacroSlot = 255;
 }
diff --git a/right/src/macro_events.h b/right/src/macro_events.h
index bf108d26b..8e9319533 100644
--- a/right/src/macro_events.h
+++ b/right/src/macro_events.h
@@ -22,5 +22,7 @@
 
     void MacroEvent_OnInit();
     void MacroEvent_OnKeymapChange(uint8_t keymapIdx);
+    void MacroEvent_OnLayerChange(layer_id_t layerId);
+    void MacroEvent_RegisterLayerMacros();
 
 #endif
diff --git a/right/src/macro_set_command.c b/right/src/macro_set_command.c
index 51182498c..9f3a9c9a2 100644
--- a/right/src/macro_set_command.c
+++ b/right/src/macro_set_command.c
@@ -1,4 +1,5 @@
 #include "macro_set_command.h"
+#include "layer.h"
 #include "ledmap.h"
 #include "macros.h"
 #include "timer.h"
@@ -35,6 +36,11 @@ static void moduleNavigationMode(const char* arg1, const char *textEnd, module_c
     layer_id_t layerId = Macros_ParseLayerId(arg1, textEnd);
     navigation_mode_t modeId = ParseNavigationModeId(NextTok(arg1, textEnd), textEnd);
 
+    if (IS_MODIFIER_LAYER(layerId)) {
+        Macros_ReportError("Navigation mode cannot be changed for modifier layers!", NULL, NULL);
+        return;
+    }
+
     if (Macros_ParserError) {
         return;
     }
@@ -237,7 +243,7 @@ static void leds(const char* arg1, const char *textEnd)
 {
     const char* value = NextTok(arg1, textEnd);
     if (TokenMatches(arg1, textEnd, "fadeTimeout")) {
-        LedSleepTimeout = 1000*60*Macros_ParseInt(value, textEnd, NULL);
+        LedSleepTimeout = 1000*Macros_ParseInt(value, textEnd, NULL);
     } else if (TokenMatches(arg1, textEnd, "brightness")) {
         LedBrightnessMultiplier = ParseFloat(value, textEnd);
     } else if (TokenMatches(arg1, textEnd, "enabled")) {
diff --git a/right/src/macros.c b/right/src/macros.c
index 899337dce..81db9d91e 100644
--- a/right/src/macros.c
+++ b/right/src/macros.c
@@ -622,17 +622,20 @@ static macro_result_t dispatchText(const char* text, uint16_t textLen)
 
     // If all characters have been sent, finish.
     if (s->as.dispatchData.textIdx == textLen) {
-        s->as.dispatchData.textIdx = 0;
-        s->as.dispatchData.reportState = REPORT_FULL;
-        memset(&s->ms.macroBasicKeyboardReport, 0, sizeof s->ms.macroBasicKeyboardReport);
-        dispatchMutex = NULL;
-        return MacroResult_Finished;
+        if (s->as.dispatchData.reportState != REPORT_EMPTY) {
+            s->as.dispatchData.reportState = REPORT_EMPTY;
+            memset(&s->ms.macroBasicKeyboardReport, 0, sizeof s->ms.macroBasicKeyboardReport);
+            return MacroResult_Blocking;
+        } else {
+            s->as.dispatchData.textIdx = 0;
+            dispatchMutex = NULL;
+            return MacroResult_Finished;
+        }
     }
 
     // Whenever the report is full, we clear the report and send it empty before continuing.
     if (s->as.dispatchData.reportState == REPORT_FULL) {
         s->as.dispatchData.reportState = REPORT_EMPTY;
-
         memset(&s->ms.macroBasicKeyboardReport, 0, sizeof s->ms.macroBasicKeyboardReport);
         return MacroResult_Blocking;
     }
@@ -2141,10 +2144,27 @@ static bool processIfKeyDefinedCommand(bool negate, const char* arg1, const char
 static macro_result_t processActivateKeyPostponedCommand(const char* arg1, const char* argEnd)
 {
     uint8_t layer = 255;
-    if (TokenMatches(arg1, argEnd, "atLayer")) {
-        const char* arg2 = NextTok(arg1, argEnd);
-        layer = Macros_ParseLayerId(arg2, argEnd);
-        arg1 = NextTok(arg2, argEnd);
+    bool options = true;
+    bool append = true;
+
+    while (options) {
+        options = false;
+        if (TokenMatches(arg1, argEnd, "atLayer")) {
+            const char* arg2 = NextTok(arg1, argEnd);
+            layer = Macros_ParseLayerId(arg2, argEnd);
+            arg1 = NextTok(arg2, argEnd);
+            options = true;
+        }
+        if (TokenMatches(arg1, argEnd, "append")) {
+            arg1 = NextTok(arg1, argEnd);
+            append = true;
+            options = true;
+        }
+        if (TokenMatches(arg1, argEnd, "prepend")) {
+            arg1 = NextTok(arg1, argEnd);
+            append = false;
+            options = true;
+        }
     }
 
     if (Macros_ParserError) {
@@ -2153,12 +2173,24 @@ static macro_result_t processActivateKeyPostponedCommand(const char* arg1, const
 
     uint16_t keyid = parseNUM(arg1, argEnd);
     key_state_t* key = Utils_KeyIdToKeyState(keyid);
-    if (PostponerQuery_IsActiveEventually(key)) {
-        PostponerCore_TrackKeyEvent(key, false, layer);
-        PostponerCore_TrackKeyEvent(key, true, layer);
+
+    if (append) {
+        if (PostponerQuery_IsActiveEventually(key)) {
+            PostponerCore_TrackKeyEvent(key, false, layer);
+            PostponerCore_TrackKeyEvent(key, true, layer);
+        } else {
+            PostponerCore_TrackKeyEvent(key, true, layer);
+            PostponerCore_TrackKeyEvent(key, false, layer);
+        }
     } else {
-        PostponerCore_TrackKeyEvent(key, true, layer);
-        PostponerCore_TrackKeyEvent(key, false, layer);
+        if (KeyState_Active(key)) {
+            //reverse order when prepending
+            PostponerCore_PrependKeyEvent(key, true, layer);
+            PostponerCore_PrependKeyEvent(key, false, layer);
+        } else {
+            PostponerCore_PrependKeyEvent(key, false, layer);
+            PostponerCore_PrependKeyEvent(key, true, layer);
+        }
     }
     return MacroResult_Finished;
 }
@@ -3410,3 +3442,13 @@ void Macros_ClearStatus(void)
 {
     processClearStatusCommand();
 }
+
+bool Macros_MacroHasActiveInstance(macro_index_t macroIdx)
+{
+    for(uint8_t j = 0; j < MACRO_STATE_POOL_SIZE; j++) {
+        if(MacroState[j].ms.macroPlaying && MacroState[j].ms.currentMacroIndex == MacroIndex_UsbCmdReserved) {
+            return true;
+        }
+    }
+    return false;
+}
diff --git a/right/src/macros.h b/right/src/macros.h
index d31e03702..600896b4f 100644
--- a/right/src/macros.h
+++ b/right/src/macros.h
@@ -268,6 +268,7 @@
     void Macros_Initialize();
     void Macros_ClearStatus();
     bool Macros_IsLayerHeld();
+    bool Macros_MacroHasActiveInstance(macro_index_t macroIdx);
     uint8_t Macros_ParseLayerId(const char* arg1, const char* cmdEnd);
     int32_t Macros_ParseInt(const char *a, const char *aEnd, const char* *parsedTill);
     bool Macros_ParseBoolean(const char *a, const char *aEnd);
diff --git a/right/src/postponer.c b/right/src/postponer.c
index 16e864e55..a13e38076 100644
--- a/right/src/postponer.c
+++ b/right/src/postponer.c
@@ -17,7 +17,7 @@ uint8_t cyclesUntilActivation = 0;
 key_state_t* Postponer_NextEventKey;
 uint32_t lastPressTime;
 
-#define POS(idx) ((bufferPosition + (idx)) % POSTPONER_BUFFER_SIZE)
+#define POS(idx) ((bufferPosition + POSTPONER_BUFFER_SIZE + (idx)) % POSTPONER_BUFFER_SIZE)
 
 uint8_t ChordingDelay = 0;
 static void chording();
@@ -88,6 +88,26 @@ bool PostponerCore_IsActive(void)
 }
 
 
+void PostponerCore_PrependKeyEvent(key_state_t *keyState, bool active, uint8_t layer)
+{
+    uint8_t pos = POS(-1);
+
+    if (bufferSize == POSTPONER_BUFFER_SIZE) {
+        return;
+    }
+
+    buffer[pos] = (postponer_buffer_record_type_t) {
+            .time = CurrentTime,
+            .key = keyState,
+            .active = active,
+            .layer = layer,
+    };
+    lastPressTime = active && bufferSize == 0 ? CurrentTime : lastPressTime;
+    bufferSize = bufferSize < POSTPONER_BUFFER_SIZE ? bufferSize + 1 : bufferSize;
+    bufferPosition--;
+}
+
+
 void PostponerCore_TrackKeyEvent(key_state_t *keyState, bool active, uint8_t layer)
 {
     uint8_t pos = POS(bufferSize);
@@ -104,8 +124,8 @@ void PostponerCore_TrackKeyEvent(key_state_t *keyState, bool active, uint8_t lay
             .active = active,
             .layer = layer,
     };
-    bufferSize = bufferSize < POSTPONER_BUFFER_SIZE ? bufferSize + 1 : bufferSize;
     lastPressTime = active ? CurrentTime : lastPressTime;
+    bufferSize = bufferSize < POSTPONER_BUFFER_SIZE ? bufferSize + 1 : bufferSize;
 }
 
 void PostponerCore_RunPostponedEvents(void)
diff --git a/right/src/postponer.h b/right/src/postponer.h
index d9b2e395b..be01fa169 100644
--- a/right/src/postponer.h
+++ b/right/src/postponer.h
@@ -49,6 +49,7 @@
     bool PostponerCore_IsActive(void);
     void PostponerCore_PostponeNCycles(uint8_t n);
     bool PostponerCore_RunKey(key_state_t* key, bool active);
+    void PostponerCore_PrependKeyEvent(key_state_t *keyState, bool active, uint8_t layer);
     void PostponerCore_TrackKeyEvent(key_state_t *keyState, bool active, uint8_t layer);
     void PostponerCore_RunPostponedEvents(void);
     void PostponerCore_FinishCycle(void);
diff --git a/right/src/usb_commands/usb_command_exec_macro_command.c b/right/src/usb_commands/usb_command_exec_macro_command.c
index 94dff2296..d2bcf1aeb 100644
--- a/right/src/usb_commands/usb_command_exec_macro_command.c
+++ b/right/src/usb_commands/usb_command_exec_macro_command.c
@@ -27,11 +27,8 @@ static bool canExecute()
         return false;
     }
 
-    // make sure there is no other instance running
-    for(uint8_t j = 0; j < MACRO_STATE_POOL_SIZE; j++) {
-        if(MacroState[j].ms.macroPlaying && MacroState[j].ms.currentMacroIndex == MacroIndex_UsbCmdReserved) {
-            return false;
-        }
+    if (Macros_MacroHasActiveInstance(MacroIndex_UsbCmdReserved)) {
+        return false;
     }
 
     return true;