diff --git a/config.h b/config.h
index 13ebf27..9b0ca0b 100644
--- a/config.h
+++ b/config.h
@@ -37,7 +37,7 @@
 #define TAP_HOLD_CAPS_DELAY 10
 #define PERMISSIVE_HOLD
 
-#define IGNORE_MOD_TAP_INTERRUPT
+//#define IGNORE_MOD_TAP_INTERRUPT
 
 #ifdef COMBO_ENABLE
     #ifdef COMBO_COUNT
@@ -55,7 +55,14 @@
     #define COMBO_HOLD (TAPPING_TERM) // time to hold to trigger delayed combo
 #endif
 
-#define ADAPTIVE_ENABLED
+#define ADAPTIVE_ENABLE
+#define ADAPTIVE_TRAILER KC_3
+
+//#define THUMB_REPEATER
+#ifdef THUMB_REPEATER
+#define HD_REPEATER_A HD_BSPC
+#define HD_REPEATER_B KC_ENT
+#endif
 
 #ifdef COMBO_HOLD
     #undef ADAPTIVE_TERM
@@ -68,13 +75,6 @@
 // how long to leave a state active before resetting like APPMENU or SHIFTWORD
 #define STATE_RESET_TIME LINGER_TIME * 4
 
-//#define BILATERAL_COMBINATIONS LINGER_TIME * 2
-/*
-#define RETRO_SHIFT 500
-#define AUTO_SHIFT_TIMEOUT LINGER_TIME
-#define NO_AUTO_SHIFT_SPECIAL
-#define NO_AUTO_SHIFT_NUMERIC
- */
 
 #define EN_PRONOUN_COMBOS // English First Person pronoun combos (I, I'm, I've I'd I'll etc) (184 bytes on AVR)
 #define EN_PRONOUN_COMBOS_ALL  // combos for you('ve), We('ve), They('ve) etc. (616 bytes on AVR)
