feat(keymap): Add binding get/set, layer movement

* Add keymap API for getting/setting a bindings
  in keymap layers.
* Add layer move support via intemediary ordering array.
* Add settings storage for keymap changes.

6 files changed, 1192 insertions, 50 deletions

diff --git a/app/src/keymap.c b/app/src/keymap.c
index 94bd12048c..7afd951c03 100644
--- a/app/src/keymap.c
+++ b/app/src/keymap.c
@@ -6,10 +6,12 @@
 
 #include <drivers/behavior.h>
 #include <zephyr/sys/util.h>
+#include <zephyr/settings/settings.h>
 #include <zephyr/bluetooth/bluetooth.h>
 #include <zephyr/logging/log.h>
 LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 
+#include <zmk/stdlib.h>
 #include <zmk/behavior.h>
 #include <zmk/keymap.h>
 #include <zmk/matrix.h>
@@ -27,7 +29,7 @@ LOG_MODULE_DECLARE(zmk, CONFIG_ZMK_LOG_LEVEL);
 #include <zmk/events/sensor_event.h>
 
 static zmk_keymap_layers_state_t _zmk_keymap_layer_state = 0;
-static uint8_t _zmk_keymap_layer_default = 0;
+static zmk_keymap_layer_id_t _zmk_keymap_layer_default = 0;
 
 #define DT_DRV_COMPAT zmk_keymap
 
@@ -38,7 +40,11 @@ static uint8_t _zmk_keymap_layer_default = 0;
 #endif
 
 #define TRANSFORMED_LAYER(node)                                                                    \
-    { LISTIFY(DT_PROP_LEN(node, bindings), ZMK_KEYMAP_EXTRACT_BINDING, (, ), node) }
+    {                                                                                              \
+        COND_CODE_1(                                                                               \
+            DT_NODE_HAS_PROP(node, bindings),                                                      \
+            (LISTIFY(DT_PROP_LEN(node, bindings), ZMK_KEYMAP_EXTRACT_BINDING, (, ), node)), ())    \
+    }
 
 #if ZMK_KEYMAP_HAS_SENSORS
 #define _TRANSFORM_SENSOR_ENTRY(idx, layer)                                                        \
@@ -58,7 +64,7 @@ static uint8_t _zmk_keymap_layer_default = 0;
 
 #endif /* ZMK_KEYMAP_HAS_SENSORS */
 
-#define LAYER_NAME(node) DT_PROP_OR(node, display_name, DT_PROP_OR(node, label, NULL))
+#define LAYER_NAME(node) DT_PROP_OR(node, display_name, DT_PROP_OR(node, label, ""))
 
 // State
 
@@ -67,12 +73,36 @@ static uint8_t _zmk_keymap_layer_default = 0;
 // still send the release event to the behavior in that layer also.
 static uint32_t zmk_keymap_active_behavior_layer[ZMK_KEYMAP_LEN];
 
-static struct zmk_behavior_binding zmk_keymap[ZMK_KEYMAP_LAYERS_LEN][ZMK_KEYMAP_LEN] = {
-    DT_INST_FOREACH_CHILD_SEP(0, TRANSFORMED_LAYER, (, ))};
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+
+static uint8_t keymap_layer_orders[ZMK_KEYMAP_LAYERS_LEN];
+
+#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+
+#define KEYMAP_VAR(_name, _opts)                                                                   \
+    static _opts struct zmk_behavior_binding _name[ZMK_KEYMAP_LAYERS_LEN][ZMK_KEYMAP_LEN] = {      \
+        COND_CODE_1(IS_ENABLED(CONFIG_ZMK_STUDIO),                                                 \
+                    (DT_INST_FOREACH_CHILD_SEP(0, TRANSFORMED_LAYER, (, ))),                       \
+                    (DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP(0, TRANSFORMED_LAYER, (, ))))};
+
+KEYMAP_VAR(zmk_keymap, )
+
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
+
+KEYMAP_VAR(zmk_stock_keymap, const)
+
+static char zmk_keymap_layer_names[ZMK_KEYMAP_LAYERS_LEN][CONFIG_ZMK_KEYMAP_LAYER_NAME_MAX_LEN] = {
+    DT_INST_FOREACH_CHILD_SEP(0, LAYER_NAME, (, ))};
+
+static uint32_t changed_layer_names = 0;
+
+#else
 
 static const char *zmk_keymap_layer_names[ZMK_KEYMAP_LAYERS_LEN] = {
     DT_INST_FOREACH_CHILD_SEP(0, LAYER_NAME, (, ))};
 
+#endif
+
 #if ZMK_KEYMAP_HAS_SENSORS
 
 static struct zmk_behavior_binding
@@ -81,23 +111,50 @@ static struct zmk_behavior_binding
 
 #endif /* ZMK_KEYMAP_HAS_SENSORS */
 
