feat(src): Make usable

18 files changed, 1986 insertions, 651 deletions

diff --git a/src/config.h b/src/config.h
index 240867c..b846d89 100644
--- a/src/config.h
+++ b/src/config.h
@@ -1,70 +1,37 @@
-// LTeX: language=off
-/*
- * Moonlander Layout
+/* Copyright 2020 ZSA Technology Labs, Inc <@zsa>
+ * Copyright 2020 Jack Humbert <jack.humb@gmail.com>
+ * Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
  *
- * Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
- * SPDX-License-Identifier: AGPL-3.0-or-later
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
  *
- * This file is part of Moonlander Layout.
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
  *
- * You should have received a copy of the License along with this program.
- * If not, see <https://www.gnu.org/licenses/agpl.txt>.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-/*
-  Set any config.h overrides for your specific keymap here.
-  See config.h options at
-  https://docs.qmk.fm/#/config_options?id=the-configh-file
-*/
+#pragma once
 
-#undef DEBOUNCE
-#define DEBOUNCE 8
+/* key matrix size */
+#define MATRIX_ROWS 12
+#define MATRIX_COLS 7
 
-#define USB_SUSPEND_WAKEUP_DELAY 0
-#define LAYER_STATE_16BIT
+#define EEPROM_I2C_24LC128
 
-#define RGB_MATRIX_STARTUP_SPD 60
+#define IS31FL3731_I2C_ADDRESS_1 IS31FL3731_I2C_ADDRESS_GND
+#define IS31FL3731_I2C_ADDRESS_2 IS31FL3731_I2C_ADDRESS_VCC
 
-#define UNICODE_SELECTED_MODES UNICODE_MODE_LINUX
+#define MUSIC_MAP
 
-// Mouse Key section {{{
-/* Delay between pressing a movement key and cursor movement */
-#undef MOUSEKEY_DELAY
-#define MOUSEKEY_DELAY 0 // default: 10
+#define FIRMWARE_VERSION_SIZE 17
+#define DYNAMIC_KEYMAP_EEPROM_ADDR (EECONFIG_SIZE + FIRMWARE_VERSION_SIZE)
 