diff --git a/handsdown/au-adaptive.c b/handsdown/au-adaptive.c
new file mode 100644
index 0000000..458f459
--- /dev/null
+++ b/handsdown/au-adaptive.c
@@ -0,0 +1,355 @@
+/*
+ Adaptive Keys
+ Called from within process_record_user
+ 
+ Tailored for HD Gold (au)
+ 
+ NOTE: assumed dual-function keys (MOD_TAP, LAYER_TAP) have already been handled AND
+    FILTERED OUT! The combos handler will have already taken out combo candidates,
+    which have a shorter keydown threshhold (COMBO_TERM).
+ 
+ All the goto shenanigans should be resolved after complete migration to STM/RP controllersr
+ (not totally possible, as many of my boards have embedded AVR mcus)
+
+ */
+//              Hands Down Gold
+// ╭─────────────────────╮ ╭─────────────────────╮
+// │  J   G   M   P   V  │ │  #$  .:  /*  "[  '] │
+// │  R   S   N   D   B  | |  ,;   A   E   I   H │
+// │  X   F   L   C   W  │ │  -+   U   O   Y   K │
+// ╰───────────╮ BSP  T  │ │ SPC  RET ╭──────────╯
+//             ╰─────────╯ ╰──────────╯
+// Q (LT3) & Z (LT4) are on the punc layer
+
+
+bool process_adaptive_key(uint16_t *calling_keycode, const keyrecord_t *record) {
+    bool return_state = true; // assume we don't do anything.
+    uint16_t keycode = *calling_keycode;
+    
+    // Are we in an adaptive context? (adaptive on is assumed).
+    if (timer_elapsed(prior_keydown) > ADAPTIVE_TERM) { // outside adaptive threshhold
+        prior_keycode = prior_keydown = 0; // turn off Adaptives.
+        return true; // no adaptive conditions, so return.
+    }
+
+    // K, this could be adaptive, so process.
+    saved_mods = get_mods();
+
+    if (!caps_word_on) { // turn off shift, (first-words & Proper nouns)
+        unregister_mods(MOD_MASK_SHIFT);  //CAPS_WORD/LOCK won't be affected.
+    } // may want more granular control than this…
+
+    switch (keycode & QK_BASIC_MAX) { // process ignoring multi-function keys
+
+/*
+// Left hand adaptives (most are single-handed neighbor fingers, bc speed, dexterity limits)
+*/
+        case KC_B:  // avoid the index-middle split
+            switch (prior_keycode) {
+                case KC_P: // pull up M over
+                    tap_code(KC_M);
+                    return_state = false; // done.
+                case KC_D: // pull L over
+                    goto PullUpLAndExit; // short jumps save bytes
+                break;
+           }
+            break;
+        case KC_M: // M becomes L (pull up "L" to same row)
+            switch (prior_keycode) {
+                case KC_P: //
+                case KC_G: //
+PullUpLAndExit:
+                    tap_code(KC_L);  //
+                    return_state = false; // done.
+                    break;
+                case KC_J: //
+ReplacePriorWithL:
+                    tap_code(KC_BSPC);
+                    tap_code(KC_L);
+                    break;
+            }
+            break;
+        case KC_D: //
+            switch (prior_keycode) { //
+                case KC_B:
+                    goto PullUpLAndExit; // short jumps save bytes
+            }
+            break;
+        case KC_P:
+            switch (prior_keycode) {
+                case KC_G: // avoid the scissor
+                    goto ReplacePriorWithL; // short jumps save bytes
+                case KC_J:
+                    tap_code(KC_BSPC);
+                    send_string("lml"); // for "calmly" but not quite intuitive…
+                    return_state = false; // done.
+                    break;
+                case KC_V: // avoid the index-middle split
+                    goto PullUpLAndExit; // short jumps save bytes
+            }
+            break;
+
+
+/*
+// right hand adaptives
+*/
+
+        case KC_E: //
+            switch (prior_keycode) { //
+                case KC_A:
+                    tap_code(KC_U); // "AE" yields "AU" (8x more common)
+                    return_state = false; // done.
+                    break;
+            }
+            break;
+        case KC_H: // How often are we likely to hit BS so quickly after?
+            switch (prior_keycode) { // maybe OK? What about xxR? resulting in a SFB on thumb?
+                case KC_E:
+                    tap_code(KC_O); // "EH" yields "EO" (1.75:1)
+                    return_state = false; // done.
+                    break;
+                case KC_O:
+                    tap_code(KC_E); // "OH" yields "OE" (almost 1:1, but eliminates an SFB?)
+                    return_state = false; // done.
+                    break;
+                case KC_U:
+                    tap_code(KC_A); // "UH" yields "UA" (126x more common)
+                    return_state = false; // done.
+                    break;
+
+            }
+            break;
+
+        case KC_K:
+            switch (prior_keycode) {
+                case KC_Y:  // eliminate SFB on ring finger
+                    tap_code(KC_I);
+                    return_state = false; // done.
+                    break;
+            }
+            break;
+        case KC_U:
+            switch (prior_keycode) {
+                case KC_K: // make KU send Qu
+                    tap_code(KC_BSPC);
+                    tap_code(KC_Q);
+                    break;
+            }
+            break;
+
+
+#ifdef THUMB_REPEATER
+        case HD_REPEATER_A: // Make a repeat key of the secondary thumb key on both sides
+        case HD_REPEATER_B: // for most common double letters (inherently SFBs)
+            switch (prior_keycode) {
+                case KC_A ... KC_SLASH: // Any alpha can be repeated?
+/* double-letter frequencies from Peter Norvig's data <https://norvig.com/mayzner.html>
+                case KC_L: // 0.577%
+                case KC_S: // 0.405%
+                case KC_E: // 0.378%
+                case KC_O: // 0.210%
+                case KC_T: // 0.171%
+                case KC_F: // 0.146%
+                case KC_P: // 0.137%
+                case KC_R: // 0.121%
+                case KC_M: // 0.096%
+                case KC_C: // 0.083%
+                case KC_N: // 0.073%
+                case KC_D: // 0.043%
+                case KC_G: // 0.025%
+                case KC_I: // 0.023%
+                case KC_B: // 0.011%
+                case KC_A: // 0.003%
+                case KC_Z: // 0.003%
+                case KC_X: // 0.003%
+                case KC_U: // 0.001%
+                case KC_H: // 0.001%
+*/
+                    tap_code(prior_keycode); // eliminate SFB on double
+                    return_state = false; // done.
+            }
+            break;
+#endif
+#ifdef ADAPTIVE_TRAILER
+// Using Adaptives for macros (like a flexible LeaderKey)
+        case ADAPTIVE_TRAILER:
+            switch (prior_keycode) {
+#ifdef adaptAMINS
+                case KC_A: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptAMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptBMINS
+                case KC_B: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptBMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptCMINS
+                case KC_C: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptCMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptDMINS
+                case KC_D: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptDMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptEMINS
+                case KC_E: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptEMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptFMINS
+                case KC_F: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptFMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptGMINS
+                case KC_G: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptGMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptHMINS
+                case KC_H: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptHMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptIMINS
+                case KC_I: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptIMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptJMINS
+                case KC_J: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptJMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptKMINS
+                case KC_K: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptKMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptLMINS
+                case KC_L: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptLMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptMMINS
+                case KC_M: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptMMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptNMINS
+                case KC_N: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptNMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptOMINS
+                case KC_O: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptOMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptPMINS
+                case KC_P: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptPMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptRMINS
+                case KC_R: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptRMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptSMINS
+                case KC_S: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptSMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptTMINS
+                case KC_T: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptTMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptUMINS
+                case KC_U: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptUMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptVMINS
+                case KC_V: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptVMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptWMINS
+                case KC_W: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptWMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptYMINS
+                case KC_Y: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptYMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptYMINS
+                case KC_Y: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptYMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+            }
+            break;
+#endif // ADAPTIVE_TRAILER
+
+    }
+    if (return_state) { // no adaptive processed, cancel state and pass it on.
+        set_mods(saved_mods);
+        prior_keycode = keycode = 0;
+    }
+    return return_state; //
+}
diff --git a/handsdown/au-config.h b/handsdown/au-config.h
new file mode 100644
index 0000000..5932b6d
--- /dev/null
+++ b/handsdown/au-config.h
@@ -0,0 +1,288 @@
+
+//
+// The Hands Down Variation dependent defs & files
+//
+#define HD_adaptive_code "handsdown/au-adaptive.c"
+//
+//
+//       Alpha Layer for a 34 key formfactor
+// ╭─────────────────────╮ ╭─────────────────────╮
+// │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │
+// │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │
+// │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │
+// ╰───────────╮ LH2 LH1 │ │ RH1 RH2  ╭──────────╯
+//             ╰─────────╯ ╰──────────╯
+//              Hands Down Gold
+// ╭─────────────────────╮ ╭─────────────────────╮
+// │  J   G   M   P   V  │ │  #$  .:  /*  "[  '] │
+// │  R   S   N   D   B  | |  ,;   A   E   I   H │
+// │  X   F   L   C   W  │ │  -+   U   O   Y   K │
+// ╰───────────╮ BSP  T  │ │ SPC  RET ╭──────────╯
+//             ╰─────────╯ ╰──────────╯
+// Q (LT3) & Z (LT4) are on the punc layer
+// and on combos (defined below)
+//
+// for now...
+// This will morph to being entirel properly abstracted
+// similar to Miryoku, (maybe someone will make an HD Miryoku someday?)
+//
+//
+
+//
+// We want to be able to define a combo either
+// by location for variation independent, spatial referencing, or
+// or by letter for mnemonic/phonetic referencing (variation dependent)
+//
+// BE CAREFUL to not double define a combo!
+//
+// First, let's add any hold-taps to the keycodes
+//
+#define HD_A RSFT_T(KC_A)
+#define HD_B LT(L_NUMPAD,KC_B)
+#define HD_C KC_C
+#define HD_D RSFT_T(KC_D)
+#define HD_E RGUI_T(KC_E)
+#define HD_F KC_F
+#define HD_G KC_G
+#define HD_H RCTL_T(KC_H)
+#define HD_I RALT_T(KC_I)
+#define HD_J KC_J
+#define HD_K KC_K
+#define HD_L KC_L
+#define HD_M KC_M
+#define HD_N RGUI_T(KC_N)
+#define HD_O KC_O
+#define HD_P KC_P
+#define HD_Q KC_Q
+#define HD_R RCTL_T(KC_R)
+#define HD_S RALT_T(KC_S)
+#define HD_T LT(L_NAV,KC_T)
+#define HD_U KC_U
+#define HD_V KC_V
+#define HD_W KC_W
+#define HD_X KC_X
+#define HD_Y KC_Y
+#define HD_Z KC_Z
+
+#define HD_MINS KC_MINS
+#define HD_HASH KC_HASH
+#define HD_SPC  LT(L_PUNCT,KC_SPC)
+#define HD_BSPC LT(L_FN_NUM,KC_BSPC)
+#define HD_ENT  LT(L_NAV,KC_ENT)
+#define HD_QUOT KC_QUOT
+#define HD_DQUO KC_DQUO
+#define HD_SLSH KC_SLSH
+#define HD_DOT  KC_DOT
+#define HD_COMM LT(L_FN_NUM, KC_COMM)
+
+//
+// Now let's also defineo the keycodes on the map for spatial referencing
+//
+// (is there anyway to combine these 2 steps?)
+//
+#define HD_LT4 HD_J
+#define HD_LT3 HD_G
+#define HD_LT2 HD_M
+#define HD_LT1 HD_P
+#define HD_LT0 HD_V
+#define HD_RT0 HD_HASH
+#define HD_RT1 HD_DOT
+#define HD_RT2 HD_SLSH
+#define HD_RT3 HD_DQUO
+#define HD_RT4 HD_QUOT
+
+#define HD_LM4 HD_R
+#define HD_LM3 HD_S
+#define HD_LM2 HD_N
+#define HD_LM1 HD_D
+#define HD_LM0 HD_B
+#define HD_RM0 HD_COMM
+#define HD_RM1 HD_A
+#define HD_RM2 HD_E
+#define HD_RM3 HD_I
+#define HD_RM4 HD_H
+
+#define HD_LB4 HD_X
+#define HD_LB3 HD_F
+#define HD_LB2 HD_L
+#define HD_LB1 HD_C
+#define HD_LB0 HD_W
+#define HD_RB0 HD_MINS
+#define HD_RB1 HD_U
+#define HD_RB2 HD_O
+#define HD_RB3 HD_Y
+#define HD_RB4 HD_K
+
+//Primary Thumbs (others unique to the board)
+#define HD_LH2 HD_BSPC
+#define HD_LH1 HD_T
+#define HD_RH1 HD_SPC
+#define HD_RH2 HD_ENT
+
+
+
+#ifdef COMBO_ENABLE
+//
+// Combo definitions that rely on phonetics/mnemonics for their locations.
+//
+// Combos that are spacially organized don't need to be redefined
+// to match the base alpha layer, so they are not included here.
+//
+// These few spatial combos may move to accommodate some mnemonic combos,
+// notably the H-digraph combos that inhabit close areas.
+//
+#define HD_tab_keys  HD_LM4, HD_LM3     // tab
+#define HD_spc_keys  HD_LM1, HD_LM0     // SPACE
+#define HD_ent_keys  HD_LB0, HD_LB1     // ENTER
+#define HD_ent2_keys HD_LB0, HD_LB2, HD_LB1 // hard-ENTER/page break
+
+// TEXT ENTRY - off map standard alphas (also on Layer L_PUNCT @ Z=LT4 & Q=LT3)
+//
+#define HD_Z_keys HD_LT1, HD_LT0 // TYPE "z"
+#define HD_Qu_keys HD_LT3, HD_LT1 // TYPE "q" (Qu & Linger deletes u)
+
+//
+// H digraph combos
+// try to make these use the lead letter and a neighbor.
+//
+#define HD_Th_keys HD_LM2, HD_LM1 // TYPE "th"
+#define HD_Ch_keys HD_LM3, HD_LM1 // TYPE "ch"
+#define HD_Wh_keys HD_LT4, HD_LT3 // TYPE "wh"
+#define HD_Sh_keys HD_LM3, HD_LM2 // TYPE "sh"
+#define HD_Ph_keys HD_LT1, HD_LT2 // TYPE "ph"
+#define HD_Gh_keys HD_LT3, HD_LT2 // TYPE "gh"
+#define HD_Sch_keys HD_LM4, HD_LM3, HD_LM2 // TYPE "Sch"
+
+#define HD_OE_lig_keys HD_RM2, HD_RB2 // Œ
+#define HD_AE_lig_keys HD_RM1, HD_RB1 // Æ
+
+
+#ifdef EN_PRONOUN_COMBOS
+// the entirely unnecessary pronoun combo shenanigans
+
+// PRONOUNS Fast 4-7grams
+#define HD_Icap_keys  HD_I, HD_H  // TYPE "I"
+#define HD_Id_keys    HD_I, HD_D  // TYPE "I'd"+"'ve "
+#define HD_Ill_keys   HD_I, HD_L  // TYPE "I'll"+"'ve "
+#define HD_Im_keys    HD_I, HD_M  // TYPE "I'm "
+#define HD_Iv_keys    HD_I, HD_V  // TYPE "I've "
+
+#ifdef EN_PRONOUN_COMBOS_ALL // Admittedly of questionable value
+#define HD_youd_keys  HD_Y, HD_D  // TYPE "you'd" + 've
+#define HD_youll_keys HD_Y, HD_L  // TYPE "you'll" + 've
+#define HD_youre_keys HD_Y, HD_R  // TYPE "you're"
+#define HD_youve_keys HD_Y, HD_V  // TYPE "you've"
+#define HD_your_keys  HD_Y, HD_P  // TYPE "your" "P" for "possessive" case
+#define HD_their_keys HD_T, HD_W  // TYPE "their" #6
+#define HD_they_keys  HD_T, HD_Y  // "they" #23 + 've
+#define HD_theyd_keys HD_T, HD_X  // "they'd" #23 + 've
+#define HD_theyll_keys HD_T, HD_L // "they'll" #23 + 've
+#define HD_theyre_keys HD_T, HD_QUOT // "they're"
+
+#define HD_there_keys HD_T, HD_F  // TYPE "there" #7 + 's
+#define HD_here_keys  HD_H, HD_R  // TYPE "here" #5 + 's
+
+
+#ifdef EN_W_PRONOUNS
+#define HD_where_keys HD_X, HD_R  // "where" + 's
+#define HD_wed_keys   HD_X, HD_G  // TYPE "we'd" + 've
+#define HD_well_keys  HD_X, HD_M  // TYPE "we'll" + 've
+#define HD_were_keys  HD_X, HD_QUOT  // TYPE "we're"
+#define HD_weve_keys  HD_X, HD_J  // TYPE "we've"
+#endif // EN_W_PRONOUNS
+
+#endif // EN_PRONOUN_keysS_ALL
+#endif // EN_PRONOUN_keysS // the entirely unnecessary pronoun combo shenanigans
+
+
+
+// SEMANTIC FUNCTIONS  ** uses SemKeys **
+// Spatially arranged on the QWERTY ZXCV locations
+//
+#define HD_new_keys   HD_LM2, HD_LB2   // new
+#define HD_open_keys  HD_LM1, HD_LB1   // open
+#define HD_close_keys HD_LM3, HD_LB3   // close
+#define HD_quit_keys  HD_LB0, HD_LM0   // quit
+#define HD_find_keys  HD_RM4, HD_RB0   // find selection
+#define HD_sall_keys  HD_LB4, HD_LB1   // select all
+#define HD_swrd_keys  HD_LB4, HD_LB0   // select word
+#define HD_undo_keys  HD_LB4, HD_LB3   // undo
+#define HD_redo_keys  HD_LB4, HD_LB3, HD_LB2   // redo
+//#define HD_cut_keys   HD_LB4, HD_LB2   // cut
+#define HD_copy_keys  HD_LB3, HD_LB2   // copy (hold for cut)
+#define HD_pste_keys  HD_LB2, HD_LB1   // paste (hold for paste-match)
+
+
+
+#ifdef JP_MODE_ENABLE
+#ifdef JP_YOUON_COMBOS
+// Major Japanese contracted consonants as combos
+//
+// These will conflict with some diacritics (noted below),
+// so some sort of mode-switch in process_keys_event is necessary
+// for both to be used on the same board.
+//
+// There is also risk of conflict with spatial any phonetically/mnemonically coded combos.
+//
+// Major (high frequency) Japanese contracted sounds
+#define JP_kya_keys HD_LM0, HD_RM1 // きゃ
+#define JP_kyu_keys HD_LM0, HD_RB1 //　きゅ
+#define JP_kyo_keys HD_LM0, HD_RB2 //　きょ
+#define JP_sya_keys HD_LM4, HD_RM1 // しゃ
+#define JP_syu_keys HD_LM4, HD_RB1 //　しゅ
+#define JP_sye_keys HD_LM4, HD_RM2 //　しぇ
+#define JP_syo_keys HD_LM4, HD_RB2 //　しょ
+#define JP_zya_keys HD_LM3, HD_RM1 // じゃ
+#define JP_zyu_keys HD_LM3, HD_RB1 //　じゅ
+#define JP_zyo_keys HD_LM3, HD_RB2 //　じょ
+#define JP_tya_keys HD_LM1, HD_RM1 // ちゃ
+#define JP_tyu_keys HD_LM1, HD_RB1 //　ちゅ
+#define JP_tye_keys HD_LM1, HD_RM2 // ちぇ
+#define JP_tyo_keys HD_LM1, HD_RB2 //　ちょ
+#define JP_pya_keys HD_LB3, HD_RM1 // ぴゃ
+#define JP_pyu_keys HD_LB3, HD_RB1 //　ぴゅ
+#define JP_pyo_keys HD_LB3, HD_RB2 //　ぴょ
+
+#ifdef JP_YOUON_COMBOS_ALL // All Japanese contracted sounds
+
+#define JP_gya_keys HD_LT1, HD_RM1 // ぎゃ
+#define JP_gyu_keys HD_LT1, HD_RB1 //　ぎゅ
+#define JP_gyo_keys HD_LT1, HD_RB2 //　ぎょ
+#define JP_tha_keys HD_LM2, HD_LM1, HD_RM1 // てゃ
+#define JP_thi_keys HD_LM2, HD_LM1, HD_RM3 // てぃ
+#define JP_thu_keys HD_LM2, HD_LM1, HD_RB1 //　てゅ
+#define JP_the_keys HD_LM2, HD_LM1, HD_RM2 // てぇ
+#define JP_tho_keys HD_LM2, HD_LM1, HD_RB2 //　てょ
+#define JP_dha_keys HD_LB1, HD_RM1 // でゃ
+#define JP_dhi_keys HD_LB1, HD_RM3 // でぃ
+#define JP_dhu_keys HD_LB1, HD_RB1 //　でゅ
+#define JP_dhe_keys HD_LB1, HD_RM2 // でぇ
+#define JP_dho_keys HD_LB1, HD_RB2 //　でょ
+#define JP_nya_keys HD_LM2, HD_RM1 // にゃ
+#define JP_nyu_keys HD_LM2, HD_RB1 //　にゅ
+#define JP_nyo_keys HD_LM2, HD_RB2 //　にょ
+
+//#define JP_hya_keys HD_RM4, HD_RM1 // ひゃ conflicts with diacritic
+#define JP_hyu_keys HD_RM4, HD_RB1 //　ひゅ
+#define JP_hyo_keys HD_RM4, HD_RB2 //　ひょ
+//#define JP_fya_keys HD_RM4, HD_RM1 // ふぁ unnecessary?
+//#define JP_fyu_keys HD_RM4, HD_RB1 //　ふぃ
+//#define JP_fye_keys HD_RM4, HD_RB1 //　ふぇ
+//#define JP_fyo_keys HD_RM4, HD_RB2 //　ふぉ
+
+#define JP_bya_keys HD_LB4, HD_RM1 // びゃ
+#define JP_byu_keys HD_LB4, HD_RB1 //　びゅ  conflicts with diacritic?
+#define JP_byo_keys HD_LB4, HD_RB2 //　びょ
+#define JP_mya_keys HD_LT2, HD_RM1 // みゃ
+#define JP_myu_keys HD_LT2, HD_RB1 //　みゅ
+#define JP_myo_keys HD_LT2, HD_RB2 //　みょ
+#define JP_rya_keys HD_LH1, HD_RM1 // りゃ
+#define JP_ryu_keys HD_LH1, HD_RB1 //　りゅ
+#define JP_ryo_keys HD_LH1, HD_RB2 //　りょ
+
+#endif // JP_YOUON_COMBOS_ALL // All Japanese contracted sounds
+#endif // JP_YOUON_COMBOS  // Major Japanese contracted sounds as combos
+#endif // JP_MODE_ENABLE // All Japanese mode features
+
+
+#endif // COMBO_ENABLE
diff --git a/handsdown/nu-adaptive.c b/handsdown/nu-adaptive.c
new file mode 100644
index 0000000..bbb1f06
--- /dev/null
+++ b/handsdown/nu-adaptive.c
@@ -0,0 +1,375 @@
+/*
+ Adaptive Keys
+ Called from within process_record_user
+ 
+ Tailored for HD Vibranium-b (vb)
+ 
+ NOTE: assumed dual-function keys (MOD_TAP, LAYER_TAP) have already been handled AND
+    FILTERED OUT! The combos handler will have already taken out combo candidates,
+    which have a shorter keydown threshhold (COMBO_TERM).
+ 
+ All the goto shenanigans should be resolved after complete migration to STM/RP controllersr
+ (not totally possible, as many of my boards have embedded AVR mcus)
+
+ */
+//              Hands Down Neu
+// ╭─────────────────────╮ ╭─────────────────────╮
+// │  W   F   M   P   V  │ │  #$  .:  /*  "[  '] │
+// │  R   S   N   T   B  | |  ,;   A   E   I   H │
+// │  X   C   L   D   G  │ │  -+   U   O   Y   K │
+// ╰───────────╮ BSP SPC │ │ SPC  RET ╭──────────╯
+//             ╰─────────╯ ╰──────────╯
+// Q (LT3) & Z (LT4) are on the punc layer
+
+bool process_adaptive_key(uint16_t *calling_keycode, const keyrecord_t *record) {
+    bool return_state = true; // assume we don't do anything.
+    uint16_t keycode = *calling_keycode;
+    
+    // Are we in an adaptive context? (adaptive on is assumed).
+    if (timer_elapsed(prior_keydown) > ADAPTIVE_TERM) { // outside adaptive threshhold
+        prior_keycode = prior_keydown = 0; // turn off Adaptives.
+        return true; // no adaptive conditions, so return.
+    }
+
+    // K, this could be adaptive, so process.
+    saved_mods = get_mods();
+
+    if (!caps_word_on) { // turn off shift, (first-words & Proper nouns)
+        unregister_mods(MOD_MASK_SHIFT);  //CAPS_WORD/LOCK won't be affected.
+    } // may want more granular control than this…
+
+    switch (keycode & QK_BASIC_MAX) { // process ignoring multi-function keys
+
+/*
+// Left hand adaptives (most are single-handed neighbor fingers, bc speed, dexterity limits)
+*/
+        case KC_B:  // avoid the index-middle split
+            switch (prior_keycode) {
+                case KC_P: // pull up M over
+                    tap_code(KC_M);
+                    return_state = false; // done.
+                case KC_D: // pull L over
+                    goto PullUpLAndExit; // short jumps save bytes
+                break;
+           }
+            break;
+        case KC_M: // M becomes L (pull up "L" to same row)
+            switch (prior_keycode) {
+                case KC_P: //
+                case KC_F: //
+PullUpLAndExit:
+                    tap_code(KC_L);  //
+                    return_state = false; // done.
+                    break;
+                case KC_W: // WM = LM (LM 20x more common)
+ReplacePriorWithL:
+                    tap_code(KC_BSPC);
+                    tap_code(KC_L);
+                    break;
+            }
+            break;
+        case KC_D: //
+            switch (prior_keycode) { //
+                case KC_G:
+                    goto PullUpLAndExit; // short jumps save bytes
+            }
+            break;
+        case KC_P:
+            switch (prior_keycode) {
+                case KC_F: // avoid the scissor
+                    goto ReplacePriorWithL; // short jumps save bytes
+                case KC_W:
+                    tap_code(KC_BSPC);
+                    send_string("lml"); // for "calmly" but not quite intuitive…
+                    return_state = false; // done.
+                    break;
+                case KC_V: // avoid the index-middle split
+                    goto PullUpLAndExit; // short jumps save bytes
+            }
+            break;
+        case KC_G: // avoid the index-middle split
+            switch (prior_keycode) {
+                case KC_T: // pull N over
+                    tap_code(KC_N);
+                    return_state = false; // done.
+               case KC_D: // pull L over
+                    goto ReplacePriorWithL;
+            }
+            break;
+
+        case KC_T:  // alt fingering remedy for middle-index splits
+            switch (prior_keycode) {
+                case KC_B: //
+                    goto PullUpLAndExit; // short jumps save bytes
+                    break;
+                case KC_G:
+                    send_string("ght"); // GHT is much more common
+                    return_state = false; // done.
+                    break;
+            }
+            break;
+
+
+/*
+// right hand adaptives
+*/
+
+        case KC_E: //
+            switch (prior_keycode) { //
+                case KC_A:
+                    tap_code(KC_U); // "AE" yields "AU" (8x more common)
+                    return_state = false; // done.
+                    break;
+            }
+            break;
+        case KC_H: // How often are we likely to hit BS so quickly after?
+            switch (prior_keycode) { // maybe OK? What about xxR? resulting in a SFB on thumb?
+                case KC_E:
+                    tap_code(KC_O); // "EH" yields "EO" (1.75:1)
+                    return_state = false; // done.
+                    break;
+                case KC_O:
+                    tap_code(KC_E); // "OH" yields "OE" (almost 1:1, but eliminates an SFB?)
+                    return_state = false; // done.
+                    break;
+                case KC_U:
+                    tap_code(KC_A); // "UH" yields "UA" (126x more common)
+                    return_state = false; // done.
+                    break;
+
+            }
+            break;
+
+        case KC_K:
+            switch (prior_keycode) {
+                case KC_Y:  // eliminate SFB on ring finger
+                    tap_code(KC_I);
+                    return_state = false; // done.
+                    break;
+            }
+            break;
+        case KC_U:
+            switch (prior_keycode) {
+                case KC_K: // make KU send Qu
+                    tap_code(KC_BSPC);
+                    tap_code(KC_Q);
+                    break;
+            }
+            break;
+
+
+#ifdef THUMB_REPEATER
+        case HD_REPEATER_A: // Make a repeat key of the secondary thumb key on both sides
+        case HD_REPEATER_B: // for most common double letters (inherently SFBs)
+            switch (prior_keycode) {
+                case KC_A ... KC_SLASH: // Any alpha can be repeated?
+/* double-letter frequencies from Peter Norvig's data <https://norvig.com/mayzner.html>
+                case KC_L: // 0.577%
+                case KC_S: // 0.405%
+                case KC_E: // 0.378%
+                case KC_O: // 0.210%
+                case KC_T: // 0.171%
+                case KC_F: // 0.146%
+                case KC_P: // 0.137%
+                case KC_R: // 0.121%
+                case KC_M: // 0.096%
+                case KC_C: // 0.083%
+                case KC_N: // 0.073%
+                case KC_D: // 0.043%
+                case KC_G: // 0.025%
+                case KC_I: // 0.023%
+                case KC_B: // 0.011%
+                case KC_A: // 0.003%
+                case KC_Z: // 0.003%
+                case KC_X: // 0.003%
+                case KC_U: // 0.001%
+                case KC_H: // 0.001%
+*/
+                    tap_code(prior_keycode); // eliminate SFB on double
+                    return_state = false; // done.
+            }
+            break;
+#endif
+#ifdef ADAPTIVE_TRAILER
+// Using Adaptives for macros (like a flexible LeaderKey)
+        case ADAPTIVE_TRAILER:
+            switch (prior_keycode) {
+#ifdef adaptAMINS
+                case KC_A: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptAMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptBMINS
+                case KC_B: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptBMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptCMINS
+                case KC_C: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptCMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptDMINS
+                case KC_D: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptDMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptEMINS
+                case KC_E: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptEMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptFMINS
+                case KC_F: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptFMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptGMINS
+                case KC_G: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptGMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptHMINS
+                case KC_H: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptHMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptIMINS
+                case KC_I: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptIMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptJMINS
+                case KC_J: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptJMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptKMINS
+                case KC_K: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptKMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptLMINS
+                case KC_L: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptLMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptMMINS
+                case KC_M: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptMMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptNMINS
+                case KC_N: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptNMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptOMINS
+                case KC_O: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptOMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptPMINS
+                case KC_P: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptPMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptRMINS
+                case KC_R: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptRMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptSMINS
+                case KC_S: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptSMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptTMINS
+                case KC_T: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptTMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptUMINS
+                case KC_U: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptUMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptVMINS
+                case KC_V: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptVMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptWMINS
+                case KC_W: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptWMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptYMINS
+                case KC_Y: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptYMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptYMINS
+                case KC_Y: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptYMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+            }
+            break;
+#endif // ADAPTIVE_TRAILER
+
+    }
+    if (return_state) { // no adaptive processed, cancel state and pass it on.
+        set_mods(saved_mods);
+        prior_keycode = keycode = 0;
+    }
+    return return_state; //
+}
diff --git a/handsdown/nu-config.h b/handsdown/nu-config.h
new file mode 100644
index 0000000..1b57492
--- /dev/null
+++ b/handsdown/nu-config.h
@@ -0,0 +1,286 @@
+
+//
+// The Hands Down Variation dependent defs & files
+//
+#define HD_adaptive_code "handsdown/nu-adaptive.c"
+//
+//
+//       Alpha Layer for a 34 key formfactor
+// ╭─────────────────────╮ ╭─────────────────────╮
+// │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │
+// │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │
+// │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │
+// ╰───────────╮ LH2 LH1 │ │ RH1 RH2  ╭──────────╯
+//             ╰─────────╯ ╰──────────╯
+//              Hands Down Neu
+// ╭─────────────────────╮ ╭─────────────────────╮
+// │  W   F   M   P   V  │ │  #$  .:  /*  "[  '] │
+// │  R   S   N   T   B  | |  ,;   A   E   I   H │
+// │  X   C   L   D   G  │ │  -+   U   O   Y   K │
+// ╰───────────╮ TAB BSP │ │ SPC  RET ╭──────────╯
+//             ╰─────────╯ ╰──────────╯
+// Q (LT3) & Z (LT4) are on the punc layer
+// and on combos (defined below)
+//
+// for now...
+// This will morph to being entirel properly abstracted
+// similar to Miryoku, (maybe someone will make an HD Miryoku someday?)
+//
+//
+// We want to be able to define a combo either
+// by location for variation independent, spatial referencing, or
+// or by letter for mnemonic/phonetic referencing (variation dependent)
+//
+// BE CAREFUL to not double define a combo!
+//
+// First, let's add any hold-taps to the keycodes
+//
+#define HD_A RSFT_T(KC_A)
+#define HD_B KC_B
+#define HD_C RALT_T(KC_C)
+#define HD_D KC_D
+#define HD_E RGUI_T(KC_E)
+#define HD_F KC_F
+#define HD_G KC_G
+#define HD_H RCTL_T(KC_H)
+#define HD_I RALT_T(KC_I)
+#define HD_J KC_J
+#define HD_K KC_K
+#define HD_L KC_L
+#define HD_M KC_M
+#define HD_N RGUI_T(KC_N)
+#define HD_O KC_O
+#define HD_P KC_P
+#define HD_Q KC_Q
+#define HD_R RCTL_T(KC_R)
+#define HD_S RALT_T(KC_S)
+#define HD_T RSFT_T(KC_T)
+#define HD_U KC_U
+#define HD_V KC_V
+#define HD_W KC_W
+#define HD_X KC_X
+#define HD_Y KC_Y
+#define HD_Z KC_Z
+
+#define HD_MINS KC_MINS
+#define HD_HASH KC_HASH
+#define HD_SPC  LT(L_PUNCT,KC_SPC)
+#define HD_BSPC LT(L_FN_NUM,KC_BSPC)
+#define HD_ENT  LT(L_NAV,KC_ENT)
+#define HD_QUOT KC_QUOT
+#define HD_DQUO KC_DQUO
+#define HD_SLSH KC_SLSH
+#define HD_DOT  KC_DOT
+#define HD_COMM LT(L_FN_NUM, KC_COMM)
+
+//
+// Now let's also defineo the keycodes on the map for spatial referencing
+//
+// (is there anyway to combine these 2 steps?)
+//
+#define HD_LT4 HD_W
+#define HD_LT3 HD_F
+#define HD_LT2 HD_M
+#define HD_LT1 HD_P
+#define HD_LT0 HD_V
+#define HD_RT0 HD_HASH
+#define HD_RT1 HD_DOT
+#define HD_RT2 HD_SLSH
+#define HD_RT3 HD_DQUO
+#define HD_RT4 HD_QUOT
+
+#define HD_LM4 HD_R
+#define HD_LM3 HD_S
+#define HD_LM2 HD_N
+#define HD_LM1 HD_T
+#define HD_LM0 HD_B
+#define HD_RM0 HD_COMM
+#define HD_RM1 HD_A
+#define HD_RM2 HD_E
+#define HD_RM3 HD_I
+#define HD_RM4 HD_H
+
+#define HD_LB4 HD_X
+#define HD_LB3 HD_C
+#define HD_LB2 HD_L
+#define HD_LB1 HD_D
+#define HD_LB0 HD_G
+#define HD_RB0 HD_MINS
+#define HD_RB1 HD_U
+#define HD_RB2 HD_O
+#define HD_RB3 HD_Y
+#define HD_RB4 HD_K
+
+//Primary Thumbs (others unique to the board)
+#define HD_LH2 KC_TAB
+#define HD_LH1 HD_BSPC
+#define HD_RH1 HD_SPC
+#define HD_RH2 HD_ENT
+
+
+
+#ifdef COMBO_ENABLE
+//
+// Combo definitions that rely on phonetics/mnemonics for their locations.
+//
+// Combos that are spacially organized don't need to be redefined
+// to match the base alpha layer, so they are not included here.
+//
+// These few spatial combos may move to accommodate some mnemonic combos,
+// notably the H-digraph combos that inhabit close areas.
+//
+#define HD_tab_keys  HD_LM4, HD_LM3     // tab
+#define HD_spc_keys  HD_LM1, HD_LM0     // SPACE
+#define HD_ent_keys  HD_LT0, HD_LT1     // ENTER
+#define HD_ent2_keys HD_LT0, HD_LT1, HD_LT2 // hard-ENTER/page break
+
+// TEXT ENTRY - off map standard alphas (also on Layer L_PUNCT @ Z=LT4 & Q=LT3)
+//
+#define HD_Z_keys HD_LM3, HD_LM1 // TYPE "z"
+#define HD_Qu_keys HD_LT3, HD_LT1 // TYPE "q" (Qu & Linger deletes u)
+
+//
+// H digraph combos
+// try to make these use the lead letter and a neighbor.
+//
+#define HD_Th_keys HD_LM2, HD_LM1 // TYPE "th"
+#define HD_Ch_keys HD_LM3, HD_LM1 // TYPE "ch"
+#define HD_Wh_keys HD_LT4, HD_LT3 // TYPE "wh"
+#define HD_Sh_keys HD_LM3, HD_LM2 // TYPE "sh"
+#define HD_Ph_keys HD_LT2, HD_LT1 // TYPE "ph"
+#define HD_Gh_keys HD_LB1, HD_LB0 // TYPE "gh"
+#define HD_Sch_keys HD_LM4, HD_LM3, HD_LM2 // TYPE "Sch"
+
+#define HD_OE_lig_keys HD_RM2, HD_RB2 // Œ
+#define HD_AE_lig_keys HD_RM1, HD_RB1 // Æ
+
+
+#ifdef EN_PRONOUN_COMBOS
+// the entirely unnecessary pronoun combo shenanigans
+
+// PRONOUNS Fast 4-7grams
+#define HD_Icap_keys  HD_I, HD_H  // TYPE "I"
+#define HD_Id_keys    HD_I, HD_D  // TYPE "I'd"+"'ve "
+#define HD_Ill_keys   HD_I, HD_L  // TYPE "I'll"+"'ve "
+#define HD_Im_keys    HD_I, HD_M  // TYPE "I'm "
+#define HD_Iv_keys    HD_I, HD_V  // TYPE "I've "
+
+#ifdef EN_PRONOUN_COMBOS_ALL // Admittedly of questionable value
+#define HD_youd_keys  HD_Y, HD_D  // TYPE "you'd" + 've
+#define HD_youll_keys HD_Y, HD_L  // TYPE "you'll" + 've
+#define HD_youre_keys HD_Y, HD_R  // TYPE "you're"
+#define HD_youve_keys HD_Y, HD_V  // TYPE "you've"
+#define HD_your_keys  HD_Y, HD_P  // TYPE "your" "P" for "possessive" case
+#define HD_their_keys HD_T, HD_W  // TYPE "their" #6
+#define HD_they_keys  HD_T, HD_Y  // "they" #23 + 've
+#define HD_theyd_keys HD_T, HD_X  // "they'd" #23 + 've
+#define HD_theyll_keys HD_T, HD_L // "they'll" #23 + 've
+#define HD_theyre_keys HD_T, HD_QUOT // "they're"
+
+#define HD_there_keys HD_T, HD_F  // TYPE "there" #7 + 's
+#define HD_here_keys  HD_H, HD_R  // TYPE "here" #5 + 's
+
+
+#ifdef EN_W_PRONOUNS
+#define HD_where_keys HD_X, HD_R  // "where" + 's
+#define HD_wed_keys   HD_X, HD_G  // TYPE "we'd" + 've
+#define HD_well_keys  HD_X, HD_M  // TYPE "we'll" + 've
+#define HD_were_keys  HD_X, HD_QUOT  // TYPE "we're"
+#define HD_weve_keys  HD_X, HD_J  // TYPE "we've"
+#endif // EN_W_PRONOUNS
+
+#endif // EN_PRONOUN_keysS_ALL
+#endif // EN_PRONOUN_keysS // the entirely unnecessary pronoun combo shenanigans
+
+
+
+// SEMANTIC FUNCTIONS  ** uses SemKeys **
+// Spatially arranged on the QWERTY ZXCV locations
+//
+#define HD_new_keys   HD_LM2, HD_LB2   // new
+#define HD_open_keys  HD_LM1, HD_LB1   // open
+#define HD_close_keys HD_LM3, HD_LB3   // close
+#define HD_quit_keys  HD_LB0, HD_LM0   // quit
+#define HD_find_keys  HD_RM4, HD_RB0   // find selection
+#define HD_sall_keys  HD_LB4, HD_LB1   // select all
+#define HD_swrd_keys  HD_LB4, HD_LB0   // select word
+#define HD_undo_keys  HD_LB4, HD_LB3   // undo
+#define HD_redo_keys  HD_LB4, HD_LB3, HD_LB2   // redo
+//#define HD_cut_keys   HD_LB4, HD_LB2   // cut
+#define HD_copy_keys  HD_LB3, HD_LB2   // copy (hold for cut)
+#define HD_pste_keys  HD_LB2, HD_LB1   // paste (hold for paste-match)
+
+
+
+#ifdef JP_MODE_ENABLE
+#ifdef JP_YOUON_COMBOS
+// Major Japanese contracted consonants as combos
+//
+// These will conflict with some diacritics (noted below),
+// so some sort of mode-switch in process_keys_event is necessary
+// for both to be used on the same board.
+//
+// There is also risk of conflict with spatial any phonetically/mnemonically coded combos.
+//
+// Major (high frequency) Japanese contracted sounds
+#define JP_kya_keys HD_LM0, HD_RM1 // きゃ
+#define JP_kyu_keys HD_LM0, HD_RB1 //　きゅ
+#define JP_kyo_keys HD_LM0, HD_RB2 //　きょ
+#define JP_sya_keys HD_LM4, HD_RM1 // しゃ
+#define JP_syu_keys HD_LM4, HD_RB1 //　しゅ
+#define JP_sye_keys HD_LM4, HD_RM2 //　しぇ
+#define JP_syo_keys HD_LM4, HD_RB2 //　しょ
+#define JP_zya_keys HD_LM3, HD_RM1 // じゃ
+#define JP_zyu_keys HD_LM3, HD_RB1 //　じゅ
+#define JP_zyo_keys HD_LM3, HD_RB2 //　じょ
+#define JP_tya_keys HD_LM1, HD_RM1 // ちゃ
+#define JP_tyu_keys HD_LM1, HD_RB1 //　ちゅ
+#define JP_tye_keys HD_LM1, HD_RM2 // ちぇ
+#define JP_tyo_keys HD_LM1, HD_RB2 //　ちょ
+#define JP_pya_keys HD_LB3, HD_RM1 // ぴゃ
+#define JP_pyu_keys HD_LB3, HD_RB1 //　ぴゅ
+#define JP_pyo_keys HD_LB3, HD_RB2 //　ぴょ
+
+#ifdef JP_YOUON_COMBOS_ALL // All Japanese contracted sounds
+
+#define JP_gya_keys HD_LT1, HD_RM1 // ぎゃ
+#define JP_gyu_keys HD_LT1, HD_RB1 //　ぎゅ
+#define JP_gyo_keys HD_LT1, HD_RB2 //　ぎょ
+#define JP_tha_keys HD_LM2, HD_LM1, HD_RM1 // てゃ
+#define JP_thi_keys HD_LM2, HD_LM1, HD_RM3 // てぃ
+#define JP_thu_keys HD_LM2, HD_LM1, HD_RB1 //　てゅ
+#define JP_the_keys HD_LM2, HD_LM1, HD_RM2 // てぇ
+#define JP_tho_keys HD_LM2, HD_LM1, HD_RB2 //　てょ
+#define JP_dha_keys HD_LB1, HD_RM1 // でゃ
+#define JP_dhi_keys HD_LB1, HD_RM3 // でぃ
+#define JP_dhu_keys HD_LB1, HD_RB1 //　でゅ
+#define JP_dhe_keys HD_LB1, HD_RM2 // でぇ
+#define JP_dho_keys HD_LB1, HD_RB2 //　でょ
+#define JP_nya_keys HD_LM2, HD_RM1 // にゃ
+#define JP_nyu_keys HD_LM2, HD_RB1 //　にゅ
+#define JP_nyo_keys HD_LM2, HD_RB2 //　にょ
+
+//#define JP_hya_keys HD_RM4, HD_RM1 // ひゃ conflicts with diacritic
+#define JP_hyu_keys HD_RM4, HD_RB1 //　ひゅ
+#define JP_hyo_keys HD_RM4, HD_RB2 //　ひょ
+//#define JP_fya_keys HD_RM4, HD_RM1 // ふぁ unnecessary?
+//#define JP_fyu_keys HD_RM4, HD_RB1 //　ふぃ
+//#define JP_fye_keys HD_RM4, HD_RB1 //　ふぇ
+//#define JP_fyo_keys HD_RM4, HD_RB2 //　ふぉ
+
+#define JP_bya_keys HD_LB4, HD_RM1 // びゃ
+#define JP_byu_keys HD_LB4, HD_RB1 //　びゅ  conflicts with diacritic?
+#define JP_byo_keys HD_LB4, HD_RB2 //　びょ
+#define JP_mya_keys HD_LT2, HD_RM1 // みゃ
+#define JP_myu_keys HD_LT2, HD_RB1 //　みゅ
+#define JP_myo_keys HD_LT2, HD_RB2 //　みょ
+#define JP_rya_keys HD_LH1, HD_RM1 // りゃ
+#define JP_ryu_keys HD_LH1, HD_RB1 //　りゅ
+#define JP_ryo_keys HD_LH1, HD_RB2 //　りょ
+
+#endif // JP_YOUON_COMBOS_ALL // All Japanese contracted sounds
+#endif // JP_YOUON_COMBOS  // Major Japanese contracted sounds as combos
+#endif // JP_MODE_ENABLE // All Japanese mode features
+
+
+#endif // COMBO_ENABLE
diff --git a/handsdown/vb-adaptive.c b/handsdown/vb-adaptive.c
new file mode 100644
index 0000000..0729464
--- /dev/null
+++ b/handsdown/vb-adaptive.c
@@ -0,0 +1,434 @@
+/*
+ Adaptive Keys
+ Called from within process_record_user
+ 
+ Tailored for HD Vibranium-b (vb)
+ 
+ NOTE: assumed dual-function keys (MOD_TAP, LAYER_TAP) have already been handled AND
+    FILTERED OUT! The combos handler will have already taken out combo candidates,
+    which have a shorter keydown threshhold (COMBO_TERM).
+ 
+ All the goto shenanigans should be resolved after complete migration to STM/RP controllersr
+ (not totally possible, as many of my boards have embedded AVR mcus)
+
+ */
+
+
+bool process_adaptive_key(uint16_t *calling_keycode, const keyrecord_t *record) {
+    bool return_state = true; // assume we don't do anything.
+    uint16_t keycode = *calling_keycode;
+    
+    // Are we in an adaptive context? (adaptive on is assumed).
+    if (timer_elapsed(prior_keydown) > ADAPTIVE_TERM) { // outside adaptive threshhold
+        prior_keycode = prior_keydown = 0; // turn off Adaptives.
+        return true; // no adaptive conditions, so return.
+    }
+
+    // K, this could be adaptive, so process.
+    saved_mods = get_mods();
+
+    if (!caps_word_on) { // turn off shift, (first-words & Proper nouns)
+        unregister_mods(MOD_MASK_SHIFT);  //CAPS_WORD/LOCK won't be affected.
+    } // may want more granular control than this…
+
+    switch (keycode & QK_BASIC_MAX) { // process ignoring multi-function keys
+
+/*
+// Left hand adaptives (most are single-handed neighbor fingers, bc speed, dexterity limits)
+*/
+        case KC_C:
+            switch (prior_keycode) {
+                case KC_T: // roll for tch
+                    send_string("ch"); // 85% of tc is tch, so this saves a lot of key press "H"
+                    return_state = false; // done.
+                    break;
+                case KC_B: // eliminate BS SFB (BS is 23x more common than BC)
+                    tap_code(KC_S);  //
+                    return_state = false; // done.
+                    break;
+            }
+            break;
+        case KC_B:
+            switch (prior_keycode) {
+                case KC_C: // eliminate SB SFB (CB is 11x more common than SB)
+                    tap_code(KC_BSPC);
+                    tap_code(KC_S);
+                    break;
+           }
+            break;
+        case KC_M: // M becomes L (pull up "L" to same row)
+            switch (prior_keycode) {
+                case KC_P: // tricksy fake out
+                case KC_G: // pull up "L" (GL is 5x more common than GM)
+PullUpLAndExit:
+                    tap_code(KC_L);  // pull up "L" (PL is 15x more common than PM)
+                    return_state = false; // done.
+                    break;
+                case KC_W: // WM = LM (LM 20x more common)
+ReplacePriorWithL:
+                    tap_code(KC_BSPC);
+                    tap_code(KC_L);
+                    break;
+                case KC_X:
+                    tap_code(KC_BSPC);
+                    send_string("lml"); // for "calmly" but not quite intuitive…
+                    return_state = false; // done.
+                    break;
+            }
+            break;
+        case KC_D: // (for KD=KL; least code, no side effects)
+            switch (prior_keycode) { //
+                case KC_K:
+                case KC_V:
+                    goto PullUpLAndExit; // short jumps save bytes
+            }
+            break;
+
+        case KC_W:
+            switch (prior_keycode) {
+                case KC_X:  // W becomes P (pull up "L" to same row) after X or M
+                case KC_M:
+                    *calling_keycode = KC_P; // tricksy fake out
+                    tap_code(KC_P); // pull up P from bottom row.
+                    return_state = false; // done.
+                    break;
+                case KC_G:
+                    tap_code(KC_D); // eliminate SFB.
+                    return_state = false; // done.
+                    break;
+            }
+            break;
+        case KC_G:
+            switch (prior_keycode) {
+                case KC_K:
+                    goto PullUpLAndExit; // short jumps save bytes
+               case KC_M:
+                    goto ReplacePriorWithL;
+            }
+            break;
+
+        case KC_K:
+        case KC_V:
+            switch (prior_keycode) {
+                case KC_D: // DV/TV/GV = LV (remedy mid-index split by shifting fingering)
+                case KC_T: // TK/DK/GK = LK (remedy mid-index split by shifting fingering)
+                case KC_G: //
+                    goto ReplacePriorWithL; // short jumps save bytes
+           }
+            break;
+        case KC_T:  // alt fingering remedy for middle-index splits
+            switch (prior_keycode) {
+                case KC_K: // quickly typing "k?" yields "kn"
+                    tap_code(KC_N);
+                    return_state = false; // done.
+                    break;
+            }
+            break;
+
+        case KC_X:
+            switch (prior_keycode) {
+                case KC_W:
+                    goto PullUpLAndExit;
+                case KC_M: // "MB" is 2558x more frequent than "MX"
+                    tap_code(KC_B);
+                    return_state = false; // done.
+                    break;
+                case KC_G:
+                    tap_code(KC_T); // eliminate SFB.
+                    return_state = false; // done.
+                    break;
+            }
+        case KC_P:
+            switch (prior_keycode) {
+                case KC_D: // DP = DT eliminate SFB (DT is 2.5x more common)
+                    tap_code(KC_G);
+                    return_state = false; // done.
+                    break;
+                case KC_V: // Pull S down from middle row.
+                case KC_B: // Pull S down from middle row to make SP roll
+                    tap_code(KC_BSPC);
+                    tap_code(KC_S); //(but maybe should be BS? SP/BS are about equal...)
+                    return_state = true; // not done (process this key normally)
+                    break;
+            }
+            break;
+
+
+/*
+// right hand adaptives
+*/
+            
+          case KC_QUOT:
+              switch (prior_keycode) {
+                  case KC_DOT:
+                      send_string("edu");
+                      return_state = false; // done.
+                      break;
+                  case KC_SLSH:
+                      tap_code(KC_BSPC);
+                      send_string(".org");
+                      return_state = false; // done.
+                      break;
+              }
+              break;
+            case KC_SLSH:
+                switch (prior_keycode) {
+                    case KC_DOT:
+                        send_string("com");
+                        return_state = false; // done.
+                        break;
+      
+                }
+                break;
+
+        case KC_E: //
+            switch (prior_keycode) { //
+                case KC_A:
+                    tap_code(KC_U); // "AE" yields "AU" (8x more common)
+                    return_state = false; // done.
+                    break;
+            }
+            break;
+        case KC_H: // How often are we likely to hit BS so quickly after?
+            switch (prior_keycode) { // maybe OK? What about xxR? resulting in a SFB on thumb?
+                case KC_E:
+                    tap_code(KC_O); // "EH" yields "EO" (1.75:1)
+                    return_state = false; // done.
+                    break;
+                case KC_O:
+                    tap_code(KC_E); // "OH" yields "OE" (almost 1:1, but eliminates an SFB?)
+                    return_state = false; // done.
+                    break;
+                case KC_U:
+                    tap_code(KC_A); // "UH" yields "UA" (126x more common)
+                    return_state = false; // done.
+                    break;
+
+            }
+            break;
+
+        case KC_F:
+            switch (prior_keycode) {
+                case KC_Y: //
+                    tap_code(KC_I); // YF = YI (eliminate SFB on ring finger YI is 37x YF)
+                    return_state = false; // done.
+                    break;
+            }
+            break;
+            
+
+#ifdef THUMB_REPEATER
+        case HD_REPEATER_A: // Make a repeat key of the secondary thumb key on both sides
+        case HD_REPEATER_B: // for most common double letters (inherently SFBs)
+            switch (prior_keycode) {
+                case KC_A ... KC_SLASH: // Any alpha can be repeated?
+/* double-letter frequencies from Peter Norvig's data <https://norvig.com/mayzner.html>
+                case KC_L: // 0.577%
+                case KC_S: // 0.405%
+                case KC_E: // 0.378%
+                case KC_O: // 0.210%
+                case KC_T: // 0.171%
+                case KC_F: // 0.146%
+                case KC_P: // 0.137%
+                case KC_R: // 0.121%
+                case KC_M: // 0.096%
+                case KC_C: // 0.083%
+                case KC_N: // 0.073%
+                case KC_D: // 0.043%
+                case KC_G: // 0.025%
+                case KC_I: // 0.023%
+                case KC_B: // 0.011%
+                case KC_A: // 0.003%
+                case KC_Z: // 0.003%
+                case KC_X: // 0.003%
+                case KC_U: // 0.001%
+                case KC_H: // 0.001%
+*/
+                    tap_code(prior_keycode); // eliminate SFB on double
+                    return_state = false; // done.
+            }
+            break;
+#endif
+#ifdef ADAPTIVE_TRAILER
+// Using Adaptives for macros (like a flexible LeaderKey)
+        case ADAPTIVE_TRAILER:
+            switch (prior_keycode) {
+#ifdef adaptAMINS
+                case KC_A: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptAMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptBMINS
+                case KC_B: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptBMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptCMINS
+                case KC_C: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptCMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptDMINS
+                case KC_D: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptDMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptEMINS
+                case KC_E: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptEMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptFMINS
+                case KC_F: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptFMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptGMINS
+                case KC_G: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptGMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptHMINS
+                case KC_H: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptHMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptIMINS
+                case KC_I: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptIMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptJMINS
+                case KC_J: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptJMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptKMINS
+                case KC_K: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptKMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptLMINS
+                case KC_L: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptLMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptMMINS
+                case KC_M: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptMMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptNMINS
+                case KC_N: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptNMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptOMINS
+                case KC_O: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptOMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptPMINS
+                case KC_P: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptPMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptRMINS
+                case KC_R: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptRMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptSMINS
+                case KC_S: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptSMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptTMINS
+                case KC_T: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptTMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptUMINS
+                case KC_U: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptUMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptVMINS
+                case KC_V: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptVMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptWMINS
+                case KC_W: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptWMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptYMINS
+                case KC_Y: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptYMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+#ifdef adaptYMINS
+                case KC_Y: //
+                    tap_code(KC_BSPC); // may have been lowercase
+                    send_string(adaptYMINS);  //
+                    return_state = false; // done.
+                    break;
+#endif
+            }
+            break;
+#endif // ADAPTIVE_TRAILER
+
+    }
+    if (return_state) { // no adaptive processed, cancel state and pass it on.
+        set_mods(saved_mods);
+        prior_keycode = keycode = 0;
+    }
+    return return_state; //
+}
diff --git a/handsdown/vb-config.h b/handsdown/vb-config.h
new file mode 100644
index 0000000..0fe321f
--- /dev/null
+++ b/handsdown/vb-config.h
@@ -0,0 +1,288 @@
+
+//
+// The Hands Down Variation dependent defs & files
+//
+#define HD_adaptive_code "handsdown/vb-adaptive.c"
+//
+//
+//       Alpha Layer for a 34 key formfactor
+// ╭─────────────────────╮ ╭─────────────────────╮
+// │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │
+// │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │
+// │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │
+// ╰───────────╮ LH2 LH1 │ │ RH1 RH2  ╭──────────╯
+//             ╰─────────╯ ╰──────────╯
+//              Hands Down Vibranium b
+// ╭─────────────────────╮ ╭─────────────────────╮
+// │  X   W   M   G   J  │ │  #$  .:  /*  "[  '] │
+// │  S   C   N   T   K  | |  ,;   A   E   I   H │
+// │  B   P   L   D   V  │ │  -+   U   O   Y   F │
+// ╰───────────╮ BSP  R  │ │ SPC  RET ╭──────────╯
+//             ╰─────────╯ ╰──────────╯
+// Q (LT3) & Z (LT4) are on the punc layer
+// and on combos (defined below)
+//
+// for now...
+// This will morph to being entirel properly abstracted
+// similar to Miryoku, (maybe someone will make an HD Miryoku someday?)
+//
+//
+
+//
+// We want to be able to define a combo either
+// by location for variation independent, spatial referencing, or
+// or by letter for mnemonic/phonetic referencing (variation dependent)
+//
+// BE CAREFUL to not double define a combo!
+//
+// First, let's add any hold-taps to the keycodes
+//
+#define HD_A RSFT_T(KC_A)
+#define HD_B KC_B
+#define HD_C RALT_T(KC_C)
+#define HD_D KC_D
+#define HD_E RGUI_T(KC_E)
+#define HD_F KC_F
+#define HD_G KC_G
+#define HD_H RCTL_T(KC_H)
+#define HD_I RALT_T(KC_I)
+#define HD_J KC_J
+#define HD_K LT(L_NUMPAD,KC_K)
+#define HD_L KC_L
+#define HD_M KC_M
+#define HD_N RGUI_T(KC_N)
+#define HD_O KC_O
+#define HD_P KC_P
+#define HD_Q KC_Q
+#define HD_R LT(L_NAV,KC_R)
+#define HD_S RCTL_T(KC_S)
+#define HD_T RSFT_T(KC_T)
+#define HD_U KC_U
+#define HD_V KC_V
+#define HD_W KC_W
+#define HD_X KC_X
+#define HD_Y KC_Y
+#define HD_Z KC_Z
+
+#define HD_MINS KC_MINS
+#define HD_HASH KC_HASH
+#define HD_SPC  LT(L_PUNCT,KC_SPC)
+#define HD_BSPC LT(L_FN_NUM,KC_BSPC)
+#define HD_ENT  LT(L_NAV,KC_ENT)
+#define HD_QUOT KC_QUOT
+#define HD_DQUO KC_DQUO
+#define HD_SLSH KC_SLSH
+#define HD_DOT  KC_DOT
+#define HD_COMM LT(L_FN_NUM, KC_COMM)
+
+//
+// Now let's also defineo the keycodes on the map for spatial referencing
+//
+// (is there anyway to combine these 2 steps?)
+//
+#define HD_LT4 HD_X
+#define HD_LT3 HD_W
+#define HD_LT2 HD_M
+#define HD_LT1 HD_G
+#define HD_LT0 HD_J
+#define HD_RT0 HD_HASH
+#define HD_RT1 HD_DOT
+#define HD_RT2 HD_SLSH
+#define HD_RT3 HD_DQUO
+#define HD_RT4 HD_QUOT
+
+#define HD_LM4 HD_S
+#define HD_LM3 HD_C
+#define HD_LM2 HD_N
+#define HD_LM1 HD_T
+#define HD_LM0 HD_K
+#define HD_RM0 HD_COMM
+#define HD_RM1 HD_A
+#define HD_RM2 HD_E
+#define HD_RM3 HD_I
+#define HD_RM4 HD_H
+
+#define HD_LB4 HD_B
+#define HD_LB3 HD_P
+#define HD_LB2 HD_L
+#define HD_LB1 HD_D
+#define HD_LB0 HD_V
+#define HD_RB0 HD_MINS
+#define HD_RB1 HD_U
+#define HD_RB2 HD_O
+#define HD_RB3 HD_Y
+#define HD_RB4 HD_F
+
+//Primary Thumbs (others unique to the board)
+#define HD_LH2 HD_BSPC
+#define HD_LH1 HD_R
+#define HD_RH1 HD_SPC
+#define HD_RH2 HD_ENT
+
+
+
+#ifdef COMBO_ENABLE
+//
+// Combo definitions that rely on phonetics/mnemonics for their locations.
+//
+// Combos that are spacially organized don't need to be redefined
+// to match the base alpha layer, so they are not included here.
+//
+// These few spatial combos may move to accommodate some mnemonic combos,
+// notably the H-digraph combos that inhabit close areas.
+//
+#define HD_tab_keys  HD_LT4, HD_LT3     // tab
+#define HD_spc_keys  HD_LM1, HD_LM0     // SPACE
+#define HD_ent_keys  HD_LB0, HD_LB1     // ENTER
+#define HD_ent2_keys HD_LB0, HD_LB1, HD_LB2 // hard-ENTER/page break
+
+// TEXT ENTRY - off map standard alphas (also on Layer L_PUNCT @ Z=LT4 & Q=LT3)
+//
+#define HD_Z_keys HD_LM3, HD_LM1 // TYPE "z"
+#define HD_Qu_keys HD_LT3, HD_LT1 // TYPE "q" (Qu & Linger deletes u)
+
+//
+// H digraph combos
+// try to make these use the lead letter and a neighbor.
+//
+#define HD_Th_keys HD_LM2, HD_LM1 // TYPE "th"
+#define HD_Ch_keys HD_LM3, HD_LM2 // TYPE "ch"
+#define HD_Wh_keys HD_LT3, HD_LT2 // TYPE "wh"
+#define HD_Sh_keys HD_LM4, HD_LM3 // TYPE "sh"
+#define HD_Ph_keys HD_LB3, HD_LB1 // TYPE "ph"
+#define HD_Gh_keys HD_LT2, HD_LT1 // TYPE "gh"
+#define HD_Sch_keys HD_LM4, HD_LM3, HD_LM2 // TYPE "Sch"
+
+#define HD_OE_lig_keys HD_RM2, HD_RB2 // Œ
+#define HD_AE_lig_keys HD_RM1, HD_RB1 // Æ
+
+
+#ifdef EN_PRONOUN_COMBOS
+// the entirely unnecessary pronoun combo shenanigans
+
+// PRONOUNS Fast 4-7grams
+#define HD_Icap_keys  HD_I, HD_H  // TYPE "I"
+#define HD_Id_keys    HD_I, HD_D  // TYPE "I'd"+"'ve "
+#define HD_Ill_keys   HD_I, HD_L  // TYPE "I'll"+"'ve "
+#define HD_Im_keys    HD_I, HD_M  // TYPE "I'm "
+#define HD_Iv_keys    HD_I, HD_V  // TYPE "I've "
+
+#ifdef EN_PRONOUN_COMBOS_ALL // Admittedly of questionable value
+#define HD_youd_keys  HD_Y, HD_D  // TYPE "you'd" + 've
+#define HD_youll_keys HD_Y, HD_L  // TYPE "you'll" + 've
+#define HD_youre_keys HD_Y, HD_R  // TYPE "you're"
+#define HD_youve_keys HD_Y, HD_V  // TYPE "you've"
+#define HD_your_keys  HD_Y, HD_P  // TYPE "your" "P" for "possessive" case
+#define HD_their_keys HD_T, HD_W  // TYPE "their" #6
+#define HD_they_keys  HD_T, HD_Y  // "they" #23 + 've
+#define HD_theyd_keys HD_T, HD_X  // "they'd" #23 + 've
+#define HD_theyll_keys HD_T, HD_L // "they'll" #23 + 've
+#define HD_theyre_keys HD_T, HD_QUOT // "they're"
+
+#define HD_there_keys HD_T, HD_F  // TYPE "there" #7 + 's
+#define HD_here_keys  HD_H, HD_R  // TYPE "here" #5 + 's
+
+
+#ifdef EN_W_PRONOUNS
+#define HD_where_keys HD_X, HD_R  // "where" + 's
+#define HD_wed_keys   HD_X, HD_G  // TYPE "we'd" + 've
+#define HD_well_keys  HD_X, HD_M  // TYPE "we'll" + 've
+#define HD_were_keys  HD_X, HD_QUOT  // TYPE "we're"
+#define HD_weve_keys  HD_X, HD_J  // TYPE "we've"
+#endif // EN_W_PRONOUNS
+
+#endif // EN_PRONOUN_keysS_ALL
+#endif // EN_PRONOUN_keysS // the entirely unnecessary pronoun combo shenanigans
+
+
+
+// SEMANTIC FUNCTIONS  ** uses SemKeys **
+// Spatially arranged on the QWERTY ZXCV locations
+//
+#define HD_new_keys   HD_LM2, HD_LB2   // new
+#define HD_open_keys  HD_LM1, HD_LB1   // open
+#define HD_close_keys HD_LM3, HD_LB3   // close
+#define HD_quit_keys  HD_LB0, HD_LM0   // quit
+#define HD_find_keys  HD_RM4, HD_RB0   // find selection
+#define HD_sall_keys  HD_LB4, HD_LB1   // select all
+#define HD_swrd_keys  HD_LB4, HD_LB0   // select word
+#define HD_undo_keys  HD_LB4, HD_LB3   // undo
+#define HD_redo_keys  HD_LB4, HD_LB3, HD_LB2   // redo
+//#define HD_cut_keys   HD_LB4, HD_LB2   // cut
+#define HD_copy_keys  HD_LB3, HD_LB2   // copy (hold for cut)
+#define HD_pste_keys  HD_LB2, HD_LB1   // paste (hold for paste-match)
+
+
+
+#ifdef JP_MODE_ENABLE
+#ifdef JP_YOUON_COMBOS
+// Major Japanese contracted consonants as combos
+//
+// These will conflict with some diacritics (noted below),
+// so some sort of mode-switch in process_keys_event is necessary
+// for both to be used on the same board.
+//
+// There is also risk of conflict with spatial any phonetically/mnemonically coded combos.
+//
+// Major (high frequency) Japanese contracted sounds
+#define JP_kya_keys HD_LM0, HD_RM1 // きゃ
+#define JP_kyu_keys HD_LM0, HD_RB1 //　きゅ
+#define JP_kyo_keys HD_LM0, HD_RB2 //　きょ
+#define JP_sya_keys HD_LM4, HD_RM1 // しゃ
+#define JP_syu_keys HD_LM4, HD_RB1 //　しゅ
+#define JP_sye_keys HD_LM4, HD_RM2 //　しぇ
+#define JP_syo_keys HD_LM4, HD_RB2 //　しょ
+#define JP_zya_keys HD_LM3, HD_RM1 // じゃ
+#define JP_zyu_keys HD_LM3, HD_RB1 //　じゅ
+#define JP_zyo_keys HD_LM3, HD_RB2 //　じょ
+#define JP_tya_keys HD_LM1, HD_RM1 // ちゃ
+#define JP_tyu_keys HD_LM1, HD_RB1 //　ちゅ
+#define JP_tye_keys HD_LM1, HD_RM2 // ちぇ
+#define JP_tyo_keys HD_LM1, HD_RB2 //　ちょ
+#define JP_pya_keys HD_LB3, HD_RM1 // ぴゃ
+#define JP_pyu_keys HD_LB3, HD_RB1 //　ぴゅ
+#define JP_pyo_keys HD_LB3, HD_RB2 //　ぴょ
+
+#ifdef JP_YOUON_COMBOS_ALL // All Japanese contracted sounds
+
+#define JP_gya_keys HD_LT1, HD_RM1 // ぎゃ
+#define JP_gyu_keys HD_LT1, HD_RB1 //　ぎゅ
+#define JP_gyo_keys HD_LT1, HD_RB2 //　ぎょ
+#define JP_tha_keys HD_LM2, HD_LM1, HD_RM1 // てゃ
+#define JP_thi_keys HD_LM2, HD_LM1, HD_RM3 // てぃ
+#define JP_thu_keys HD_LM2, HD_LM1, HD_RB1 //　てゅ
+#define JP_the_keys HD_LM2, HD_LM1, HD_RM2 // てぇ
+#define JP_tho_keys HD_LM2, HD_LM1, HD_RB2 //　てょ
+#define JP_dha_keys HD_LB1, HD_RM1 // でゃ
+#define JP_dhi_keys HD_LB1, HD_RM3 // でぃ
+#define JP_dhu_keys HD_LB1, HD_RB1 //　でゅ
+#define JP_dhe_keys HD_LB1, HD_RM2 // でぇ
+#define JP_dho_keys HD_LB1, HD_RB2 //　でょ
+#define JP_nya_keys HD_LM2, HD_RM1 // にゃ
+#define JP_nyu_keys HD_LM2, HD_RB1 //　にゅ
+#define JP_nyo_keys HD_LM2, HD_RB2 //　にょ
+
+//#define JP_hya_keys HD_RM4, HD_RM1 // ひゃ conflicts with diacritic
+#define JP_hyu_keys HD_RM4, HD_RB1 //　ひゅ
+#define JP_hyo_keys HD_RM4, HD_RB2 //　ひょ
+//#define JP_fya_keys HD_RM4, HD_RM1 // ふぁ unnecessary?
+//#define JP_fyu_keys HD_RM4, HD_RB1 //　ふぃ
+//#define JP_fye_keys HD_RM4, HD_RB1 //　ふぇ
+//#define JP_fyo_keys HD_RM4, HD_RB2 //　ふぉ
+
+#define JP_bya_keys HD_LB4, HD_RM1 // びゃ
+#define JP_byu_keys HD_LB4, HD_RB1 //　びゅ  conflicts with diacritic?
+#define JP_byo_keys HD_LB4, HD_RB2 //　びょ
+#define JP_mya_keys HD_LT2, HD_RM1 // みゃ
+#define JP_myu_keys HD_LT2, HD_RB1 //　みゅ
+#define JP_myo_keys HD_LT2, HD_RB2 //　みょ
+#define JP_rya_keys HD_LH1, HD_RM1 // りゃ
+#define JP_ryu_keys HD_LH1, HD_RB1 //　りゅ
+#define JP_ryo_keys HD_LH1, HD_RB2 //　りょ
+
+#endif // JP_YOUON_COMBOS_ALL // All Japanese contracted sounds
+#endif // JP_YOUON_COMBOS  // Major Japanese contracted sounds as combos
+#endif // JP_MODE_ENABLE // All Japanese mode features
+
+
+#endif // COMBO_ENABLE
diff --git a/moutis.c b/moutis.c
index 42fd46e..a6a8cb7 100644
--- a/moutis.c
+++ b/moutis.c
@@ -13,7 +13,7 @@ user_config_t user_config;
 uint8_t  saved_mods = 0; // to pass state between process_record_user and matrix_scan_user
 uint16_t record_keycode = 0; // the keykcode we poke at in process_record
 uint16_t key_trap = 0; // the actual keycode registered (need to unregister)
