diff --git a/device/src/messenger.c b/device/src/messenger.c
index 60f04460..69518a11 100644
--- a/device/src/messenger.c
+++ b/device/src/messenger.c
@@ -17,6 +17,7 @@
 #include "legacy/str_utils.h"
 #include "legacy/event_scheduler.h"
 #include "legacy/slave_drivers/uhk_module_driver.h"
+#include "macros/status_buffer.h"
 
 #if DEVICE_IS_KEYBOARD
 #include "keyboard/uart.h"
@@ -143,11 +144,22 @@ static void processSyncablePropertyRight(device_id_t src, const uint8_t* data, u
     const uint8_t* message = data;
     switch (propertyId) {
         case SyncablePropertyId_LeftHalfKeyStates:
-            for (uint8_t keyId = 0; keyId < MAX_KEY_COUNT_PER_MODULE; keyId++) {
-                KeyStates[SlotId_LeftKeyboardHalf][keyId].hardwareSwitchState = !!(message[keyId/8] & (1 << (keyId % 8)));
-            }
-            EventVector_Set(EventVector_StateMatrix);
-            break;
+            {
+                bool somethingChanged = false;
+                for (uint8_t keyId = 0; keyId < MAX_KEY_COUNT_PER_MODULE; keyId++) {
+                    bool state = !!(message[keyId/8] & (1 << (keyId % 8)));
+                    if (KeyStates[SlotId_LeftKeyboardHalf][keyId].hardwareSwitchState != state) {
+                        KeyStates[SlotId_LeftKeyboardHalf][keyId].hardwareSwitchState = state;
+                        somethingChanged = true;
+
+                        Macros_ReportPrintf(NULL, "M+%s", MacroKeyIdParser_KeyIdToAbbreviation(SlotId_LeftKeyboardHalf*64 + keyId));
+                    }
+                    KeyStates[SlotId_LeftKeyboardHalf][keyId].hardwareSwitchState = !!(message[keyId/8] & (1 << (keyId % 8)));
+                }
+                if (somethingChanged) {
+                    EventVector_Set(EventVector_StateMatrix);
+                }
+            } break;
         case SyncablePropertyId_LeftModuleKeyStates:
             {
                 uint8_t driverId = UhkModuleDriverId_LeftModule;
diff --git a/right/src/debug.h b/right/src/debug.h
index b4e30446..297b5105 100644
--- a/right/src/debug.h
+++ b/right/src/debug.h
@@ -10,6 +10,8 @@
 #define DEBUG_POSTPONER false
 #define WATCH_INTERVAL 500
 
+#define DEBUG_ROLL_STATUS_BUFFER true
+
 #ifdef __ZEPHYR__
     #include "logger.h"
     #include <zephyr/kernel.h>
diff --git a/right/src/event_scheduler.c b/right/src/event_scheduler.c
index d8b62b42..dd5aeebf 100644
--- a/right/src/event_scheduler.c
+++ b/right/src/event_scheduler.c
@@ -221,7 +221,7 @@ void EventVector_ReportMask(const char* prefix, uint32_t mask) {
     REPORT_MASK(MouseKeysReportsUsed);
     REPORT_MASK(MouseControllerMouseReportsUsed);
     REPORT_MASK(MouseControllerKeyboardReportsUsed);
-    REPORT_MASK(ReportsChanged);
+    REPORT_MASK(SendUsbReports);
     REPORT_MASK(NativeActionsPostponing);
     REPORT_MASK(MacroEnginePostponing);
 
diff --git a/right/src/event_scheduler.h b/right/src/event_scheduler.h
index 173d5bf8..b11bd971 100644
--- a/right/src/event_scheduler.h
+++ b/right/src/event_scheduler.h
@@ -49,8 +49,8 @@
        EventVector_MouseController =                       1 << 4,
        EventVector_Postponer =                             1 << 5,
        EventVector_LayerHolds =                            1 << 6,
-       EventVector_ZeroScan =                              1 << 7,
-       EventVector_EventScheduler =                        1 << 8,
+       EventVector_EventScheduler =                        1 << 7,
+       EventVector_MainTriggers =                          ((EventVector_EventScheduler << 1) - 1),
 
 
        // some other minor triggers
@@ -63,9 +63,7 @@
        EventVector_LedMapUpdateNeeded =                    1 << 15,
        EventVector_ApplyConfig =                           1 << 16,
        EventVector_NewMessage =                            1 << 17,
-
-       EventVector_ReportUpdateMask = ((1 << 9) - 1) & ~EventVector_EventScheduler,
-       EventVector_UserLogicUpdateMask = ((1 << 18) - 1) & ~EventVector_EventScheduler,
+       EventVector_AuxiliaryTriggers =                     ((EventVector_NewMessage << 1) - 1),
 
        // events that are informational only
        EventVector_NativeActionReportsUsed =               1 << 18,
@@ -73,14 +71,15 @@
        EventVector_MouseKeysReportsUsed =                  1 << 20,
        EventVector_MouseControllerMouseReportsUsed =       1 << 21,
        EventVector_MouseControllerKeyboardReportsUsed =    1 << 22,
-       EventVector_ReportsChanged =                        1 << 23,
+       EventVector_SendUsbReports =                        1 << 23,
        EventVector_NativeActionsPostponing =               1 << 24,
        EventVector_MacroEnginePostponing =                 1 << 25,
        EventVector_MouseControllerPostponing =             1 << 26,
 
-       // helpers
+       // helper masks
+       EventVector_ReportUpdateMask = EventVector_MainTriggers & ~EventVector_EventScheduler,
+       EventVector_UserLogicUpdateMask = EventVector_AuxiliaryTriggers & ~EventVector_EventScheduler,
        EventVector_SomeonePostponing = EventVector_NativeActionsPostponing | EventVector_MacroEnginePostponing | EventVector_MouseControllerPostponing,
-
     } event_vector_event_t;
 
 /**
diff --git a/right/src/macros/core.c b/right/src/macros/core.c
index bdf9277f..a7256682 100644
--- a/right/src/macros/core.c
+++ b/right/src/macros/core.c
@@ -624,7 +624,7 @@ static void executePreemptive(void)
 
             if (res & MacroResult_BlockingFlag) {
                 SchedulerPostponing = true;
-                EventVector_Set(EventVector_ReportsChanged);
+                EventVector_Set(EventVector_SendUsbReports);
             }
 
             if (S->ms.macroInterrupted) {
@@ -784,7 +784,7 @@ static void executeBlocking(void)
 
         if ((someoneBlocking = (res & MacroResult_BlockingFlag))) {
             SchedulerPostponing = true;
-            EventVector_Set(EventVector_ReportsChanged);
+            EventVector_Set(EventVector_SendUsbReports);
             break;
         }
 
diff --git a/right/src/macros/status_buffer.c b/right/src/macros/status_buffer.c
index 5d5af4f0..3b3eefec 100644
--- a/right/src/macros/status_buffer.c
+++ b/right/src/macros/status_buffer.c
@@ -1,6 +1,7 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <string.h>
+#include "debug.h"
 #include "macros/core.h"
 #include "macros/scancode_commands.h"
 #include "macros/status_buffer.h"
@@ -9,6 +10,7 @@
 #include "segment_display.h"
 #include "config_parser/parse_macro.h"
 #include "config_parser/config_globals.h"
+#include "timer.h"
 #include <math.h>
 #include <stdarg.h>
 
@@ -112,9 +114,11 @@ static void setStatusChar(char n)
         return;
     }
 
-    if (n && statusBufferLen == STATUS_BUFFER_MAX_LENGTH) {
+    if (n && statusBufferLen == STATUS_BUFFER_MAX_LENGTH && DEBUG_ROLL_STATUS_BUFFER) {
         memcpy(statusBuffer, &statusBuffer[STATUS_BUFFER_MAX_LENGTH/2], STATUS_BUFFER_MAX_LENGTH/2);
+        int16_t shiftBy = STATUS_BUFFER_MAX_LENGTH - STATUS_BUFFER_MAX_LENGTH/2;
         statusBufferLen = STATUS_BUFFER_MAX_LENGTH/2;
+        consumeStatusCharReadingPos = consumeStatusCharReadingPos > shiftBy ? consumeStatusCharReadingPos - shiftBy : 0;
     }
 
     if (n && statusBufferLen < STATUS_BUFFER_MAX_LENGTH) {
@@ -304,14 +308,20 @@ void Macros_ReportPrintf(const char* pos, const char *fmt, ...)
     char buffer[256];
     vsprintf(buffer, fmt, myargs);
 
+    static uint32_t lastUpdate = 0;
+
     indicateOut();
     if (pos != NULL) {
         reportErrorHeader("Out", findPosition(pos));
         reportError(buffer, pos, pos);
     } else {
+        Macros_SetStatusChar('+');
+        Macros_SetStatusNumSpaced(CurrentTime-lastUpdate, false);
+        Macros_SetStatusChar(' ');
         Macros_SetStatusString(buffer, NULL);
         Macros_SetStatusString("\n", NULL);
     }
+    lastUpdate = CurrentTime;
 }
 
 void Macros_ReportErrorPrintf(const char* pos, const char *fmt, ...)
diff --git a/right/src/macros/status_buffer.h b/right/src/macros/status_buffer.h
index 08111640..b147e783 100644
--- a/right/src/macros/status_buffer.h
+++ b/right/src/macros/status_buffer.h
@@ -13,6 +13,7 @@
 
 // Typedefs:
 
+
 // Variables:
 //
     extern bool Macros_ConsumeStatusCharDirtyFlag;
diff --git a/right/src/mouse_controller.c b/right/src/mouse_controller.c
index f531b65e..1741d942 100644
--- a/right/src/mouse_controller.c
+++ b/right/src/mouse_controller.c
@@ -777,7 +777,7 @@ void MouseController_ProcessMouseActions()
     EventVector_SetValue(EventVector_MouseControllerMouseReportsUsed, mouseReportsUsed);
 
     if (keyboardReportsUsed || mouseReportsUsed || caretModeActionWasRunningSomewhere || modsChanged) {
-        EventVector_Set(EventVector_ReportsChanged);
+        EventVector_Set(EventVector_SendUsbReports);
     }
     if (!caretModeActionIsRunningSomewhere) {
         EventVector_Unset(EventVector_MouseControllerPostponing);
diff --git a/right/src/mouse_keys.c b/right/src/mouse_keys.c
index 89541894..8a2710f6 100644
--- a/right/src/mouse_keys.c
+++ b/right/src/mouse_keys.c
@@ -210,13 +210,13 @@ void MouseKeys_ProcessMouseActions()
         EventVector_Set(EventVector_MouseKeysReportsUsed);
     }
     if (wasMoving) {
-        EventVector_Set(EventVector_MouseKeys | EventVector_ReportsChanged);
+        EventVector_Set(EventVector_MouseKeys | EventVector_SendUsbReports);
     }
 }
 
 void MouseKeys_SetState(serialized_mouse_action_t action, bool lock, bool activate)
 {
-    EventVector_Set(EventVector_MouseKeys | EventVector_ReportsChanged);
+    EventVector_Set(EventVector_MouseKeys | EventVector_SendUsbReports);
     if (activate) {
         if (lock) {
             EventVector_Set(EventVector_NativeActions);
diff --git a/right/src/postponer.c b/right/src/postponer.c
index 040f52cd..2e4ba27f 100644
--- a/right/src/postponer.c
+++ b/right/src/postponer.c
@@ -91,6 +91,7 @@ static void applyEventAndConsume(postponer_buffer_record_type_t* rec) {
             Postponer_LastKeyMods = rec->event.key.modifiers;
             // This gives the key two ticks (this and next) to get properly processed before execution of next queued event.
             // PostponerCore_PostponeNCycles(1);
+            Macros_ReportPrintf(NULL, "P%c%s", rec->event.key.active ? '+' : '-', Utils_KeyStateToKeyAbbreviation(rec->event.key.keyState));
             EventVector_Set(EventVector_NativeActions);
             Macros_WakeBecauseOfKeystateChange();
             consumeEvent(1);
diff --git a/right/src/slave_drivers/touchpad_driver.c b/right/src/slave_drivers/touchpad_driver.c
index 70b092bf..c5f7eb99 100644
--- a/right/src/slave_drivers/touchpad_driver.c
+++ b/right/src/slave_drivers/touchpad_driver.c
@@ -164,25 +164,46 @@ slave_result_t TouchpadDriver_Update(uint8_t uhkModuleDriverId)
 
             ModuleConnectionStates[UhkModuleDriverId_RightModule].lastTimeConnected = CurrentTime;
 
-            TouchpadEvents.singleTap = gestureEvents.events0.singleTap;
-            TouchpadEvents.twoFingerTap = gestureEvents.events1.twoFingerTap;
-            TouchpadEvents.tapAndHold = gestureEvents.events0.tapAndHold;
-            TouchpadEvents.noFingers = noFingers;
-
-            if (gestureEvents.events1.scroll) {
-                TouchpadEvents.wheelX -= deltaX;
-                TouchpadEvents.wheelY += deltaY;
-            } else if (gestureEvents.events1.zoom) {
-                TouchpadEvents.zoomLevel -= deltaY;
-            } else {
-                TouchpadEvents.x -= deltaX;
-                TouchpadEvents.y += deltaY;
+            if (deltaX || deltaY || *(uint16_t*)&gestureEvents) {
+                bool somethingChanged = false;
+
+                if (
+                        TouchpadEvents.singleTap != gestureEvents.events0.singleTap
+                        || TouchpadEvents.twoFingerTap != gestureEvents.events1.twoFingerTap
+                        || TouchpadEvents.tapAndHold != gestureEvents.events0.tapAndHold
+                        || TouchpadEvents.noFingers != noFingers
+                   ) {
+                    TouchpadEvents.singleTap = gestureEvents.events0.singleTap;
+                    TouchpadEvents.twoFingerTap = gestureEvents.events1.twoFingerTap;
+                    TouchpadEvents.tapAndHold = gestureEvents.events0.tapAndHold;
+                    TouchpadEvents.noFingers = noFingers;
+                    somethingChanged = true;
+                }
+
+                if (deltaX != 0 || deltaY != 0) {
+                    if (gestureEvents.events1.scroll) {
+                        TouchpadEvents.wheelX -= deltaX;
+                        TouchpadEvents.wheelY += deltaY;
+                        somethingChanged = true;
+                    } else if (gestureEvents.events1.zoom) {
+                        TouchpadEvents.zoomLevel -= deltaY;
+                        somethingChanged = true;
+                    } else {
+                        TouchpadEvents.x -= deltaX;
+                        TouchpadEvents.y += deltaY;
+                        somethingChanged = true;
+                    }
+                }
+
+                if (somethingChanged) {
+                    EventVector_Set(EventVector_MouseController);
+                    EventVector_WakeMain();
+                }
             }
 
             res.status = I2cAsyncWrite(address, closeCommunicationWindow, sizeof(closeCommunicationWindow));
             res.hold = false;
-            EventVector_Set(EventVector_MouseController);
-            EventVector_WakeMain();
+
             phase = 3;
             break;
         }
diff --git a/right/src/slave_drivers/uhk_module_driver.c b/right/src/slave_drivers/uhk_module_driver.c
index b88c58f5..a611eab7 100644
--- a/right/src/slave_drivers/uhk_module_driver.c
+++ b/right/src/slave_drivers/uhk_module_driver.c
@@ -2,6 +2,7 @@
 #include "config_parser/parse_config.h"
 #include "i2c_addresses.h"
 #include "i2c.h"
+#include "macros/keyid_parser.h"
 
 #ifdef __ZEPHYR__
 #include "messenger.h"
@@ -145,6 +146,11 @@ void UhkModuleSlaveDriver_ProcessKeystates(uint8_t uhkModuleDriverId, uhk_module
         }
 
         if (KeyStates[slotId][targetKeyId].hardwareSwitchState != keyStatesBuffer[keyId]) {
+            if (keyStatesBuffer[keyId]) {
+                Macros_ReportPrintf(NULL, "S+%s", MacroKeyIdParser_KeyIdToAbbreviation(targetKeyId+slotId*64));
+            } else {
+                Macros_ReportPrintf(NULL, "S-%s", MacroKeyIdParser_KeyIdToAbbreviation(targetKeyId+slotId*64));
+            }
             KeyStates[slotId][targetKeyId].hardwareSwitchState = keyStatesBuffer[keyId];
             stateChanged = true;
         }
@@ -446,6 +452,7 @@ slave_result_t UhkModuleSlaveDriver_Update(uint8_t uhkModuleDriverId)
         case UhkModulePhase_ProcessKeystates:
             if (CRC16_IsMessageValid(rxMessage)) {
                 if (DEVICE_ID == DeviceId_Uhk80_Left) {
+                    // this handles forwarding left module states in uhk80 left half
                     forwardKeystates(uhkModuleDriverId, uhkModuleState, rxMessage);
                 } else {
                     UhkModuleSlaveDriver_ProcessKeystates(uhkModuleDriverId, uhkModuleState, rxMessage->data);
diff --git a/right/src/usb_interfaces/usb_interface_basic_keyboard.c b/right/src/usb_interfaces/usb_interface_basic_keyboard.c
index 1498b4d6..130900eb 100644
--- a/right/src/usb_interfaces/usb_interface_basic_keyboard.c
+++ b/right/src/usb_interfaces/usb_interface_basic_keyboard.c
@@ -1,10 +1,12 @@
 #include <string.h>
+#include "event_scheduler.h"
 #include "led_display.h"
 #include "lufa/HIDClassCommon.h"
 #include "macros/core.h"
 #include "macro_events.h"
 #include "usb_composite_device.h"
 #include "usb_report_updater.h"
+#include "macros/status_buffer.h"
 
 #ifdef __ZEPHYR__
 #include "usb/usb_compatibility.h"
@@ -206,6 +208,7 @@ void UsbBasicKeyboardSendActiveReport(void)
         //This is *not* asynchronously safe as long as multiple reports of different type can be sent at the same time.
         //TODO: consider either making it atomic, or lowering semaphore reset delay
         UsbReportUpdateSemaphore &= ~(1 << USB_BASIC_KEYBOARD_INTERFACE_INDEX);
+        EventVector_Set(EventVector_SendUsbReports);
     }
 #endif
 }
diff --git a/right/src/usb_interfaces/usb_interface_mouse.c b/right/src/usb_interfaces/usb_interface_mouse.c
index 1f632faa..05499dac 100644
--- a/right/src/usb_interfaces/usb_interface_mouse.c
+++ b/right/src/usb_interfaces/usb_interface_mouse.c
@@ -1,6 +1,7 @@
 #include "usb_composite_device.h"
 #include "usb_report_updater.h"
 #include <string.h>
+#include "event_scheduler.h"
 
 #ifdef __ZEPHYR__
 #include "usb/usb_compatibility.h"
@@ -167,6 +168,7 @@ void UsbMouseSendActiveReport(void)
     usb_status_t status = UsbMouseAction();
     if (status != kStatus_USB_Success) {
         UsbReportUpdateSemaphore &= ~(1 << USB_MOUSE_INTERFACE_INDEX);
+        EventVector_Set(EventVector_SendUsbReports);
     }
 #endif
 }
diff --git a/right/src/usb_report_updater.c b/right/src/usb_report_updater.c
index c2d76597..79e89c18 100644
--- a/right/src/usb_report_updater.c
+++ b/right/src/usb_report_updater.c
@@ -221,7 +221,7 @@ static void resetStickyMods(key_action_cached_t *cachedAction)
 {
     StickyModifiers = 0;
     StickyModifiersNegative = cachedAction->modifierLayerMask;
-    EventVector_Set(EventVector_ReportsChanged);
+    EventVector_Set(EventVector_SendUsbReports);
 }
 
 static void activateStickyMods(key_state_t *keyState, key_action_cached_t *action)
@@ -230,7 +230,7 @@ static void activateStickyMods(key_state_t *keyState, key_action_cached_t *actio
     StickyModifiers = action->action.keystroke.modifiers;
     stickyModifierKey = keyState;
     stickyModifierShouldStick = shouldStickAction(&action->action);
-    EventVector_Set(EventVector_ReportsChanged);
+    EventVector_Set(EventVector_SendUsbReports);
 }
 
 void ActivateStickyMods(key_state_t *keyState, uint8_t mods)
@@ -239,12 +239,12 @@ void ActivateStickyMods(key_state_t *keyState, uint8_t mods)
     StickyModifiers = mods;
     stickyModifierKey = keyState;
     stickyModifierShouldStick = ActiveLayerHeld;
-    EventVector_Set(EventVector_ReportsChanged);
+    EventVector_Set(EventVector_SendUsbReports);
 }
 
 static void applyKeystrokePrimary(key_state_t *keyState, key_action_cached_t *cachedAction, usb_keyboard_reports_t* reports)
 {
-    EventVector_Set(EventVector_ReportsChanged);
+    EventVector_Set(EventVector_SendUsbReports);
 
     if (KeyState_Active(keyState)) {
         key_action_t* action = &cachedAction->action;
@@ -259,7 +259,7 @@ static void applyKeystrokePrimary(key_state_t *keyState, key_action_cached_t *ca
         } else {
             if (action->keystroke.modifiers) {
                 reports->inputModifiers |= action->keystroke.modifiers;
-                EventVector_Set(EventVector_ReportsChanged | reports->reportsUsedVectorMask);
+                EventVector_Set(reports->reportsUsedVectorMask);
             }
         }
         // If there are mods: first cycle send just mods, in next cycle start sending mods+scancode
@@ -283,12 +283,13 @@ static void applyKeystrokePrimary(key_state_t *keyState, key_action_cached_t *ca
         bool stickyModsAreNonZero = StickyModifiers != 0 || StickyModifiersNegative != 0;
         if (stickyModifierKey == keyState && !stickyModifierShouldStick && stickyModsAreNonZero) {
             //disable the modifiers, but send one last report of modifiers without scancode
+            //do we actually want / need extra modifier report on release?
             reports->basic.modifiers |= StickyModifiers;
             StickyModifiers = 0;
             StickyModifiersNegative = 0;
             EventVector_Set(
                     reports->recomputeStateVectorMask | // trigger next update in order to clear them, usually EventVector_NativeActions here
-                    EventVector_ReportsChanged | reports->reportsUsedVectorMask |
+                    reports->reportsUsedVectorMask |
                     reports->postponeMask
                 );
         }
@@ -310,7 +311,7 @@ static void applyKeystrokeSecondary(key_state_t *keyState, key_action_t *action,
     } else if (IS_SECONDARY_ROLE_MODIFIER(secondaryRole)) {
         if (KeyState_Active(keyState)) {
             reports->inputModifiers |= SECONDARY_ROLE_MODIFIER_TO_HID_MODIFIER(secondaryRole);
-            EventVector_Set(EventVector_ReportsChanged | reports->reportsUsedVectorMask);
+            EventVector_Set(EventVector_SendUsbReports | reports->reportsUsedVectorMask);
         }
     }
 }
@@ -458,9 +459,11 @@ static void commitKeyState(key_state_t *keyState, bool active)
     }
 
     if (PostponerCore_EventsShouldBeQueued()) {
+        Macros_ReportPrintf(NULL, "CP%c%s", active ? '+' : '-', Utils_KeyStateToKeyAbbreviation(keyState));
         PostponerCore_TrackKeyEvent(keyState, active, 255);
     } else {
         KEY_TIMING(KeyTiming_RecordKeystroke(keyState, active, CurrentTime, CurrentTime));
+        Macros_ReportPrintf(NULL, "C%c%s", active ? '+' : '-', Utils_KeyStateToKeyAbbreviation(keyState));
         keyState->current = active;
     }
     Macros_WakeBecauseOfKeystateChange();
@@ -512,7 +515,7 @@ static void handleUsbStackTestMode() {
             Cfg.MouseMoveState.xOut = isEven ? -5 : 5;
         }
         EventVector_Set(EventVector_NativeActions);
-        EventVector_Set(EventVector_ReportsChanged);
+        EventVector_Set(EventVector_SendUsbReports);
         EventVector_Set(EventVector_NativeActionReportsUsed);
     }
 }
@@ -527,7 +530,7 @@ static void handleLayerChanges() {
         previousLayer = ActiveLayer;
         StickyModifiers = 0;
         StickyModifiersNegative = 0;
-        EventVector_Set(EventVector_ReportsChanged);
+        EventVector_Set(EventVector_SendUsbReports);
     }
 }
 
@@ -544,6 +547,8 @@ static void updateActionStates() {
     EventVector_Unset(EventVector_StateMatrix);
     EventVector_Unset(EventVector_NativeActionsPostponing);
 
+    Macros_ReportPrintf(NULL, "U");
+
     for (uint8_t slotId=0; slotId<SLOT_COUNT; slotId++) {
         for (uint8_t keyId=0; keyId<MAX_KEY_COUNT_PER_MODULE; keyId++) {
             key_state_t *keyState = &KeyStates[slotId][keyId];
@@ -585,6 +590,12 @@ static void updateActionStates() {
                         Postponer_LastKeyMods = 0;
                     }
                     handleEventInterrupts(keyState);
+
+                    Macros_ReportPrintf(NULL, "R+%s", Utils_KeyStateToKeyAbbreviation(keyState));
+                }
+
+                if (KeyState_DeactivatedNow(keyState)) {
+                    Macros_ReportPrintf(NULL, "R-%s", Utils_KeyStateToKeyAbbreviation(keyState));
                 }
 
                 cachedAction = &actionCache[slotId][keyId];
@@ -602,13 +613,12 @@ static void updateActionStates() {
     }
     uint8_t currentMods = NativeKeyboardReports.basic.modifiers | NativeKeyboardReports.inputModifiers;
     if (currentMods != previousMods) {
-        EventVector_Set(EventVector_ReportsChanged);
+        EventVector_Set(EventVector_SendUsbReports);
     }
 }
 
 static void updateActiveUsbReports(void)
 {
-    EventVector_Unset(EventVector_ReportsChanged);
     InputModifiersPrevious = InputModifiers;
     OutputModifiers = 0;
     static bool lastSomeonePostponing = false;
@@ -678,6 +688,9 @@ static void sendActiveReports() {
     bool usbReportsChangedByAction = false;
     bool usbReportsChangedByAnything = false;
 
+    // in case of usb error, this gets set back again
+    EventVector_Unset(EventVector_SendUsbReports);
+
     if (UsbBasicKeyboardCheckReportReady() == kStatus_USB_Success) {
 #ifdef __ZEPHYR__
         if (InputInterceptor_RegisterReport(ActiveUsbBasicKeyboardReport)) {
@@ -686,6 +699,7 @@ static void sendActiveReports() {
 
 #endif
         {
+            Utils_PrintReport("O:", ActiveUsbBasicKeyboardReport);
             MacroRecorder_RecordBasicReport(ActiveUsbBasicKeyboardReport);
 
             KEY_TIMING(KeyTiming_RecordReport(ActiveUsbBasicKeyboardReport));
@@ -718,6 +732,7 @@ static void sendActiveReports() {
         usb_status_t status = UsbMediaKeyboardAction();
         if (status != kStatus_USB_Success) {
             UsbReportUpdateSemaphore &= ~(1 << USB_MEDIA_KEYBOARD_INTERFACE_INDEX);
+            EventVector_Set(EventVector_SendUsbReports);
         }
         UsbReportUpdater_LastActivityTime = CurrentTime;
         usbReportsChangedByAction = true;
@@ -729,6 +744,7 @@ static void sendActiveReports() {
         usb_status_t status = UsbSystemKeyboardAction();
         if (status != kStatus_USB_Success) {
             UsbReportUpdateSemaphore &= ~(1 << USB_SYSTEM_KEYBOARD_INTERFACE_INDEX);
+            EventVector_Set(EventVector_SendUsbReports);
         }
         UsbReportUpdater_LastActivityTime = CurrentTime;
         usbReportsChangedByAction = true;
@@ -747,7 +763,12 @@ static void sendActiveReports() {
     if (usbReportsChangedByAction) {
         Macros_SignalUsbReportsChange();
     }
-    EventVector_SetValue(EventVector_ZeroScan, usbReportsChangedByAnything);
+
+    // If anything changed, trigger one more update to send zero reports
+    // TODO: consider doing this depending on change of ReportsUsed mask(s) and actual module scans
+    if (usbReportsChangedByAnything) {
+        EventVector_Set(EventVector_SendUsbReports);
+    }
 }
 
 void UpdateUsbReports(void)
@@ -766,11 +787,13 @@ void UpdateUsbReports(void)
 
     updateActiveUsbReports();
 
-    if (EventVector_IsSet(EventVector_ReportsChanged | EventVector_ZeroScan) && CurrentPowerMode < PowerMode_DeepSleep) {
-        mergeReports();
-        sendActiveReports();
-    } else {
-        EventVector_Unset(EventVector_ReportsChanged);
+    if (EventVector_IsSet(EventVector_SendUsbReports)) {
+        if (CurrentPowerMode < PowerMode_DeepSleep) {
+            mergeReports();
+            sendActiveReports();
+        } else {
+            EventVector_Unset(EventVector_SendUsbReports);
+        }
     }
 
     if (DisplaySleepModeActive || KeyBacklightSleepModeActive) {
diff --git a/right/src/utils.c b/right/src/utils.c
index 9f18d942..435b68d4 100644
--- a/right/src/utils.c
+++ b/right/src/utils.c
@@ -2,6 +2,7 @@
 #include "utils.h"
 #include "key_action.h"
 #include "key_states.h"
+#include "macros/keyid_parser.h"
 
 #ifdef __ZEPHYR__
 #include "device.h"
@@ -53,6 +54,15 @@ key_state_t* Utils_KeyIdToKeyState(uint16_t keyid)
 #endif
 }
 
+const char* Utils_KeyStateToKeyAbbreviation(key_state_t* key)
+{
+    if (key == NULL) {
+        return NULL;
+    }
+    uint16_t keyId = Utils_KeyStateToKeyId(key);
+    return MacroKeyIdParser_KeyIdToAbbreviation(keyId);
+}
+
 key_coordinates_t Utils_KeyIdToKeyCoordinates(uint16_t keyId)
 {
     return (key_coordinates_t) { .slotId = keyId / 64, .inSlotId = keyId % 64, };
@@ -114,8 +124,6 @@ void Utils_PrintReport(const char* prefix, usb_basic_keyboard_report_t* report)
 {
     Macros_SetStatusString(prefix, NULL);
 
-    Macros_SetStatusString(" ", NULL);
-
     bool modifierFound = reportModifiers(report->modifiers);
 
     if (modifierFound) {
diff --git a/right/src/utils.h b/right/src/utils.h
index 110aca7c..dba40c8a 100644
--- a/right/src/utils.h
+++ b/right/src/utils.h
@@ -36,6 +36,7 @@ if (reentrancyGuard_active) {                    \
     void Utils_SafeStrCopy(char* target, const char* src, uint8_t max);
     key_state_t* Utils_KeyIdToKeyState(uint16_t keyid);
     uint16_t Utils_KeyStateToKeyId(key_state_t* key);
+    const char* Utils_KeyStateToKeyAbbreviation(key_state_t* key);
     void Utils_DecodeId(uint16_t keyid, uint8_t* outSlotId, uint8_t* outSlotIdx);
     void Utils_PrintReport(const char* prefix, usb_basic_keyboard_report_t* report);
     key_coordinates_t Utils_KeyIdToKeyCoordinates(uint16_t keyId);