-/* Time between cursor movements in milliseconds */
-#undef MOUSEKEY_INTERVAL
-#define MOUSEKEY_INTERVAL 20 // default: 20
-
-/* Step size */
-// #undef MOUSEKEY_MOVE_DELTA
-// #define MOUSEKEY_MOVE_DELTA 18 // default: 8
-
-/* Maximum cursor speed at which acceleration stops */
-#undef MOUSEKEY_MAX_SPEED
-#define MOUSEKEY_MAX_SPEED 14 // default: 10
-
-/* Time until maximum cursor speed is reached */
-#undef MOUSEKEY_TIME_TO_MAX
-#define MOUSEKEY_TIME_TO_MAX 60 // default: 30
-
-/* Delay between pressing a wheel key and wheel movement */
-#undef MOUSEKEY_WHEEL_DELAY
-#define MOUSEKEY_WHEEL_DELAY 0 // default: 10
-
-/* Time between wheel movements */
-#undef MOUSEKEY_WHEEL_INTERVAL
-#define MOUSEKEY_WHEEL_INTERVAL 80 // default: 80
-
-/* Wheel movement step size */
-#undef MOUSEKEY_WHEEL_DELTA
-#define MOUSEKEY_WHEEL_DELTA 3 // default: 1
-
-/* Maximum number of scroll steps per scroll action */
-#undef MOUSEKEY_WHEEL_MAX_SPEED
-#define MOUSEKEY_WHEEL_MAX_SPEED 8 // default: 8
-
-/* Time until maximum scroll speed is reached */
-#undef MOUSEKEY_WHEEL_TIME_TO_MAX
-#define MOUSEKEY_WHEEL_TIME_TO_MAX 60 // default: 40
-// }}}
+#define AUDIO_PIN A5
+#define AUDIO_PIN_ALT A4
+#define AUDIO_PIN_ALT_AS_NEGATIVE
diff --git a/src/halconf.h b/src/halconf.h
new file mode 100644
index 0000000..46b53b1
--- /dev/null
+++ b/src/halconf.h
@@ -0,0 +1,22 @@
+/* Copyright 2021 QMK
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#define HAL_USE_I2C TRUE
+#define HAL_USE_GPT TRUE
+#define HAL_USE_DAC TRUE
+
+#include_next <halconf.h>
diff --git a/src/keyboard.json b/src/keyboard.json
new file mode 100644
index 0000000..07b2e4b
--- /dev/null
+++ b/src/keyboard.json
@@ -0,0 +1,213 @@
+{
+    "keyboard_name": "Moonlander Mark I",
+    "manufacturer": "ZSA Technology Labs",
+
+    "url": "zsa.io/moonlander",
+    "maintainer": "ZSA via Drashna",
+
+    "usb": {
+        "vid": "0x3297",
+        "pid": "0x1969",
+        "device_version": "0.0.1",
+
+        "shared_endpoint": {
+            "mouse": false
+        }
+    },
+
+    "qmk": {
+        "locking": {
+            "enabled": true,
+            "resync": true
+        }
+    },
+
+    "audio": {
+        "driver": "dac_additive"
+    },
+    "dynamic_keymap": {
+        "layer_count": 8
+    },
+
+    "eeprom": {
+        "driver": "i2c"
+    },
+
+    "rgb_matrix": {
+        "center_point": [120, 36],
+        "driver": "is31fl3731",
+        "layout": [
+            {"matrix": [0, 0], "x": 0, "y": 4, "flags": 1},
+            {"matrix": [1, 0], "x": 0, "y": 20, "flags": 1},
+            {"matrix": [2, 0], "x": 0, "y": 36, "flags": 1},
+            {"matrix": [3, 0], "x": 0, "y": 52, "flags": 1},
+            {"matrix": [4, 0], "x": 0, "y": 68, "flags": 1},
+            {"matrix": [0, 1], "x": 16, "y": 3, "flags": 4},
+            {"matrix": [1, 1], "x": 16, "y": 19, "flags": 4},
+            {"matrix": [2, 1], "x": 16, "y": 35, "flags": 4},
+            {"matrix": [3, 1], "x": 16, "y": 51, "flags": 4},
+            {"matrix": [4, 1], "x": 16, "y": 67, "flags": 1},
+            {"matrix": [0, 2], "x": 32, "y": 1, "flags": 4},
+            {"matrix": [1, 2], "x": 32, "y": 17, "flags": 4},
+            {"matrix": [2, 2], "x": 32, "y": 33, "flags": 4},
+            {"matrix": [3, 2], "x": 32, "y": 49, "flags": 4},
+            {"matrix": [4, 2], "x": 32, "y": 65, "flags": 1},
+            {"matrix": [0, 3], "x": 48, "y": 0, "flags": 4},
+            {"matrix": [1, 3], "x": 48, "y": 16, "flags": 4},
+            {"matrix": [2, 3], "x": 48, "y": 32, "flags": 4},
+            {"matrix": [3, 3], "x": 48, "y": 48, "flags": 4},
+            {"matrix": [4, 3], "x": 48, "y": 64, "flags": 1},
+            {"matrix": [0, 4], "x": 64, "y": 1, "flags": 4},
+            {"matrix": [1, 4], "x": 64, "y": 17, "flags": 4},
+            {"matrix": [2, 4], "x": 64, "y": 33, "flags": 4},
+            {"matrix": [3, 4], "x": 64, "y": 49, "flags": 4},
+            {"matrix": [4, 4], "x": 64, "y": 65, "flags": 1},
+            {"matrix": [0, 5], "x": 80, "y": 3, "flags": 4},
+            {"matrix": [1, 5], "x": 80, "y": 19, "flags": 4},
+            {"matrix": [2, 5], "x": 80, "y": 35, "flags": 4},
+            {"matrix": [3, 5], "x": 80, "y": 51, "flags": 4},
+            {"matrix": [0, 6], "x": 96, "y": 4, "flags": 1},
+            {"matrix": [1, 6], "x": 96, "y": 20, "flags": 1},
+            {"matrix": [2, 6], "x": 96, "y": 36, "flags": 1},
+            {"matrix": [5, 0], "x": 88, "y": 69, "flags": 1},
+            {"matrix": [5, 1], "x": 100, "y": 80, "flags": 1},
+            {"matrix": [5, 2], "x": 112, "y": 91, "flags": 1},
+            {"matrix": [5, 3], "x": 108, "y": 69, "flags": 1},
+            {"matrix": [6, 6], "x": 240, "y": 4, "flags": 1},
+            {"matrix": [7, 6], "x": 240, "y": 20, "flags": 1},
+            {"matrix": [8, 6], "x": 240, "y": 36, "flags": 1},
+            {"matrix": [9, 6], "x": 240, "y": 52, "flags": 1},
+            {"matrix": [10, 6], "x": 240, "y": 68, "flags": 1},
+            {"matrix": [6, 5], "x": 224, "y": 3, "flags": 4},
+            {"matrix": [7, 5], "x": 224, "y": 19, "flags": 4},
+            {"matrix": [8, 5], "x": 224, "y": 35, "flags": 4},
+            {"matrix": [9, 5], "x": 224, "y": 51, "flags": 4},
+            {"matrix": [10, 5], "x": 224, "y": 67, "flags": 1},
+            {"matrix": [6, 4], "x": 208, "y": 1, "flags": 4},
+            {"matrix": [7, 4], "x": 208, "y": 17, "flags": 4},
+            {"matrix": [8, 4], "x": 208, "y": 33, "flags": 4},
+            {"matrix": [9, 4], "x": 208, "y": 49, "flags": 4},
+            {"matrix": [10, 4], "x": 208, "y": 65, "flags": 1},
+            {"matrix": [6, 3], "x": 192, "y": 0, "flags": 4},
+            {"matrix": [7, 3], "x": 192, "y": 16, "flags": 4},
+            {"matrix": [8, 3], "x": 192, "y": 32, "flags": 4},
+            {"matrix": [9, 3], "x": 192, "y": 48, "flags": 4},
+            {"matrix": [10, 3], "x": 192, "y": 64, "flags": 1},
+            {"matrix": [6, 2], "x": 176, "y": 1, "flags": 4},
+            {"matrix": [7, 2], "x": 176, "y": 17, "flags": 4},
+            {"matrix": [8, 2], "x": 176, "y": 33, "flags": 4},
+            {"matrix": [9, 2], "x": 176, "y": 49, "flags": 4},
+            {"matrix": [10, 2], "x": 176, "y": 65, "flags": 1},
+            {"matrix": [6, 1], "x": 160, "y": 3, "flags": 4},
+            {"matrix": [7, 1], "x": 160, "y": 19, "flags": 4},
+            {"matrix": [8, 1], "x": 160, "y": 35, "flags": 4},
+            {"matrix": [9, 1], "x": 160, "y": 51, "flags": 4},
+            {"matrix": [6, 0], "x": 144, "y": 4, "flags": 1},
+            {"matrix": [7, 0], "x": 144, "y": 20, "flags": 1},
+            {"matrix": [8, 0], "x": 144, "y": 36, "flags": 1},
+            {"matrix": [11, 6], "x": 152, "y": 69, "flags": 1},
+            {"matrix": [11, 5], "x": 140, "y": 80, "flags": 1},
+            {"matrix": [11, 4], "x": 128, "y": 91, "flags": 1},
+            {"matrix": [11, 3], "x": 132, "y": 69, "flags": 1}
+        ],
+        "led_flush_limit": 26,
+        "led_process_limit": 5,
+        "max_brightness": 175,
+        "sleep": true
+    },
+
+    "processor": "STM32F303",
+    "bootloader": "stm32-dfu",
+    "layout_aliases": {
+        "LAYOUT_moonlander": "LAYOUT"
+    },
+    "layouts": {
+        "LAYOUT": {
+            "layout": [
+                {"matrix": [0, 0], "x": 0, "y": 0.375},
+                {"matrix": [0, 1], "x": 1, "y": 0.375},
+                {"matrix": [0, 2], "x": 2, "y": 0.125},
+                {"matrix": [0, 3], "x": 3, "y": 0},
+                {"matrix": [0, 4], "x": 4, "y": 0.125},
+                {"matrix": [0, 5], "x": 5, "y": 0.25},
+                {"matrix": [0, 6], "x": 6, "y": 0.25},
+
+                {"matrix": [6, 0], "x": 10, "y": 0.25},
+                {"matrix": [6, 1], "x": 11, "y": 0.25},
+                {"matrix": [6, 2], "x": 12, "y": 0.125},
+                {"matrix": [6, 3], "x": 13, "y": 0},
+                {"matrix": [6, 4], "x": 14, "y": 0.125},
+                {"matrix": [6, 5], "x": 15, "y": 0.375},
+                {"matrix": [6, 6], "x": 16, "y": 0.375},
+
+                {"matrix": [1, 0], "x": 0, "y": 1.375},
+                {"matrix": [1, 1], "x": 1, "y": 1.375},
+                {"matrix": [1, 2], "x": 2, "y": 1.125},
+                {"matrix": [1, 3], "x": 3, "y": 1},
+                {"matrix": [1, 4], "x": 4, "y": 1.125},
+                {"matrix": [1, 5], "x": 5, "y": 1.25},
+                {"matrix": [1, 6], "x": 6, "y": 1.25},
+
+                {"matrix": [7, 0], "x": 10, "y": 1.25},
+                {"matrix": [7, 1], "x": 11, "y": 1.25},
+                {"matrix": [7, 2], "x": 12, "y": 1.125},
+                {"matrix": [7, 3], "x": 13, "y": 1},
+                {"matrix": [7, 4], "x": 14, "y": 1.125},
+                {"matrix": [7, 5], "x": 15, "y": 1.375},
+                {"matrix": [7, 6], "x": 16, "y": 1.375},
+
+                {"matrix": [2, 0], "x": 0, "y": 2.375},
+                {"matrix": [2, 1], "x": 1, "y": 2.375},
+                {"matrix": [2, 2], "x": 2, "y": 2.125},
+                {"matrix": [2, 3], "x": 3, "y": 2},
+                {"matrix": [2, 4], "x": 4, "y": 2.125},
+                {"matrix": [2, 5], "x": 5, "y": 2.25},
+                {"matrix": [2, 6], "x": 6, "y": 2.25},
+
+                {"matrix": [8, 0], "x": 10, "y": 2.25},
+                {"matrix": [8, 1], "x": 11, "y": 2.25},
+                {"matrix": [8, 2], "x": 12, "y": 2.125},
+                {"matrix": [8, 3], "x": 13, "y": 2},
+                {"matrix": [8, 4], "x": 14, "y": 2.125},
+                {"matrix": [8, 5], "x": 15, "y": 2.375},
+                {"matrix": [8, 6], "x": 16, "y": 2.375},
+
+                {"matrix": [3, 0], "x": 0, "y": 3.375},
+                {"matrix": [3, 1], "x": 1, "y": 3.375},
+                {"matrix": [3, 2], "x": 2, "y": 3.125},
+                {"matrix": [3, 3], "x": 3, "y": 3},
+                {"matrix": [3, 4], "x": 4, "y": 3.125},
+                {"matrix": [3, 5], "x": 5, "y": 3.25},
+
+                {"matrix": [9, 1], "x": 11, "y": 3.25},
+                {"matrix": [9, 2], "x": 12, "y": 3.125},
+                {"matrix": [9, 3], "x": 13, "y": 3},
+                {"matrix": [9, 4], "x": 14, "y": 3.125},
+                {"matrix": [9, 5], "x": 15, "y": 3.375},
+                {"matrix": [9, 6], "x": 16, "y": 3.375},
+
+                {"matrix": [4, 0], "x": 0, "y": 4.375},
+                {"matrix": [4, 1], "x": 1, "y": 4.375},
+                {"matrix": [4, 2], "x": 2, "y": 4.125},
+                {"matrix": [4, 3], "x": 3, "y": 4},
+                {"matrix": [4, 4], "x": 4, "y": 4.125},
+                {"matrix": [5, 3], "x": 5, "y": 4.5, "w": 2},
+
+                {"matrix": [11, 3], "x": 10, "y": 4.5, "w": 2},
+                {"matrix": [10, 2], "x": 12, "y": 4.125},
+                {"matrix": [10, 3], "x": 13, "y": 4},
+                {"matrix": [10, 4], "x": 14, "y": 4.125},
+                {"matrix": [10, 5], "x": 15, "y": 4.375},
+                {"matrix": [10, 6], "x": 16, "y": 4.375},
+
+                {"matrix": [5, 0], "x": 5, "y": 5.5, "h": 1.5},
+                {"matrix": [5, 1], "x": 6, "y": 5.5, "h": 1.5},
+                {"matrix": [5, 2], "x": 7, "y": 5.5, "h": 1.5},
+
+                {"matrix": [11, 4], "x": 9, "y": 5.5, "h": 1.5},
+                {"matrix": [11, 5], "x": 10, "y": 5.5, "h": 1.5},
+                {"matrix": [11, 6], "x": 11, "y": 5.5, "h": 1.5}
+            ]
+        }
+    }
+}
diff --git a/src/keymap.c b/src/keymap.c
deleted file mode 100644
index 35b6d5d..0000000
--- a/src/keymap.c
+++ /dev/null
@@ -1,572 +0,0 @@
-/*
- * Moonlander Layout
- *
- * Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
- * SPDX-License-Identifier: AGPL-3.0-or-later
- *
- * This file is part of Moonlander Layout.
- *
- * You should have received a copy of the License along with this program.
- * If not, see <https://www.gnu.org/licenses/agpl.txt>.
- */
-
-#include QMK_KEYBOARD_H
-#include "version.h"
-#define MOON_LED_LEVEL LED_LEVEL
-#define ML_SAFE_RANGE SAFE_RANGE
-
-enum custom_keycodes {
-  RGB_SLD = ML_SAFE_RANGE,
-  ST_MACRO_0,
-  ST_MACRO_1,
-  ST_MACRO_2,
-  ST_MACRO_3,
-  ST_MACRO_4,
-  ST_MACRO_5,
-  ST_MACRO_6,
-  ST_MACRO_7,
-};
-
-enum tap_dance_codes {
-  DANCE_0,
-  DANCE_1,
-  DANCE_2,
-  DANCE_3,
-  DANCE_4,
-};
-
-// clang-format off
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [0] = LAYOUT_moonlander(
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, QK_BOOT,                                        QK_BOOT,        KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    TG(5),          KC_QUOTE,       KC_COMMA,       LT(9,KC_DOT),   KC_P,           KC_Y,           KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_F,           KC_G,           LT(9,KC_C),     KC_R,           KC_L,           TG(5),
-    MO(7),          KC_A,           KC_O,           KC_E,           KC_U,           KC_I,           MO(8),                                                                          MO(8),          KC_D,           KC_H,           KC_T,           KC_N,           KC_S,           MO(7),
-    KC_LEFT_SHIFT,  KC_SCLN,        KC_Q,           KC_J,           KC_K,           KC_X,                                           KC_B,           KC_M,           KC_W,           KC_V,           KC_Z,           KC_RIGHT_SHIFT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_LEFT,        KC_RIGHT,       LALT(LGUI(LCTL(LSFT(KC_T)))),                                                                                                LALT(LGUI(LCTL(LSFT(KC_K)))),KC_UP,          KC_DOWN,        KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    MO(3),          MO(4),          MO(6),                          KC_TRANSPARENT, MO(1),          MO(2)
-  ),
-  [1] = LAYOUT_moonlander(
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, LALT(LGUI(LCTL(LSFT(KC_R)))),LALT(LGUI(LCTL(LSFT(KC_P)))),LALT(LGUI(LCTL(LSFT(KC_Q)))),LALT(LGUI(LCTL(LSFT(KC_S)))),KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, LALT(LGUI(LCTL(LSFT(KC_L)))),LALT(LGUI(LCTL(LSFT(KC_M)))),LALT(LGUI(LCTL(LSFT(KC_N)))),LALT(LGUI(LCTL(LSFT(KC_O)))),KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, LALT(LGUI(LCTL(LSFT(KC_I)))),LALT(LGUI(LCTL(LSFT(KC_H)))),LALT(LGUI(LCTL(LSFT(KC_G)))),KC_TRANSPARENT, LALT(LGUI(LCTL(LSFT(KC_A)))),KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, LALT(LGUI(LCTL(LSFT(KC_W)))),LALT(LGUI(LCTL(LSFT(KC_V)))),LALT(LGUI(LCTL(LSFT(KC_U)))),KC_TRANSPARENT,                                                                 KC_TRANSPARENT, LALT(LGUI(LCTL(LSFT(KC_B)))),LALT(LGUI(LCTL(LSFT(KC_D)))),LALT(LGUI(LCTL(LSFT(KC_F)))),LALT(LGUI(LCTL(LSFT(KC_E)))),LALT(LGUI(LCTL(LSFT(KC_C)))),KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, LALT(LGUI(LCTL(LSFT(KC_J)))),KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                                                                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT
-  ),
-  [2] = LAYOUT_moonlander(
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, OSM(MOD_RSFT),  OSM(MOD_RGUI),  OSM(MOD_RCTL),  OSM(MOD_RALT),  KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, OSM(MOD_LSFT),  OSM(MOD_LGUI),  OSM(MOD_LCTL),  OSM(MOD_LALT),  KC_TRANSPARENT, KC_TRANSPARENT,                                                                 KC_TRANSPARENT, KC_TAB,         KC_SPACE,       KC_BSPC,        KC_ENTER,       KC_ESCAPE,      KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                                                                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT
-  ),
-  [3] = LAYOUT_moonlander(
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_GRAVE,       KC_EXLM,        KC_DLR,         KC_PERC,        CW_TOGG,        KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_AT,          KC_HASH,        KC_AMPR,        KC_ASTR,        KC_QUES,        KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_LABK,        KC_LBRC,        KC_LPRN,        KC_LCBR,        TD(DANCE_0),    KC_TRANSPARENT,                                                                 KC_TRANSPARENT, KC_TILD,        TD(DANCE_1),    TD(DANCE_2),    TD(DANCE_3),    KC_PLUS,        KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_RABK,        KC_RBRC,        KC_RPRN,        KC_RCBR,        KC_TRANSPARENT,                                 KC_CIRC,        KC_BSLS,        KC_COMMA,       TD(DANCE_4),    KC_PIPE,        KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                                                                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT
-  ),
-  [4] = LAYOUT_moonlander(
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_F1,          KC_F2,          KC_F3,          KC_F4,          KC_F5,          KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_1,           KC_2,           KC_3,           KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_F6,          KC_F7,          KC_F8,          KC_F9,          KC_F10,         KC_TRANSPARENT,                                                                 KC_TRANSPARENT, KC_0,           KC_4,           KC_5,           KC_6,           KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_F11,         KC_F12,         KC_F13,         KC_F14,         KC_F15,                                         KC_TRANSPARENT, KC_7,           KC_8,           KC_9,           KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                                                                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT
-  ),
-  [5] = LAYOUT_moonlander(
-    KC_TRANSPARENT, KC_TRANSPARENT,     KC_TRANSPARENT,    KC_TRANSPARENT,      KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, QK_BOOT,
-    KC_TRANSPARENT, KC_TRANSPARENT,     KC_MS_BTN2,        KC_MS_BTN3,          KC_MS_BTN1,     KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_MS_BTN1,     KC_MS_BTN3,     KC_MS_BTN2,     KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_MS_WH_UP,        QK_MOUSE_WHEEL_UP, QK_MOUSE_WHEEL_DOWN, KC_MS_WH_LEFT,  KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_MS_LEFT,     KC_MS_DOWN,     KC_MS_UP,       KC_MS_RIGHT,    KC_TRANSPARENT,
-    KC_TRANSPARENT, LCTL(LSFT(KC_TAB)), LALT(LCTL(KC_R)),  LCTL(KC_T),          LCTL(KC_TAB),   KC_TRANSPARENT,                                                 KC_TRANSPARENT, KC_WWW_BACK,    KC_TRANSPARENT, KC_WWW_HOME,    KC_WWW_FORWARD, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT,     KC_TRANSPARENT,    KC_TRANSPARENT,      KC_TRANSPARENT, KC_TRANSPARENT,                                                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT,     KC_TRANSPARENT,    KC_TRANSPARENT,      KC_TRANSPARENT, KC_TRANSPARENT
-  ),
-  [6] = LAYOUT_moonlander(
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, LALT(LCTL(LSFT(KC_3))),LALT(LCTL(LSFT(KC_2))),LALT(LCTL(LSFT(KC_1))),KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, LALT(LGUI(LCTL(LSFT(KC_1)))),LALT(LGUI(LCTL(LSFT(KC_2)))),LALT(LGUI(LCTL(LSFT(KC_3)))),KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, LALT(LCTL(LSFT(KC_6))),LALT(LCTL(LSFT(KC_5))),LALT(LCTL(LSFT(KC_4))),LALT(LCTL(LSFT(KC_0))),KC_TRANSPARENT,                                                                 KC_TRANSPARENT, LALT(LGUI(LCTL(LSFT(KC_0)))),LALT(LGUI(LCTL(LSFT(KC_4)))),LALT(LGUI(LCTL(LSFT(KC_5)))),LALT(LGUI(LCTL(LSFT(KC_6)))),KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, LALT(LCTL(LSFT(KC_9))),LALT(LCTL(LSFT(KC_8))),LALT(LCTL(LSFT(KC_7))),KC_TRANSPARENT,                                 KC_TRANSPARENT, LALT(LGUI(LCTL(LSFT(KC_7)))),LALT(LGUI(LCTL(LSFT(KC_8)))),LALT(LGUI(LCTL(LSFT(KC_9)))),KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                                                                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT
-  ),
-  [7] = LAYOUT_moonlander(
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, ST_MACRO_0,     ST_MACRO_1,     KC_TRANSPARENT, ST_MACRO_2,     KC_TRANSPARENT, KC_TRANSPARENT,                                                                 KC_TRANSPARENT, KC_TRANSPARENT, ST_MACRO_3,     KC_TRANSPARENT, ST_MACRO_4,     ST_MACRO_5,     KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                                                                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT
-  ),
-  [8] = LAYOUT_moonlander(
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, ST_MACRO_6,     KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, ST_MACRO_7,     KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                                                                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT
-  ),
-  [9] = LAYOUT_moonlander(
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, UC(0x201C),        KC_TRANSPARENT, KC_TRANSPARENT, UC(0x201D),        KC_TRANSPARENT, KC_TRANSPARENT,                                                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                                                                                                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,
-    KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT,                 KC_TRANSPARENT, KC_TRANSPARENT, KC_TRANSPARENT
-  ),
-};
-// clang-format on
-
-extern rgb_config_t rgb_matrix_config;
-
-void keyboard_post_init_user(void) { rgb_matrix_enable(); }
-
-// clang-format off
-const uint8_t PROGMEM ledmap[][RGB_MATRIX_LED_COUNT][3] = {
-    [0] = { {0,255,255}, {86,255,128}, {86,255,128}, {172,255,255}, {215,255,128}, {0,255,255}, {27,255,255}, {86,255,128}, {172,255,255}, {215,255,128}, {0,255,255}, {27,255,255}, {86,255,128}, {172,255,255}, {215,255,128}, {0,255,255}, {27,255,255}, {86,255,128}, {172,255,255}, {215,255,128}, {0,255,255}, {27,255,255}, {43,255,255}, {172,255,255}, {215,255,128}, {0,255,255}, {27,255,255}, {86,255,128}, {172,255,255}, {0,255,255}, {27,255,255}, {27,255,255}, {0,245,245}, {0,245,245}, {0,245,245}, {0,0,0}, {0,255,255}, {86,255,128}, {86,255,128}, {172,255,255}, {215,255,128}, {0,255,255}, {27,255,255}, {86,255,128}, {172,255,255}, {215,255,128}, {0,255,255}, {27,255,255}, {86,255,128}, {172,255,255}, {215,255,128}, {0,255,255}, {27,255,255}, {86,255,128}, {172,255,255}, {215,255,128}, {0,255,255}, {27,255,255}, {43,255,255}, {172,255,255}, {215,255,128}, {0,255,255}, {27,255,255}, {86,255,128}, {172,255,255}, {0,255,255}, {27,255,255}, {27,255,255}, {0,245,245}, {0,245,245}, {0,245,245}, {0,0,0} },
-
-    [1] = { {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,245,245}, {0,245,245}, {0,245,245}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,245,245}, {131,255,255}, {0,245,245}, {0,0,0} },
-
-    [2] = { {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,245,245}, {0,245,245}, {0,245,245}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {131,255,255}, {0,245,245}, {0,245,245}, {0,0,0} },
-
-    [3] = { {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {131,255,255}, {0,245,245}, {0,245,245}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,245,245}, {0,245,245}, {0,245,245}, {0,0,0} },
-
-    [4] = { {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,245,245}, {131,255,255}, {0,245,245}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,245,245}, {0,245,245}, {0,245,245}, {0,0,0} },
-
-    [5] = { {0,0,0}, {131,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,245,245}, {0,245,245}, {0,245,245}, {0,245,245}, {0,0,0}, {131,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,245,245}, {0,245,245}, {0,245,245}, {0,245,245} },
-
-    [6] = { {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,245,245}, {0,245,245}, {131,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,245,245}, {0,245,245}, {0,245,245}, {0,0,0} },
-
-    [7] = { {0,0,0}, {0,0,0}, {131,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {215,255,128}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {215,255,128}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {215,255,128}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {131,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {215,255,128}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {215,255,128}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {215,255,128}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0} },
-
-    [8] = { {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {215,255,128}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {131,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {215,255,128}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {131,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0} },
-
-    [9] = { {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {131,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {131,255,255}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}, {0,0,0} },
-};
-// clang-format on
-
-void set_layer_color(int layer) {
-  for (int i = 0; i < RGB_MATRIX_LED_COUNT; i++) {
-    HSV hsv = {
-        .h = pgm_read_byte(&ledmap[layer][i][0]),
-        .s = pgm_read_byte(&ledmap[layer][i][1]),
-        .v = pgm_read_byte(&ledmap[layer][i][2]),
-    };
-    if (!hsv.h && !hsv.s && !hsv.v) {
-      rgb_matrix_set_color(i, 0, 0, 0);
-    } else {
-      RGB rgb = hsv_to_rgb(hsv);
-      float f = (float)rgb_matrix_config.hsv.v / UINT8_MAX;
-      rgb_matrix_set_color(i, f * rgb.r, f * rgb.g, f * rgb.b);
-    }
-  }
-}
-
-bool rgb_matrix_indicators_user(void) {
-  if (keyboard_config.disable_layer_led) {
-    return false;
-  }
-  switch (biton32(layer_state)) {
-  case 0:
-    set_layer_color(0);
-    break;
-  case 1:
-    set_layer_color(1);
-    break;
-  case 2:
-    set_layer_color(2);
-    break;
-  case 3:
-    set_layer_color(3);
-    break;
-  case 4:
-    set_layer_color(4);
-    break;
-  case 5:
-    set_layer_color(5);
-    break;
-  case 6:
-    set_layer_color(6);
-    break;
-  case 7:
-    set_layer_color(7);
-    break;
-  case 8:
-    set_layer_color(8);
-    break;
-  case 9:
-    set_layer_color(9);
-    break;
-  default:
-    if (rgb_matrix_get_flags() == LED_FLAG_NONE)
-      rgb_matrix_set_color_all(0, 0, 0);
-    break;
-  }
-  return true;
-}
-
-// clang-format off
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  switch (keycode) {
-    case ST_MACRO_0:
-    if (record->event.pressed) {
-      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE)) SS_DELAY(100) SS_TAP(X_A));
-    }
-    break;
-    case ST_MACRO_1:
-    if (record->event.pressed) {
-      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE)) SS_DELAY(100) SS_TAP(X_O));
-    }
-    break;
-    case ST_MACRO_2:
-    if (record->event.pressed) {
-      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE)) SS_DELAY(100) SS_TAP(X_U));
-    }
-    break;
-    case ST_MACRO_3:
-    if (record->event.pressed) {
-      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE)) SS_DELAY(100) SS_LSFT(SS_TAP(X_U)));
-    }
-    break;
-    case ST_MACRO_4:
-    if (record->event.pressed) {
-      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE)) SS_DELAY(100) SS_LSFT(SS_TAP(X_O)));
-    }
-    break;
-    case ST_MACRO_5:
-    if (record->event.pressed) {
-      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE)) SS_DELAY(100) SS_LSFT(SS_TAP(X_A)));
-    }
-    break;
-    case ST_MACRO_6:
-    if (record->event.pressed) {
-      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_TAP(X_O) SS_DELAY(100) SS_TAP(X_A));
-    }
-    break;
-    case ST_MACRO_7:
-    if (record->event.pressed) {
-      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_TAP(X_O) SS_DELAY(100) SS_LSFT(SS_TAP(X_A)));
-    }
-    break;
-
-    case RGB_SLD:
-        if (record->event.pressed) {
-            rgblight_mode(1);
-        }
-        return false;
-  }
-  return true;
-}
-// clang-format on
-
-typedef struct {
-  bool is_press_action;
-  uint8_t step;
-} tap;
-
-enum {
-  SINGLE_TAP = 1,
-  SINGLE_HOLD,
-  DOUBLE_TAP,
-  DOUBLE_HOLD,
-  DOUBLE_SINGLE_TAP,
-  MORE_TAPS
-};
-
-static tap dance_state[5];
-
-uint8_t dance_step(tap_dance_state_t *state);
-
-uint8_t dance_step(tap_dance_state_t *state) {
-  if (state->count == 1) {
-    if (state->interrupted || !state->pressed)
-      return SINGLE_TAP;
-    else
-      return SINGLE_HOLD;
-  } else if (state->count == 2) {
-    if (state->interrupted)
-      return DOUBLE_SINGLE_TAP;
-    else if (state->pressed)
-      return DOUBLE_HOLD;
-    else
-      return DOUBLE_TAP;
-  }
-  return MORE_TAPS;
-}
-
-void on_dance_0(tap_dance_state_t *state, void *user_data);
-void dance_0_finished(tap_dance_state_t *state, void *user_data);
-void dance_0_reset(tap_dance_state_t *state, void *user_data);
-
-void on_dance_0(tap_dance_state_t *state, void *user_data) {
-  if (state->count == 3) {
-    tap_code16(KC_SCLN);
-    tap_code16(KC_SCLN);
-    tap_code16(KC_SCLN);
-  }
-  if (state->count > 3) {
-    tap_code16(KC_SCLN);
-  }
-}
-
-void dance_0_finished(tap_dance_state_t *state, void *user_data) {
-  dance_state[0].step = dance_step(state);
-  switch (dance_state[0].step) {
-  case SINGLE_TAP:
-    register_code16(KC_SCLN);
-    break;
-  case SINGLE_HOLD:
-    register_code16(KC_COLN);
-    break;
-  case DOUBLE_TAP:
-    register_code16(KC_SCLN);
-    register_code16(KC_SCLN);
-    break;
-  case DOUBLE_SINGLE_TAP:
-    tap_code16(KC_SCLN);
-    register_code16(KC_SCLN);
-  }
-}
-
-void dance_0_reset(tap_dance_state_t *state, void *user_data) {
-  wait_ms(10);
-  switch (dance_state[0].step) {
-  case SINGLE_TAP:
-    unregister_code16(KC_SCLN);
-    break;
-  case SINGLE_HOLD:
-    unregister_code16(KC_COLN);
-    break;
-  case DOUBLE_TAP:
-    unregister_code16(KC_SCLN);
-    break;
-  case DOUBLE_SINGLE_TAP:
-    unregister_code16(KC_SCLN);
-    break;
-  }
-  dance_state[0].step = 0;
-}
-void on_dance_1(tap_dance_state_t *state, void *user_data);
-void dance_1_finished(tap_dance_state_t *state, void *user_data);
-void dance_1_reset(tap_dance_state_t *state, void *user_data);
-
-void on_dance_1(tap_dance_state_t *state, void *user_data) {
-  if (state->count == 3) {
-    tap_code16(KC_SLASH);
-    tap_code16(KC_SLASH);
-    tap_code16(KC_SLASH);
-  }
-  if (state->count > 3) {
-    tap_code16(KC_SLASH);
-  }
-}
-
-void dance_1_finished(tap_dance_state_t *state, void *user_data) {
-  dance_state[1].step = dance_step(state);
-  switch (dance_state[1].step) {
-  case SINGLE_TAP:
-    register_code16(KC_SLASH);
-    break;
-  case SINGLE_HOLD:
-    register_code16(KC_BSLS);
-    break;
-  case DOUBLE_TAP:
-    register_code16(KC_SLASH);
-    register_code16(KC_SLASH);
-    break;
-  case DOUBLE_SINGLE_TAP:
-    tap_code16(KC_SLASH);
-    register_code16(KC_SLASH);
-  }
-}
-
-void dance_1_reset(tap_dance_state_t *state, void *user_data) {
-  wait_ms(10);
-  switch (dance_state[1].step) {
-  case SINGLE_TAP:
-    unregister_code16(KC_SLASH);
-    break;
-  case SINGLE_HOLD:
-    unregister_code16(KC_BSLS);
-    break;
-  case DOUBLE_TAP:
-    unregister_code16(KC_SLASH);
-    break;
-  case DOUBLE_SINGLE_TAP:
-    unregister_code16(KC_SLASH);
-    break;
-  }
-  dance_state[1].step = 0;
-}
-void on_dance_2(tap_dance_state_t *state, void *user_data);
-void dance_2_finished(tap_dance_state_t *state, void *user_data);
-void dance_2_reset(tap_dance_state_t *state, void *user_data);
-
-void on_dance_2(tap_dance_state_t *state, void *user_data) {
-  if (state->count == 3) {
-    tap_code16(KC_MINUS);
-    tap_code16(KC_MINUS);
-    tap_code16(KC_MINUS);
-  }
-  if (state->count > 3) {
-    tap_code16(KC_MINUS);
-  }
-}
-
-void dance_2_finished(tap_dance_state_t *state, void *user_data) {
-  dance_state[2].step = dance_step(state);
-  switch (dance_state[2].step) {
-  case SINGLE_TAP:
-    register_code16(KC_MINUS);
-    break;
-  case SINGLE_HOLD:
-    register_code16(KC_UNDS);
-    break;
-  case DOUBLE_TAP:
-    register_code16(KC_MINUS);
-    register_code16(KC_MINUS);
-    break;
-  case DOUBLE_SINGLE_TAP:
-    tap_code16(KC_MINUS);
-    register_code16(KC_MINUS);
-  }
-}
-
-void dance_2_reset(tap_dance_state_t *state, void *user_data) {
-  wait_ms(10);
-  switch (dance_state[2].step) {
-  case SINGLE_TAP:
-    unregister_code16(KC_MINUS);
-    break;
-  case SINGLE_HOLD:
-    unregister_code16(KC_UNDS);
-    break;
-  case DOUBLE_TAP:
-    unregister_code16(KC_MINUS);
-    break;
-  case DOUBLE_SINGLE_TAP:
-    unregister_code16(KC_MINUS);
-    break;
-  }
-  dance_state[2].step = 0;
-}
-void on_dance_3(tap_dance_state_t *state, void *user_data);
-void dance_3_finished(tap_dance_state_t *state, void *user_data);
-void dance_3_reset(tap_dance_state_t *state, void *user_data);
-
-void on_dance_3(tap_dance_state_t *state, void *user_data) {
-  if (state->count == 3) {
-    tap_code16(KC_QUOTE);
-    tap_code16(KC_QUOTE);
-    tap_code16(KC_QUOTE);
-  }
-  if (state->count > 3) {
-    tap_code16(KC_QUOTE);
-  }
-}
-
-void dance_3_finished(tap_dance_state_t *state, void *user_data) {
-  dance_state[3].step = dance_step(state);
-  switch (dance_state[3].step) {
-  case SINGLE_TAP:
-    register_code16(KC_QUOTE);
-    break;
-  case SINGLE_HOLD:
-    register_code16(KC_DQUO);
-    break;
-  case DOUBLE_TAP:
-    register_code16(KC_QUOTE);
-    register_code16(KC_QUOTE);
-    break;
-  case DOUBLE_SINGLE_TAP:
-    tap_code16(KC_QUOTE);
-    register_code16(KC_QUOTE);
-  }
-}
-
-void dance_3_reset(tap_dance_state_t *state, void *user_data) {
-  wait_ms(10);
-  switch (dance_state[3].step) {
-  case SINGLE_TAP:
-    unregister_code16(KC_QUOTE);
-    break;
-  case SINGLE_HOLD:
-    unregister_code16(KC_DQUO);
-    break;
-  case DOUBLE_TAP:
-    unregister_code16(KC_QUOTE);
-    break;
-  case DOUBLE_SINGLE_TAP:
-    unregister_code16(KC_QUOTE);
-    break;
-  }
-  dance_state[3].step = 0;
-}
-void on_dance_4(tap_dance_state_t *state, void *user_data);
-void dance_4_finished(tap_dance_state_t *state, void *user_data);
-void dance_4_reset(tap_dance_state_t *state, void *user_data);
-
-void on_dance_4(tap_dance_state_t *state, void *user_data) {
-  if (state->count == 3) {
-    tap_code16(KC_EQUAL);
-    tap_code16(KC_EQUAL);
-    tap_code16(KC_EQUAL);
-  }
-  if (state->count > 3) {
-    tap_code16(KC_EQUAL);
-  }
-}
-
-void dance_4_finished(tap_dance_state_t *state, void *user_data) {
-  dance_state[4].step = dance_step(state);
-  switch (dance_state[4].step) {
-  case SINGLE_TAP:
-    register_code16(KC_EQUAL);
-    break;
-  case SINGLE_HOLD:
-    register_code16(KC_PLUS);
-    break;
-  case DOUBLE_TAP:
-    register_code16(KC_EQUAL);
-    register_code16(KC_EQUAL);
-    break;
-  case DOUBLE_SINGLE_TAP:
-    tap_code16(KC_EQUAL);
-    register_code16(KC_EQUAL);
-  }
-}
-
-void dance_4_reset(tap_dance_state_t *state, void *user_data) {
-  wait_ms(10);
-  switch (dance_state[4].step) {
-  case SINGLE_TAP:
-    unregister_code16(KC_EQUAL);
-    break;
-  case SINGLE_HOLD:
-    unregister_code16(KC_PLUS);
-    break;
-  case DOUBLE_TAP:
-    unregister_code16(KC_EQUAL);
-    break;
-  case DOUBLE_SINGLE_TAP:
-    unregister_code16(KC_EQUAL);
-    break;
-  }
-  dance_state[4].step = 0;
-}
-
-tap_dance_action_t tap_dance_actions[] = {
-    [DANCE_0] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_0, dance_0_finished,
-                                             dance_0_reset),
-    [DANCE_1] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_1, dance_1_finished,
-                                             dance_1_reset),
-    [DANCE_2] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_2, dance_2_finished,
-                                             dance_2_reset),
-    [DANCE_3] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_3, dance_3_finished,
-                                             dance_3_reset),
-    [DANCE_4] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_4, dance_4_finished,
-                                             dance_4_reset),
-};
diff --git a/src/keymaps/soispha/config.h b/src/keymaps/soispha/config.h
new file mode 100644
index 0000000..2b1d36a
--- /dev/null
+++ b/src/keymaps/soispha/config.h
@@ -0,0 +1,44 @@
+// LTeX: language=off
+
+/*
+ * Moonlander Layout
+ *
+ * Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This file is part of Moonlander Layout.
+ *
+ * You should have received a copy of the License along with this program.
+ * If not, see <https://www.gnu.org/licenses/agpl.txt>.
+ */
+
+/*
+  Set any config.h overrides for your specific keymap here.
+  See config.h options at
+  https://docs.qmk.fm/#/config_options?id=the-configh-file
+*/
+
+#define DEBOUNCE 8
+
+#define USB_SUSPEND_WAKEUP_DELAY 0
+#define LAYER_STATE_16BIT
+
+#define UNICODE_SELECTED_MODES UNICODE_MODE_LINUX
+
+#define MOUSEKEY_DELAY 0
+#define MOUSEKEY_INTERVAL 20
+#define MOUSEKEY_MAX_SPEED 7
+#define MOUSEKEY_TIME_TO_MAX 60
+#define MOUSEKEY_WHEEL_DELAY 400
+#define MOUSEKEY_WHEEL_INTERVAL MOUSEKEY_INTERVAL
+#define MOUSEKEY_WHEEL_MAX_SPEED MOUSEKEY_MAX_SPEED
+#define MOUSEKEY_WHEEL_TIME_TO_MAX MOUSEKEY_TIME_TO_MAX
+
+// maybe?
+// #define MOUSEKEY_INTERVAL 20
+// #define MOUSEKEY_DELAY 0
+// #define MOUSEKEY_TIME_TO_MAX 60
+// #define MOUSEKEY_MAX_SPEED 7
+// #define MOUSEKEY_WHEEL_DELAY 0
+
+#define RGB_MATRIX_STARTUP_SPD 60
diff --git a/src/keymaps/soispha/keymap.c b/src/keymaps/soispha/keymap.c
new file mode 100644
index 0000000..9391212
--- /dev/null
+++ b/src/keymaps/soispha/keymap.c
@@ -0,0 +1,390 @@
+/*
+ * Moonlander Layout
+ *
+ * Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This file is part of Moonlander Layout.
+ *
+ * You should have received a copy of the License along with this program.
+ * If not, see <https://www.gnu.org/licenses/agpl.txt>.
+ */
+
+#include "layout/layout.h"
+#include "macros.h"
+#include "version.h"
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+  case VERSION_NUMBER:
+    if (record->event.pressed) {
+      SEND_STRING(QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION
+                               " (rev: " QMK_GIT_HASH ")");
+    }
+    break;
+  case ST_MACRO_0:
+    if (record->event.pressed) {
+      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE))
+                      SS_DELAY(100) SS_TAP(X_A));
+    }
+    break;
+  case ST_MACRO_1:
+    if (record->event.pressed) {
+      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE))
+                      SS_DELAY(100) SS_TAP(X_O));
+    }
+    break;
+  case ST_MACRO_2:
+    if (record->event.pressed) {
+      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE))
+                      SS_DELAY(100) SS_TAP(X_U));
+    }
+    break;
+  case ST_MACRO_3:
+    if (record->event.pressed) {
+      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE))
+                      SS_DELAY(100) SS_LSFT(SS_TAP(X_U)));
+    }
+    break;
+  case ST_MACRO_4:
+    if (record->event.pressed) {
+      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE))
+                      SS_DELAY(100) SS_LSFT(SS_TAP(X_O)));
+    }
+    break;
+  case ST_MACRO_5:
+    if (record->event.pressed) {
+      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_LSFT(SS_TAP(X_QUOTE))
+                      SS_DELAY(100) SS_LSFT(SS_TAP(X_A)));
+    }
+    break;
+  case ST_MACRO_6:
+    if (record->event.pressed) {
+      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_TAP(X_O) SS_DELAY(100)
+                      SS_TAP(X_A));
+    }
+    break;
+  case ST_MACRO_7:
+    if (record->event.pressed) {
+      SEND_STRING(SS_TAP(X_CAPS) SS_DELAY(100) SS_TAP(X_O) SS_DELAY(100)
+                      SS_LSFT(SS_TAP(X_A)));
+    }
+    break;
+
+  case RGB_SLD:
+    if (record->event.pressed) {
+      rgblight_mode(1);
+    }
+    return false;
+  }
+  return true;
+}
+
+typedef struct {
+  bool is_press_action;
+  uint8_t step;
+} tap;
+
+enum {
+  SINGLE_TAP = 1,
+  SINGLE_HOLD,
+  DOUBLE_TAP,
+  DOUBLE_HOLD,
+  DOUBLE_SINGLE_TAP,
+  MORE_TAPS
+};
+
+static tap dance_state[5];
+
+uint8_t dance_step(tap_dance_state_t *state);
+
+uint8_t dance_step(tap_dance_state_t *state) {
+  if (state->count == 1) {
+    if (state->interrupted || !state->pressed)
+      return SINGLE_TAP;
+    else
+      return SINGLE_HOLD;
+  } else if (state->count == 2) {
+    if (state->interrupted)
+      return DOUBLE_SINGLE_TAP;
+    else if (state->pressed)
+      return DOUBLE_HOLD;
+    else
+      return DOUBLE_TAP;
+  }
+  return MORE_TAPS;
+}
+
+void on_dance_0(tap_dance_state_t *state, void *user_data);
+void dance_0_finished(tap_dance_state_t *state, void *user_data);
+void dance_0_reset(tap_dance_state_t *state, void *user_data);
+
+void on_dance_0(tap_dance_state_t *state, void *user_data) {
+  if (state->count == 3) {
+    tap_code16(KC_SCLN);
+    tap_code16(KC_SCLN);
+    tap_code16(KC_SCLN);
+  }
+  if (state->count > 3) {
+    tap_code16(KC_SCLN);
+  }
+}
+
+void dance_0_finished(tap_dance_state_t *state, void *user_data) {
+  dance_state[0].step = dance_step(state);
+  switch (dance_state[0].step) {
+  case SINGLE_TAP:
+    register_code16(KC_SCLN);
+    break;
+  case SINGLE_HOLD:
+    register_code16(KC_COLN);
+    break;
+  case DOUBLE_TAP:
+    register_code16(KC_SCLN);
+    register_code16(KC_SCLN);
+    break;
+  case DOUBLE_SINGLE_TAP:
+    tap_code16(KC_SCLN);
+    register_code16(KC_SCLN);
+  }
+}
+
+void dance_0_reset(tap_dance_state_t *state, void *user_data) {
+  wait_ms(10);
+  switch (dance_state[0].step) {
+  case SINGLE_TAP:
+    unregister_code16(KC_SCLN);
+    break;
+  case SINGLE_HOLD:
+    unregister_code16(KC_COLN);
+    break;
+  case DOUBLE_TAP:
+    unregister_code16(KC_SCLN);
+    break;
+  case DOUBLE_SINGLE_TAP:
+    unregister_code16(KC_SCLN);
+    break;
+  }
+  dance_state[0].step = 0;
+}
+void on_dance_1(tap_dance_state_t *state, void *user_data);
+void dance_1_finished(tap_dance_state_t *state, void *user_data);
+void dance_1_reset(tap_dance_state_t *state, void *user_data);
+
+void on_dance_1(tap_dance_state_t *state, void *user_data) {
+  if (state->count == 3) {
+    tap_code16(KC_SLASH);
+    tap_code16(KC_SLASH);
+    tap_code16(KC_SLASH);
+  }
+  if (state->count > 3) {
+    tap_code16(KC_SLASH);
+  }
+}
+
+void dance_1_finished(tap_dance_state_t *state, void *user_data) {
+  dance_state[1].step = dance_step(state);
+  switch (dance_state[1].step) {
+  case SINGLE_TAP:
+    register_code16(KC_SLASH);
+    break;
+  case SINGLE_HOLD:
+    register_code16(KC_BSLS);
+    break;
+  case DOUBLE_TAP:
+    register_code16(KC_SLASH);
+    register_code16(KC_SLASH);
+    break;
+  case DOUBLE_SINGLE_TAP:
+    tap_code16(KC_SLASH);
+    register_code16(KC_SLASH);
+  }
+}
+
+void dance_1_reset(tap_dance_state_t *state, void *user_data) {
+  wait_ms(10);
+  switch (dance_state[1].step) {
+  case SINGLE_TAP:
+    unregister_code16(KC_SLASH);
+    break;
+  case SINGLE_HOLD:
+    unregister_code16(KC_BSLS);
+    break;
+  case DOUBLE_TAP:
+    unregister_code16(KC_SLASH);
+    break;
+  case DOUBLE_SINGLE_TAP:
+    unregister_code16(KC_SLASH);
+    break;
+  }
+  dance_state[1].step = 0;
+}
+void on_dance_2(tap_dance_state_t *state, void *user_data);
+void dance_2_finished(tap_dance_state_t *state, void *user_data);
+void dance_2_reset(tap_dance_state_t *state, void *user_data);
+
+void on_dance_2(tap_dance_state_t *state, void *user_data) {
+  if (state->count == 3) {
+    tap_code16(KC_MINUS);
+    tap_code16(KC_MINUS);
+    tap_code16(KC_MINUS);
+  }
+  if (state->count > 3) {
+    tap_code16(KC_MINUS);
+  }
+}
+
+void dance_2_finished(tap_dance_state_t *state, void *user_data) {
+  dance_state[2].step = dance_step(state);
+  switch (dance_state[2].step) {
+  case SINGLE_TAP:
+    register_code16(KC_MINUS);
+    break;
+  case SINGLE_HOLD:
+    register_code16(KC_UNDS);
+    break;
+  case DOUBLE_TAP:
+    register_code16(KC_MINUS);
+    register_code16(KC_MINUS);
+    break;
+  case DOUBLE_SINGLE_TAP:
+    tap_code16(KC_MINUS);
+    register_code16(KC_MINUS);
+  }
+}
+
+void dance_2_reset(tap_dance_state_t *state, void *user_data) {
+  wait_ms(10);
+  switch (dance_state[2].step) {
+  case SINGLE_TAP:
+    unregister_code16(KC_MINUS);
+    break;
+  case SINGLE_HOLD:
+    unregister_code16(KC_UNDS);
+    break;
+  case DOUBLE_TAP:
+    unregister_code16(KC_MINUS);
+    break;
+  case DOUBLE_SINGLE_TAP:
+    unregister_code16(KC_MINUS);
+    break;
+  }
+  dance_state[2].step = 0;
+}
+void on_dance_3(tap_dance_state_t *state, void *user_data);
+void dance_3_finished(tap_dance_state_t *state, void *user_data);
+void dance_3_reset(tap_dance_state_t *state, void *user_data);
+
+void on_dance_3(tap_dance_state_t *state, void *user_data) {
+  if (state->count == 3) {
+    tap_code16(KC_QUOTE);
+    tap_code16(KC_QUOTE);
+    tap_code16(KC_QUOTE);
+  }
+  if (state->count > 3) {
+    tap_code16(KC_QUOTE);
+  }
+}
+
+void dance_3_finished(tap_dance_state_t *state, void *user_data) {
+  dance_state[3].step = dance_step(state);
+  switch (dance_state[3].step) {
+  case SINGLE_TAP:
+    register_code16(KC_QUOTE);
+    break;
+  case SINGLE_HOLD:
+    register_code16(KC_DQUO);
+    break;
+  case DOUBLE_TAP:
+    register_code16(KC_QUOTE);
+    register_code16(KC_QUOTE);
+    break;
+  case DOUBLE_SINGLE_TAP:
+    tap_code16(KC_QUOTE);
+    register_code16(KC_QUOTE);
+  }
+}
+
+void dance_3_reset(tap_dance_state_t *state, void *user_data) {
+  wait_ms(10);
+  switch (dance_state[3].step) {
+  case SINGLE_TAP:
+    unregister_code16(KC_QUOTE);
+    break;
+  case SINGLE_HOLD:
+    unregister_code16(KC_DQUO);
+    break;
+  case DOUBLE_TAP:
+    unregister_code16(KC_QUOTE);
+    break;
+  case DOUBLE_SINGLE_TAP:
+    unregister_code16(KC_QUOTE);
+    break;
+  }
+  dance_state[3].step = 0;
+}
+void on_dance_4(tap_dance_state_t *state, void *user_data);
+void dance_4_finished(tap_dance_state_t *state, void *user_data);
+void dance_4_reset(tap_dance_state_t *state, void *user_data);
+
+void on_dance_4(tap_dance_state_t *state, void *user_data) {
+  if (state->count == 3) {
+    tap_code16(KC_EQUAL);
+    tap_code16(KC_EQUAL);
+    tap_code16(KC_EQUAL);
+  }
+  if (state->count > 3) {
+    tap_code16(KC_EQUAL);
+  }
+}
+
+void dance_4_finished(tap_dance_state_t *state, void *user_data) {
+  dance_state[4].step = dance_step(state);
+  switch (dance_state[4].step) {
+  case SINGLE_TAP:
+    register_code16(KC_EQUAL);
+    break;
+  case SINGLE_HOLD:
+    register_code16(KC_PLUS);
+    break;
+  case DOUBLE_TAP:
+    register_code16(KC_EQUAL);
+    register_code16(KC_EQUAL);
+    break;
+  case DOUBLE_SINGLE_TAP:
+    tap_code16(KC_EQUAL);
+    register_code16(KC_EQUAL);
+  }
+}
+
+void dance_4_reset(tap_dance_state_t *state, void *user_data) {
+  wait_ms(10);
+  switch (dance_state[4].step) {
+  case SINGLE_TAP:
+    unregister_code16(KC_EQUAL);
+    break;
+  case SINGLE_HOLD:
+    unregister_code16(KC_PLUS);
+    break;
+  case DOUBLE_TAP:
+    unregister_code16(KC_EQUAL);
+    break;
+  case DOUBLE_SINGLE_TAP:
+    unregister_code16(KC_EQUAL);
+    break;
+  }
+  dance_state[4].step = 0;
+}
+
+tap_dance_action_t tap_dance_actions[] = {
+    [DANCE_0] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_0, dance_0_finished,
+                                             dance_0_reset),
+    [DANCE_1] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_1, dance_1_finished,
+                                             dance_1_reset),
+    [DANCE_2] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_2, dance_2_finished,
+                                             dance_2_reset),
+    [DANCE_3] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_3, dance_3_finished,
+                                             dance_3_reset),
+    [DANCE_4] = ACTION_TAP_DANCE_FN_ADVANCED(on_dance_4, dance_4_finished,
+                                             dance_4_reset),
+};
diff --git a/src/keymaps/soispha/layout/keymap.h b/src/keymaps/soispha/layout/keymap.h
new file mode 100644
index 0000000..d4b183a
--- /dev/null
+++ b/src/keymaps/soispha/layout/keymap.h
@@ -0,0 +1,92 @@
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [0] = LAYOUT_moonlander( // Dvorak
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        QK_BOOT,           QK_BOOT,       KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          VERSION_NUMBER,
+    TG(5),         KC_QUOTE,           KC_COMMA,          LT(9,KC_DOT),        KC_P,          KC_Y,         KK_TP,             KK_TP,         KC_F,        KC_G,         LT(9,KC_C),  KC_R,        KC_L,           TG(5),
+    MO(7),         KC_A,               KC_O,              KC_E,                KC_U,          KC_I,         MO(8),             MO(8),         KC_D,        KC_H,         KC_T,        KC_N,        KC_S,           MO(7),
+    KC_LEFT_SHIFT, KC_SCLN,            KC_Q,              KC_J,                KC_K,          KC_X,                                           KC_B,        KC_M,         KC_W,        KC_V,        KC_Z,           KC_RIGHT_SHIFT,
+    KK_TP,         KK_TP,              KK_TP,             KC_LEFT,             KC_RIGHT,      HYPR(KC_T),                                     HYPR(KC_K),  KC_UP,        KC_DOWN,     KK_TP,       KK_TP,          KC_RIGHT_SHIFT,
+                                                          MO(3),               MO(4),         MO(6),                                          KK_TP,       MO(1),        MO(2)
+
+  ),
+  [1] = LAYOUT_moonlander( // River
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         RV_SP_NHK,   RV_SP_NRG_BR, RV_SP_KPSS,  RV_SP_SGNL,  KK_TP,          KK_TP,
+    KK_TP,         RV_SC_SHOT,         RV_PAUSE,          RV_TG_MSC,           RV_RUN,        KK_TP,        KK_TP,             KK_TP,         RV_TG_FLOAT, RV_TG_FL_SC,  RV_ZOOM_VW,  KK_TP,       RV_EXIT,        KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             RV_MV_VW_PRVS_TG,    RV_MV_PRVS_TG, RV_MV_OT_NXT, KK_TP,             KK_TP,         RV_VW_CLSE,  RV_VW_NXT,    RV_SWP_NXT,  RV_SWP_PRVS, RV_VW_PRVS,     KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       RV_SEND_OUT,  KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+                                                          KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP
+
+  ),
+  [2] = LAYOUT_moonlander( // Modifier
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         OSM(MOD_RSFT),      OSM(MOD_RGUI),     OSM(MOD_RCTL),       OSM(MOD_RALT), KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         OSM(MOD_LSFT),      OSM(MOD_LGUI),     OSM(MOD_LCTL),       OSM(MOD_LALT), KK_TP,        KK_TP,             KK_TP,         KC_TAB,      KC_SPACE,     KC_BSPC,     KC_ENTER,    KC_ESCAPE,      KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+                                                          KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP
+
+  ),
+  [3] = LAYOUT_moonlander( // Symbols
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KC_GRAVE,           KC_EXLM,           KC_DLR,              KC_PERC,       CW_TOGG,      KK_TP,             KK_TP,         KC_AT,       KC_HASH,      KC_AMPR,     KC_ASTR,     KC_QUES,        KK_TP,
+    KK_TP,         KC_LABK,            KC_LBRC,           KC_LPRN,             KC_LCBR,       TD(DANCE_0),  KK_TP,             KK_TP,         KC_TILD,     TD(DANCE_1),  TD(DANCE_2), TD(DANCE_3), KC_PLUS,        KK_TP,
+    KK_TP,         KC_RABK,            KC_RBRC,           KC_RPRN,             KC_RCBR,       KK_TP,                                          KC_CIRC,     KC_BSLS,      KC_COMMA,    TD(DANCE_4), KC_PIPE,        KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+                                                          KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP
+
+  ),
+  [4] = LAYOUT_moonlander( // Numbers
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KC_F1,              KC_F2,             KC_F3,               KC_F4,         KC_F5,        KK_TP,             KK_TP,         KK_TP,       KC_1,         KC_2,        KC_3,        KK_TP,          KK_TP,
+    KK_TP,         KC_F6,              KC_F7,             KC_F8,               KC_F9,         KC_F10,       KK_TP,             KK_TP,         KC_0,        KC_4,         KC_5,        KC_6,        KK_TP,          KK_TP,
+    KK_TP,         KC_F11,             KC_F12,            KC_F13,              KC_F14,        KC_F15,                                         KK_TP,       KC_7,         KC_8,        KC_9,        KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+                                                          KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP
+
+  ),
+  [5] = LAYOUT_moonlander( // Media
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          QK_BOOT,
+    KK_TP,         KK_TP,              KC_MS_BTN2,        KC_MS_BTN3,          KC_MS_BTN1,    KK_TP,        KK_TP,             KK_TP,         KK_TP,       KC_MS_BTN1,   KC_MS_BTN3,  KC_MS_BTN2,  KK_TP,          KK_TP,
+    KK_TP,         KC_MS_WH_UP,        QK_MOUSE_WHEEL_UP, QK_MOUSE_WHEEL_DOWN, KC_MS_WH_LEFT, KK_TP,        KK_TP,             KK_TP,         KK_TP,       KC_MS_LEFT,   KC_MS_DOWN,  KC_MS_UP,    KC_MS_RIGHT,    KK_TP,
+    KK_TP,         LCTL(LSFT(KC_TAB)), LALT(LCTL(KC_R)),  LCTL(KC_T),          LCTL(KC_TAB),  KK_TP,                                          KK_TP,       KC_WWW_BACK,  KK_TP,       KC_WWW_HOME, KC_WWW_FORWARD, KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+                                                          KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP
+
+  ),
+  [6] = LAYOUT_moonlander( // River Tag Movement
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              MEH(KC_3),         MEH(KC_2),           MEH(KC_1),     KK_TP,        KK_TP,             KK_TP,         KK_TP,       HYPR(KC_1),   HYPR(KC_2),  HYPR(KC_3),  KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              MEH(KC_6),         MEH(KC_5),           MEH(KC_4),     MEH(KC_0),    KK_TP,             KK_TP,         HYPR(KC_0),  HYPR(KC_4),   HYPR(KC_5),  HYPR(KC_6),  KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              MEH(KC_9),         MEH(KC_8),           MEH(KC_7),     KK_TP,                                          KK_TP,       HYPR(KC_7),   HYPR(KC_8),  HYPR(KC_9),  KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+                                                          KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP
+
+  ),
+  [7] = LAYOUT_moonlander( // German characters
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         ST_MACRO_0,         ST_MACRO_1,        KK_TP,               ST_MACRO_2,    KK_TP,        KK_TP,             KK_TP,         KK_TP,       ST_MACRO_3,   KK_TP,       ST_MACRO_4,  ST_MACRO_5,     KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+                                                          KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP
+
+  ),
+  [8] = LAYOUT_moonlander( // Swedish characters
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         ST_MACRO_6,         KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       ST_MACRO_7,     KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+                                                          KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP
+
+  ),
+  [9] = LAYOUT_moonlander( // Special characters
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         UC(0x201C),         KK_TP,             KK_TP,               UC(0x201D),    KK_TP,        KK_TP,             KK_TP,         KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+    KK_TP,         KK_TP,              KK_TP,             KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP,       KK_TP,       KK_TP,          KK_TP,
+                                                          KK_TP,               KK_TP,         KK_TP,                                          KK_TP,       KK_TP,        KK_TP
+
+  ),
+};
diff --git a/src/keymaps/soispha/layout/layout.h b/src/keymaps/soispha/layout/layout.h
new file mode 100644
index 0000000..4acb7f5
--- /dev/null
+++ b/src/keymaps/soispha/layout/layout.h
@@ -0,0 +1,21 @@
+/*
+ * Moonlander Layout
+ *
+ * Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ *
+ * This file is part of Moonlander Layout.
+ *
+ * You should have received a copy of the License along with this program.
+ * If not, see <https://www.gnu.org/licenses/agpl.txt>.
+ */
+
+#pragma once
+#include QMK_KEYBOARD_H
+#include "../macros.h"
+
+#define KK_TP KC_TRANSPARENT
+
+#include "keymap.h"
+
+// vim: cursorcolumn nowrap
diff --git a/src/keymaps/soispha/macros.h b/src/keymaps/soispha/macros.h
new file mode 100644
index 0000000..e337830
--- /dev/null
+++ b/src/keymaps/soispha/macros.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#include QMK_KEYBOARD_H
+
+#define ML_SAFE_RANGE SAFE_RANGE
+
+enum custom_keycodes {
+  RGB_SLD = ML_SAFE_RANGE,
+  ST_MACRO_0,
+  ST_MACRO_1,
+  ST_MACRO_2,
+  ST_MACRO_3,
+  ST_MACRO_4,
+  ST_MACRO_5,
+  ST_MACRO_6,
+  ST_MACRO_7,
+  VERSION_NUMBER,
+};
+
+enum tap_dance_codes {
+  DANCE_0,
+  DANCE_1,
+  DANCE_2,
+  DANCE_3,
+  DANCE_4,
+};
+
+// river_mappings {
+#define RV_SC_SHOT HYPR(KC_L)
+#define RV_PAUSE HYPR(KC_M)
+#define RV_TG_MSC HYPR(KC_N)
+#define RV_RUN HYPR(KC_O)
+#define RV_MV_VW_PRVS_TG HYPR(KC_W)
+#define RV_MV_PRVS_TG HYPR(KC_V)
+#define RV_MV_OT_NXT HYPR(KC_U)
+
+#define RV_SP_NHK HYPR(KC_R)
+#define RV_SP_NRG_BR HYPR(KC_P)
+#define RV_SP_KPSS HYPR(KC_Q)
+#define RV_SP_SGNL HYPR(KC_S)
+
+#define RV_TG_FLOAT HYPR(KC_I)
+#define RV_TG_FL_SC HYPR(KC_H)
+#define RV_ZOOM_VW HYPR(KC_G)
+#define RV_EXIT HYPR(KC_A)
+#define RV_VW_CLSE HYPR(KC_B)
+#define RV_VW_NXT HYPR(KC_D)
+#define RV_SWP_NXT HYPR(KC_F)
+#define RV_SWP_PRVS HYPR(KC_E)
+#define RV_VW_PRVS HYPR(KC_C)
+#define RV_SEND_OUT HYPR(KC_J)
diff --git a/src/keymaps/soispha/rgb.c b/src/keymaps/soispha/rgb.c
new file mode 100644
index 0000000..183296e
--- /dev/null
+++ b/src/keymaps/soispha/rgb.c
@@ -0,0 +1,227 @@
+#include QMK_KEYBOARD_H
+#define MOON_LED_LEVEL LED_LEVEL
+
+extern rgb_config_t rgb_matrix_config;
+
+void keyboard_post_init_user(void) { rgb_matrix_enable(); }
+
+// clang-format off
+const uint8_t PROGMEM ledmap[][RGB_MATRIX_LED_COUNT][3] = {
+    [0] = {{0, 255, 255},   {86, 255, 128},  {86, 255, 128},  {172, 255, 255},
+           {215, 255, 128}, {0, 255, 255},   {27, 255, 255},  {86, 255, 128},
+           {172, 255, 255}, {215, 255, 128}, {0, 255, 255},   {27, 255, 255},
+           {86, 255, 128},  {172, 255, 255}, {215, 255, 128}, {0, 255, 255},
+           {27, 255, 255},  {86, 255, 128},  {172, 255, 255}, {215, 255, 128},
+           {0, 255, 255},   {27, 255, 255},  {43, 255, 255},  {172, 255, 255},
+           {215, 255, 128}, {0, 255, 255},   {27, 255, 255},  {86, 255, 128},
+           {172, 255, 255}, {0, 255, 255},   {27, 255, 255},  {27, 255, 255},
+           {0, 245, 245},   {0, 245, 245},   {0, 245, 245},   {0, 0, 0},
+           {0, 255, 255},   {86, 255, 128},  {86, 255, 128},  {172, 255, 255},
+           {215, 255, 128}, {0, 255, 255},   {27, 255, 255},  {86, 255, 128},
+           {172, 255, 255}, {215, 255, 128}, {0, 255, 255},   {27, 255, 255},
+           {86, 255, 128},  {172, 255, 255}, {215, 255, 128}, {0, 255, 255},
+           {27, 255, 255},  {86, 255, 128},  {172, 255, 255}, {215, 255, 128},
+           {0, 255, 255},   {27, 255, 255},  {43, 255, 255},  {172, 255, 255},
+           {215, 255, 128}, {0, 255, 255},   {27, 255, 255},  {86, 255, 128},
+           {172, 255, 255}, {0, 255, 255},   {27, 255, 255},  {27, 255, 255},
+           {0, 245, 245},   {0, 245, 245},   {0, 245, 245},   {0, 0, 0}},
+
+    [1] = {{0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 245, 245}, {0, 245, 245},   {0, 245, 245}, {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 245, 245}, {131, 255, 255}, {0, 245, 245}, {0, 0, 0}},
+
+    [2] = {{0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 245, 245},   {0, 245, 245}, {0, 245, 245}, {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {131, 255, 255}, {0, 245, 245}, {0, 245, 245}, {0, 0, 0}},
+
+    [3] = {{0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {131, 255, 255}, {0, 245, 245}, {0, 245, 245}, {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},       {0, 0, 0},     {0, 0, 0},     {0, 0, 0},
+           {0, 245, 245},   {0, 245, 245}, {0, 245, 245}, {0, 0, 0}},
+
+    [4] = {{0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 245, 245}, {131, 255, 255}, {0, 245, 245}, {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 245, 245}, {0, 245, 245},   {0, 245, 245}, {0, 0, 0}},
+
+    [5] = {{0, 0, 0},     {131, 255, 255}, {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 245, 245}, {0, 245, 245},   {0, 245, 245}, {0, 245, 245},
+           {0, 0, 0},     {131, 255, 255}, {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},       {0, 0, 0},     {0, 0, 0},
+           {0, 245, 245}, {0, 245, 245},   {0, 245, 245}, {0, 245, 245}},
+
+    [6] = {{0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 245, 245}, {0, 245, 245}, {131, 255, 255}, {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0},     {0, 0, 0},     {0, 0, 0},       {0, 0, 0},
+           {0, 245, 245}, {0, 245, 245}, {0, 245, 245},   {0, 0, 0}},
+
+    [7] = {{0, 0, 0}, {0, 0, 0}, {131, 255, 255}, {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {215, 255, 128}, {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {215, 255, 128}, {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {215, 255, 128}, {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {131, 255, 255}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {215, 255, 128}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {215, 255, 128}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {215, 255, 128}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0},       {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}},
+
+    [8] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {215, 255, 128},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {131, 255, 255},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {215, 255, 128},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {131, 255, 255},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
+
+    [9] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {131, 255, 255}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {131, 255, 255}, {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}, {0, 0, 0},       {0, 0, 0}, {0, 0, 0},
+           {0, 0, 0}, {0, 0, 0}},
+};
+// clang-format on
+
+void set_layer_color(int layer) {
+  for (int i = 0; i < RGB_MATRIX_LED_COUNT; i++) {
+    HSV hsv = {
+        .h = pgm_read_byte(&ledmap[layer][i][0]),
+        .s = pgm_read_byte(&ledmap[layer][i][1]),
+        .v = pgm_read_byte(&ledmap[layer][i][2]),
+    };
+    if (!hsv.h && !hsv.s && !hsv.v) {
+      rgb_matrix_set_color(i, 0, 0, 0);
+    } else {
+      RGB rgb = hsv_to_rgb(hsv);
+      float f = (float)rgb_matrix_config.hsv.v / UINT8_MAX;
+      rgb_matrix_set_color(i, f * rgb.r, f * rgb.g, f * rgb.b);
+    }
+  }
+}
+
+bool rgb_matrix_indicators_user(void) {
+  if (keyboard_config.disable_layer_led) {
+    return false;
+  }
+
+  int layer = biton32(layer_state);
+  if (layer <= 9) {
+    set_layer_color(layer);
+  } else {
+    if (rgb_matrix_get_flags() == LED_FLAG_NONE) {
+      rgb_matrix_set_color_all(0, 0, 0);
+    }
+  }
+  return true;
+}
diff --git a/src/keymaps/soispha/rules.mk b/src/keymaps/soispha/rules.mk
new file mode 100644
index 0000000..c04c2d7
--- /dev/null
+++ b/src/keymaps/soispha/rules.mk
@@ -0,0 +1,31 @@
+# Moonlander Layout
+#
+# Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#
+# This file is part of Moonlander Layout.
+#
+# You should have received a copy of the License along with this program.
+# If not, see <https://www.gnu.org/licenses/agpl.txt>.
+
+# Set any rules.mk overrides for your specific keymap here.
+# See rules at https://docs.qmk.fm/#/config_options?id=the-rulesmk-file
+AUDIO_ENABLE = yes
+BOOTMAGIC_ENABLE = yes
+CAPS_WORD_ENABLE = yes
+COMMAND_ENABLE = no
+CONSOLE_ENABLE = no
+DEFERRED_EXEC_ENABLE = yes
+EXTRAKEY_ENABLE = yes
+MOUSEKEY_ENABLE = yes
+NKRO_ENABLE = yes
+RGB_MATRIX_ENABLE = yes
+SEND_STRING_ENABLE = yes
+SPACE_CADET_ENABLE = no
+SWAP_HANDS_ENABLE = yes
+TAP_DANCE_ENABLE = yes
+
+UNICODE_COMMON = yes
+UNICODE_ENABLE = yes
+
+SRC += rgb.c
diff --git a/src/ld/STM32F303xB.ld b/src/ld/STM32F303xB.ld
new file mode 100644
index 0000000..c3a8146
--- /dev/null
+++ b/src/ld/STM32F303xB.ld
@@ -0,0 +1,85 @@
+/*
+    ChibiOS - Copyright (C) 2006..2018 Giovanni Di Sirio
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+/*
+ * STM32F303xB memory setup.
+ */
+MEMORY
+{
+    flash0 (rx) : org = 0x08000000, len = 128k
+    flash1 (rx) : org = 0x00000000, len = 0
+    flash2 (rx) : org = 0x00000000, len = 0
+    flash3 (rx) : org = 0x00000000, len = 0
+    flash4 (rx) : org = 0x00000000, len = 0
+    flash5 (rx) : org = 0x00000000, len = 0
+    flash6 (rx) : org = 0x00000000, len = 0
+    flash7 (rx) : org = 0x00000000, len = 0
+    ram0   (wx) : org = 0x20000000, len = 32k
+    ram1   (wx) : org = 0x00000000, len = 0
+    ram2   (wx) : org = 0x00000000, len = 0
+    ram3   (wx) : org = 0x00000000, len = 0
+    ram4   (wx) : org = 0x10000000, len = 8k
+    ram5   (wx) : org = 0x00000000, len = 0
+    ram6   (wx) : org = 0x00000000, len = 0
+    ram7   (wx) : org = 0x00000000, len = 0
+}
+
+/* For each data/text section two region are defined, a virtual region
+   and a load region (_LMA suffix).*/
+
+/* Flash region to be used for exception vectors.*/
+REGION_ALIAS("VECTORS_FLASH", flash0);
+REGION_ALIAS("VECTORS_FLASH_LMA", flash0);
+
+/* Flash region to be used for constructors and destructors.*/
+REGION_ALIAS("XTORS_FLASH", flash0);
+REGION_ALIAS("XTORS_FLASH_LMA", flash0);
+
+/* Flash region to be used for code text.*/
+REGION_ALIAS("TEXT_FLASH", flash0);
+REGION_ALIAS("TEXT_FLASH_LMA", flash0);
+
+/* Flash region to be used for read only data.*/
+REGION_ALIAS("RODATA_FLASH", flash0);
+REGION_ALIAS("RODATA_FLASH_LMA", flash0);
+
+/* Flash region to be used for various.*/
+REGION_ALIAS("VARIOUS_FLASH", flash0);
+REGION_ALIAS("VARIOUS_FLASH_LMA", flash0);
+
+/* Flash region to be used for RAM(n) initialization data.*/
+REGION_ALIAS("RAM_INIT_FLASH_LMA", flash0);
+
+/* RAM region to be used for Main stack. This stack accommodates the processing
+   of all exceptions and interrupts.*/
+REGION_ALIAS("MAIN_STACK_RAM", ram0);
+
+/* RAM region to be used for the process stack. This is the stack used by
+   the main() function.*/
+REGION_ALIAS("PROCESS_STACK_RAM", ram0);
+
+/* RAM region to be used for data segment.*/
+REGION_ALIAS("DATA_RAM", ram0);
+REGION_ALIAS("DATA_RAM_LMA", flash0);
+
+/* RAM region to be used for BSS segment.*/
+REGION_ALIAS("BSS_RAM", ram0);
+
+/* RAM region to be used for the default heap.*/
+REGION_ALIAS("HEAP_RAM", ram0);
+
+/* Generic rules inclusion.*/
+INCLUDE rules.ld
diff --git a/src/matrix.c b/src/matrix.c
new file mode 100644
index 0000000..867fa85
--- /dev/null
+++ b/src/matrix.c
@@ -0,0 +1,211 @@
+/* Copyright 2020 ZSA Technology Labs, Inc <@zsa>
+ * Copyright 2020 Jack Humbert <jack.humb@gmail.com>
+ * Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "moonlander.h"
+#include "mcp23018.h"
+
+#pragma GCC push_options
+#pragma GCC optimize("-O3")
+/*
+#define MATRIX_ROW_PINS { B10, B11, B12, B13, B14, B15 } outputs
+#define MATRIX_COL_PINS { A0, A1, A2, A3, A6, A7, B0 }   inputs
+#define MCP23_ROW_PINS { GPB5, GBP4, GBP3, GBP2, GBP1, GBP0 }       outputs
+#define MCP23_COL_PINS { GPA0, GBA1, GBA2, GBA3, GBA4, GBA5, GBA6 } inputs
+
+ */
+/* matrix state(1:on, 0:off) */
+extern matrix_row_t matrix[MATRIX_ROWS];     // debounced values
+extern matrix_row_t raw_matrix[MATRIX_ROWS]; // raw values
+static matrix_row_t raw_matrix_right[MATRIX_ROWS];
+
+#define MCP_ROWS_PER_HAND (MATRIX_ROWS / 2)
+
+extern bool mcp23018_leds[3];
+extern bool is_launching;
+
+static uint16_t mcp23018_reset_loop;
+uint8_t         mcp23018_errors;
+
+bool io_expander_ready(void) {
+    uint8_t tx;
+    return mcp23018_read_pins(MCP23018_DEFAULT_ADDRESS, mcp23018_PORTA, &tx);
+}
+
+void matrix_init_custom(void) {
+    // outputs
+    gpio_set_pin_output(B10);
+    gpio_set_pin_output(B11);
+    gpio_set_pin_output(B12);
+    gpio_set_pin_output(B13);
+    gpio_set_pin_output(B14);
+    gpio_set_pin_output(B15);
+
+    // inputs
+    gpio_set_pin_input_low(A0);
+    gpio_set_pin_input_low(A1);
+    gpio_set_pin_input_low(A2);
+    gpio_set_pin_input_low(A3);
+    gpio_set_pin_input_low(A6);
+    gpio_set_pin_input_low(A7);
+    gpio_set_pin_input_low(B0);
+
+    mcp23018_init(MCP23018_DEFAULT_ADDRESS);
+    mcp23018_errors += !mcp23018_set_config(MCP23018_DEFAULT_ADDRESS, mcp23018_PORTA, 0b00000000);
+    mcp23018_errors += !mcp23018_set_config(MCP23018_DEFAULT_ADDRESS, mcp23018_PORTB, 0b00111111);
+
+    if (!mcp23018_errors) {
+        is_launching = true;
+    }
+}
+
+bool matrix_scan_custom(matrix_row_t current_matrix[]) {
+    bool changed = false;
+    // Attempt to reset the mcp23018 if it's not initialized
+    if (mcp23018_errors) {
+        if (++mcp23018_reset_loop > 0x1FFF) {
+            if (io_expander_ready()) {
+                // If we managed to initialize the mcp23018 - we need to reinitialize the matrix / layer state. During an electric discharge the i2c peripherals might be in a weird state. Giving a delay and resetting the MCU allows to recover from this.
+                wait_ms(200);
+                mcu_reset();
+            }
+        }
+    }
+
+    matrix_row_t data = 0;
+    // actual matrix
+    for (uint8_t row = 0; row <= MCP_ROWS_PER_HAND; row++) {
+        // strobe row
+        switch (row) {
+            case 0:
+                gpio_write_pin_high(B10);
+                break;
+            case 1:
+                gpio_write_pin_high(B11);
+                break;
+            case 2:
+                gpio_write_pin_high(B12);
+                break;
+            case 3:
+                gpio_write_pin_high(B13);
+                break;
+            case 4:
+                gpio_write_pin_high(B14);
+                break;
+            case 5:
+                gpio_write_pin_high(B15);
+                break;
+            case 6:
+                break; // Left hand has 6 rows
+        }
+
+        // Selecting the row on the right side of the keyboard.
+        if (!mcp23018_errors) {
+            // select row
+            mcp23018_errors += !mcp23018_set_output_all(MCP23018_DEFAULT_ADDRESS, (0b01111111 & ~(1 << (row))) | ((uint8_t)!mcp23018_leds[2] << 7), ((uint8_t)!mcp23018_leds[1] << 6) | ((uint8_t)!mcp23018_leds[0] << 7));
+        }
+
+        // Reading the left side of the keyboard.
+        if (row < MCP_ROWS_PER_HAND) {
+            // i2c comm incur enough wait time
+            if (mcp23018_errors) {
+                // need wait to settle pin state
+                matrix_io_delay();
+            }
+            // read col data
+            data = ((readPin(A0) << 0) | (readPin(A1) << 1) | (readPin(A2) << 2) | (readPin(A3) << 3) | (readPin(A6) << 4) | (readPin(A7) << 5) | (readPin(B0) << 6));
+            // unstrobe  row
+            switch (row) {
+                case 0:
+                    gpio_write_pin_low(B10);
+                    break;
+                case 1:
+                    gpio_write_pin_low(B11);
+                    break;
+                case 2:
+                    gpio_write_pin_low(B12);
+                    break;
+                case 3:
+                    gpio_write_pin_low(B13);
+                    break;
+                case 4:
+                    gpio_write_pin_low(B14);
+                    break;
+                case 5:
+                    gpio_write_pin_low(B15);
+                    break;
+                case 6:
+                    break;
+            }
+
+            if (current_matrix[row] != data) {
+                current_matrix[row] = data;
+                changed             = true;
+            }
+        }
+
+        // Reading the right side of the keyboard.
+        if (!mcp23018_errors) {
+            uint8_t rx;
+            mcp23018_errors += !mcp23018_read_pins(MCP23018_DEFAULT_ADDRESS, mcp23018_PORTB, &rx);
+            data = ~(rx & 0b00111111);
+        } else {
+            data = 0;
+        }
+
+        if (raw_matrix_right[row] != data) {
+            raw_matrix_right[row] = data;
+            changed               = true;
+        }
+    }
+
+    for (uint8_t row = 0; row < MCP_ROWS_PER_HAND; row++) {
+        current_matrix[11 - row] = 0;
+        for (uint8_t col = 0; col < MATRIX_COLS; col++) {
+            current_matrix[11 - row] |= ((raw_matrix_right[6 - col] & (1 << row) ? 1 : 0) << col);
+        }
+    }
+    return changed;
+}
+
+// DO NOT REMOVE
+// Needed for proper wake/sleep
+void matrix_power_up(void) {
+    bool temp_launching = is_launching;
+
+    matrix_init_custom();
+
+    is_launching = temp_launching;
+    if (!is_launching) {
+        ML_LED_1(false);
+        ML_LED_2(false);
+        ML_LED_3(false);
+        ML_LED_4(false);
+        ML_LED_5(false);
+        ML_LED_6(false);
+    }
+
+    // initialize matrix state: all keys off
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+        matrix[i] = 0;
+    }
+}
+
+bool is_transport_connected(void) {
+    return (bool)(mcp23018_errors == 0);
+}
+#pragma GCC pop_options
diff --git a/src/mcuconf.h b/src/mcuconf.h
new file mode 100644
index 0000000..43d7774
--- /dev/null
+++ b/src/mcuconf.h
@@ -0,0 +1,31 @@
+/* Copyright 2021 QMK
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include_next <mcuconf.h>
+
+// for i2c expander, and ISSI
+#undef STM32_I2C_USE_I2C1
+#define STM32_I2C_USE_I2C1 TRUE
+
+// for audio
+#undef STM32_DAC_USE_DAC1_CH1
+#define STM32_DAC_USE_DAC1_CH1 TRUE
+#undef STM32_DAC_USE_DAC1_CH2
+#define STM32_DAC_USE_DAC1_CH2 TRUE
+#undef STM32_GPT_USE_TIM6
+#define STM32_GPT_USE_TIM6 TRUE
diff --git a/src/moonlander.c b/src/moonlander.c
new file mode 100644
index 0000000..01168a1
--- /dev/null
+++ b/src/moonlander.c
@@ -0,0 +1,421 @@
+/* Copyright 2020 ZSA Technology Labs, Inc <@zsa>
+ * Copyright 2020 Jack Humbert <jack.humb@gmail.com>
+ * Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna)
+ * <drashna@live.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "moonlander.h"
+
+keyboard_config_t keyboard_config;
+
+bool mcp23018_leds[3] = {0, 0, 0};
+bool is_launching = false;
+
+#if defined(DEFERRED_EXEC_ENABLE)
+#if defined(DYNAMIC_MACRO_ENABLE)
+deferred_token dynamic_macro_token = INVALID_DEFERRED_TOKEN;
+
+static uint32_t dynamic_macro_led(uint32_t trigger_time, void *cb_arg) {
+  static bool led_state = true;
+  if (!is_launching) {
+    led_state = !led_state;
+    ML_LED_3(led_state);
+  }
+  return 100;
+}
+
+bool dynamic_macro_record_start_kb(int8_t direction) {
+  if (!dynamic_macro_record_start_user(direction)) {
+    return false;
+  }
+  if (dynamic_macro_token == INVALID_DEFERRED_TOKEN) {
+    ML_LED_3(true);
+    dynamic_macro_token = defer_exec(100, dynamic_macro_led, NULL);
+  }
+  return true;
+}
+
+bool dynamic_macro_record_end_kb(int8_t direction) {
+  if (!dynamic_macro_record_end_user(direction)) {
+    return false;
+  }
+  if (cancel_deferred_exec(dynamic_macro_token)) {
+    dynamic_macro_token = INVALID_DEFERRED_TOKEN;
+    ML_LED_3(false);
+  }
+  return false;
+}
+#endif
+
+static uint32_t startup_exec(uint32_t trigger_time, void *cb_arg) {
+  static uint8_t startup_loop = 0;
+
+  switch (startup_loop++) {
+  case 0:
+    ML_LED_1(true);
+    ML_LED_2(false);
+    ML_LED_3(false);
+    ML_LED_4(false);
+    ML_LED_5(false);
+    ML_LED_6(false);
+    break;
+  case 1:
+    ML_LED_2(true);
+    break;
+  case 2:
+    ML_LED_3(true);
+    break;
+  case 3:
+    ML_LED_4(true);
+    break;
+  case 4:
+    ML_LED_5(true);
+    break;
+  case 5:
+    ML_LED_6(true);
+    break;
+  case 6:
+    ML_LED_1(false);
+    break;
+  case 7:
+    ML_LED_2(false);
+    break;
+  case 8:
+    ML_LED_3(false);
+    break;
+  case 9:
+    ML_LED_4(false);
+    break;
+  case 10:
+    ML_LED_5(false);
+    break;
+  case 11:
+    ML_LED_6(false);
+    break;
+  case 12:
+    is_launching = false;
+    layer_state_set_kb(layer_state);
+    return 0;
+  }
+  return 250;
+}
+#endif
+
+void keyboard_pre_init_kb(void) {
+  gpio_set_pin_output(B5);
+  gpio_set_pin_output(B4);
+  gpio_set_pin_output(B3);
+
+  gpio_write_pin_low(B5);
+  gpio_write_pin_low(B4);
+  gpio_write_pin_low(B3);
+
+  keyboard_pre_init_user();
+}
+
+#if !defined(MOONLANDER_USER_LEDS)
+layer_state_t layer_state_set_kb(layer_state_t state) {
+  state = layer_state_set_user(state);
+  if (is_launching || !keyboard_config.led_level)
+    return state;
+  bool LED_1 = false;
+  bool LED_2 = false;
+  bool LED_3 = false;
+  bool LED_4 = false;
+  bool LED_5 = false;
+#if !defined(CAPS_LOCK_STATUS)
+  bool LED_6 = false;
+#endif
+
+  uint8_t layer = get_highest_layer(state);
+  switch (layer) {
+  case 1:
+    LED_1 = true;
+    LED_4 = true;
+    break;
+  case 2:
+    LED_2 = true;
+    LED_5 = true;
+    break;
+  case 3:
+    LED_3 = true;
+#if !defined(CAPS_LOCK_STATUS)
+    LED_6 = true;
+#endif
+    break;
+  case 4:
+    LED_4 = true;
+    break;
+  case 5:
+    LED_5 = true;
+    break;
+  case 6:
+#if !defined(CAPS_LOCK_STATUS)
+    LED_6 = true;
+#endif
+    break;
+  default:
+    break;
+  }
+
+  ML_LED_1(LED_1);
+  ML_LED_2(LED_2);
+  ML_LED_3(LED_3);
+  ML_LED_4(LED_4);
+  ML_LED_5(LED_5);
+#if !defined(CAPS_LOCK_STATUS)
+  ML_LED_6(LED_6);
+#endif
+
+  return state;
+}
+#endif
+
+#ifdef RGB_MATRIX_ENABLE
+// clang-format off
+const is31fl3731_led_t PROGMEM g_is31fl3731_leds[IS31FL3731_LED_COUNT] = {
+    {0, C3_2,  C1_1,  C4_2},
+    {0, C2_2,  C1_2,  C4_3},
+    {0, C2_3,  C1_3,  C3_3},
+    {0, C2_4,  C1_4,  C3_4},
+    {0, C2_5,  C1_5,  C3_5},
+    {0, C2_6,  C1_6,  C3_6},
+    {0, C2_7,  C1_7,  C3_7},
+    {0, C2_8,  C1_8,  C3_8},
+    {0, C3_1,  C2_1,  C4_1},
+
+    {0, C7_8,  C6_8,  C8_8},
+    {0, C7_7,  C6_7,  C9_8},
+    {0, C8_7,  C6_6,  C9_7},
+    {0, C8_6,  C7_6,  C9_6},
+    {0, C8_5,  C7_5,  C9_5},
+    {0, C8_4,  C7_4,  C9_4},
+    {0, C8_3,  C7_3,  C9_3},
+    {0, C8_2,  C7_2,  C9_2},
+    {0, C8_1,  C7_1,  C9_1},
+
+    {0, C3_10,  C1_9,   C4_10},
+    {0, C2_10,  C1_10,  C4_11},
+    {0, C2_11,  C1_11,  C3_11},
+    {0, C2_12,  C1_12,  C3_12},
+    {0, C2_13,  C1_13,  C3_13},
+    {0, C2_14,  C1_14,  C3_14},
+    {0, C2_15,  C1_15,  C3_15},
+    {0, C2_16,  C1_16,  C3_16},
+    {0, C3_9,   C2_9,   C4_9},
+
+    {0, C7_16,  C6_16,  C8_16},
+    {0, C7_15,  C6_15,  C9_16},
+    {0, C8_15,  C6_14,  C9_15},
+    {0, C8_10,  C7_10,  C9_10},
+    {0, C8_9,   C7_9,   C9_9},
+    {0, C8_11,  C7_11,  C9_11},
+    {0, C8_12,  C7_12,  C9_12},
+    {0, C8_13,  C7_13,  C9_13},
+    {0, C8_14,  C7_14,  C9_14},
+
+    {1, C3_2,  C1_1,  C4_2},
+    {1, C2_2,  C1_2,  C4_3},
+    {1, C2_3,  C1_3,  C3_3},
+    {1, C2_4,  C1_4,  C3_4},
+    {1, C2_5,  C1_5,  C3_5},
+    {1, C2_6,  C1_6,  C3_6},
+    {1, C2_7,  C1_7,  C3_7},
+    {1, C2_8,  C1_8,  C3_8},
+    {1, C3_1,  C2_1,  C4_1},
+
+    {1, C7_8,  C6_8,  C8_8},
+    {1, C7_7,  C6_7,  C9_8},
+    {1, C8_7,  C6_6,  C9_7},
+    {1, C8_6,  C7_6,  C9_6},
+    {1, C8_5,  C7_5,  C9_5},
+    {1, C8_4,  C7_4,  C9_4},
+    {1, C8_3,  C7_3,  C9_3},
+    {1, C8_2,  C7_2,  C9_2},
+    {1, C8_1,  C7_1,  C9_1},
+
+    {1, C3_10,  C1_9,   C4_10},
+    {1, C2_10,  C1_10,  C4_11},
+    {1, C2_11,  C1_11,  C3_11},
+    {1, C2_12,  C1_12,  C3_12},
+    {1, C2_13,  C1_13,  C3_13},
+    {1, C2_14,  C1_14,  C3_14},
+    {1, C2_15,  C1_15,  C3_15},
+    {1, C2_16,  C1_16,  C3_16},
+    {1, C3_9,   C2_9,   C4_9},
+
+    {1, C7_16,  C6_16,  C8_16},
+    {1, C7_15,  C6_15,  C9_16},
+    {1, C8_15,  C6_14,  C9_15},
+    {1, C8_10,  C7_10,  C9_10},
+    {1, C8_9,   C7_9,   C9_9},
+    {1, C8_11,  C7_11,  C9_11},
+    {1, C8_12,  C7_12,  C9_12},
+    {1, C8_13,  C7_13,  C9_13},
+    {1, C8_14,  C7_14,  C9_14},
+};
+// clang-format on
+#endif
+
+#ifdef AUDIO_ENABLE
+bool music_mask_kb(uint16_t keycode) {
+  switch (keycode) {
+  case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
+  case QK_TO ... QK_TO_MAX:
+  case QK_MOMENTARY ... QK_MOMENTARY_MAX:
+  case QK_DEF_LAYER ... QK_DEF_LAYER_MAX:
+  case QK_PERSISTENT_DEF_LAYER ... QK_PERSISTENT_DEF_LAYER_MAX:
+  case QK_TOGGLE_LAYER ... QK_TOGGLE_LAYER_MAX:
+  case QK_ONE_SHOT_LAYER ... QK_ONE_SHOT_LAYER_MAX:
+  case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE_MAX:
+  case QK_LAYER_MOD ... QK_LAYER_MOD_MAX:
+  case QK_ONE_SHOT_MOD ... QK_ONE_SHOT_MOD_MAX:
+  case QK_MOD_TAP ... QK_MOD_TAP_MAX:
+  case AU_ON ... AU_PREV:
+  case QK_BOOT:
+  case QK_CLEAR_EEPROM:
+    return false;
+  default:
+    return music_mask_user(keycode);
+  }
+}
+#endif
+
+#ifdef SWAP_HANDS_ENABLE
+// swap-hands action needs a matrix to define the swap
+// clang-format off
+const keypos_t PROGMEM hand_swap_config[MATRIX_ROWS][MATRIX_COLS] = {
+    /* Left hand, matrix positions */
+    {{6,6}, {5,6}, {4,6}, {3,6}, {2,6}, {1,6},{0,6}},
+    {{6,7}, {5,7}, {4,7}, {3,7}, {2,7}, {1,7},{0,7}},
+    {{6,8}, {5,8}, {4,8}, {3,8}, {2,8}, {1,8},{0,8}},
+    {{6,9}, {5,9}, {4,9}, {3,9}, {2,9}, {1,9},{0,9}},
+    {{6,10},{5,10},{4,10},{3,10},{2,10},{1,10},{0,10}},
+    {{6,11},{5,11},{4,11},{3,11},{2,11},{1,11},{0,11}},
+    /* Right hand, matrix positions */
+    {{6,0}, {5,0}, {4,0}, {3,0}, {2,0}, {1,0},{0,0}},
+    {{6,1}, {5,1}, {4,1}, {3,1}, {2,1}, {1,1},{0,1}},
+    {{6,2}, {5,2}, {4,2}, {3,2}, {2,2}, {1,2},{0,2}},
+    {{6,3}, {5,3}, {4,3}, {3,3}, {2,3}, {1,3},{0,3}},
+    {{6,4}, {5,4}, {4,4}, {3,4}, {2,4}, {1,4},{0,4}},
+    {{6,5}, {5,5}, {4,5}, {3,5}, {2,5}, {1,5},{0,5}},
+};
+// clang-format on
+#endif
+
+#if defined(AUDIO_ENABLE) && defined(MUSIC_MAP)
+// clang-format off
+__attribute__ ((weak))
+const uint8_t music_map[MATRIX_ROWS][MATRIX_COLS] = {
+    {58, 59, 60, 61, 62, 63, 64},
+    {44, 45, 46, 47, 48, 49, 50},
+    {30, 31, 32, 33, 34, 35, 36},
+    {18, 19, 20, 21, 22, 23,  0},
+    { 8,  9, 10, 11, 12,  0,  0},
+    { 0,  1,  2,  3,  0,  0,  0},
+    {65, 66, 67, 68, 69, 70, 71},
+    {51, 52, 53, 54, 55, 56, 57},
+    {37, 38, 39, 40, 41, 42, 43},
+    { 0, 24, 25, 26, 27, 28, 29},
+    { 0,  0, 13, 14, 15, 16, 17},
+    { 0,  0,  0,  4,  5,  6,  7}
+};
+// clang-format on
+#endif
+
+#ifdef CAPS_LOCK_STATUS
+void led_update_ports(led_t led_state) { ML_LED_6(led_state.caps_lock); }
+#endif
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+  if (!process_record_user(keycode, record)) {
+    return false;
+  }
+  switch (keycode) {
+#if !defined(MOONLANDER_USER_LEDS)
+  case LED_LEVEL:
+    if (record->event.pressed) {
+      keyboard_config.led_level ^= 1;
+      eeconfig_update_kb(keyboard_config.raw);
+      if (keyboard_config.led_level) {
+        layer_state_set_kb(layer_state);
+      } else {
+        ML_LED_1(false);
+        ML_LED_2(false);
+        ML_LED_3(false);
+        ML_LED_4(false);
+        ML_LED_5(false);
+        ML_LED_6(false);
+      }
+    }
+    break;
+#endif
+#ifdef RGB_MATRIX_ENABLE
+  case TOGGLE_LAYER_COLOR:
+    if (record->event.pressed) {
+      keyboard_config.disable_layer_led ^= 1;
+      if (keyboard_config.disable_layer_led)
+        rgb_matrix_set_color_all(0, 0, 0);
+      eeconfig_update_kb(keyboard_config.raw);
+    }
+    break;
+  case QK_RGB_MATRIX_TOGGLE:
+    if (record->event.pressed) {
+      switch (rgb_matrix_get_flags()) {
+      case LED_FLAG_ALL: {
+        rgb_matrix_set_flags(LED_FLAG_NONE);
+        keyboard_config.rgb_matrix_enable = false;
+        rgb_matrix_set_color_all(0, 0, 0);
+      } break;
+      default: {
+        rgb_matrix_set_flags(LED_FLAG_ALL);
+        keyboard_config.rgb_matrix_enable = true;
+      } break;
+      }
+      eeconfig_update_kb(keyboard_config.raw);
+    }
+    return false;
+#endif
+  }
+  return true;
+}
+
+void keyboard_post_init_kb(void) {
+  keyboard_config.raw = eeconfig_read_kb();
+
+  if (!keyboard_config.led_level && !keyboard_config.led_level_res) {
+    keyboard_config.led_level = true;
+    keyboard_config.led_level_res = 0b11;
+    eeconfig_update_kb(keyboard_config.raw);
+  }
+#ifdef RGB_MATRIX_ENABLE
+  rgb_matrix_enable_noeeprom();
+#endif
+#if defined(DEFERRED_EXEC_ENABLE)
+  is_launching = true;
+  defer_exec(500, startup_exec, NULL);
+#endif
+  keyboard_post_init_user();
+}
+
+void eeconfig_init_kb(void) { // EEPROM is getting reset!
+  keyboard_config.raw = 0;
+  keyboard_config.rgb_matrix_enable = true;
+  keyboard_config.led_level = true;
+  keyboard_config.led_level_res = 0b11;
+  eeconfig_update_kb(keyboard_config.raw);
+  eeconfig_init_user();
+}
diff --git a/src/moonlander.h b/src/moonlander.h
new file mode 100644
index 0000000..3e1f39a
--- /dev/null
+++ b/src/moonlander.h
@@ -0,0 +1,58 @@
+/* Copyright 2020 ZSA Technology Labs, Inc <@zsa>
+ * Copyright 2020 Jack Humbert <jack.humb@gmail.com>
+ * Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#pragma once
+
+#include "quantum.h"
+
+extern bool mcp23018_leds[];
+
+#define MCP23018_DEFAULT_ADDRESS 0b0100000
+
+#define ML_LED_1(status) gpio_write_pin(B5, (bool)status)
+#define ML_LED_2(status) gpio_write_pin(B4, (bool)status)
+#define ML_LED_3(status) gpio_write_pin(B3, (bool)status)
+
+#define ML_LED_4(status) mcp23018_leds[0] = (bool)status
+#define ML_LED_5(status) mcp23018_leds[1] = (bool)status
+#define ML_LED_6(status) mcp23018_leds[2] = (bool)status
+
+enum planck_ez_keycodes {
+    TOGGLE_LAYER_COLOR = QK_KB_0,
+    LED_LEVEL,
+};
+
+#ifndef WEBUSB_ENABLE
+#    define WEBUSB_PAIR KC_NO
+#endif
+
+typedef union {
+  uint32_t raw;
+  struct {
+    bool         disable_layer_led   :1;
+    bool         rgb_matrix_enable   :1;
+    bool         led_level           :1;
+    uint8_t      led_level_res       :2; // DO NOT REMOVE
+  };
+} keyboard_config_t;
+
+extern keyboard_config_t keyboard_config;
+
+bool is_transport_connected(void);
diff --git a/src/readme.md b/src/readme.md
new file mode 100644
index 0000000..546681e
--- /dev/null
+++ b/src/readme.md
@@ -0,0 +1,58 @@
+# Moonlander
+
+![Moonlander](https://i.imgur.com/st2PCgph.png)
+
+A next-gen split, ergonomic keyboard with an active left side, USB type C, integrated wrist rest, and a thumb cluster that can move.
+
+
+* Keyboard Maintainer: [drashna](https://github.com/drashna), [ZSA](https://github.com/zsa/)
+* Hardware Supported: Moonlander MK 1 (STM32F303xC)
+* Hardware Availability: [ZSA Store](https://zsa.io/moonlander/)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make zsa/moonlander:default
+
+Flashing example for this keyboard:
+
+    make zsa/moonlander:default:flash
+
+See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
+
+
+## Moonlander Customization
+
+### Indicator LEDs
+
+There are 6 functions for enabling and disabling the LEDs on the top of the boards. The functions are `ML_LED_1(bool)` through `ML_LED_6(bool)`, with the first LED being the left most LED on the left hand, and the sixth LED being the right most LED on the right side. 
+
+By default, the Indicator LEDs are used to indicate the layer state for the keyboard.  If you wish to change this (and indicate caps/num/scroll lock status instead), then define `MOONLANDER_USER_LEDS` in your `config.h` file. 
+
+
+### Oryx Configuration
+
+To enable the features from Oryx (ZSA's Configurator), either compile the `default` keymap, or add `#define ORYX_CONFIGURATOR` to your `config.h` file.
+
+This enables the front Indicator LEDs, and the `TOGGLE_LAYER_COLOR` keycode.  The `TOGGLE_LAYER_COLOR` keycode toggles the customized LED map configured on Oryx. 
+
+### RGB Matrix Features
+
+If you're using the Smart LED (layer indication) feature from the Oryx Configurator, you want to make sure that you enable these options by adding `#define ORYX_CONFIGURATOR` to your keymap's `config.h`. 
+
+This changes the `RGB_TOG` keycode so that it will toggle the lights on and off, in a way that will allow the Smart LEDs to continue to work, even with the rest of the LEDs turned off. 
+
+Additionally, a new keycode has been added to toggle the Smart LEDs.  Use `TOGGLE_LAYER_COLOR`, if you aren't already.
+
+### Detecting split / Gaming mode
+
+To make it extra gaming friendly, you can configure what happens when you disconnect the right half. This is especially useful when using gaming unfriendly layers or layouts (e.g. home row mods, dvorak, colemak).
+
+Example for enabling a specific layer while right side is disconnected:
+
+```
+void housekeeping_task_user(void) {
+    if (!is_transport_connected()) {
+        // set layer
+    }
+}
+```
diff --git a/src/rules.mk b/src/rules.mk
index b1c5823..d2018cf 100644
--- a/src/rules.mk
+++ b/src/rules.mk
@@ -1,22 +1,7 @@
-# Moonlander Layout
-#
-# Copyright (C) 2024 Benedikt Peetz <benedikt.peetz@b-peetz.de>
-# SPDX-License-Identifier: AGPL-3.0-or-later
-#
-# This file is part of Moonlander Layout.
-#
-# You should have received a copy of the License along with this program.
-# If not, see <https://www.gnu.org/licenses/agpl.txt>.
+CUSTOM_MATRIX = lite
 
-# Set any rules.mk overrides for your specific keymap here.
-# See rules at https://docs.qmk.fm/#/config_options?id=the-rulesmk-file
-CONSOLE_ENABLE = no
-COMMAND_ENABLE = no
-TAP_DANCE_ENABLE = yes
-SPACE_CADET_ENABLE = no
-CAPS_WORD_ENABLE = yes
+VPATH += drivers/gpio
+SRC += matrix.c mcp23018.c
+I2C_DRIVER_REQUIRED = yes
 
-MOUSEKEY_ENABLE = yes
-
-UNICODE_COMMON = yes
-UNICODE_ENABLE = yes
+MCU_LDSCRIPT = STM32F303xB