-#ifdef ADAPTIVE_ENABLED
+#ifdef ADAPTIVE_ENABLE
 uint16_t prior_keycode = KC_NO;
 uint16_t prior_keydown = 0; // timer of keydown for adaptive threshhold.
 #endif
@@ -26,13 +26,7 @@ bool mods_held = false;  // nood to remember how we entered the appmenu state
 
 #ifdef JP_MODE_ENABLE
 bool IS_ENGLISH_MODE = true;
-uint16_t myKC_C = KC_C;  // keycode for "C"  (could be Z if Japanese mode)
-uint16_t myKC_X = KC_X;  // keycode for "X"  (could be - if Japanese mode)
-//uint16_t myKC_L = KC_L;  // keycode for "L"  (could be K if Japanese mode)
-//uint16_t myKC_K = KC_K;  // keycode for "K"  (could be L if Japanese mode)
 #endif
-//uint16_t LBRC_key = KC_LBRC;  // keycode for "[" // Bronze/Ag/Pl are swapped
-//uint16_t RBRC_key = KC_RBRC;  // keycode for "]" // unneeded if only one map onboard.
 
 #ifdef RGBLIGHT_ENABLE
 int RGB_current_mode;
@@ -43,45 +37,6 @@ uint8_t  combo_on = 0;           // for combo actions to hold before triggering
 bool  combo_triggered = false;   // for one-shot-combo-actions
 
 