-static inline int set_layer_state(uint8_t layer, bool state) {
+#define ASSERT_LAYER_VAL(_layer, _fail_ret)                                                        \
+    if ((_layer) >= ZMK_KEYMAP_LAYERS_LEN) {                                                       \
+        return (_fail_ret);                                                                        \
+    }
+
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+
+uint8_t map_layer_id_to_index(zmk_keymap_layer_id_t layer_id) {
+    for (uint8_t i = 0; i < ZMK_KEYMAP_LAYERS_LEN; i++) {
+        if (keymap_layer_orders[i] == layer_id) {
+            return i;
+        }
+    }
+
+    return ZMK_KEYMAP_LAYER_ID_INVAL;
+}
+
+#define LAYER_INDEX_TO_ID(_layer) keymap_layer_orders[_layer]
+#define LAYER_ID_TO_INDEX(_layer) map_layer_id_to_index(_layer)
+
+#else
+
+#define LAYER_INDEX_TO_ID(_layer) _layer
+#define LAYER_ID_TO_INDEX(_layer) _layer
+
+#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+
+static inline int set_layer_state(zmk_keymap_layer_id_t layer_id, bool state) {
     int ret = 0;
-    if (layer >= ZMK_KEYMAP_LAYERS_LEN) {
+    if (layer_id >= ZMK_KEYMAP_LAYERS_LEN) {
         return -EINVAL;
     }
 
     // Default layer should *always* remain active
-    if (layer == _zmk_keymap_layer_default && !state) {
+    if (layer_id == _zmk_keymap_layer_default && !state) {
         return 0;
     }
 
     zmk_keymap_layers_state_t old_state = _zmk_keymap_layer_state;
-    WRITE_BIT(_zmk_keymap_layer_state, layer, state);
+    WRITE_BIT(_zmk_keymap_layer_state, layer_id, state);
     // Don't send state changes unless there was an actual change
     if (old_state != _zmk_keymap_layer_state) {
-        LOG_DBG("layer_changed: layer %d state %d", layer, state);
-        ret = raise_layer_state_changed(layer, state);
+        LOG_DBG("layer_changed: layer %d state %d", layer_id, state);
+        ret = raise_layer_state_changed(layer_id, state);
         if (ret < 0) {
             LOG_WRN("Failed to raise layer state changed (%d)", ret);
         }
@@ -106,21 +163,28 @@ static inline int set_layer_state(uint8_t layer, bool state) {
     return ret;
 }
 
-uint8_t zmk_keymap_layer_default(void) { return _zmk_keymap_layer_default; }
+zmk_keymap_layer_id_t zmk_keymap_layer_index_to_id(zmk_keymap_layer_index_t layer_index) {
+    ASSERT_LAYER_VAL(layer_index, UINT8_MAX);
+
+    return LAYER_INDEX_TO_ID(layer_index);
+}
+
+zmk_keymap_layer_id_t zmk_keymap_layer_default(void) { return _zmk_keymap_layer_default; }
 
 zmk_keymap_layers_state_t zmk_keymap_layer_state(void) { return _zmk_keymap_layer_state; }
 
-bool zmk_keymap_layer_active_with_state(uint8_t layer, zmk_keymap_layers_state_t state_to_test) {
+bool zmk_keymap_layer_active_with_state(zmk_keymap_layer_id_t layer,
+                                        zmk_keymap_layers_state_t state_to_test) {
     // The default layer is assumed to be ALWAYS ACTIVE so we include an || here to ensure nobody
     // breaks up that assumption by accident
     return (state_to_test & (BIT(layer))) == (BIT(layer)) || layer == _zmk_keymap_layer_default;
 };
 
-bool zmk_keymap_layer_active(uint8_t layer) {
+bool zmk_keymap_layer_active(zmk_keymap_layer_id_t layer) {
     return zmk_keymap_layer_active_with_state(layer, _zmk_keymap_layer_state);
 };
 
-uint8_t zmk_keymap_highest_layer_active(void) {
+zmk_keymap_layer_id_t zmk_keymap_highest_layer_active(void) {
     for (uint8_t layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer > 0; layer--) {
         if (zmk_keymap_layer_active(layer)) {
             return layer;
@@ -129,11 +193,13 @@ uint8_t zmk_keymap_highest_layer_active(void) {
     return zmk_keymap_layer_default();
 }
 
-int zmk_keymap_layer_activate(uint8_t layer) { return set_layer_state(layer, true); };
+int zmk_keymap_layer_activate(zmk_keymap_layer_id_t layer) { return set_layer_state(layer, true); };
 
-int zmk_keymap_layer_deactivate(uint8_t layer) { return set_layer_state(layer, false); };
+int zmk_keymap_layer_deactivate(zmk_keymap_layer_id_t layer) {
+    return set_layer_state(layer, false);
+};
 
-int zmk_keymap_layer_toggle(uint8_t layer) {
+int zmk_keymap_layer_toggle(zmk_keymap_layer_id_t layer) {
     if (zmk_keymap_layer_active(layer)) {
         return zmk_keymap_layer_deactivate(layer);
     }
@@ -141,7 +207,7 @@ int zmk_keymap_layer_toggle(uint8_t layer) {
     return zmk_keymap_layer_activate(layer);
 };
 
-int zmk_keymap_layer_to(uint8_t layer) {
+int zmk_keymap_layer_to(zmk_keymap_layer_id_t layer) {
     for (int i = ZMK_KEYMAP_LAYERS_LEN - 1; i >= 0; i--) {
         zmk_keymap_layer_deactivate(i);
     }
@@ -151,18 +217,365 @@ int zmk_keymap_layer_to(uint8_t layer) {
     return 0;
 }
 
-bool is_active_layer(uint8_t layer, zmk_keymap_layers_state_t layer_state) {
-    return (layer_state & BIT(layer)) == BIT(layer) || layer == _zmk_keymap_layer_default;
+const char *zmk_keymap_layer_name(zmk_keymap_layer_id_t layer_id) {
+    ASSERT_LAYER_VAL(layer_id, NULL)
+
+    return zmk_keymap_layer_names[layer_id];
 }
 
-const char *zmk_keymap_layer_name(uint8_t layer) {
-    if (layer >= ZMK_KEYMAP_LAYERS_LEN) {
+const struct zmk_behavior_binding *
+zmk_keymap_get_layer_binding_at_idx(zmk_keymap_layer_id_t layer_id, uint8_t binding_idx) {
+    if (binding_idx >= ZMK_KEYMAP_LEN) {
         return NULL;
     }
 
-    return zmk_keymap_layer_names[layer];
+    ASSERT_LAYER_VAL(layer_id, NULL)
+
+    return &zmk_keymap[layer_id][binding_idx];
+}
+
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
+
+#define PENDING_ARRAY_SIZE DIV_ROUND_UP(ZMK_KEYMAP_LEN, 8)
+
+static uint8_t zmk_keymap_layer_pending_changes[ZMK_KEYMAP_LAYERS_LEN][PENDING_ARRAY_SIZE];
+
+#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
+
+int zmk_keymap_set_layer_binding_at_idx(zmk_keymap_layer_id_t layer_id, uint8_t binding_idx,
+                                        struct zmk_behavior_binding binding) {
+    if (binding_idx >= ZMK_KEYMAP_LEN) {
+        return -EINVAL;
+    }
+
+    ASSERT_LAYER_VAL(layer_id, -EINVAL)
+
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
+    uint8_t *pending = zmk_keymap_layer_pending_changes[layer_id];
+
+    WRITE_BIT(pending[binding_idx / 8], binding_idx % 8, 1);
+#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
+
+    // TODO: Need a mutex to protect access to the keymap data?
+    memcpy(&zmk_keymap[layer_id][binding_idx], &binding, sizeof(binding));
+
+    return 0;
 }
 
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
+
+static uint8_t settings_layer_orders[ZMK_KEYMAP_LAYERS_LEN];
+
+#endif
+
+int zmk_keymap_move_layer(zmk_keymap_layer_index_t start_idx, zmk_keymap_layer_index_t dest_idx) {
+    ASSERT_LAYER_VAL(start_idx, -EINVAL)
+    ASSERT_LAYER_VAL(dest_idx, -EINVAL)
+
+    if (start_idx == dest_idx) {
+        return 0;
+    } else if (dest_idx > start_idx) {
+        uint8_t val = keymap_layer_orders[start_idx];
+
+        for (int i = start_idx; i < dest_idx; i++) {
+            keymap_layer_orders[i] = keymap_layer_orders[i + 1];
+        }
+
+        keymap_layer_orders[dest_idx] = val;
+    } else {
+        uint8_t val = keymap_layer_orders[start_idx];
+
+        for (int i = start_idx; i > dest_idx; i--) {
+            keymap_layer_orders[i] = keymap_layer_orders[i - 1];
+        }
+
+        keymap_layer_orders[dest_idx] = val;
+    }
+
+    return 0;
+}
+
+int zmk_keymap_add_layer(void) {
+    uint32_t seen_layer_ids = 0;
+    LOG_HEXDUMP_DBG(keymap_layer_orders, ZMK_KEYMAP_LAYERS_LEN, "Order");
+
+    for (int index = 0; index < ZMK_KEYMAP_LAYERS_LEN; index++) {
+        zmk_keymap_layer_id_t id = LAYER_INDEX_TO_ID(index);
+
+        if (id != ZMK_KEYMAP_LAYER_ID_INVAL) {
+            WRITE_BIT(seen_layer_ids, id, 1);
+            continue;
+        }
+
+        for (int candidate_id = 0; candidate_id < ZMK_KEYMAP_LAYERS_LEN; candidate_id++) {
+            if (!(seen_layer_ids & BIT(candidate_id))) {
+                keymap_layer_orders[index] = candidate_id;
+                return index;
+            }
+        }
+    }
+
+    return -ENOSPC;
+}
+
+int zmk_keymap_remove_layer(zmk_keymap_layer_index_t index) {
+    ASSERT_LAYER_VAL(index, -EINVAL);
+
+    if (keymap_layer_orders[index] == ZMK_KEYMAP_LAYER_ID_INVAL) {
+        return -EINVAL;
+    }
+
+    LOG_DBG("Removing layer index %d which is ID %d", index, keymap_layer_orders[index]);
+    LOG_HEXDUMP_DBG(keymap_layer_orders, ZMK_KEYMAP_LAYERS_LEN, "Order");
+
+    while (index < ZMK_KEYMAP_LAYERS_LEN - 1) {
+        keymap_layer_orders[index] = keymap_layer_orders[index + 1];
+        index++;
+    }
+
+    keymap_layer_orders[ZMK_KEYMAP_LAYERS_LEN - 1] = ZMK_KEYMAP_LAYER_ID_INVAL;
+
+    LOG_HEXDUMP_DBG(keymap_layer_orders, ZMK_KEYMAP_LAYERS_LEN, "Order");
+
+    return 0;
+}
+
+int zmk_keymap_restore_layer(zmk_keymap_layer_id_t id, zmk_keymap_layer_index_t at_index) {
+    ASSERT_LAYER_VAL(at_index, -EINVAL);
+    ASSERT_LAYER_VAL(id, -ENODEV);
+
+    for (zmk_keymap_layer_index_t index = ZMK_KEYMAP_LAYERS_LEN - 1; index > at_index; index--) {
+        keymap_layer_orders[index] = keymap_layer_orders[index - 1];
+    }
+
+    keymap_layer_orders[at_index] = id;
+
+    return 0;
+}
+
+int zmk_keymap_set_layer_name(zmk_keymap_layer_id_t id, const char *name, size_t size) {
+    ASSERT_LAYER_VAL(id, -EINVAL);
+
+    if (size >= CONFIG_ZMK_KEYMAP_LAYER_NAME_MAX_LEN) {
+        return -ENOSPC;
+    }
+
+    strlcpy(zmk_keymap_layer_names[id], name, CONFIG_ZMK_KEYMAP_LAYER_NAME_MAX_LEN);
+
+    // Ensure we properly null terminate our name if we previously had a longer one.
+    if (size < CONFIG_ZMK_KEYMAP_LAYER_NAME_MAX_LEN - 1) {
+        zmk_keymap_layer_names[id][size] = 0;
+    }
+
+    WRITE_BIT(changed_layer_names, id, 1);
+
+    return 0;
+}
+
+#else
+
+int zmk_keymap_move_layer(zmk_keymap_layer_index_t layer, zmk_keymap_layer_index_t dest) {
+    return -ENOTSUP;
+}
+
+int zmk_keymap_add_layer(void) { return -ENOTSUP; }
+
+int zmk_keymap_remove_layer(zmk_keymap_layer_index_t index) { return -ENOTSUP; }
+
+int zmk_keymap_restore_layer(zmk_keymap_layer_id_t id, zmk_keymap_layer_index_t at_index) {
+    return -ENOTSUP;
+}
+
+int zmk_keymap_set_layer_name(zmk_keymap_layer_id_t id, const char *name, size_t size) {
+    return -ENOTSUP;
+}
+
+#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
+
+#define PENDING_ARRAY_SIZE DIV_ROUND_UP(ZMK_KEYMAP_LEN, 8)
+
+static uint8_t zmk_keymap_layer_pending_changes[ZMK_KEYMAP_LAYERS_LEN][PENDING_ARRAY_SIZE];
+
+struct zmk_behavior_binding_setting {
+    zmk_behavior_local_id_t behavior_local_id;
+    uint32_t param1;
+    uint32_t param2;
+} __packed;
+
+int zmk_keymap_check_unsaved_changes(void) {
+    for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
+        uint8_t *pending = zmk_keymap_layer_pending_changes[l];
+        for (int kp = 0; kp < ZMK_KEYMAP_LEN; kp++) {
+            if (pending[kp / 8] & BIT(kp % 8)) {
+                return 1;
+            }
+        }
+
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+        if (settings_layer_orders[l] != keymap_layer_orders[l]) {
+            return 1;
+        }
+#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+    }
+
+    return 0;
+}
+
+#define LAYER_ORDER_SETTINGS_KEY "keymap/layer_order"
+#define LAYER_NAME_SETTINGS_KEY "keymap/l_n/%d"
+#define LAYER_BINDING_SETTINGS_KEY "keymap/l/%d/%d"
+
+static void save_bindings(void) {
+    for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
+        uint8_t *pending = zmk_keymap_layer_pending_changes[l];
+
+        for (int kp = 0; kp < ZMK_KEYMAP_LEN; kp++) {
+            if (pending[kp / 8] & BIT(kp % 8)) {
+                LOG_DBG("Pending save for layer %d at key position %d", l, kp);
+
+                struct zmk_behavior_binding *binding = &zmk_keymap[l][kp];
+                struct zmk_behavior_binding_setting binding_setting = {
+                    .behavior_local_id = zmk_behavior_get_local_id(binding->behavior_dev),
+                    .param1 = binding->param1,
+                    .param2 = binding->param2,
+                };
+
+                // We can skip any trailing zero params, regardless of the behavior
+                // and if those params are meaningful.
+                size_t len = sizeof(binding_setting);
+                if (binding_setting.param2 == 0) {
+                    len -= 4;
+
+                    if (binding_setting.param1 == 0) {
+                        len -= 4;
+                    }
+                }
+
+                char setting_name[20];
+                sprintf(setting_name, LAYER_BINDING_SETTINGS_KEY, l, kp);
+
+                settings_save_one(setting_name, &binding_setting, len);
+            }
+        }
+
+        *pending = 0;
+    }
+}
+
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+static void save_layer_orders(void) {
+    settings_save_one(LAYER_ORDER_SETTINGS_KEY, keymap_layer_orders,
+                      ARRAY_SIZE(keymap_layer_orders));
+    memcpy(settings_layer_orders, keymap_layer_orders, ARRAY_SIZE(keymap_layer_orders));
+}
+#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+
+static void save_layer_names(void) {
+    for (int id = 0; id < ZMK_KEYMAP_LAYERS_LEN; id++) {
+        if (changed_layer_names & BIT(id)) {
+            char setting_name[14];
+            sprintf(setting_name, LAYER_NAME_SETTINGS_KEY, id);
+            settings_save_one(setting_name, zmk_keymap_layer_names[id],
+                              strlen(zmk_keymap_layer_names[id]));
+        }
+    }
+
+    changed_layer_names = 0;
+}
+
+int zmk_keymap_save_changes(void) {
+    save_bindings();
+
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+    save_layer_orders();
+#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+
+    save_layer_names();
+
+    return 0;
+}
+
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+
+#define KEYMAP_LAYER_ORDER_INIT(n)                                                                 \
+    keymap_layer_orders[i] = i;                                                                    \
+    settings_layer_orders[i] = i;                                                                  \
+    i++;
+
+static void load_stock_keymap_layer_ordering() {
+    int i = 0;
+    DT_INST_FOREACH_CHILD_STATUS_OKAY(0, KEYMAP_LAYER_ORDER_INIT)
+    while (i < ZMK_KEYMAP_LAYERS_LEN) {
+        keymap_layer_orders[i] = ZMK_KEYMAP_LAYER_ID_INVAL;
+        i++;
+    }
+}
+#endif
+
+static void reload_from_stock_keymap(void) {
+    for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
+        for (int k = 0; k < ZMK_KEYMAP_LEN; k++) {
+            zmk_keymap[l][k] = zmk_stock_keymap[l][k];
+        }
+    }
+}
+
+int zmk_keymap_discard_changes(void) {
+    load_stock_keymap_layer_ordering();
+    reload_from_stock_keymap();
+
+    int ret = settings_load_subtree("keymap");
+    if (ret >= 0) {
+        changed_layer_names = 0;
+
+        for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
+            memset(zmk_keymap_layer_pending_changes[l], 0, PENDING_ARRAY_SIZE);
+        }
+    }
+
+    return ret;
+}
+
+int zmk_keymap_reset_settings(void) {
+    settings_delete(LAYER_ORDER_SETTINGS_KEY);
+    for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
+        char layer_name_setting_name[14];
+        sprintf(layer_name_setting_name, LAYER_NAME_SETTINGS_KEY, l);
+        settings_delete(layer_name_setting_name);
+
+        for (int k = 0; k < ZMK_KEYMAP_LEN; k++) {
+            if (memcmp(&zmk_keymap[l][k], &zmk_stock_keymap[l][k],
+                       sizeof(struct zmk_behavior_binding_setting)) == 0) {
+                continue;
+            }
+
+            char setting_name[20];
+            sprintf(setting_name, LAYER_BINDING_SETTINGS_KEY, l, k);
+            settings_delete(setting_name);
+        }
+    }
+
+    load_stock_keymap_layer_ordering();
+
+    reload_from_stock_keymap();
+
+    return 0;
+}
+
+#else
+
+int zmk_keymap_save_changes(void) { return -ENOTSUP; }
+
+int zmk_keymap_discard_changes(void) { return -ENOTSUP; }
+
+int zmk_keymap_reset_settings(void) { return -ENOTSUP; }
+
+#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
+
 int invoke_locally(struct zmk_behavior_binding *binding, struct zmk_behavior_binding_event event,
                    bool pressed) {
     if (pressed) {
@@ -172,24 +585,28 @@ int invoke_locally(struct zmk_behavior_binding *binding, struct zmk_behavior_bin
     }
 }
 
-int zmk_keymap_apply_position_state(uint8_t source, int layer, uint32_t position, bool pressed,
-                                    int64_t timestamp) {
+int zmk_keymap_apply_position_state(uint8_t source, zmk_keymap_layer_id_t layer_id,
+                                    uint32_t position, bool pressed, int64_t timestamp) {
     // We want to make a copy of this, since it may be converted from
     // relative to absolute before being invoked
-    struct zmk_behavior_binding binding = zmk_keymap[layer][position];
+
+    ASSERT_LAYER_VAL(layer_id, -EINVAL);
+
+    struct zmk_behavior_binding binding = zmk_keymap[layer_id][position];
     const struct device *behavior;
     struct zmk_behavior_binding_event event = {
-        .layer = layer,
+        .layer = layer_id,
         .position = position,
         .timestamp = timestamp,
     };
 
-    LOG_DBG("layer: %d position: %d, binding name: %s", layer, position, binding.behavior_dev);
+    LOG_DBG("layer_id: %d position: %d, binding name: %s", layer_id, position,
+            binding.behavior_dev);
 
     behavior = zmk_behavior_get_binding(binding.behavior_dev);
 
     if (!behavior) {
-        LOG_WRN("No behavior assigned to %d on layer %d", position, layer);
+        LOG_WRN("No behavior assigned to %d on layer %d", position, layer_id);
         return 1;
     }
 
@@ -236,9 +653,19 @@ int zmk_keymap_position_state_changed(uint8_t source, uint32_t position, bool pr
     if (pressed) {
         zmk_keymap_active_behavior_layer[position] = _zmk_keymap_layer_state;
     }
-    for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= _zmk_keymap_layer_default; layer--) {
-        if (zmk_keymap_layer_active_with_state(layer, zmk_keymap_active_behavior_layer[position])) {
-            int ret = zmk_keymap_apply_position_state(source, layer, position, pressed, timestamp);
+
+    // We use int here to be sure we don't loop layer_idx back to UINT8_MAX
+    for (int layer_idx = ZMK_KEYMAP_LAYERS_LEN - 1;
+         layer_idx >= LAYER_ID_TO_INDEX(_zmk_keymap_layer_default); layer_idx--) {
+        zmk_keymap_layer_id_t layer_id = LAYER_INDEX_TO_ID(layer_idx);
+
+        if (layer_id == ZMK_KEYMAP_LAYER_ID_INVAL) {
+            continue;
+        }
+        if (zmk_keymap_layer_active_with_state(layer_id,
+                                               zmk_keymap_active_behavior_layer[position])) {
+            int ret =
+                zmk_keymap_apply_position_state(source, layer_id, position, pressed, timestamp);
             if (ret > 0) {
                 LOG_DBG("behavior processing to continue to next layer");
                 continue;
@@ -260,20 +687,26 @@ int zmk_keymap_sensor_event(uint8_t sensor_index,
                             size_t channel_data_size, int64_t timestamp) {
     bool opaque_response = false;
 
-    for (int layer = ZMK_KEYMAP_LAYERS_LEN - 1; layer >= 0; layer--) {
-        struct zmk_behavior_binding *binding = &zmk_sensor_keymap[layer][sensor_index];
+    for (int layer_idx = ZMK_KEYMAP_LAYERS_LEN - 1; layer_idx >= 0; layer_idx--) {
+        uint8_t layer_id = LAYER_INDEX_TO_ID(layer_idx);
 
-        LOG_DBG("layer: %d sensor_index: %d, binding name: %s", layer, sensor_index,
-                binding->behavior_dev);
+        if (layer_id >= ZMK_KEYMAP_LAYERS_LEN) {
+            continue;
+        }
+
+        struct zmk_behavior_binding *binding = &zmk_sensor_keymap[layer_id][sensor_index];
+
+        LOG_DBG("layer idx: %d, layer id: %d sensor_index: %d, binding name: %s", layer_idx,
+                layer_id, sensor_index, binding->behavior_dev);
 
         const struct device *behavior = zmk_behavior_get_binding(binding->behavior_dev);
         if (!behavior) {
-            LOG_DBG("No behavior assigned to %d on layer %d", sensor_index, layer);
+            LOG_DBG("No behavior assigned to %d on layer %d", sensor_index, layer_id);
             continue;
         }
 
         struct zmk_behavior_binding_event event = {
-            .layer = layer,
+            .layer = layer_id,
             .position = ZMK_VIRTUAL_KEY_POSITION_SENSOR(sensor_index),
             .timestamp = timestamp,
         };
@@ -290,8 +723,8 @@ int zmk_keymap_sensor_event(uint8_t sensor_index,
         }
 
         enum behavior_sensor_binding_process_mode mode =
-            (!opaque_response && layer >= _zmk_keymap_layer_default &&
-             zmk_keymap_layer_active(layer))
+            (!opaque_response && layer_idx >= LAYER_ID_TO_INDEX(_zmk_keymap_layer_default) &&
+             zmk_keymap_layer_active(layer_id))
                 ? BEHAVIOR_SENSOR_BINDING_PROCESS_MODE_TRIGGER
                 : BEHAVIOR_SENSOR_BINDING_PROCESS_MODE_DISCARD;
 
@@ -335,3 +768,137 @@ ZMK_SUBSCRIPTION(keymap, zmk_position_state_changed);
 #if ZMK_KEYMAP_HAS_SENSORS
 ZMK_SUBSCRIPTION(keymap, zmk_sensor_event);
 #endif /* ZMK_KEYMAP_HAS_SENSORS */
+
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
+
+static int keymap_handle_set(const char *name, size_t len, settings_read_cb read_cb, void *cb_arg) {
+    const char *next;
+
+    LOG_DBG("Setting Keymap setting %s", name);
+
+    if (settings_name_steq(name, "l_n", &next) && next) {
+        char *endptr;
+        zmk_keymap_layer_id_t layer = strtoul(next, &endptr, 10);
+
+        if (*endptr != '\0') {
+            LOG_WRN("Invalid layer number: %s with endptr %s", next, endptr);
+            return -EINVAL;
+        }
+
+        if (layer >= ZMK_KEYMAP_LAYERS_LEN) {
+            LOG_WRN("Found layer name for invalid layer ID %d", layer);
+        }
+
+        int err = read_cb(cb_arg, zmk_keymap_layer_names[layer],
+                          MIN(len, CONFIG_ZMK_KEYMAP_LAYER_NAME_MAX_LEN - 1));
+        if (err <= 0) {
+            LOG_ERR("Failed to handle keymap layer name from settings (err %d)", err);
+            return err;
+        }
+    } else if (settings_name_steq(name, "l", &next) && next) {
+        char *endptr;
+        uint8_t layer = strtoul(next, &endptr, 10);
+        if (*endptr != '/') {
+            LOG_WRN("Invalid layer number: %s with endptr %s", next, endptr);
+            return -EINVAL;
+        }
+
+        uint8_t key_position = strtoul(endptr + 1, &endptr, 10);
+
+        if (*endptr != '\0') {
+            LOG_WRN("Invalid key_position number: %s with endptr %s", next, endptr);
+            return -EINVAL;
+        }
+
+        if (len > sizeof(struct zmk_behavior_binding_setting)) {
+            LOG_ERR("Too large binding setting size (got %d expected %d)", len,
+                    sizeof(struct zmk_behavior_binding_setting));
+            return -EINVAL;
+        }
+
+        if (layer >= ZMK_KEYMAP_LAYERS_LEN) {
+            LOG_WRN("Layer %d is larger than max of %d", layer, ZMK_KEYMAP_LAYERS_LEN);
+            return -EINVAL;
+        }
+
+        if (key_position >= ZMK_KEYMAP_LEN) {
+            LOG_WRN("Key position %d is larger than max of %d", key_position, ZMK_KEYMAP_LEN);
+            return -EINVAL;
+        }
+
+        struct zmk_behavior_binding_setting binding_setting = {0};
+        int err = read_cb(cb_arg, &binding_setting, len);
+        if (err <= 0) {
+            LOG_ERR("Failed to handle keymap binding from settings (err %d)", err);
+            return err;
+        }
+
+        const char *name =
+            zmk_behavior_find_behavior_name_from_local_id(binding_setting.behavior_local_id);
+
+        if (!name) {
+            LOG_WRN("Loaded device %d from settings but no device found by that local ID",
+                    binding_setting.behavior_local_id);
+        }
+
+        zmk_keymap[layer][key_position] = (struct zmk_behavior_binding){
+            .local_id = binding_setting.behavior_local_id,
+            .behavior_dev = name,
+            .param1 = binding_setting.param1,
+            .param2 = binding_setting.param2,
+        };
+    }
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+    else if (settings_name_steq(name, "layer_order", &next) && !next) {
+        int err =
+            read_cb(cb_arg, settings_layer_orders, MIN(len, ARRAY_SIZE(settings_layer_orders)));
+        if (err <= 0) {
+            LOG_ERR("Failed to handle keymap layer orders from settings (err %d)", err);
+            return err;
+        }
+
+        LOG_HEXDUMP_DBG(settings_layer_orders, ARRAY_SIZE(settings_layer_orders),
+                        "Settings Layer Order");
+
+        memcpy(keymap_layer_orders, settings_layer_orders,
+               MIN(len, ARRAY_SIZE(settings_layer_orders)));
+    }
+#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+
+    return 0;
+};
+
+static int keymap_handle_commit(void) {
+    for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
+        for (int p = 0; p < ZMK_KEYMAP_LEN; p++) {
+            struct zmk_behavior_binding *binding = &zmk_keymap[l][p];
+
+            if (binding->local_id > 0 && !binding->behavior_dev) {
+                binding->behavior_dev =
+                    zmk_behavior_find_behavior_name_from_local_id(binding->local_id);
+
+                if (!binding->behavior_dev) {
+                    LOG_ERR("Failed to finding device for local ID %d after settings load",
+                            binding->local_id);
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+SETTINGS_STATIC_HANDLER_DEFINE(keymap, "keymap", NULL, keymap_handle_set, keymap_handle_commit,
+                               NULL);
+
+#endif // IS_ENABLED(CONFIG_ZMK_KEYMAP_SETTINGS_STORAGE)
+
+int keymap_init(void) {
+#if IS_ENABLED(CONFIG_ZMK_KEYMAP_LAYER_REORDERING)
+    load_stock_keymap_layer_ordering();
+#endif
+
+    return 0;
+}
+
+SYS_INIT(keymap_init, APPLICATION, CONFIG_APPLICATION_INIT_PRIORITY);
diff --git a/app/src/physical_layouts.c b/app/src/physical_layouts.c
index 16b13e710c..00cfa29e78 100644
--- a/app/src/physical_layouts.c
+++ b/app/src/physical_layouts.c
@@ -72,9 +72,17 @@ struct position_map_entry {
     const uint32_t positions[ZMK_POS_MAP_LEN];
 };
 
+#define ZMK_POS_MAP_LEN_CHECK(node_id)                                                             \
+    BUILD_ASSERT(ZMK_POS_MAP_LEN == DT_PROP_LEN(node_id, positions),                               \
+                 "Position maps must all have the same number of entries")
+
+DT_FOREACH_CHILD_SEP(DT_INST(0, POS_MAP_COMPAT), ZMK_POS_MAP_LEN_CHECK, (;));
+
 #define ZMK_POS_MAP_ENTRY(node_id)                                                                 \
     {                                                                                              \
-        .layout = &_CONCAT(_zmk_physical_layout_, DT_PHANDLE(node_id, physical_layout)),           \
+        .layout = COND_CODE_1(                                                                     \
+            DT_HAS_COMPAT_STATUS_OKAY(DT_PHANDLE(node_id, physical_layout)),                       \
+            (&_CONCAT(_zmk_physical_layout_, DT_PHANDLE(node_id, physical_layout))), (NULL)),      \
         .positions = DT_PROP(node_id, positions),                                                  \
     }
 
@@ -275,13 +283,15 @@ int zmk_physical_layouts_save_selected(void) {
 
 int zmk_physical_layouts_revert_selected(void) { return zmk_physical_layouts_select_initial(); }
 
-int zmk_physical_layouts_get_position_map(uint8_t source, uint8_t dest, uint32_t *map) {
+int zmk_physical_layouts_get_position_map(uint8_t source, uint8_t dest, size_t map_size,
+                                          uint32_t map[map_size]) {
     if (source >= ARRAY_SIZE(layouts) || dest >= ARRAY_SIZE(layouts)) {
         return -EINVAL;
     }
 
     const struct zmk_physical_layout *src_layout = layouts[source];
     const struct zmk_physical_layout *dest_layout = layouts[dest];
+    int max_kp = dest_layout->keys_len;
 
 #if HAVE_POS_MAP
     const struct position_map_entry *src_pos_map = NULL;
@@ -296,11 +306,24 @@ int zmk_physical_layouts_get_position_map(uint8_t source, uint8_t dest, uint32_t
             dest_pos_map = &positions_maps[pm];
         }
     }
+
+    // Maps can place items "off the end" of other layouts so they are
+    // preserved but not visible, so adjust our max here if that is being used.
+    if (src_pos_map && dest_pos_map) {
+        for (int mp = 0; mp < ZMK_POS_MAP_LEN; mp++) {
+            max_kp =
+                MAX(max_kp, MAX(src_pos_map->positions[mp] + 1, dest_pos_map->positions[mp] + 1));
+        }
+    }
 #endif
 
-    memset(map, UINT32_MAX, dest_layout->keys_len);
+    if (map_size < max_kp) {
+        return -EINVAL;
+    }
+
+    memset(map, UINT32_MAX, map_size);
 
-    for (int b = 0; b < dest_layout->keys_len; b++) {
+    for (int b = 0; b < max_kp; b++) {
         bool found = false;
 
 #if HAVE_POS_MAP
@@ -329,13 +352,9 @@ int zmk_physical_layouts_get_position_map(uint8_t source, uint8_t dest, uint32_t
             }
         }
 #endif
-
-        if (!found || map[b] >= src_layout->keys_len) {
-            map[b] = UINT32_MAX;
-        }
     }
 
-    return dest_layout->keys_len;
+    return max_kp;
 }
 
 #if IS_ENABLED(CONFIG_SETTINGS)
diff --git a/app/src/studio/CMakeLists.txt b/app/src/studio/CMakeLists.txt
index e8f0d49d26..a8417dd768 100644
--- a/app/src/studio/CMakeLists.txt
+++ b/app/src/studio/CMakeLists.txt
@@ -3,6 +3,7 @@
 
 zephyr_linker_sources(DATA_SECTIONS ../../include/linker/zmk-rpc-subsystems.ld)
 zephyr_linker_sources(SECTIONS ../../include/linker/zmk-rpc-subsystem-handlers.ld)
+zephyr_linker_sources(SECTIONS ../../include/linker/zmk-rpc-subsystem-settings-reset.ld)
 zephyr_linker_sources(SECTIONS ../../include/linker/zmk-rpc-event-mappers.ld)
 zephyr_linker_sources(SECTIONS ../../include/linker/zmk-rpc-transport.ld)
 
@@ -11,5 +12,6 @@ target_sources(app PRIVATE rpc.c)
 target_sources(app PRIVATE core.c)
 target_sources(app PRIVATE behavior_subsystem.c)
 target_sources(app PRIVATE core_subsystem.c)
+target_sources(app PRIVATE keymap_subsystem.c)
 target_sources_ifdef(CONFIG_ZMK_STUDIO_TRANSPORT_UART app PRIVATE uart_rpc_transport.c)
 target_sources_ifdef(CONFIG_ZMK_STUDIO_TRANSPORT_BLE app PRIVATE gatt_rpc_transport.c)
\ No newline at end of file
diff --git a/app/src/studio/Kconfig b/app/src/studio/Kconfig
index ebe680bb8c..d1315070e6 100644
--- a/app/src/studio/Kconfig
+++ b/app/src/studio/Kconfig
@@ -41,6 +41,8 @@ menuconfig ZMK_STUDIO_RPC
     select ZMK_BEHAVIOR_METADATA
     select ZMK_BEHAVIOR_LOCAL_IDS
     select RING_BUFFER
+    select ZMK_KEYMAP_SETTINGS_STORAGE
+    select ZMK_KEYMAP_LAYER_REORDERING
     help
       Add firmware support for studio RPC protocol
 
diff --git a/app/src/studio/core_subsystem.c b/app/src/studio/core_subsystem.c
index 001aed9b9c..2cdc9d7ce4 100644
--- a/app/src/studio/core_subsystem.c
+++ b/app/src/studio/core_subsystem.c
@@ -61,8 +61,21 @@ zmk_studio_Response get_lock_state(const zmk_studio_Request *req) {
     return CORE_RESPONSE(get_lock_state, resp);
 }
 
+zmk_studio_Response reset_settings(const zmk_studio_Request *req) {
+    ZMK_RPC_SUBSYSTEM_SETTINGS_RESET_FOREACH(sub) {
+        int ret = sub->callback();
+        if (ret < 0) {
+            LOG_ERR("Failed to reset settings: %d", ret);
+            return CORE_RESPONSE(reset_settings, false);
+        }
+    }
+
+    return CORE_RESPONSE(reset_settings, true);
+}
+
 ZMK_RPC_SUBSYSTEM_HANDLER(core, get_device_info, ZMK_STUDIO_RPC_HANDLER_UNSECURED);
 ZMK_RPC_SUBSYSTEM_HANDLER(core, get_lock_state, ZMK_STUDIO_RPC_HANDLER_UNSECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(core, reset_settings, ZMK_STUDIO_RPC_HANDLER_SECURED);
 
 static int core_event_mapper(const zmk_event_t *eh, zmk_studio_Notification *n) {
     struct zmk_studio_core_lock_state_changed *lock_ev = as_zmk_studio_core_lock_state_changed(eh);
diff --git a/app/src/studio/keymap_subsystem.c b/app/src/studio/keymap_subsystem.c
new file mode 100644
index 0000000000..aa4b979920
--- /dev/null
+++ b/app/src/studio/keymap_subsystem.c
@@ -0,0 +1,539 @@
+/*
+ * Copyright (c) 2024 The ZMK Contributors
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <zephyr/logging/log.h>
+
+LOG_MODULE_DECLARE(zmk_studio, CONFIG_ZMK_STUDIO_LOG_LEVEL);
+
+#include <drivers/behavior.h>
+
+#include <zmk/behavior.h>
+#include <zmk/matrix.h>
+#include <zmk/keymap.h>
+#include <zmk/studio/rpc.h>
+#include <zmk/physical_layouts.h>
+
+#include <pb_encode.h>
+
+ZMK_RPC_SUBSYSTEM(keymap)
+
+#define KEYMAP_RESPONSE(type, ...) ZMK_RPC_RESPONSE(keymap, type, __VA_ARGS__)
+#define KEYMAP_NOTIFICATION(type, ...) ZMK_RPC_NOTIFICATION(keymap, type, __VA_ARGS__)
+
+static bool encode_layer_bindings(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
+    const zmk_keymap_layer_id_t layer_id = *(uint8_t *)*arg;
+
+    for (int b = 0; b < ZMK_KEYMAP_LEN; b++) {
+        const struct zmk_behavior_binding *binding =
+            zmk_keymap_get_layer_binding_at_idx(layer_id, b);
+
+        zmk_keymap_BehaviorBinding bb = zmk_keymap_BehaviorBinding_init_zero;
+
+        if (binding && binding->behavior_dev) {
+            bb.behavior_id = zmk_behavior_get_local_id(binding->behavior_dev);
+            bb.param1 = binding->param1;
+            bb.param2 = binding->param2;
+        }
+
+        if (!pb_encode_tag_for_field(stream, field)) {
+            return false;
+        }
+
+        if (!pb_encode_submessage(stream, &zmk_keymap_BehaviorBinding_msg, &bb)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool encode_layer_name(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
+    const zmk_keymap_layer_index_t layer_idx = *(uint8_t *)*arg;
+
+    const char *name = zmk_keymap_layer_name(layer_idx);
+
+    if (!name) {
+        return true;
+    }
+
+    if (!pb_encode_tag_for_field(stream, field)) {
+        return false;
+    }
+
+    return pb_encode_string(stream, name, strlen(name));
+}
+
+static bool encode_keymap_layers(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
+    for (zmk_keymap_layer_index_t l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
+        zmk_keymap_layer_id_t layer_id = zmk_keymap_layer_index_to_id(l);
+
+        if (layer_id == UINT8_MAX) {
+            break;
+        }
+
+        if (!pb_encode_tag_for_field(stream, field)) {
+            LOG_WRN("Failed to encode tag");
+            return false;
+        }
+
+        zmk_keymap_Layer layer = zmk_keymap_Layer_init_zero;
+        layer.id = layer_id;
+
+        layer.name.funcs.encode = encode_layer_name;
+        layer.name.arg = &layer_id;
+
+        layer.bindings.funcs.encode = encode_layer_bindings;
+        layer.bindings.arg = &layer_id;
+
+        if (!pb_encode_submessage(stream, &zmk_keymap_Layer_msg, &layer)) {
+            LOG_WRN("Failed to encode layer submessage");
+            return false;
+        }
+    }
+
+    return true;
+}
+
+zmk_studio_Response get_keymap(const zmk_studio_Request *req) {
+    zmk_keymap_Keymap resp = zmk_keymap_Keymap_init_zero;
+
+    resp.layers.funcs.encode = encode_keymap_layers;
+
+    resp.available_layers = 0;
+
+    for (zmk_keymap_layer_index_t index = 0; index < ZMK_KEYMAP_LAYERS_LEN; index++) {
+        zmk_keymap_layer_id_t id = zmk_keymap_layer_index_to_id(index);
+
+        if (id == UINT8_MAX) {
+            resp.available_layers = ZMK_KEYMAP_LAYERS_LEN - index;
+            break;
+        }
+    }
+
+    return KEYMAP_RESPONSE(get_keymap, resp);
+}
+
+zmk_studio_Response set_layer_binding(const zmk_studio_Request *req) {
+    const zmk_keymap_SetLayerBindingRequest *set_req =
+        &req->subsystem.keymap.request_type.set_layer_binding;
+
+    zmk_behavior_local_id_t bid = set_req->binding.behavior_id;
+
+    const char *behavior_name = zmk_behavior_find_behavior_name_from_local_id(bid);
+
+    if (!behavior_name) {
+        return KEYMAP_RESPONSE(
+            set_layer_binding,
+            zmk_keymap_SetLayerBindingResponse_SET_LAYER_BINDING_RESP_INVALID_BEHAVIOR);
+    }
+
+    struct zmk_behavior_binding binding = (struct zmk_behavior_binding){
+        .behavior_dev = behavior_name,
+        .param1 = set_req->binding.param1,
+        .param2 = set_req->binding.param2,
+    };
+
+    int ret = zmk_behavior_validate_binding(&binding);
+    if (ret < 0) {
+        return KEYMAP_RESPONSE(
+            set_layer_binding,
+            zmk_keymap_SetLayerBindingResponse_SET_LAYER_BINDING_RESP_INVALID_PARAMETERS);
+    }
+
+    ret = zmk_keymap_set_layer_binding_at_idx(set_req->layer_id, set_req->key_position, binding);
+
+    if (ret < 0) {
+        LOG_WRN("Setting the binding failed with %d", ret);
+        switch (ret) {
+        case -EINVAL:
+            return KEYMAP_RESPONSE(
+                set_layer_binding,
+                zmk_keymap_SetLayerBindingResponse_SET_LAYER_BINDING_RESP_INVALID_LOCATION);
+        default:
+            return ZMK_RPC_SIMPLE_ERR(GENERIC);
+        }
+    }
+
+    raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
+        .notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
+
+    return KEYMAP_RESPONSE(set_layer_binding,
+                           zmk_keymap_SetLayerBindingResponse_SET_LAYER_BINDING_RESP_OK);
+}
+
+zmk_studio_Response check_unsaved_changes(const zmk_studio_Request *req) {
+    int layout_changes = zmk_physical_layouts_check_unsaved_selection();
+    int keymap_changes = zmk_keymap_check_unsaved_changes();
+
+    return KEYMAP_RESPONSE(check_unsaved_changes, layout_changes > 0 || keymap_changes > 0);
+}
+
+zmk_studio_Response save_changes(const zmk_studio_Request *req) {
+    int ret = zmk_physical_layouts_save_selected();
+
+    if (ret < 0) {
+        return ZMK_RPC_SIMPLE_ERR(GENERIC);
+    }
+
+    ret = zmk_keymap_save_changes();
+    if (ret < 0) {
+        return ZMK_RPC_SIMPLE_ERR(GENERIC);
+    }
+
+    raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
+        .notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, false)});
+
+    return KEYMAP_RESPONSE(save_changes, true);
+}
+
+zmk_studio_Response discard_changes(const zmk_studio_Request *req) {
+    int ret = zmk_physical_layouts_revert_selected();
+    if (ret < 0) {
+        return ZMK_RPC_SIMPLE_ERR(GENERIC);
+    }
+
+    ret = zmk_keymap_discard_changes();
+    if (ret < 0) {
+        return ZMK_RPC_SIMPLE_ERR(GENERIC);
+    }
+
+    raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
+        .notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, false)});
+
+    return KEYMAP_RESPONSE(discard_changes, true);
+}
+
+static int keymap_settings_reset(void) { return zmk_keymap_reset_settings(); }
+
+ZMK_RPC_SUBSYSTEM_SETTINGS_RESET(keymap, keymap_settings_reset);
+
+static bool encode_layout_name(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
+    struct zmk_physical_layout *layout = (struct zmk_physical_layout *)*arg;
+
+    if (!layout->display_name) {
+        return true;
+    }
+
+    if (!pb_encode_tag_for_field(stream, field)) {
+        LOG_WRN("Failed to encode tag");
+        return false;
+    }
+
+    pb_encode_string(stream, layout->display_name, strlen(layout->display_name));
+
+    return true;
+}
+
+static bool encode_layout_keys(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
+    struct zmk_physical_layout *layout = (struct zmk_physical_layout *)*arg;
+
+    for (int kp = 0; kp < layout->keys_len; kp++) {
+        const struct zmk_key_physical_attrs *layout_kp = &layout->keys[kp];
+
+        if (!pb_encode_tag_for_field(stream, field)) {
+            LOG_WRN("Failed to encode tag");
+            return false;
+        }
+
+        zmk_keymap_KeyPhysicalAttrs layout_kp_msg = {
+            .width = layout_kp->width,
+            .height = layout_kp->height,
+            .x = layout_kp->x,
+            .y = layout_kp->y,
+            .r = layout_kp->r,
+            .rx = layout_kp->rx,
+            .ry = layout_kp->ry,
+        };
+
+        if (!pb_encode_submessage(stream, &zmk_keymap_KeyPhysicalAttrs_msg, &layout_kp_msg)) {
+            LOG_WRN("Failed to encode layout key position submessage");
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool encode_layouts(pb_ostream_t *stream, const pb_field_t *field, void *const *arg) {
+    struct zmk_physical_layout const *const *layouts;
+    const size_t layout_count = zmk_physical_layouts_get_list(&layouts);
+
+    for (int i = 0; i < layout_count; i++) {
+        const struct zmk_physical_layout *l = layouts[i];
+
+        if (!pb_encode_tag_for_field(stream, field)) {
+            LOG_WRN("Failed to encode tag");
+            return false;
+        }
+
+        zmk_keymap_PhysicalLayout layout = zmk_keymap_PhysicalLayout_init_zero;
+
+        layout.name.funcs.encode = encode_layout_name;
+        layout.name.arg = l;
+
+        layout.keys.funcs.encode = encode_layout_keys;
+        layout.keys.arg = l;
+
+        if (!pb_encode_submessage(stream, &zmk_keymap_PhysicalLayout_msg, &layout)) {
+            LOG_WRN("Failed to encode layout submessage");
+            return false;
+        }
+    }
+
+    return true;
+}
+
+zmk_studio_Response get_physical_layouts(const zmk_studio_Request *req) {
+    zmk_keymap_PhysicalLayouts resp = zmk_keymap_PhysicalLayouts_init_zero;
+    resp.active_layout_index = zmk_physical_layouts_get_selected();
+    resp.layouts.funcs.encode = encode_layouts;
+    return KEYMAP_RESPONSE(get_physical_layouts, resp);
+}
+
+static void migrate_keymap(const uint8_t old) {
+    int new = zmk_physical_layouts_get_selected();
+
+    uint32_t new_to_old_map[ZMK_KEYMAP_LEN];
+    int layout_size =
+        zmk_physical_layouts_get_position_map(old, new, ZMK_KEYMAP_LEN, new_to_old_map);
+
+    if (layout_size < 0) {
+        return;
+    }
+
+    for (int l = 0; l < ZMK_KEYMAP_LAYERS_LEN; l++) {
+        struct zmk_behavior_binding new_layer[ZMK_KEYMAP_LEN];
+
+        for (int b = 0; b < layout_size; b++) {
+            uint32_t old_b = new_to_old_map[b];
+
+            if (old_b == UINT32_MAX) {
+                memset(&new_layer[b], 0, sizeof(struct zmk_behavior_binding));
+                continue;
+            }
+
+            const struct zmk_behavior_binding *binding =
+                zmk_keymap_get_layer_binding_at_idx(l, old_b);
+
+            if (!binding) {
+                memset(&new_layer[b], 0, sizeof(struct zmk_behavior_binding));
+                continue;
+            }
+
+            memcpy(&new_layer[b], binding, sizeof(struct zmk_behavior_binding));
+        }
+
+        for (int b = 0; b < layout_size; b++) {
+            zmk_keymap_set_layer_binding_at_idx(l, b, new_layer[b]);
+        }
+    }
+
+    // TODO: Migrate combos?
+}
+
+zmk_studio_Response set_active_physical_layout(const zmk_studio_Request *req) {
+    uint8_t index = (uint8_t)req->subsystem.keymap.request_type.set_active_physical_layout;
+    int old = zmk_physical_layouts_get_selected();
+
+    zmk_keymap_SetActivePhysicalLayoutResponse resp =
+        zmk_keymap_SetActivePhysicalLayoutResponse_init_zero;
+    resp.which_result = zmk_keymap_SetActivePhysicalLayoutResponse_ok_tag;
+    resp.result.ok.layers.funcs.encode = encode_keymap_layers;
+
+    if (old == index) {
+        return KEYMAP_RESPONSE(set_active_physical_layout, resp);
+    }
+
+    int ret = zmk_physical_layouts_select(index);
+    if (ret >= 0) {
+        migrate_keymap(old);
+    } else {
+        resp.which_result = zmk_keymap_SetActivePhysicalLayoutResponse_err_tag;
+        resp.result.err =
+            zmk_keymap_SetActivePhysicalLayoutErrorCode_SET_ACTIVE_PHYSICAL_LAYOUT_ERR_GENERIC;
+    }
+
+    raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
+        .notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
+
+    return KEYMAP_RESPONSE(set_active_physical_layout, resp);
+}
+
+zmk_studio_Response move_layer(const zmk_studio_Request *req) {
+    const zmk_keymap_MoveLayerRequest *move_req = &req->subsystem.keymap.request_type.move_layer;
+
+    zmk_keymap_MoveLayerResponse resp = zmk_keymap_MoveLayerResponse_init_zero;
+
+    int ret = zmk_keymap_move_layer(move_req->start_index, move_req->dest_index);
+
+    if (ret >= 0) {
+        resp.which_result = zmk_keymap_SetActivePhysicalLayoutResponse_ok_tag;
+        resp.result.ok.layers.funcs.encode = encode_keymap_layers;
+
+        raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
+            .notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
+    } else {
+        LOG_WRN("Failed to move layer: %d", ret);
+        resp.which_result = zmk_keymap_MoveLayerResponse_err_tag;
+        resp.result.err = zmk_keymap_MoveLayerErrorCode_MOVE_LAYER_ERR_GENERIC;
+    }
+
+    return KEYMAP_RESPONSE(move_layer, resp);
+}
+
+zmk_studio_Response add_layer(const zmk_studio_Request *req) {
+    // Use a static here to keep the value valid during serialization
+    static zmk_keymap_layer_id_t layer_id = 0;
+
+    zmk_keymap_AddLayerResponse resp = zmk_keymap_AddLayerResponse_init_zero;
+
+    int ret = zmk_keymap_add_layer();
+
+    if (ret >= 0) {
+        layer_id = zmk_keymap_layer_index_to_id(ret);
+
+        resp.which_result = zmk_keymap_AddLayerResponse_ok_tag;
+
+        resp.result.ok.index = ret;
+
+        resp.result.ok.has_layer = true;
+        resp.result.ok.layer.id = layer_id;
+
+        resp.result.ok.layer.name.funcs.encode = encode_layer_name;
+        resp.result.ok.layer.name.arg = &layer_id;
+
+        resp.result.ok.layer.bindings.funcs.encode = encode_layer_bindings;
+        resp.result.ok.layer.bindings.arg = &layer_id;
+
+        raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
+            .notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
+    } else {
+        LOG_WRN("Failed to add layer: %d", ret);
+        resp.which_result = zmk_keymap_AddLayerResponse_err_tag;
+        switch (ret) {
+        case -ENOSPC:
+            resp.result.err = zmk_keymap_AddLayerErrorCode_ADD_LAYER_ERR_NO_SPACE;
+            break;
+        default:
+            resp.result.err = zmk_keymap_AddLayerErrorCode_ADD_LAYER_ERR_GENERIC;
+            break;
+        }
+    }
+
+    return KEYMAP_RESPONSE(add_layer, resp);
+}
+
+zmk_studio_Response remove_layer(const zmk_studio_Request *req) {
+    const zmk_keymap_RemoveLayerRequest *rm_req = &req->subsystem.keymap.request_type.remove_layer;
+
+    zmk_keymap_RemoveLayerResponse resp = zmk_keymap_RemoveLayerResponse_init_zero;
+
+    int ret = zmk_keymap_remove_layer(rm_req->layer_index);
+
+    if (ret >= 0) {
+        resp.which_result = zmk_keymap_RemoveLayerResponse_ok_tag;
+
+        raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
+            .notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
+    } else {
+        LOG_WRN("Failed to rm layer: %d", ret);
+        resp.which_result = zmk_keymap_RemoveLayerResponse_err_tag;
+        switch (ret) {
+        case -EINVAL:
+            resp.result.err = zmk_keymap_RemoveLayerErrorCode_REMOVE_LAYER_ERR_INVALID_INDEX;
+            break;
+        default:
+            resp.result.err = zmk_keymap_RemoveLayerErrorCode_REMOVE_LAYER_ERR_GENERIC;
+            break;
+        }
+    }
+
+    return KEYMAP_RESPONSE(remove_layer, resp);
+}
+
+zmk_studio_Response restore_layer(const zmk_studio_Request *req) {
+    const zmk_keymap_RestoreLayerRequest *restore_req =
+        &req->subsystem.keymap.request_type.restore_layer;
+
+    zmk_keymap_RestoreLayerResponse resp = zmk_keymap_RestoreLayerResponse_init_zero;
+
+    int ret = zmk_keymap_restore_layer(restore_req->layer_id, restore_req->at_index);
+
+    if (ret >= 0) {
+        resp.which_result = zmk_keymap_RemoveLayerResponse_ok_tag;
+        resp.result.ok.id = restore_req->layer_id;
+
+        resp.result.ok.name.funcs.encode = encode_layer_name;
+        resp.result.ok.name.arg = &restore_req->layer_id;
+
+        resp.result.ok.bindings.funcs.encode = encode_layer_bindings;
+        resp.result.ok.bindings.arg = &restore_req->layer_id;
+
+        raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
+            .notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
+    } else {
+        LOG_WRN("Failed to restore layer: %d", ret);
+        resp.which_result = zmk_keymap_RestoreLayerResponse_err_tag;
+        switch (ret) {
+        case -EINVAL:
+            resp.result.err = zmk_keymap_RestoreLayerErrorCode_RESTORE_LAYER_ERR_INVALID_INDEX;
+            break;
+        default:
+            resp.result.err = zmk_keymap_RestoreLayerErrorCode_RESTORE_LAYER_ERR_GENERIC;
+            break;
+        }
+    }
+
+    return KEYMAP_RESPONSE(restore_layer, resp);
+}
+
+zmk_studio_Response set_layer_props(const zmk_studio_Request *req) {
+    const zmk_keymap_SetLayerPropsRequest *set_req =
+        &req->subsystem.keymap.request_type.set_layer_props;
+
+    zmk_keymap_SetLayerPropsResponse resp =
+        zmk_keymap_SetLayerPropsResponse_SET_LAYER_PROPS_RESP_OK;
+
+    if (strlen(set_req->name) <= 0) {
+        return KEYMAP_RESPONSE(set_layer_props, resp);
+    }
+
+    int ret = zmk_keymap_set_layer_name(set_req->layer_id, set_req->name, strlen(set_req->name));
+
+    if (ret >= 0) {
+
+        raise_zmk_studio_rpc_notification((struct zmk_studio_rpc_notification){
+            .notification = KEYMAP_NOTIFICATION(unsaved_changes_status_changed, true)});
+    } else {
+        LOG_WRN("Failed to set layer props: %d", ret);
+        switch (ret) {
+        case -EINVAL:
+            resp = zmk_keymap_SetLayerPropsResponse_SET_LAYER_PROPS_RESP_ERR_INVALID_ID;
+            break;
+        default:
+            resp = zmk_keymap_SetLayerPropsResponse_SET_LAYER_PROPS_RESP_ERR_GENERIC;
+            break;
+        }
+    }
+
+    return KEYMAP_RESPONSE(set_layer_props, resp);
+}
+
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, get_keymap, ZMK_STUDIO_RPC_HANDLER_SECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, set_layer_binding, ZMK_STUDIO_RPC_HANDLER_SECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, check_unsaved_changes, ZMK_STUDIO_RPC_HANDLER_SECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, save_changes, ZMK_STUDIO_RPC_HANDLER_SECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, discard_changes, ZMK_STUDIO_RPC_HANDLER_SECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, get_physical_layouts, ZMK_STUDIO_RPC_HANDLER_SECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, set_active_physical_layout, ZMK_STUDIO_RPC_HANDLER_SECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, move_layer, ZMK_STUDIO_RPC_HANDLER_SECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, add_layer, ZMK_STUDIO_RPC_HANDLER_SECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, remove_layer, ZMK_STUDIO_RPC_HANDLER_SECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, restore_layer, ZMK_STUDIO_RPC_HANDLER_SECURED);
+ZMK_RPC_SUBSYSTEM_HANDLER(keymap, set_layer_props, ZMK_STUDIO_RPC_HANDLER_SECURED);
+
+static int event_mapper(const zmk_event_t *eh, zmk_studio_Notification *n) { return 0; }
+
+ZMK_RPC_EVENT_MAPPER(keymap, event_mapper);