diff --git a/doc-dev/reference-manual.md b/doc-dev/reference-manual.md
index 343a4116a..c905de6f6 100644
--- a/doc-dev/reference-manual.md
+++ b/doc-dev/reference-manual.md
@@ -183,6 +183,10 @@ COMMAND = set oneShotTimeout <time in ms (INT)>
 COMMAND = set macroEngine.batchSize <number of commands to execute per one update cycle INT>
 COMMAND = set navigationModeAction.NAVIGATION_MODE_CUSTOM.DIRECTION ACTION
 COMMAND = set keymapAction.LAYERID.KEYID ACTION
+COMMAND = set chord[.LAYERID_BASIC] KEYID KEYID [KEYID]* ACTION
+COMMAND = set chordTimeout <ms, 0-255 (INT)> sets the chord activation window size
+COMMAND = set chordPriorIdleTime <ms, 0-65535 (INT)> sets the minimum dead time before a chord can trigger
+COMMAND = set chordLifetime { leadingKey | allKeys } sets how long a chord activation lasts
 COMMAND = set backlight.strategy { functional | constantRgb | perKeyRgb | off }
 COMMAND = set backlight.constantRgb.rgb <number 0-255 (INT)> <number 0-255 (INT)> <number 0-255 (INT)><number 0-255 (INT)>
 COMMAND = set backlight.keyRgb.LAYERID.KEYID <number 0-255 (INT)> <number 0-255 (INT)> <number 0-255 (INT)>
@@ -722,6 +726,16 @@ Key actions can be parametrized with macro arguments. These arguments can be exp
   - `set navigationModeAction.{caret|media}.{DIRECTION|none} ACTION` can be used to customize the caret or media mode behaviour by binding directions to macros. This action is global and reversible only by powercycling.
   - `set keymapAction.LAYERID.KEYID ACTION` can be used to remap any action that lives in a keymap. Most remappable ids can be retrieved with `resolveNextKeyId`. Keyid can also be constructed manually - see `KEYID`. Binding applies only until the next keymap switch. E.g., `set keymapAction.base.64 keystroke escape` (maps `~` key to escape), or `set keymapAction.fn.193 macro TouchpadAction` (maps touchpad two-finger gesture to a macro named `TouchpadAction`).
 
+- Chords
+  Chords is a concept where a number of keys can be linked together such that if they are pressed together all at once, like a chord on a piano, a specific action is taken, different from what each of the keys do on their own.  Anywhere between 2 and 5 keys can be chorded together and associated with an `ACTION`
+
+  - `set chord[.LAYERID_BASIC] ACTION` Configures a chord with an action.  If a layer is specified, the chord will be available when that layer is active, if not, it will be available on any layer.  The same chord can be defined for different actions for different layers, including the `any` layer.  If action is `none`, the chord is removed and the keys will work as individual keys if the chord is pressed, not as an empty action.
+  - `set chordTimeout <ms, 0-255 (INT)>` sets the interval within which all keys of a chord must be pressed in order for the chord to be activated.
+  - `set chordPriorIdleTime <ms, 0-65535 (INT)>` sets a limit to how soon a chord can be activated after a key has been pressed.  This helps prevent accidental activations while typing rapidly.  Chords do not prevent chord activations, so chords can still be doubletapped.
+  - `set chordLifetime { leadingKey | allKeys }` sets how long a chord activation lasts.  With `leadingKey`, the chord is considered released when earliest key pressed in the activation is released, with `allKeys`, the chord is considered released when all keys in the chord is released.
+
+  Chords are reset every time the keymap is changed, so they are best set using the `$onKeymapChange` macro event.  A maximum of 64 chords can be defined at a time.
+
 - Secondary roles section configures the resolution strategy used for controlling both the native (agent-mapped) secondary roles and the`ifPrimary` and `ifSecondary` conditions.
 
   - `set secondaryRole.defaultStrategy [ simple | advanced ]` sets the default resolution strategy to be used. Furthermore, `ifPrimary/ifSecondary` can specify explicitly which strategy to use (e.g., `ifPrimary advancedStrategy final tapKey a`).