-#ifdef AUTO_SHIFT_ENABLE
-bool get_auto_shifted_key(uint16_t keycode, keyrecord_t *record) {
-    switch(keycode) {
-#    ifndef NO_AUTO_SHIFT_ALPHA
-        case KC_A ... KC_Z:
-#    endif
-#    ifndef NO_AUTO_SHIFT_NUMERIC
-        case KC_1 ... KC_0:
-#    endif
-#    ifndef NO_AUTO_SHIFT_SPECIAL
-        case KC_TAB:
-        case KC_MINUS ... KC_SLASH:
-        case KC_NONUS_BSLASH:
-#    endif
-        case LCTL_T(KC_C): // #ifdef Rh
-        case LT(6,KC_H):  // #ifdef Bronze
-        case LT(6,KC_R):  // #elseif Ti
-        case RALT_T(KC_I):
-        case RCTL_T(KC_H):
-        case LCTL_T(KC_R):
-        case LALT_T(KC_S):
-        case LGUI_T(KC_N):
-        case LSFT_T(KC_T):
-        case RSFT_T(KC_A):
-        case RGUI_T(KC_E):
-        case RALT_T(KC_C):
-        case RCTL_T(KC_I):
-        case LT(4,KC_COMM):
-        case LT(5,KC_B): // #std B
-        case LT(5,KC_K): // #alt K
-            return true;
-        default:
-            return false;
-    }
-}
-#endif // AUTO_SHIFT_ENABLE
-
-
-
 layer_state_t layer_state_set_user(layer_state_t layer_state) {
 
 /*
@@ -98,54 +53,10 @@ layer_state_t layer_state_set_user(layer_state_t layer_state) {
 
 
     switch (biton32(layer_state)) {
-#ifdef L_HDNEU
-        case L_HDNEU:
-#ifdef RGBLIGHT_ENABLE
-#endif
-#endif
-#ifdef L_HDGOLD
-        case L_HDGOLD:
-#ifdef RGBLIGHT_ENABLE
-            rgblight_sethsv_noeeprom(36, 240, 240);
-            break;
-#endif
-#endif
-//#ifdef L_HDTITANIUM
-        case L_HDTITANIUM:
-//#endif
-#ifdef L_HDRHODIUM
-        case L_HDRHODIUM:
+        case L_HDALPHA:
 #ifdef RGBLIGHT_ENABLE
             rgblight_sethsv_noeeprom(128, 128, 128);
             break;
-#endif
-#endif
-#if defined(L_HDNEU) || defined(L_HDGOLD) || defined(L_HDTITANIUM) || defined(L_HDRHODIUM)
-           LBRC_key = KC_LBRC;  // keycode for "["
-           RBRC_key = KC_RBRC;  // keycode for "]"
-           break;
-#endif
-#ifdef L_HDBRONZE
-        case L_HDBRONZE:
-#ifdef RGBLIGHT_ENABLE
-            rgblight_sethsv_noeeprom(12, 228, 228);
-            break;
-#endif
-#endif
-#ifdef L_HDSILVER
-        case L_HDSILVER,
-#ifdef RGBLIGHT_ENABLE
-#endif
-#endif
-#ifdef L_HDPLATINUM
-        case L_HDPLATINUM,
-#ifdef RGBLIGHT_ENABLE
-#endif
-#endif
-#if defined(L_HDBRONZE) || defined(L_HDSILVER) || defined(L_HDPLATINUM) || defined(L_HDRHODIUM)
-//        LBRC_key = KC_RBRC;  // keycode for "]"
-//        RBRC_key = KC_LBRC;  // keycode for "["
-//        break;
 #endif
         case L_PUNCT:
 #ifdef RGBLIGHT_ENABLE
@@ -203,6 +114,7 @@ void keyboard_post_init_user(void) {
 #endif
 }
 
+#include "moutis_app_menu.c" // my custom app_menu handler (mac/win)
 
 #include "moutis_semantickeys.c" // anything could send a semantic, so…first
 
@@ -215,39 +127,16 @@ void keyboard_post_init_user(void) {
 #endif
 
 #ifdef COMBO_ENABLE
-    #include HD_combo_code
+    #include "moutis_combo.c"  // combo processing code (def in keymap)
 #endif
 
 #include "moutis_casemods.c"
 
-#ifdef ADAPTIVE_ENABLED
-#include HD_adaptive_code
+#ifdef ADAPTIVE_ENABLE
+#include HD_adaptive_code   // this is HD variation dependent
 #endif
 
-#include HD_process_record_code
-
-
-#include "moutis_MATRIX.c"
-// This
-
-#ifdef KEY_OVERRIDE_ENABLE  // If using QMK's key overrides...
-const key_override_t delete_key_override = ko_make_basic(MOD_MASK_SHIFT, LT(L_NUMPAD,KC_BSPC), KC_DELETE);
-const key_override_t ques_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_QUES, KC_EXLM);
-const key_override_t hash_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_HASH, KC_AT);
-const key_override_t dot_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_DOT, KC_COLN);
-const key_override_t comm_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_COMM, KC_SCLN);
-const key_override_t slsh_key_override = ko_make_basic(MOD_MASK_SHIFT, KC_SLSH, KC_ASTR);
-const key_override_t bsls_key_override = ko_make_basic(MOD_MASK_ALT, KC_SLSH, KC_BSLS);
-
-// This globally defines all key overrides to be used
-const key_override_t **key_overrides = (const key_override_t *[]){
-    &delete_key_override,
-    &ques_key_override,
-    &hash_key_override,
-    &dot_key_override,
-    &comm_key_override,
-    &slsh_key_override,
-    &bsls_key_override,
-    NULL // Null terminate the array of overrides!
-};
-#endif
+// #include HD_process_record_code   // this might need to be HD variation dependent?
+#include "moutis_process_record.c"
+
+#include "moutis_matrix.c"
diff --git a/moutis.h b/moutis.h
index b7d64a3..6f49c90 100644
--- a/moutis.h
+++ b/moutis.h
@@ -1,5 +1,12 @@
 #pragma once
 
+//
+// which HD alpha variation are we using?
+//
+// defines all variation dependent constants/files/keycodes, etc.
+#include "handsdown/au-config.h"
+
+
 #ifndef USERSPACE
     #define USERSPACE
 #endif
@@ -42,55 +49,54 @@ extern rgblight_config_t rgblight_config;
 #endif
 
 
+
 #ifdef COMBO_ENABLE
     #include "process_combo.h"
 #endif
 
 #include "moutis_casemods.h"
 
-#include "HDvariations/vb/moutis_COMBO_hd.h"
-
-#define HD_combo_code "HDvariations/vb/moutis_COMBO_hd.c"
-#define HD_adaptive_code "HDvariations/vb/moutis_adaptivekeys_hd.c"
-#define HD_process_record_code "HDvariations/vb/moutis_PROCESS_RECORD_hd.c"
-
-
-void matrix_scan_user_process_combo(void);
-
+#include "moutis_combo.h"  //
+
+//
+// These COULD be made variation dependent, to allow
+// them to adapt to geometry differences. Ex.
+// most NEU variations have " ' on ring/pinky
+// but Bronze/Silver heve ' " (inverted)
+// since [ ] and « » are SHIFT/ALT of " '
+// the paired brackets would be inverted.
+// Perhaps simply redefining these in the xx-config.h
+// to override these defs would be the right approach?
+//
 #define DQUO_S  KC_RBRC // ]
 #define DQUO_A  A(S(KC_BSLS)) // »
 #define DQUO_SA A(S(KC_4)) // ›
 #define SQUO_S  KC_LBRC // [
 #define SQUO_A  A(KC_BSLS) // «
 #define SQUO_SA A(S(KC_3)) // ‹
+#define JRQU KC_RBRC // keycode for "[" in Japanese mode
+#define JLQU KC_LBRC // keycode for "]" in Japanese mode
+
 
 typedef union {
     uint32_t raw;
     struct {
-        uint8_t LBRC_key;  // keycode for "["
-        uint8_t RBRC_key;  // keycode for "]"
-        uint8_t OSIndex; // index of platforms (0=mac, 1=win, 2=lux)?
-        bool AdaptiveKeys; // Adaptive Keys On?
+        uint8_t OSIndex; // index of platforms (0=mac, 1=win, 2=lux)? // used by semantickeys
+        bool AdaptiveKeys; // Adaptive Keys On? (and advanced combos)
     };
 } user_config_t;
 
 
 enum my_layers {  // must be difined before semantickeys.h
 // enum my_layers for layout layers for HD Neu family
-    L_QWERTY,    //
-//    L_HDNUE,     // N             RSNT AEIH
-//      L_HDBRONZE,  // B BR (Neu-hx) RSNT AECI (same home row as Platinum)
-//    L_HDSILVER,  // S Ag (Neu-nx) RSHT AECI
-//    L_HDPLATINUM,// P Pl (Neu-lx) RSNT AECI (same home row as Bronze)
-//    L_HDGOLD,    // G Au (Neu-tx) RSND AEIH
-      L_HDTITANIUM,// T Ti (Neu-rx) CSNT AEIH
-//    L_HDRHODIUM, // R Rh (Neu-rxm) CSNT AEIM
-      L_PUNCT,     // 2
-      L_FN_NUM,    // 3
-      L_NUMPAD,    // 4
-      L_NAV,       // 5
-//    L_SYMBOLS,   //  diacritics…maybe to be handled by semantickeys?
-      L_MEDIA_KBD  // 6
+    L_QWERTY,    // 0 - QWERTY compatibility layer
+    L_HDALPHA,   // 1 - Hands Down Alpha layer
+    L_PUNCT,     // 2 - symbols, punctuation, off-map alphas
+    L_FN_NUM,    // 3 - number row & function row
+    L_NUMPAD,    // 4 - numpad (right); navpad (left)
+    L_NAV,       // 5 - nav pad (right); meta keys (left)
+//  L_SYMBOLS,   //  diacritics are better handled by combos and semantickeys?
+    L_MEDIA_KBD  // 6 - Media/Consumer controls; Keyboard settings
 };
 
 enum OS_Platform { // Used for platform support via SemKeys
@@ -103,13 +109,6 @@ enum OS_Platform { // Used for platform support via SemKeys
 
 #define register_linger_key(kc) {register_code16(kc);linger_key = kc;linger_timer = state_reset_timer = timer_read();}
 #define unregister_linger_key() {unregister_code16(linger_key);linger_key = 0;}
-/*
-#define register_linger_key(kc) register_code16(kc);
-#define unregister_linger_key(kc) unregister_code16(kc);
-*/
-
-#ifdef JP_MODE_ENABLE
-bool IS_ENGLISH_MODE;
-//#define IS_ENGLISH_MODE (myKC_C == KC_C)
-#define TOGGLE_ENGLISH_MODE {IS_ENGLISH_MODE ^= true;}
-#endif
+
+
+void matrix_scan_user_process_combo(void);
diff --git a/moutis_BONGO.c b/moutis_BONGO.c
new file mode 100644
index 0000000..ce89724
--- /dev/null
+++ b/moutis_BONGO.c
@@ -0,0 +1,167 @@
+
+
+
+// WPM-responsive animation stuff here
+#define IDLE_FRAMES 5
+#define IDLE_SPEED 40 // below this wpm value your animation will idle
+
+// #define PREP_FRAMES 1 // uncomment if >1
+
+#define TAP_FRAMES 2
+#define TAP_SPEED 30 // above this wpm value typing animation to triggere
+
+#define ANIM_FRAME_DURATION 200 // how long each frame lasts in ms
+// #define SLEEP_TIMER 60000 // should sleep after this period of 0 wpm, needs fixing
+#define ANIM_SIZE 636 // number of bytes in array, minimize for adequate firmware size, max is 1024
+
+uint32_t anim_timer = 0;
+uint32_t anim_sleep = 0;
+uint8_t current_idle_frame = 0;
+// uint8_t current_prep_frame = 0; // uncomment if PREP_FRAMES >1
+uint8_t current_tap_frame = 0;
+
+// Images credit j-inc(/James Incandenza) and pixelbenny. Credit to obosob for initial animation approach.
+static void render_BONGO(void) {
+    static const char PROGMEM idle[IDLE_FRAMES][ANIM_SIZE] = {
+        {
+        0,  0,126,126, 24, 60,102, 66,  0, 12, 28,112,112, 28, 12,  0,116,116, 20, 20,124,104,  0,124,124,  0,112,120, 44, 36,124,124,0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16, 16,  8,  8,  4,  4,  4,  8, 48, 64,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,128,
+        0,  0,  0,  0,192, 96, 48, 24, 12,132,198, 98, 35, 51, 17,145,113,241,113,145, 17, 51, 35, 98,198,132, 12, 24, 48, 96,192,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 24,100,130,  2,  2,  2,  2,  2,  1,  0,  0,  0,  0,128,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,  0, 48, 48,  0,192,193,193,194,  4,  8, 16, 32, 64,128,  0,  0,  0,128,128,128,128, 64, 64, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  8,  8,  8,  8,196,  4,196,  4,196,  2,194,  2,194,  1,  1,  1,  1,  0,  0,  0,
+        0,  0,252, 15,  1,  0,248, 14, 31,109,140,148,148,164,166,249,224,255,224,249,166,164,148,148,140,109, 31, 14,248,  0,  1, 15,252,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,192, 56,  4,  3,  0,  0,  0,  0,  0,  0,  0, 12, 12, 12, 13,  1,  0, 64,160, 33, 34, 18, 17, 17, 17,  9,  8,  8,  8,  8,  4,  4,  8,  8, 16, 16, 16, 16, 16, 17, 15,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,170,170,255,255,195,191,127,  3,127,191,195,255,255,170,170,  0,  0,  0,  0,
+        0,  0, 31,120,192,  0, 15, 56,124,219,152, 20, 20, 18, 50,207,  3,255,  3,207, 50, 18, 20, 20,152,219,124, 56, 15,  0,192,120, 31, 16, 16, 16, 16,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  2,  3,  2,  2,  1,  1,  1,  1,  1,  1,  2,  2,  4,  4,  8,  8,  8,  8,  8,  7,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2,130,135, 31,  7,159,  7, 28,  7,159,  7,159,  7,  2,130,  0,  0,  0,  0,
+        32, 16, 16, 16, 17, 11, 14, 12, 24, 16, 49, 35, 98,102, 68, 68, 71, 71, 71, 68, 68,102, 98, 35, 49, 16, 24, 12,  6,  3,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  7,  8,  8, 23,  0, 15,  1,  2,  1, 15,  0, 15,  2,  5,  8
+        },
+        {
+        0,  0,126,126, 24, 60,102, 66,  0, 12, 28,112,112, 28, 12,  0,116,116, 20, 20,124,104,  0,124,124,  0,112,120, 44, 36,124,124,0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16, 16,  8,  8,  4,  4,  4,  8, 48, 64,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,128,
+        0,  0,  0,  0,192, 96, 48, 24, 12,132,198, 98, 35, 51, 17,145,113,241,113,145, 17, 51, 35, 98,198,132, 12, 24, 48, 96,192,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 24,100,130,  2,  2,  2,  2,  2,  1,  0,  0,  0,  0,128,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,  0, 48, 48,  0,192,193,193,194,  4,  8, 16, 32, 64,128,  0,  0,  0,128,128,128,128, 64, 64, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  8,  8,  8,  8,196,  4,196,  4,196,  2,194,  2,194,  1,  1,  1,  1,  0,  0,  0,
+        0,  0,252, 15,  1,  0,248, 14, 31,109,140,148,148,164,166,249,224,255,224,249,166,164,148,148,140,109, 31, 14,248,  0,  1, 15,252,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,192, 56,  4,  3,  0,  0,  0,  0,  0,  0,  0, 12, 12, 12, 13,  1,  0, 64,160, 33, 34, 18, 17, 17, 17,  9,  8,  8,  8,  8,  4,  4,  8,  8, 16, 16, 16, 16, 16, 17, 15,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,170,170,255,255,195,191,127,  3,127,191,195,255,255,170,170,  0,  0,  0,  0,
+        0,  0, 31,120,192,  0, 15, 56,124,219,152, 20, 20, 18, 50,207,  3,255,  3,207, 50, 18, 20, 20,152,219,124, 56, 15,  0,192,120, 31, 16, 16, 16, 16,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  2,  3,  2,  2,  1,  1,  1,  1,  1,  1,  2,  2,  4,  4,  8,  8,  8,  8,  8,  7,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2,130,135, 31,  7,159,  7, 28,  7,159,  7,159,  7,  2,130,  0,  0,  0,  0,
+        32, 16, 16, 16, 17, 11, 14, 12, 24, 16, 49, 35, 98,102, 68, 68, 71, 71, 71, 68, 68,102, 98, 35, 49, 16, 24, 12,  6,  3,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  7,  8,  8, 23,  0, 15,  1,  2,  1, 15,  0, 15,  2,  5,  8
+        },
+        {
+        0,  0,126,126, 24, 60,102, 66,  0, 12, 28,112,112, 28, 12,  0,116,116, 20, 20,124,104,  0,124,124,  0,112,120, 44, 36,124,124,0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128, 64, 64, 64, 64, 32, 32, 32, 32, 16,  8,  4,  2,  2,  4, 24, 96,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,128,
+        0,  0,  0,  0,192, 96, 48, 24, 12,132,198, 98, 35, 51, 17,145,113,241,113,145, 17, 51, 35, 98,198,132, 12, 24, 48, 96,192,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 60,194,  1,  1,  2,  2,  4,  4,  2,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 96, 96,  0,129,130,130,132,  8, 16, 32, 64,128,  0,  0,  0,  0,128,128,128,128, 64, 64, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  8,  8,  8,  8,196,  4,196,  4,196,  2,194,  2,194,  1,  1,  1,  1,  0,  0,  0,
+        0,  0,252, 15,  1,  0,248, 14, 31,109,140,148,148,164,166,249,224,255,224,249,166,164,148,148,140,109, 31, 14,248,  0,  1, 15,252,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,112, 25,  6,  0,  0,  0,  0,  0,  0,  0, 24, 24, 24, 27,  3,  0, 64,160, 34, 36, 20, 18, 18, 18, 11,  8,  8,  8,  8,  5,  5,  9,  9, 16, 16, 16, 16, 16, 17, 15,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,170,170,255,255,195,191,127,  3,127,191,195,255,255,170,170,  0,  0,  0,  0,
+        0,  0, 31,120,192,  0, 15, 56,124,219,152, 20, 20, 18, 50,207,  3,255,  3,207, 50, 18, 20, 20,152,219,124, 56, 15,  0,192,120, 31, 16, 16, 16, 16,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  2,  3,  2,  2,  1,  1,  1,  1,  1,  1,  2,  2,  4,  4,  8,  8,  8,  8,  8,  7,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2,130,135, 31,  7,159,  7, 28,  7,159,  7,159,  7,  2,130,  0,  0,  0,  0,
+        32, 16, 16, 16, 17, 11, 14, 12, 24, 16, 49, 35, 98,102, 68, 68, 71, 71, 71, 68, 68,102, 98, 35, 49, 16, 24, 12,  6,  3,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  7,  8,  8, 23,  0, 15,  1,  2,  1, 15,  0, 15,  2,  5,  8
+        },
+        {
+        0,  0,126,126, 24, 60,102, 66,  0, 12, 28,112,112, 28, 12,  0,116,116, 20, 20,124,104,  0,124,124,  0,112,120, 44, 36,124,124,0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,  0,  0,  0,  0,  0,128, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  4,  2,  1,  1,  2, 12, 48, 64,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,128,
+        0,  0,  0,  0,192, 96, 48, 24, 12,132,198, 98, 35, 51, 17,145,113,241,113,145, 17, 51, 35, 98,198,132, 12, 24, 48, 96,192,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 30,225,  0,  0,  1,  1,  2,  2,  1,  0,  0,  0,  0,128,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,  0, 48, 48,  0,192,193,193,194,  4,  8, 16, 32, 64,128,  0,  0,  0,128,128,128,128, 64, 64, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  8,  8,  8,  8,196,  4,196,  4,196,  2,194,  2,194,  1,  1,  1,  1,  0,  0,  0,
+        0,  0,252, 15,  1,  0,248, 14, 31,109,140,148,148,164,166,249,224,255,224,249,166,164,148,148,140,109, 31, 14,248,  0,  1, 15,252,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,112, 12,  3,  0,  0,  0,  0,  0,  0,  0, 12, 12, 12, 13,  1,  0, 64,160, 33, 34, 18, 17, 17, 17,  9,  8,  8,  8,  8,  4,  4,  8,  8, 16, 16, 16, 16, 16, 17, 15,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,170,170,255,255,195,191,127,  3,127,191,195,255,255,170,170,  0,  0,  0,  0,
+        0,  0, 31,120,192,  0, 15, 56,124,219,152, 20, 20, 18, 50,207,  3,255,  3,207, 50, 18, 20, 20,152,219,124, 56, 15,  0,192,120, 31, 16, 16, 16, 16,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  2,  3,  2,  2,  1,  1,  1,  1,  1,  1,  2,  2,  4,  4,  8,  8,  8,  8,  8,  7,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2,130,135, 31,  7,159,  7, 28,  7,159,  7,159,  7,  2,130,  0,  0,  0,  0,
+        32, 16, 16, 16, 17, 11, 14, 12, 24, 16, 49, 35, 98,102, 68, 68, 71, 71, 71, 68, 68,102, 98, 35, 49, 16, 24, 12,  6,  3,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  7,  8,  8, 23,  0, 15,  1,  2,  1, 15,  0, 15,  2,  5,  8
+        },
+        {
+        0,  0,126,126, 24, 60,102, 66,  0, 12, 28,112,112, 28, 12,  0,116,116, 20, 20,124,104,  0,124,124,  0,112,120, 44, 36,124,124,0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  8,  4,  2,  2,  2,  4, 56, 64,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,128,
+        0,  0,  0,  0,192, 96, 48, 24, 12,132,198, 98, 35, 51, 17,145,113,241,113,145, 17, 51, 35, 98,198,132, 12, 24, 48, 96,192,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 28,226,  1,  1,  2,  2,  2,  2,  1,  0,  0,  0,  0,128,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,  0, 48, 48,  0,192,193,193,194,  4,  8, 16, 32, 64,128,  0,  0,  0,128,128,128,128, 64, 64, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  8,  8,  8,  8,196,  4,196,  4,196,  2,194,  2,194,  1,  1,  1,  1,  0,  0,  0,
+        0,  0,252, 15,  1,  0,248, 14, 31,109,140,148,148,164,166,249,224,255,224,249,166,164,148,148,140,109, 31, 14,248,  0,  1, 15,252,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,112, 12,  3,  0,  0,  0,  0,  0,  0,  0, 12, 12, 12, 13,  1,  0, 64,160, 33, 34, 18, 17, 17, 17,  9,  8,  8,  8,  8,  4,  4,  8,  8, 16, 16, 16, 16, 16, 17, 15,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,170,170,255,255,195,191,127,  3,127,191,195,255,255,170,170,  0,  0,  0,  0,
+        0,  0, 31,120,192,  0, 15, 56,124,219,152, 20, 20, 18, 50,207,  3,255,  3,207, 50, 18, 20, 20,152,219,124, 56, 15,  0,192,120, 31, 16, 16, 16, 16,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  2,  3,  2,  2,  1,  1,  1,  1,  1,  1,  2,  2,  4,  4,  8,  8,  8,  8,  8,  7,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2,130,135, 31,  7,159,  7, 28,  7,159,  7,159,  7,  2,130,  0,  0,  0,  0,
+        32, 16, 16, 16, 17, 11, 14, 12, 24, 16, 49, 35, 98,102, 68, 68, 71, 71, 71, 68, 68,102, 98, 35, 49, 16, 24, 12,  6,  3,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  7,  8,  8, 23,  0, 15,  1,  2,  1, 15,  0, 15,  2,  5,  8
+        }
+    };
+    static const char PROGMEM prep[][ANIM_SIZE] = {
+        {
+        0,  0,126,126, 24, 60,102, 66,  0, 12, 28,112,112, 28, 12,  0,116,116, 20, 20,124,104,  0,124,124,  0,112,120, 44, 36,124,124,0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,  0,  0,  0,  0,  0,128, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  4,  2,  1,  1,  2, 12, 48, 64,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,128,
+        0,  0,  0,  0,192, 96, 48, 24, 12,132,198, 98, 35, 51, 17,145,113,241,113,145, 17, 51, 35, 98,198,132, 12, 24, 48, 96,192,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 30,225,  0,  0,  1,  1,  2,  2,129,128,128,  0,  0,128,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,  0, 48, 48,  0,  0,  1,225, 26,  6,  9, 49, 53,  1,138,124,  0,  0,128,128,128,128, 64, 64, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  8,  8,  8,  8,196,  4,196,  4,196,  2,194,  2,194,  1,  1,  1,  1,  0,  0,  0,
+        0,  0,252, 15,  1,  0,248, 14, 31,109,140,148,148,164,166,249,224,255,224,249,166,164,148,148,140,109, 31, 14,248,  0,  1, 15,252,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,112, 12,  3,  0,  0, 24,  6,  5,152,153,132,195,124, 65, 65, 64, 64, 32, 33, 34, 18, 17, 17, 17,  9,  8,  8,  8,  8,  4,  4,  4,  4,  4,  4,  2,  2,  2,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,170,170,255,255,195,191,127,  3,127,191,195,255,255,170,170,  0,  0,  0,  0,
+        0,  0, 31,120,192,  0, 15, 56,124,219,152, 20, 20, 18, 50,207,  3,255,  3,207, 50, 18, 20, 20,152,219,124, 56, 15,  0,192,120, 31, 16, 16, 16, 16,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  2,  3,  2,  2,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2,130,135, 31,  7,159,  7, 28,  7,159,  7,159,  7,  2,130,  0,  0,  0,  0,
+        32, 16, 16, 16, 17, 11, 14, 12, 24, 16, 49, 35, 98,102, 68, 68, 71, 71, 71, 68, 68,102, 98, 35, 49, 16, 24, 12,  6,  3,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  7,  8,  8, 23,  0, 15,  1,  2,  1, 15,  0, 15,  2,  5,  8
+        }
+    };
+    static const char PROGMEM tap[TAP_FRAMES][ANIM_SIZE] = {
+        {
+        0,  0,126,126, 24, 60,102, 66,  0, 12, 28,112,112, 28, 12,  0,116,116, 20, 20,124,104,  0,124,124,  0,112,120, 44, 36,124,124,0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,  0,  0,  0,  0,  0,128, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  4,  2,  1,  1,  2, 12, 48, 64,128,  0,  0,  0,  0,  0,  0,  0,248,248,248,248,  0,  0,  0,  0,  0,128,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,128,
+        0,  0,  0,  0,192, 96, 48, 24, 12,132,198, 98, 35, 51, 17,145,113,241,113,145, 17, 51, 35, 98,198,132, 12, 24, 48, 96,192,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 30,225,  0,  0,  1,  1,  2,  2,129,128,128,  0,  0,128,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,  0, 48, 48,  0,  0,  1,  1,  2,  4,  8, 16, 32, 67,135,  7,  1,  0,184,188,190,159, 95, 95, 79, 76, 32, 32, 32, 32, 16, 16, 16, 16,  8,  8,  8,  8,  8,196,  4,196,  4,196,  2,194,  2,194,  1,  1,  1,  1,  0,  0,  0,
+        0,  0,252, 15,  1,  0,248, 14, 31,109,140,148,148,164,166,249,224,255,224,249,166,164,148,148,140,109, 31, 14,248,  0,  1, 15,252,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,112, 12,  3,  0,  0, 24,  6,  5,152,153,132, 67,124, 65, 65, 64, 64, 32, 33, 34, 18, 17, 17, 17,  9,  8,  8,  8,  8,  4,  4,  8,  8, 16, 16, 16, 16, 16, 17, 15,  1, 61,124,252,252,252,252,252, 60, 12,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,170,170,255,255,195,191,127,  3,127,191,195,255,255,170,170,  0,  0,  0,  0,
+        0,  0, 31,120,192,  0, 15, 56,124,219,152, 20, 20, 18, 50,207,  3,255,  3,207, 50, 18, 20, 20,152,219,124, 56, 15,  0,192,120, 63, 16, 16, 16, 16,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  2,  3,  2,  2,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  3,  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2,130,135, 31,  7,159,  7, 28,  7,159,  7,159,  7,  2,130,  0,  0,  0,  0,
+        32, 16, 16, 16, 17, 11, 14, 12, 24, 16, 49, 35, 98,102, 68, 68, 71, 71, 71, 68, 68,102, 98, 35, 49, 16, 24, 12,  6,  3,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  7,  8,  8, 23,  0, 15,  1,  2,  1, 15,  0, 15,  2,  5,  8
+        },
+        {
+        0,  0,126,126, 24, 60,102, 66,  0, 12, 28,112,112, 28, 12,  0,116,116, 20, 20,124,104,  0,124,124,  0,112,120, 44, 36,124,124,0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,  0,  0,  0,  0,  0,128, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  4,  2,  1,  1,  2, 12, 48, 64,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,128,128,
+        0,  0,  0,  0,192, 96, 48, 24, 12,132,198, 98, 35, 51, 17,145,113,241,113,145, 17, 51, 35, 98,198,132, 12, 24, 48, 96,192,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 30,225,  0,  0,  1,  1,  2,  2,  1,  0,  0,  0,  0,128,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,  0, 48, 48,  0,  0,  1,225, 26,  6,  9, 49, 53,  1,138,124,  0,  0,128,128,128,128, 64, 64, 64, 64, 32, 32, 32, 32, 16, 16, 16, 16,  8,  8,  8,  8,  8,196,  4,196,  4,196,  2,194,  2,194,  1,  1,  1,  1,  0,  0,  0,
+        0,  0,252, 15,  1,  0,248, 14, 31,109,140,148,148,164,166,249,224,255,224,249,166,164,148,148,140,109, 31, 14,248,  0,  1, 15,252,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,128,112, 12,  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  0, 64,160, 33, 34, 18, 17, 17, 17,  9,  8,  8,  8,  8,  4,  4,  4,  4,  4,  4,  2,  2,  2,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,170,170,255,255,195,191,127,  3,127,191,195,255,255,170,170,  0,  0,  0,  0,
+        0,  0, 31,120,192,  0, 15, 56,124,219,152, 20, 20, 18, 50,207,  3,255,  3,207, 50, 18, 20, 20,152,219,124, 56, 15,  0,192,120, 31, 16, 16, 16, 16,  8,  8,  8,  8,  8,  4,  4,  4,  4,  4,  2,  3,122,122,121,121,121,121, 57, 49,  2,  2,  4,  4,  8,  8,  8,136,136,135,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2,130,135, 31,  7,159,  7, 28,  7,159,  7,159,  7,  2,130,  0,  0,  0,  0,
+        32, 16, 16, 16, 17, 11, 14, 12, 24, 16, 49, 35, 98,102, 68, 68, 71, 71, 71, 68, 68,102, 98, 35, 49, 16, 24, 12,  6,  3,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 48,120,124,254,255, 63,  7,  0,  0,  0,  0,255,255,127,127, 63, 62, 28, 24,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  7,  8,  8, 23,  0, 15,  1,  2,  1, 15,  0, 15,  2,  5,  8
+        },
+    };
+
+    //assumes 1 frame prep stage
+    void animation_phase(void) {
+        if(get_current_wpm() <=IDLE_SPEED){
+            current_idle_frame = (current_idle_frame + 1) % IDLE_FRAMES;
+            oled_write_raw_P(idle[abs((IDLE_FRAMES-1)-current_idle_frame)], ANIM_SIZE);
+         }
+         if(get_current_wpm() >IDLE_SPEED && get_current_wpm() <TAP_SPEED){
+             // oled_write_raw_P(prep[abs((PREP_FRAMES-1)-current_prep_frame)], ANIM_SIZE); // uncomment if IDLE_FRAMES >1
+             oled_write_raw_P(prep[0], ANIM_SIZE);  // remove if IDLE_FRAMES >1
+         }
+         if(get_current_wpm() >=TAP_SPEED){
+             current_tap_frame = (current_tap_frame + 1) % TAP_FRAMES;
+             oled_write_raw_P(tap[abs((TAP_FRAMES-1)-current_tap_frame)], ANIM_SIZE);
+         }
+    }
+    if(get_current_wpm() != 000) {
+        oled_on(); // not essential but turns on animation OLED with any alpha keypress
+        if(timer_elapsed32(anim_timer) > ANIM_FRAME_DURATION) {
+            anim_timer = timer_read32();
+            animation_phase();
+        }
+        anim_sleep = timer_read32();
+    } else {
+        if(timer_elapsed32(anim_sleep) > OLED_TIMEOUT) {
+            oled_off();
+        } else {
+            if(timer_elapsed32(anim_timer) > ANIM_FRAME_DURATION) {
+                anim_timer = timer_read32();
+                animation_phase();
+            }
+        }
+    }
+}
+
+
+#endif
+
+static void render_status(void) {
+    uint8_t modifiers = get_mods();
+    uint8_t led_usb_state = host_keyboard_leds();
+
+    oled_set_cursor(0, 7);
+    oled_write_P((modifiers & MOD_MASK_ALT) ? PSTR("ALT ") : PSTR("    "), false);
+    oled_write_P((modifiers & MOD_MASK_SHIFT) ? PSTR("SHIFT ") : PSTR("      "), false);
+    oled_write_P((modifiers & MOD_MASK_GUI) ? PSTR("CMD ") : PSTR("    "), false);
+    oled_write_P((modifiers & MOD_MASK_CTRL) ? PSTR("CTRL") : PSTR("    "), false);
+
+    oled_set_cursor(0, 5);
+    oled_write_P(IS_LED_ON(led_usb_state, USB_LED_NUM_LOCK) ? PSTR("NUM ") : PSTR("    "), false);
+    oled_write_P(IS_LED_ON(led_usb_state, USB_LED_CAPS_LOCK) ? PSTR("CAPS") : PSTR("    "), false);
+
+    oled_set_cursor(0, 0);
+    // Host Keyboard Layer Status
+  switch (get_highest_layer(layer_state)) {
+    case L_ASERT:
+        oled_write_P(PSTR("ASERT"), false);
+        break;
+    case L_PUNCT:
+        oled_write_P(PSTR("@()#&"), false);
+        break;
+    case L_FN:
+        oled_write_P(PSTR("fn   "), false);
+        break;
+    case L_MEDIA_NAV:
+        oled_write_P(PSTR("Media"), false);
+        break;
+    case L_SYM_NUM:
+        oled_write_P(PSTR("Symbl"), false);
+        break;
+    default: //  for any other layers, or the default layer
+        oled_write_P(PSTR("     "), false);
+  }
+
+    //Host Keyboard LED Status
+    led_t led_state = host_keyboard_led_state();
+    oled_write_P(led_state.num_lock ? PSTR("NUM ") : PSTR("       "), false);
+    oled_write_P(led_state.caps_lock ? PSTR("CAPS ") : PSTR("       "), false);
+    oled_write_P(led_state.scroll_lock ? PSTR("SCRL") : PSTR("       "), false);
+}
+
diff --git a/moutis_ENCODER.c b/moutis_ENCODER.c
index 2853201..0031bd4 100644
--- a/moutis_ENCODER.c
+++ b/moutis_ENCODER.c
@@ -77,13 +77,21 @@ bool encoder_update_user(uint8_t index, bool clockwise) {
               break;
     #endif
           default:
-              if (clockwise) {
+                if (clockwise) {
+                    tap_code(KC_VOLU); // media vol up
+                } else {
+                    tap_code(KC_VOLD); // media vol dn
+                }
+/*
+            if (clockwise) {
                   tap_code(KC_RIGHT); // fwd
               } else {
                   tap_code(KC_LEFT); // back
               }
               break;
-      }
+*/
+                
+        }
   } else  {  // Second (right) encoder
       switch(get_highest_layer(layer_state)){
           case L_PUNCT: // puncuation layer
diff --git a/moutis_app_menu.c b/moutis_app_menu.c
new file mode 100644
index 0000000..69648f5
--- /dev/null
+++ b/moutis_app_menu.c
@@ -0,0 +1,69 @@
+//
+// called early within process_record_user
+// process_APP_MENU handles taps to turn on APP_MENU and cycle.
+//
+// called early within scan_matrix_user
+// matrix_APP_MENU checks/disables the timer.
+//
+// uses globals:
+// uint32_t state_reset_timer = 0; // timer used for app_menu, adaptives, lingers
+// uint8_t  saved_mods = 0; //
+// bool appmenu_on = false;  // state of windows-like app switcher
+// bool mods_held = false;  // nood to remember how we entered the appmenu state
+//
+
+void process_APP_MENU(keyrecord_t *record) {
+// KC_APP key gets special treatment
+  if (record->event.pressed) {
+    if (saved_mods & (MOD_MASK_CTRL)) {
+      unregister_code(KC_RALT);  // ignore these if ctrl
+      unregister_code(KC_RGUI);
+      tap_code(KC_TAB);  // switch window w/in app (need semkey for this.)
+      return; // handled this record.
+    }
+    mods_held = (saved_mods & (MOD_MASK_GUI | MOD_MASK_ALT)); // were mods held?
+    if (!mods_held) { // gui/alt not down, supply them
+      if (user_config.OSIndex) {  // Can't SemKey this bc hold mods & timer...
+        register_code(KC_RALT); // Windows
+      } else {
+        register_code(KC_RGUI); // Mac
+      }
+    }
+    tap_code(KC_TAB); // switch app
+    state_reset_timer = timer_read(); // (re)start timing hold for keyup below
+    return; // handled this record.
+  }
+  // up event
+  if (mods_held || appmenu_on) // mods down, or already on…
+    return; // so nothing to do here (scan_matrix_user will handle it)
+  if (timer_elapsed(state_reset_timer) > LINGER_TIME) { // held long enough?
+    appmenu_on = true; // Y:turn on menu (taken down in matrix_scan_user)
+    state_reset_timer = timer_read(); // start timer
+  } else { // N: just a quick tap for app switch.
+    if (user_config.OSIndex) { // let mod keys up now
+      unregister_code(KC_RALT); // Win
+    } else {
+      unregister_code(KC_RGUI); // Mac
+    }
+    state_reset_timer = 0;  // stop the timer
+  }
+  return; // handled this record.
+}
+
+
+//
+// somewhere in matrix_scan_user (early?)
+//
+void matrix_APP_MENU(void) {
+    if (appmenu_on) { // App menu up, (no mods) check if it needs to be cleared
+        if (timer_elapsed(state_reset_timer) > STATE_RESET_TIME) {// menu up time elapsed?
+            if (user_config.OSIndex) { // Y. stop the menu by lifting the mods
+                unregister_code(KC_RALT); // Win
+            } else {
+                unregister_code(KC_RGUI); // Mac
+            }
+            state_reset_timer = mods_held = 0;  // stop the timer
+            appmenu_on = false;
+        }
+    }
+}
diff --git a/moutis_combo.c b/moutis_combo.c
new file mode 100644
index 0000000..2ba53a7
--- /dev/null
+++ b/moutis_combo.c
@@ -0,0 +1,919 @@
+/*
+ Combos
+
+ Tailored for Hands Down Neu related variations
+ Others have been removed, but I'll try to get everything in here soon enough.
+ Finally getting to the last of imagined features that spurred Hands Down design!
+  
+ */
+
+uint16_t COMBO_LEN = COMBO_LENGTH;
+
+void process_combo_event(uint16_t combo_index, bool pressed) {
+
+#ifdef OLED_DRIVER_ENABLE
+    oled_set_cursor(0, combo_OLED_row);
+#endif
+    if (pressed) {
+#ifdef OLED_DRIVER_ENABLE
+        oled_write_P(PSTR("Combo: "), false);
+#endif
+#ifdef JP_MODE_ENABLE
+        // Don't process these
+        if (IS_ENGLISH_MODE
+#ifdef JP_YOUON_COMBOS
+            && (combo_index >= jp_kya)
+#ifdef JP_YOUON_COMBOS_ALL
+            && (combo_index <= jp_ryo)
+#else
+            && (combo_index <= jp_pyo)
+#endif  // JP_YOUON_COMBOS_ALL
+#endif  // JP_YOUON_COMBOS
+            )
+            return;
+#endif // JP_MODE_ENABLE
+        switch(combo_index) {
+            case PC_STAB ... COMBO_LENGTH:// these may have a hold delay BEFORE triggering
+            case HC_AT ... HC_COLN: //
+                combo_on = combo_index; // queue for matrix_scan_user_process_combo
+                break;
+
+                
+//            case HC_CAPG: // turn on capsword for Gold
+            case HC_CAPW: // turn on capsword (automatically turns off on delimiter)
+                toggle_caps_word();
+                break;
+
+            case HC_Q: //
+                if (saved_mods & (MOD_MASK_ALT | MOD_MASK_GUI)) // interested?
+                    break;
+                tap_code16(KC_Q); //
+                unregister_mods(MOD_MASK_SHIFT);  //
+                tap_code16(KC_U); //
+                combo_on = combo_index; // if held, delete the 'u' in matrix_scan_user_process_combo
+                break;
+                
+/*
+ * H digraphs here
+ */
+            case HC_Th: // on first press
+                tap_code(KC_T); // send "T" honoring caps
+                combo_on = combo_index; // if held, check in matrix_scan_user_process_combo
+                break;
+            case HC_Sh:
+                tap_code(KC_S); // send "T" honoring caps
+                combo_on = combo_index; // if held, check in matrix_scan_user_process_combo
+                break;
+           case HC_Wh:
+                tap_code(KC_W); // send "W" honoring caps
+#ifdef JP_MODE_ENABLE
+                if (!IS_ENGLISH_MODE) { // not in English mode?
+                    tap_code(KC_O); // send "o" for を (this is more common/convenient?)
+                    break;
+                }
+#endif
+                combo_on = combo_index; // if held, check in matrix_scan_user_process_combo
+                break;
+/* this conflicts with home row tab, so using adaptive CS -> SC
+            case HC_Sc: // to avoid outward roll on ring->pinky fingers moving in unison is easier
+                tap_code(KC_S); // send "S"
+                unregister_mods(MOD_MASK_SHIFT);  //
+                tap_code(KC_C); // send "C"
+                combo_on = combo_index; // if held, addd 'h' for "Sch" in matrix_scan_user_process_combo
+                break;
+*/
+            case HC_Sch: // to avoid outward roll on ring->pinky fingers moving in unison is easier
+                tap_code(KC_S); // send "S"
+                unregister_mods(MOD_MASK_SHIFT);  //
+            case HC_Ch: // not held
+                tap_code(KC_C); // send "C" honoring caps
+                combo_on = combo_index; // if held, check in matrix_scan_user_process_combo
+                break;
+            case HC_Gh: // not held
+                tap_code(KC_G); // send "G" honoring caps
+                combo_on = combo_index; // if held, check in matrix_scan_user_process_combo
+                break;
+            case HC_Ph:
+                tap_code(KC_P); // send "P" honoring caps
+                combo_on = combo_index; // if held, check in matrix_scan_user_process_combo
+                break;
+
+
+            case HC_ACUT:
+                tap_code16(A(KC_E)); // this should use semkeys
+                combo_on = combo_index; // may add "e" in matrix_scan_user_process_combo
+                break;
+            case HC_GRV:
+//                tap_code16(A(KC_NUBS)); // this should use semkeys
+                tap_code16(A(KC_GRAVE)); // this should use semkeys
+                combo_on = combo_index; // may add "e" in matrix_scan_user_process_combo
+                break;
+            case HC_CIRC:
+                 tap_code16(A(KC_6)); // this should use semkeys
+                combo_on = combo_index; // may add "e" in matrix_scan_user_process_combo
+                break;
+            case HC_MACR:
+                tap_code16(A(KC_A)); // this should use semkeys
+                combo_on = combo_index; // may add "o" in matrix_scan_user_process_combo
+                break;
+            case HC_DIER:
+                tap_code16(A(KC_U)); // this should use semkeys
+                combo_on = combo_index; // may add "u" in matrix_scan_user_process_combo
+                break;
+            case HC_RING:
+#ifdef JP_MODE_ENABLE
+                if (!IS_ENGLISH_MODE) {// in Japanese mode?
+                    send_string("hya");// Y: so ひゃ
+                    break;
+                }
+#endif // JP_MODE_ENABLE
+                tap_code16(A(KC_K)); // this should use semkeys
+                combo_on = combo_index; // may add "a" for å in matrix_scan_user_process_combo
+                break;
+            case HC_CEDILLE:
+                tap_code16(A(KC_C)); // this should use semkeys
+                combo_on = combo_index; // may add "c" in matrix_scan_user_process_combo
+                break;
+            case HC_ENYE:
+                tap_code16(A(KC_N)); // this should use semkeys
+                combo_on = combo_index; // may add "n" in matrix_scan_user_process_combo
+                break;
+            case HC_AE: // Æ
+                tap_code16(A(KC_QUOT)); // this should use semkeys
+                break;
+            case HC_OE: // Œ
+                tap_code16(A(KC_Q)); // this should use semkeys
+                tap_code16(KC_U); // almost always "œu"
+                combo_on = combo_index; // but like qu, we'll take it back if we must.
+                break;
+/*
+            case HC_1E: // É
+                tap_code16(A(KC_E)); // this should use semkeys
+                tap_code16(KC_E); //
+                break;
+            case HC_2E: // È
+                tap_code16(A(KC_GRAVE)); // this should use semkeys
+                tap_code16(KC_E); //
+                break;
+            case HC_3E: // Ê
+                tap_code16(A(KC_6)); // this should use semkeys
+                tap_code16(KC_E); //
+                break;
+            case HC_4E: // Ë
+                tap_code16(A(KC_U)); // this should use semkeys
+                tap_code16(KC_E); //
+                break;
+            case HC_5E: // Ē
+                tap_code16(A(KC_A)); // this should use semkeys
+                tap_code16(KC_E); //
+                break;
+            case HC_6E: // E̊
+                tap_code16(A(KC_K)); // this should use semkeys
+                tap_code16(KC_E); //
+                break;
+*/
+/*
+            case HC_OSLSH:
+                tap_code16(A(KC_O)); // this should use semkeys
+                break;
+*/
+            case HC_NDSH:
+                register_code16(A(KC_MINS));  // should be a semkey
+                break;
+            case HC_MDSH:
+                 register_code16(A(S(KC_MINS))); // should be a semkey
+                break;
+            case HC_UNDS:
+#ifdef JP_MODE_ENABLE
+#ifdef JP_YOUON_COMBOS_ALL
+                // case jp_byu:  // びゅ
+               if (!IS_ENGLISH_MODE) // in Japanese mode?
+                   send_string("byu");  // Y: so びゅ
+                else
+#endif // JP_YOUON_COMBOS_ALL
+#endif // JP_MODE_ENABLE
+                    tap_code16(S(KC_MINS)); // _ underscore (semkey this?)
+                break;
+
+#ifdef EN_PRONOUN_COMBOS // the entirely unnecessary pronoun combo shenanigans
+
+            case HC_I:
+#ifdef JP_MODE_ENABLE
+                if (!IS_ENGLISH_MODE) { // if in Japanese mode
+                    send_string("watasi");  //
+                    break;
+                }
+#endif // JP_MODE_ENABLE
+                tap_code16(S(KC_I));
+                unregister_mods(MOD_MASK_SHIFT);  //
+                combo_on = combo_index; // may add "'ve " if held
+                break;
+            case HC_Id:
+            case HC_Ill:
+            case HC_Im:
+            case HC_Iv:
+#ifdef JP_MODE_ENABLE
+                if (!IS_ENGLISH_MODE) { // if in Japanese mode
+                    send_string("watasiga");  //
+                    break;
+                }
+#endif // JP_MODE_ENABLE
+                tap_code16(S(KC_I)); // send "I" CAPITALIZED
+                unregister_mods(MOD_MASK_SHIFT);  //
+                goto addonsuffix;
+
+#ifdef EN_PRONOUN_COMBOS_ALL
+
+// This group all share a suffix, with a goto addonsuffix,
+// so keep together 'cause we're messing with stack frames at the end!
+
+            case HC_they_4gram: // "they"
+//            case HC_theyg_4gram: // "they"
+                tap_code(KC_T); // send "Y" honoring caps
+                unregister_mods(MOD_MASK_SHIFT);  //
+                send_string("hey"); // send "they" right away
+                combo_on = combo_index; // may add "'ve " in matrix_scan_user_process_combo
+                break;
+            case HC_your_4gram:
+                tap_code(KC_Y);
+                unregister_mods(MOD_MASK_SHIFT);  //
+                send_string("our");
+                combo_on = combo_index; // may add "'s " in matrix_scan_user_process_combo
+                break;
+#ifdef EN_W_PRONOUNS
+            case HC_wed_4gram:
+            case HC_well_5gram:
+            case HC_were_5gram:
+            case HC_weve_5gram:
+                tap_code(KC_W); // send "W" honoring caps
+                unregister_mods(MOD_MASK_SHIFT);  //
+                send_string("e"); // send "We" right away
+                goto addonsuffix;
+#endif // EN_W_PRONOUNS
+            case HC_youd_5gram:
+            case HC_youll_6gram:
+            case HC_youre_6gram:
+            case HC_youve_6gram:
+                tap_code(KC_Y); // send "Y" honoring caps
+                unregister_mods(MOD_MASK_SHIFT);  //
+                send_string("ou"); // send "We're" right away
+                goto addonsuffix;
+            case HC_theyd_6gram: // TYPE "they'd " #23
+            case HC_theyll_7gram:
+            case HC_theyre_7gram:
+            case HC_theyve_7gram: // "they've"
+                tap_code(KC_T); // send "Y" honoring caps
+                unregister_mods(MOD_MASK_SHIFT);  //
+                send_string("hey"); // send "they" right away
+
+#endif // #ifdef EN_PRONOUN_COMBOS_ALL
+
+addonsuffix: // sharing this saves about 100 bytes (10 bytes per instance)
+                tap_code(KC_QUOT);
+                switch (combo_index) { //
+                    case HC_Im:
+                        SEND_STRING("m ");
+                        break;
+#ifdef EN_PRONOUN_COMBOS_ALL
+#ifdef EN_W_PRONOUNS
+                    case HC_wed_4gram: // we'd
+#endif // EN_W_PRONOUNS
+                    case HC_youd_5gram:
+//                    case HC_youdg_5gram:
+                    case HC_theyd_6gram: // TYPE "they'd " #23
+//                    case HC_theydg_6gram: // TYPE "they'd " #23
+#endif // #ifdef EN_PRONOUN_COMBOS_ALL
+                    case HC_Id: // "I'd " …
+                        send_string("d");
+                        combo_on = combo_index; // may add "'ve " in matrix_scan_user_process_combo
+                        break;
+#ifdef EN_PRONOUN_COMBOS_ALL
+#ifdef EN_W_PRONOUNS
+                    case HC_well_5gram: // we'll
+#endif // EN_W_PRONOUNS
+                    case HC_youll_6gram:
+                    case HC_theyll_7gram: // TYPE "they'll " #23
+//                    case HC_theyllg_7gram: // TYPE "they'll " #23
+#endif //#ifdef EN_PRONOUN_COMBOS_ALL
+                    case HC_Ill: // "I'll "
+                        send_string("ll");
+                        combo_on = combo_index; // may add "'ve " in matrix_scan_user_process_combo
+                        break;
+#ifdef EN_PRONOUN_COMBOS_ALL
+#ifdef EN_W_PRONOUNS
+                    case HC_were_5gram: // we're
+#endif // EN_W_PRONOUNS
+                    case HC_youre_6gram:
+                    case HC_theyre_7gram: // "they're"
+                        send_string("re ");
+                        break;
+#ifdef EN_W_PRONOUNS
+                    case HC_weve_5gram: // we've
+#endif // EN_W_PRONOUNS
+                    case HC_youve_6gram:
+                    case HC_theyve_7gram: // "they've"
+//                    case HC_theyveg_7gram: // "they've"
+#endif // #ifdef EN_PRONOUN_COMBOS_ALL
+                    case HC_Iv: // "I've " …
+                        send_string("ve ");
+                        break;
+                }
+                break;
+// END of the common Pronoun suffix group with the goto addonsuffix:
+
+#ifdef EN_PRONOUN_COMBOS_ALL
+            case HC_their_5gram: // TYPE "their" #6
+                tap_code(KC_T);
+                unregister_mods(MOD_MASK_SHIFT);  //
+                send_string("heir");
+                combo_on = combo_index; // may add "'s " if held
+                break;
+
+            case HC_here_4gram: // TYPE "here" #9
+                tap_code(KC_H);
+                unregister_mods(MOD_MASK_SHIFT);  //
+                send_string("ere");
+                combo_on = combo_index; // may add "'s " if held
+                break;
+#ifdef EN_W_PRONOUNS
+            case HC_where_5gram: // TYPE "where" // this should be a linger add text?
+                tap_code(KC_W);
+                goto ADD_HERE;
+#endif // EN_W_PRONOUNS
+            case HC_there_5gram: // TYPE "there" #7
+                tap_code(KC_T);
+#ifdef EN_W_PRONOUNS
+ADD_HERE:
+#endif // EN_W_PRONOUNS
+                unregister_mods(MOD_MASK_SHIFT);  //
+                send_string("here");
+                combo_on = combo_index; // may add "'ve " if held
+                break;
+
+#endif // EN_PRONOUN_COMBOS_ALL
+#endif // EN_PRONOUN_COMBOS
+                
+#ifdef JP_MODE_ENABLE
+        // Don't process these
+#ifdef JP_YOUON_COMBOS
+            case jp_kya:  // きゃ:
+                send_string("kya");  //
+                break;
+            case jp_kyu:  // きゅ
+                send_string("kyu");  //
+                break;
+            case jp_kyo:  // きょ
+                send_string("kyo");  //
+                break;
+            case jp_sya:  // しゃ
+                send_string("sya");  //
+                break;
+            case jp_syu:  // しゅ
+                send_string("syu");  //
+                break;
+            case jp_sye:  // しぇ
+                send_string("sye");  //
+                break;
+            case jp_syo:  // しょ
+                send_string("syo");  //
+                break;
+            case jp_zya:  // じゃ
+                send_string("zya");  //
+                break;
+            case jp_zyu:  // じょ
+                send_string("zyu");  //
+                break;
+            case jp_zyo:  // じょ
+                send_string("zyo");  //
+                break;
+            case jp_tya:  // ちゃ
+                send_string("tya");  //
+                break;
+            case jp_tyu:  // ちゅ
+                send_string("tyu");  //
+                break;
+            case jp_tye:  // ちぇ
+                send_string("tye");  //
+                break;
+            case jp_tyo:  // ちょ
+                send_string("tyo");  //
+                break;
+            case jp_pya:  // ぴゃ:
+                send_string("pya");  //
+                break;
+            case jp_pyu:  // ぴゅ
+                send_string("pyu");  //
+                break;
+            case jp_pyo:  // ぴょ
+                send_string("pyo");  //
+                break;
+
+#ifdef JP_YOUON_COMBOS_ALL // JP_YOUON_COMBOS_ALL
+/* Unnecessary?
+            case ch:  // アー
+                send_string("a-");  //
+                break;
+            case jp_ii:  //　イー
+                send_string("i-");  //
+                break;
+            case jp_uu:  //　ウー
+                send_string("u-");  //
+                break;
+            case jp_ee:  //　エー
+                send_string("e-");  //
+                break;
+            case jp_oo:  //　オー
+                send_string("o-");  //
+                break;
+            case jp_nn:  //　ン
+                send_string("nn");  //
+                break;
+*/
+
+            case jp_gya:  // ぎゃ:
+                send_string("gya");  //
+                break;
+            case jp_gyu:  // ぎゅ
+                send_string("gyu");  //
+                break;
+            case jp_gyo:  // ぎょ
+                send_string("gyo");  //
+                break;
+            case jp_tha:  // てゃ
+                send_string("tha");  //
+                break;
+            case jp_thi:  // てぃ
+                send_string("thi");  //
+                break;
+            case jp_thu:  // てゅ
+                send_string("thu");  //
+                break;
+            case jp_the:  // てぇ
+                send_string("the");  //
+                break;
+            case jp_tho:  // てょ
+                send_string("tho");  //
+                break;
+            case jp_dha:  // でゃ
+                send_string("dha");  //
+                break;
+            case jp_dhi:  // でぃ
+                send_string("dhi");  //
+                break;
+            case jp_dhu:  // でょ
+                send_string("dhu");  //
+                break;
+            case jp_dhe:  // でぇ
+                send_string("dhe");  //
+                break;
+            case jp_dho:  // でょ
+                send_string("dho");  //
+                break;
+            case jp_nya:  // にゃ
+                send_string("nya");  //
+                break;
+            case jp_nyu:  // にょ
+                send_string("nyu");  //
+                break;
+            case jp_nyo:  // ひゅ
+                send_string("nyo");  //
+                break;
+/*
+            case jp_hya:  // ひゃ
+                send_string("hyu");  // handled with diacritic
+                break;
+*/
+            case jp_hyu:  // ひゅ
+                send_string("hyu");  //
+                break;
+            case jp_hyo:  // ひょ
+                send_string("hyo");  //
+                break;
+            case jp_bya:  // びゃ:
+                send_string("bya");  //
+                break;
+            case jp_byu:  // びゅ
+                send_string("byu");  // conflicts, handled in the main section
+                break;
+            case jp_byo:  // びょ
+                send_string("byo");  //
+                break;
+            case jp_mya:  // みゃ:
+                send_string("mya");  //
+                break;
+            case jp_myu:  // みゅ
+                send_string("myu");  //
+                break;
+            case jp_myo:  // みょ
+                send_string("myo");  //
+                break;
+            case jp_rya:  // りゃ:
+                send_string("rya");  //
+                break;
+            case jp_ryu:  // りゅ
+                send_string("ryu");  //
+                break;
+            case jp_ryo:  // りょ
+                send_string("ryo");  //
+                break;
+#endif // JP_YOUON_COMBOS_ALL
+#endif // JP_YOUON_COMBOS
+#endif // JP_MODE_ENABLE
+                
+                
+                
+        } // end switch (combo_index)
+        if (combo_on) linger_timer = timer_read(); // start timing for linger process
+        // should GUARD this with return instead
+    } else { // end if (pressed) so this is the key up switch, hold threshold not met.
+#ifdef OLED_DRIVER_ENABLE
+        oled_set_cursor(0,combo_OLED_row);
+        oled_write_P(PSTR("                     "), false);
+#endif
+/*
+ This is the key up event
+*/
+        // make this smarter/smaller/faster.
+        // lookup keys to output from the key_combos[key_combos] table, bypassing this switch?
+        // wrapup the combo and send the underlying keys if necessary
+        //
+        if (combo_on && !combo_triggered) { // combo NOT triggered in matrix_scan_user_process_combo
+#ifdef OLED_DRIVER_ENABLE
+    oled_set_cursor(oled_max_chars() - 5, combo_OLED_row);
+    oled_write_P(PSTR("abort"), true);
+#endif
+            switch(combo_index) {
+// the H digraphs
+
+                case HC_Sch: // to avoid outward roll on ring->pinky fingers moving in unison is easier
+                case HC_Ch:
+                case HC_Th:
+                case HC_Sh:
+                case HC_Wh:
+                case HC_Gh:
+                case HC_Ph:
+                    unregister_mods(MOD_MASK_SHIFT);  //
+                    tap_code(KC_H); // send "h" honoring CAPSLK state
+                    break;
+
+// END the H digraphs
+
+                case HC_FIND:  // Find next of selection. Should work with many editors/platforms, but not all...obviously.
+                    tap_SemKey(SK_COPY);
+                    tap_SemKey(SK_FIND);
+                    tap_SemKey(SK_PSTE);
+                    tap_SemKey(KC_ENT); // register current find
+                    tap_SemKey(SK_FAGN); // find next
+                    break;
+                case HC_NEW:
+                    tap_SemKey(SK_NEW);
+                    break;
+                case HC_COPY: // not held, so simple copy
+                    tap_SemKey(SK_COPY);
+                    break;
+                case HC_PSTE: // not held, so simple paste
+                    tap_SemKey(SK_PSTE);
+                    break;
+    
+                case HC_AT:
+                    tap_code16(KC_AT); //
+                    break;
+                case HC_COLN:
+                    tap_code16(KC_COLN); //
+                    break;
+
+                case PC_DASH:
+                    tap_code(KC_P1);
+                    tap_code(KC_P2);
+                    break;
+                case PC_TILD:
+                    tap_code(KC_P1);
+                    tap_code(KC_P3);
+                    break;
+                case PC_ELIP:
+                    tap_code(KC_P2);
+                    tap_code(KC_P3);
+                    break;
+                case PC_LPRN:
+                    tap_code(KC_P4);
+                    tap_code(KC_P5);
+                    break;
+                case PC_RPRN:
+                    tap_code(KC_P5);
+                    tap_code(KC_P6);
+                    break;
+                case PC_COLN:
+                    tap_code(KC_P4);
+                    tap_code(KC_P6);
+                    break;
+                case PC_PERC:
+                    tap_code(KC_P6);
+                    tap_code(KC_PPLS);
+                    break;
+                case PC_JYEN:
+                    tap_code(KC_SLSH);
+                    tap_code(KC_7);
+                    break;
+                case PC_DOLR:
+                    tap_code(KC_7);
+                    tap_code(KC_8);
+                    break;
+                case PC_CENT:
+                    tap_code(KC_7);
+                    tap_code(KC_9);
+                    break;
+                case PC_EURO:
+                    tap_code(KC_8);
+                    tap_code(KC_9);
+                    break;
+                                        
+                case HC_TYPE_LEFTCOMBO:
+#ifdef JP_MODE_ENABLE
+                    if (IS_ENGLISH_MODE) {
+#endif
+                        send_string(LeftComboTapE); //
+#ifdef JP_MODE_ENABLE
+                    } else {
+                        send_string(LeftComboTapJ); //
+                    }
+#endif
+                    break;
+                case HC_TYPE_RIGHTCOMBO:
+#ifdef JP_MODE_ENABLE
+                    if (IS_ENGLISH_MODE) {
+#endif
+                        send_string(RightComboTapE); // send "Japan" right away
+#ifdef JP_MODE_ENABLE
+                    } else {
+                        send_string(RightComboTapJ); // send "Japan" right away
+                    }
+#endif
+                    break;
+
+#ifdef EN_PRONOUN_COMBOS
+                case HC_I ... HC_Iv:
+#ifdef EN_PRONOUN_COMBOS_ALL
+                case HC_wed_4gram ... HC_their_5gram:
+#endif
+#endif
+                    tap_code(KC_SPC); // add space after a composed pronoun
+                    combo_on = 0;  // done w/these shenanigans
+                    break;
+                case HC_Q: //
+                    unregister_code16(KC_Q); //
+                    linger_key = 0;
+                    break;
+                case HC_EQL: //
+                    tap_code16(KC_EQL); // Not held, so…
+                    linger_key = 0;
+                    break;
+
+            }  // end switch(combo_index) {
+        } else {
+        // Key up, threshold met, so we'll WRAP-UP the combo action if neccessary.
+        // unregister_code for repeating keys, etc. that weren't handled in matrix_scan_user
+            switch(combo_index) {
+                case HC_NDSH:
+                    unregister_code16(A(KC_MINS));  // this should use semkeys
+                    break;
+                case HC_MDSH:
+                    unregister_code16(A(S(KC_MINS)));  // this should use semkeys
+                    break;
+
+            }  // end switch(combo_index) {
+        } // else if (threshold met)
+        combo_on = combo_triggered = false;
+    } // ELSE IF (pressed) meaning keyup
+#ifdef OLED_DRIVER_ENABLE
+//    oled_render();
+#endif
+    return;
+}
+
+void matrix_scan_user_process_combo() {  // called from matrix_scan_user if combo_on
+
+    // These combos are to be held for COMBO_HOLD term before triggering
+    // to avoid accidental triggers while fast typing these common rolls (or on home row).
+    // If repeats aren't deemed necessary, use tap_code here, otherwise register_code here
+    // and add unregister_code to the !pressed switch in process_combo_event above.
+    // Checking combo_triggered above can enable sending untriggered keys
+    // and thus allow for longer COMBO_TERM. (recommend < TAPPING_TERM / 2)
+    // still, really fast rolls, esp if they can go both ways, are going to be
+    // a problem for this (ex er, re; io oi), so maybe best to avoid them as
+    // combos. On Hands Down, this means no combos on home row, but that's fine,
+    // because home already has modifiers, so it all works out.
+    //
+    // I've since successfully added COMBO_HOLD Home Row combos without difficulty.
+    // To use multiple home row mods, just put them down one at a time...works great.
+    //
+    if (!combo_triggered) {
+        // do simple "on" on held actions and then turn on combo state in process_combo_event above,
+        // then handle hold actions here,
+        // before resolving in keyup event above.
+        // if necessary (like releasing the underlying keys, or other cleanup)
+        if ((timer_elapsed(linger_timer) > COMBO_HOLD) && combo_on && user_config.AdaptiveKeys) {
+            saved_mods = get_mods();
+            clear_mods();
+            switch(combo_on) {  // combo_on is global, set in process_combo above
+
+                case HC_FIND: // Held, so find selection (should work with most apps/platforms)
+                    tap_SemKey(SK_COPY); // copy the selection
+                    tap_SemKey(SK_FIND); // start find
+                    tap_SemKey(SK_PSTE); // paste the copy. will find the selection
+                    tap_SemKey(SK_FAGN); // now find the next...
+                    break;
+                case HC_COPY: // held, so cut
+                    tap_SemKey(SK_CUT);
+                    break;
+                case HC_PSTE: // held, so pastematch
+                    tap_SemKey(SK_PSTM);
+                    break;
+
+                    
+                case HC_Sh:
+                case HC_Th: // if this H digragh combo is held, then send T/Sion instead
+                    unregister_mods(MOD_MASK_SHIFT);  //
+                    send_string("ion");
+                    break;
+                case HC_Gh: // held, send "ght"
+                    unregister_mods(MOD_MASK_SHIFT);  //
+                    tap_code(KC_H); // send "h"
+                    tap_code(KC_T); // add "t" ("ght" is 55% of all "gh" occurrences)
+                    break;
+                case HC_Sch: //
+                    tap_code(KC_H); // send "h"
+                    tap_code(KC_O); // add "o" // o is the most common after sch
+                    break;
+                case HC_Ch: //
+                case HC_Wh: //
+                case HC_Ph: //
+                    unregister_mods(MOD_MASK_SHIFT);  //
+                    tap_code(KC_H); // send "h"
+                    tap_code(KC_I); // add "i"
+                    break;
+//                case HC_Sc: //
+//                    tap_code(KC_H); // add "h" (for "Sch", since were already on these keys.)
+//                    break;
+                case HC_AT:
+                    send_string(At_ComboHeld);
+                    break;
+                case HC_COLN:
+                    tap_code16(A(KC_SCLN)); // held, so … (this could use semkeys)
+                    break;
+                case HC_OE:
+                case HC_Q:
+                    tap_code16(KC_BSPC); // held, so delete u
+                    break;
+                case HC_EQL:
+                    tap_code16(KC_PERC); // Held, so send % (instead of =)
+                    break;
+
+                case PC_STAB:
+                    tap_code16(S(KC_TAB));
+                    break;
+                case PC_SENT:
+                    tap_code16(S(KC_ENT));
+                    break;
+                case PC_LPRN:
+                    tap_code16(KC_LPRN);
+                    break;
+                case PC_RPRN:
+                    tap_code16(KC_RPRN);
+                    break;
+                case PC_COLN:
+                    tap_code16(KC_COLN);
+                    break;
+                case PC_PERC:
+                    tap_code16(KC_PERC);
+                    break;
+                case PC_DOLR:
+                    tap_code16(S(KC_4));
+                    break;
+                case PC_TILD:
+                    tap_code16(KC_TILD);
+                    break;
+                case PC_DASH:
+                    tap_code16(A(KC_MINS)); // this should use semkeys
+                    break;
+//                case HC_ELIP:
+                case PC_ELIP:
+                    tap_code16(A(KC_SCLN)); // this should use semkeys
+                    break;
+                case PC_EURO:
+                    tap_code16(A(S(KC_2))); // this should use semkeys
+                    break;
+                case PC_CENT:
+                    tap_code16(A(KC_4)); // this should use semkeys
+                    break;
+                case PC_JYEN:
+                    tap_code16(A(KC_Y)); // this should use semkeys
+                    break;
+                case PC_BPND:
+                    tap_code16(A(KC_3)); // this should use semkeys
+                    break;
+                case PC_NEQL:
+                    tap_code16(A(KC_EQL)); // this should use semkeys
+                    break;
+                case PC_DIV:
+                    tap_code16(A(KC_SLSH)); // this should use semkeys
+                    break;
+                case PC_PLMN:
+                    tap_code16(A(S(KC_EQL))); // this should use semkeys
+                    break;
+                case PC_DEG:
+                    tap_code16(A(KC_0)); // this should use semkeys
+                    break;
+
+
+// PRONOUN shenanigans
+#ifdef EN_PRONOUN_COMBOS
+#ifdef EN_PRONOUN_COMBOS_ALL
+
+                case HC_here_4gram:
+                case HC_there_5gram: // TYPE "there's" #7
+                case HC_where_5gram: //
+
+                case HC_your_4gram: // TYPE "your's"
+                case HC_their_5gram: // TYPE "their's" #6
+
+                    tap_code(KC_QUOT);
+#endif // EN_PRONOUN_COMBOS_ALL
+                    SEND_STRING("s ");
+                    break;
+
+//                case HC_ould_4gram: // TYPE "ould " #11
+#ifdef EN_PRONOUN_COMBOS_ALL
+                case HC_they_4gram: // TYPE "they " #23
+                case HC_theyd_6gram: // TYPE "they'd " #23
+                case HC_theyll_7gram: // TYPE "they'll " #23
+                case HC_wed_4gram:
+                case HC_well_5gram:
+                case HC_youd_5gram:
+                case HC_youll_6gram:
+#endif // EN_PRONOUN_COMBOS_ALL
+                case HC_I:
+                case HC_Id:
+                case HC_Ill:
+                    unregister_mods(MOD_MASK_SHIFT);  //
+                    send_string("'ve "); // or should it be "'nt"?
+                    break;
+#endif // EN_PRONOUN_COMBOS
+
+// END PRONOUN shenanigans
+
+    // if lingered, these will followup with the most common composed letter (Latinate language mashup stats)
+                case HC_ACUT:
+                case HC_GRV:
+                case HC_CIRC:
+                    tap_code16(KC_E); // this should use semkeys? éêè
+                    break;
+                case HC_MACR:
+                    tap_code16(KC_O); // this should use semkeys? ō
+                    break;
+                case HC_DIER:
+                    tap_code16(KC_U); // this should use semkeys? ü
+                    break;
+                case HC_RING:
+                    tap_code16(KC_A); // this should use semkeys? å
+                    break;
+                case HC_CEDILLE:
+                    tap_code16(KC_C); // this should use semkeys? ç
+                    break;
+                case HC_ENYE:
+                    tap_code16(KC_N); // this should use semkeys? ñ
+                    break;
+
+                    
+                case HC_TYPE_LEFTCOMBO: // already "LeftComboTap" has been sent; if held, undo and send "LeftComboHeld"
+#ifdef JP_MODE_ENABLE
+                    if (IS_ENGLISH_MODE) {
+#endif
+                        send_string(LeftComboHeldE); //
+#ifdef JP_MODE_ENABLE
+                    } else {
+                        send_string(LeftComboHeldJ); //
+                    }
+#endif
+                    break;
+                case HC_TYPE_RIGHTCOMBO: // already "RightComboTap" has been sent; if held, add "RightComboHeld"
+#ifdef JP_MODE_ENABLE
+                    if (IS_ENGLISH_MODE) {
+#endif
+                        send_string(RightComboHeldE); //
+#ifdef JP_MODE_ENABLE
+                    } else {
+                        send_string(RightComboHeldJ); //
+                    }
+#endif
+                    break;
+
+            } // switch
+            set_mods(saved_mods); // Restore mods
+            combo_triggered = true;
+            #ifdef OLED_DRIVER_ENABLE
+                oled_set_cursor(oled_max_chars() - 5, combo_OLED_row);
+                oled_write_P(PSTR(" sent"), false);
+            #endif
+        } //  if (combo_on) {
+    }
+}
diff --git a/moutis_combo.h b/moutis_combo.h
new file mode 100644
index 0000000..cfb718b
--- /dev/null
+++ b/moutis_combo.h
@@ -0,0 +1,282 @@
+#define combo_OLED_row 5
+
+#define EXTRA_SHORT_COMBOS // because I don't believ in big combos-use layers or leader_key
+
+
+//
+// where's the file with the combo definitions to be included in the keymap.c
+//
+#define HD_combo_def "moutis_combo_def.c"
+
+#include "personalizedmacros.h"
+
+#ifndef At_ComboHeld
+#define At_ComboHeld ".com"
+#endif
+#ifndef LeftComboTapE
+#define LeftComboTapE "LeftCombo tapped"
+#endif
+#ifndef LeftComboHeldE
+#define LeftComboHeldE "LeftCombo held"
+#endif
+#ifndef LeftComboTapJ
+#define LeftComboTapJ "hidarikombotappu"
+#endif
+#ifndef LeftComboHeldJ
+#define LeftComboHeldJ "hidarikombochouosi"
+#endif
+#ifndef RightComboTapE
+#define RightComboTapE "RightCombo tapped"
+#endif
+#ifndef RightComboHeldE
+#define RightComboHeldE "RightCombo held"
+#endif
+#ifndef RightComboTapJ
+#define RightComboTapJ "migikombotappu"
+#endif
+#ifndef RightComboHeldJ
+#define RightComboHeldJ "migikombochouosi"
+#endif
+
+
+enum my_combos {
+    FC_ESC, // ESCape SIMPLE COMBO must be first (used as FALSE for combo_on)
+    HC_KBD,
+    HC_APP,
+    HC_CAPW, // CAPS WORD for all others
+    FC_CAPS, // CAPS LOCK (others)
+    FC_LANG2, // eisuu (others)
+    FC_LANG1, // kana (others)
+
+    HC_TAB,
+    HC_PCT, // % percent
+    HC_DQUO, // " hijacked for $
+    HC_HASH, // #
+    HC_QUES, // ?
+    HC_EXLM, // !
+    HC_SCLN, // ;
+    HC_UNDS, // _ underscore
+    HC_NDSH, // – N-dash
+    HC_MDSH, // — M-dash
+    HC_TILD, // ~ tilde
+    HC_TIC, // ` tic (not a dead key)
+    HC_ACUT, // ´ acute
+    HC_GRV, // ` grave (dead key)
+    HC_CIRC, // ˆ circumflex
+    HC_MACR, // - macron
+    HC_DIER, // ¨ dieresis
+    HC_RING, // ˚ ring
+    HC_CEDILLE, // ¸ cedille
+    HC_ENYE, // ñ/Ñ enye
+//    HC_OSLSH, // ø/Ø
+
+//    HC_J, // if J is not on the map
+    HC_Q, // Q is not on the map
+    HC_Z, // Z is not on the map
+
+    
+
+    HC_OE, // Œ
+    HC_AE, // Æ
+/*
+    HC_1E, // É acute
+    HC_2E, // È grave
+    HC_3E, // Ê circumflex
+    HC_4E, // Ë diarisis/umlaut
+    HC_5E, // Ē macron
+    HC_6E, // E̊
+
+    HC_UM, // Ü
+    HC_OM, // Ö
+    HC_UK, // Ů
+    HC_OK, // O̊
+    HC_UV, // Û
+    HC_OV, // Ô
+    HC_UF, // Ú
+    HC_OF, // Ó
+ */
+
+
+    
+    //
+    // ACTION COMBOS (ie, not simple combos as above)
+    //
+    // This group all have actions on press (no hold-delay),
+    // may be repeated if held (register_code) or not (tap_code)
+    // to be handled in process_combo_event and/or matrix_scan_user_process_combo
+    //
+    PC_PENT, // <enter> on num
+    PC_BSPC, // <bksp> on num
+    PC_DEL, // <del> on num
+    PC_TAB, // <tab> on num
+
+    HC_AT, // @
+    HC_COLN, // :
+    // Fast entry 4grams
+    // since combos are a bit slower,
+    // needs to be a 4gram+ or more to be worth it
+    HC_Th, // treat as θ
+    HC_Sh, // TYPE "sh"
+    HC_Wh, // treat as digraph 'WH'
+    HC_Ch, // treat as digraph 'CH'
+    HC_Gh, // treat as digraph 'GH'
+    HC_Ph, // treat as φ
+    HC_Sch, // treat as digraph 'SCH'
+
+#ifdef EN_PRONOUN_COMBOS
+// Pronoun combos. KEEP these together!
+    HC_I, // Cap I + "'ve " if lingered
+    HC_Id, // "I'd " …
+    HC_Ill, // "I'll " …
+    HC_Im, // "I'm " …
+    HC_Iv, // "I've " …
+
+#ifdef EN_PRONOUN_COMBOS_ALL
+#ifdef EN_W_PRONOUNS
+    HC_wed_4gram, // we'd
+    HC_well_5gram, // we'll
+    HC_were_5gram, // we're
+    HC_weve_5gram, // we've
+    HC_where_5gram, // TYPE "where"
+#endif // EN_W_PRONOUNS
+
+    HC_youd_5gram,
+    HC_youll_6gram,
+    HC_youre_6gram,
+    HC_youve_6gram,
+    HC_your_4gram,
+
+    HC_there_5gram, // "there" #7
+    HC_here_4gram, // TYPE "here" #9
+
+    HC_they_4gram, // TYPE "they" #23
+    HC_theyd_6gram, // TYPE "they'd " #23
+    HC_theyll_7gram, // TYPE "they'll" #23
+    HC_theyre_7gram, // "they're"
+    HC_theyve_7gram, // "they've"
+    HC_their_5gram, // "their" #6
+
+// END of PRONOUN combos ()
+#endif // EN_PRONOUN_COMBOS_ALL
+#endif // EN_PRONOUN_COMBOS
+
+
+// Japanese contract consonants.
+
+#ifdef JP_MODE_ENABLE  // Japanese mode switching
+#ifdef JP_YOUON_COMBOS  // Japanese contracted sounds as combos
+    jp_kya,  // きゃ
+    jp_kyu,  // きゅ
+    jp_kyo,  // きょ
+    jp_sya,  // しゃ
+    jp_syu,  // しゅ
+    jp_sye,  // しぇ
+    jp_syo,  // しょ
+    jp_zya,  // じゃ
+    jp_zyu,  // じゅ
+    jp_zyo,  // じょ
+    jp_tya,  // ちゃ
+    jp_tyu,  // ちゅ
+    jp_tye,  // ちぇ
+    jp_tyo,  // ちょ
+    jp_pya,  // ぴゃ
+    jp_pyu,  // ぴゅ
+    jp_pyo,  // ぴょ
+
+#ifdef JP_YOUON_COMBOS_ALL
+    jp_gya,  // ぎゃ
+    jp_gyu,  // ぎゅ
+    jp_gyo,  // ぎょ
+    jp_tha,  // てゃ
+    jp_thi,  // てぃ
+    jp_thu,  // てょ
+    jp_the,  // てぇ
+    jp_tho,  // てょ
+    jp_dha,  // でゃ
+    jp_dhi,  // でぃ
+    jp_dhu,  // でょ
+    jp_dhe,  // でぇ
+    jp_dho,  // でょ
+    jp_nya,  // にゃ
+    jp_nyu,  // にゅ
+    jp_nyo,  // にょ
+//    jp_hya,  // ひゃ // conflicts with diacritic combo, handled individually
+    jp_hyu,  // ひゅ
+    jp_hyo,  // ひょ
+    jp_bya,  // びゃ
+    jp_byu,  // びゅ // potential conflict
+    jp_byo,  // びょ
+    jp_mya,  // みゃ
+    jp_myu,  // みゅ
+    jp_myo,  // みょ
+    jp_rya,  // りゃ
+    jp_ryu,  // りゅ
+    jp_ryo,  // りょ
+#endif // JP_YOUON_COMBOS_ALL
+#endif // JP_YOUON_COMBOS
+#endif // JP_MODE_ENABLE
+
+// END Japanese contract consonants.
+
+    //
+    // DELAYED ACTION COMBOS -- this block must be contiguous!!
+    //
+    // no action on press, action (in matrix_scan_user),
+    // underlying keys seng if the hold threshold is not met.
+    // may repeat as appropriate. (tap_code vs register_code)
+    //
+    PC_STAB,  // Shift-<tab>
+    PC_TGNM, // TOGGLE NUMLCK on numpad layer
+    PC_DASH, // – on number layer (keypad)
+    PC_TILD, // ˜
+    PC_ELIP, // …
+    HC_EQL, // = equal
+    HC_ELIP, // …
+    PC_COLN, // :
+    PC_DEG, //
+    PC_NEQL, // ≠
+    PC_ENTR, // <enter> on num layer
+    PC_SENT,  // Shift-<enter>
+    PC_DIV, // ÷
+    PC_PLMN, // ±
+    PC_PERC, // %
+    PC_EURO, // €
+    PC_DOLR, // $
+    PC_CENT, // ¢
+    PC_JYEN, // ¥
+    PC_BPND, // £
+    PC_LPRN,
+    PC_RPRN,
+    PC_CLR,
+    PC_AC,   // END OF DELAY BLOCK
+    
+    HC_TYPE_LEFTCOMBO, // TYPE "LeftComboTapE" and hold for "LeftComboHeldE"
+    HC_TYPE_RIGHTCOMBO, // TYPE "RightComboTapE" and hold for "RightComboHeldE"
+
+    //    HC_2DQUO, // "|" insertion point between double quotes
+
+    // THESE ALL USE SemKeys for platform independence
+    FC_KILL, // Force quit
+    FC_SCAP, // Screen Capture Selection
+    FC_SCLP, // Screen Capture Selection to clipboard
+
+    HC_ENT,
+    HC_ENT2, // hard enter (cmd/ctrl-enter)
+    HC_SPC,
+    HC_NEW,
+    HC_OPEN,
+    HC_CLOZ,
+    HC_QUIT,
+    HC_FIND, // Find the selection
+    HC_SWRD, // select current word
+    HC_SALL, // select all
+
+    HC_UNDO,
+    HC_REDO,
+//    HC_CUT,   // Do I use this anymore?
+    HC_COPY,  // hold for cut
+    HC_PSTE,  // hold for paste+match style
+
+
+    COMBO_LENGTH
+};
diff --git a/moutis_combo_def.c b/moutis_combo_def.c
new file mode 100644
index 0000000..39c2266
--- /dev/null
+++ b/moutis_combo_def.c
@@ -0,0 +1,474 @@
+
+//
+//      Alpha Layer for a 34 key form factor
+// ╭─────────────────────╮ ╭─────────────────────╮
+// │ LT4 LT3 LT2 LT1 LT0 │ │ RT0 RT1 RT2 RT3 RT4 │
+// │ LM4 LM3 LM2 LM1 LM0 | | RT0 RM1 RM2 RM3 RM4 │
+// │ LB4 LB3 LB2 LB1 LB0 │ │ RB0 RB1 RB2 RB3 RB4 │
+// ╰───────────╮ LH2 LH1 │ │ RH1 RH2  ╭──────────╯
+//             ╰─────────╯ ╰──────────╯
+//
+// These definitions based on Hands Down Neu
+// combo keycodes defined in the variation config
+// ex "HDvariations/nu/nu-config.h"
+//
+// Combo definitions defined spatially
+// Other variation dependent combos have predetermined
+//
+
+
+
+// for 34 key boards
+const uint16_t PROGMEM HC_kbd_combo[] = {HD_RH1, HD_RH2, COMBO_END}; // keyboard settings/config layer
+const uint16_t PROGMEM H_menu_combo[] = {HD_LH2, HD_LH1, COMBO_END}; // MENU
+
+/* examples of text entry combos */
+const uint16_t PROGMEM H_Left_combo[] = {HD_LT3, HD_LT2, HD_LT1, COMBO_END}; // TYPE LeftComboTapE
+const uint16_t PROGMEM H_Right_combo[] = {HD_RT1, HD_RT2, HD_RT3, COMBO_END}; // some demonstrator macro placeholder
+
+const uint16_t PROGMEM F_KILL_combo[] = {HD_RT3, HD_RT0, COMBO_END}; // KILL = Force quit OR CTRL-ALT-DEL
+const uint16_t PROGMEM F_SCLP_combo[] = {HD_LT2, HD_LT1, HD_LT0, COMBO_END}; // SCREEN shot SELECTION to clipboard
+const uint16_t PROGMEM F_SCAP_combo[] = {HD_LT3, HD_LT2, HD_LT1, HD_LT0, COMBO_END}; //  SCREEN shot SELECTION to file
+
+
+const uint16_t PROGMEM F_CAPS_combo[] = {HD_LM3, HD_LM2, HD_RM2, HD_RM3, COMBO_END}; // CAPS LOCK (on until hit again)
+const uint16_t PROGMEM H_CAPW_combo[] = {HD_LM1, HD_LM2, HD_RM1, HD_RM2, COMBO_END}; // CAPS WORD (on until word delimiter)
+const uint16_t PROGMEM H_EISUU_combo[] = {HD_LM3, HD_LM2, HD_LM1, COMBO_END}; // KC_MHEN
+const uint16_t PROGMEM H_KANA_combo[] = {HD_RM3, HD_RM2, HD_RM1, COMBO_END}; // KC_HENK
+
+
+
+// Off map and other letter/symbol thingies typically on keyboard
+
+// RIGHT HAND
+// should work for most Neu variations (Gold/Titanium/Rhodium/Vibranium)
+// Bronze/Silver/Platinum (C on right hand, H on left/thumb) may need changes...
+//
+const uint16_t PROGMEM F_ESC_combo[] = {HD_LM4, HD_LM1, COMBO_END}; // ESCape
+const uint16_t PROGMEM Hndsh_combo[] = {HD_RB0, HD_RB1, COMBO_END}; // – n dash
+const uint16_t PROGMEM Hmdsh_combo[] = {HD_RB0, HD_RB2, COMBO_END}; // — m dash
+const uint16_t PROGMEM Htild_combo[] = {HD_RB0, HD_RB4, COMBO_END}; // ~ tilde (not the deadkey for eñye)
+const uint16_t PROGMEM Hunds_combo[] = {HD_RB1, HD_RB3, COMBO_END}; // _ underscore
+const uint16_t PROGMEM Hequal_combo[] = {HD_RB2, HD_RB3, COMBO_END}; // = equal (hold for %)
+const uint16_t PROGMEM Hpercent_combo[] = {HD_RB3, HD_RB4, COMBO_END}; // % percent
+
+
+// spatially arranged characters and diacritics
+const uint16_t PROGMEM Hscln_combo[] = {HD_RM0, HD_RM1, COMBO_END}; // ; semicolon
+const uint16_t PROGMEM Hcoln_combo[] = {HD_RT1, HD_RT3, COMBO_END}; // : colon
+const uint16_t PROGMEM Hexlm_combo[] = {HD_RT1, HD_RT2, COMBO_END}; // !
+const uint16_t PROGMEM Hques_combo[] = {HD_RT2, HD_RT3, COMBO_END}; // ?
+const uint16_t PROGMEM Hdquo_combo[] = {HD_RT2, HD_RT4, COMBO_END}; // " DOUBLE QUOTE  // " hijacked for $
+const uint16_t PROGMEM Htic_combo[] = {HD_RT3, HD_RT4, COMBO_END}; // ` tic (not dead key grave)
+
+const uint16_t PROGMEM Hhash_combo[] = {HD_RT0, HD_RT2, COMBO_END}; // # HASH hijacked for §
+const uint16_t PROGMEM Hat_combo[] = {HD_RT0, HD_RT1, COMBO_END}; // @
+
+// spatially arranged diacritics
+const uint16_t PROGMEM Hdier_combo[] = {HD_RB1, HD_RB2, COMBO_END}; // ¨ dieresis (dead key)
+const uint16_t PROGMEM Henye_combo[] = {HD_LT4, HD_LT0, COMBO_END}; // ˜ enye (dead key) (ñ only?)
+const uint16_t PROGMEM Hacut_combo[] = {HD_RM1, HD_RM2, COMBO_END}; // ´ acute (dead key)é
+
+// for Neu/Au/Ti/Rh
+const uint16_t PROGMEM Hgrv_combo[] = {HD_RM2, HD_RM3, COMBO_END}; // ` grave (dead key)
+const uint16_t PROGMEM Hcirc_combo[] = {HD_RM1, HD_RM3, COMBO_END}; // ˆ circumflex (dead key)
+const uint16_t PROGMEM Hmacr_combo[] = {HD_RM2, HD_RM4, COMBO_END}; // - macron (dead key)
+const uint16_t PROGMEM Hring_combo[] = {HD_RM1, HD_RM4, COMBO_END}; // ˚ ring (dead key)
+const uint16_t PROGMEM Hcedi_combo[] = {HD_LM4, HD_LM2, COMBO_END}; // ¸ cedille (dead key)
+//const uint16_t PROGMEM Hoslsh_combo[] = {HD_RB2, HD_LB0, COMBO_END}; // ø/Ø or Wh
+
+// TEXT ENTRY - off map standard alphas (also on Layer L_PUNCT @ J & G respectively)byby=
+const uint16_t PROGMEM H_Z_combo[] = {HD_Z_keys, COMBO_END}; // TYPE "z"
+const uint16_t PROGMEM H_Q_combo[] = {HD_Qu_keys, COMBO_END}; // TYPE "q" (Qu & Linger deletes u)
+
+// H digraph combos (ideally, these are phonetically/mnemonically arranged
+
+const uint16_t PROGMEM H_Th_combo[] = {HD_Th_keys, COMBO_END}; // TYPE "th"
+const uint16_t PROGMEM H_Ch_combo[] = {HD_Ch_keys, COMBO_END}; // TYPE "ch"
+const uint16_t PROGMEM H_Wh_combo[] = {HD_Wh_keys, COMBO_END}; // TYPE "wh"
+const uint16_t PROGMEM H_Sh_combo[] = {HD_Sh_keys, COMBO_END}; // TYPE "sh"
+const uint16_t PROGMEM H_Ph_combo[] = {HD_Ph_keys, COMBO_END}; // TYPE "ph"
+const uint16_t PROGMEM H_Gh_combo[] = {HD_Gh_keys, COMBO_END}; // TYPE "gh"
+const uint16_t PROGMEM H_Sch_combo[] = {HD_Sch_keys, COMBO_END}; // TYPE "Sch"
+
+// TEXT ENTRY - (ANY ROW/ MIXED ROWS)
+
+
+const uint16_t PROGMEM HOE_lig_combo[] = {HD_OE_lig_keys, COMBO_END}; // Œ
+const uint16_t PROGMEM HAE_lig_combo[] = {HD_AE_lig_keys, COMBO_END}; // Æ
+
+
+// Fast 4grams
+
+#ifdef EN_PRONOUN_COMBOS // the entirely unnecessary pronoun combo shenanigans
+
+// PRONOUNS Fast 4-7grams
+const uint16_t PROGMEM H_Icap_combo[] = {HD_Icap_keys, COMBO_END}; // TYPE "I"
+const uint16_t PROGMEM H_Id_combo[] = {HD_Id_keys, COMBO_END}; // TYPE "I'd"+"'ve "
+const uint16_t PROGMEM H_Ill_combo[] = {HD_Ill_keys, COMBO_END}; // TYPE "I'll"+"'ve "
+const uint16_t PROGMEM H_Im_combo[] = {HD_Im_keys, COMBO_END}; // TYPE "I'm "
+const uint16_t PROGMEM H_Iv_combo[] = {HD_Iv_keys, COMBO_END}; // TYPE "I've "
+
+#ifdef EN_PRONOUN_COMBOS_ALL
+const uint16_t PROGMEM H_youd_combo[] = {HD_youd_keys, COMBO_END}; // TYPE "you'd" + 've
+const uint16_t PROGMEM H_youll_combo[] = {HD_youll_keys, COMBO_END}; // TYPE "you'll" + 've
+const uint16_t PROGMEM H_youre_combo[] = {HD_youre_keys, COMBO_END}; // TYPE "you're"
+const uint16_t PROGMEM H_youve_combo[] = {HD_youve_keys, COMBO_END}; // TYPE "you've"
+const uint16_t PROGMEM H_your_combo[] = {HD_your_keys, COMBO_END}; // TYPE "your" "P" for "possessive" case
+const uint16_t PROGMEM H_their_combo[] = {HD_their_keys, COMBO_END}; // TYPE "their" #6
+const uint16_t PROGMEM H_they_combo[] = {HD_they_keys, COMBO_END}; // "they" #23 + 've
+const uint16_t PROGMEM H_theyd_combo[] = {HD_theyd_keys, COMBO_END}; // "they'd" #23 + 've
+const uint16_t PROGMEM H_theyll_combo[] = {HD_theyll_keys, COMBO_END}; // "they'll" #23 + 've
+const uint16_t PROGMEM H_theyre_combo[] = {HD_theyre_keys, COMBO_END}; // "they're"
+
+const uint16_t PROGMEM H_there_combo[] = {HD_there_keys, COMBO_END}; // TYPE "there" #7 + 's
+const uint16_t PROGMEM H_here_combo[] = {HD_here_keys, COMBO_END}; // TYPE "here" #5 + 's
+
+#ifdef EN_W_PRONOUNS
+const uint16_t PROGMEM H_where_combo[] = {HD_where_keys, COMBO_END}; // "where" + 's
+const uint16_t PROGMEM H_wed_combo[] = {HD_wed_keys, COMBO_END}; // TYPE "we'd" + 've
+const uint16_t PROGMEM H_well_combo[] = {HD_well_keys, COMBO_END}; // TYPE "we'll" + 've
+const uint16_t PROGMEM H_were_combo[] = {HD_were_keys, COMBO_END}; // TYPE "we're"
+const uint16_t PROGMEM H_weve_combo[] = {HD_weve_keys, COMBO_END}; // TYPE "we've"
+#endif // EN_W_PRONOUNS
+
+#endif // EN_PRONOUN_COMBOS_ALL
+
+#endif // EN_PRONOUN_COMBOS // the entirely unnecessary pronoun combo shenanigans
+
+// UPPER ROW
+
+// FUNCTIONS/COMMANDS Spatially arranged
+const uint16_t PROGMEM Htab_combo[] = {HD_tab_keys, COMBO_END};    // tab
+const uint16_t PROGMEM Hspc_combo[] = {HD_spc_keys, COMBO_END};    // SPACE
+const uint16_t PROGMEM Hent_combo[] = {HD_ent_keys, COMBO_END};    // ENTER
+const uint16_t PROGMEM Hent2_combo[] = {HD_ent2_keys, COMBO_END};  // hard-ENTER/page break
+
+// LOWER ROW
+
+// SEMANTIC FUNCTIONS  ** uses SemKeys **
+// Spatially arranged on the QWERTY ZXCV locations
+//
+const uint16_t PROGMEM Hnew_combo[] = {HD_new_keys, COMBO_END}; // new
+const uint16_t PROGMEM Hopen_combo[] = {HD_open_keys, COMBO_END}; // open
+const uint16_t PROGMEM Hclose_combo[] = {HD_close_keys, COMBO_END}; // close
+const uint16_t PROGMEM Hquit_combo[] = {HD_quit_keys, COMBO_END}; // quit
+const uint16_t PROGMEM Hfind_combo[] = {HD_find_keys, COMBO_END}; // find selection
+const uint16_t PROGMEM Hsall_combo[] = {HD_sall_keys, COMBO_END}; // select all
+const uint16_t PROGMEM Hswrd_combo[] = {HD_swrd_keys, COMBO_END}; // select word
+const uint16_t PROGMEM Hundo_combo[] = {HD_undo_keys, COMBO_END}; // undo
+const uint16_t PROGMEM Hredo_combo[] = {HD_redo_keys, COMBO_END}; // redo
+//const uint16_t PROGMEM Hcut_combo[] = {HD_cut_keys, COMBO_END}; // cut (not using this anymore?)
+const uint16_t PROGMEM Hcopy_combo[] = {HD_copy_keys, COMBO_END}; // copy (hold for cut)
+const uint16_t PROGMEM Hpste_combo[] = {HD_pste_keys, COMBO_END}; // paste (hold for paste-match)
+
+
+// TWO HANDS
+
+// 53 Japanese contract consonant combos.
+// Some of these will conflict with diacritics (noted below),
+// so some sort of mode-switch is necessary for both to be used on the same board.
+//
+// Also, these should be coded phonetically, not spatially, but there is risk of
+// conflict with spatial and phonetically/mnemonically coded combos.
+// already, some conflicts with diacritic or pronoun combos
+// that are also phonetically/mnemonically (noted here).
+//
+
+#ifdef JP_MODE_ENABLE
+#ifdef JP_YOUON_COMBOS  // Major Japanese contracted sounds as combos
+const uint16_t PROGMEM kya_combo[] = {JP_kya_keys, COMBO_END};  // きゃ
+const uint16_t PROGMEM kyu_combo[] = {JP_kyu_keys, COMBO_END};  //　きゅ
+const uint16_t PROGMEM kyo_combo[] = {JP_kyo_keys, COMBO_END};  //　きょ
+const uint16_t PROGMEM sya_combo[] = {JP_sya_keys, COMBO_END};  // しゃ
+const uint16_t PROGMEM syu_combo[] = {JP_syu_keys, COMBO_END};  //　しゅ
+const uint16_t PROGMEM sye_combo[] = {JP_sye_keys, COMBO_END};  //　しぇ
+const uint16_t PROGMEM syo_combo[] = {JP_syo_keys, COMBO_END};  //　しょ
+const uint16_t PROGMEM zya_combo[] = {JP_zya_keys, COMBO_END};  // じゃ
+const uint16_t PROGMEM zyu_combo[] = {JP_zyu_keys, COMBO_END};  //　じゅ
+const uint16_t PROGMEM zyo_combo[] = {JP_zyo_keys, COMBO_END};  //　じょ
+const uint16_t PROGMEM tya_combo[] = {JP_tya_keys, COMBO_END};  // ちゃ
+const uint16_t PROGMEM tyu_combo[] = {JP_tyu_keys, COMBO_END};  //　ちゅ
+const uint16_t PROGMEM tye_combo[] = {JP_tye_keys, COMBO_END};  // ちぇ
+const uint16_t PROGMEM tyo_combo[] = {JP_tyo_keys, COMBO_END};  //　ちょ
+const uint16_t PROGMEM pya_combo[] = {JP_pya_keys, COMBO_END};  // ぴゃ
+const uint16_t PROGMEM pyu_combo[] = {JP_pyu_keys, COMBO_END};  //　ぴゅ
+const uint16_t PROGMEM pyo_combo[] = {JP_pyo_keys, COMBO_END};  //　ぴょ
+
+#ifdef JP_YOUON_COMBOS_ALL // All Japanese contracted sounds
+
+const uint16_t PROGMEM gya_combo[] = {JP_gya_keys, COMBO_END};  // ぎゃ
+const uint16_t PROGMEM gyu_combo[] = {JP_gyu_keys, COMBO_END};  //　ぎゅ
+const uint16_t PROGMEM gyo_combo[] = {JP_gyo_keys, COMBO_END};  //　ぎょ
+const uint16_t PROGMEM tha_combo[] = {JP_tha_keys, COMBO_END};  // てゃ
+const uint16_t PROGMEM thi_combo[] = {JP_thi_keys, COMBO_END};  // てぃ
+const uint16_t PROGMEM thu_combo[] = {JP_thu_keys, COMBO_END};  //　てゅ
+const uint16_t PROGMEM the_combo[] = {JP_the_keys, COMBO_END};  // てぇ
+const uint16_t PROGMEM tho_combo[] = {JP_tho_keys, COMBO_END};  //　てょ
+const uint16_t PROGMEM dha_combo[] = {JP_dha_keys, COMBO_END};  // でゃ
+const uint16_t PROGMEM dhi_combo[] = {JP_dhi_keys, COMBO_END};  // でぃ
+const uint16_t PROGMEM dhu_combo[] = {JP_dhu_keys, COMBO_END};  //　でゅ
+const uint16_t PROGMEM dhe_combo[] = {JP_dhe_keys, COMBO_END};  // でぇ
+const uint16_t PROGMEM dho_combo[] = {JP_dho_keys, COMBO_END};  //　でょ
+const uint16_t PROGMEM nya_combo[] = {JP_nya_keys, COMBO_END};  // にゃ
+const uint16_t PROGMEM nyu_combo[] = {JP_nyu_keys, COMBO_END};  //　にゅ
+const uint16_t PROGMEM nyo_combo[] = {JP_nyo_keys, COMBO_END};  //　にょ
+
+//fconst uint16_t PROGMEM hya_combo[] = {JP_hya_keys, COMBO_END};  // ひゃ　conflicts with diacritic?
+const uint16_t PROGMEM hyu_combo[] = {JP_hyu_keys, COMBO_END};  //　ひゅ
+const uint16_t PROGMEM hyo_combo[] = {JP_hyo_keys, COMBO_END};  //　ひょ
+
+const uint16_t PROGMEM bya_combo[] = {JP_bya_keys, COMBO_END};  // びゃ
+const uint16_t PROGMEM byu_combo[] = {JP_byu_keys, COMBO_END};  //　びゅ  potential conflict?
+const uint16_t PROGMEM byo_combo[] = {JP_byo_keys, COMBO_END};  //　びょ
+const uint16_t PROGMEM mya_combo[] = {JP_mya_keys, COMBO_END};  // みゃ
+const uint16_t PROGMEM myu_combo[] = {JP_myu_keys, COMBO_END};  //　みゅ
+const uint16_t PROGMEM myo_combo[] = {JP_myo_keys, COMBO_END};  //　みょ
+const uint16_t PROGMEM rya_combo[] = {JP_rya_keys, COMBO_END};  // りゃ
+const uint16_t PROGMEM ryu_combo[] = {JP_ryu_keys, COMBO_END};  //　りゅ
+const uint16_t PROGMEM ryo_combo[] = {JP_ryo_keys, COMBO_END};  //　りょ
+#endif // JP_YOUON_COMBOS_ALL
+#endif // JP_YOUON_COMBOS
+#endif // JP_MODE_ENABLE
+
+
+//
+//  (22) keypad combos
+// These are not abstracted to location, as they are not on an HD alpha layer
+//
+const uint16_t PROGMEM PNLCK_combo[] = {RSFT_T(KC_P4), RGUI_T(KC_P5), RALT_T(KC_P6), COMBO_END}; // toggle numlck from num layer
+const uint16_t PROGMEM P0E_combo[] = {KC_P0, KC_PEQL, COMBO_END};
+const uint16_t PROGMEM PCME_combo[] = {KC_PDOT, KC_PEQL, COMBO_END};
+const uint16_t PROGMEM PCM1_combo[] = {KC_PDOT, KC_P1, COMBO_END};
+const uint16_t PROGMEM PCM2_combo[] = {KC_PDOT, KC_P2, COMBO_END};
+const uint16_t PROGMEM P01_combo[] = {KC_P0, KC_P1, COMBO_END};
+const uint16_t PROGMEM P02_combo[] = {KC_P0, KC_P2, COMBO_END};
+const uint16_t PROGMEM P04_combo[] = {KC_P0, RSFT_T(KC_P4), COMBO_END};
+const uint16_t PROGMEM P05_combo[] = {KC_P0, RGUI_T(KC_P5), COMBO_END};
+const uint16_t PROGMEM P12_combo[] = {KC_P1, KC_P2, COMBO_END};
+const uint16_t PROGMEM P23_combo[] = {KC_P2, KC_P3, COMBO_END};
+const uint16_t PROGMEM P13_combo[] = {KC_P1, KC_P3, COMBO_END};
+const uint16_t PROGMEM P1E_combo[] = {KC_P1, KC_PEQL, COMBO_END};
+const uint16_t PROGMEM P2E_combo[] = {KC_P2, KC_PEQL, COMBO_END};
+const uint16_t PROGMEM P3E_combo[] = {KC_P3, KC_PEQL, COMBO_END};
+const uint16_t PROGMEM P45_combo[] = {RSFT_T(KC_P4), RGUI_T(KC_P5), COMBO_END};
+const uint16_t PROGMEM P56_combo[] = {RGUI_T(KC_P5), RALT_T(KC_P6), COMBO_END};
+const uint16_t PROGMEM P46_combo[] = {RSFT_T(KC_P4), RALT_T(KC_P6), COMBO_END};
+const uint16_t PROGMEM P5PLS_combo[] = {RGUI_T(KC_P5), RCTL_T(KC_PPLS), COMBO_END};
+const uint16_t PROGMEM P6PLS_combo[] = {RALT_T(KC_P6), RCTL_T(KC_PPLS), COMBO_END};
+const uint16_t PROGMEM PS7_combo[] = {KC_PSLS, KC_P7, COMBO_END};
+const uint16_t PROGMEM P78_combo[] = {KC_P7, KC_P8, COMBO_END};
+const uint16_t PROGMEM P79_combo[] = {KC_P7, KC_P9, COMBO_END};
+const uint16_t PROGMEM P89_combo[] = {KC_P8, KC_P9, COMBO_END};
+const uint16_t PROGMEM P9M_combo[] = {KC_P9, KC_PMNS, COMBO_END};
+const uint16_t PROGMEM PSLT_combo[] = {KC_P7, KC_PMNS, COMBO_END};
+const uint16_t PROGMEM PPLMN_combo[] = {RSFT_T(KC_P4), RCTL_T(KC_PPLS), COMBO_END};
+
+
+combo_t key_combos[] = {
+    // These simple combos trigger on press, repeat. HC_kbd_combo
+    [HC_KBD] = COMBO(HC_kbd_combo, MO(L_MEDIA_KBD)), // keyboard/media settings/config layer
+    [HC_APP] = COMBO(H_menu_combo, KC_APP), // app menu
+    [HC_PCT] = COMBO(Hpercent_combo, KC_PERC), // %
+    [HC_SCLN] = COMBO(Hscln_combo, KC_SCLN), // ;
+    [HC_COLN] = COMBO_ACTION(Hcoln_combo), // :  (hold for elipsis)
+    [HC_UNDS] = COMBO_ACTION(Hunds_combo), // _ underscore
+    [HC_TILD] = COMBO(Htild_combo, KC_TILD),  // ~ or SK_TILD?
+    [HC_TIC] = COMBO(Htic_combo, KC_GRAVE),  // ` (not dead)
+    [HC_EXLM] = COMBO(Hexlm_combo, KC_EXLM), // !
+    [HC_QUES] = COMBO(Hques_combo, KC_QUES), // ?
+    [HC_DQUO] = COMBO(Hdquo_combo, KC_DLR), // " hijacked for $
+    [HC_HASH] = COMBO(Hhash_combo, SK_SECT), // # hijacked for §
+    [HC_AT] = COMBO_ACTION(Hat_combo), // @ & alanreiser.com if held
+    [HC_TAB] = COMBO(Htab_combo, KC_TAB),
+
+    [HC_Q] = COMBO_ACTION(H_Q_combo),
+    [HC_Z] = COMBO(H_Z_combo, KC_Z),
+    [HC_Ch] = COMBO_ACTION(H_Ch_combo),
+    [HC_Sch] = COMBO_ACTION(H_Sch_combo),
+    [HC_Gh] = COMBO_ACTION(H_Gh_combo),
+    [HC_Ph] = COMBO_ACTION(H_Ph_combo),
+    [HC_Th] = COMBO_ACTION(H_Th_combo),
+    [HC_Sh] = COMBO_ACTION(H_Sh_combo),
+    [HC_Wh] = COMBO_ACTION(H_Wh_combo),
+
+    [HC_OE] = COMBO_ACTION(HOE_lig_combo),  // Œ
+    [HC_AE] = COMBO_ACTION(HAE_lig_combo),  // Æ
+
+// Japanese contract consonants
+#ifdef JP_MODE_ENABLE  // Japanese contracted sounds as combos
+#ifdef JP_YOUON_COMBOS  // Japanese contracted sounds as combos
+    [jp_kya] = COMBO_ACTION(kya_combo),  // きゃ
+    [jp_kyu] = COMBO_ACTION(kyu_combo),  // きゅ
+    [jp_kyo] = COMBO_ACTION(kyo_combo),  // きょ
+    [jp_sya] = COMBO_ACTION(sya_combo),  // しゃ
+    [jp_syu] = COMBO_ACTION(syu_combo),  // しゅ
+    [jp_sye] = COMBO_ACTION(sye_combo),  // しぇ
+    [jp_syo] = COMBO_ACTION(syo_combo),  // しょ
+    [jp_zya] = COMBO_ACTION(zya_combo),  // じゃ
+    [jp_zyu] = COMBO_ACTION(zyu_combo),  // じゅ
+    [jp_zyo] = COMBO_ACTION(zyo_combo),  // じょ
+    [jp_tya] = COMBO_ACTION(tya_combo),  // ちゃ
+    [jp_tyu] = COMBO_ACTION(tyu_combo),  // ちゅ
+    [jp_tye] = COMBO_ACTION(tye_combo),  // ちぇ
+    [jp_tyo] = COMBO_ACTION(tyo_combo),  // ちょ
+    [jp_pya] = COMBO_ACTION(pya_combo),  // ぴゃ
+    [jp_pyu] = COMBO_ACTION(pyu_combo),  // ぴゅ
+    [jp_pyo] = COMBO_ACTION(pyo_combo),  // ぴょ
+
+#ifdef JP_YOUON_COMBOS_ALL // JP_YOUON_COMBOS_ALL
+    [jp_gya] = COMBO_ACTION(gya_combo),  // ぎゃ
+    [jp_gyu] = COMBO_ACTION(gyu_combo),  // ぎゅ
+    [jp_gyo] = COMBO_ACTION(gyo_combo),  // ぎょ
+    [jp_tha] = COMBO_ACTION(tha_combo),  // てゃ
+    [jp_thi] = COMBO_ACTION(thi_combo),  // てぃ
+    [jp_thu] = COMBO_ACTION(thu_combo),  // てゅ
+    [jp_the] = COMBO_ACTION(the_combo),  // てぇ
+    [jp_tho] = COMBO_ACTION(tho_combo),  // てょ
+    [jp_dha] = COMBO_ACTION(dha_combo),  // でゃ
+    [jp_dhi] = COMBO_ACTION(dhi_combo),  // でぃ
+    [jp_dhu] = COMBO_ACTION(dhu_combo),  // でゅ
+    [jp_dhe] = COMBO_ACTION(dhe_combo),  // でぇ
+    [jp_dho] = COMBO_ACTION(dho_combo),  // でょ
+    [jp_nya] = COMBO_ACTION(nya_combo),  // にゃ
+    [jp_nyu] = COMBO_ACTION(nyu_combo),  // にゅ
+    [jp_nyo] = COMBO_ACTION(nyo_combo),  // にょ
+//    [jp_hya] = COMBO_ACTION(hya_combo),  // ひゃ conflicts with diactric combos
+    [jp_hyu] = COMBO_ACTION(hyu_combo),  // ひゅ
+    [jp_hyo] = COMBO_ACTION(hyo_combo),  // ひょ
+    [jp_bya] = COMBO_ACTION(bya_combo),  // びゃ
+    [jp_byu] = COMBO_ACTION(byu_combo),  // びゅ potential conflict with diactric combos
+    [jp_byo] = COMBO_ACTION(byo_combo),  // びょ
+    [jp_mya] = COMBO_ACTION(mya_combo),  // みゃ
+    [jp_myu] = COMBO_ACTION(myu_combo),  // みゅ
+    [jp_myo] = COMBO_ACTION(myo_combo),  // みょ
+    [jp_rya] = COMBO_ACTION(rya_combo),  // りゃ
+    [jp_ryu] = COMBO_ACTION(ryu_combo),  // りゅ
+    [jp_ryo] = COMBO_ACTION(ryo_combo),  // りょ
+
+#endif // JP_YOUON_COMBOS_ALL  // All Japanese contracted sounds
+#endif // JP_YOUON_COMBOS  // Japanese contracted sounds as combos
+#endif // JP_MODE_ENABLE
+
+    [PC_PENT] = COMBO(P3E_combo, KC_PENT), // <enter> on num
+    [PC_BSPC] = COMBO(P01_combo, KC_BSPC), // <bksp> on num
+    [PC_DEL] = COMBO(P02_combo, KC_DEL), // <del> on num
+    [PC_TAB] = COMBO(PCM1_combo, KC_TAB), // <tab> on num
+
+    // action combos below
+    // This group have custom actions on trigger (no hold-delay), repeat if held
+
+    // this block should be contiguous,
+    // Delayed action (COMBO_HOLD threshold). No repeat if held (tap_code)
+    // should send the underlying combo keys if COMBO_HOLD is not met.
+
+    // Keypad combos (all need actions or mods, so must be here)
+    [PC_STAB] = COMBO_ACTION(PCM2_combo), // shift-<tab> on num
+    
+    [HC_EQL] = COMBO_ACTION(Hequal_combo), // =  (hold for %)
+    [PC_SENT] = COMBO_ACTION(P2E_combo), // shift-<enter> on num
+    [PC_TGNM] = COMBO(PNLCK_combo, KC_NUM), // toggle num lock
+    [PC_DASH] = COMBO_ACTION(P12_combo), // – for time span on number layer
+    [PC_TILD] = COMBO_ACTION(P13_combo), // ~ for time span on number layer
+    [PC_ELIP] = COMBO_ACTION(P23_combo), // … for time span on number layer
+    [PC_LPRN] = COMBO_ACTION(P45_combo), // ( on number layer
+    [PC_RPRN] = COMBO_ACTION(P56_combo), // ) on number layer
+    [PC_COLN] = COMBO_ACTION(P46_combo), // : on number layer for time 12:30xx
+    [PC_PERC] = COMBO_ACTION(P6PLS_combo), // % on numbers
+    [PC_DEG] = COMBO_ACTION(P5PLS_combo), // degree symbol on number layer
+    [PC_JYEN] = COMBO_ACTION(PS7_combo), // €
+    [PC_DOLR] = COMBO_ACTION(P78_combo), // $
+    [PC_CENT] = COMBO_ACTION(P79_combo), // ¢
+    [PC_EURO] = COMBO_ACTION(P89_combo), // ¥
+    [PC_BPND] = COMBO_ACTION(P9M_combo), // £
+    [PC_DIV] = COMBO_ACTION(PSLT_combo), // ÷
+    [PC_PLMN] = COMBO_ACTION(PPLMN_combo), // ±
+    [PC_NEQL] = COMBO_ACTION(P1E_combo), // ≠
+    [PC_CLR] = COMBO(P0E_combo, KC_C), // C for "CLEAR"
+    [PC_AC] = COMBO(PCME_combo, KC_ESC), // ESC for "ALL CLEAR"
+    [PC_PLMN] = COMBO_ACTION(PPLMN_combo), // ±
+
+    [FC_ESC] = COMBO(F_ESC_combo, KC_ESC),  // ESCape
+    [FC_KILL] = COMBO(F_KILL_combo, SK_KILL), // Force quit
+    [FC_SCAP] = COMBO(F_SCAP_combo, SK_SCAP), // SCREEN CAPTURE SELECTION
+    [FC_SCLP] = COMBO(F_SCLP_combo, SK_SCLP), // SCREEN CAPTURE SELECTION to clipboard
+    [FC_CAPS] = COMBO(F_CAPS_combo, KC_CAPS), // CAPS LOCK
+    [HC_CAPW] = COMBO_ACTION(H_CAPW_combo), // CAPS_WORD
+
+    [FC_LANG2] = COMBO(H_EISUU_combo, SK_MHEN), // eisuu (others)
+    [FC_LANG1] = COMBO(H_KANA_combo, SK_HENK), // kana (others)
+
+    [HC_NDSH] = COMBO_ACTION(Hndsh_combo), // – N-DASH
+    [HC_MDSH] = COMBO_ACTION(Hmdsh_combo), // — M-DASH
+    
+// Dead keys (Mac only, for now)
+    [HC_ACUT] = COMBO_ACTION(Hacut_combo), // ´ acute
+    [HC_GRV] = COMBO_ACTION(Hgrv_combo), // ` grave
+    [HC_CIRC] = COMBO_ACTION(Hcirc_combo), // ˆ circumflex
+    [HC_MACR] = COMBO_ACTION(Hmacr_combo), // - macron
+    [HC_DIER] = COMBO_ACTION(Hdier_combo), // ¨ dieresis
+    [HC_RING] = COMBO_ACTION(Hring_combo), // ˚ ring
+    [HC_CEDILLE] = COMBO_ACTION(Hcedi_combo), // ¸ cedille
+    [HC_ENYE] = COMBO_ACTION(Henye_combo), // ˜ tilde (dead)
+//    [HC_OSLSH] = COMBO_ACTION(Hoslsh_combo), // ø/Ø or Wh
+
+//    [HC_ENYE] = COMBO(Henye_combo, SK_ENYE), // ñ/Ñ enye
+//    [HC_ELIP] = COMBO_ACTION(Helip_combo),  // …
+
+
+// Fast entry 4grams
+
+#ifdef EN_PRONOUN_COMBOS
+// PRONOUNS Fast entry 4-7gram PRONOUNS (an English quirk)
+    [HC_I] = COMBO_ACTION(H_Icap_combo),// TYPE "I"+"'ve "
+    [HC_Id] = COMBO_ACTION(H_Id_combo),// TYPE "I'd "
+    [HC_Ill] = COMBO_ACTION(H_Ill_combo),// TYPE "I'll "
+    [HC_Im] = COMBO_ACTION(H_Im_combo),// TYPE "I'm  "
+    [HC_Iv] = COMBO_ACTION(H_Iv_combo),// TYPE "I've  "
+
+#ifdef EN_PRONOUN_COMBOS_ALL
+#ifdef EN_W_PRONOUNS
+    [HC_wed_4gram] = COMBO_ACTION(H_wed_combo),// TYPE "we'd"
+    [HC_well_5gram] = COMBO_ACTION(H_well_combo),// TYPE "we'll"
+    [HC_were_5gram] = COMBO_ACTION(H_were_combo),// TYPE "we're"
+    [HC_weve_5gram] = COMBO_ACTION(H_weve_combo),// TYPE "we've"
+    [HC_where_5gram] = COMBO_ACTION(H_where_combo), // TYPE "where"
+#endif // EN_W_PRONOUNS
+    [HC_youd_5gram] = COMBO_ACTION(H_youd_combo),// TYPE "you'd"
+    [HC_youll_6gram] = COMBO_ACTION(H_youll_combo),// TYPE "you'll"
+    [HC_youre_6gram] = COMBO_ACTION(H_youre_combo),// TYPE "you're"
+    [HC_youve_6gram] = COMBO_ACTION(H_youve_combo),// TYPE "you've"
+    [HC_your_4gram] = COMBO_ACTION(H_your_combo),// TYPE "your"
+    [HC_they_4gram] = COMBO_ACTION(H_they_combo), // TYPE "they" #23
+    [HC_their_5gram] = COMBO_ACTION(H_their_combo), // TYPE "their" #6
+    [HC_theyre_7gram] = COMBO_ACTION(H_theyre_combo), // TYPE "they're"
+
+    [HC_there_5gram] = COMBO_ACTION(H_there_combo), // TYPE "there" #7
+    [HC_here_4gram] = COMBO_ACTION(H_here_combo), // TYPE "here" #9
+
+#endif // EN_PRONOUN_COMBOS_ALL
+#endif // EN_PRONOUN_COMBOS
+
+    [HC_TYPE_LEFTCOMBO] = COMBO_ACTION(H_Left_combo), // a personally useful 5-8gram!
+    [HC_TYPE_RIGHTCOMBO] = COMBO_ACTION(H_Right_combo), // a demonstrator, how long autotypes can be!
+    
+    [HC_SPC] = COMBO(Hspc_combo, KC_SPC), // SPACE
+    [HC_ENT] = COMBO(Hent_combo, KC_ENT), // ENTER
+    [HC_ENT2] = COMBO(Hent2_combo, SK_HENT), // hard-ENTER
+
+/* These all use SemKeys, even as simple combos (handled by process_semkey from process_record_user) */
+    [HC_NEW] = COMBO(Hnew_combo, SK_NEW),
+    [HC_OPEN] = COMBO(Hopen_combo, SK_OPEN),
+    [HC_CLOZ] = COMBO(Hclose_combo, SK_CLOZ),
+    [HC_QUIT] = COMBO(Hquit_combo, SK_QUIT),
+    [HC_FIND] = COMBO_ACTION(Hfind_combo),
+    [HC_SALL] = COMBO(Hsall_combo, SK_SALL),
+    [HC_SWRD] = COMBO(Hswrd_combo, SK_SWRD),
+    [HC_UNDO] = COMBO(Hundo_combo, SK_UNDO),
+    [HC_REDO] = COMBO(Hredo_combo, SK_REDO),
+//    [HC_CUT] = COMBO(Hcut_combo, SK_CUT), // also hold copy (no longer used?)
+    [HC_COPY] = COMBO_ACTION(Hcopy_combo), // using hold for cut
+//    [HC_PSTM] = COMBO(Hpstm_combo, SK_PSTM),  // also hold paste (no longer used?)
+    [HC_PSTE] = COMBO_ACTION(Hpste_combo) // using hold for paste-match
+    
+};
diff --git a/moutis_matrix.c b/moutis_matrix.c
new file mode 100644
index 0000000..e295176
--- /dev/null
+++ b/moutis_matrix.c
@@ -0,0 +1,100 @@
+
+
+void matrix_scan_user(void) {
+
+#ifdef COMBO_ENABLE
+// Is a combo_action being held for delayed action/linger combos)?
+    if (combo_on) {
+        matrix_scan_user_process_combo();
+    }
+#endif
+
+    if (state_reset_timer) { // is there an active state to check on (caps_word)?
+
+        if (caps_word_on) { // caps_word mode on, (no mods) check if it needs to be cleared
+            if (timer_elapsed(state_reset_timer) > STATE_RESET_TIME * 3) {// caps time over?
+                disable_caps_word(); // turn off all open states
+                state_reset_timer = 0;
+            }
+        }
+
+//
+// quick check in with the APP_MENU process
+// This was inline, to avoid the call/return before the test in matrix,
+// but doesn't seem to be an issue, even on AVR.
+//
+        matrix_APP_MENU();
+
+//
+// prior register_linger_key(kc) needs to be handled here
+//
+        if (linger_key && user_config.AdaptiveKeys) { // A linger key is being held down
+            if (timer_elapsed(linger_timer) > LINGER_TIME) { // linger triggered
+                saved_mods = get_mods();
+                clear_mods();
+                unregister_mods(MOD_MASK_SHIFT);  // second char isn't shifted. CAPSLOCK UNAFFECTED.
+                switch(linger_key) { // only one linger_key at a time, obviously
+                    case KC_Q: // already "Q" has been sent; if lingered, add "u"
+                        tap_code(KC_U);
+                        break;
+
+                    case KC_V: // already "V" has been sent; if lingered, add "ivi "
+                        if ((saved_mods & MOD_MASK_SHIFT)) {
+                            SEND_STRING("ivi");
+                        }
+                        break;
+                    case KC_Z: // already "Z" has been sent; if lingered, add "oe "
+                        if ((saved_mods & MOD_MASK_SHIFT)) {
+                            SEND_STRING("oe");
+                        }
+                        break;
+                    case KC_J: // already "Z" has been sent; if lingered, add "oe "
+                        if ((saved_mods & MOD_MASK_SHIFT)) {
+                            SEND_STRING("acob");
+                        }
+                        break;
+
+                    case KC_LPRN: //
+                        tap_code16(KC_RPRN);
+                        tap_code16(KC_LEFT);
+                        break;
+                    case KC_LBRC: //
+                        tap_code16(KC_RBRC);
+                        tap_code16(KC_LEFT);
+                        break;
+                    case KC_LCBR: //
+                        tap_code16(KC_RCBR);
+                        tap_code16(KC_LEFT);
+                        break;
+                    case KC_LT: //
+                        tap_code16(KC_GT);
+                        tap_code16(KC_LEFT);
+                        break;
+
+                    case KC_QUOT: //
+                        tap_code16(KC_BSPC);
+                        tap_SemKey(SK_SQUL);
+                        tap_SemKey(SK_SQUR);
+                        tap_code16(KC_LEFT);
+                        break;
+                    case KC_DQUO: //
+                        tap_code16(KC_BSPC);
+                        clear_keyboard();       // QMK doesn't let go of shift here?
+                        tap_SemKey(SK_SDQL);
+                        tap_SemKey(SK_SDQR);
+                        tap_code(KC_LEFT);
+                        break;
+
+                    default:
+                        break;
+                }
+                linger_timer = state_reset_timer = 0; // stop lingering
+                set_mods(saved_mods); // Restore mods
+            }
+        }
+
+    }
+
+
+ }
+
diff --git a/moutis_process_record.c b/moutis_process_record.c
new file mode 100644
index 0000000..dabd97f
--- /dev/null
+++ b/moutis_process_record.c
@@ -0,0 +1,491 @@
+/*
+
+ Set keyboard on host to ANSI (not ISO/JIS for now. will eventually invert this.)
+ 
+ */
+
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+
+    bool return_state = true;
+    uint8_t  saved_mods;
+    
+
+    saved_mods = get_mods(); // preserve mods
+
+#ifdef ADAPTIVE_ENABLE
+    // Should we handle an adaptive key?  (Semkey may send Adaptive?)
+    if (record->event.pressed // keyup = not rolling = no adaptive -> return.
+        && user_config.AdaptiveKeys // AdaptiveKeys is on
+#ifdef JP_MODE_ENABLE
+        && IS_ENGLISH_MODE
+#endif // #ifdef JP_MODE_ENABLE
+        ) { // Adaptives only in primary (Latin) mode
+        if (!process_adaptive_key(&keycode, record)) {
+            prior_keydown = timer_read(); // (re)start prior_key timing
+            prior_keycode = keycode; // this keycode is stripped of mods+taps
+            return false; // took care of that key
+        }
+    }
+#endif // #ifdef ADAPTIVE_ENABLE
+    
+    // Do we need to filter multi-function keys?
+    switch (keycode) {
+        case QK_MOD_TAP ... QK_MOD_TAP_MAX:
+        case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
+#ifdef TAP_DANCE_ENABLE
+        case QK_TAP_DANCE ... QK_TAP_DANCE_MAX:
+#endif
+            if (!record->tap.count) // if not tapped yet…
+                return true; // let QMK do that first
+            keycode &= QK_BASIC_MAX; // mods & taps have been handled.
+    }
+
+    // Do we turn off CAPS_WORD?
+    if (caps_word_on) {
+        if (!process_caps_word(keycode, record)) {
+            return false; // took care of that key
+        }
+    }
+
+    // Do we handle a semantic key? Combos or adaptives could have sent one.
+    if (!process_semkey(keycode, record)) {
+        return false; // took care of that key
+    }
+
+    // APP_MENU gets special treatment (also needs matrix_APP_MENU)
+
+    if  (keycode == KC_APP) {  // mimic windows app key behavior (only better?) also in scan_matrix
+        process_APP_MENU(record);
+        return false; // took care of that key
+    }
+    
+    // only process for SHIFT/ALT & no CTRL or GUI mods
+    if (saved_mods & MOD_MASK_CG)  // CTRL or GUI/CMD?
+        return true; // do default if CTRL or GUI/CMD are down
+
+
+    if (record->event.pressed) {
+        switch (keycode) { // only handling normal, SHFT or ALT cases.
+
+/*
+    Key overrides here. use SemKey wherever possible (del_wd?)
+*/
+#ifndef KEY_OVERRIDE_ENABLE
+/*
+    QMK KEY_OVERRIDE can't integrate semkeys or linger keys,
+    so for now I roll my own here.
+*/
+
+            case KC_BSPC:  // make S(KC_BSPC) = KC_DEL; ALT = word_del L & R
+                if (saved_mods & MOD_MASK_SHIFT) {  // shift down with KC_BSPC? (ALT OK)
+                    key_trap = KC_DEL;  // mode monitor on to clear this on keyup
+register_key_trap_and_return:
+                    register_code16(key_trap);
+                    return_state = false; // stop processing this record.
+                    set_mods(saved_mods);  // not sure if we need this
+                    break;
+                }
+            case KC_MINS:  // SHIFT = +
+                if (!(saved_mods & MOD_MASK_SHIFT)) // only SHFT? (ALT ok)
+                    break; // N: nothing to do
+                key_trap = KC_PLUS;  //  enter override state
+                goto register_key_trap_and_return;
+
+            case KC_EQL: // SHIFT = _
+                if (!(saved_mods & MOD_MASK_SHIFT)) // only SHFT? (ALT ok)
+                    break; // N: nothing to do
+                key_trap = S(KC_MINS);  // enter override state
+                goto register_key_trap_and_return;
+
+            case KC_SLSH:  // SHIFT = *, ALT=\, ALT+SHIFT=⁄
+                unregister_mods(MOD_MASK_SA); // get rid of shift & alt
+                if (saved_mods & MOD_MASK_ALT) { // ALT down?
+                    if (saved_mods & MOD_MASK_SHIFT) { // SHFT too?
+                        tap_code16(A(S(KC_1))); // Y:
+                    } else {
+                        tap_code16(KC_BSLS); // N: just alt, so
+                    }
+                    return_state = false; // don't do more with this record.
+                } else if (saved_mods & MOD_MASK_SHIFT) { // only SHFT?
+                    key_trap = KC_ASTR;  // enter override state
+                    goto register_key_trap_and_return;
+                }
+                break;
+
+            case KC_HASH:  // SHIFT = $ ALT=‹ SHIFT_ALT = ›
+                unregister_mods(MOD_MASK_SA); // get rid of shift & alt
+                if (saved_mods & MOD_MASK_ALT) { // ALT down?
+                   if (saved_mods & MOD_MASK_SHIFT) { // SFT too?
+                        tap_code16(A(KC_4)); // convert to SemKey ¢
+                    } else {
+                        tap_code16(S(A(KC_SCLN)));
+                    }
+                    return_state = false; // stop processing this record.
+                } else if (saved_mods & MOD_MASK_SHIFT) { // only SHFT down
+                    key_trap = KC_DLR;  // enter override state
+                    goto register_key_trap_and_return;
+                }
+                break;
+                
+            case KC_LPRN:  // SHIFT = { (linger=(|))
+                if (!saved_mods) {
+                    register_linger_key(keycode); // example of simple linger macro
+                    return_state = false; // don't do more with this record.
+                } else if (saved_mods & MOD_MASK_SHIFT) { // shift down with KC_RPRN?
+                    if (saved_mods & MOD_MASK_ALT) { // SHIFT & ALT?
+                        register_linger_key(KC_LCBR); // this should be semkey for ‹/«?
+                    } else { // just SHIFT
+                        unregister_mods(MOD_MASK_SA); // get rid of shift & alt
+                        register_linger_key(KC_LBRC); //
+                    }
+                    return_state = false; // don't do more with this record.
+                } else if (saved_mods & MOD_MASK_ALT) { // ALT only?
+                    unregister_mods(MOD_MASK_ALT); // get rid of alt
+                    register_linger_key(KC_LCBR);
+                    return_state = false; // stop processing this record.
+                }
+                break;
+
+            case KC_RPRN:  // send } FOR Shift )
+                if (saved_mods & MOD_MASK_SHIFT) { // SHFT down?
+                    if (saved_mods & MOD_MASK_ALT) { // ALT also?
+                        tap_code16(KC_RCBR); // SHIFT and ALT
+                    } else {
+                        unregister_mods(MOD_MASK_SA); // get rid of shift & alt
+                        tap_code16(KC_RBRC); // only SHIFT
+                    }
+                    return_state = false; // don't do more with this record.
+                } else if (saved_mods & MOD_MASK_ALT) { // only ALT KC_RPRN?
+                    unregister_mods(MOD_MASK_ALT); // get rid of alt
+                    tap_code16(KC_RCBR);
+                    return_state = false; // stop processing this record.
+                }
+                break;
+
+            case KC_LT:  //  linger=<|>
+                if (!saved_mods)
+                    goto linger_and_return; // CAUTION: messing w/stack frame here!!
+                if (saved_mods & MOD_MASK_SHIFT) { // SHFT down? (ALT ok)
+                    tap_code16(A(KC_COMM)); // ≤ convert to SemKey
+                    return_state = false; // stop processing this record.
+                }
+                break;
+            case KC_GT:  // SHIFT = ≥,
+                if (saved_mods & MOD_MASK_SHIFT) { // SHFT down? (ALT ok)
+                    tap_code16(A(KC_DOT)); // convert to SemKey
+                    return_state = false; // stop processing this record.
+                }
+                break;
+
+            case KC_LBRC:  // linger=[|]
+            case KC_LCBR:   // linger={|}
+                if (!saved_mods)
+                    goto linger_and_return; // CAUTION: messing w/stack frame here!!
+                break;
+
+            case KC_COMM:  // SHIFT = ;, ALT=_
+                unregister_mods(MOD_MASK_SA); // get rid of shift & alt
+                if (saved_mods & MOD_MASK_ALT) { // ALT down?
+                    if (saved_mods & MOD_MASK_SHIFT) { // SFT too?
+                        tap_code16(A(KC_BSLS)); // convert to SemKey
+                    } else {
+                        tap_code16(KC_UNDS);
+                    }
+                    return_state = false; // stop processing this record.
+                } else if (saved_mods & MOD_MASK_SHIFT) { // only SHFT down
+                    tap_code16(KC_SCLN); // just semicolon
+                    return_state = false; // stop processing this record.
+                }
+                break;
+
+            case KC_DOT:  // SHIFT = :, ALT=…, ALT+SHIFT= \ backslash
+                unregister_mods(MOD_MASK_SA); // get rid of shift & alt
+                if (saved_mods & MOD_MASK_ALT) { // ALT down?
+                    if (saved_mods & MOD_MASK_SHIFT) { // SHFT too?
+                        tap_code16(KC_BSLS);
+                    } else {
+                        tap_code16(A(KC_SCLN));  // convert to SemKey
+                    }
+                    return_state = false; // stop processing this record.
+                } else if (saved_mods & MOD_MASK_SHIFT) { // only SHFT down?
+                    tap_code16(KC_COLN);
+                    return_state = false; // stop processing this record.
+                }
+                break;
+
+
+            case KC_EXLM: // SHFT ! = ¡
+                unregister_mods(MOD_MASK_SA); // get rid of shift & alt
+                if (saved_mods & MOD_MASK_ALT) { // ALT down?
+                    if (saved_mods & MOD_MASK_SHIFT) { // SHFT too?
+                        tap_code16(S(KC_4)); // this should be semkey for №
+                    } else {
+                        tap_code16(A(KC_1)); // ¡
+                    }
+                    return_state = false; // stop processing this record.
+                } else if (saved_mods & MOD_MASK_SHIFT) { // only SHFT down
+                    tap_code16(A(S(KC_2))); // this should be semkey for €
+                    return_state = false; // stop processing this record.
+                }
+                break;
+
+            case KC_QUES: // ALT ? = ¿ (should be SemKey?)
+                unregister_mods(MOD_MASK_SA); // get rid of shift & alt
+                if (saved_mods & MOD_MASK_ALT) { // ALT down?
+                    if (saved_mods & MOD_MASK_SHIFT) { // SHFT too?
+                        tap_code16(A(KC_Y)); // this should be semkey for ¥
+                    } else {
+                        tap_code16(S(A(KC_SLSH))); // this should be semkey for ¿
+                    }
+                    return_state = false; // stop processing this record.
+                } else if (saved_mods & MOD_MASK_SHIFT) { // only SHFT down
+                    tap_code16(A(KC_3)); // this should be semkey for £
+                    return_state = false; // stop processing this record.
+                }
+                break;
+
+            case KC_SCLN:  // SHIFT = , ALT=_,
+                unregister_mods(MOD_MASK_SA); // get rid of shift & alt
+                if (saved_mods & MOD_MASK_ALT) { // ALT down?
+                    if (saved_mods & MOD_MASK_SHIFT) { // SHFT too?
+                        tap_SemKey(SK_SECT); //
+                    } else {
+                        tap_code16(A(KC_7)); // this should be semkey for ¶
+                    }
+                    return_state = false; // stop processing this record.
+                } else if (saved_mods & MOD_MASK_SHIFT) { // only SHFT down
+                    tap_code16(S(A(KC_MINS))); // this should be semkey for — M-Dash
+                    return_state = false; // stop processing this record.
+                }
+                break;
+
+            case KC_COLN:  // SHIFT = …
+                unregister_mods(MOD_MASK_SA); // get rid of shift & alt
+                if (saved_mods & MOD_MASK_ALT) { // ALT down?
+                    if (saved_mods & MOD_MASK_SHIFT) { // SHFT too?
+                        tap_code16(S(A(KC_R))); // this should be semkey for ‰
+                    } else {
+                        tap_code16(KC_PERC); // this should be semkey for %
+                    }
+                    return_state = false; // stop processing this record.
+                } else if (saved_mods & MOD_MASK_SHIFT) { // only SHFT down
+                    tap_code16(A(KC_SCLN)); // this should be semkey for …
+                    return_state = false; // stop processing this record.
+                }
+                break;
+
+            case KC_QUOT:  // SHIFT = ], ALT=›, ALT+SHIFT=»
+                clear_keyboard(); // clean record to tinker with.
+                if (saved_mods & MOD_MASK_ALT) { // ALT (only) down?
+                        if (saved_mods & MOD_MASK_SHIFT) { // SHFT too?
+                            tap_code16(DQUO_SA);// this should be semkey for ‹?
+                        } else { // alt & shift?
+                            tap_code16(DQUO_A);// this should be linger on semkey for «?
+                        }
+                        return_state = false; // don't do more with this record.
+#ifndef JP_MODE_ENABLE
+                } else if (saved_mods & MOD_MASK_SHIFT) { // SHFT (only)?
+#else
+                } else if (((saved_mods & MOD_MASK_SHIFT) && IS_ENGLISH_MODE)  // SHFT (only)
+                           || (!saved_mods && !IS_ENGLISH_MODE)) { // or no mods & not in english
+#endif
+//                    register_linger_key(user_config.RBRC_key); // example of simple linger macro
+                    register_linger_key(DQUO_S); // example of simple linger macro
+                    return_state = false; // don't do more with this record.
+                } else //{ // no mods, so linger
+                    goto byteshave; // CAUTION: messing w/stack frame here!!
+//                    register_linger_key(keycode); // example of simple linger macro
+//                    return_state = false; // don't do more with this record.
+//                }
+                break;
+            case KC_DQUO: // SHIFT = [ (linger=[|]), ALT=‹, ALT+SHIFT=«
+                clear_keyboard(); // clean record to tinker with.
+                if (saved_mods & MOD_MASK_ALT) { // ALT (only) down?
+                    if (saved_mods & MOD_MASK_SHIFT) { // SHFT too?
+                        tap_code16(SQUO_SA);// this should be semkey for ›?
+                    } else {
+                        tap_code16(SQUO_A);// this should be linger on semkey for »?
+                    }
+                    return_state = false; // don't do more with this record.
+#ifndef JP_MODE_ENABLE
+                } else if (saved_mods & MOD_MASK_SHIFT) { // SHFT (only)?
+#else
+                } else if (((saved_mods & MOD_MASK_SHIFT) && IS_ENGLISH_MODE)  // SHFT (only)
+                           || (!saved_mods && !IS_ENGLISH_MODE)) { // or no mods & not in english
+#endif
+//                    register_linger_key(user_config.RBRC_key); // example of simple linger macro
+                    register_linger_key(SQUO_S); // example of simple linger macro
+                    return_state = false; // don't do more with this record.
+                } else { // no mods, so
+byteshave: // CAUTION: messing w/stack frame here!!
+                    register_linger_key(keycode); // example of simple linger macro
+                    return_state = false; // don't do more with this record.
+                }
+                break;
+
+#ifdef JP_MODE_ENABLE
+            case KC_L: // L if English, ん if Japanese mode
+                if (!IS_ENGLISH_MODE) {
+                    tap_code(KC_N);
+                    tap_code(KC_N);
+                    return_state = false; // stop processing this record.
+                }
+                break;
+            case KC_C: // C if English, z if Japanese mode
+                if (!IS_ENGLISH_MODE) {
+                    register_code(KC_Z);
+                    return_state = false; // stop processing this record.
+                }
+                break;
+           case KC_X: // X if English, - if Japanese mode
+                if (!IS_ENGLISH_MODE) {
+                    register_code(KC_MINS);
+                    return_state = false; // stop processing this record.
+                }
+                break;
+#endif
+            case KC_J:  // optional linger
+            case KC_V:  // optional linger
+            case KC_Q:  // Qu, linger deletes U
+            case KC_Z:  // optional linger
+                if ((saved_mods & MOD_MASK_ALT)
+#ifdef JP_MODE_ENABLE
+                    || !IS_ENGLISH_MODE
+#endif
+                    ) // can this linger?
+                    break; // N: do default thing
+#ifndef KEY_OVERRIDE_ENABLE
+linger_and_return:
+#endif
+                register_linger_key(keycode); // example of simple linger macro
+                return_state = false; // stop processing this record.
+                break;
+/*
+            case KC_LNG1: // Japanese
+#ifdef JP_MODE_ENABLE
+                IS_ENGLISH_MODE = false;
+#endif
+                tap_SemKey(SK_HENK); // Mac/Win/iOS all different?
+                return_state = false; // stop processing this record.
+                break;
+            case KC_LNG2: // English
+#ifdef JP_MODE_ENABLE
+                IS_ENGLISH_MODE = true;
+#endif
+                tap_SemKey(SK_MHEN); // Mac/Win/iOS all different?
+                return_state = false; // stop processing this record.
+                break;
+*/
+            case CG_SWAP: // SINCE MAC IS MY LAYOUT DEFAULT switch to windows
+                user_config.OSIndex = 1; // for Windows Semkeys
+                return_state = true; // let QMK do it's swap thing.
+                goto storeSettings;
+            case CG_NORM: // Back to default
+                user_config.OSIndex = 0; // for Mac Semkeys
+                return_state = true; // let QMK do it's swap thing.
+                goto storeSettings;
+            case HD_AdaptKeyToggle: // toggle AdaptiveKeys (& LingerKeys, linger combos)
+#ifdef ADAPTIVE_ENABLE
+                user_config.AdaptiveKeys = !user_config.AdaptiveKeys;
+#endif
+                return_state = false; // stop processing this record.
+                goto storeSettings;
+            case HD_L_QWERTY: // are we changing default layers?
+#ifdef ADAPTIVE_ENABLE
+                user_config.AdaptiveKeys = false; // no adaptive keys on QWERTY
+#endif
+                goto setLayer;
+            case HD_L_ALPHA:
+#ifdef ADAPTIVE_ENABLE
+                user_config.AdaptiveKeys = true; // assume adaptive keys on Hands Down
+#endif
+setLayer:
+                return_state = false; // don't do more with this record.
+                set_single_persistent_default_layer(keycode-L_BASELAYER);// Remember default layer after powerdown
+storeSettings:
+                eeconfig_update_user(user_config.raw); // Remember platform variables after powerdown
+                break;
+
+#endif // KEY_OVERRIDE_ENABLE
+        } // switch (keycode) {
+
+#ifdef ADAPTIVE_ENABLE
+        prior_keydown = timer_read(); // (re)start prior_key timing
+        prior_keycode = keycode; // this keycode is now stripped of mods+taps
+#endif
+        
+    } else { // key up event
+//  when I can get this to work with HRMs properly, this will strictly enforce rolling.
+//        if (keycode == prior_keycode) // releasing adaptive?
+//            prior_keycode = prior_keydown = 0; // exit Adaptive state
+        switch (keycode) { // clean up on keyup.
+
+#ifdef JP_MODE_ENABLE
+            case KC_C: // C if English, z if Japanese mode
+                if (!IS_ENGLISH_MODE) {
+                    unregister_code(KC_Z);
+                    return_state = false; // stop processing this record.
+                }
+                break;
+           case KC_X: // X if English, - if Japanese mode
+                if (!IS_ENGLISH_MODE) {
+                    unregister_code(KC_MINS);
+                    return_state = false; // stop processing this record.
+                }
+                break;
+#endif
+            case KC_J:  //
+            case KC_V:  //
+            case KC_Z:  //
+            case KC_Q:  // for linger Qu (ironically, need to handle this direclty w/o the macros.)
+                unregister_code16(keycode);
+                linger_key = 0; // make sure nothing lingers
+//                unregister_linger_key();
+                return_state = false; // stop processing this record.
+                break;
+
+#ifndef KEY_OVERRIDE_ENABLE
+/*
+    QMK KEY_OVERRIDE in 14.1 is much larger,
+    and can't integrate semkeys or linger keys,
+    so for now I roll my own here.
+*/
+
+            case KC_LT:    //  < (linger=<|>)
+            case KC_LPRN:  //  ( (linger=(|))
+            case KC_LBRC:  //  [ (linger=[|])
+            case KC_LCBR:  //  { (linger={|})
+                //if (!saved_mods) { //
+                    unregister_linger_key(); // stop lingering
+                    return_state = false; // stop processing this record.
+                //
+                break;
+
+            case KC_DQUO:  // SHIFT = ], ALT=›, ALT+SHIFT=»
+            case KC_QUOT:  // SHIFT = [ (linger=[|]), ALT=‹, ALT+SHIFT=«
+                unregister_linger_key(); // stop lingering
+                unregister_code16(keycode); // may still need to handle this
+                return_state = false; // stop processing this record.
+                break;
+
+            case KC_BSPC:  // make S(KC_BSPC) = KC_DEL; plus word_del L & R
+            case KC_MINS:  // SHIFT = +, ALT=–(n-dash), ALT+SHIFT=±
+            case KC_EQL:   // ALT _
+            case KC_SLSH:  // SHIFT = *, ALT=\, ALT+SHIFT=⁄
+            case KC_HASH:  // SHIFT = @, ALT= , ALT+SHIFT=
+                if (!key_trap) // did we override this earlier?
+                    break; // N: do normal thing
+                unregister_code16(key_trap); //
+                key_trap = 0;  // exit override state.
+                return_state = false; // stop processing this record.
+                break;
+
+#endif // KEY_OVERRIDE_ENABLE
+        } // end switch (keycode) {
+    } // end key up event
+
+    return return_state;  // keep processing record
+}
+
+
diff --git a/moutis_semantickeys.c b/moutis_semantickeys.c
index a68b81f..71d5a3d 100644
--- a/moutis_semantickeys.c
+++ b/moutis_semantickeys.c
@@ -65,10 +65,11 @@ void tap_SemKey(uint16_t semkeycode) {
 const uint16_t SemKeys_t[SemKeys_COUNT - SK_KILL][OS_count] = {
     // Mac, Win, (Phase 3, add others if necessary, expand to multi-key?)
     [SK_KILL - SK_KILL] = {G(A(KC_ESC)),C(A(KC_DEL))}, // "KILL" OR Force quit / ctrl-alt-del
-    [SK_HENK - SK_KILL] = {KC_INT4, KC_INT4}, // 変換
-    [SK_MHEN - SK_KILL] = {KC_INT5, KC_INT5}, // 無変換
+    [SK_HENK - SK_KILL] = {KC_LNG1, KC_INT4}, // 変換
+    [SK_MHEN - SK_KILL] = {KC_LNG2, KC_INT5}, // 無変換
     [SK_HENT - SK_KILL] = {G(KC_ENT),C(KC_ENT)}, // Hard ENTER
     [SK_UNDO - SK_KILL] = {G(KC_Z),C(KC_Z)}, // undo
+    [SK_REDO - SK_KILL] = {G(S(KC_Z)),C(S(KC_Z))}, // Redo
     [SK_CUT  - SK_KILL] = {G(KC_X),C(KC_X)}, // cut
     [SK_COPY - SK_KILL] = {G(KC_C),C(KC_C)}, // copy
     [SK_PSTE - SK_KILL] = {G(KC_V),C(KC_V)}, // paste
@@ -107,6 +108,10 @@ const uint16_t SemKeys_t[SemKeys_COUNT - SK_KILL][OS_count] = {
     [SK_SQUR - SK_KILL] = {S(A(KC_RBRC)),S(A(KC_RBRC))}, // ’ ** Right single quote UNICODE?
     [SK_SDQL - SK_KILL] = {A(KC_LBRC),A(KC_LBRC)}, // ’ ** Left double quote UNICODE?
     [SK_SDQR - SK_KILL] = {A(S(KC_LBRC)),A(S(KC_LBRC))}, // ’ ** Right double quote UNICODE?
+    [SK_FDQL - SK_KILL] = {A(KC_BSLS),A(KC_BSLS)}, //  « Left double French quote UNICODE?
+    [SK_FDQR - SK_KILL] = {S(A(KC_BSLS)),S(A(KC_BSLS))}, //  » Right double French quote UNICODE?
+    [SK_FSQL - SK_KILL] = {S(A(KC_3)),A(KC_LBRC)}, //  ‹ Left single French quote UNICODE?
+    [SK_FSQR - SK_KILL] = {S(A(KC_4)),A(S(KC_LBRC))}, //  › Right single French quote UNICODE?
 
 };
 
@@ -207,6 +212,20 @@ bool process_semkey(uint16_t keycode, const keyrecord_t *record) {
 #endif
                     }
                     break;
+                case SK_HENK: // Japanese
+#ifdef JP_MODE_ENABLE
+                    IS_ENGLISH_MODE = false;
+#endif
+                    tap_SemKey(SK_HENK); // Mac/Win/iOS all different?
+//                    return_state = false; // stop processing this record.
+                    break;
+                case SK_MHEN: // English
+#ifdef JP_MODE_ENABLE
+                    IS_ENGLISH_MODE = true;
+#endif
+                    tap_SemKey(SK_MHEN); // Mac/Win/iOS all different?
+//                    return_state = false; // stop processing this record.
+                    break;
                 default: // default keydown event
                     register_SemKey(keycode);
                     break;
diff --git a/moutis_semantickeys.h b/moutis_semantickeys.h
index 0754ddb..51afb98 100644
--- a/moutis_semantickeys.h
+++ b/moutis_semantickeys.h
@@ -27,10 +27,11 @@
 
 enum my_keycodes {
     SK_KILL = SAFE_RANGE, // SK_KILL must be the first of contiguous block of SKs
-    SK_HENK,
-    SK_MHEN,
+    SK_HENK,  // kana (others)
+    SK_MHEN, // eisuu (others)
     SK_HENT, // Hard-Enter
     SK_UNDO, // undo
+    SK_REDO, // redo
     SK_CUT, // cut
     SK_COPY, // copy
     SK_PSTE, // paste
@@ -71,35 +72,17 @@ enum my_keycodes {
     SK_SQUR, // ’ ** Right single quote UNICODE?
     SK_SDQL, // ’ ** Left double quote UNICODE?
     SK_SDQR, // ’ ** Right double quote UNICODE?
+    SK_FDQL, // ’ « Left double French quote UNICODE?
+    SK_FDQR, // ’ » Right double French quote UNICODE?
+    SK_FSQL, // ’ ‹ Left single French quote UNICODE? S(A(3))
+    SK_FSQR, // ’ › Right single French quote UNICODE? S(A(4))
     SemKeys_COUNT, // end of non-glyph SemKeys
     HD_AdaptKeyToggle,
-//#ifdef L_QWERTY
-     HD_L_QWERTY,
-//#endif
-#ifdef L_HDNUE
-     HD_L_Neu,
-#endif
-#ifdef L_HDBRONZE
-    HD_L_Bronze,  // KC to switch default layout
-#endif
-#ifdef L_HDSILVER
-     HD_L_Silver,
-#endif
-#ifdef L_HDPLATINUM
-     HD_L_Platinum,
-#endif
-#ifdef L_HDGOLD
-     HD_L_Gold,
-#endif
-//#ifdef L_HDTITANIUM
-    HD_L_Titanium,
-//#endif
-#ifdef L_HDRHODIUM
-    HD_L_Rhodium,
-#endif
+    HD_L_QWERTY,
+    HD_L_ALPHA,
 
 
-/* Eventually…these should be handled as SemKeys?
+/* Eventually…these should be handled as SemKeys with BCD Alt-gr?
    HD_aumlt,
    HD_amacr,
    HD_aacut,
diff --git a/mykeyboards/Atreus/atreus_hd_keymap.c b/mykeyboards/Atreus/atreus_hd_keymap.c
index d0f0539..4cd6121 100644
--- a/mykeyboards/Atreus/atreus_hd_keymap.c
+++ b/mykeyboards/Atreus/atreus_hd_keymap.c
@@ -1,20 +1,33 @@
 #include QMK_KEYBOARD_H
 
 
-/* THIS FILE WAS GENERATED!
- *
- * This file was generated by qmk json2c. You may or may not want to
- * edit it directly.
- */
+#ifdef COMBO_ENABLE
+#include HD_combo_def // this has the combo definitions
+#endif
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-	[0] = LAYOUT(KC_J, KC_G, KC_M, KC_P, KC_V, KC_HASH, KC_DOT, KC_SLSH, KC_QUOT, KC_DQUO, LCTL_T(KC_R), LALT_T(KC_S), LGUI_T(KC_N), LSFT_T(KC_T), LT(5,KC_K), LT(4,KC_COMM), RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_C), RCTL_T(KC_I), KC_X, KC_F, KC_L, KC_D, KC_B, TT(5), LT(7,KC_MPLY), KC_MINS, KC_U, KC_O, KC_W, KC_Y, KC_LEFT, KC_RGHT, KC_APP, LT(4,KC_BSPC), LT(6,KC_H), LT(7,KC_MUTE), LT(4,KC_MPLY), LT(3,KC_SPC), LT(6,KC_ENT), LT(7,KC_MPLY), KC_UP, KC_DOWN),
-	[1] = LAYOUT(KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_DQUO, KC_QUOT, LCTL_T(KC_C), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, RALT_T(KC_I), RCTL_T(KC_H), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_Y, KC_W, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LT(6,KC_R), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
-	[2] = LAYOUT(KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LCTL_T(KC_H), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LT(6,KC_R), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
-	[3] = LAYOUT(KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y), KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, LALT(KC_8), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_RO), KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LSA(KC_5), KC_TRNS, KC_TRNS, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, KC_TRNS, KC_TRNS, KC_TRNS, SK_DELWDL, SK_DELWDR, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
-	[4] = LAYOUT(KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_GRV, KC_6, KC_7, KC_8, KC_BSLS, LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_SCLN, RSFT_T(KC_1), RGUI_T(KC_5), RALT_T(KC_9), RCTL_T(KC_SLSH), KC_F1, KC_F2, KC_F3, KC_F4, KC_F15, KC_PAUS, KC_TAB, KC_MINS, KC_2, KC_3, KC_4, KC_EQL, KC_PSCR, KC_LSCR, KC_TRNS, KC_BSPC, KC_ENT, KC_TRNS, KC_DEL, KC_0, KC_DOT, KC_COMM, KC_TRNS, KC_TRNS),
-	[5] = LAYOUT(KC_LNUM, KC_HOME, KC_UP, KC_END, KC_PGUP, KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, LALT_T(KC_TAB), KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, KC_SPC, TG(5), KC_TRNS, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_TRNS, KC_TRNS, KC_TRNS, LGUI_T(KC_BSPC), LSFT_T(KC_ENT), KC_TRNS, KC_DEL, KC_P0, KC_PDOT, KC_C, KC_TRNS, KC_TRNS),
-	[6] = LAYOUT(SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, KC_ESC, KC_TAB, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, SK_HISTPRV, SK_HISTNXT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, SK_HISTPRV, SK_HISTNXT, SK_ZOOMRST, SK_ZOOMOUT, SK_ZOOMIN),
-	[7] = LAYOUT(KC_NO, KC_NO, KC_EJCT, KC_NO, LCA(KC_DEL), SK_KILL, CG_SWAP, AG_SWAP, KC_NO, EE_CLR, KC_MPRV, KC_MNXT, KC_MPLY, KC_VOLU, KC_BRIU, KC_NO, HD_L_Bronze, HD_L_Titanium, HD_L_Rhodium, KC_NO, KC_MRWD, KC_MFFD, KC_MSTP, KC_VOLD, KC_BRID, KC_NO, KC_NO, HD_AdaptKeyToggle, KC_NO, KC_NO, KC_NO, KC_NO, KC_VOLD, KC_VOLU, QK_BOOT, KC_MUTE, KC_MPLY, KC_MUTE, KC_NO, CG_NORM, AG_NORM, KC_NO, KC_MPRV, KC_MNXT)
+	[0] = LAYOUT(
+                 KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P,
+                 RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN),
+                 KC_Z, KC_X, KC_C, KC_V, KC_B, TT(5), LT(7,KC_MPLY), KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH,
+                 KC_LEFT, KC_RGHT, KC_APP, LT(L_MEDIA_KBD,KC_MUTE), LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_MEDIA_KBD,KC_MUTE), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), LT(L_MEDIA_KBD,KC_MPLY), KC_UP, KC_DOWN),
+	[1] = LAYOUT(
+                 HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4,
+                 HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4,
+                 HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, KC_TRNS, KC_TRNS, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4,
+                 KC_TRNS, KC_TRNS, LT(L_MEDIA_KBD,KC_MUTE), HD_LH2, HD_LH1, KC_TRNS, KC_TRNS, HD_RH1, HD_RH2, LT(L_MEDIA_KBD,KC_MPLY), KC_TRNS, KC_TRNS),
+	[2] = LAYOUT(
+                 KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y),
+                 KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS),
+                 KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), KC_TRNS, KC_TRNS, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC,
+                 KC_TRNS, KC_TRNS, KC_TRNS, SK_DELWDL, SK_DELWDR, KC_TRNS, LSA(KC_8), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
+	[3] = LAYOUT(KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_GRV, KC_6, KC_7, KC_8, KC_BSLS, LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_SCLN, RSFT_T(KC_1), RGUI_T(KC_5), RALT_T(KC_9), RCTL_T(KC_SLSH), KC_F1, KC_F2, KC_F3, KC_F4, KC_F15, KC_PAUS, KC_TAB, KC_MINS, KC_2, KC_3, KC_4, KC_EQL, KC_PSCR, KC_LSCR, KC_TRNS, KC_BSPC, KC_ENT, KC_TRNS, KC_DEL, KC_0, KC_DOT, KC_COMM, KC_TRNS, KC_TRNS),
+	[4] = LAYOUT(KC_LNUM, KC_HOME, KC_UP, KC_END, KC_PGUP, KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, LALT_T(KC_TAB), KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, KC_SPC, TG(5), KC_TRNS, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, KC_TRNS, KC_TRNS, KC_TRNS, LGUI_T(KC_BSPC), LSFT_T(KC_ENT), KC_TRNS, KC_DEL, KC_P0, KC_PDOT, KC_C, KC_TRNS, KC_TRNS),
+	[5] = LAYOUT(SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_PSTM, KC_ESC, KC_TAB, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, SK_HISTPRV, SK_HISTNXT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, SK_HISTPRV, SK_HISTNXT, SK_ZOOMRST, SK_ZOOMOUT, SK_ZOOMIN),
+	[6] = LAYOUT(
+                 KC_NO, EE_CLR, AG_SWAP, CG_SWAP, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, KC_NO, SK_ZOOMRST,
+                 HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, KC_NO, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT,
+                 QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, KC_NO, KC_NO, KC_NO, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN,
+                 KC_NO, KC_NO, TG(L_NUMPAD), KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO, KC_NO)
 };
 
