Merge pull request #11 from t4corun/updtkeymap

Settling in on my long term keymap
2025-05-21 06:45:29 -04:00 · 2024-05-12 22:06:14 -05:00 · 2024-05-12 22:06:14 -05:00 · 6a086705c1
commit 6a086705c1
parent aa2a8463fe 978348d115
22 changed files with 314 additions and 434 deletions
--- a/README.md
+++ b/README.md
@ -4,11 +4,10 @@ My userspace for building QMK firmware via GitHub Actions. This does not require

 ## Layout

-The custom layout optimizes for programming (SQL, Powershell, C) and minimizes holds for comfort. It started from [Manna Harbor Miryoku](https://github.com/manna-harbour/miryoku), took heavy influence from [Jonas Hietala T-34](https://www.jonashietala.se/series/t-34/), and trying to achieve [Callum's Minimal Layout](https://github.com/qmk/qmk_firmware/tree/user-keymaps-still-present/users/callum). The keymap designed for split 3x5, two thumbs keys, dual encoders, and combined with a Ploopy Nano trackball mouse. Design themes:
+The custom layout optimizes for programming (SQL, Powershell, C) and minimizes holds for comfort. It started from [Manna Harbor Miryoku](https://github.com/manna-harbour/miryoku) and took heavy influence from [Jonas Hietala T-34](https://www.jonashietala.se/series/t-34/). The keymap designed for split 3x5, two thumbs keys, dual encoders, and combined with a Ploopy Nano trackball mouse. Design themes:

 - Releasing all keys always brings you back to base layer
- Keeping certain keys consistent on all layers for better muscle memory
- Numbers and function keys are positioned similarly
+- Patterns to layout design to reduce learning curve (e.g., Shortcuts in same place on multiple layers)
 - Symbols important for powershell / writing are positioned under stronger fingers
 - Game keymap that doesn't require massive game key bind changes. Tested on Resident Evil 4 Remake

@ -33,15 +32,19 @@ In this userspace, the base split 3x5_3 layout can be adapted for other split ke

 ### Tri-Layer

-Hold both thumb momentary layer keys `NAVIGATION` and `SYMBOL` to access the `NUMBER` layer
+Hold both thumb momentary layer keys `NAVIGATION` and `NUMBER` to access the `SYMBOL` layer

 ### One Shot Mods

-One Shot Mods is here to minimize holding and simplify layers as mods are not required on every layer. Here we have bi-lateral(ish) GACS mods.
+One Shot Mods is here to minimize holding, simplify layers, and avoid misfires from having Home Row Mods. Here we have bi-lateral(ish) GACS mods.
+
+### Mouse Keys
+
+This layout is designed to be used with a Ploopy Nano. Mouse buttons and scroll wheel is handled on the keyboard side via combos. There are macros with the host status (Caps lock, Num Lock) to toggle Ploopy Nano settings and switch to drag scrolling (simulates scroll wheel)

 ### Caps Word

-Caps Word enables temporary all-caps typing without holding shift. Useful to typing programming variables. Tap `shift`  twice to enable Caps Word. It cancels when any key is pressed except
+Caps Word enables temporary all-caps typing without holding shift. Useful to typing programming variables. Tap `shift` twice to enable Caps Word. It cancels when any key is pressed except

 - `numbers 0-9`
 - `backspace`
@ -57,40 +60,52 @@ Certain keys have different behaviors when held vs tapped allowing commonly type
 | `TR_LBRC` | `[`         | `[]` with cursor inside |                                   |
 | `TR_LABK` | `<`         | `<>` with cursor inside |                                   |
 | `TR_LPRN` | `(`         | `()` with cursor inside |                                   |
+| `TR_SQUO` | `"`         | `""` with cursor inside |                                   |
 | `TR_SQUO` | `'`         | `''` with cursor inside |                                   |
-| `TR_EQL`  | `=`         | `==`                    |                                   |
-| `TR_EXLM` | `!`         | `$`                     |                                   |
+| `TR_BSLS` | `\`         | `\\`                    |                                   |
+| `TR_SLSH` | `/`         | `//`                    |                                   |
+| `TR_PIPE` | `\|`        | `\|\|`                  |                                   |
 | `TR_COMM` | `,`         | `(`                     | enables parenthesis on base layer |
 | `TR_DOT`  | `.`         | `)`                     |                                   |
 | `TR_PERC` | `%`         | `^`                     |                                   |
+| `TR_EQL`  | `=`         | `+`                     |                                   |
 | `TR_MINS` | `-`         | `_`                     |                                   |
 | `TR_GRV`  | `backtick`  | `~`                     |                                   |
 | `TR_SCLN` | `;`         | `:`                     |                                   |
 | `TR_QUOT` | `'`         | `"`                     |                                   |
-| `TR_AT`   | `@`         | `&`                     |                                   |
-| `TR_EXLM` | `!`         | `$`                     |                                   |

-Opted to implement overrides here instead of using built-in Key Override functionality because
-
- Not required to press/hold shift to get the alternate key
- Key Overrides would enable holding to repeat keycodes but hard to justify that for the symbols, even for programming
+Opted to implement overrides here instead of using built-in Key Override functionality because this implementation does not require pressing/holding shift to get the alternate key

 ### Combos

-Enables additional keys to be mapped by pressing multiple keys simultaneously. Primarily used to implement mouse buttons and make important keys (enter, backspace, etc) available on base layer
+Enables additional keys to be mapped by pressing multiple keys simultaneously. Primarily used to implement mouse buttons and make important keys (tab, backspace, etc) available on base layer. Combos are mapped based on the QWERTY layout but will work on any layer*. All Combos are disabled when `CONFIG` layer is active
+
+| Combo         | Result               | Comment                                           |
+| ------------- | -------------------- | ------------------------------------------------- |
+| `D` + `F`     | `Mouse Button 1`     | Left click. Mouse buttons only work on base layer |
+| `S` + `D`     | `Mouse Button 2`     | RIght click                                       |
+| `F` + `G`     | `Mouse Button 3`     | Middle click                                      |
+| `R` + `F`     | `Mouse Button 4`     | Back                                              |
+| `T` + `G`     | `Mouse Button 5`     | Forward                                           |
+| `T` + `G`     | `Drag Scroll Toggle` |                                                   |
+| `C` + `V`     | `Enter`              |                                                   |
+| `U` + `I`     | `Tab`                |                                                   |
+| `M` + `Comma` | `Backspace`          |                                                   |

 ### Key Overrides

-Primarily used to minimize the layout
+Enables us to customize the result of applying certain mods to keycodes. For example, Shift + Backspace will give Delete. Primarily used to minimize the number of layers required and the layout itself

-| Keycode   | Shift Mod Applied | Comment                                |
-| --------- | ----------------- | -------------------------------------- |
-| `KC_BSPC` | `KC_DEL`          | Implemented to reduce amount of combos |
-| `KC_MNXT` | `KC_MPRV`         |                                        |
-
-### Mouse Keys
-
-This layout is designed to be used with a Ploopy Nano. Mouse buttons and scroll wheel is handled on the keyboard side. There are macros with the host status (Caps lock, Num Lock) to toggle Ploopy Nano settings or change the tracking to simulate a scroll wheel
+| Shortcut              | Result               | Comment                                                                       |
+| --------------------- | -------------------- | ----------------------------------------------------------------------------- |
+| `Shift` + `Backspace` | `Delete`             | Backspace is a combo. There are no dedicated backspace and delete keys mapped |
+| `Shift` + `Next Song` | `Prev Song`          | Only works on `NAVIGATION` layer                                              |
+| `Meh` + `1...9`       | `F1...F9`            | Only works on `NUMBER` layer. Meh is Shift + Ctrl + Alt.                      |
+| `Meh` + `Comma`       | `F10`                | Only works on `NUMBER` layer                                                  |
+| `Meh` + `Dot`         | `F11`                | Only works on `NUMBER` layer                                                  |
+| `Meh` + `Minus`       | `F12`                | Only works on `NUMBER` layer                                                  |
+| `Ctrl` + `Mouse 1`    | `Print Screen`       | Only works on `NUMBER` layer                                                  |
+| `Alt` + `Mouse 2`     | `Open File Explorer` | Only works on `NUMBER` layer. Keyboard Shortcut `GUI` + `E`                   |

 ## Optional Features

--- a/keyboards/barbellboards/rollow/keymaps/t4corun/keymap.c
+++ b/keyboards/barbellboards/rollow/keymaps/t4corun/keymap.c
@ -19,13 +19,13 @@ LAYOUT_rollow_wrapper ( \

 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

-  [_DEFAULT_LAYER_1] = ROLLOW(LAYER_QWERTY),
-  [_DEFAULT_LAYER_2] = ROLLOW(LAYER_COLEMAK_DH),
-  [_DEFAULT_LAYER_3] = ROLLOW(LAYER_GAME),
-  [_NAVIGATION]      = ROLLOW(LAYER_NAVIGATION),
-  [_SYMBOL]          = ROLLOW(LAYER_SYMBOL),
-  [_NUMBER]          = ROLLOW(LAYER_NUMBER),
-  [_CONFIG]          = ROLLOW(LAYER_CONFIG)
+  [_QWERTY]     = ROLLOW(LAYER_QWERTY),
+  [_COLEMAK_DH] = ROLLOW(LAYER_COLEMAK_DH),
+  [_GAME]       = ROLLOW(LAYER_GAME),
+  [_NAVIGATION] = ROLLOW(LAYER_NAVIGATION),
+  [_NUMBER]     = ROLLOW(LAYER_NUMBER),
+  [_SYMBOL]     = ROLLOW(LAYER_SYMBOL),
+  [_CONFIG]     = ROLLOW(LAYER_CONFIG)

 };

@ -34,13 +34,15 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

 /* These are horizontal encoders. Found I have to make it opposite the rotary encoders for it to feel intuitive*/
 const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS] = {
-  [_DEFAULT_LAYER_1] = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD)  },
-  [_DEFAULT_LAYER_2] = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD)  },
-  [_DEFAULT_LAYER_3] = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD)  },
-  [_NAVIGATION]      = { ENCODER_CCW_CW(ZOOMIN,  ZOOMOUT), ENCODER_CCW_CW(___x___, ___x___)  },
-  [_SYMBOL]          = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(KC_RGHT, KC_LEFT)  },
-  [_NUMBER]          = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(___x___, ___x___)  },
-  [_CONFIG]          = { ENCODER_CCW_CW(BASELYR, RBSELYR), ENCODER_CCW_CW(TR_RMOD, TR_RRMD)  }
+
+  [_QWERTY]     = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD)  },
+  [_COLEMAK_DH] = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD)  },
+  [_GAME]       = { ENCODER_CCW_CW(KC_WH_D, KC_WH_U), ENCODER_CCW_CW(KC_VOLU, KC_VOLD)  },
+  [_NAVIGATION] = { ENCODER_CCW_CW(ZOOMIN,  ZOOMOUT), ENCODER_CCW_CW(___x___, ___x___)  },
+  [_NUMBER]     = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(KC_RGHT, KC_LEFT)  },
+  [_SYMBOL]     = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(___x___, ___x___)  },
+  [_CONFIG]     = { ENCODER_CCW_CW(BASELYR, RBSELYR), ENCODER_CCW_CW(TR_RMOD, TR_RRMD)  }
+
 };

 #endif
