[Keyboard] Flinguenheld (#19661)

10 files changed, 1835 insertions, 0 deletions

diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/config.h b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/config.h
new file mode 100644
index 0000000000..c147d5e67f
--- /dev/null
+++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/config.h
@@ -0,0 +1,75 @@
+/* Copyright 2023 Florent Linguenheld (@FLinguenheld)
+ *
+ * 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
+
+/* Flash */
+#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET              // Activates the double-tap behavior
+#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET_TIMEOUT 200U // Timeout window in ms in which the double tap can occur.
+
+/* OLED */
+#undef OLED_FONT_H
+#define OLED_FONT_H "./oled/glcdfont.c"
+
+#define  OLED_TIMEOUT 25000
+#define OLED_BRIGHTNESS 60 // Protect my eyesss
+#define SPLIT_LAYER_STATE_ENABLE
+#define SPLIT_MODS_ENABLE
+#define SPLIT_OLED_ENABLE
+
+/* Auto shift ♥ */
+#define AUTO_SHIFT_TIMEOUT 115
+
+/* Redefine CTRL + space (See space cadet shift) */
+#define LCPO_KEYS KC_LCTL, KC_TRNS, KC_SPC
+
+/* Unicode */
+// #define UNICODE_SELECTED_MODES UC_LNX
+#define UNICODE_SELECTED_MODES UNICODE_MODE_LINUX
+
+/* leader */
+#define LEADER_PER_KEY_TIMING
+#define LEADER_TIMEOUT 280
+#define LEADER_NO_TIMEOUT
+
+/* Mouse */
+#define MK_3_SPEED
+#define MK_MOMENTARY_ACCEL
+
+#define MK_C_OFFSET_0 1
+#define MK_C_INTERVAL_0 12
+
+#define MK_C_OFFSET_1 4
+#define MK_C_INTERVAL_1 18
+
+#define MK_C_OFFSET_UNMOD 13
+#define MK_C_INTERVAL_UNMOD 15
+
+#define MK_C_OFFSET_2 25
+#define MK_C_INTERVAL_2 10
+
+
+#define MK_W_OFFSET_0 1
+#define MK_W_INTERVAL_0 160
+
+#define MK_W_OFFSET_1 2
+#define MK_W_INTERVAL_1 120
+
+#define MK_W_OFFSET_UNMOD 4
+#define MK_W_INTERVAL_UNMOD 70
+
+#define MK_W_OFFSET_2 10
+#define MK_W_INTERVAL_2 30
diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/auto_shift.c b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/auto_shift.c
new file mode 100644
index 0000000000..d6bd3818b4
--- /dev/null
+++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/auto_shift.c
@@ -0,0 +1,199 @@
+// Copyright 2023 Florent Linguenheld (@FLinguenheld)
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include QMK_KEYBOARD_H
+#include "keycodes.h"
+
+/* Only for basis letters
+   Exceptions like Tab or Enter */
+bool get_auto_shifted_key(uint16_t keycode, keyrecord_t *record) {
+
+    switch (keycode) {
+
+        case KC_TAB:
+        case KC_ENT:
+
+        // --
+        case KC_A:
+        case KC_B:
+        case KC_C:
+        case KC_D:
+        case KC_E:
+        case KC_F:
+        case KC_G:
+        case KC_H:
+        case KC_I:
+        case KC_J:
+        case KC_K:
+        case KC_L:
+        case KC_M:
+        case KC_N:
+        case KC_O:
+        case KC_P:
+        case KC_Q:
+        case KC_R:
+        case KC_S:
+        case KC_T:
+        case KC_U:
+        case KC_V:
+        case KC_W:
+        case KC_X:
+        case KC_Y:
+        case KC_Z:
+
+            return true;
+    }
+
+    return get_custom_auto_shifted_key(keycode, record);
+}
+
+
+/* Custom auto shift
+   I use this instead of tap dance because double tap is horrible
+   Add here the letter or the custom enum, then add in press_user and press_release the actions */
+bool get_custom_auto_shifted_key(uint16_t keycode, keyrecord_t *record) {
+    switch(keycode) {
+
+        case KC_BSPC:
+        case KC_LABK:  // Easy indent with vim
+        case KC_RABK:
+
+        /* French */
+        case CS_E_ACUTE:
+
+        case CS_A_GRAVE:
+        case CS_E_GRAVE:
+        case CS_I_GRAVE:
+        case CS_O_GRAVE:
+        case CS_U_GRAVE:
+
+        case CS_A_CIRCUMFLEX:
+        case CS_E_CIRCUMFLEX:
+        case CS_I_CIRCUMFLEX:
+        case CS_O_CIRCUMFLEX:
+        case CS_U_CIRCUMFLEX:
+
+        case CS_A_DIAERESIS:
+        case CS_E_DIAERESIS:
+        case CS_I_DIAERESIS:
+        case CS_O_DIAERESIS:
+        case CS_U_DIAERESIS:
+        case CS_Y_DIAERESIS:
+
+        case CS_C_CEDILLA:
+        case CS_AE:
+        case CS_OE:
+
+            return true;
+
+        default:
+            return false;
+    }
+}
+
+void autoshift_press_user(uint16_t keycode, bool shifted, keyrecord_t *record) {
+    switch(keycode) {
+
+        case KC_BSPC:
+            register_code16((!shifted) ? KC_BSPC : KC_DEL);
+            break;
+
+        case KC_LABK:
+            if (shifted) { send_unicode_string("<<"); }
+            else         { send_unicode_string("<"); } break;
+
+        case KC_RABK:
+            if (shifted) { send_unicode_string(">>"); }
+            else         { send_unicode_string(">"); } break;
+
+        /* French
+           Release is not necessary with 'send_unicode_string()' */
+        case CS_E_ACUTE:
+            if (shifted) { send_unicode_string("É"); }
+            else         { send_unicode_string("é"); } break;
+
+        case CS_A_GRAVE:
+            if (shifted) { send_unicode_string("À"); }
+            else         { send_unicode_string("à"); } break;
+        case CS_E_GRAVE:
+            if (shifted) { send_unicode_string("È"); }
+            else         { send_unicode_string("è"); } break;
+        case CS_I_GRAVE:
+            if (shifted) { send_unicode_string("Ì"); }
+            else         { send_unicode_string("ì"); } break;
+        case CS_O_GRAVE:
+            if (shifted) { send_unicode_string("Ò"); }
+            else         { send_unicode_string("ò"); } break;
+        case CS_U_GRAVE:
+            if (shifted) { send_unicode_string("Ù"); }
+            else         { send_unicode_string("ù"); } break;
+
+        case CS_A_CIRCUMFLEX:
+            if (shifted) { send_unicode_string("Â"); }
+            else         { send_unicode_string("â"); }  break;
+        case CS_E_CIRCUMFLEX:
+            if (shifted) { send_unicode_string("Ê"); }
+            else         { send_unicode_string("ê"); }  break;
+        case CS_I_CIRCUMFLEX:
+            if (shifted) { send_unicode_string("Î"); }
+            else         { send_unicode_string("î"); }  break;
+        case CS_O_CIRCUMFLEX:
+            if (shifted) { send_unicode_string("Ô"); }
+            else         { send_unicode_string("ô"); }  break;
+        case CS_U_CIRCUMFLEX:
+            if (shifted) { send_unicode_string("Û"); }
+            else         { send_unicode_string("û"); }  break;
+
+        case CS_A_DIAERESIS:
+            if (shifted) { send_unicode_string("Ä"); }
+            else         { send_unicode_string("ä"); }  break;
+        case CS_E_DIAERESIS:
+            if (shifted) { send_unicode_string("Ë"); }
+            else         { send_unicode_string("ë"); }  break;
+        case CS_I_DIAERESIS:
+            if (shifted) { send_unicode_string("Ï"); }
+            else         { send_unicode_string("ï"); }  break;
+        case CS_O_DIAERESIS:
+            if (shifted) { send_unicode_string("Ö"); }
+            else         { send_unicode_string("ö"); }  break;
+        case CS_U_DIAERESIS:
+            if (shifted) { send_unicode_string("Ü"); }
+            else         { send_unicode_string("ü"); }  break;
+        case CS_Y_DIAERESIS:
+            if (shifted) { send_unicode_string("Ÿ"); }
+            else         { send_unicode_string("ÿ"); }  break;
+
+        case CS_C_CEDILLA:
+            if (shifted) { send_unicode_string("Ç"); }
+            else         { send_unicode_string("ç"); } break;
+        case CS_AE:
+            if (shifted) { send_unicode_string("Æ"); }
+            else         { send_unicode_string("æ"); } break;
+        case CS_OE:
+            if (shifted) { send_unicode_string("Œ"); }
+            else         { send_unicode_string("œ"); } break;
+
+
+        default:
+            if (shifted) {
+                add_weak_mods(MOD_BIT(KC_LSFT));
+            }
+            /* & 0xFF gets the Tap key for Tap Holds, required when using Retro Shift */
+            register_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode);
+    }
+}
+
+void autoshift_release_user(uint16_t keycode, bool shifted, keyrecord_t *record) {
+    switch(keycode) {
+
+        case KC_BSPC:
+            unregister_code16((!shifted) ? KC_BSPC : KC_DEL);
+            break;
+
+        default:
+            /* & 0xFF gets the Tap key for Tap Holds, required when using Retro Shift
+               The IS_RETRO check isn't really necessary here, always using
+               keycode & 0xFF would be fine. */
+            unregister_code16((IS_RETRO(keycode)) ? keycode & 0xFF : keycode);
+    }
+}
diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/combo.c b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/combo.c
new file mode 100644
index 0000000000..e5b897dc62
--- /dev/null
+++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/combo.c
@@ -0,0 +1,275 @@
+// Copyright 2023 Florent Linguenheld (@FLinguenheld)
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include QMK_KEYBOARD_H
+#include "keycodes.h"
+
+/* How to :
+        - Add an entry in the enum
+        - Create a new sequence of keys
+        - Link the enum to this sequence in the key_combos table
+
+   For macros :
+        - Same steps
+        - And add the macro in the process_combo_event() function
+*/
+
+enum combos {
+    LEADER,
+    BOOTLOADER,
+
+    LAYER_ADJUST,
+    LAYER_FN,
+    LAYER_LEFT_HAND,
+
+    /* French */
+    E_ACUTE,
+    C_CEDILLA,
+    E_A,
+    E_O,
+
+    A_GRAVE,
+    E_GRAVE,
+    I_GRAVE,
+    O_GRAVE,
+    U_GRAVE,
+
+    A_CIRCUMFLEX,
+    E_CIRCUMFLEX,
+    I_CIRCUMFLEX,
+    O_CIRCUMFLEX,
+    U_CIRCUMFLEX,
+
+    A_DIAERESIS,
+    E_DIAERESIS,
+    I_DIAERESIS,
+    O_DIAERESIS,
+    U_DIAERESIS,
+    Y_DIAERESIS,
+
+    /* -- */
+    AMPERSAND,
+    AT_SIGN,
+    BACKSLASH,
+    CIRCUMFLEX,
+    COLON,
+    DOLLAR,
+    EQUAL,
+    EXCLAMATION_MARK,
+    GRAVE,
+    HASH,
+    MINUS,
+    PERCENT,
+    PIPE,
+    PLUS,
+    QUESTION_MARK,
+    QUOTE,
+    QUOTE_DOUBLE,
+    SEMICOLON,
+    SLASH,
+    STAR,
+    TILDE,
+    UNDERSCORE,
+
+    ANGLE_BRACKET_LEFT,
+    ANGLE_BRACKET_RIGHT,
+
+    BRACKET_LEFT,
+    BRACKET_RIGHT,
+    CURLY_BRACKET_LEFT,
+    CURLY_BRACKET_RIGHT,
+    PARENTHESIS_LEFT,
+    PARENTHESIS_RIGHT,
+
+    /* -- */
+    ALT_SHIFT,
+    CONTROL_SHIFT,
+    CONTROL_ALT,
+    CONTROL_SHIFT_ALT,
+    RIGHT_ALT,
+
+    /* One hand special */
+    CONTROL_RIGHT,
+    CONTROL_SHIFT_RIGHT,
+
+    // DEL_LEFT,
+    SHIFT_LEFT,
+    ALTGR_LEFT,
+    CONTROL_SHIFT_LEFT,
+
+    /* Just to replace the define in config.h */
+    COMBO_LENGTH,
+};
+uint16_t COMBO_LEN = COMBO_LENGTH;
+
+
+/* Sequences fo keys */
+const uint16_t PROGMEM combo_leader[] =                 {LT(_MOUSE, KC_COMM), LT(_ARROWS, KC_DOT), COMBO_END};
+const uint16_t PROGMEM combo_bootloader[] =             {KC_K, KC_TAB, KC_Z, KC_BSPC, KC_V, KC_J, COMBO_END};
+
+const uint16_t PROGMEM combo_adjust[] =                 {KC_LCPO, LT(_NUMERIC, KC_ENT), COMBO_END};
+const uint16_t PROGMEM combo_fn[] =                     {LT(_NUMERIC, KC_ENT), KC_N, COMBO_END};
+const uint16_t PROGMEM combo_left_hand[] =              {KC_LCPO, GUI_T(KC_ESC), COMBO_END};
+
+/* -- */
+// const uint16_t PROGMEM combo_enter_shifted[] =          {LT(_NUMERIC, KC_ENT), KC_S, COMBO_END};
+const uint16_t PROGMEM combo_control_shift[] =          {KC_LCPO, KC_S, COMBO_END};
+const uint16_t PROGMEM combo_control_alt[] =            {KC_LCPO, KC_LALT, COMBO_END};
+const uint16_t PROGMEM combo_control_shift_alt[] =      {KC_LCPO, KC_S, KC_A, COMBO_END};
+const uint16_t PROGMEM combo_right_alt[] =              {KC_LAPO, KC_G, COMBO_END};
+const uint16_t PROGMEM combo_alt_shift[] =              {KC_LALT, KC_S, COMBO_END};
+
+/* -- */
+const uint16_t PROGMEM combo_e_acute[] =                {KC_LCPO, KC_E, COMBO_END};
+const uint16_t PROGMEM combo_c_cedilla[] =              {KC_LCPO, KC_I, COMBO_END};
+const uint16_t PROGMEM combo_ea[] =                     {KC_LCPO, KC_A, COMBO_END};
+const uint16_t PROGMEM combo_eo[] =                     {KC_LCPO, KC_O, COMBO_END};
+
+const uint16_t PROGMEM combo_a_grave[] =                {LT(_MOUSE, KC_COMM), KC_A, COMBO_END};
+const uint16_t PROGMEM combo_e_grave[] =                {LT(_MOUSE, KC_COMM), KC_E, COMBO_END};
+const uint16_t PROGMEM combo_i_grave[] =                {LT(_MOUSE, KC_COMM), KC_I, COMBO_END};
+const uint16_t PROGMEM combo_o_grave[] =                {LT(_MOUSE, KC_COMM), KC_O, COMBO_END};
+const uint16_t PROGMEM combo_u_grave[] =                {LT(_MOUSE, KC_COMM), KC_U, COMBO_END};
+
+const uint16_t PROGMEM combo_a_circumflex[] =           {KC_C, KC_A, COMBO_END};
+const uint16_t PROGMEM combo_e_circumflex[] =           {KC_C, KC_E, COMBO_END};
+const uint16_t PROGMEM combo_i_circumflex[] =           {KC_C, KC_I, COMBO_END};
+const uint16_t PROGMEM combo_o_circumflex[] =           {KC_C, KC_O, COMBO_END};
+const uint16_t PROGMEM combo_u_circumflex[] =           {KC_C, KC_U, COMBO_END};
+
+const uint16_t PROGMEM combo_a_diaeresis[] =            {KC_T, KC_A, COMBO_END};
+const uint16_t PROGMEM combo_e_diaeresis[] =            {KC_T, KC_E, COMBO_END};
+const uint16_t PROGMEM combo_i_diaeresis[] =            {KC_T, KC_I, COMBO_END};
+const uint16_t PROGMEM combo_o_diaeresis[] =            {KC_T, KC_O, COMBO_END};
+const uint16_t PROGMEM combo_u_diaeresis[] =            {KC_T, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_y_diaeresis[] =            {KC_T, KC_Y, COMBO_END};
+
+/* -- */
+const uint16_t PROGMEM combo_ampersand[] =              {KC_I, KC_E, COMBO_END};
+const uint16_t PROGMEM combo_at_sign[] =                {KC_Q, KC_Y, COMBO_END};
+const uint16_t PROGMEM combo_backslash[] =              {KC_D, KC_R, COMBO_END};
+const uint16_t PROGMEM combo_circumflex[] =             {KC_T, KC_D, COMBO_END};
+const uint16_t PROGMEM combo_colon[] =                  {KC_C, KC_G, COMBO_END};
+const uint16_t PROGMEM combo_dollar[] =                 {KC_D, KC_L, COMBO_END};
+const uint16_t PROGMEM combo_equal[] =                  {KC_T, KC_H, COMBO_END};
+const uint16_t PROGMEM combo_exclamation_mark[] =       {KC_O, KC_W, COMBO_END};
+const uint16_t PROGMEM combo_grave[] =                  {KC_T, KC_G, COMBO_END};
+const uint16_t PROGMEM combo_hash[] =                   {KC_I, KC_O, COMBO_END};
+const uint16_t PROGMEM combo_minus[] =                  {KC_T, KC_R, COMBO_END};
+const uint16_t PROGMEM combo_percent[] =                {KC_O, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_pipe[] =                   {KC_E, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_plus[] =                   {KC_T, KC_L, COMBO_END};
+const uint16_t PROGMEM combo_question_mark[] =          {KC_B, KC_O, COMBO_END};
+const uint16_t PROGMEM combo_quote[] =                  {KC_T, KC_N, COMBO_END};
+const uint16_t PROGMEM combo_quote_double[] =           {KC_A, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_semicolon[] =              {KC_G, KC_H, COMBO_END};
+const uint16_t PROGMEM combo_slash[] =                  {KC_S, KC_L, COMBO_END};
+const uint16_t PROGMEM combo_star[] =                   {KC_S, KC_T, COMBO_END};
+const uint16_t PROGMEM combo_tilde[] =                  {KC_I, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_underscore[] =             {KC_S, KC_R, COMBO_END};
+
+const uint16_t PROGMEM combo_angle_bracket_left[] =     {KC_C, KC_S, COMBO_END};
+const uint16_t PROGMEM combo_angle_bracket_right[] =    {KC_S, KC_H, COMBO_END};
+
+const uint16_t PROGMEM combo_bracket_left[] =           {KC_Q, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_bracket_right[] =          {KC_E, KC_Y, COMBO_END};
+const uint16_t PROGMEM combo_curly_bracket_left[] =     {KC_X, KC_E, COMBO_END};
+const uint16_t PROGMEM combo_curly_bracket_right[] =    {KC_I, KC_Q, COMBO_END};
+const uint16_t PROGMEM combo_parenthesis_left[] =       {KC_X, KC_U, COMBO_END};
+const uint16_t PROGMEM combo_parenthesis_right[] =      {KC_I, KC_Y, COMBO_END};
+
+/* One hand special */
+const uint16_t PROGMEM combo_control_right[] =          {LT(_NUMERIC, KC_ENT), KC_R, COMBO_END};
+const uint16_t PROGMEM combo_control_shift_right[] =    {LT(_NUMERIC, KC_ENT), KC_S, COMBO_END};
+
+const uint16_t PROGMEM combo_shift_left[] =             {KC_LCPO, KC_LALT, COMBO_END};
+// const uint16_t PROGMEM combo_altgr_left[] =             {LT(_MOUSE, KC_COMM), KC_LALT, COMBO_END};
+// const uint16_t PROGMEM combo_del_left[] =               {GUI_T(KC_ESC), KC_K, COMBO_END};
+const uint16_t PROGMEM combo_control_shift_left[] =     {LT(_MOUSE, KC_COMM), KC_LALT, COMBO_END};
+
+
+/* Sequences fo keys */
+combo_t key_combos[] = {
+    [LEADER] = COMBO(combo_leader,                          KC_LEAD),
+    [BOOTLOADER] = COMBO(combo_bootloader,                  QK_BOOTLOADER),
+
+    [LAYER_ADJUST] = COMBO(combo_adjust,                    OSL(_ADJUST)),
+    [LAYER_FN] = COMBO(combo_fn,                            OSL(_FN)),
+    [LAYER_LEFT_HAND] = COMBO(combo_left_hand,              OSL(_LEFT_HAND)),
+
+    /* -- */
+    // [ENTER_SHIFTED] = COMBO(combo_enter_shifted,            S(KC_ENT)),
+    [ALT_SHIFT] = COMBO(combo_alt_shift,                    A(S(XXXXXXX))),
+    [CONTROL_SHIFT] = COMBO(combo_control_shift,            C(S(XXXXXXX))),
+    [CONTROL_ALT] = COMBO(combo_control_alt,                C(A(XXXXXXX))),
+    [CONTROL_SHIFT_ALT] = COMBO(combo_control_shift_alt,    C(S(A(XXXXXXX)))),
+    [RIGHT_ALT] = COMBO(combo_right_alt,                    KC_RALT),
+
+    /* French */
+    [E_ACUTE] = COMBO(combo_e_acute,                        CS_E_ACUTE),
+    [C_CEDILLA] = COMBO(combo_c_cedilla,                    CS_C_CEDILLA),
+    [E_A] = COMBO(combo_ea,                                 CS_AE),
+    [E_O] = COMBO(combo_eo,                                 CS_OE),
+
+    [A_GRAVE] = COMBO(combo_a_grave,                        CS_A_GRAVE),
+    [E_GRAVE] = COMBO(combo_e_grave,                        CS_E_GRAVE),
+    [I_GRAVE] = COMBO(combo_i_grave,                        CS_I_GRAVE),
+    [O_GRAVE] = COMBO(combo_o_grave,                        CS_O_GRAVE),
+    [U_GRAVE] = COMBO(combo_u_grave,                        CS_U_GRAVE),
+
+    [A_CIRCUMFLEX] = COMBO(combo_a_circumflex,              CS_A_CIRCUMFLEX),
+    [E_CIRCUMFLEX] = COMBO(combo_e_circumflex,              CS_E_CIRCUMFLEX),
+    [I_CIRCUMFLEX] = COMBO(combo_i_circumflex,              CS_I_CIRCUMFLEX),
+    [O_CIRCUMFLEX] = COMBO(combo_o_circumflex,              CS_O_CIRCUMFLEX),
+    [U_CIRCUMFLEX] = COMBO(combo_u_circumflex,              CS_U_CIRCUMFLEX),
+
+    [A_DIAERESIS] = COMBO(combo_a_diaeresis,                CS_A_DIAERESIS),
+    [E_DIAERESIS] = COMBO(combo_e_diaeresis,                CS_E_DIAERESIS),
+    [I_DIAERESIS] = COMBO(combo_i_diaeresis,                CS_I_DIAERESIS),
+    [O_DIAERESIS] = COMBO(combo_o_diaeresis,                CS_O_DIAERESIS),
+    [U_DIAERESIS] = COMBO(combo_u_diaeresis,                CS_U_DIAERESIS),
+    [Y_DIAERESIS] = COMBO(combo_y_diaeresis,                CS_Y_DIAERESIS),
+
+    /* -- */
+    [AMPERSAND] = COMBO(combo_ampersand,                    KC_AMPR),
+    [AT_SIGN] = COMBO(combo_at_sign,                        KC_AT),
+    [BACKSLASH] = COMBO(combo_backslash,                    KC_BSLS),
+    [CIRCUMFLEX] = COMBO(combo_circumflex,                  KC_CIRC),
+    [COLON] = COMBO(combo_colon,                            KC_COLON),
+    [DOLLAR] = COMBO(combo_dollar,                          KC_DLR),
+    [EQUAL] = COMBO(combo_equal,                            KC_EQL),
+    [EXCLAMATION_MARK] = COMBO(combo_exclamation_mark,      KC_EXCLAIM),
+    [GRAVE] = COMBO(combo_grave,                            KC_GRV),
+    [HASH] = COMBO(combo_hash,                              KC_HASH),
+    [MINUS] = COMBO(combo_minus,                            KC_MINS),
+    [PERCENT] = COMBO(combo_percent,                        KC_PERC),
+    [PIPE] = COMBO(combo_pipe,                              KC_PIPE),
+    [PLUS] = COMBO(combo_plus,                              KC_PLUS),
+    [QUESTION_MARK] = COMBO(combo_question_mark,            KC_QUESTION),
+    [QUOTE] = COMBO(combo_quote,                            KC_QUOTE),
+    [QUOTE_DOUBLE] = COMBO(combo_quote_double,              KC_DOUBLE_QUOTE),
+    [SEMICOLON] = COMBO(combo_semicolon,                    KC_SEMICOLON),
+    [SLASH] = COMBO(combo_slash,                            KC_SLSH),
+    [STAR] = COMBO(combo_star,                              KC_ASTR),
+    [TILDE] = COMBO(combo_tilde,                            KC_TILD),
+    [UNDERSCORE] = COMBO(combo_underscore,                  KC_UNDS),
+
+    [ANGLE_BRACKET_LEFT] = COMBO(combo_angle_bracket_left,      KC_LABK),
+    [ANGLE_BRACKET_RIGHT] = COMBO(combo_angle_bracket_right,    KC_RABK),
+
+    [BRACKET_LEFT] = COMBO(combo_bracket_left,                  KC_LEFT_BRACKET),
+    [BRACKET_RIGHT] = COMBO(combo_bracket_right,                KC_RIGHT_BRACKET),
+    [CURLY_BRACKET_LEFT] = COMBO(combo_curly_bracket_left,      KC_LEFT_CURLY_BRACE),
+    [CURLY_BRACKET_RIGHT] = COMBO(combo_curly_bracket_right,    KC_RIGHT_CURLY_BRACE),
+    [PARENTHESIS_LEFT] = COMBO(combo_parenthesis_left,          KC_LEFT_PAREN),
+    [PARENTHESIS_RIGHT] COMBO(combo_parenthesis_right,          KC_RIGHT_PAREN),
+
+    /* One hand special */
+    [CONTROL_RIGHT] = COMBO(combo_control_right,                KC_RCTL),
+    [CONTROL_SHIFT_RIGHT] = COMBO(combo_control_shift_right,    C(S(XXXXXXX))),
+
+    [SHIFT_LEFT] = COMBO(combo_shift_left,                      KC_LSFT),
+    // [ALTGR_LEFT] = COMBO(combo_altgr_left,                      KC_ALGR),
+    [CONTROL_SHIFT_LEFT] = COMBO(combo_control_shift_left,      C(S(XXXXXXX))),
+    // [DEL_LEFT] = COMBO(combo_del_left,                          KC_BSPC),
+};
diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/leader.c b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/leader.c
new file mode 100644
index 0000000000..7cfd30af6d
--- /dev/null
+++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/features/leader.c
@@ -0,0 +1,268 @@
+// Copyright 2023 Florent Linguenheld (@FLinguenheld)
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include QMK_KEYBOARD_H
+
+LEADER_EXTERNS();
+
+void matrix_scan_user(void) {
+  LEADER_DICTIONARY() {
+    leading = false;
+    leader_end();
+
+    // SEQ_ONE_KEY(KC_F) {
+      // // Anything you can do in a macro.
+      // SEND_STRING("QMK is awesome."); }
+
+
+    SEQ_TWO_KEYS(KC_M, KC_S) {
+      SEND_STRING("f@linguenheld.fr"); }
+    SEQ_TWO_KEYS(KC_M, KC_L) {
+      SEND_STRING("florent@linguenheld.fr"); }
+    SEQ_TWO_KEYS(KC_F, KC_L) {
+      SEND_STRING("FLinguenheld"); }
+
+    SEQ_THREE_KEYS(KC_T, KC_E, KC_S) {
+      SEND_STRING("test01234"); }
+    SEQ_THREE_KEYS(KC_A, KC_D, KC_M) {
+      SEND_STRING("admin01234"); }
+
+    SEQ_ONE_KEY(KC_C) {
+      SEND_STRING(" | xclip -r -selection clipboard"); }
+
+    /* Degree */
+    SEQ_THREE_KEYS(KC_D, KC_E, KC_G) {
+      send_unicode_string("°"); }
+
+    /* Copyright / Register */
+    SEQ_THREE_KEYS(KC_C, KC_O, KC_P) {
+      send_unicode_string("©"); }
+    SEQ_THREE_KEYS(KC_R, KC_E, KC_G) {
+      send_unicode_string("®"); }
+
+    /* Diameter */
+    SEQ_THREE_KEYS(KC_D, KC_I, KC_A) {
+      send_unicode_string("ø"); }
+    SEQ_FOUR_KEYS(KC_D, KC_I, KC_A, KC_M) {
+      send_unicode_string("Ø"); }
+
+    /* Currency */
+    SEQ_THREE_KEYS(KC_E, KC_U, KC_R) {
+      send_unicode_string("€"); }
+    SEQ_THREE_KEYS(KC_P, KC_O, KC_U) {
+      send_unicode_string("£"); }
+    SEQ_THREE_KEYS(KC_Y, KC_E, KC_N) {
+      send_unicode_string("¥"); }
+    SEQ_THREE_KEYS(KC_C, KC_E, KC_N) {
+      send_unicode_string("¢"); }
+
+    /* Fractions */
+    SEQ_THREE_KEYS(KC_F, KC_C, KC_T) {
+      send_unicode_string("¼"); }
+    SEQ_THREE_KEYS(KC_F, KC_C, KC_G) {
+      send_unicode_string("½"); }
+    SEQ_THREE_KEYS(KC_F, KC_H, KC_T) {
+      send_unicode_string("¾"); }
+
+    /* Maths */
+    SEQ_THREE_KEYS(KC_M, KC_U, KC_L) {
+      send_unicode_string("×"); }
+    SEQ_THREE_KEYS(KC_D, KC_I, KC_V) {
+      send_unicode_string("÷"); }
+    SEQ_TWO_KEYS(KC_P, KC_M) {
+      send_unicode_string("±"); }
+    SEQ_THREE_KEYS(KC_I, KC_N, KC_E) {
+      send_unicode_string("≠"); }
+    SEQ_THREE_KEYS(KC_A, KC_L, KC_M) {
+      send_unicode_string("≈"); }
+    SEQ_THREE_KEYS(KC_S, KC_Q, KC_U) {
+      send_unicode_string("√"); }
+    SEQ_THREE_KEYS(KC_I, KC_N, KC_F) {
+      send_unicode_string("∞"); }
+    SEQ_TWO_KEYS(KC_LABK, KC_LABK) {
+      send_unicode_string("≤"); }
+    SEQ_TWO_KEYS(KC_RABK, KC_RABK) {
+      send_unicode_string("≥"); }
+
+    /* Greek */
+    SEQ_TWO_KEYS(KC_P, KC_I) {
+      send_unicode_string("π"); }
+    SEQ_THREE_KEYS(KC_P, KC_I, KC_I) {
+      send_unicode_string("Π"); }
+
+    SEQ_THREE_KEYS(KC_O, KC_M, KC_E) {
+      send_unicode_string("ω"); }
+    SEQ_FOUR_KEYS(KC_O, KC_M, KC_E, KC_G) {
+      send_unicode_string("Ω"); }
+
+    /* Icons */
+    SEQ_THREE_KEYS(KC_F, KC_L, KC_A) {
+      send_unicode_string("⚡"); }
+    SEQ_THREE_KEYS(KC_S, KC_T, KC_A) {
+      send_unicode_string("⭐"); }
+    SEQ_THREE_KEYS(KC_S, KC_P, KC_A) {
+      send_unicode_string("✨"); }
+    SEQ_THREE_KEYS(KC_P, KC_O, KC_P) {
+      send_unicode_string("🎉"); }
+    SEQ_THREE_KEYS(KC_R, KC_E, KC_C) {
+      send_unicode_string("♻️"); }
+    SEQ_THREE_KEYS(KC_L, KC_O, KC_V) {
+      send_unicode_string("❤️"); }
+    SEQ_THREE_KEYS(KC_F, KC_I, KC_R) {
+      send_unicode_string("🔥"); }
+    SEQ_THREE_KEYS(KC_B, KC_O, KC_M) {
+      send_unicode_string("💣"); }
+    SEQ_FOUR_KEYS(KC_B, KC_O, KC_U, KC_M) {
+      send_unicode_string("💥"); }
+    SEQ_THREE_KEYS(KC_R, KC_O, KC_C) {
+      send_unicode_string("🚀"); }
+    SEQ_THREE_KEYS(KC_T, KC_E, KC_L) {
+      send_unicode_string("🔭"); }
+    SEQ_THREE_KEYS(KC_M, KC_A, KC_G) {
+      send_unicode_string("🔎"); }
+    SEQ_THREE_KEYS(KC_W, KC_A, KC_R) {
+      send_unicode_string("⚠️"); }
+
+    SEQ_THREE_KEYS(KC_B, KC_U, KC_L) {
+      send_unicode_string("💡"); }
+    SEQ_FOUR_KEYS(KC_I, KC_N, KC_F, KC_O) {
+      send_unicode_string("ℹ️"); }
+    SEQ_THREE_KEYS(KC_G, KC_E, KC_A) {
+      send_unicode_string("⚙️"); }
+    SEQ_THREE_KEYS(KC_L, KC_I, KC_N) {
+      send_unicode_string("🔗"); }
+    SEQ_THREE_KEYS(KC_P, KC_I, KC_N) {
+      send_unicode_string("📌"); }
+    SEQ_FOUR_KEYS(KC_F, KC_L, KC_A, KC_G) {
+      send_unicode_string("🚩"); }
+    SEQ_THREE_KEYS(KC_B, KC_A, KC_L) {
+      send_unicode_string("🎈"); }
+    SEQ_THREE_KEYS(KC_G, KC_I, KC_F) {
+      send_unicode_string("🎁"); }
+
+    SEQ_THREE_KEYS(KC_P, KC_E, KC_N) {
+      send_unicode_string("✏️"); }
+    SEQ_THREE_KEYS(KC_K, KC_E, KC_Y) {
+      send_unicode_string("🔑"); }
+    SEQ_THREE_KEYS(KC_B, KC_O, KC_X) {
+      send_unicode_string("🧰"); }
+
+    SEQ_TWO_KEYS(KC_O, KC_K) {
+      send_unicode_string("👌"); }
+    SEQ_THREE_KEYS(KC_O, KC_W, KC_D) {
+      send_unicode_string("⛔"); }
+
+    SEQ_ONE_KEY(KC_V) {
+      send_unicode_string("✓"); }
+    SEQ_TWO_KEYS(KC_V, KC_B) {
+      send_unicode_string("☑"); }
+    SEQ_TWO_KEYS(KC_V, KC_G) {
+      send_unicode_string("✅"); }
+
+    SEQ_ONE_KEY(KC_X) {
+      send_unicode_string("✗"); }
+    SEQ_TWO_KEYS(KC_X, KC_B) {
+      send_unicode_string("☒"); }
+    SEQ_TWO_KEYS(KC_X, KC_G) {
+      send_unicode_string("❎"); }
+    SEQ_TWO_KEYS(KC_X, KC_R) {
+      send_unicode_string("❌"); }
+
+    SEQ_ONE_KEY(KC_QUESTION) {
+      send_unicode_string("❔"); }
+    SEQ_ONE_KEY(KC_EXCLAIM) {
+      send_unicode_string("❕"); }
+    SEQ_TWO_KEYS(KC_QUESTION, KC_QUESTION) {
+      send_unicode_string("❓"); }
+    SEQ_TWO_KEYS(KC_EXCLAIM, KC_EXCLAIM) {
+      send_unicode_string("❗"); }
+
+    SEQ_THREE_KEYS(KC_C, KC_O, KC_F) {
+      send_unicode_string("☕"); }
+    SEQ_THREE_KEYS(KC_U, KC_M, KC_B) {
+      send_unicode_string("☔"); }
+
+    SEQ_THREE_KEYS(KC_L, KC_O, KC_L) {
+      send_unicode_string("😀"); }
+    SEQ_THREE_KEYS(KC_M, KC_D, KC_R) {
+      send_unicode_string("🤣"); }
+    SEQ_THREE_KEYS(KC_K, KC_I, KC_S) {
+      send_unicode_string("😙"); }
+    SEQ_THREE_KEYS(KC_A, KC_N, KC_G) {
+      send_unicode_string("😇"); }
+    SEQ_THREE_KEYS(KC_G, KC_L, KC_A) {
+      send_unicode_string("😎"); }
+    SEQ_THREE_KEYS(KC_A, KC_N, KC_G) {
+      send_unicode_string("🤬"); }
+    SEQ_THREE_KEYS(KC_F, KC_E, KC_A) {
+      send_unicode_string("😱"); }
+    SEQ_THREE_KEYS(KC_N, KC_E, KC_U) {
+      send_unicode_string("😐"); }
+    SEQ_THREE_KEYS(KC_T, KC_H, KC_I) {
+      send_unicode_string("🤔"); }
+    SEQ_THREE_KEYS(KC_Z, KC_I, KC_P) {
+      send_unicode_string("🤐"); }
+    SEQ_THREE_KEYS(KC_S, KC_U, KC_R) {
+      send_unicode_string("😯"); }
+    SEQ_THREE_KEYS(KC_R, KC_O, KC_L) {
+      send_unicode_string("🙄"); }
+    SEQ_THREE_KEYS(KC_M, KC_O, KC_O) {
+      send_unicode_string("🌝"); }
+    SEQ_THREE_KEYS(KC_H, KC_U, KC_G) {
+      send_unicode_string("🫂"); }
+
+    SEQ_THREE_KEYS(KC_H, KC_E, KC_N) {
+      send_unicode_string("🐔"); }
+    SEQ_THREE_KEYS(KC_R, KC_O, KC_O) {
+      send_unicode_string("🐓"); }
+    SEQ_THREE_KEYS(KC_D, KC_U, KC_C) {
+      send_unicode_string("🦆"); }
+    SEQ_THREE_KEYS(KC_P, KC_E, KC_A) {
+      send_unicode_string("🦚"); }
+    SEQ_THREE_KEYS(KC_B, KC_I, KC_R) {
+      send_unicode_string("🐦"); }
+
+    /* Subscript / superscript */
+    SEQ_THREE_KEYS(KC_U, KC_P, KC_F) {
+      send_unicode_string("⁰"); }
+    SEQ_THREE_KEYS(KC_D, KC_N, KC_F) {
+      send_unicode_string("₀"); }
+    SEQ_THREE_KEYS(KC_U, KC_P, KC_C) {
+      send_unicode_string("¹"); }
+    SEQ_THREE_KEYS(KC_D, KC_N, KC_C) {
+      send_unicode_string("₁"); }
+    SEQ_THREE_KEYS(KC_U, KC_P, KC_G) {
+      send_unicode_string("²"); }
+    SEQ_THREE_KEYS(KC_D, KC_N, KC_G) {
+      send_unicode_string("₂"); }
+    SEQ_THREE_KEYS(KC_U, KC_P, KC_H) {
+      send_unicode_string("³"); }
+    SEQ_THREE_KEYS(KC_D, KC_N, KC_H) {
+      send_unicode_string("₃"); }
+    SEQ_THREE_KEYS(KC_U, KC_P, KC_T) {
+      send_unicode_string("⁴"); }
+    SEQ_THREE_KEYS(KC_D, KC_N, KC_T) {
+      send_unicode_string("₄"); }
+    SEQ_THREE_KEYS(KC_U, KC_P, KC_S) {
+      send_unicode_string("⁵"); }
+    SEQ_THREE_KEYS(KC_D, KC_N, KC_S) {
+      send_unicode_string("₅"); }
+    SEQ_THREE_KEYS(KC_U, KC_P, KC_R) {
+      send_unicode_string("⁶"); }
+    SEQ_THREE_KEYS(KC_D, KC_N, KC_R) {
+      send_unicode_string("₆"); }
+    SEQ_THREE_KEYS(KC_U, KC_P, KC_P) {
+      send_unicode_string("⁷"); }
+    SEQ_THREE_KEYS(KC_D, KC_N, KC_P) {
+      send_unicode_string("₇"); }
+    SEQ_THREE_KEYS(KC_U, KC_P, KC_D) {
+      send_unicode_string("⁸"); }
+    SEQ_THREE_KEYS(KC_D, KC_N, KC_D) {
+      send_unicode_string("₈"); }
+    SEQ_THREE_KEYS(KC_U, KC_P, KC_L) {
+      send_unicode_string("⁹"); }
+    SEQ_THREE_KEYS(KC_D, KC_N, KC_L) {
+      send_unicode_string("₉"); }
+
+  };
+}
diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keycodes.h b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keycodes.h
new file mode 100644
index 0000000000..b90b28fda4
--- /dev/null
+++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keycodes.h
@@ -0,0 +1,44 @@
+// Copyright 2023 Florent Linguenheld (@FLinguenheld)
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+enum layers {
+    _BASE,
+    _NUMERIC,
+    _ARROWS,
+    _MOUSE,
+    _ADJUST,
+    _FN,
+    _LEFT_HAND,
+};
+
+enum custom_keys {
+    UNICODE = SAFE_RANGE, // Shortcut to write unicodes, see numeric layer
+
+    /* See auto-shift */
+    CS_E_ACUTE,
+
+    CS_A_GRAVE,
+    CS_E_GRAVE,
+    CS_I_GRAVE,
+    CS_O_GRAVE,
+    CS_U_GRAVE,
+
+    CS_C_CEDILLA,
+    CS_AE,
+    CS_OE,
+
+    CS_A_CIRCUMFLEX,
+    CS_E_CIRCUMFLEX,
+    CS_I_CIRCUMFLEX,
+    CS_O_CIRCUMFLEX,
+    CS_U_CIRCUMFLEX,
+
+    CS_A_DIAERESIS,
+    CS_E_DIAERESIS,
+    CS_I_DIAERESIS,
+    CS_O_DIAERESIS,
+    CS_U_DIAERESIS,
+    CS_Y_DIAERESIS,
+};
diff --git a/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keymap.c b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keymap.c
new file mode 100644
index 0000000000..50fb7909f3
--- /dev/null
+++ b/keyboards/splitkb/aurora/sweep/keymaps/flinguenheld/keymap.c
@@ -0,0 +1,133 @@
+/* Copyright 2023 Florent Linguenheld (@FLinguenheld)
+ *
+ * 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 QMK_KEYBOARD_H
+#include "keycodes.h"
+
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+
+    /* Macros */
+    switch (keycode) {
+
+        case UNICODE:
+            if (record->event.pressed) {
+                register_code(KC_LCTL);
+                register_code(KC_LSFT);
+                tap_code16(KC_U);
+            } else {
+                unregister_code(KC_LCTL);
+                unregister_code(KC_LSFT);
+            }
+            break;
+    }
+
+    return true;
+}
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+