Merge pull request #7762 from CurryFurious/userspace_curry

Adding custom userspace & 2 keymaps

17 files changed, 1719 insertions, 0 deletions

diff --git a/users/curry/.gitignore b/users/curry/.gitignore
new file mode 100644
index 0000000000..c6df8c0139
--- /dev/null
+++ b/users/curry/.gitignore
@@ -0,0 +1 @@
+secrets.c
diff --git a/users/curry/LICENSE.md b/users/curry/LICENSE.md
new file mode 100644
index 0000000000..198ae45b2e
--- /dev/null
+++ b/users/curry/LICENSE.md
@@ -0,0 +1,14 @@
+Copyright 2020 Akaash Suresh casa.akaash@gmail.com @CurryFurious
+
+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/>.
diff --git a/users/curry/README.md b/users/curry/README.md
new file mode 100644
index 0000000000..70d6262d73
--- /dev/null
+++ b/users/curry/README.md
@@ -0,0 +1,30 @@
+# Information
+
+These is my userspace files, heavily influenced by @drashna's userspace structure.
+
+# Keyboards
+
+Main uses are for corne & lily58, supporting dfu bootloader (elite-c)
+
+## Split Common
+Is compatible with split_common when the previous two keyboards update to them. 
+
+If you want to use these keymaps with split common code, they are on my personal github fork: [CurryFurious/qmk_firmware](https://github.com/CurryFurious/qmk_firmware)
+
+Referenced PRs: #6260, #5998, #6001
+
+## Keymaps
+Keymap layout is similar between the two keyboards. Lily58 has a lot of open keys for custom keys as well. Keymap formatting is set up in the physical layout of the keyboard, so mapping keys should be easier.
+
+## Tap Dances
+
+Tap dances are enabled but none are defined, you can add them to [tapdances.c](tapdances.c). If not using tapdances, you can disable them in the keymaps.
+
+## RGB 
+RGB is implemented pretty much the same as @drashna. Only change is that I added the RGB code from the drashna's corne [keymap.c](../../keyboards/crkbd/keymaps/drashna/keymap.c), lines 313-383 into rgb_stuff.c.
+
+## OLED
+Similarly to RGB, I moved all OLED code into [oled.c](oled.c) to better clear up the keymap.c file. I haven't experimented with the kyria's 128x64 pixel screen so it probably won't work as well with it yet.
+
+## Wrappers
+Have implemented QWERTY, COLEMAK Mod DH, and DVORAK. Other macros are defined, some modified from drashna's. Drashna's [wrappers.h](../drashna/wrappers.h) has other layouts that you can copy in as you see fit, make sure to add them to the userspace_layers enum in [curry.h](curry.h)
diff --git a/users/curry/config.h b/users/curry/config.h
new file mode 100644
index 0000000000..45b8364e12
--- /dev/null
+++ b/users/curry/config.h
@@ -0,0 +1,118 @@
+#pragma once
+
+// Use custom magic number so that when switching branches, EEPROM always gets reset
+#define EECONFIG_MAGIC_NUMBER (uint16_t)0x420
+
+/* Set Polling rate to 1000Hz */
+#define USB_POLLING_INTERVAL_MS 1
+
+#ifdef RGBLIGHT_ENABLE
+#    undef RGBLIGHT_ANIMATIONS
+#    if defined(__AVR__) && !defined(__AVR_AT90USB1286__)
+#        define RGBLIGHT_SLEEP
+#        define RGBLIGHT_EFFECT_BREATHING
+#        define RGBLIGHT_EFFECT_SNAKE
+#        define RGBLIGHT_EFFECT_KNIGHT
+#    else
+#        define RGBLIGHT_ANIMATIONS
+#    endif
+#endif  // RGBLIGHT_ENABLE
+
+#ifdef RGB_MATRIX_ENABLE
+#    define RGB_MATRIX_KEYPRESSES  // reacts to keypresses (will slow down matrix scan by a lot)
+// #   define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (not recommened)
+#    define RGB_MATRIX_FRAMEBUFFER_EFFECTS
+// #   define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
+#    define RGB_DISABLE_WHEN_USB_SUSPENDED true  // turn off effects when suspended
+// #   define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
+// #   define EECONFIG_RGB_MATRIX (uint32_t *)16
+
+#    if defined(__AVR__) && !defined(__AVR_AT90USB1286__)
+#        define DISABLE_RGB_MATRIX_ALPHAS_MODS
+#        define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN
+#        define DISABLE_RGB_MATRIX_BREATHING
+#        define DISABLE_RGB_MATRIX_BAND_SAT
+#        define DISABLE_RGB_MATRIX_BAND_VAL
+#        define DISABLE_RGB_MATRIX_BAND_PINWHEEL_SAT
+#        define DISABLE_RGB_MATRIX_BAND_PINWHEEL_VAL
+#        define DISABLE_RGB_MATRIX_BAND_SPIRAL_SAT
+#        define DISABLE_RGB_MATRIX_BAND_SPIRAL_VAL
+#        define DISABLE_RGB_MATRIX_CYCLE_ALL
+#        define DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
+#        define DISABLE_RGB_MATRIX_CYCLE_UP_DOWN
+#        define DISABLE_RGB_MATRIX_CYCLE_OUT_IN
+// #       define DISABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL
+#        define DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
+#        define DISABLE_RGB_MATRIX_DUAL_BEACON
+#        define DISABLE_RGB_MATRIX_CYCLE_PINWHEEL
+#        define DISABLE_RGB_MATRIX_CYCLE_SPIRAL
+#        define DISABLE_RGB_MATRIX_RAINBOW_BEACON
+#        define DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS
+#        define DISABLE_RGB_MATRIX_RAINDROPS
+#        define DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS
+// #       define DISABLE_RGB_MATRIX_TYPING_HEATMAP
+#        define DISABLE_RGB_MATRIX_DIGITAL_RAIN
+#        define DISABLE_RGB_MATRIX_SOLID_REACTIVE
+#        define DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE
+#        define DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE
+#        define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE
+#        define DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS
+#        define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS
+#        define DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS
+#        define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS
+#        define DISABLE_RGB_MATRIX_SPLASH
+#        define DISABLE_RGB_MATRIX_MULTISPLASH
+#        define DISABLE_RGB_MATRIX_SOLID_SPLASH
+#        define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH
+#    endif  // AVR
+#endif      // RGB_MATRIX_ENABLE
+
+#ifndef ONESHOT_TAP_TOGGLE
+#    define ONESHOT_TAP_TOGGLE 2
+#endif  // !ONESHOT_TAP_TOGGLE
+
+#ifndef ONESHOT_TIMEOUT
+#    define ONESHOT_TIMEOUT 3000
+#endif  // !ONESHOT_TIMEOUT
+
+#ifndef QMK_KEYS_PER_SCAN
+#    define QMK_KEYS_PER_SCAN 4
+#endif  // !QMK_KEYS_PER_SCAN
+
+// this makes it possible to do rolling combos (zx) with keys that
+// convert to other keys on hold (z becomes ctrl when you hold it,
+// and when this option isn't enabled, z rapidly followed by x
+// actually sends Ctrl-x. That's bad.)
+#define IGNORE_MOD_TAP_INTERRUPT
+#undef PERMISSIVE_HOLD
+//#define TAPPING_FORCE_HOLD
+//#define RETRO_TAPPING
+
+#define FORCE_NKRO
+
+#ifndef TAPPING_TOGGLE
+#    define TAPPING_TOGGLE 1
+#endif
+
+#ifdef TAPPING_TERM
+#    undef TAPPING_TERM
+#endif  // TAPPING_TERM
+#if defined(KEYBOARD_ergodox_ez)
+#    define TAPPING_TERM 185
+#elif defined(KEYBOARD_crkbd)
+#    define TAPPING_TERM 200
+#else
+#    define TAPPING_TERM 175
+#endif
+
+#define TAP_CODE_DELAY 5
+
+/* Disable unused and unneeded features to reduce on firmware size */
+#ifdef LOCKING_SUPPORT_ENABLE
+#    undef LOCKING_SUPPORT_ENABLE
+#endif
+#ifdef LOCKING_RESYNC_ENABLE
+#    undef LOCKING_RESYNC_ENABLE
+#endif
+
+#define OLED_FONT_H "users/curry/glcdfont.c"
diff --git a/users/curry/curry.c b/users/curry/curry.c
new file mode 100644
index 0000000000..b6afa5ef2e
--- /dev/null
+++ b/users/curry/curry.c
@@ -0,0 +1,131 @@
+#include "curry.h"
+
+userspace_config_t userspace_config;
+
+#define CURRY_UNICODE_MODE 1
+
+void bootmagic_lite(void) {
+    matrix_scan();
+#if defined(DEBOUNCING_DELAY) && DEBOUNCING_DELAY > 0
+    wait_ms(DEBOUNCING_DELAY * 2);
+#elif defined(DEBOUNCE) && DEBOUNCE > 0
+    wait_ms(DEBOUNCE * 2);
+#else
+    wait_ms(30);
+#endif
+    matrix_scan();
+    if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {
+        bootloader_jump();
+    }
+}
+
+__attribute__((weak)) void keyboard_pre_init_keymap(void) {}
+
+void keyboard_pre_init_user(void) {
+    userspace_config.raw = eeconfig_read_user();
+    keyboard_pre_init_keymap();
+}
+
+__attribute__((weak)) void matrix_init_keymap(void) {}
+
+// Call user matrix init, set default RGB colors and then
+// call the keymap's init function
+void matrix_init_user(void) {
+#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
+    set_unicode_input_mode(CURRY_UNICODE_MODE);
+    get_unicode_input_mode();
+#endif  // UNICODE_ENABLE
+    matrix_init_keymap();
+}
+
+__attribute__((weak)) void keyboard_post_init_keymap(void) {}
+
+void keyboard_post_init_user(void) {
+#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
+    keyboard_post_init_rgb();
+#endif
+    keyboard_post_init_keymap();
+}
+
+__attribute__((weak)) void shutdown_keymap(void) {}
+
+void rgb_matrix_update_pwm_buffers(void);
+
+// On RESET, set all RGB to red, shutdown the keymap.
+void shutdown_user(void) {
+#ifdef RGBLIGHT_ENABLE
+    rgblight_enable_noeeprom();
+    rgblight_mode_noeeprom(1);
+    rgblight_setrgb_red();
+#endif  // RGBLIGHT_ENABLE
+#ifdef RGB_MATRIX_ENABLE
+    rgb_matrix_set_color_all(0xFF, 0x00, 0x00);
+    rgb_matrix_update_pwm_buffers();
+#endif  // RGB_MATRIX_ENABLE
+    shutdown_keymap();
+}
+
+__attribute__((weak)) void suspend_power_down_keymap(void) {}
+
+void suspend_power_down_user(void) { suspend_power_down_keymap(); }
+
+__attribute__((weak)) void suspend_wakeup_init_keymap(void) {}
+
+void suspend_wakeup_init_user(void) { suspend_wakeup_init_keymap(); }
+
+__attribute__((weak)) void matrix_scan_keymap(void) {}
+
+// No global matrix scan code, so just run keymap's matrix
+// scan function
+void matrix_scan_user(void) {
+    static bool has_ran_yet;
+    if (!has_ran_yet) {
+        has_ran_yet = true;
+        startup_user();
+    }
+
+#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
+    matrix_scan_rgb();
+#endif  // RGBLIGHT_ENABLE
+
+    matrix_scan_keymap();
+}
+
+__attribute__((weak)) layer_state_t layer_state_set_keymap(layer_state_t state) { return state; }
+
+// On Layer change, run keymap's layer change check
+layer_state_t layer_state_set_user(layer_state_t state) {
+    state = update_tri_layer_state(state, _RAISE, _LOWER, _ADJUST);
+#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
+    state = layer_state_set_rgb(state);
+#endif  // RGBLIGHT_ENABLE
+    return layer_state_set_keymap(state);
+}
+
+__attribute__((weak)) layer_state_t default_layer_state_set_keymap(layer_state_t state) { return state; }
+
+// Runs state check and changes underglow color and animation
+layer_state_t default_layer_state_set_user(layer_state_t state) {
+    return default_layer_state_set_keymap(state);
+}
+
+__attribute__((weak)) void led_set_keymap(uint8_t usb_led) {}
+
+// Any custom LED code goes here.
+void led_set_user(uint8_t usb_led) { led_set_keymap(usb_led); }
+
+__attribute__((weak)) void eeconfig_init_keymap(void) {}
+
+void eeconfig_init_user(void) {
+    userspace_config.raw              = 0;
+    userspace_config.rgb_layer_change = true;
+    eeconfig_update_user(userspace_config.raw);
+#if (defined(UNICODE_ENABLE) || defined(UNICODEMAP_ENABLE) || defined(UCIS_ENABLE))
+    set_unicode_input_mode(CURRY_UNICODE_MODE);
+    get_unicode_input_mode();
+#else
+    eeprom_update_byte(EECONFIG_UNICODEMODE, CURRY_UNICODE_MODE);
+#endif
+    eeconfig_init_keymap();
+    keyboard_init();
+}
diff --git a/users/curry/curry.h b/users/curry/curry.h
new file mode 100644
index 0000000000..a9de9ae510
--- /dev/null
+++ b/users/curry/curry.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include QMK_KEYBOARD_H
+
+#include "version.h"
+#include "eeprom.h"
+#include "wrappers.h"
+#include "process_records.h"
+
+#ifdef TAP_DANCE_ENABLE
+#    include "tap_dances.h"
+#endif  // TAP_DANCE_ENABLE
+#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
+#    include "rgb_stuff.h"
+#endif
+#if defined(KEYBOARD_lily58_rev1) & defined(PROTOCOL_LUFA)
+#    include "lufa.h"
+#    include "split_util.h"
+#endif
+
+/* Define layer names */
+enum userspace_layers {
+    _QWERTY  = 0,
+    _COLEMAK,
+    _DVORAK,
+    _MODS,
+    _LOWER,
+    _RAISE,
+    _ADJUST,
+};
+
+void          matrix_init_keymap(void);
+void          shutdown_keymap(void);
+void          suspend_power_down_keymap(void);
+void          suspend_wakeup_init_keymap(void);
+void          matrix_scan_keymap(void);
+layer_state_t layer_state_set_keymap(layer_state_t state);
+layer_state_t default_layer_state_set_keymap(layer_state_t state);
+void          led_set_keymap(uint8_t usb_led);
+void          eeconfig_init_keymap(void);
+
+// clang-format off
+typedef union {
+    uint32_t raw;
+    struct {
+        bool    rgb_layer_change     :1;
+        bool    nuke_switch          :1;
+        bool    rgb_matrix_idle_anim :1;
+    };
+} userspace_config_t;
+// clang-format on
+
+extern userspace_config_t userspace_config;
diff --git a/users/curry/glcdfont.c b/users/curry/glcdfont.c
new file mode 100644
index 0000000000..2bfc3fac6d
--- /dev/null
+++ b/users/curry/glcdfont.c
@@ -0,0 +1,241 @@
+#pragma once
+
+#ifdef __AVR__
+#    include <avr/io.h>
+#    include <avr/pgmspace.h>
+#elif defined(ESP8266)
+#    include <pgmspace.h>
+#else
+#    define PROGMEM
+#endif
+
+// Corne 8x6 font with QMK Firmware Logo
+// Online editor: https://helixfonteditor.netlify.com/
+
+// clang-format off
+const unsigned char font[] PROGMEM = {
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x3E, 0x5B, 0x4F, 0x5B, 0x3E, 0x00,
+0x3E, 0x6B, 0x4F, 0x6B, 0x3E, 0x00,
+0x1C, 0x3E, 0x7C, 0x3E, 0x1C, 0x00,
+0x18, 0x3C, 0x7E, 0x3C, 0x18, 0x00,
+0x1C, 0x57, 0x7D, 0x57, 0x1C, 0x00,
+0x1C, 0x5E, 0x7F, 0x5E, 0x1C, 0x00,
+0x00, 0x18, 0x3C, 0x18, 0x00, 0x00,
+0xFF, 0xE7, 0xC3, 0xE7, 0xFF, 0x00,
+0x00, 0x18, 0x24, 0x18, 0x00, 0x00,
+0xFF, 0xE7, 0xDB, 0xE7, 0xFF, 0x00,
+0x30, 0x48, 0x3A, 0x06, 0x0E, 0x00,
+0x26, 0x29, 0x79, 0x29, 0x26, 0x00,
+0x40, 0x7F, 0x05, 0x05, 0x07, 0x00,
+0x40, 0x7F, 0x05, 0x25, 0x3F, 0x00,
+0x5A, 0x3C, 0xE7, 0x3C, 0x5A, 0x00,
+0x7F, 0x3E, 0x1C, 0x1C, 0x08, 0x00,
+0x08, 0x1C, 0x1C, 0x3E, 0x7F, 0x00,
+0x14, 0x22, 0x7F, 0x22, 0x14, 0x00,
+0x5F, 0x5F, 0x00, 0x5F, 0x5F, 0x00,
+0x06, 0x09, 0x7F, 0x01, 0x7F, 0x00,
+0x00, 0x66, 0x89, 0x95, 0x6A, 0x00,
+0x60, 0x60, 0x60, 0x60, 0x60, 0x00,
+0x94, 0xA2, 0xFF, 0xA2, 0x94, 0x00,
+0x08, 0x04, 0x7E, 0x04, 0x08, 0x00,
+0x10, 0x20, 0x7E, 0x20, 0x10, 0x00,
+0x08, 0x08, 0x2A, 0x1C, 0x08, 0x00,
+0x08, 0x1C, 0x2A, 0x08, 0x08, 0x00,
+0x1E, 0x10, 0x10, 0x10, 0x10, 0x00,
+0x0C, 0x1E, 0x0C, 0x1E, 0x0C, 0x00,
+0x30, 0x38, 0x3E, 0x38, 0x30, 0x00,
+0x06, 0x0E, 0x3E, 0x0E, 0x06, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x5F, 0x00, 0x00, 0x00,
+0x00, 0x07, 0x00, 0x07, 0x00, 0x00,
+0x14, 0x7F, 0x14, 0x7F, 0x14, 0x00,
+0x24, 0x2A, 0x7F, 0x2A, 0x12, 0x00,
+0x23, 0x13, 0x08, 0x64, 0x62, 0x00,
+0x36, 0x49, 0x56, 0x20, 0x50, 0x00,
+0x00, 0x08, 0x07, 0x03, 0x00, 0x00,
+0x00, 0x1C, 0x22, 0x41, 0x00, 0x00,
+0x00, 0x41, 0x22, 0x1C, 0x00, 0x00,
+0x2A, 0x1C, 0x7F, 0x1C, 0x2A, 0x00,
+0x08, 0x08, 0x3E, 0x08, 0x08, 0x00,
+0x00, 0x80, 0x70, 0x30, 0x00, 0x00,
+0x08, 0x08, 0x08, 0x08, 0x08, 0x00,
+0x00, 0x00, 0x60, 0x60, 0x00, 0x00,
+0x20, 0x10, 0x08, 0x04, 0x02, 0x00,
+0x3E, 0x51, 0x49, 0x45, 0x3E, 0x00,
+0x00, 0x42, 0x7F, 0x40, 0x00, 0x00,
+0x72, 0x49, 0x49, 0x49, 0x46, 0x00,
+0x21, 0x41, 0x49, 0x4D, 0x33, 0x00,
+0x18, 0x14, 0x12, 0x7F, 0x10, 0x00,
+0x27, 0x45, 0x45, 0x45, 0x39, 0x00,
+0x3C, 0x4A, 0x49, 0x49, 0x31, 0x00,
+0x41, 0x21, 0x11, 0x09, 0x07, 0x00,
+0x36, 0x49, 0x49, 0x49, 0x36, 0x00,
+0x46, 0x49, 0x49, 0x29, 0x1E, 0x00,
+0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
+0x00, 0x40, 0x34, 0x00, 0x00, 0x00,
+0x00, 0x08, 0x14, 0x22, 0x41, 0x00,
+0x14, 0x14, 0x14, 0x14, 0x14, 0x00,
+0x00, 0x41, 0x22, 0x14, 0x08, 0x00,
+0x02, 0x01, 0x59, 0x09, 0x06, 0x00,
+0x3E, 0x41, 0x5D, 0x59, 0x4E, 0x00,
+0x7C, 0x12, 0x11, 0x12, 0x7C, 0x00,
+0x7F, 0x49, 0x49, 0x49, 0x36, 0x00,
+0x3E, 0x41, 0x41, 0x41, 0x22, 0x00,
+0x7F, 0x41, 0x41, 0x41, 0x3E, 0x00,
+0x7F, 0x49, 0x49, 0x49, 0x41, 0x00,
+0x7F, 0x09, 0x09, 0x09, 0x01, 0x00,
+0x3E, 0x41, 0x41, 0x51, 0x73, 0x00,
+0x7F, 0x08, 0x08, 0x08, 0x7F, 0x00,
+0x00, 0x41, 0x7F, 0x41, 0x00, 0x00,
+0x20, 0x40, 0x41, 0x3F, 0x01, 0x00,
+0x7F, 0x08, 0x14, 0x22, 0x41, 0x00,
+0x7F, 0x40, 0x40, 0x40, 0x40, 0x00,
+0x7F, 0x02, 0x1C, 0x02, 0x7F, 0x00,
+0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00,
+0x3E, 0x41, 0x41, 0x41, 0x3E, 0x00,
+0x7F, 0x09, 0x09, 0x09, 0x06, 0x00,
+0x3E, 0x41, 0x51, 0x21, 0x5E, 0x00,
+0x7F, 0x09, 0x19, 0x29, 0x46, 0x00,
+0x26, 0x49, 0x49, 0x49, 0x32, 0x00,
+0x03, 0x01, 0x7F, 0x01, 0x03, 0x00,
+0x3F, 0x40, 0x40, 0x40, 0x3F, 0x00,
+0x1F, 0x20, 0x40, 0x20, 0x1F, 0x00,
+0x3F, 0x40, 0x38, 0x40, 0x3F, 0x00,
+0x63, 0x14, 0x08, 0x14, 0x63, 0x00,
+0x03, 0x04, 0x78, 0x04, 0x03, 0x00,
+0x61, 0x59, 0x49, 0x4D, 0x43, 0x00,
+0x00, 0x7F, 0x41, 0x41, 0x41, 0x00,
+0x02, 0x04, 0x08, 0x10, 0x20, 0x00,
+0x00, 0x41, 0x41, 0x41, 0x7F, 0x00,
+0x04, 0x02, 0x01, 0x02, 0x04, 0x00,
+0x40, 0x40, 0x40, 0x40, 0x40, 0x00,
+0x00, 0x03, 0x07, 0x08, 0x00, 0x00,
+0x20, 0x54, 0x54, 0x78, 0x40, 0x00,
+0x7F, 0x28, 0x44, 0x44, 0x38, 0x00,
+0x38, 0x44, 0x44, 0x44, 0x28, 0x00,
+0x38, 0x44, 0x44, 0x28, 0x7F, 0x00,
+0x38, 0x54, 0x54, 0x54, 0x18, 0x00,
+0x00, 0x08, 0x7E, 0x09, 0x02, 0x00,
+0x18, 0x24, 0x24, 0x1C, 0x78, 0x00,
+0x7F, 0x08, 0x04, 0x04, 0x78, 0x00,
+0x00, 0x44, 0x7D, 0x40, 0x00, 0x00,
+0x20, 0x40, 0x40, 0x3D, 0x00, 0x00,
+0x7F, 0x10, 0x28, 0x44, 0x00, 0x00,
+0x00, 0x41, 0x7F, 0x40, 0x00, 0x00,
+0x7C, 0x04, 0x78, 0x04, 0x78, 0x00,
+0x7C, 0x08, 0x04, 0x04, 0x78, 0x00,
+0x38, 0x44, 0x44, 0x44, 0x38, 0x00,
+0x7C, 0x18, 0x24, 0x24, 0x18, 0x00,
+0x18, 0x24, 0x24, 0x18, 0x7C, 0x00,
+0x7C, 0x08, 0x04, 0x04, 0x08, 0x00,
+0x48, 0x54, 0x54, 0x54, 0x24, 0x00,
+0x04, 0x04, 0x3F, 0x44, 0x24, 0x00,
+0x3C, 0x40, 0x40, 0x20, 0x7C, 0x00,
+0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00,
+0x3C, 0x40, 0x30, 0x40, 0x3C, 0x00,
+0x44, 0x28, 0x10, 0x28, 0x44, 0x00,
+0x4C, 0x90, 0x90, 0x90, 0x7C, 0x00,
+0x44, 0x64, 0x54, 0x4C, 0x44, 0x00,
+0x00, 0x08, 0x36, 0x41, 0x00, 0x00,
+0x00, 0x00, 0x77, 0x00, 0x00, 0x00,
+0x00, 0x41, 0x36, 0x08, 0x00, 0x00,
+0x02, 0x01, 0x02, 0x04, 0x02, 0x00,
+0x3C, 0x26, 0x23, 0x26, 0x3C, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0xC0, 0xE0,
+0xF0, 0xF8, 0xF8, 0x18, 0x00, 0xC0,
+0xF0, 0xFC, 0xFE, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0x7E, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x80, 0xC0, 0xE0, 0xE0,
+0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
+0xC0, 0x80, 0x00, 0x00, 0x00, 0x00,
+0x80, 0xC0, 0xE0, 0xE0, 0xE0, 0xE0,
+0xE0, 0xE0, 0xE0, 0xE0, 0xC0, 0x80,
+0x00, 0x00, 0x00, 0xE0, 0xE0, 0xC0,
+0xC0, 0xE0, 0xE0, 0xE0, 0xE0, 0x00,
+0x00, 0xE0, 0xE0, 0xC0, 0xC0, 0xE0,
+0xE0, 0xE0, 0xE0, 0xE0, 0xC0, 0x80,
+0x00, 0x00, 0x00, 0x00, 0x80, 0xC0,
+0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,
+0xE0, 0xE0, 0xC0, 0x80, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0xE0, 0xF0, 0xF0, 0xF0, 0xE0, 0xEC,
+0xEE, 0xF7, 0xF3, 0x70, 0x20, 0x00,
+0x7C, 0x7C, 0x7C, 0x7E, 0x00, 0x7E,
+0x7E, 0x7E, 0x7F, 0x7F, 0x7F, 0x00,
+0x00, 0x80, 0xC0, 0xE0, 0x7E, 0x5B,
+0x4F, 0x5B, 0xFE, 0xC0, 0x00, 0x00,
+0xC0, 0x00, 0xDC, 0xD7, 0xDE, 0xDE,
+0xDE, 0xD7, 0xDC, 0x00, 0xC0, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0xF8, 0xFC, 0xFE,
+0xFF, 0xE0, 0x00, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0x80, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0x1F, 0x07, 0x01, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0xFF, 0xFF, 0xFF, 0x81, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x81,
+0xC3, 0xC3, 0xC3, 0x00, 0x00, 0xFF,
+0xFF, 0xFF, 0x81, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x81, 0xFF, 0xFF,
+0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
+0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0xFF, 0xFF, 0xFF, 0x01, 0x00,
+0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF,
+0xFF, 0x00, 0x00, 0xFF, 0xFF, 0xFF,
+0x9D, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C,
+0x1C, 0x9D, 0xDF, 0xDF, 0xDF, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x0F, 0x1F, 0x3F, 0x7F, 0x7F, 0x7F,
+0x7F, 0x7F, 0x3F, 0x1E, 0x0C, 0x00,
+0x1F, 0x1F, 0x1F, 0x3F, 0x00, 0x3F,
+0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0x00,
+0x30, 0x7B, 0x7F, 0x78, 0x30, 0x20,
+0x20, 0x30, 0x78, 0x7F, 0x3B, 0x00,
+0x03, 0x00, 0x0F, 0x7F, 0x0F, 0x0F,
+0x0F, 0x7F, 0x0F, 0x00, 0x03, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x03, 0x0F, 0x1F,
+0x3F, 0x3F, 0x3F, 0x3F, 0x1F, 0x1F,
+0x3F, 0x3F, 0x7F, 0x7F, 0x7F, 0x3F,
+0x3F, 0x1F, 0x3F, 0x7F, 0x7F, 0x7F,
+0x7F, 0x7C, 0x78, 0x78, 0x38, 0x1C,
+0x0F, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x01, 0x03, 0x07, 0x07,
+0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+0x03, 0x01, 0x00, 0x00, 0x00, 0x00,
+0x01, 0x03, 0x07, 0x07, 0x07, 0x07,
+0x07, 0x07, 0x07, 0x07, 0x03, 0x01,
+0x00, 0x00, 0x00, 0x07, 0x07, 0x07,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x07, 0x07, 0x07, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x07, 0x07,
+0x07, 0x00, 0x00, 0x00, 0x01, 0x03,
+0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
+0x07, 0x07, 0x03, 0x01, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
diff --git a/users/curry/oled.c b/users/curry/oled.c
new file mode 100644
index 0000000000..4eb23423eb
--- /dev/null
+++ b/users/curry/oled.c
@@ -0,0 +1,162 @@
+#include "curry.h"
+
+#ifdef OLED_DRIVER_ENABLE
+#define KEYLOGGER_LENGTH 5
+static uint32_t oled_timer                       = 0;
+static char     keylog_str[KEYLOGGER_LENGTH + 1] = {"\n"};
+static uint16_t log_timer                        = 0;
+// clang-format off
+static const char PROGMEM code_to_name[0xFF] = {
+//   0    1    2    3    4    5    6    7    8    9    A    B    c    D    E    F
+    ' ', ' ', ' ', ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',  // 0x
+    'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '1', '2',  // 1x
+    '3', '4', '5', '6', '7', '8', '9', '0',  20,  19,  27,  26,  22, '-', '=', '[',  // 2x
+    ']','\\', '#', ';','\'', '`', ',', '.', '/', 128, ' ', ' ', ' ', ' ', ' ', ' ',  // 3x
+    ' ', ' ', ' ', ' ', ' ', ' ', 'P', 'S', ' ', ' ', ' ', ' ',  16, ' ', ' ', ' ',  // 4x
+    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',  // 5x
+    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',  // 6x
+    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',  // 7x
+    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',  // 8x
+    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',  // 9x
+    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',  // Ax
+    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',  // Bx
+    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',  // Cx
+    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',  // Dx
+    'C', 'S', 'A', 'C', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',  // Ex
+    ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '        // Fx
+};
+
+void add_keylog(uint16_t keycode);
+
+oled_rotation_t oled_init_user(oled_rotation_t rotation) { return OLED_ROTATION_270; }
+
+void add_keylog(uint16_t keycode) {
+    if ((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX) || (keycode >= QK_MODS && keycode <= QK_MODS_MAX)) {
+        keycode = keycode & 0xFF;
+    } else if (keycode > 0xFF) {
+        keycode = 0;
+    }
+
+    for (uint8_t i = (KEYLOGGER_LENGTH - 1); i > 0; --i) {
+        keylog_str[i] = keylog_str[i - 1];
+    }
+
+    if (keycode < (sizeof(code_to_name) / sizeof(char))) {
+        keylog_str[0] = pgm_read_byte(&code_to_name[keycode]);
+    }
+
+    log_timer = timer_read();
+}
+
+void render_keylogger_status(void) {
+    oled_write_P(PSTR("Keys"), false);
+    oled_write(keylog_str, false);
+}
+
+void render_default_layer_state(void) {
+    oled_write_P(PSTR("Lyout"), false);
+    switch (get_highest_layer(default_layer_state)) {
+        case _QWERTY:
+            oled_write_P(PSTR(" QRTY"), false);
+            break;
+        case _COLEMAK:
+            oled_write_P(PSTR(" COLE"), false);
+            break;
+        case _DVORAK:
+            oled_write_P(PSTR(" DVRK"), false);
+            break;
+    }
+}
+
+void render_layer_state(void) {
+    oled_write_P(PSTR("LAYER"), false);
+    oled_write_P(PSTR("Lower"), layer_state_is(_LOWER));
+    oled_write_P(PSTR("Raise"), layer_state_is(_RAISE));
+    oled_write_P(PSTR(" Mods"), layer_state_is(_MODS));
+}
+
+void render_keylock_status(uint8_t led_usb_state) {
+    oled_write_P(PSTR("Lock:"), false);
+    oled_write_P(PSTR(" "), false);
+    oled_write_P(PSTR("N"), led_usb_state & (1 << USB_LED_NUM_LOCK));
+    oled_write_P(PSTR("C"), led_usb_state & (1 << USB_LED_CAPS_LOCK));
+    oled_write_ln_P(PSTR("S"), led_usb_state & (1 << USB_LED_SCROLL_LOCK));
+}
+
+void render_mod_status(uint8_t modifiers) {
+    oled_write_P(PSTR("Mods:"), false);
+    oled_write_P(PSTR(" "), false);
+    oled_write_P(PSTR("S"), (modifiers & MOD_MASK_SHIFT));
+    oled_write_P(PSTR("C"), (modifiers & MOD_MASK_CTRL));
+    oled_write_P(PSTR("A"), (modifiers & MOD_MASK_ALT));
+    oled_write_P(PSTR("G"), (modifiers & MOD_MASK_GUI));
+}
+
+void render_bootmagic_status(void) {
+    /* Show Ctrl-Gui Swap options */
+    static const char PROGMEM logo[][2][3] = {
+        {{0x97, 0x98, 0}, {0xb7, 0xb8, 0}},
+        {{0x95, 0x96, 0}, {0xb5, 0xb6, 0}},
+    };
+    oled_write_P(PSTR("BTMGK"), false);
+    oled_write_P(PSTR(" "), false);
+    oled_write_P(logo[0][0], !keymap_config.swap_lctl_lgui);
+    oled_write_P(logo[1][0], keymap_config.swap_lctl_lgui);
+    oled_write_P(PSTR(" "), false);
+    oled_write_P(logo[0][1], !keymap_config.swap_lctl_lgui);
+    oled_write_P(logo[1][1], keymap_config.swap_lctl_lgui);
+    oled_write_P(PSTR(" NKRO"), keymap_config.nkro);
+}
+
+void render_user_status(void) {
+    oled_write_P(PSTR("USER:"), false);
+    oled_write_P(PSTR(" Anim"), userspace_config.rgb_matrix_idle_anim);
+    oled_write_P(PSTR(" Layr"), userspace_config.rgb_layer_change);
+    oled_write_P(PSTR(" Nuke"), userspace_config.nuke_switch);
+}
+
+void render_status_main(void) {
+    /* Show Keyboard Layout  */
+    render_default_layer_state();
+    render_keylock_status(host_keyboard_leds());
+    render_bootmagic_status();
+    render_user_status();
+
+    render_keylogger_status();
+}
+
+void render_status_secondary(void) {
+    /* Show Keyboard Layout  */
+    render_default_layer_state();
+    render_layer_state();
+    render_mod_status(get_mods() | get_oneshot_mods());
+
+    render_keylogger_status();
+}
+
+void oled_task_user(void) {
+    if (timer_elapsed32(oled_timer) > 30000) {
+        oled_off();
+        return;
+    }
+#    ifndef SPLIT_KEYBOARD
+    else {
+        oled_on();
+    }
+#    endif
+    if (is_keyboard_master()) {
+        render_status_main();  // Renders the current keyboard state (layer, lock, caps, scroll, etc)
+    } else {
+        render_status_secondary();
+    }
+}
+
+bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
+    if (record->event.pressed) {
+        oled_timer = timer_read32();
+        add_keylog(keycode);
+    }
+    return true;
+}
+
+#endif
diff --git a/users/curry/process_records.c b/users/curry/process_records.c
new file mode 100644
index 0000000000..fd1d61ad9d
--- /dev/null
+++ b/users/curry/process_records.c
@@ -0,0 +1,85 @@
+#include "curry.h"
+
+uint16_t copy_paste_timer;
+
+__attribute__((weak)) bool process_record_keymap(uint16_t keycode, keyrecord_t *record) { return true; }
+
+__attribute__((weak)) bool process_record_secrets(uint16_t keycode, keyrecord_t *record) { return true; }
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+    xprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
+    switch (keycode) {
+        case KC_MAKE:
+            if (!record->event.pressed) {
+                uint8_t temp_mod = mod_config(get_mods());
+                uint8_t temp_osm = mod_config(get_oneshot_mods());
+                clear_mods();
+                clear_oneshot_mods();
+                send_string_with_delay_P(PSTR("make " QMK_KEYBOARD ":" QMK_KEYMAP), TAP_CODE_DELAY);
+                if ((temp_mod | temp_osm) & MOD_MASK_SHIFT) {
+                    send_string_with_delay_P(PSTR(":flash"), TAP_CODE_DELAY);
+                }
+                if ((temp_mod | temp_osm) & MOD_MASK_CTRL) {
+                    send_string_with_delay_P(PSTR(" -j8 --output-sync"), TAP_CODE_DELAY);
+                }
+#ifdef RGB_MATRIX_SPLIT_RIGHT
+                send_string_with_delay_P(PSTR(" RGB_MATRIX_SPLIT_RIGHT=yes"), TAP_CODE_DELAY);
+#    ifndef OLED_DRIVER_ENABLE
+                send_string_with_delay_P(PSTR(" OLED_DRIVER_ENABLE=no"), TAP_CODE_DELAY);
+#    endif
+#endif
+                send_string_with_delay_P(PSTR(SS_TAP(X_ENTER)), TAP_CODE_DELAY);
+            }
+
+            break;
+
+        case VRSN:  // Prints firmware version
+            if (record->event.pressed) {
+                send_string_with_delay_P(PSTR(QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION ", Built on: " QMK_BUILDDATE), TAP_CODE_DELAY);
+            }
+            break;
+
+        case KC_CCCV:  // One key copy/paste
+            if (record->event.pressed) {
+                copy_paste_timer = timer_read();
+            } else {
+                if (timer_elapsed(copy_paste_timer) > TAPPING_TERM) {  // Hold, copy
+                    register_code(KC_LCTL);
+                    tap_code(KC_C);
+                    unregister_code(KC_LCTL);
+                } else {  // Tap, paste
+                    register_code(KC_LCTL);
+                    tap_code(KC_V);
+                    unregister_code(KC_LCTL);
+                }
+            }
+            break;
+#ifdef UNICODE_ENABLE
+        case UC_FLIP:  // (ノಠ痊ಠ)ノ彡┻━┻
+            if (record->event.pressed) {
+                send_unicode_hex_string("0028 30CE 0CA0 75CA 0CA0 0029 30CE 5F61 253B 2501 253B");
+            }
+            break;
+        case UC_TABL:  // ┬─┬ノ( º _ ºノ)
+            if (record->event.pressed) {
+                send_unicode_hex_string("252C 2500 252C 30CE 0028 0020 00BA 0020 005F 0020 00BA 30CE 0029");
+            }
+            break;
+        case UC_SHRG:  // ¯\_(ツ)_/¯
+            if (record->event.pressed) {
+                send_unicode_hex_string("00AF 005C 005F 0028 30C4 0029 005F 002F 00AF");
+            }
+            break;
+        case UC_DISA:  // ಠ_ಠ
+            if (record->event.pressed) {
+                send_unicode_hex_string("0CA0 005F 0CA0");
+            }
+            break;
+#endif
+    }
+    return process_record_keymap(keycode, record) &&
+#if defined(RGBLIGHT_ENABLE) || defined(RGB_MATRIX_ENABLE)
+           process_record_user_rgb(keycode, record) &&
+#endif  // RGBLIGHT_ENABLE
+           process_record_secrets(keycode, record);
+}
diff --git a/users/curry/process_records.h b/users/curry/process_records.h
new file mode 100644
index 0000000000..6170ed4c7e
--- /dev/null
+++ b/users/curry/process_records.h
@@ -0,0 +1,104 @@
+#pragma once
+#include "curry.h"
+
+#if defined(KEYMAP_SAFE_RANGE)
+#    define PLACEHOLDER_SAFE_RANGE KEYMAP_SAFE_RANGE
+#else