--- a/keyboards/bastardkb/charybdis/3x5/keymaps/t4corun/keymap.c
+++ b/keyboards/bastardkb/charybdis/3x5/keymaps/t4corun/keymap.c
@ -19,12 +19,12 @@ LAYOUT_cnano_wrapper ( \

 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

-  [_DEFAULT_LAYER_1] = CNANO(LAYER_QWERTY),
-  [_DEFAULT_LAYER_2] = CNANO(LAYER_COLEMAK_DH),
-  [_DEFAULT_LAYER_3] = CNANO(LAYER_GAME),
-  [_NAVIGATION]      = CNANO(LAYER_NAVIGATION),
-  [_SYMBOL]          = CNANO(LAYER_SYMBOL),
-  [_NUMBER]          = CNANO(LAYER_NUMBER),
-  [_CONFIG]          = CNANO(LAYER_CONFIG)
+  [_QWERTY]     = CNANO(LAYER_QWERTY),
+  [_COLEMAK_DH] = CNANO(LAYER_COLEMAK_DH),
+  [_GAME]       = CNANO(LAYER_GAME),
+  [_NAVIGATION] = CNANO(LAYER_NAVIGATION),
+  [_NUMBER]     = CNANO(LAYER_NUMBER),
+  [_SYMBOL]     = CNANO(LAYER_SYMBOL),
+  [_CONFIG]     = CNANO(LAYER_CONFIG)

 };
--- a/keyboards/bluebell/swoop/keymaps/t4corun/keymap.c
+++ b/keyboards/bluebell/swoop/keymaps/t4corun/keymap.c
@ -19,13 +19,13 @@ LAYOUT_swoop_wrapper ( \

 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

-  [_DEFAULT_LAYER_1] = SWOOP(LAYER_QWERTY),
-  [_DEFAULT_LAYER_2] = SWOOP(LAYER_COLEMAK_DH),
-  [_DEFAULT_LAYER_3] = SWOOP(LAYER_GAME),
-  [_NAVIGATION]      = SWOOP(LAYER_NAVIGATION),
-  [_SYMBOL]          = SWOOP(LAYER_SYMBOL),
-  [_NUMBER]          = SWOOP(LAYER_NUMBER),
-  [_CONFIG]          = SWOOP(LAYER_CONFIG)
+  [_QWERTY]     = SWOOP(LAYER_QWERTY),
+  [_COLEMAK_DH] = SWOOP(LAYER_COLEMAK_DH),
+  [_GAME]       = SWOOP(LAYER_GAME),
+  [_NAVIGATION] = SWOOP(LAYER_NAVIGATION),
+  [_NUMBER]     = SWOOP(LAYER_NUMBER),
+  [_SYMBOL]     = SWOOP(LAYER_SYMBOL),
+  [_CONFIG]     = SWOOP(LAYER_CONFIG)

 };

@ -34,13 +34,15 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

 /* The encoder presses are handled in the keymap */
 const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS] = {
-  [_DEFAULT_LAYER_1] = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU)  },
-  [_DEFAULT_LAYER_2] = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU)  },
-  [_DEFAULT_LAYER_3] = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU)  },
-  [_NAVIGATION]      = { ENCODER_CCW_CW(ZOOMOUT, ZOOMIN),  ENCODER_CCW_CW(___x___, ___x___)  },
-  [_SYMBOL]          = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(KC_LEFT, KC_RGHT)  },
-  [_NUMBER]          = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(___x___, ___x___)  },
-  [_CONFIG]          = { ENCODER_CCW_CW(RBSELYR, BASELYR), ENCODER_CCW_CW(TR_RRMD, TR_RMOD)  }
+
+  [_QWERTY]     = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU)  },
+  [_COLEMAK_DH] = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU)  },
+  [_GAME]       = { ENCODER_CCW_CW(KC_WH_U, KC_WH_D), ENCODER_CCW_CW(KC_VOLD, KC_VOLU)  },
+  [_NAVIGATION] = { ENCODER_CCW_CW(ZOOMOUT, ZOOMIN),  ENCODER_CCW_CW(___x___, ___x___)  },
+  [_NUMBER]     = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(KC_LEFT, KC_RGHT)  },
+  [_SYMBOL]     = { ENCODER_CCW_CW(___x___, ___x___), ENCODER_CCW_CW(___x___, ___x___)  },
+  [_CONFIG]     = { ENCODER_CCW_CW(RBSELYR, BASELYR), ENCODER_CCW_CW(TR_RRMD, TR_RMOD)  }
+
 };

 #endif //ENCODER_MAP_ENABLE