diff --git a/mykeyboards/ferris/ferris_hd_keymap.c b/mykeyboards/ferris/ferris_hd_keymap.c
index 2720fda..79a9c4e 100644
--- a/mykeyboards/ferris/ferris_hd_keymap.c
+++ b/mykeyboards/ferris/ferris_hd_keymap.c
@@ -1,19 +1,47 @@
 #include QMK_KEYBOARD_H
 
-
-/* THIS FILE WAS GENERATED!
- *
- * This file was generated by qmk json2c. You may or may not want to
- * edit it directly.
- */
+#ifdef COMBO_ENABLE
+#include HD_combo_def // this has the combo definitions
+#endif
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-	[0] = LAYOUT_split_3x5_2(KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT)),
-	[1] = LAYOUT_split_3x5_2(KC_X, KC_W, KC_M, KC_G, KC_J, KC_HASH, KC_DOT, KC_SLSH, KC_DQUO, KC_QUOT, RCTL_T(KC_S), RALT_T(KC_C), RGUI_T(KC_N), RSFT_T(KC_T), LT(L_NUMPAD,KC_K), LT(L_FN_NUM,KC_COMM), RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_I), RCTL_T(KC_H), KC_F, KC_P, KC_L, KC_D, KC_V, KC_MINS, KC_U, KC_O, KC_Y, KC_B, LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_R), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT)),
-	[2] = LAYOUT_split_3x5_2(KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y), KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS), KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, SK_DELWDL, SK_DELWDR, KC_TRNS, LSA(KC_8)),
-	[3] = LAYOUT_split_3x5_2(KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_GRV, KC_7, KC_8, KC_9, KC_MINS, LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_COMM, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_PPLS), KC_F1, KC_F2, KC_F3, KC_F4, KC_INS, KC_COMM, KC_4, KC_5, KC_6, KC_EQL, KC_TRNS, KC_SCLN, TG(L_NUMPAD), KC_0),
-	[4] = LAYOUT_split_3x5_2(KC_ESC, KC_HOME, KC_UP, KC_PGUP, LT(L_MEDIA_KBD, KC_NUM), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_PAST, RSFT_T(KC_P4), RGUI_T(KC_P5), RALT_T(KC_P6), RCTL_T(KC_PPLS), KC_DEL, KC_END, KC_TAB, KC_PGDN, KC_SPC, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_PENT), LT(L_PUNCT,KC_P0), LT(L_NAV,KC_PDOT)),
-	[5] = LAYOUT_split_3x5_2(SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_FAGN, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, MO(L_MEDIA_KBD), KC_APP, SK_HISTPRV, SK_HISTNXT),
-	[6] = LAYOUT_split_3x5_2(KC_NO, EE_CLR, AG_SWAP, CG_SWAP, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, KC_NO, SK_ZOOMRST, HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_Titanium, KC_VOLU, KC_BRIU, KC_NO, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, KC_NO, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, KC_NO, TG(L_NUMPAD), KC_NO, KC_NO)
+
+    
+    [0] = LAYOUT_split_3x5_2(
+        KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P,
+        RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN),
+        KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH,
+                LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT)),
+    [1] = LAYOUT_split_3x5_2(
+        HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4,
+        HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4,
+        HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4,
+                HD_LH2, HD_LH1, HD_RH1, HD_RH2),
+    [2] = LAYOUT_split_3x5_2(
+        KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y),
+        KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS),
+        KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC,
+                SK_DELWDL, SK_DELWDR, KC_TRNS, LSA(KC_8)),
+    [3] = LAYOUT_split_3x5_2(
+        KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_GRV, KC_7, KC_8, KC_9, KC_MINS,
+        LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_COMM, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_PPLS),
+        KC_F1, KC_F2, KC_F3, KC_F4, KC_INS, KC_COMM, KC_4, KC_5, KC_6, KC_EQL,
+                KC_SCLN, TG(L_NUMPAD), KC_0, KC_DOT),
+    [4] = LAYOUT_split_3x5_2(
+        KC_ESC, KC_HOME, KC_UP, KC_PGUP, LT(L_MEDIA_KBD, KC_NUM), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS,
+        SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_PAST, RSFT_T(KC_P4), RGUI_T(KC_P5), RALT_T(KC_P6),RCTL_T(KC_PPLS),
+        KC_DEL, KC_END, KC_TAB, KC_PGDN, KC_SPC, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL,
+                LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_PENT), LT(L_PUNCT,KC_P0), LT(L_NAV,KC_PDOT)),
+    [5] = LAYOUT_split_3x5_2(
+        SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV,
+        KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT,
+        SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_FAGN, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT,
+                MO(L_MEDIA_KBD), KC_APP, SK_HISTPRV, SK_HISTNXT),
+    [6] = LAYOUT_split_3x5_2(
+        KC_NO, EE_CLR, AG_SWAP, CG_SWAP, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, KC_NO, SK_ZOOMRST,
+        HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, KC_NO, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT,
+        QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, KC_NO, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN,
+                KC_NO, TG(L_NUMPAD), KC_NO, KC_NO)
+
 };
 