diff --git a/doc-dev/user-guide.md b/doc-dev/user-guide.md
index 6ba5d5c78..1532e76d3 100644
--- a/doc-dev/user-guide.md
+++ b/doc-dev/user-guide.md
@@ -543,6 +543,24 @@ set keymapAction.base.192 macro TouchpadLeft
 set keymapAction.base.193 macro TouchpadRight
 ```
 
+### Key Chords
+
+A different kind of gestures exists: Chords.  A chord is when a set of keys are associated with each other such that if they are pressed all at once, like a chord on a piano, they do something different from the functionality of each key on it's own.
+
+In order to define a macro, you can use the command `set chord[.LAYERID_BASIC] KEYID KEYID [KEYID]* ACTION`.  Up to five keys can be used for each chord.
+
+An example could be to use it for the Vim user's eternal quest for an ergonomical Esc button.  But on the mod layer, we want that chord to perform another action, in this case a macro.  Also, to spare the right pinky, we can put an Enter key near the home row on the right hand, but only on the base layer.
+
+```
+set chord q w keystroke escape
+set chord.mod q w macro DetachScreen
+set chord.base u i keystroke enter
+```
+
+All defined chords are cleared/undefined on keymap change, so chords are most sensibly set using the `$onKeymapChange` macro triggers.
+
+The behavior of chords can be fine-tuned using `set chordTimeout`, `set chordPriorIdleTime` and `set chordLifetime`
+
 ### Macro recorder
 
 Runtime macro recorder allows capturing and replaying sequences of scancodes. Each such macro is identified by a number or a character (or `$thisKeyId` which resolves to the `KEYID` of the current key, therefore allowing generic key-associated macros). (Runtime macros are unrelated to the macros that can be created via Agent.)
diff --git a/right/src/CMakeLists.txt b/right/src/CMakeLists.txt
index 8a42ceebd..15947ad40 100644
--- a/right/src/CMakeLists.txt
+++ b/right/src/CMakeLists.txt
@@ -21,6 +21,7 @@ endif()
 
 target_sources(${PROJECT_NAME} PRIVATE
     caret_config.c
+    chords.c
     config_manager.c
     debug.c
     eeprom.c
diff --git a/right/src/chords.c b/right/src/chords.c
new file mode 100644
index 000000000..cdeaee15c
--- /dev/null
+++ b/right/src/chords.c
@@ -0,0 +1,412 @@
+#include "chords.h"
+#include "config_manager.h"
+#include "event_scheduler.h"
+#include "key_history.h"
+#include "keymap.h"
+#include "layer.h"
+#include "macros/status_buffer.h"
+#include "postponer.h"
+#include "utils.h"
+
+#define MAX_CHORDS_COUNT 64
+
+// Not sure if this should be an enum or just macros.
+typedef enum {
+    ChordSearch_Partial = 0b01, // There was no exact match, but there were chords eligible with more keys
+    ChordSearch_Exact = 0b10, // There was an exact match and no other potential matches
+} chord_search_result_t;
+
+chord_def_t Chords[MAX_CHORDS_COUNT];
+uint8_t ChordCount = 0;
+uint8_t NextActivationId = CHORDS_INVALID_ACTIVATION_ID + 1;
+
+// Not sure how nice or not this is.  I like named parameters rather than just true/false in calls.
+// I also don't like the all-caps of macros, this C doesn't have consexpr, and I don't know if global consts will get optimized.
+typedef enum {
+    KeyReleased = false,
+    KeyPressed = true,
+} key_pressed_state_t;
+
+static struct {
+    const key_state_t *initialKey;
+    uint32_t pressTime;
+    uint32_t releaseTime;
+    uint8_t unrollingKeysCount;
+    chord_def_t *unrollingChord;
+} ResolutionState;
+
+static inline void sortKeys(chord_keys_t keys, uint8_t keyCount)
+{
+    // Some kind of bubblesort, I dunno, 5 keys max, don't care about optimal algorithm
+    bool recheck = true;
+    while ( recheck ) {
+        recheck = false;
+        for (uint8_t i = 0; i < keyCount - 1; ++i) {
+            if (keys[i] > keys[i + 1] ) {
+                uint8_t temp = keys[i];
+                keys[i] = keys[i + 1];
+                keys[i + 1] = temp;
+                if (i < keyCount - 1) {
+                    // If the keys we just switched were not the last keys, we need to go again.
+                    recheck = true;
+                }
+            }
+        }
+    }
+}
+
+uint8_t findUsedKeys(chord_keys_t unusedKeys, uint8_t keyCount, const chord_def_t *chord) {
+    uint8_t i = 0;
+    uint8_t j = 0;
+    while (i < keyCount && j < chord->keyCount) {
+        while (i < keyCount && unusedKeys[i] < chord->keys[j]) {++i;}
+        if (unusedKeys[i] == chord->keys[j]) {
+            memmove(unusedKeys + i, unusedKeys + i + 1, keyCount-- - i);
+        }
+        while (j < chord->keyCount && chord->keys[j] < unusedKeys[i]) {++j;}
+    }
+    return keyCount;
+}
+
+void handleUpdateKeysOfDeletedChordOnLayer(layer_id_t layer, chord_keys_t keys, uint8_t keyCount) {
+    for (uint8_t i = 0; i < ChordCount; ++i) {
+        if (Chords[i].layer < layer) continue;
+        if (Chords[i].layer > layer && Chords[i].layer != LayerId_None) continue;
+        if ((keyCount = findUsedKeys(keys, keyCount, &Chords[i])) == 0) break;
+    }
+
+    for (uint8_t i = 0; i < keyCount; ++i) {
+        CurrentKeymap[layer][keys[i]/64][keys[i]%64].isPartOfChord = false;
+    }
+}
+
+void handleUpdateKeysOfDeletedChord(layer_id_t layer, chord_keys_t keys, uint8_t keyCount) {
+    if (layer == LayerId_None) {
+        for (layer_id_t loopLayer = LayerId_Base; loopLayer < LayerId_Count; ++loopLayer) {
+            handleUpdateKeysOfDeletedChordOnLayer(loopLayer, keys, keyCount);
+        }
+    }
+    else {
+        handleUpdateKeysOfDeletedChordOnLayer(layer, keys, keyCount);
+    }
+}
+
+void markKeysAsPartsOfChord(chord_def_t *chord) {
+    for (uint8_t i = 0; i < chord->keyCount; ++i) {
+        if (chord->layer != LayerId_None) {
+            CurrentKeymap[chord->layer][chord->keys[i]/64][chord->keys[i]%64].isPartOfChord = true;
+        }
+        else {
+            for (layer_id_t j = 0; j < LayerId_Count; ++j) {
+                CurrentKeymap[j][chord->keys[i]/64][chord->keys[i]%64].isPartOfChord = true;
+            }
+        }
+    }
+}
+
+
+/*
+Chords are stored sorted as follows:
+First by layer, ascending to put the any layer (255) last
+Then ascending by key count - ascending so we know that chord size within a layer's chords increases
+Then by key id list, direction doesn't matter, only that they're sorted consistently
+*/
+static inline int16_t compareToChord(const chord_def_t *left, layer_id_t layer, uint8_t keyCount, const chord_keys_t keys) {
+    // These could be collapsed and optimized more if we're willing to do union with a bitfield, but that's hacky
+    if (left->layer != layer) {
+        return (int16_t)left->layer - layer;
+    }
+    if (left->keyCount != keyCount) {
+        return (int16_t)left->keyCount - keyCount;
+    }
+    return memcmp(left->keys, keys, keyCount);
+}
+
+/*
+Search here is implemented as just iteration over the list.
+One could do a binary search instead, for a minor speed increase.
+I might do that later.
+*/
+bool Chords_TryAddChord(layer_id_t layer, chord_keys_t keys, uint8_t keyCount, key_action_t *action)
+{
+    sortKeys(keys, keyCount);
+
+    // Find a spot
+    uint8_t i = 0;
+    int16_t chordCmp = 1; // Initialize to not zero to not overwrite first on empty list
+    while (i < ChordCount && (chordCmp = compareToChord(&Chords[i], layer, keyCount, keys)) < 0) {++i;}
+
+    if (chordCmp == 0) {
+        // We already have the chord, erase or update, depending on provided action
+        if (action->type == KeyActionType_None) {
+            // Erase the chord
+            memmove(&Chords[i], &Chords[i + 1], sizeof(chord_def_t) * (--ChordCount - i));
+            handleUpdateKeysOfDeletedChord(layer, keys, keyCount);
+            return true;
+        }
+        // Just overwrite action, the rest of the chord is already in place
+        Chords[i].action = *action;
+        return true;
+    }
+
+    if (action->type == KeyActionType_None) {
+        // We were told to remove it, but we don't have it, great success!
+        return true;
+    }
+
+    // Check if there is room if we're not removing a chord
+    if (action->type != KeyActionType_None && ChordCount >= MAX_CHORDS_COUNT) {
+        // No room
+        return false;
+    }
+
+    // We do not have the chord, but we know where to put it now
+    // Insert the chord.
+    memmove(&Chords[i + 1], &Chords[i], sizeof(chord_def_t) * (ChordCount++ - i));
+    chord_def_t *chord = &Chords[i];
+    memcpy(chord->keys, keys, MAX_CHORD_KEYS);
+    chord->keyCount = keyCount;
+    chord->layer = layer;
+    chord->action = *action;
+    markKeysAsPartsOfChord(chord);
+    return true;
+}
+
+// This function assumes that both lists of keys are sorted smallest to largest.
+static bool isPartialOfChord(const chord_def_t *large, chord_keys_t keys, uint8_t keyCount)
+{
+    uint8_t i = 0, j = 0;
+    for (; i < keyCount; ++i) {
+        // We can skip keys in the chord to see if all the provided keys exist
+        while (keys[i] > large->keys[j]) {
+            ++j;
+        }
+        if (keys[i] != large->keys[j]) {
+            // A provided key was not in the chord
+            // The provided key cannot grow into the chord
+            return false;
+        }
+        ++j;
+    }
+    return true;
+}
+
+// Again linear search, not binary
+chord_search_result_t searchForChordAction(chord_def_t **out_matchedChord, layer_id_t layer, chord_keys_t keys, uint8_t keyCount, bool noPartial)
+{
+    sortKeys(keys, keyCount);
+
+    uint8_t i = 0;
+    bool matched = false;
+    bool partialMatched = false;
+    
+    while (true) {
+        // First maybe find the chord
+        if ( !matched ) {
+            for (; i < ChordCount; ++i) {
+                int16_t chordCmp = compareToChord(&Chords[i], layer, keyCount, keys);
+                if (chordCmp < 0) continue;
+                if (chordCmp == 0) {
+                    // We found the longest completed chord so far
+                    *out_matchedChord = &Chords[i];
+                    //Macros_SetStatusNum(i);
+                    //Macros_SetStatusString("Matched!!!\n", NULL);
+                    matched = true;
+                    ++i;
+                }
+                break;
+            }
+        }
+        
+        // We now may have a match, but we can't return it yet.
+        // We need to check if we have a potential for a longer chord
+        // Because of the sort order of the chord list, all chords after this slot
+        // with the same layer are same length or longer than the desired chord.
+        
+        // Now iterate until we get to the longer chords in the layer because
+        // we want to see if there are potential matches in them
+        if ( !noPartial && !partialMatched ) {
+            while (i < ChordCount && Chords[i].layer == layer && Chords[i].keyCount == keyCount) {++i;}
+
+            // i is now at the first longer chord in the layer, or the first key in another layer, on at list's end
+            // Now we look for potential matches with more keys
+            while (i < ChordCount && Chords[i].layer == layer) {
+                if (isPartialOfChord(&Chords[i++], keys, keyCount)) {
+                    // If we have a partial chord
+                    partialMatched = true;
+                }
+            }
+        }
+
+        if (layer == LayerId_None) {
+            break;
+        }
+        layer = LayerId_None;
+    }
+
+    return (matched ? ChordSearch_Exact : 0) | (partialMatched ? ChordSearch_Partial : 0);
+}
+
+void Chords_ResetChords() {
+    ChordCount = 0;
+}
+
+bool setKeyHoldingChord(chord_def_t *chord, uint8_t keyId, key_pressed_state_t pressed) {
+    for (uint8_t i = 0; i < chord->keyCount; ++i) {
+        if (chord->keys[i] == keyId) {
+            if (pressed) chord->pressedStates |= 1 << i;
+            else chord->pressedStates &= ~(1 << i);
+
+            return true;
+        }
+    }
+    return false;
+}
+
+chord_resolution_t Chords_Driver(key_state_t *keyState, layer_id_t layer, const chord_def_t **out_matchedChord)
+{
+    const uint8_t thisKeyId = Utils_KeyStateToKeyId(keyState);
+    if (KeyState_ActivatedNow(keyState) && ResolutionState.unrollingKeysCount > 0) {
+        --ResolutionState.unrollingKeysCount;
+        *out_matchedChord = ResolutionState.unrollingChord;
+        setKeyHoldingChord(ResolutionState.unrollingChord, thisKeyId, KeyPressed);
+        // Since the chord is unrolling, initial action on the keystroke should already have taken effect on the first key.
+        // We set the chord action, but block the initial effect.  This allows the effect of keys to linger until release.
+        // Except with macros, where we specifically want the initial effect on the last key.
+        if ( !(ResolutionState.unrollingKeysCount == 0 && ResolutionState.unrollingChord->action.type == KeyActionType_PlayMacro) ) {
+            keyState->previous = true;
+        }
+        return ChordResolution_Resolved;
+    }
+    if (Cfg.Chords_MinimumIdleTime + KeyHistory_GetLastActivationTime() > CurrentPostponedTime) {
+        return ChordResolution_Failed;
+    }
+    if (KeyState_ActivatedNow(keyState) && ResolutionState.initialKey == NULL) {
+        ResolutionState.initialKey = keyState;
+        ResolutionState.pressTime = CurrentPostponedTime;
+    }
+    else if (ResolutionState.initialKey != keyState) {
+        return ChordResolution_Failed;
+    }
+
+    chord_keys_t pressedKeys;
+    uint8_t keyCount = PostponerQuery_GetPendingKeypresses(pressedKeys + 1, MAX_CHORD_KEYS - 1, ResolutionState.pressTime + Cfg.Chords_Timeout) + 1;
+
+    pressedKeys[0] = thisKeyId;
+
+    // It is interesting to know if we have duplicates because we cannot have chords with duplicates,
+    // and the duplicate will prevent any future events from completing a chord.
+    bool hasDuplicate = PostponerQuery_ContainsKeyId(pressedKeys[0]);
+    for (uint8_t i = 1; i < keyCount; ++i) {
+        for (uint8_t j = 0; j < i; ++j) {
+            if (pressedKeys[i] == pressedKeys[j]) {
+                keyCount = i;
+                hasDuplicate = true;
+                break;
+            }
+        }
+    }
+
+    const bool pressIntervalIsOver = ResolutionState.pressTime + Cfg.Chords_Timeout <= Timer_GetCurrentTime();
+
+    chord_def_t * matchedChord = NULL;
+    chord_search_result_t searchRes = searchForChordAction(&matchedChord, layer, pressedKeys, keyCount, pressIntervalIsOver || hasDuplicate);
+
+    if (searchRes & ChordSearch_Partial) {
+        // There is an unhandled edge case here:  If two chords are defined, one being a subset of the other, the smaller one cannot trigger instantly,
+        // but has to wait to see if the larger one is pressed instead.  So far so good, but if a key outside the larger chord is pressed before timeout,
+        // the smaller chord won't trigger at all because there is now no match anymore, with the unchorded key.
+        // This could be dealt with by creeping up on the chord size every check, possibly with a cached size checked stored in ResolutionState,
+        // but it's complex for a pretty limited edge case.
+        EventScheduler_Schedule(ResolutionState.pressTime + Cfg.Chords_Timeout, EventSchedulerEvent_NativeActions, "NativeActions - Chord Press Interval");
+        return ChordResolution_Wait;
+    }
+
+    // No reason to wait anymore, we resolve one way or the other.    
+    memset((void *)&ResolutionState, 0, sizeof(ResolutionState));
+    // Fake activation of the key now.
+    keyState->current = true;
+    keyState->previous = false;
+
+    if (searchRes & ChordSearch_Exact) {
+        *out_matchedChord = matchedChord;
+        // Check that next acitvation id does not collide with an existing one since we use the activationId to identify chords.
+        // Collision can cause the following
+        //  - Chord activated macro checks for release may use the wrong chord and be incorrect
+        //  - If colliding chords share keyIds, one will not be registered as released until pressed and released again
+        // Maybe not worth the cost?  It's highly unlikely and currently only affects macro checks for release if a macro is kept active for more than 60 chord presses.
+        bool collision;
+        do {
+            collision = false;
+            if (NextActivationId == CHORDS_INVALID_ACTIVATION_ID) ++NextActivationId;
+            for (uint8_t i = 0; i < ChordCount; ++i) {
+                if (Chords[i].activationId == NextActivationId) {
+                    if (++NextActivationId == CHORDS_INVALID_ACTIVATION_ID) {
+                        ++NextActivationId;
+                    }
+                    // Recheck from begining
+                    collision = true;
+                }
+            }
+        } while (collision);
+
+        matchedChord->activationId = NextActivationId++;
+        matchedChord->pressedStates = 0;
+        setKeyHoldingChord(matchedChord, thisKeyId, KeyPressed);
+        if (Cfg.Chords_ApplicationType == ChordApplicationType_LeadingKey) {
+            PostponerExtended_ConsumePendingKeypresses(keyCount - 1);
+        }
+        else if (Cfg.Chords_ApplicationType == ChordApplicationType_AllKeys) {
+            if (matchedChord->action.type == KeyActionType_PlayMacro) {
+                // Do not activate on the first key, but rather on the last.
+                // This is to prevent the following issues:
+                //  - activateKeyPostponed with prepend, or consumePending modifying the roll-out
+                //  - the rest of the chord waiting on the queue causing problems with ifSecondary in the macro we run
+                // We are still hypothetically vulnerable to other macros using those commands, but that's highly hypothetical as they would
+                // likely be used while postponeKeys is active, meaning we would not be resolving anyway.
+                keyState->previous = true;
+            }
+            ResolutionState.unrollingKeysCount = keyCount - 1;
+            ResolutionState.unrollingChord = matchedChord;
+        }
+        return ChordResolution_Resolved;
+    }
+
+    return ChordResolution_Failed;
+}
+
+void Chords_KeyReleased(const key_state_t *keyState)
+{
+    for (uint8_t i = 0; i < ChordCount; ++i) {
+        if (Chords[i].pressedStates == 0) continue;
+        if (setKeyHoldingChord(&Chords[i], Utils_KeyStateToKeyId(keyState), KeyReleased) ) {
+            if (Chords[i].pressedStates == 0) {
+                Chords[i].activationId = 0;
+            }
+            return;
+        }
+    }
+}
+
+bool Chords_IsChordActivationActive(uint8_t activationId, bool checkPostponer)
+{
+    if (activationId == CHORDS_INVALID_ACTIVATION_ID) {
+        return false;
+    }
+    for (uint8_t i = 0; i < ChordCount; ++i) {
+        if (Chords[i].activationId == activationId) {
+            for (uint8_t j = 0; j < Chords[i].keyCount; ++j) {
+                if (Chords[i].pressedStates & (1 << j)) {
+                    const key_state_t * const keyState = Utils_KeyIdToKeyState(Chords[i].keys[j]);
+                    // Since we catch releases, if it's active, it's still the same activation.
+                    // Check keystate because releases are registered after macro has it's go, so otherwise,
+                    // release would not get registered for the key which applied the macro.
+                    if (KeyState_Active(keyState) && (!checkPostponer || !PostponerQuery_IsKeyReleased(keyState))) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
\ No newline at end of file
diff --git a/right/src/chords.h b/right/src/chords.h
new file mode 100644
index 000000000..35caf7abb
--- /dev/null
+++ b/right/src/chords.h
@@ -0,0 +1,42 @@
+#ifndef __CHORDS_H__
+#define __CHORDS_H__
+
+#include "key_action.h"
+
+#define MAX_CHORD_KEYS 5
+#define CHORDS_ACTIVATIONID_SIZE 6
+#define CHORDS_INVALID_ACTIVATION_ID 0
+
+typedef enum {
+    ChordApplicationType_LeadingKey,
+    ChordApplicationType_AllKeys,
+} chord_application_type_t;
+
+typedef enum {
+    ChordResolution_Wait,
+    ChordResolution_Failed,
+    ChordResolution_Resolved,
+} chord_resolution_t;
+
+typedef uint8_t chord_keys_t[MAX_CHORD_KEYS];
+
+typedef struct {
+    // Chord definition
+    layer_id_t layer;
+    chord_keys_t keys;
+    key_action_t action;
+    uint8_t keyCount : 3;
+
+    // Chord state
+    uint8_t pressedStates : MAX_CHORD_KEYS;
+    uint8_t activationId : CHORDS_ACTIVATIONID_SIZE;
+} ATTR_PACKED chord_def_t;
+
+bool Chords_TryAddChord(layer_id_t layer, chord_keys_t keys, uint8_t keyCount, key_action_t *action);
+void Chords_ResetChords();
+
+chord_resolution_t Chords_Driver(key_state_t *keyState, layer_id_t layer, const chord_def_t **out_matchedChord);
+void Chords_KeyReleased(const key_state_t *keyState);
+bool Chords_IsChordActivationActive(uint8_t activationId, bool checkPostponer); 
+
+#endif
diff --git a/right/src/config_manager.c b/right/src/config_manager.c
index b10d2d84e..b908e721c 100644
--- a/right/src/config_manager.c
+++ b/right/src/config_manager.c
@@ -271,6 +271,9 @@ const config_t DefaultCfg = (config_t){
         .Macros_OneShotTimeout = 500,
         .AutoShiftDelay = 0,
         .ChordingDelay = 0,
+        .Chords_Timeout = 75,
+        .Chords_MinimumIdleTime = 70,
+        .Chords_ApplicationType = ChordApplicationType_LeadingKey,
         .BatteryStationaryMode = false,
 #ifdef __ZEPHYR__
         .I2cBaudRate = 0,
diff --git a/right/src/config_manager.h b/right/src/config_manager.h
index 5e00d34c4..461fbb3f5 100644
--- a/right/src/config_manager.h
+++ b/right/src/config_manager.h
@@ -92,6 +92,10 @@
         uint16_t Macros_OneShotTimeout;
         uint16_t AutoShiftDelay;
         uint8_t ChordingDelay;
+        uint8_t Chords_Timeout;
+        uint8_t Chords_ApplicationType;
+        uint16_t Chords_MinimumIdleTime;
+        
         key_state_t* EmergencyKey;
         uint8_t RecoveryKey;
 
diff --git a/right/src/key_action.h b/right/src/key_action.h
index fe4d51b0a..0102d71f6 100644
--- a/right/src/key_action.h
+++ b/right/src/key_action.h
@@ -116,7 +116,8 @@
     typedef struct {
         key_action_t action;
         rgb_t color;
-        bool colorOverridden;
+        bool colorOverridden : 1;
+        bool isPartOfChord : 1;
     } ATTR_PACKED key_definition_t;
 
     typedef struct {
diff --git a/right/src/key_history.c b/right/src/key_history.c
index 4734dc30a..97485801e 100644
--- a/right/src/key_history.c
+++ b/right/src/key_history.c
@@ -1,55 +1,134 @@
+#include "chords.h"
 #include "config_manager.h"
 #include "key_history.h"
 #include "postponer.h"
 
 typedef enum {
-    DoubletapState_Blocked,
-    DoubletapState_First,
-    DoubletapState_Multitap,
-    DoubletapState_Doubletap,
-} doubletap_state_t;
+    HistoryEventType_Key,
+    HistoryEventType_Chord,
+} history_event_type_t;
 
 typedef struct {
-    const key_state_t *keyState;
-    uint8_t keyActivationId;
+    const chord_def_t *chord;
+    const key_state_t *chord_keys[MAX_CHORD_KEYS];
+} ATTR_PACKED previous_chord_event_type_t;
+
+typedef struct {
+    history_event_type_t eventType;
+    union {
+        const key_state_t *key;
+        previous_chord_event_type_t chord;
+    } event;
     uint32_t timestamp;
-    doubletap_state_t doubletapState;
-} previous_key_event_type_t;
+    bool multiTapBroken : 1;
+    uint8_t multiTapCount : 7;
+} ATTR_PACKED previous_event_type_t;
+
 
-static previous_key_event_type_t lastPress;
+previous_event_type_t lastPress;
 
 void KeyHistory_RecordPress(const key_state_t *keyState)
 {
     const bool isMultitap = 
-        keyState == lastPress.keyState
-        && lastPress.doubletapState != DoubletapState_Blocked
+        lastPress.eventType == HistoryEventType_Key 
+        && keyState == lastPress.event.key
+        && !lastPress.multiTapBroken
         && CurrentPostponedTime < lastPress.timestamp + Cfg.DoubletapTimeout;
-    const bool isDoubletap = isMultitap &&
-        (lastPress.doubletapState == DoubletapState_First || lastPress.doubletapState == DoubletapState_Multitap);
 
-    lastPress = (previous_key_event_type_t){
-        .keyState = keyState,
-        .keyActivationId = keyState->activationId,
+    lastPress = (previous_event_type_t){
+        .eventType = HistoryEventType_Key,
+        .event = { .key = keyState },
         .timestamp = CurrentPostponedTime,
-        .doubletapState = isDoubletap ? DoubletapState_Doubletap :
-            isMultitap ? DoubletapState_Multitap :
-            DoubletapState_First,
+        .multiTapBroken = false,
+        .multiTapCount = 1 + (isMultitap ? lastPress.multiTapCount : 0),
+    };
+}
+
+void KeyHistory_RecordChordPress(const key_state_t *keyState, const chord_def_t *chord)
+{
+    const bool isSameChord = 
+        lastPress.eventType == HistoryEventType_Chord
+        && lastPress.event.chord.chord == chord;
+
+    if (isSameChord && Cfg.Chords_ApplicationType == ChordApplicationType_AllKeys) {
+        // There is a chance that the key press is one from the same chord activation
+        // This will be the case if we can see it's the same chord as last, but we haven't seen that key
+        // for that chord for that event.
+        // If so, register the key as pressed as part of this chord
+        bool isSameActivation = isSameChord;
+        for (uint8_t i = 0; isSameActivation && i < MAX_CHORD_KEYS; ++i) {
+            if (lastPress.event.chord.chord_keys[i] == keyState) {
+                isSameActivation = false;
+                break;
+            }
+            if (lastPress.event.chord.chord_keys[i] == NULL) {
+                break;
+            }
+        }
+
+        if (isSameActivation) {
+            uint8_t i = 0;
+            while (lastPress.event.chord.chord_keys[i] != NULL) ++i;
+            lastPress.event.chord.chord_keys[i] = keyState;
+            return;
+        }
+    }
+
+    const bool isMultitap = 
+        isSameChord
+        && !lastPress.multiTapBroken
+        && CurrentPostponedTime < lastPress.timestamp + Cfg.DoubletapTimeout;
+    
+    lastPress = (previous_event_type_t) {
+        .eventType = HistoryEventType_Chord,
+        .event.chord = {
+            .chord_keys = { keyState, NULL, NULL, NULL, NULL },
+            .chord = chord,
+        },
+        .timestamp = CurrentPostponedTime,
+        .multiTapBroken = false,
+        .multiTapCount = 1 + (isMultitap ? lastPress.multiTapCount : 0),
     };
 }
 
 void KeyHistory_RecordRelease(const key_state_t *keyState)
 {
-    if (keyState != lastPress.keyState) {
-        lastPress.doubletapState = DoubletapState_Blocked;
+    if (lastPress.eventType == HistoryEventType_Key) {
+        if (keyState != lastPress.event.key) {
+            lastPress.multiTapBroken = true;
+        }
+    }
+    else if (lastPress.eventType == HistoryEventType_Chord) {
+        bool breaksMulti = true;
+        for (uint8_t i = 0; i < MAX_CHORD_KEYS; ++i) {
+            if (lastPress.event.chord.chord_keys[i] == NULL) break;
+            if (lastPress.event.chord.chord_keys[i] == keyState ) {
+                    breaksMulti = false;
+                    break;
+            }
+        }
+        lastPress.multiTapBroken |= breaksMulti;
     }
 }
 
 bool KeyHistory_WasLastDoubletap()
 {
-    return lastPress.doubletapState == DoubletapState_Doubletap;
+    return lastPress.multiTapCount % 2 == 0;
 }
 
 bool KeyHistory_WasLastMultitap()
 {
-    return lastPress.doubletapState >= DoubletapState_Multitap;
+    return lastPress.multiTapCount > 1;
+}
+
+uint8_t KeyHistory_GetChordActivationIdOfLastAction()
+{
+    if (lastPress.eventType != HistoryEventType_Chord) {
+        return CHORDS_INVALID_ACTIVATION_ID;
+    }
+    return lastPress.event.chord.chord->activationId;
+}
+
+uint32_t KeyHistory_GetLastActivationTime() {
+    return lastPress.timestamp;
 }
\ No newline at end of file
diff --git a/right/src/key_history.h b/right/src/key_history.h
index cba1547f3..8670f7e1d 100644
--- a/right/src/key_history.h
+++ b/right/src/key_history.h
@@ -3,6 +3,7 @@
 
 // Includes:
 
+#include "chords.h"
 #include "key_states.h"
 
 // Macros:
@@ -13,10 +14,16 @@
 
 // Functions:
 
+// Registering events
 void KeyHistory_RecordPress(const key_state_t *keyState);
+void KeyHistory_RecordChordPress(const key_state_t *keyState, const chord_def_t *chord);
 void KeyHistory_RecordRelease(const key_state_t *keyState);
+
+// Querying data
 bool KeyHistory_WasLastDoubletap();
 bool KeyHistory_WasLastMultitap();
+uint8_t KeyHistory_GetChordActivationIdOfLastAction();
+uint32_t KeyHistory_GetLastActivationTime();
 
 
 #endif
\ No newline at end of file
diff --git a/right/src/keymap.c b/right/src/keymap.c
index 33e042f14..300854618 100644
--- a/right/src/keymap.c
+++ b/right/src/keymap.c
@@ -1,6 +1,7 @@
 #include <string.h>
 #include "arduino_hid/ConsumerAPI.h"
 #include "arduino_hid/SystemAPI.h"
+#include "chords.h"
 #include "keymap.h"
 #include "layer.h"
 #include "layer_switcher.h"
@@ -53,6 +54,7 @@ void SwitchKeymapById(uint8_t index, bool resetLayerStack)
 #endif
     SegmentDisplay_UpdateKeymapText();
     if (DEVICE_IS_MASTER) {
+        Chords_ResetChords();
         MacroEvent_RegisterLayerMacros();
         MacroEvent_OnKeymapChange(index);
         MacroEvent_OnLayerChange(ActiveLayer);
diff --git a/right/src/macro_events.c b/right/src/macro_events.c
index 38c7d3718..3bbf304b7 100644
--- a/right/src/macro_events.c
+++ b/right/src/macro_events.c
@@ -55,7 +55,7 @@ void MacroEvent_OnInit()
     const char* name = "$onInit";
     uint8_t idx = FindMacroIndexByName(name, name + strlen(name), false);
     if (idx != 255) {
-        previousEventMacroSlot = Macros_StartMacro(idx, NULL, 0, 255, 255, false, NULL);
+        previousEventMacroSlot = Macros_StartMacro(idx, NULL, 0, 255, false, NULL);
     }
 
     registerJoinSplitEvents();
@@ -68,7 +68,7 @@ static void startMacroInSlot(macro_index_t macroIndex, uint8_t* slotId) {
         if (*slotId != 255 && MacroState[*slotId].ms.macroPlaying) {
             *slotId = Macros_QueueMacro(macroIndex, NULL, 255, *slotId);
         } else {
-            *slotId = Macros_StartMacro(macroIndex, NULL, 0, 255, 255, false, NULL);
+            *slotId = Macros_StartMacro(macroIndex, NULL, 0, 255, false, NULL);
         }
     }
 }
diff --git a/right/src/macros/commands.c b/right/src/macros/commands.c
index 4229e9faa..9a6c6e505 100644
--- a/right/src/macros/commands.c
+++ b/right/src/macros/commands.c
@@ -136,6 +136,9 @@ bool Macros_CurrentMacroKeyIsActive()
     if (S->ms.currentMacroKey == NULL) {
         return S->ms.oneShot == 1;
     }
+    if (S->ms.chordActivationId != CHORDS_INVALID_ACTIVATION_ID && Cfg.Chords_ApplicationType == ChordApplicationType_AllKeys) {
+        return (S->ms.oneShot == 1) || Chords_IsChordActivationActive(S->ms.chordActivationId, isCurrentMacroPostponing());
+    }
     if (isCurrentMacroPostponing()) {
         bool isSameActivation = (S->ms.currentMacroKey->activationId == S->ms.keyActivationId);
         bool keyIsActive = (KeyState_Active(S->ms.currentMacroKey) && !PostponerQuery_IsKeyReleased(S->ms.currentMacroKey));
@@ -163,7 +166,7 @@ static macro_result_t writeNum(uint32_t a)
 
     macro_result_t res = Macros_DispatchText(&num[10-len], len, NULL);
     if (res == MacroResult_Finished) {
-        PostponerExtended_ConsumePendingKeypresses(1, true);
+        PostponerExtended_ConsumePendingKeypresses(1);
         return MacroResult_Finished;
     }
     return res;
@@ -1064,7 +1067,7 @@ static macro_result_t processResolveNextKeyIdCommand()
     }
     macro_result_t res = writeNum(PostponerExtended_PendingId(0));
     if (res == MacroResult_Finished) {
-        PostponerExtended_ConsumePendingKeypresses(1, true);
+        PostponerExtended_ConsumePendingKeypresses(1);
         return MacroResult_Finished;
     }
     return res;
@@ -1203,7 +1206,7 @@ static macro_result_t processIfShortcutCommand(parser_context_t* ctx, bool negat
                 return MacroResult_Sleeping;
             }
             else if (cancelInTimedOut) {
-                PostponerExtended_ConsumePendingKeypresses(numArgs, true);
+                PostponerExtended_ConsumePendingKeypresses(numArgs);
                 S->ms.macroBroken = true;
                 goto conditionFailed;
             }
@@ -1238,7 +1241,7 @@ static macro_result_t processIfShortcutCommand(parser_context_t* ctx, bool negat
 matched:
     //all keys match
     if (consume) {
-        PostponerExtended_ConsumePendingKeypresses(numArgs, true);
+        PostponerExtended_ConsumePendingKeypresses(numArgs);
     }
     if (negate) {
         goto conditionFailed;
@@ -1267,8 +1270,12 @@ uint8_t Macros_TryConsumeKeyId(parser_context_t* ctx)
     uint8_t keyId = MacroKeyIdParser_TryConsumeKeyId(ctx);
 
     if (keyId == 255 && isNUM(ctx)) {
+        bool ErrorBefore = Macros_ParserError;
+        Macros_ParserError = false;
         uint8_t num = Macros_ConsumeInt(ctx);
-        if (Macros_ParserError) {
+        bool ErrorAfter = Macros_ParserError;
+        Macros_ParserError |= ErrorBefore;
+        if (ErrorAfter) {
             return 255;
         } else {
             return num;
@@ -1617,7 +1624,7 @@ static macro_result_t processConsumePendingCommand(parser_context_t* ctx)
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
-    PostponerExtended_ConsumePendingKeypresses(cnt, true);
+    PostponerExtended_ConsumePendingKeypresses(cnt);
     return MacroResult_Finished;
 }
 
diff --git a/right/src/macros/core.c b/right/src/macros/core.c
index afc0ecdac..c0361177f 100644
--- a/right/src/macros/core.c
+++ b/right/src/macros/core.c
@@ -63,9 +63,6 @@ macro_scope_state_t MacroScopeState[MACRO_SCOPE_STATE_POOL_SIZE];
 macro_state_t MacroState[MACRO_STATE_POOL_SIZE];
 macro_state_t *S = NULL;
 
-macro_history_t MacroHistory[MACRO_HISTORY_POOL_SIZE];
-uint8_t MacroHistoryPosition = 0;
-
 static void checkSchedulerHealth(const char* tag);
 static void wakeMacroInSlot(uint8_t slotIdx);
 static void scheduleSlot(uint8_t slotIdx);
@@ -306,9 +303,6 @@ static macro_result_t endMacro(void)
     S->ms.macroSleeping = false;
     S->ms.macroPlaying = false;
     S->ms.macroBroken = false;
-    MacroHistoryPosition = (MacroHistoryPosition + 1) % MACRO_HISTORY_POOL_SIZE;
-    MacroHistory[MacroHistoryPosition].macroIndex = S->ms.currentMacroIndex;
-    MacroHistory[MacroHistoryPosition].macroStartTime = S->ms.currentMacroStartTime;
     unscheduleCurrentSlot();
     if (S->ms.parentMacroSlot != 255) {
         //resume our calee, if this macro was called by another macro
@@ -423,10 +417,22 @@ macro_result_t Macros_ExecMacro(uint8_t macroIndex)
     return MacroResult_JumpedForward;
 }
 
+//partentMacroSlot == 255 means no parent
+uint8_t startMacro(
+    uint8_t index,
+    key_state_t *keyState,
+    uint16_t argumentOffset,
+    uint8_t keyActivationId,
+    uint8_t parentMacroSlot,
+    bool runFirstAction,
+    const char *inlineText,
+    const macro_state_t *parentMacroState
+);
+
 macro_result_t Macros_CallMacro(uint8_t macroIndex)
 {
     uint32_t parentSlotIndex = S - MacroState;
-    uint8_t childSlotIndex = Macros_StartMacro(macroIndex, S->ms.currentMacroKey, 0, S->ms.keyActivationId, parentSlotIndex, true, NULL);
+    uint8_t childSlotIndex = startMacro(macroIndex, S->ms.currentMacroKey, 0, S->ms.keyActivationId, parentSlotIndex, true, NULL, S);
 
     if (childSlotIndex != 255) {
         unscheduleCurrentSlot();
@@ -440,7 +446,7 @@ macro_result_t Macros_CallMacro(uint8_t macroIndex)
 
 macro_result_t Macros_ForkMacro(uint8_t macroIndex)
 {
-    Macros_StartMacro(macroIndex, S->ms.currentMacroKey, 0, S->ms.keyActivationId, 255, true, NULL);
+    startMacro(macroIndex, S->ms.currentMacroKey, 0, S->ms.keyActivationId, 255, true, NULL, S);
     return MacroResult_Finished;
 }
 
@@ -450,7 +456,8 @@ uint8_t initMacro(
     uint16_t argumentOffset,
     uint8_t keyActivationId,
     uint8_t parentMacroSlot,
-    const char *inlineText
+    const char *inlineText,
+    const macro_state_t *parentState
 ) {
     if (!macroIsValid(index) || !findFreeStateSlot() || !findFreeScopeStateSlot())  {
        return 255;
@@ -464,11 +471,22 @@ uint8_t initMacro(
     S->ms.currentMacroIndex = index;
     S->ms.currentMacroKey = keyState;
     S->ms.keyActivationId = keyActivationId;
-    S->ms.currentMacroStartTime = CurrentPostponedTime;
     S->ms.currentMacroArgumentOffset = argumentOffset;
     S->ms.parentMacroSlot = parentMacroSlot;
-    S->ms.isDoubletap = keyState != NULL && KeyHistory_WasLastDoubletap();
     S->ms.isFirstCommand = true;
+    if (parentState != NULL) {
+        S->ms.currentMacroStartTime = S->ms.currentMacroStartTime;
+        S->ms.secondaryRoleState = S->ms.secondaryRoleState;
+        S->ms.isDoubletap = S->ms.isDoubletap;
+        S->ms.chordActivationId = S->ms.chordActivationId;
+    }
+    else {
+        S->ms.currentMacroStartTime = CurrentPostponedTime;
+        if (keyState != NULL) {
+            S->ms.isDoubletap = KeyHistory_WasLastDoubletap();
+            S->ms.chordActivationId = KeyHistory_GetChordActivationIdOfLastAction(); // returns invalid id if it was not a chord.
+        }
+    }
 
     // If inline text is provided, set up the action before resetToAddressZero
     if (inlineText != NULL) {
@@ -491,20 +509,19 @@ uint8_t initMacro(
     return S - MacroState;
 }
 
-
-//partentMacroSlot == 255 means no parent
-uint8_t Macros_StartMacro(
+uint8_t startMacro(
     uint8_t index,
     key_state_t *keyState,
     uint16_t argumentOffset,
     uint8_t keyActivationId,
     uint8_t parentMacroSlot,
     bool runFirstAction,
-    const char *inlineText
+    const char *inlineText,
+    const macro_state_t *parentMacroState
 ) {
     macro_state_t* oldState = S;
 
-    uint8_t slotIndex = initMacro(index, keyState, argumentOffset, keyActivationId, parentMacroSlot, inlineText);
+    uint8_t slotIndex = initMacro(index, keyState, argumentOffset, keyActivationId, parentMacroSlot, inlineText, parentMacroState);
 
     if (slotIndex == 255) {
         S = oldState;
@@ -528,9 +545,20 @@ uint8_t Macros_StartMacro(
     return slotIndex;
 }
 
+uint8_t Macros_StartMacro(
+    uint8_t index,
+    key_state_t *keyState,
+    uint16_t argumentOffset,
+    uint8_t keyActivationId,
+    bool runFirstAction,
+    const char *inlineText
+) {
+    return startMacro(index, keyState, argumentOffset, keyActivationId, MacroIndex_None, runFirstAction, inlineText, NULL);
+}
+
 uint8_t Macros_StartInlineMacro(const char *text, key_state_t *keyState, uint8_t keyActivationId)
 {
-    return Macros_StartMacro(MacroIndex_InlineMacro, keyState, 0, keyActivationId, 255, true, text);
+    return startMacro(MacroIndex_InlineMacro, keyState, 0, keyActivationId, 255, true, text, NULL);
 }
 
 void Macros_ValidateMacro(uint8_t macroIndex, uint16_t argumentOffset, uint8_t moduleId, uint8_t keyIdx, uint8_t keymapIdx, uint8_t layerIdx) {
@@ -544,7 +572,7 @@ void Macros_ValidateMacro(uint8_t macroIndex, uint16_t argumentOffset, uint8_t m
         return;
     }
 
-    uint8_t slotIndex = initMacro(macroIndex, NULL, argumentOffset, 255, 255, NULL);
+    uint8_t slotIndex = initMacro(macroIndex, NULL, argumentOffset, 255, 255, NULL, NULL);
 
     if (slotIndex == 255) {
         S = NULL;
@@ -639,7 +667,7 @@ uint8_t Macros_QueueMacro(uint8_t index, key_state_t *keyState, uint8_t keyActiv
 {
     macro_state_t* oldState = S;
 
-    uint8_t slotIndex = initMacro(index, keyState, 0, keyActivationId, 255, NULL);
+    uint8_t slotIndex = initMacro(index, keyState, 0, keyActivationId, 255, NULL, NULL);
 
     if (slotIndex == 255) {
         return slotIndex;
diff --git a/right/src/macros/core.h b/right/src/macros/core.h
index 6edccf7ae..3c78ed0f9 100644
--- a/right/src/macros/core.h
+++ b/right/src/macros/core.h
@@ -6,6 +6,7 @@
     #include <stdint.h>
     #include <stdbool.h>
     #include "attributes.h"
+    #include "chords.h"
     #include "key_action.h"
     #include "key_states.h"
     #include "str_utils.h"
@@ -17,7 +18,6 @@
 
     #define MAX_MACRO_NUM 255
     #define MACRO_STATE_POOL_SIZE 16
-    #define MACRO_HISTORY_POOL_SIZE 16
     #define MACRO_SCOPE_STATE_POOL_SIZE (MACRO_STATE_POOL_SIZE*2)
     #define MAX_REG_COUNT 32
 
@@ -129,11 +129,6 @@
 
     typedef struct macro_state_t macro_state_t;
 
-    typedef struct {
-        uint32_t macroStartTime;
-        uint8_t macroIndex;
-    } macro_history_t;
-
     struct macro_state_t {
         // local scope data
         macro_scope_state_t *ls;
@@ -155,6 +150,7 @@
             uint8_t oneShot : 2;
             bool macroInterrupted : 1;
             uint8_t keyActivationId: 4;
+            uint8_t chordActivationId: CHORDS_ACTIVATIONID_SIZE;
             // TODO: refactor macroSleeping, macroBroken and macroPlaying into a single state?
             bool macroSleeping : 1;
             bool macroBroken : 1;
@@ -237,7 +233,6 @@
     extern macro_reference_t AllMacros[MacroIndex_MaxCount];
     extern uint8_t AllMacrosCount;
     extern macro_state_t MacroState[MACRO_STATE_POOL_SIZE];
-    extern macro_history_t MacroHistory[MACRO_HISTORY_POOL_SIZE];
     extern macro_scope_state_t MacroScopeState[MACRO_SCOPE_STATE_POOL_SIZE];
     extern macro_state_t *S;
     extern bool MacroPlaying;
@@ -277,7 +272,7 @@
     macro_result_t Macros_SleepTillTime(uint32_t time, const char* reason);
     uint8_t Macros_ConsumeLayerId(parser_context_t* ctx);
     uint8_t Macros_QueueMacro(uint8_t index, key_state_t *keyState, uint8_t keyActivationId, uint8_t queueAfterSlot);
-    uint8_t Macros_StartMacro(uint8_t index, key_state_t *keyState, uint16_t argumentOffset, uint8_t keyActivationId, uint8_t parentMacroSlot, bool runFirstAction, const char *inlineText);
+    uint8_t Macros_StartMacro(uint8_t index, key_state_t *keyState, uint16_t argumentOffset, uint8_t keyActivationId, bool runFirstAction, const char *inlineText);
     uint8_t Macros_StartInlineMacro(const char *text, key_state_t *keyState, uint8_t keyActivationId);
     uint8_t Macros_TryConsumeKeyId(parser_context_t* ctx);
     uint8_t Macros_ConsumeKeyId(parser_context_t* ctx);
diff --git a/right/src/macros/set_command.c b/right/src/macros/set_command.c
index 91a5ca91a..0f90fc05d 100644
--- a/right/src/macros/set_command.c
+++ b/right/src/macros/set_command.c
@@ -1,5 +1,6 @@
 #include "macros/set_command.h"
 #include "attributes.h"
+#include "chords.h"
 #include "config_parser/parse_config.h"
 #include "config_parser/parse_keymap.h"
 #include "key_states.h"
@@ -800,6 +801,17 @@ static macro_variable_t navigationModeAction(parser_context_t* ctx, set_command_
     return noneVar();
 }
 
+static inline key_coordinates_t validateKeyId(uint8_t keyId, const char *at) {
+    uint8_t slotIdx = keyId/64;
+    uint8_t inSlotIdx = keyId%64;
+
+    if(slotIdx > SLOT_COUNT || inSlotIdx > MAX_KEY_COUNT_PER_MODULE) {
+        Macros_ReportErrorNum("Invalid key id:", keyId, at);
+    }
+
+    return (key_coordinates_t){.slotId = slotIdx, .inSlotId = inSlotIdx};
+}
+
 static macro_variable_t keymapAction(parser_context_t* ctx, set_command_action_t action)
 {
     uint8_t layerId = Macros_ConsumeLayerId(ctx);
@@ -821,12 +833,7 @@ static macro_variable_t keymapAction(parser_context_t* ctx, set_command_action_t
 
     key_action_t keyAction = parseKeyAction(ctx);
 
-    uint8_t slotIdx = keyId/64;
-    uint8_t inSlotIdx = keyId%64;
-
-    if(slotIdx > SLOT_COUNT || inSlotIdx > MAX_KEY_COUNT_PER_MODULE) {
-        Macros_ReportErrorNum("Invalid key id:", keyId, keyIdPos.at);
-    }
+    key_coordinates_t cords = validateKeyId(keyId, keyIdPos.at);
 
     if (Macros_ParserError) {
         return noneVar();
@@ -835,7 +842,7 @@ static macro_variable_t keymapAction(parser_context_t* ctx, set_command_action_t
         return noneVar();
     }
 
-    key_action_t* actionSlot = &CurrentKeymap[layerId][slotIdx][inSlotIdx].action;
+    key_action_t* actionSlot = &CurrentKeymap[layerId][cords.slotId][cords.inSlotId].action;
 
 #ifdef __ZEPHYR__
     StateSync_UpdateLayer(layerId, true);
@@ -845,6 +852,62 @@ static macro_variable_t keymapAction(parser_context_t* ctx, set_command_action_t
     return noneVar();
 }
 
+static macro_variable_t chordAction(parser_context_t* ctx, set_command_action_t action)
+{
+    bool hasLayer = TryConsumeDot(ctx);
+
+    uint8_t layerId = hasLayer ? Macros_ConsumeLayerId(ctx) : LayerId_None;
+
+    uint8_t keyCount = 0;
+    uint8_t keys[MAX_CHORD_KEYS];
+    const char *duplicatePos = NULL;
+    do {
+        const char *keyPos = ctx->at;
+        keys[keyCount] = Macros_TryConsumeKeyId(ctx);
+
+        if (keys[keyCount] == 255) break;
+
+        validateKeyId(keys[keyCount], keyPos);
+        if(duplicatePos == NULL) {
+            for (int i = 0; i < keyCount; ++i) {
+                if (keys[i] == keys[keyCount]) {
+                    duplicatePos = keyPos;
+                    break;
+                }
+            }
+        }
+    } while (++keyCount < MAX_CHORD_KEYS);
+
+    if(duplicatePos != NULL) {
+        Macros_ReportError("Cannot have duplicate keys in a chord!", duplicatePos, NULL);
+    }
+
+    if (keyCount < 2 || keyCount == MAX_CHORD_KEYS) {
+        CTX_COPY(errorPos, *ctx);
+        if (keyCount < 2 || Macros_TryConsumeKeyId(ctx) != 255) {
+            while (Macros_TryConsumeKeyId(ctx) != 255) {}
+            Macros_ReportErrorPos(&errorPos, "Invalid number of keys in chord.  Must be between 2 and 5.");
+        }
+    }
+
+    if (action == SetCommandAction_Read) {
+        Macros_ReportErrorPos(ctx, "Reading actions is not supported!");
+        return noneVar();
+    }
+
+    key_action_t chordAction = parseKeyAction(ctx);
+
+    if (Macros_ParserError || Macros_DryRun) {
+        return noneVar();
+    }
+
+    if (!Chords_TryAddChord(layerId, keys, keyCount, &chordAction)) {
+        Macros_ReportErrorPos(ctx, "Could not add chords, no more free chord slots.");
+    }
+
+    return noneVar();
+}
+
 static macro_variable_t modLayerTriggers(parser_context_t* ctx, set_command_action_t action)
 {
     uint8_t layerId = Macros_ConsumeLayerId(ctx);
@@ -1000,6 +1063,9 @@ static macro_variable_t root(parser_context_t* ctx, set_command_action_t action)
         ConsumeUntilDot(ctx);
         return keymapAction(ctx, action);
     }
+    else if (ConsumeToken(ctx, "chord")) {
+        return chordAction(ctx, action);
+    }
     else if (ConsumeToken(ctx, "navigationModeAction")) {
         ConsumeUntilDot(ctx);
         return navigationModeAction(ctx, action);
@@ -1084,6 +1150,27 @@ static macro_variable_t root(parser_context_t* ctx, set_command_action_t action)
         DEFINE_INT_LIMITS(0, 255);
         ASSIGN_INT(Cfg.ChordingDelay);
     }
+    else if (ConsumeToken(ctx, "chordTimeout")) {
+        DEFINE_INT_LIMITS(0, 255);
+        ASSIGN_INT(Cfg.Chords_Timeout);    
+    }
+    else if (ConsumeToken(ctx, "chordPriorIdleTime")) {
+        DEFINE_INT_LIMITS(0, 65535);
+        ASSIGN_INT(Cfg.Chords_MinimumIdleTime);
+    }
+    else if (ConsumeToken(ctx, "chordLifetime")) {
+        if (ConsumeToken(ctx, "leadingKey")) {
+            DEFINE_NONE_LIMITS();
+            ASSIGN_CUSTOM(int32_t, intVar, Cfg.Chords_ApplicationType, ChordApplicationType_LeadingKey);
+        }
+        else if (ConsumeToken(ctx, "allKeys")) {
+            DEFINE_NONE_LIMITS();
+            ASSIGN_CUSTOM(int32_t, intVar, Cfg.Chords_ApplicationType, ChordApplicationType_AllKeys);
+        }
+        else {
+            Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
+        }
+    }
     else if (ConsumeToken(ctx, "autoShiftDelay")) {
         DEFINE_INT_LIMITS(0, 65535);
         ASSIGN_INT(Cfg.AutoShiftDelay);
diff --git a/right/src/mouse_controller.c b/right/src/mouse_controller.c
index 940b8c001..cc2d21e6d 100644
--- a/right/src/mouse_controller.c
+++ b/right/src/mouse_controller.c
@@ -336,7 +336,7 @@ static void handleNewCaretModeAction(caret_axis_t axis, uint8_t resultSign, int1
             caret_dir_action_t* dirActions = &currentCaretConfig->axisActions[ks->caretAxis];
             ks->caretAction.action = resultSign > 0 ? dirActions->positiveAction : dirActions->negativeAction;
             ks->caretFakeKeystate.current = true;
-            ApplyKeyAction(&ks->caretFakeKeystate, &ks->caretAction, &ks->caretAction.action, &MouseControllerKeyboardReports);
+            ApplyKeyAction(&ks->caretFakeKeystate, &ks->caretAction, &MouseControllerKeyboardReports);
             Macros_WakeBecauseOfKeystateChange();
             EventVector_Set(EventVector_MouseController);
             break;
@@ -359,7 +359,7 @@ static void handleSimpleRunningAction(module_kinetic_state_t* ks) {
     bool tmp = ks->caretFakeKeystate.current;
     ks->caretFakeKeystate.current = !ks->caretFakeKeystate.previous;
     ks->caretFakeKeystate.previous = tmp;
-    ApplyKeyAction(&ks->caretFakeKeystate, &ks->caretAction, &ks->caretAction.action, &MouseControllerKeyboardReports);
+    ApplyKeyAction(&ks->caretFakeKeystate, &ks->caretAction, &MouseControllerKeyboardReports);
     Macros_WakeBecauseOfKeystateChange();
     EventVector_Set(EventVector_MouseController);
 }
diff --git a/right/src/postponer.c b/right/src/postponer.c
index 1aebb4fb1..182d38d2b 100644
--- a/right/src/postponer.c
+++ b/right/src/postponer.c
@@ -361,7 +361,7 @@ uint8_t PostponerQuery_PendingKeypressCount()
 }
 
 
-bool PostponerQuery_IsKeyReleased(key_state_t* key)
+bool PostponerQuery_IsKeyReleased(const key_state_t* key)
 {
     if (key == NULL) {
         return false;
@@ -442,6 +442,17 @@ void PostponerQuery_FindFirstReleased(const postponer_buffer_record_type_t** rel
     return;
 }
 
+uint8_t PostponerQuery_GetPendingKeypresses(uint8_t keyIds[], uint8_t maxCount, uint32_t cutoffTime) {
+    uint8_t pos = 0;
+    uint8_t i = 0;
+    while (pos < maxCount) {
+        while (i < bufferSize && buffer[POS(i)].event.type != PostponerEventType_PressKey) { ++i; }
+        if (i == bufferSize || buffer[POS(i)].time > cutoffTime) break;
+        keyIds[pos++] = Utils_KeyStateToKeyId(buffer[POS(i++)].event.key.keyState);
+    }
+    return pos;
+}
+
 //##########################
 //### Extended Functions ###
 //##########################
@@ -483,10 +494,10 @@ uint32_t PostponerExtended_LastPressTime()
     return lastPressTime;
 }
 
-void PostponerExtended_ConsumePendingKeypresses(int count, bool suppress)
+void PostponerExtended_ConsumePendingKeypresses(int count)
 {
     for (int i = 0; i < count; i++) {
-        consumeOneKeypress(suppress);
+        consumeOneKeypress();
     }
 }
 
diff --git a/right/src/postponer.h b/right/src/postponer.h
index b2816533c..3e6a77223 100644
--- a/right/src/postponer.h
+++ b/right/src/postponer.h
@@ -84,18 +84,19 @@
 // Functions (Basic Query APIs):
 
     uint8_t PostponerQuery_PendingKeypressCount();
-    bool PostponerQuery_IsKeyReleased(key_state_t* key);
+    bool PostponerQuery_IsKeyReleased(const key_state_t* key);
     bool PostponerQuery_IsActiveEventually(key_state_t* key);
     void PostponerQuery_InfoByKeystate(key_state_t* key, postponer_buffer_record_type_t** press, postponer_buffer_record_type_t** release);
     bool PostponerQuery_ContainsKeyId(uint8_t keyid);
     void PostponerQuery_FindFirstPressed(const postponer_buffer_record_type_t** press, const key_state_t* opposingKey);
     void PostponerQuery_FindFirstReleased(const postponer_buffer_record_type_t** release, const key_state_t* opposingKey);
+    uint8_t PostponerQuery_GetPendingKeypresses(uint8_t pendingKeyIds[], uint8_t maxCount, uint32_t cutoffTime);   
 
 // Functions (Query APIs extended):
     uint16_t PostponerExtended_PendingId(uint16_t idx);
     uint32_t PostponerExtended_LastPressTime(void);
     bool PostponerExtended_IsPendingKeyReleased(uint8_t idx);
-    void PostponerExtended_ConsumePendingKeypresses(int count, bool suppress);
+    void PostponerExtended_ConsumePendingKeypresses(int count);
     void PostponerExtended_ResetPostponer(void);
 
     void PostponerExtended_PrintContent();
diff --git a/right/src/str_utils.c b/right/src/str_utils.c
index 7928fcda1..101356473 100644
--- a/right/src/str_utils.c
+++ b/right/src/str_utils.c
@@ -157,6 +157,14 @@ static void consumeWhite(parser_context_t* ctx)
     }
 }
 
+bool TryConsumeDot(parser_context_t* ctx)
+{
+    if (*ctx->at == '.') {
+        ++ctx->at;
+        return true;
+    }
+    return false;
+}
 
 void ConsumeCommentsAsWhite(bool consume)
 {
diff --git a/right/src/str_utils.h b/right/src/str_utils.h
index 0341d18da..9f12fcefa 100644
--- a/right/src/str_utils.h
+++ b/right/src/str_utils.h
@@ -84,6 +84,7 @@
     const char* CmdEnd(const char* cmd, const char *cmdEnd);
     void ConsumeUntilDot(parser_context_t* ctx);
     void ConsumeWhiteAt(parser_context_t* ctx, const char* at);
+    bool TryConsumeDot(parser_context_t* ctx);
     const char* SkipWhite(const char* cmd, const char *cmdEnd);
     uint8_t CountCommands(const char* text, uint16_t textLen);
     const char* TokEnd(const char* cmd, const char *cmdEnd);
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 62d964db9..7d94058e0 100644
--- a/right/src/usb_commands/usb_command_exec_macro_command.c
+++ b/right/src/usb_commands/usb_command_exec_macro_command.c
@@ -42,7 +42,7 @@ static bool canExecute()
 
 void UsbMacroCommand_ExecuteSynchronously()
 {
-    Macros_StartMacro(MacroIndex_InlineMacro, &dummyState, 0, 255, MacroIndex_None, false, UsbMacroCommand);
+    Macros_StartMacro(MacroIndex_InlineMacro, &dummyState, 0, 255, false, UsbMacroCommand);
     EventVector_Unset(EventVector_UsbMacroCommandWaitingForExecution);
 }
 
diff --git a/right/src/usb_report_updater.c b/right/src/usb_report_updater.c
index 8671ff637..2960c252e 100644
--- a/right/src/usb_report_updater.c
+++ b/right/src/usb_report_updater.c
@@ -1,6 +1,7 @@
 #include <math.h>
 #include <errno.h>
 #include "atomicity.h"
+#include "chords.h"
 #include "event_scheduler.h"
 #include "host_connection.h"
 #include "key_action.h"
@@ -367,13 +368,13 @@ static void applyKeystrokePrimary(key_state_t *keyState, key_action_cached_t *ca
     }
 }
 
-static void applyKeystrokeSecondary(key_state_t *keyState, key_action_t *action, key_action_t *actionBase, usb_keyboard_reports_t* reports)
+static void applyKeystrokeSecondary(key_state_t *keyState, key_action_cached_t *cachedAction, usb_keyboard_reports_t* reports)
 {
-    secondary_role_t secondaryRole = action->keystroke.secondaryRole;
+    secondary_role_t secondaryRole = cachedAction->action.keystroke.secondaryRole;
     if ( IS_SECONDARY_ROLE_LAYER_SWITCHER(secondaryRole) ) {
         // If the cached action is the current base role, then hold, otherwise keymap was changed. In that case do nothing just
         // as a well behaved hold action should.
-        if(KeyState_Active(keyState) && action->type == actionBase->type && action->keystroke.secondaryRole == actionBase->keystroke.secondaryRole) {
+        if(KeyState_Active(keyState)) {
             LayerSwitcher_HoldLayer(SECONDARY_ROLE_LAYER_TO_LAYER_ID(secondaryRole), false);
         }
         if (KeyState_ActivatedNow(keyState) || KeyState_DeactivatedNow(keyState)) {
@@ -387,7 +388,7 @@ static void applyKeystrokeSecondary(key_state_t *keyState, key_action_t *action,
     }
 }
 
-static void applyKeystroke(key_state_t *keyState, key_action_cached_t *cachedAction, key_action_t *actionBase, usb_keyboard_reports_t* reports)
+static void applyKeystroke(key_state_t *keyState, key_action_cached_t *cachedAction, usb_keyboard_reports_t* reports)
 {
     key_action_t* action = &cachedAction->action;
     if (action->keystroke.secondaryRole) {
@@ -397,7 +398,7 @@ static void applyKeystroke(key_state_t *keyState, key_action_cached_t *cachedAct
                 applyKeystrokePrimary(keyState, cachedAction, reports);
                 return;
             case SecondaryRoleState_Secondary:
-                applyKeystrokeSecondary(keyState, action, actionBase, reports);
+                applyKeystrokeSecondary(keyState, cachedAction, reports);
                 return;
             case SecondaryRoleState_DontKnowYet:
                 // Repeatedly trigger to keep Postponer in postponing mode until the driver decides.
@@ -495,7 +496,7 @@ static void applyOtherAction(other_action_t actionSubtype)
     }
 }
 
-void ApplyKeyAction(key_state_t *keyState, key_action_cached_t *cachedAction, key_action_t *actionBase, usb_keyboard_reports_t* reports)
+void ApplyKeyAction(key_state_t *keyState, key_action_cached_t *cachedAction, usb_keyboard_reports_t* reports)
 {
     key_action_t* action = &cachedAction->action;
 
@@ -503,7 +504,7 @@ void ApplyKeyAction(key_state_t *keyState, key_action_cached_t *cachedAction, ke
         case KeyActionType_Keystroke:
             if (KeyState_NonZero(keyState)) {
                 EventVector_Set(EventVector_NativeActionReportsUsed);
-                applyKeystroke(keyState, cachedAction, actionBase, reports);
+                applyKeystroke(keyState, cachedAction, reports);
             }
             break;
         case KeyActionType_Mouse:
@@ -534,7 +535,7 @@ void ApplyKeyAction(key_state_t *keyState, key_action_cached_t *cachedAction, ke
         case KeyActionType_PlayMacro:
             if (KeyState_ActivatedNow(keyState)) {
                 StickyMods_ResetLater(cachedAction);
-                Macros_StartMacro(action->playMacro.macroId, keyState, action->playMacro.offset, keyState->activationId, 255, true, NULL);
+                Macros_StartMacro(action->playMacro.macroId, keyState, action->playMacro.offset, keyState->activationId, true, NULL);
             }
             break;
         case KeyActionType_InlineMacro:
@@ -644,6 +645,7 @@ static void commitKeyState(key_state_t *keyState, bool active, uint8_t pressTime
         DEBUG_KEY_LIFE(applied);
         KEY_TIMING(KeyTiming_RecordKeystroke(keyState, active, Timer_GetCurrentTime(), Timer_GetCurrentTime()));
         keyState->current = active;
+        EventVector_Set(EventVector_NativeActionsPostponing);
     }
     Macros_WakeBecauseOfKeystateChange();
 }
@@ -742,14 +744,24 @@ static void updateActionStates() {
     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];
-            key_action_cached_t *cachedAction;
-            key_action_t *actionBase;
 
             if(KEYSTATE_KEYINACTIVE(keyState)) {
                 continue;
             }
-
+             
             preprocessKeyState(keyState, false);
+        }
+    }
+
+    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];
+            key_action_cached_t *cachedAction;
+            const chord_def_t *activatedChord = NULL;
+
+            if(KEYSTATE_KEYINACTIVE(keyState)) {
+                continue;
+            }
 
             if (KeyState_NonZero(keyState)) {
                 Trace_Printc("w2");
@@ -758,7 +770,20 @@ static void updateActionStates() {
                     DEBUG_KEY_LIFE(action);
                 }
 
-                if (KeyState_ActivatedNow(keyState)) {
+                // Here we handle the chords
+                uint8_t layerInEffect = Postponer_LastKeyLayer != 255 && PostponerCore_IsActive()
+                    ? Postponer_LastKeyLayer : ActiveLayer;
+                chord_resolution_t chordRes = CurrentKeymap[layerInEffect][slotId][keyId].isPartOfChord
+                    ? Chords_Driver(keyState, layerInEffect, &activatedChord) : ChordResolution_Failed;
+                if (chordRes == ChordResolution_Resolved) {
+                    actionCache[slotId][keyId].action = activatedChord->action;
+                    KeyHistory_RecordChordPress(keyState, activatedChord);
+                }
+                else if (chordRes == ChordResolution_Wait) {
+                    actionCache[slotId][keyId].action = (key_action_t){.type = KeyActionType_None};
+                    EventVector_Set(EventVector_NativeActionsPostponing);
+                }
+                else if (chordRes == ChordResolution_Failed && KeyState_ActivatedNow(keyState)) {
                     // cache action so that key's meaning remains the same as long
                     // as it is pressed
                     actionCache[slotId][keyId].modifierLayerMask = 0;
@@ -790,17 +815,24 @@ static void updateActionStates() {
                 }
 
                 cachedAction = &actionCache[slotId][keyId];
-                actionBase = &CurrentKeymap[LayerId_Base][slotId][keyId].action;
 
                 Trace_Printc("w3");
-                //apply base-layer holds
-                applyLayerHolds(keyState, actionBase);
+                // apply base-layer holds, but only if the key is not currenty applying another action
+                // Also, don't apply layers from keys currently undergoing chord evaluation
+                if (chordRes != ChordResolution_Wait && cachedAction->action.type == KeyActionType_None) {
+                    applyLayerHolds(keyState, &CurrentKeymap[LayerId_Base][slotId][keyId].action);
+                }
                 Trace_Printc("w4");
 
                 //apply active-layer action
-                ApplyKeyAction(keyState, cachedAction, actionBase, &NativeKeyboardReports);
+                ApplyKeyAction(keyState, cachedAction, &NativeKeyboardReports);
 
                 if (KeyState_DeactivatedNow(keyState)) {
+                    // I kind of want to only trigger chord releases for chord-holding keys.
+                    // It's safe as it is, but it is not exactly free if there are chords.
+                    // Maybe grab a bit in the keyState for isHoldingChord?
+                    // I could also get rid of the need to do this by storing activationIds for the holding keys, costing memory per chord.
+                    Chords_KeyReleased(keyState);
                     KeyHistory_RecordRelease(keyState);
                     keyState->secondaryState = SecondaryRoleState_DontKnowYet;
                 }
diff --git a/right/src/usb_report_updater.h b/right/src/usb_report_updater.h
index 4cd2193f6..498e330f3 100644
--- a/right/src/usb_report_updater.h
+++ b/right/src/usb_report_updater.h
@@ -59,7 +59,7 @@
     void ToggleMouseState(serialized_mouse_action_t action, bool activate);
     void ActivateKey(key_state_t *keyState, bool debounce);
     void ActivateStickyMods(key_state_t *keyState, uint8_t mods);
-    void ApplyKeyAction(key_state_t *keyState, key_action_cached_t *cachedAction, key_action_t *actionBase, usb_keyboard_reports_t* reports);
+    void ApplyKeyAction(key_state_t *keyState, key_action_cached_t *cachedAction, usb_keyboard_reports_t* reports);
     void StickyMods_ResetLater(key_action_cached_t *cachedAction);
 
     void UsbReportUpdater_ResetKeyboardReports(usb_keyboard_reports_t* reports);
diff --git a/right/src/utils.c b/right/src/utils.c
index f0ab5e9ee..b38ad0410 100644
--- a/right/src/utils.c
+++ b/right/src/utils.c
@@ -25,24 +25,18 @@
 #if !DEVICE_IS_UHK_DONGLE
 //this is noop at the moment, prepared for time when MAX_KEY_COUNT_PER_MODULE changes
 //the purpose is to preserve current keyids
-static uint16_t recodeId(uint16_t newFormat, uint16_t fromBase, uint16_t toBase)
-{
-    return toBase * (newFormat / fromBase) + (newFormat % fromBase);
-}
+#define RECODE_ID(id, oldBase, newBase) (newBase * (id / oldBase) + id % oldBase)
 #endif
 
-uint16_t Utils_KeyStateToKeyId(key_state_t* key)
+uint16_t Utils_KeyStateToKeyId(const key_state_t* key)
 {
 #if DEVICE_IS_UHK_DONGLE
     return 0;
 #else
     if (key == NULL) {
-        return 0;
+        return 255;
     }
-    uint32_t ptr1 = (uint32_t)(key_state_t*)key;
-    uint32_t ptr2 = (uint32_t)(key_state_t*)&(KeyStates[0][0]);
-    uint32_t res = (ptr1 - ptr2) / sizeof(key_state_t);
-    return recodeId(res, MAX_KEY_COUNT_PER_MODULE, 64);
+    return RECODE_ID((uint16_t)(key - (key_state_t*)KeyStates), MAX_KEY_COUNT_PER_MODULE, 64);
 #endif
 }
 
@@ -51,7 +45,7 @@ key_state_t* Utils_KeyIdToKeyState(uint16_t keyid)
 #if DEVICE_IS_UHK_DONGLE
     return NULL;
 #else
-    return &(((key_state_t*)KeyStates)[recodeId(keyid, 64, MAX_KEY_COUNT_PER_MODULE)]);
+    return &(((key_state_t*)KeyStates)[RECODE_ID(keyid, 64, MAX_KEY_COUNT_PER_MODULE)]);
 #endif
 }
 
diff --git a/right/src/utils.h b/right/src/utils.h
index ab0b69634..5e87fc9c6 100644
--- a/right/src/utils.h
+++ b/right/src/utils.h
@@ -34,7 +34,7 @@ if (reentrancyGuard_active) {                    \
 
     uint8_t 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);
+    uint16_t Utils_KeyStateToKeyId(const key_state_t* key);
     const char* Utils_KeyStateToKeyAbbreviation(key_state_t* key);
     void Utils_DecodeId(uint16_t keyid, uint8_t* outSlotId, uint8_t* outSlotIdx);
     const char* Utils_GetUsbReportString(const hid_keyboard_report_t* report);