--- a/keyboards/crkbd/keymaps/t4corun/keymap.c
+++ b/keyboards/crkbd/keymaps/t4corun/keymap.c
@ -19,12 +19,12 @@ LAYOUT_crkbd_wrapper ( \

 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

-  [_DEFAULT_LAYER_1] = CRKBD(LAYER_QWERTY),
-  [_DEFAULT_LAYER_2] = CRKBD(LAYER_COLEMAK_DH),
-  [_DEFAULT_LAYER_3] = CRKBD(LAYER_GAME),
-  [_NAVIGATION]      = CRKBD(LAYER_NAVIGATION),
-  [_SYMBOL]          = CRKBD(LAYER_SYMBOL),
-  [_NUMBER]          = CRKBD(LAYER_NUMBER),
-  [_CONFIG]          = CRKBD(LAYER_CONFIG)
+  [_QWERTY]     = CRKBD(LAYER_QWERTY),
+  [_COLEMAK_DH] = CRKBD(LAYER_COLEMAK_DH),
+  [_GAME]       = CRKBD(LAYER_GAME),
+  [_NAVIGATION] = CRKBD(LAYER_NAVIGATION),
+  [_NUMBER]     = CRKBD(LAYER_NUMBER),
+  [_SYMBOL]     = CRKBD(LAYER_SYMBOL),
+  [_CONFIG]     = CRKBD(LAYER_CONFIG)

 };