diff --git a/mykeyboards/kyria/kyria_hd_keymap.c b/mykeyboards/kyria/kyria_hd_keymap.c
index a6d0cc5..c58eea3 100644
--- a/mykeyboards/kyria/kyria_hd_keymap.c
+++ b/mykeyboards/kyria/kyria_hd_keymap.c
@@ -1,19 +1,24 @@
 #include QMK_KEYBOARD_H
 
 
-/* THIS FILE WAS GENERATED!
- *
- * This file was generated by qmk json2c. You may or may not want to
- * edit it directly.
- */
+#ifdef COMBO_ENABLE
+#include HD_combo_def // this has the combo definitions
+#endif
 
+    
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-	[0] = LAYOUT(SK_COPY, KC_W, KC_G, KC_M, KC_P, KC_J, KC_HASH, KC_DOT, KC_SLSH, KC_QUOT, KC_DQUO, KC_LNG2, SK_PSTE, RCTL_T(KC_C), RALT_T(KC_S), RGUI_T(KC_N), RSFT_T(KC_T), LT(L_NUMPAD,KC_K), LT(L_FN_NUM,KC_COMM), RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_I), RCTL_T(KC_H), KC_LNG1, KC_AMPR, KC_X, KC_F, KC_L, KC_D, KC_V, LT(7,KC_MUTE), LT(5,KC_ESC), LT(5,KC_ESC), LT(7,KC_MPLY), KC_MINS, KC_U, KC_O, KC_Y, KC_B, KC_EQL, LT(6,KC_MUTE), KC_APP, LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_R), LT(4,KC_LNG2), LT(4,KC_LNG1), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), LT(4,KC_TAB), LT(6,KC_MPLY)),
-	[1] = LAYOUT(KC_TRNS, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_TRNS, KC_TRNS, RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), KC_TRNS, KC_TRNS, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LT(L_NAV,KC_SPC), LT(L_PUNCT,KC_LNG1), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS),
-	[2] = LAYOUT(KC_TRNS, KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y), KC_TRNS, KC_TRNS, KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, LSA(KC_5), RALT(KC_1), LSFT_T(KC_PAST), LGUI_T(KC_PEQL), LALT_T(KC_PPLS), LCTL_T(KC_PSLS), KC_TRNS, KC_TRNS, KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, KC_TRNS, KC_VOLD, KC_VOLU, SK_DELWDL, SK_DELWDR, KC_TRNS, LALT(KC_9), KC_TRNS, LSA(KC_8), LSA(KC_9), KC_TRNS),
+    [0] = LAYOUT(SK_COPY, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LNG2,
+                 SK_PSTE, RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), KC_LNG1,
+                 KC_AMPR, KC_Z, KC_X, KC_C, KC_V, KC_B, LT(7,KC_MUTE), LT(5,KC_ESC), LT(5,KC_ESC), LT(7,KC_MPLY), KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_EQL,
+                 LT(6,KC_MUTE), KC_APP, LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(4,KC_LNG2), LT(4,KC_LNG1), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), LT(4,KC_TAB), LT(6,KC_MPLY)),
+    [1] = LAYOUT(KC_TRNS, HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0,   HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4, KC_TRNS,
+                 KC_TRNS, HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0,   HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4, KC_TRNS,
+                 KC_TRNS, HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, LT(7,KC_MUTE), LT(5,KC_ESC), LT(5,KC_ESC), LT(7,KC_MPLY), HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4, KC_TRNS,
+                 KC_TRNS, KC_TRNS, HD_LH2, HD_LH1, LT(L_NAV,KC_SPC), LT(L_PUNCT,KC_LNG1), HD_RH1, HD_RH2, KC_TRNS, KC_TRNS),
+    [2] = LAYOUT(KC_TRNS, KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y), KC_TRNS, KC_TRNS, KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, LSA(KC_5), RALT(KC_1), LSFT_T(KC_PAST), LGUI_T(KC_PEQL), LALT_T(KC_PPLS), LCTL_T(KC_PSLS), KC_TRNS, KC_TRNS, KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, KC_TRNS, KC_VOLD, KC_VOLU, SK_DELWDL, SK_DELWDR, KC_TRNS, LALT(KC_9), KC_TRNS, LSA(KC_8), LSA(KC_9), KC_TRNS),
 	[3] = LAYOUT(RGB_TOG, KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_SLSH, KC_7, KC_8, KC_9, KC_MINS, RGB_MOD, RGB_VAI, LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_ASTR, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_PPLS), RGB_HUI, RGB_VAD, KC_F1, KC_F2, KC_F3, KC_F4, KC_F15, QK_BOOT, KC_TRNS, KC_TRNS, KC_TRNS, KC_COMM, KC_4, KC_5, KC_6, KC_EQL, RGB_HUD, KC_TRNS, KC_TRNS, KC_TRNS, KC_SCLN, LT(L_MEDIA_KBD, KC_MUTE), KC_TRNS, KC_TRNS, KC_0, KC_DOT, SK_ZOOMRST),
 	[4] = LAYOUT(RGB_TOG, TG(L_NUMPAD), KC_HOME, KC_UP, KC_END, KC_PGUP, KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, RGB_MOD, RGB_VAI, LALT_T(KC_TAB), KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, KC_PAST, KC_P4, KC_P5, KC_P6, KC_PPLS, RGB_HUI, RGB_VAD, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, KC_SPC, TG(5), KC_NO, KC_NO, LALT(KC_MINS), KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, RGB_HUD, KC_TRNS, KC_TRNS, LGUI_T(KC_BSPC), LSFT_T(KC_ENT), KC_TRNS, KC_DEL, KC_P0, KC_PDOT, KC_C, SK_ZOOMRST),
 	[5] = LAYOUT(KC_TRNS, SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_PSTM, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_NUM, KC_VOLU, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_TRNS, KC_VOLD, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_FAGN, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, KC_TRNS, KC_BRIU, KC_BRID, LT(L_MEDIA_KBD, KC_ESC), KC_APP, KC_TRNS, SK_ZOOMOUT, SK_HISTPRV, SK_HISTNXT, SK_ZOOMIN, SK_ZOOMRST),