--- a/keyboards/planck/keymaps/t4corun/keymap.c
+++ b/keyboards/planck/keymaps/t4corun/keymap.c
@ -19,12 +19,12 @@ LAYOUT_planck_wrapper ( \

 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {

-  [_DEFAULT_LAYER_1] = PLANCK(LAYER_QWERTY),
-  [_DEFAULT_LAYER_2] = PLANCK(LAYER_COLEMAK_DH),
-  [_DEFAULT_LAYER_3] = PLANCK(LAYER_GAME),
-  [_NAVIGATION]      = PLANCK(LAYER_NAVIGATION),
-  [_SYMBOL]          = PLANCK(LAYER_SYMBOL),
-  [_NUMBER]          = PLANCK(LAYER_NUMBER),
-  [_CONFIG]          = PLANCK(LAYER_CONFIG)
+  [_QWERTY]     = PLANCK(LAYER_QWERTY),
+  [_COLEMAK_DH] = PLANCK(LAYER_COLEMAK_DH),
+  [_GAME]       = PLANCK(LAYER_GAME),
+  [_NAVIGATION] = PLANCK(LAYER_NAVIGATION),
+  [_NUMBER]     = PLANCK(LAYER_NUMBER),
+  [_SYMBOL]     = PLANCK(LAYER_SYMBOL),
+  [_CONFIG]     = PLANCK(LAYER_CONFIG)

 };
--- a/keymap-drawer.yml
+++ b/keymap-drawer.yml
@ -4,8 +4,8 @@ layout:
 layers:
  base_QWERTY:
    - [Q, W, E, R, T, Y, U, I ,O, P]
-    - [A, S, D, F, G, H, J, K ,L, {h: '"', t: ''''}]
-    - [Z, X, C, V, B, N, M, {h: '(', t: ','} , {h: ')', t: '.'}, {h: '_', t: '-'}]
+    - [A, S, D, F, G, H, J, K ,L, {h: "\"", t: "'"}]
+    - [Z, X, C, V, B, N, M, {h: "(", t: ","} , {h: ")", t: "."}, {h: "_", t: "-"}]
    - {type: ghost}
    - NUM
    - Shift
@ -13,9 +13,9 @@ layers:
    - NAV
    - {t: Mute, type: ghost}
  base_COLEMAK_DH:
-    - [Q, W, F, P, B, J, L, U ,Y, {h: '"', t: ''''}]
+    - [Q, W, F, P, B, J, L, U ,Y, {h: "\"", t: "'"}]
    - [A, R, S, T, G, M, N, E ,I, O]
-    - [Z, X, C, D, V, K, H, {h: '(', t: ','} , {h: ')', t: '.'}, {h: '_', t: '-'}]
+    - [Z, X, C, D, V, K, H, {h: "(", t: ","} , {h: ")", t: "."}, {h: "_", t: "-"}]
    - {type: ghost}
    - NUM
    - Shift
@ -23,9 +23,9 @@ layers:
    - NAV
    - {t: Mute, type: ghost}
  base_GAME:
-    - [Tab, Q, W, E, R, T, '7', '8' ,'9', Esc]
-    - [Ctrl, A, S, D, F, G, '4', '5' ,'6', '`']
-    - [Z, X, C, V, B, Alt, '1', '2' ,'3', Combo Toggle]
+    - [Tab, Q, W, E, R, T, "7", "8" ,"9", Esc]
+    - [Ctrl, A, S, D, F, G, "4", "5" ,"6", {s: "~", t: "`"}]
+    - [Z, X, C, V, B, Alt, "1", "2" ,"3", Combo Toggle]
    - {t: Enter, type: ghost}
    - Space
    - Shift
@ -33,29 +33,29 @@ layers:
    - NAV
    - {t: Mute, type: ghost}
  NAV:
-    - [null, Home, ▲, End, Page Up, null, null, Caps Lock, Print Screen, CONFIG ]
+    - [Esc, Home, ▲, End, Page Up, null, null, null, null, CONFIG ]
    - [null, ◄, ▼, ►, Page Down, null, Shift, Ctrl, Alt, Gui ]
    - [Undo, Cut, Copy, Paste, Redo, null, App, Sniper Toggle, Sniper DPI, Pointer DPI ]
    - {t: Zoom Reset, type: ghost}
    - NUM
-    - Space
+    - Ent
    - null
    - {type: held}
-    - {t: Mute, type: ghost}
-  SYM:
-    - [Esc, Mouse 3, Mouse 2, Mouse 1, {h: '~', t: '`'}, {h: '==', t: '='}, '#', {h: '<>', t: '<'}, '>', {h: '^', t: '%'}]
-    - [Gui, Alt, Ctrl, Shift, {h: ':', t: ';'}, {h: '&', t: '@'}, {h: '*', t: '?'}, {h: '[]', t: '['}, ']', {h: '''''', t: ''''}]
-    - [Undo, Cut, Copy, Paste, Redo, {h: '\\', t: "\\"}, {h: '//', t: '/'}, {h: '()', t: '('}, ')', {h: '_', t: '-'}]
-    - {type: ghost}
-    - {type: held}
-    - null
-    - {h: '$', t: '!'}
-    - NAV
    - {type: ghost}
  NUM:
-    - [F7, F5, F3, F1, F9, F8, F10, F2, F4, F6]
-    - ['7', '5', '3', '1', '9', '8', '0', '2' , '4', '6' ]
-    - [Mute, Vol-, Vol+, Next, Play Pause, F11, F12, {h: '(', t: ','} , {h: ')', t: '.'}, {h: '_', t: '-'}]
+    - [Esc, Mouse 3, Mouse 2, Mouse 1, {h: "~", t: "`"}, null, "7", "8" ,"9", {s: "<", t: ","} ]
+    - [Gui, Alt, Ctrl, Shift, {h: ":", t: ";"}, "0", "4", "5" ,"6", {s: ">", t: "."}]
+    - [Undo, Cut, Copy, Paste, Redo, null, "1", "2" ,"3", {s: "_", t: "-"}]
+    - {type: ghost}
+    - {type: held}
+    - null
+    - Space
+    - NAV
+    - {t: Mute, type: ghost}
+  SYM:
+    - [null, null, "&", {h: "%", t: "^"}, {h: "~", t: "`"}, {h: "+", t: "="}, "#", "*", null, {h: "\"\"", t: "\""}]
+    - [Caps Lock, {h: "{}", t: "{"}, "}", "!", {h: ":", t: ";"}, "@", "?", {h: "[]", t: "]"}, "]", {h: "''", t: "'"}]
+    - [null, {h: "<>", t: "<"}, ">", {h: "\\\\", t: "\\"}, {h: "||", t: "|"}, "$", {h: "//", t: "/"}, {h: "()", t: "("}, ")", {h: "_", t: "-"}]
    - {type: ghost}
    - {type: held}
    - null
@ -65,7 +65,7 @@ layers:
  CONFIG:
    - [null, null, null, null, null, null, null, EEPROM Clear, Boot Loader, {type: held}]
    - [null, null, null, null, null, null, Shift, null, null, RGB Mode]
-    - [null, null, null, null, null, RGB Toggle, RGB Hue, RGB Sat, RGB Vib, RGB Spd]
+    - [Mute, Vol-, Vol+, Next Song, Play Pause, RGB Toggle, RGB Hue, RGB Sat, RGB Vib, RGB Spd]
    - {t: Base Layer, type: ghost}
    - null
    - null
--- a/my_keymap.png
+++ b/my_keymap.png
--- a/users/t4corun/config/tapping_config.h
+++ b/users/t4corun/config/tapping_config.h
@ -26,10 +26,9 @@
 #define TAP_HOLD_CAPS_DELAY TAP_CODE_DELAY  //turning down delay for caps lock so ploopy can do DPI switching
 #define WAIT_DELAY 5                        //custom variable to configure time between taps

-#define TAPPING_TERM 200
-#define TAPPING_TERM_PER_KEY
+#define TAPPING_TERM 175

-#define QUICK_TAP_TERM 135
+#define QUICK_TAP_TERM 120

 #define ONESHOT_TAP_TOGGLE 3
 #define ONESHOT_TIMEOUT 2000
--- a/users/t4corun/features/capsword.c
+++ b/users/t4corun/features/capsword.c
@ -3,9 +3,12 @@
 //static bool caps_word_state = false;

 bool caps_word_press_user(uint16_t keycode) {
+
  switch (keycode) {
+
    // Keycodes that continue Caps Word, with shift applied.
    case KC_A ... KC_Z:
+
    case KC_MINS:
      add_weak_mods(MOD_BIT(KC_LSFT));  // Apply shift to next key.
      return true;
@ -19,5 +22,7 @@ bool caps_word_press_user(uint16_t keycode) {

    default:
      return false;  // Deactivate Caps Word.
+
  }
+
 }
--- a/users/t4corun/features/combo.c
+++ b/users/t4corun/features/combo.c
@ -17,43 +17,28 @@ bool get_combo_must_tap(uint16_t index, combo_t *combo) {

    default:
      return false;
+
  }
+
 }

 bool combo_should_trigger(uint16_t combo_index, combo_t *combo, uint16_t keycode, keyrecord_t *record) {

  // disable all combos on config layer
-  if ( get_highest_layer(layer_state) == _CONFIG ) {
-    return false;
-  }
+  if ( get_highest_layer(layer_state | default_layer_state) == _CONFIG ) return false;

  switch (combo_index) {

-    case KEY_ENT:
-      if ( get_highest_layer(layer_state) == _SYMBOL ) {
-        return false;
-      }
-      break;
-
-    case KEY_TAB:
-      if (  get_highest_layer(layer_state) == _NAVIGATION ||
-            get_highest_layer(layer_state) == _SYMBOL ) {
-        return false;
-      }
-      break;
-
    case MOUSE_BUTTON1:
    case MOUSE_BUTTON2:
    case MOUSE_BUTTON3:
    case MOUSE_BUTTON4:
    case MOUSE_BUTTON5:
    case MOUSE_DRGTOG:
-      if (  get_highest_layer(layer_state) > _DEFAULT_LAYER_1 ) {
-        return false;
-      }
-      break;
+      if ( get_highest_layer(layer_state | default_layer_state) > _DEFAULT_LAYER_1 ) return false;

+    default:
+      return true;
  }

-  return true;
 }
--- a/users/t4corun/features/combo.h
+++ b/users/t4corun/features/combo.h
@ -34,6 +34,7 @@ enum combos {
  KEY_BSPC,

  COMBO_LENGTH
+
 };


--- a/users/t4corun/features/keyoverride.c
+++ b/users/t4corun/features/keyoverride.c
@ -13,12 +13,45 @@ Intentionally did not convert all the override/autoshit tap holds to this format


 const key_override_t delete_override     = ko_make_basic(MOD_MASK_SHIFT, KC_BSPC, KC_DEL);
-const key_override_t media_next_override = ko_make_basic(MOD_MASK_SHIFT, KC_MNXT, KC_MPRV);

-const key_override_t **key_overrides = (const key_override_t *[]){
+const key_override_t media_next_override = ko_make_with_layers(MOD_MASK_SHIFT, KC_MNXT, KC_MPRV, 1<<_NAVIGATION);
+
+const key_override_t f1_override         = ko_make_with_layers(MOD_MASK_CSA,   KC_1,    KC_F1,   1<<_NUMBER);
+const key_override_t f2_override         = ko_make_with_layers(MOD_MASK_CSA,   KC_2,    KC_F2,   1<<_NUMBER);
+const key_override_t f3_override         = ko_make_with_layers(MOD_MASK_CSA,   KC_3,    KC_F3,   1<<_NUMBER);
+const key_override_t f4_override         = ko_make_with_layers(MOD_MASK_CSA,   KC_4,    KC_F4,   1<<_NUMBER);
+const key_override_t f5_override         = ko_make_with_layers(MOD_MASK_CSA,   KC_5,    KC_F5,   1<<_NUMBER);
+const key_override_t f6_override         = ko_make_with_layers(MOD_MASK_CSA,   KC_6,    KC_F6,   1<<_NUMBER);
+const key_override_t f7_override         = ko_make_with_layers(MOD_MASK_CSA,   KC_7,    KC_F7,   1<<_NUMBER);
+const key_override_t f8_override         = ko_make_with_layers(MOD_MASK_CSA,   KC_8,    KC_F8,   1<<_NUMBER);
+const key_override_t f9_override         = ko_make_with_layers(MOD_MASK_CSA,   KC_9,    KC_F9,   1<<_NUMBER);
+const key_override_t f10_override        = ko_make_with_layers(MOD_MASK_CSA,   KC_COMM, KC_F10,  1<<_NUMBER);
+const key_override_t f11_override        = ko_make_with_layers(MOD_MASK_CSA,   KC_DOT,  KC_F11,  1<<_NUMBER);
+const key_override_t f12_override        = ko_make_with_layers(MOD_MASK_CSA,   KC_MINS, KC_F12,  1<<_NUMBER);
+
+const key_override_t mb1_override        = ko_make_with_layers(MOD_MASK_CTRL,  KC_BTN1, KC_PSCR, 1<<_NUMBER);
+const key_override_t mb2_override        = ko_make_with_layers(MOD_MASK_ALT,   KC_BTN2, SC_FILE, 1<<_NUMBER);
+
+
+
+const key_override_t **key_overrides = (const key_override_t *[]) {

  &delete_override,
  &media_next_override,
+  &f1_override,
+  &f2_override,
+  &f3_override,
+  &f4_override,
+  &f5_override,
+  &f6_override,
+  &f7_override,
+  &f8_override,
+  &f9_override,
+  &f10_override,
+  &f11_override,
+  &f12_override,
+  &mb1_override,
+  &mb2_override,
  NULL // Null terminate the array of overrides!

 };
--- a/users/t4corun/features/oled.c
+++ b/users/t4corun/features/oled.c
@ -1,19 +1,27 @@
 #include "oled.h"

 void render_crkbd_logo(void) {
+
  oled_write_P(crkbd_logo, false);
+
 }

 void render_rollow_logo(void) {
+
  oled_write_raw_P(rollow_logo, sizeof(rollow_logo));
+
 }

 void render_qmk_logo(void) {
+
  oled_write_raw_P(qmk_logo, sizeof(qmk_logo));
+
 }

 void render_default_layer_state(void) {
+
  oled_write_P(PSTR(OLED_RENDER_LAYOUT_NAME), false);
+
  switch (get_highest_layer(default_layer_state)) {

    case _QWERTY:
@ -27,31 +35,37 @@ void render_default_layer_state(void) {
    case _GAME:
      oled_write_P(PSTR(OLED_RENDER_LAYOUT_GAME), false);
      break;
+
  }
+
 }


 void render_layer_state(void) {
-  oled_write_P(PSTR(OLED_RENDER_LAYER_NAME), false);
-  oled_write_P(PSTR(OLED_RENDER_LAYER_BASE), get_highest_layer(layer_state) == FIRST_DEFAULT_LAYER);  
+
+  oled_write_P(PSTR(OLED_RENDER_LAYER_NAME),       false);
+  oled_write_P(PSTR(OLED_RENDER_LAYER_BASE),       get_highest_layer(layer_state) == FIRST_DEFAULT_LAYER);  
  oled_write_P(PSTR(OLED_RENDER_LAYER_NAVIGATION), get_highest_layer(layer_state) == _NAVIGATION);
-  oled_write_P(PSTR(OLED_RENDER_LAYER_SYMBOL), get_highest_layer(layer_state) == _SYMBOL);
-  oled_write_P(PSTR(OLED_RENDER_LAYER_NUMBER), get_highest_layer(layer_state) == _NUMBER);
-  oled_write_P(PSTR(OLED_RENDER_LAYER_CONFIG), get_highest_layer(layer_state) == _CONFIG);
+  oled_write_P(PSTR(OLED_RENDER_LAYER_NUMBER),     get_highest_layer(layer_state) == _NUMBER);
+  oled_write_P(PSTR(OLED_RENDER_LAYER_SYMBOL),     get_highest_layer(layer_state) == _SYMBOL);
+  oled_write_P(PSTR(OLED_RENDER_LAYER_CONFIG),     get_highest_layer(layer_state) == _CONFIG);
+
 }


 void render_keylock_status(void) {
+
  oled_write_P(PSTR(OLED_RENDER_KEYLOCK_NAME), false);
  oled_write_P(PSTR(" "), false);
  oled_write_P(PSTR("N"), host_keyboard_led_state().num_lock);
  oled_write_P(PSTR("C"), host_keyboard_led_state().caps_lock || is_caps_word_on() );
  oled_write_ln_P(PSTR("S"), host_keyboard_led_state().scroll_lock );
+
 }


 void render_mod_status(void) {
-  
+
  uint8_t current_mod = get_mods();
  uint8_t current_osm = get_oneshot_mods();

@ -67,6 +81,7 @@ void render_mod_status(void) {
  oled_write_P(PSTR("C"), isCtrl );
  oled_write_P(PSTR("A"), isAlt );
  oled_write_P(PSTR("G"), isGUI );  
+
 }


@ -81,26 +96,39 @@ void render_oled_main(void) {


 bool oled_task_user(void) {
-  
+
  if (is_keyboard_master()) {
+
    render_oled_main();  // Renders the current keyboard state (layer, lock, caps, scroll, etc)
+
  } else {
-#if defined( KEYBOARD_barbellboards_rollow )
+
+#if defined(KEYBOARD_barbellboards_rollow)
    render_rollow_logo();
-#elif defined( KEYBOARD_crkbd )
+#elif defined(KEYBOARD_crkbd)
    render_crkbd_logo();
 #else
    render_qmk_logo();
 #endif
+
  }
+
  return false;
+
 }


+
 oled_rotation_t oled_init_user(oled_rotation_t rotation) {
+
  if (is_keyboard_master()) {
+
    return OLED_ROTATION_270;
+
  } else {
+
    return OLED_ROTATION_0;
+
  }
+
 }
--- a/users/t4corun/features/oled.h
+++ b/users/t4corun/features/oled.h
@ -13,8 +13,8 @@
 #define OLED_RENDER_LAYER_NAME        "Layer"
 #define OLED_RENDER_LAYER_BASE        " Def "
 #define OLED_RENDER_LAYER_NAVIGATION  " Nav "
-#define OLED_RENDER_LAYER_SYMBOL      " Sym "
 #define OLED_RENDER_LAYER_NUMBER      " Num "
+#define OLED_RENDER_LAYER_SYMBOL      " Sym "
 #define OLED_RENDER_LAYER_CONFIG      " Cfg "

 void              render_crkbd_logo(void);
--- a/users/t4corun/features/taphold.c
+++ b/users/t4corun/features/taphold.c
@ -1,175 +1,49 @@
 #include "taphold.h"

-void single_tap(uint16_t key, uint16_t altkey, bool isHold) {
-  isHold ? tap_code16(altkey) : tap_code16(key);
-}

-void double_tap(uint16_t key, uint16_t altkey, uint32_t ms) {
-  bool isShift = ( (get_mods() & MOD_BIT(KC_LSFT)) || (get_oneshot_mods() & MOD_BIT(KC_LSFT)) );
-  
-  isShift ? tap_code16(LSFT(key)) : tap_code16(key);
+void double_tap(uint16_t key, uint32_t ms) {
+
+  tap_code16(key);
  wait_ms(ms);
-  isShift ? tap_code16(LSFT(altkey)) : tap_code16(altkey);
+  tap_code16(key);
+
 }

 void insert_brackets(uint16_t left, uint16_t right, uint32_t ms) {
-  bool isShift = ( (get_mods() & MOD_BIT(KC_LSFT)) || (get_oneshot_mods() & MOD_BIT(KC_LSFT)) );

-  isShift ? tap_code16(LSFT(left)) : tap_code16(left);
+  tap_code16(left);
  wait_ms(ms);
-  isShift ? tap_code16(LSFT(right)) : tap_code16(right);
+  tap_code16(right);
  wait_ms(ms);
  tap_code16(KC_LEFT);
+
 }

-// here we can have the holds be more complex, like sending "" when you hold "
-bool process_tap_hold_key(keyrecord_t* record, uint16_t keycode) {
+bool process_tap_hold_key(keyrecord_t* record, uint16_t tap_keycode, uint16_t hold_keycode, int mode) {

-  // tap is record->tap.count && record->event.pressed
-  // hold is record->event.pressed
+  if (record->tap.count > 0) { // Key is being tapped

-  // just saving this to handle mods
-  // bool isShift = ( (get_mods() & MOD_BIT(KC_LSFT)) || (get_oneshot_mods() & MOD_BIT(KC_LSFT)) );
-  // isShift ? insert_brackets(LSFT(key), LSFT(altkey)) : insert_brackets(key, altkey);
+    // register on press, unregister on release
+    record->event.pressed ? register_code16(tap_keycode) : unregister_code16(tap_keycode);

-  bool isHold = false;
+  } else { // Key is being held

-  if (record->tap.count && record->event.pressed) {
+    switch (mode) {

-    switch(keycode) {
-
-      case TR_LCBR:
-        single_tap(TAPHOLD_LCBR, isHold);
-        break;
-      case TR_LABK:
-        single_tap(TAPHOLD_LABK, isHold);
-        break;
-      case TR_LBRC:
-        single_tap(TAPHOLD_LBRC, isHold);
-        break;
-      case TR_LPRN:
-        single_tap(TAPHOLD_LPRN, isHold);
-        break;
-      case TR_SQUO:
-        single_tap(TAPHOLD_SQUO, isHold);
-        break;
-      case TR_EQL:
-        single_tap(TAPHOLD_EQL, isHold);
-        break;
-      case TR_BSLS:
-        single_tap(TAPHOLD_BSLS, isHold);
-        break;
-      case TR_SLSH:
-        single_tap(TAPHOLD_SLSH, isHold);
-        break;
-      case TR_COMM:
-        single_tap(TAPHOLD_COMM, isHold);
-        break;
-      case TR_DOT:
-        single_tap(TAPHOLD_DOT, isHold);
-        break;
-      case TR_PERC:
-        single_tap(TAPHOLD_PERC, isHold);
-        break;
-      case TR_EXLM:
-        single_tap(TAPHOLD_EXLM, isHold);
-        break;
-      case TR_AT:
-        single_tap(TAPHOLD_AT, isHold);
-        break;
-      case TR_QUES:
-        single_tap(TAPHOLD_QUES, isHold);
-        break;
-      case TR_MINS:
-        single_tap(TAPHOLD_MINS, isHold);
-        break;
-      case TR_GRV:
-        single_tap(TAPHOLD_GRV, isHold);
-        break;
-      case TR_SCLN:
-        single_tap(TAPHOLD_SCLN, isHold);
-        break;
-      case TR_QUOT:
-        single_tap(TAPHOLD_QUOT, isHold);
+      case HOLD_BRACKETS:
+        record->event.pressed ? insert_brackets(tap_keycode, hold_keycode, WAIT_DELAY) : 0;
        break;

+      case HOLD_DOUBLETP:
+        record->event.pressed ? double_tap(tap_keycode, WAIT_DELAY) : 0;
+        break;
+
+      default:
+        record->event.pressed ? register_code16(hold_keycode) : unregister_code16(hold_keycode);
+        break;
    }

-    return false;
-
-  } else if (record->tap.count == 0 && record->event.pressed) {
-
-    isHold = true;
-
-    switch(keycode) {
-
-      // Brackets
-      case TR_LCBR:
-        insert_brackets(TAPHOLD_LCBR, WAIT_DELAY);
-        break;
-      case TR_LABK:
-        insert_brackets(TAPHOLD_LABK, WAIT_DELAY);
-        break;
-      case TR_LBRC:
-        insert_brackets(TAPHOLD_LBRC, WAIT_DELAY);
-        break;
-      case TR_LPRN:
-        insert_brackets(TAPHOLD_LPRN, WAIT_DELAY);
-        break;
-      case TR_SQUO:
-        insert_brackets(TAPHOLD_SQUO, WAIT_DELAY);
-        break;
-
-      // double tap
-      case TR_EQL:
-        double_tap(TAPHOLD_EQL, WAIT_DELAY);
-        break;
-      case TR_BSLS:
-        double_tap(TAPHOLD_BSLS, WAIT_DELAY);
-        break;
-      case TR_SLSH:
-        double_tap(TAPHOLD_SLSH, WAIT_DELAY);
-        break;
-
-      // custom override without holding shift
-      case TR_COMM:
-        single_tap(TAPHOLD_COMM, isHold);
-        break;
-      case TR_DOT:
-        single_tap(TAPHOLD_DOT, isHold);
-        break;
-      case TR_PERC:
-        single_tap(TAPHOLD_PERC, isHold);
-        break;
-      case TR_EXLM:
-        single_tap(TAPHOLD_EXLM, isHold);
-        break;
-      case TR_AT:
-        single_tap(TAPHOLD_AT, isHold);
-        break;
-      case TR_QUES:
-        single_tap(TAPHOLD_QUES, isHold);
-        break;
-
-      // simulates auto-shift
-      case TR_MINS:
-        single_tap(TAPHOLD_MINS, isHold);
-        break;
-      case TR_GRV:
-        single_tap(TAPHOLD_GRV, isHold);
-        break;
-      case TR_SCLN:
-        single_tap(TAPHOLD_SCLN, isHold);
-        break;
-      case TR_QUOT:
-        single_tap(TAPHOLD_QUOT, isHold);
-        break;
-
-    }
-
-    return false;
-
  }

-  return true;  // Continue default handling.
-}
+  return false;
+}
--- a/users/t4corun/features/taphold.h
+++ b/users/t4corun/features/taphold.h
@ -1,40 +1,7 @@
 #pragma once
 #include "t4corun.h"

-void single_tap(uint16_t key, uint16_t altkey, bool isHold);
-void double_tap(uint16_t key, uint16_t altkey, uint32_t ms);
+void single_tap(uint16_t key);
+void double_tap(uint16_t key, uint32_t ms);
 void insert_brackets(uint16_t left, uint16_t right, uint32_t ms);
-bool process_tap_hold_key(keyrecord_t* record, uint16_t keycode);
-
-/* the first element is the alt key (tap action)
- * the second is altkey (hold action usually)
- * 
- * I was doing a switch statement to assign these each time, but this is faster
- *    and easier to maintain
-*/ 
-
-// Brackets: open and close brackets and put the cursor inside
-#define TAPHOLD_LCBR KC_LCBR, KC_RCBR
-#define TAPHOLD_LABK KC_LABK, KC_RABK
-#define TAPHOLD_LBRC KC_LBRC, KC_RBRC
-#define TAPHOLD_LPRN KC_LPRN, KC_RPRN
-#define TAPHOLD_SQUO KC_QUOT, KC_QUOT
-
-// double tap
-#define TAPHOLD_EQL  KC_EQL,  KC_EQL
-#define TAPHOLD_BSLS KC_BSLS, KC_BSLS
-#define TAPHOLD_SLSH KC_SLSH, KC_SLSH
-
-// Custom override without holding shift
-#define TAPHOLD_COMM KC_COMM, KC_LPRN
-#define TAPHOLD_DOT  KC_DOT,  KC_RPRN
-#define TAPHOLD_PERC KC_PERC, KC_CIRC
-#define TAPHOLD_EXLM KC_EXLM, KC_DLR
-#define TAPHOLD_AT   KC_AT,   KC_AMPR
-#define TAPHOLD_QUES KC_QUES, KC_ASTR
-
-// auto shift
-#define TAPHOLD_MINS KC_MINS, KC_UNDS
-#define TAPHOLD_GRV  KC_GRV,  KC_TILD
-#define TAPHOLD_SCLN KC_SCLN, KC_COLN
-#define TAPHOLD_QUOT KC_QUOT, KC_DQUO
+bool process_tap_hold_key(keyrecord_t* record, uint16_t tap_keycode, uint16_t hold_keycode, int mode);
--- a/users/t4corun/features/tapping.c
+++ b/users/t4corun/features/tapping.c
@ -1,10 +0,0 @@
-#include "tapping.h"
-
-uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
-  switch (keycode) {
-
-    default:
-      //uprintf("tapping term: %d \n", TAPPING_TERM);
-      return TAPPING_TERM;
-  }
-}
--- a/users/t4corun/features/tapping.h
+++ b/users/t4corun/features/tapping.h
@ -1,2 +0,0 @@
-#pragma once
-#include "t4corun.h"
--- a/users/t4corun/rules.mk
+++ b/users/t4corun/rules.mk
@ -39,7 +39,6 @@ KEY_OVERRIDE_ENABLE = yes

 SRC +=                     \
 	t4corun.c              \
-	features/tapping.c     \
 	features/taphold.c     \
 	features/capsword.c    \
 	features/keyoverride.c \
--- a/users/t4corun/t4corun.c
+++ b/users/t4corun/t4corun.c
@ -4,7 +4,7 @@ static uint8_t current_base_layer = _DEFAULT_LAYER_1;

 layer_state_t layer_state_set_user(layer_state_t  state) {

-  state = update_tri_layer_state(state, _NAVIGATION, _SYMBOL, _NUMBER);
+  state = update_tri_layer_state(state, _NAVIGATION, _NUMBER, _SYMBOL);
  return state;

 }
@ -12,110 +12,94 @@ layer_state_t layer_state_set_user(layer_state_t  state) {
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {

  switch (keycode) {
-    
+
    case BASELYR:
-      if (record->event.pressed) { 
+      if (record->event.pressed) {
+
        current_base_layer = (current_base_layer + 1) % NUM_BASE_LAYER; 
        set_single_persistent_default_layer(current_base_layer);
+
      }
      return false;

+
    case RBSELYR:
      if (record->event.pressed) { 
+
        current_base_layer = (current_base_layer - 1) % NUM_BASE_LAYER; 
        set_single_persistent_default_layer(current_base_layer);
+
      }
      return false;

+
    case PN_DRGS:
      if (record->event.pressed) {
+
        //tap numlock twice to toggle ploopy nano drag scroll
-        double_tap(KC_NUM, KC_NUM, WAIT_DELAY);
+        // double_tap(KC_NUM, KC_NUM, WAIT_DELAY);
+        double_tap(KC_NUM, WAIT_DELAY);
+
      }
      return false;

+
    case PN_PDPI:
      if (record->event.pressed) {
+
        //tap capslock twice to cycle ploopy nano pointer DPI
-        double_tap(KC_CAPS, KC_CAPS, WAIT_DELAY);
+        //double_tap(KC_CAPS, KC_CAPS, WAIT_DELAY);
+        double_tap(KC_CAPS, WAIT_DELAY);
+
      }
      return false;

-/*
-    case KC_BSPC: {
-      //https://docs.qmk.fm/#/feature_advanced_keycodes?id=shift-backspace-for-delete
-
-      // Initialize a boolean variable that keeps track
-      // of the delete key status: registered or not?
-      static bool delkey_registered = false;
-
-      if (record->event.pressed) {
-
-        uint8_t current_mod = get_mods();
-        uint8_t current_osm = get_oneshot_mods();
-
-        // Detect the activation of either shift keys
-        if ((current_mod | current_osm) & MOD_MASK_SHIFT) {
-
-          // First temporarily canceling both shifts so that
-          // shift isn't applied to the KC_DEL keycode
-          del_mods(MOD_MASK_SHIFT);
-          del_oneshot_mods(MOD_MASK_SHIFT);
-
-          // Press delete and keep track that key press
-          register_code(KC_DEL);
-          delkey_registered = true;
-
-          // Reapplying modifier state so that the held shift key(s)
-          // still work even after having tapped the Backspace/Delete key
-          set_mods(current_mod);
-          set_oneshot_mods(current_osm);
-
-          return false;
-
-        }
-
-      } else { // on release of KC_BSPC
-
-        if(delkey_registered) {
-
-          unregister_code(KC_DEL);
-          delkey_registered = false;
-          return false;
-
-        }
-
-      }
-
-      // QMK will process Backspace instead
-      // if the shift modifier is not detected
-      return true;
-    }
-*/
-
    //https://docs.qmk.fm/#/mod_tap?id=changing-both-tasp-and-hold
    //https://getreuer.info/posts/keyboards/triggers/index.html#tap-vs.-long-press
    //https://www.jonashietala.se/series/t-34/ he focuses on a keymap for programming/VIM
+    // Brackets: open and close brackets and put the cursor inside
    case TR_LCBR:
+      return process_tap_hold_key(record, KC_LCBR, KC_RCBR, HOLD_BRACKETS);
    case TR_LABK:
+      return process_tap_hold_key(record, KC_LABK, KC_RABK, HOLD_BRACKETS);
    case TR_LBRC:
+      return process_tap_hold_key(record, KC_LBRC, KC_RBRC, HOLD_BRACKETS);
    case TR_LPRN:
+      return process_tap_hold_key(record, KC_LPRN, KC_RPRN, HOLD_BRACKETS);
+    case TR_DQUO:
+      return process_tap_hold_key(record, KC_DQUO, KC_DQUO, HOLD_BRACKETS);
    case TR_SQUO:
-    case TR_EQL:
+      return process_tap_hold_key(record, KC_QUOT, KC_QUOT, HOLD_BRACKETS);
+
+    // double tap
    case TR_BSLS:
+      return process_tap_hold_key(record, KC_BSLS, KC_BSLS, HOLD_DOUBLETP);
    case TR_SLSH:
+      return process_tap_hold_key(record, KC_SLSH, KC_SLSH, HOLD_DOUBLETP);
+    case TR_PIPE:
+      return process_tap_hold_key(record, KC_PIPE, KC_PIPE, HOLD_DOUBLETP);
+
+    // Custom override without holding shift
    case TR_COMM:
+      return process_tap_hold_key(record, KC_COMM, KC_LPRN, HOLD_SINGLETP);
    case TR_DOT:
+      return process_tap_hold_key(record, KC_DOT,  KC_RPRN, HOLD_SINGLETP);
    case TR_PERC:
-    case TR_EXLM:
-    case TR_AT: 
-    case TR_QUES:
+      return process_tap_hold_key(record, KC_PERC, KC_CIRC, HOLD_SINGLETP);
+
+    // auto shift
+    case TR_EQL:
+      return process_tap_hold_key(record, KC_EQL,  KC_PLUS, HOLD_SINGLETP);
    case TR_MINS:
+      return process_tap_hold_key(record, KC_MINS, KC_UNDS, HOLD_SINGLETP);
    case TR_GRV:
+      return process_tap_hold_key(record, KC_GRV,  KC_TILD, HOLD_SINGLETP);
    case TR_SCLN:
+      return process_tap_hold_key(record, KC_SCLN, KC_COLN, HOLD_SINGLETP);
    case TR_QUOT:
-      return process_tap_hold_key(record, keycode);
+      return process_tap_hold_key(record, KC_QUOT, KC_DQUO, HOLD_SINGLETP);

  }
+
  return true;
 }
--- a/users/t4corun/t4corun.h
+++ b/users/t4corun/t4corun.h
@ -9,8 +9,8 @@ enum layers {
  _COLEMAK_DH,
  _GAME,
  _NAVIGATION,
-  _SYMBOL,
  _NUMBER,
+  _SYMBOL,
  _CONFIG
 };

@ -20,19 +20,18 @@ enum keycodes {
  TH_LABK,
  TH_LBRC,
  TH_LPRN,
+  TH_DQUO,
  TH_SQUO,
-  
-  TH_EQL,
+
  TH_BSLS,
  TH_SLSH,
+  TH_PIPE,

  TH_COMM,
  TH_DOT,
  TH_PERC,
-  TH_EXLM,
-  TH_AT,
-  TH_QUES,

+  TH_EQL,
  TH_MINS,
  TH_GRV,
  TH_SCLN,
@ -49,7 +48,7 @@ enum keycodes {

 // momentary layer
 #define NAV        MO(_NAVIGATION)
-#define SYM        MO(_SYMBOL)
+#define NUM        MO(_NUMBER)
 #define CONFIG     MO(_CONFIG)

 // Windows Shortcuts
@ -62,8 +61,8 @@ enum keycodes {
 #define SC_FILE    LGUI(KC_E)

 // Zoom for encoders
-#define ZOOMIN     LCTL(LSFT(KC_EQL))
-#define ZOOMOUT    LCTL(KC_MINS)
+#define ZOOMIN     LCTL(KC_WH_U)
+#define ZOOMOUT    LCTL(KC_WH_D)
 #define ZOOMRST    LCTL(KC_0)

 /*
@ -80,28 +79,36 @@ enum keycodes {


 // tap hoLd. These will be intercepted and overridden. The LT will be ignored
-#define TR_LCBR  LT(_DEFAULT_LAYER_1, TH_LCBR) // bracket behavior
+// Brackets: open and close brackets and put the cursor inside
+#define TR_LCBR  LT(_DEFAULT_LAYER_1, TH_LCBR)
 #define TR_LABK  LT(_DEFAULT_LAYER_1, TH_LABK)
 #define TR_LBRC  LT(_DEFAULT_LAYER_1, TH_LBRC)
 #define TR_LPRN  LT(_DEFAULT_LAYER_1, TH_LPRN)
+#define TR_DQUO  LT(_DEFAULT_LAYER_1, TH_DQUO)
 #define TR_SQUO  LT(_DEFAULT_LAYER_1, TH_SQUO)

-#define TR_EQL   LT(_DEFAULT_LAYER_1, TH_EQL) // double tap
+// double tap
 #define TR_BSLS  LT(_DEFAULT_LAYER_1, TH_BSLS)
 #define TR_SLSH  LT(_DEFAULT_LAYER_1, TH_SLSH)
+#define TR_PIPE  LT(_DEFAULT_LAYER_1, TH_PIPE)

-#define TR_COMM  LT(_DEFAULT_LAYER_1, TH_COMM) // custom behavior
+// Custom override without holding shift
+#define TR_COMM  LT(_DEFAULT_LAYER_1, TH_COMM)
 #define TR_DOT   LT(_DEFAULT_LAYER_1, TH_DOT)
 #define TR_PERC  LT(_DEFAULT_LAYER_1, TH_PERC)
-#define TR_EXLM  LT(_DEFAULT_LAYER_1, TH_EXLM)
-#define TR_AT    LT(_DEFAULT_LAYER_1, TH_AT)
-#define TR_QUES  LT(_DEFAULT_LAYER_1, TH_QUES)

-#define TR_MINS  LT(_DEFAULT_LAYER_1, TH_MINS) // auto shift
+// auto shift
+#define TR_EQL   LT(_DEFAULT_LAYER_1, TH_EQL)
+#define TR_MINS  LT(_DEFAULT_LAYER_1, TH_MINS)
 #define TR_GRV   LT(_DEFAULT_LAYER_1, TH_GRV)
 #define TR_SCLN  LT(_DEFAULT_LAYER_1, TH_SCLN)
 #define TR_QUOT  LT(_DEFAULT_LAYER_1, TH_QUOT)

+// Tells the process_tap_hold_key what kind of hold action is wanted
+#define HOLD_SINGLETP 0
+#define HOLD_DOUBLETP 1
+#define HOLD_BRACKETS 2
+

 #if defined(KEYBOARD_bastardkb_charybdis_3x5)
 //these mouse codes are defined in charybdis.h
@ -156,7 +163,7 @@ enum keycodes {
 #define _SCAG_MODS________________________          TR_LSFT, TR_LCTL, TR_LALT, TR_LGUI
 #define _UCCPR_L___________________________________ SC_UNDO, SC_CUT,  SC_COPY, SC_PAST, SC_REDO

-#define _BASE_L4_________________                   ___x___, SYM,     TR_LSFT
+#define _BASE_L4_________________                   ___x___, NUM,     TR_LSFT
 #define _BASE_R4_________________                   KC_SPC,  NAV,     KC_MUTE
 #define _LAYER_TRANS_____________                   ___x___, _______, ___x___

@ -185,38 +192,29 @@ enum keycodes {


 #define LAYER_NAVIGATION                                                                    \
-  ___x___, KC_HOME, KC_UP,   KC_END,  KC_PGUP, ___x___, ___x___, KC_CAPS, KC_PSCR, CONFIG,  \
+  KC_ESC,  KC_HOME, KC_UP,   KC_END,  KC_PGUP, ___x___, ___x___, ___x___, ___x___, CONFIG,  \
  ___x___, KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, ___x___, _SCAG_MODS________________________, \
  _UCCPR_L___________________________________, ___x___, KC_APP,  TR_SNIP, TR_SDPI, TR_PDPI, \
-                    ZOOMRST, SYM,     KC_ENT,  _LAYER_TRANS_____________
-
-
-#define LAYER_SYMBOL                                                                        \
-  KC_ESC,  KC_BTN3, KC_BTN2, KC_BTN1, TR_GRV,  TR_EQL,  KC_HASH, TR_LABK, KC_RABK, TR_PERC, \
-  _GACS_MODS________________________, TR_SCLN, TR_AT,   TR_QUES, TR_LBRC, KC_RBRC, TR_SQUO, \
-  _UCCPR_L___________________________________, TR_BSLS, TR_SLSH, TR_LPRN, KC_RPRN, TR_MINS, \
-                    _LAYER_TRANS_____________, TR_EXLM, _______, ___x___
+                    ZOOMRST, NUM,     KC_ENT,  _LAYER_TRANS_____________


 #define LAYER_NUMBER                                                                        \
-  KC_F7,   KC_F5,   KC_F3,   KC_F1,   KC_F9,   KC_F8,   KC_F10,  KC_F2,   KC_F4,   KC_F6,   \
-  KC_7,    KC_5,    KC_3,    KC_1,    KC_9,    KC_8,    KC_0,    KC_2,    KC_4,    KC_6,    \
-  KC_MUTE, KC_VOLD, KC_VOLU, KC_MNXT, KC_MPLY, KC_F11,  KC_F12,  TR_COMM, TR_DOT,  TR_MINS, \
+  KC_ESC,  KC_BTN3, KC_BTN2, KC_BTN1, TR_GRV,  ___x___, KC_7,    KC_8,    KC_9,    KC_COMM, \
+  _GACS_MODS________________________, TR_SCLN, KC_0,    KC_4,    KC_5,    KC_6,    KC_DOT,  \
+  _UCCPR_L___________________________________, ___x___, KC_1,    KC_2,    KC_3,    KC_MINS, \
+                    _LAYER_TRANS_____________, _BASE_R4_________________
+
+
+#define LAYER_SYMBOL                                                                        \
+  ___x___, ___x___, KC_AMPR, TR_PERC, TR_GRV,  TR_EQL,  KC_HASH, KC_ASTR, ___x___, TR_DQUO, \
+  KC_CAPS, TR_LCBR, KC_RCBR, KC_EXLM, TR_SCLN, KC_AT,   KC_QUES, TR_LBRC, KC_RBRC, TR_SQUO, \
+  ___x___, TR_LABK, KC_RABK, TR_BSLS, TR_PIPE, KC_DLR,  TR_SLSH, TR_LPRN, KC_RPRN, TR_MINS, \
                    _LAYER_TRANS_____________, _LAYER_TRANS_____________


 #define LAYER_CONFIG                                                                        \
  _NONE_5____________________________________, ___x___, ___x___, EE_CLR,  QK_BOOT, _______, \
  _NONE_5____________________________________, ___x___, TR_LSFT, ___x___, ___x___, TR_RMOD, \
-  _NONE_5____________________________________, TR_RTOG, TR_RHUI, TR_RSAI, TR_RVAI, TR_RSPI, \
-                    BASELYR, ___x___, ___x___, TR_DMP1, TR_DMR1, TR_RTOG
+  KC_MUTE, KC_VOLD, KC_VOLU, KC_MNXT, KC_MPLY, TR_RTOG, TR_RHUI, TR_RSAI, TR_RVAI, TR_RSPI, \
+                    BASELYR, TR_DMR1, TR_DMP1, ___x___, ___x___, TR_RTOG

-/*
-If I was going to combine number and symbols together, it'd look like this
-
-#define LAYER_NUMBER \
-  ___x___, SC_SNIP, SC_FILE, TR_LABK, KC_RABK, TR_LBRC, KC_7,    KC_8,    KC_9,    KC_RBRC, \
-  _GACS_MODS________________________, TR_GRV,  TR_SCLN, KC_4,    KC_5,    KC_6,    TR_EQL,  \
-  _UCCPR_L___________________________________, KC_SLSH, KC_1,    KC_2,    KC_3,    KC_BSLS, \
-                    _LAYER_TRANS_____________, KC_SPC,  NAV_0,   ___x___
-*/