-	[6] = LAYOUT(RGB_TOG, QK_BOOT, EE_CLR, AG_SWAP, CG_SWAP, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, KC_NO, SK_ZOOMRST, RGB_MOD, RGB_VAI, HD_AdaptKeyToggle, KC_NO, HD_L_Bronze, HD_L_Titanium, KC_BRIU, KC_VOLU, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, RGB_SAI, RGB_HUI, RGB_VAD, KC_NO, KC_NO, AG_NORM, CG_NORM, KC_BRID, QK_BOOT, KC_NO, KC_VOLD, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, RGB_SAD, RGB_HUD, KC_NO, KC_NO, KC_PAUS, KC_MPLY, KC_NO, KC_NO, CG_NORM, AG_NORM, KC_NO, KC_NO)
+	[6] = LAYOUT(RGB_TOG, QK_BOOT, EE_CLR, AG_SWAP, CG_SWAP, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, KC_NO, SK_ZOOMRST, RGB_MOD, RGB_VAI, HD_AdaptKeyToggle, KC_NO, HD_L_QWERTY, HD_L_ALPHA, KC_BRIU, KC_VOLU, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, RGB_SAI, RGB_HUI, RGB_VAD, KC_NO, KC_NO, AG_NORM, CG_NORM, KC_BRID, QK_BOOT, KC_NO, KC_VOLD, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, RGB_SAD, RGB_HUD, KC_NO, KC_NO, KC_PAUS, KC_MPLY, KC_NO, KC_NO, CG_NORM, AG_NORM, KC_NO, KC_NO)
 };
 
diff --git a/mykeyboards/rollow/config.h b/mykeyboards/rollow/config.h
index aa531d6..98a4bcf 100644
--- a/mykeyboards/rollow/config.h
+++ b/mykeyboards/rollow/config.h
@@ -7,10 +7,6 @@
 // https://docs.qmk.fm/#/config_options?id=setting-handedness
 #define EE_HANDS
 
-//#ifdef PRODUCT
-//#undef PRODUCT
-//#define PRODUCT   "Rollow HD-Vibranium"
-//#endif
 
 #ifdef ENCODER_ENABLE
     #ifdef ENCODER_RESOLUTION
diff --git a/mykeyboards/rollow/rollow_hd_keymap.c b/mykeyboards/rollow/rollow_hd_keymap.c
index 20646e0..b6132e4 100644
--- a/mykeyboards/rollow/rollow_hd_keymap.c
+++ b/mykeyboards/rollow/rollow_hd_keymap.c
@@ -1,19 +1,44 @@
 #include QMK_KEYBOARD_H
 
-
-/* THIS FILE WAS GENERATED!
- *
- * This file was generated by qmk json2c. You may or may not want to
- * edit it directly.
- */
+#ifdef COMBO_ENABLE
+#include HD_combo_def // this has the combo definitions
+#endif
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-	[0] = LAYOUT_split_3x5_3(KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN), KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, LT(L_MEDIA_KBD,KC_MUTE), LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), LT(L_MEDIA_KBD,KC_MPLY)),
-	[1] = LAYOUT_split_3x5_3(KC_X, KC_W, KC_M, KC_G, KC_J, KC_HASH, KC_DOT, KC_SLSH, KC_DQUO, KC_QUOT, RCTL_T(KC_S), RALT_T(KC_C), RGUI_T(KC_N), RSFT_T(KC_T), LT(L_NUMPAD,KC_K), LT(L_FN_NUM,KC_COMM), RSFT_T(KC_A), RGUI_T(KC_E), RALT_T(KC_I), RCTL_T(KC_H), KC_F, KC_P, KC_L, KC_D, KC_V, KC_MINS, KC_U, KC_O, KC_Y, KC_B, LT(L_MEDIA_KBD,KC_MUTE), LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_R), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), LT(L_MEDIA_KBD,KC_MPLY)),
-	[2] = LAYOUT_split_3x5_3(KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y), KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS), KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC, KC_TRNS, SK_DELWDL, SK_DELWDR, KC_TRNS, LSA(KC_8), KC_TRNS),
-	[3] = LAYOUT_split_3x5_3(KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_GRV, KC_7, KC_8, KC_9, KC_MINS, LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_COMM, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_PPLS), KC_F1, KC_F2, KC_F3, KC_F4, KC_INS, KC_COMM, KC_4, KC_5, KC_6, KC_EQL, KC_TRNS, KC_SCLN, TG(L_NUMPAD), KC_0, KC_DOT, KC_TRNS),
-	[4] = LAYOUT_split_3x5_3(KC_ESC, KC_HOME, KC_UP, KC_PGUP, LT(L_MEDIA_KBD, KC_NUM), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_PAST, RSFT_T(KC_P4), RGUI_T(KC_P5), RALT_T(KC_P6), RCTL_T(KC_PPLS), KC_DEL, KC_END, KC_TAB, KC_PGDN, KC_SPC, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL, TG(L_NUMPAD), LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_PENT), LT(L_PUNCT,KC_P0), LT(L_NAV,KC_PDOT), KC_TRNS),
-	[5] = LAYOUT_split_3x5_3(SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV, KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_FAGN, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT, SK_ZOOMRST, MO(L_MEDIA_KBD), KC_APP, SK_HISTPRV, SK_HISTNXT, SK_ZOOMRST),
-	[6] = LAYOUT_split_3x5_3(KC_NO, EE_CLR, AG_SWAP, CG_SWAP, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, KC_NO, SK_ZOOMRST, HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_Titanium, KC_VOLU, KC_BRIU, KC_NO, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT, QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, KC_NO, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN, KC_NO, KC_NO, TG(L_NUMPAD), KC_NO, KC_NO, KC_NO)
+	[0] = LAYOUT_split_3x5_3(
+        KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P,
+        RCTL_T(KC_A), RALT_T(KC_S), RGUI_T(KC_D), RSFT_T(KC_F), LT(L_NUMPAD,KC_G), LT(L_FN_NUM,KC_H), RSFT_T(KC_J), RGUI_T(KC_K), RALT_T(KC_L), RCTL_T(KC_SCLN),
+        KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH,
+                LT(L_MEDIA_KBD,KC_MUTE), LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_DEL), LT(L_PUNCT,KC_SPC), LT(L_NAV,KC_ENT), LT(L_MEDIA_KBD,KC_MPLY)),
+	[1] = LAYOUT_split_3x5_3(
+        HD_LT4, HD_LT3, HD_LT2, HD_LT1, HD_LT0, HD_RT0, HD_RT1, HD_RT2, HD_RT3, HD_RT4,
+        HD_LM4, HD_LM3, HD_LM2, HD_LM1, HD_LM0, HD_RM0, HD_RM1, HD_RM2, HD_RM3, HD_RM4,
+        HD_LB4, HD_LB3, HD_LB2, HD_LB1, HD_LB0, HD_RB0, HD_RB1, HD_RB2, HD_RB3, HD_RB4,
+                LT(L_MEDIA_KBD,KC_MUTE), HD_LH2, HD_LH1, HD_RH1, HD_RH2, LT(L_MEDIA_KBD,KC_MPLY)),
+	[2] = LAYOUT_split_3x5_3(
+        KC_Z, KC_Q, RALT(KC_5), LALT(KC_7), LSA(KC_7), LALT(KC_4), KC_DLR, A(S(KC_2)), RALT(KC_3), LALT(KC_Y),
+        KC_LT, KC_LBRC, KC_LPRN, KC_LCBR, RSA(KC_5), RALT(KC_1), RSFT_T(KC_PAST), RGUI_T(KC_PEQL), RALT_T(KC_PPLS), RCTL_T(KC_PSLS),
+        KC_GT, KC_RBRC, KC_RPRN, KC_RCBR, LALT(KC_8), KC_UNDS, KC_PIPE, KC_AMPR, KC_CIRC, KC_PERC,
+                KC_TRNS, SK_DELWDL, SK_DELWDR, KC_TRNS, LSA(KC_8), KC_TRNS),
+	[3] = LAYOUT_split_3x5_3(
+        KC_F9, KC_F10, KC_F11, KC_F12, KC_F13, KC_GRV, KC_7, KC_8, KC_9, KC_MINS,
+        LCTL_T(KC_F5), LALT_T(KC_F6), LGUI_T(KC_F7), LSFT_T(KC_F8), KC_F14, KC_COMM, RSFT_T(KC_1), RGUI_T(KC_2), RALT_T(KC_3), RCTL_T(KC_PPLS),
+        KC_F1, KC_F2, KC_F3, KC_F4, KC_INS, KC_COMM, KC_4, KC_5, KC_6, KC_EQL,
+                KC_TRNS, KC_SCLN, TG(L_NUMPAD), KC_0, KC_DOT, KC_TRNS),
+	[4] = LAYOUT_split_3x5_3(
+        KC_ESC, KC_HOME, KC_UP, KC_PGUP, LT(L_MEDIA_KBD, KC_NUM), KC_PSLS, KC_P7, KC_P8, KC_P9, KC_PMNS,
+        SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT, KC_PAST, RSFT_T(KC_P4), RGUI_T(KC_P5), RALT_T(KC_P6),RCTL_T(KC_PPLS),
+        KC_DEL, KC_END, KC_TAB, KC_PGDN, KC_SPC, KC_PCMM, KC_P1, KC_P2, KC_P3, KC_PEQL,
+                TG(L_NUMPAD), LT(L_FN_NUM,KC_BSPC), LT(L_NAV,KC_PENT), LT(L_PUNCT,KC_P0), LT(L_NAV,KC_PDOT), KC_TRNS),
+	[5] = LAYOUT_split_3x5_3(
+        SK_QUIT, SK_CLOZ, SK_SCAP, SK_SCLP, SK_FAGN, SK_DOCBEG, KC_HOME, KC_UP, KC_PGUP, SK_PARAPRV,
+        KC_LCTL, KC_LALT, KC_LGUI, KC_LSFT, SK_FIND, SK_WORDPRV, KC_LEFT, KC_DOWN, KC_RGHT, SK_WORDNXT,
+        SK_UNDO, SK_CUT, SK_COPY, SK_PSTE, SK_FAGN, SK_DOCEND, KC_END, KC_DOWN, KC_PGDN, SK_PARANXT,
+                SK_ZOOMRST, MO(L_MEDIA_KBD), KC_APP, SK_HISTPRV, SK_HISTNXT, SK_ZOOMRST),
+	[6] = LAYOUT_split_3x5_3(
+        KC_NO, EE_CLR, AG_SWAP, CG_SWAP, LCA(KC_DEL), SK_KILL, KC_NUM, KC_EJCT, KC_NO, SK_ZOOMRST,
+        HD_AdaptKeyToggle, HD_L_QWERTY, HD_L_ALPHA, KC_VOLU, KC_BRIU, KC_NO, KC_MPRV, KC_MUTE, KC_MNXT, SK_ZOOMOUT,
+        QK_BOOT, AG_NORM, CG_NORM, KC_VOLD, KC_BRID, KC_NO, KC_MRWD, KC_MPLY, KC_MFFD, SK_ZOOMIN,
+                KC_NO, KC_NO, TG(L_NUMPAD), KC_NO, KC_NO, KC_NO)
 };
 
diff --git a/personalizedmacros.h b/personalizedmacros.h
new file mode 100644
index 0000000..e748523
--- /dev/null
+++ b/personalizedmacros.h
@@ -0,0 +1,23 @@
+//
+//  personalizedmacros.h
+//  
+//
+
+#define At_ComboHeld "alanreiser.com"
+
+#define LeftComboTapE "English "
+#define LeftComboHeldE "End of times in 2020"
+#define LeftComboTapJ "arigatou"
+#define LeftComboHeldJ "yorosiku"
+#define RightComboTapE "Japan "
+#define RightComboHeldE "Japanese "
+#define RightComboTapJ "gozaimasu."
+#define RightComboHeldJ "onegaisimasu."
+
+#define adaptAMINS "Amanda "
+#define adaptBMINS "Bug "
+#define adaptEMINS "Eric "
+#define adaptLMINS "Lauren "
+#define adaptTMINS "Tahlia "
+#define adaptVMINS "Vivian "
+