[Keymap] Reorganization, cleanup and readmes for drashna code (#15617)

19 files changed, 796 insertions, 107 deletions

diff --git a/users/drashna/keyrecords/autocorrection/autocorrection.c b/users/drashna/keyrecords/autocorrection/autocorrection.c
index 7c8c28c674..e561224374 100644
--- a/users/drashna/keyrecords/autocorrection/autocorrection.c
+++ b/users/drashna/keyrecords/autocorrection/autocorrection.c
@@ -1,5 +1,5 @@
 // Copyright 2021 Google LLC
-// Copyright 2022 @filterpaper
+// Copyright 2021 @filterpaper
 // SPDX-License-Identifier: Apache-2.0
 // Original source: https://getreuer.info/posts/keyboards/autocorrection
 
@@ -7,10 +7,15 @@
 #include <string.h>
 
 #if __has_include("autocorrection_data.h")
+#    pragma GCC push_options
+#    pragma GCC optimize("O0")
 #    include "autocorrection_data.h"
 #    if AUTOCORRECTION_MIN_LENGTH < 4
 #        error Minimum Length is too short and may cause overflows
 #    endif
+#    if DICTIONARY_SIZE > SIZE_MAX
+#        error Dictionary size excees maximum size permitted
+#    endif
 
 bool process_autocorrection(uint16_t keycode, keyrecord_t* record) {
     static uint8_t typo_buffer[AUTOCORRECTION_MAX_LENGTH] = {KC_SPC};
@@ -55,11 +60,17 @@ bool process_autocorrection(uint16_t keycode, keyrecord_t* record) {
             }
 #    endif
         default:
+            // Disable autocorrection while a mod other than shift is active.
+            if (((get_mods() | get_oneshot_mods()) & ~MOD_MASK_SHIFT) != 0) {
+                typo_buffer_size = 0;
+                return true;
+            }
             if (!record->event.pressed) {
                 return true;
             }
     }
 
+
     // Subtract buffer for Backspace key, reset for other non-alpha.
     if (!(KC_A <= keycode && keycode <= KC_Z)) {
         if (keycode == KC_BSPC) {
@@ -137,6 +148,7 @@ bool process_autocorrection(uint16_t keycode, keyrecord_t* record) {
     }
     return true;
 }
+#    pragma GCC pop_options
 #else
 #    pragma message "Warning!!! Autocorrect is not corretly setup!"
 bool process_autocorrection(uint16_t keycode, keyrecord_t* record) { return true; }
diff --git a/users/drashna/keyrecords/autocorrection/autocorrection.h b/users/drashna/keyrecords/autocorrection/autocorrection.h
index 57685eb4b5..cea93159ae 100644
--- a/users/drashna/keyrecords/autocorrection/autocorrection.h
+++ b/users/drashna/keyrecords/autocorrection/autocorrection.h
@@ -1,5 +1,5 @@
 // Copyright 2021 Google LLC
-// Copyright 2022 @filterpaper
+// Copyright 2021 @filterpaper
 // SPDX-License-Identifier: Apache-2.0
 // Original source: https://getreuer.info/posts/keyboards/autocorrection
 
diff --git a/users/drashna/keyrecords/autocorrection/make_autocorrection_data.py b/users/drashna/keyrecords/autocorrection/make_autocorrection_data.py
index 27383b8955..54fd9ba594 100755
--- a/users/drashna/keyrecords/autocorrection/make_autocorrection_data.py
+++ b/users/drashna/keyrecords/autocorrection/make_autocorrection_data.py
@@ -252,8 +252,9 @@ def write_generated_code(autocorrections: List[Tuple[str, str]],
                    for typo, correction in autocorrections)),
     f'\n#define AUTOCORRECTION_MIN_LENGTH {len(min_typo)}  // "{min_typo}"\n',
     f'#define AUTOCORRECTION_MAX_LENGTH {len(max_typo)}  // "{max_typo}"\n\n',
-    textwrap.fill('static const uint8_t autocorrection_data[%d] PROGMEM = {%s};' % (
-      len(data), ', '.join(map(str, data))), width=80, subsequent_indent='  '),
+    f'#define DICTIONARY_SIZE {len(data)}\n\n',
+    textwrap.fill('static const uint8_t autocorrection_data[DICTIONARY_SIZE] PROGMEM = {%s};' % (
+      ', '.join(map(str, data))), width=120, subsequent_indent='    '),
     '\n\n'])
 
   with open(file_name, 'wt') as f:
diff --git a/users/drashna/keyrecords/autocorrection/readme.md b/users/drashna/keyrecords/autocorrection/readme.md
new file mode 100644
index 0000000000..d920508793
--- /dev/null
+++ b/users/drashna/keyrecords/autocorrection/readme.md
@@ -0,0 +1,301 @@
+# Autocorrection
+
+This is taken from [Pascal Getreuer's implemenation](https://getreuer.info/posts/keyboards/autocorrection/index.html), with a number of modifications. 
+
+To enabled Autocorrection, add `AUTOCORRECTION_ENABLE = yes` to your `rules.mk` file. 
+
+This is mostly a reproduction of Pascal's docs:
+
+## Overview
+Some words are more prone to typos than others. I have a habit of typo-ing *ouput* and *fitler*. This post describes a rudimentary autocorrection implementation that runs on your keyboard with QMK.
+
+The animation below shows the effect as I type *aparent*. As I press the final t, the autocorrection feature detects the typo and automatically sends keys to correct it:
+
+Example: Autocorrecting *aparent* → apparent.
+
+**Features**:
+* It runs on your keyboard, so it is always active no matter what software.
+* Low resource cost: for an autocorrection dictionary of 70 entries, firmware size cost is 1620 bytes and average CPU cost per key press is about 20 µs.
+* It is case insensitive. It corrects Fitler to Filter and FITLER to FILTER.
+* It works within words. It corrects fitlered, fitlering, and useful for programming, within longer identifiers like DesignButterworthFitle*r.
+
+**Limitations**: Running autocorrection on the keyboard comes with some constraints. It is rudimentary like I said:
+* It is limited to alphabet characters a–z. No accented or Unicode letters; I’m sorry this probably isn’t useful for languages besides English.
+* It does not follow mouse or hotkey driven cursor movement.
+
+## Taking autocorrection for a test drive
+With the above flashed to your keyboard, try for instance typing the misspelled word ouput. The instant you type the final t, the word should be speedily autocorrected to output. As further tests, try becuase and invliad.
+
+Here is the full list of typos corrected using the provided autocorrection_data.h file. : is a special character denoting a word break. See below for how to change the autocorrection dictionary.
+
+```
+:guage        -> gauge
+:the:the:     -> the
+:thier        -> their
+:ture         -> true
+accomodate    -> accommodate
+acommodate    -> accommodate
+aparent       -> apparent
+aparrent      -> apparent
+apparant      -> apparent
+apparrent     -> apparent
+aquire        -> acquire
+becuase       -> because
+cauhgt        -> caught
+cheif         -> chief
+choosen       -> chosen
+cieling       -> ceiling
+collegue      -> colleague
+concensus     -> consensus
+contians      -> contains
+cosnt         -> const
+dervied       -> derived
+fales         -> false
+fasle         -> false
+fitler        -> filter
+flase         -> false
+foward        -> forward
+frequecy      -> frequency
+gaurantee     -> guarantee
+guaratee      -> guarantee
+heigth        -> height
+heirarchy     -> hierarchy
+inclued       -> include
+interator     -> iterator
+intput        -> input
+invliad       -> invalid
+lenght        -> length
+liasion       -> liaison
+libary        -> library
+listner       -> listener
+looses:       -> loses
+looup         -> lookup
+manefist      -> manifest
+namesapce     -> namespace
+namespcae     -> namespace
+occassion     -> occasion
+occured       -> occurred
+ouptut        -> output
+ouput         -> output
+overide       -> override
+postion       -> position
+priviledge    -> privilege
+psuedo        -> pseudo
+recieve       -> receive
+refered       -> referred
+relevent      -> relevant
+repitition    -> repetition
+reuslt        -> result
+retrun        -> return
+retun         -> return
+reutrn        -> return
+saftey        -> safety
+seperate      -> separate
+singed        -> signed
+stirng        -> string
+strign        -> string
+swithc        -> switch
+swtich        -> switch
+thresold      -> threshold
+udpate        -> update
+widht         -> width
+```
+
+## Firmware size and CPU costs
+I am anxiously aware that a keyboard microcontroller has limited resources. So I was sure to measure how much memory and CPU time autocorrection consumes during development. These measurements are for the example autocorrection dictionary as used above, which has 70 entries:
+* **Firmware size**: Autocorrection increases my firmware size by a total of 1620 bytes. Breaking that down, 1104 bytes are for the autocorrection_data array and 516 bytes for the autocorrection code.
+* **CPU time**: On my Elite-C microcontrollers, the average CPU time for process_autocorrection to process an alpha key press is around 20 µs. Consider this a rough order-of-magnitude cost. Processing cost increases (more trie nodes are visited) when recent input is close to a known typo, with the max being when a long typo is matched.
+
+The costs are not free but reasonable. For reference, the firmware size cost for mouse keys is 2124 bytes and the CPU time to process a layer switch is about 70 µs, so autocorrection is cheaper than those things. Of course, the cost scales with the size of the autocorrection dictionary, so keep that in mind if you add a lot more entries.
+
+## How does it work?
+The function process_autocorrection maintains a small buffer of recent key presses. On each key press, it checks whether the buffer ends in a recognized typo, and if so, automatically sends keystrokes to correct it.
+
+The tricky part is how to efficiently check the buffer for typos. We don’t want to spend too much memory or time on storing or searching the typos. A good solution is to represent the typos with a trie data structure. A trie is a tree data structure where each node is a letter, and words are formed by following a path to one of the leaves.
+
+
+An example trie.
+Since we search whether the buffer ends in a typo, we store the trie writing in reverse. The trie is queried starting from the last letter, then second to last letter, and so on, until either a letter doesn’t match or we reach a leaf, meaning a typo was found.
+
+## Changing the autocorrection dictionary
+The file autocorrection_data.h encodes the typos to correct. While you could simply use the version of this file provided above for a practical configuration, you can make your own to personalize the autocorrection to your most troublesome typos:
+
+1. First, create an autocorrection dictionary autocorrection_dict.txt, like
+
+  ```
+:thier        -> their
+fitler        -> filter
+lenght        -> length
+ouput         -> output
+widht         -> width
+```
+  For a practical 70-entry example, see autocorrection_dict.txt. And for a yet larger 400-entry example, see autocorrection_dict_extra.txt.
+
+  The syntax is `typo -> correction`. Typos and corrections are case insensitive, and any whitespace before or after the typo and correction is ignored. The typo must be only the letters a–z, or the special character : representing a word break. The correction may have any characters.
+
+2. Use the make_autocorrection_data.py Python script to process the dictionary
+
+```
+$ python3 make_autocorrection_data.py
+Processed 70 autocorrection entries to table with 1104 bytes.
+```
+The script arranges the entries in autocorrection_dict.txt into a trie and generates autocorrection_data.h with the serialized trie embedded as an array.
+
+3. Finally, recompile and flash your keymap.
+
+The generated C header looks like this:
+
+autocorrection_data.h
+```c
+// Generated code.
+
+#define AUTOCORRECTION_MIN_LENGTH 5  // "cheif"
+#define AUTOCORRECTION_MAX_LENGTH 10  // "accomodate"
+
+static const uint8_t autocorrection_data[1104] PROGMEM = {108, 43, 0, 6,
+  71, 0, 7, 81, 0, 8, 199, 0, 9, 240, 1, 10, 250, 1, 11, 26, 2, 17, 53, 2,
+  18, 190, 2, 19, 202, 2, 21, 212, 2, 22, 20, 3, 23, 67, 3, 28, 16, 4, 0,
+  72, 50, 0, 22, 60, 0, 0, 11, 23, 44, 8, 11, 23, 44, 0, 132, 0, 8, 22, 18,
+  18, 15, 0, 132, 115, 101, 115, 0, 11, 23, 12, 26, 22, 0, 129, 99, 104, 0,
+  68, 94, 0, 8, 106, 0, 15, 174, 0, 21, 187, 0, 0, 12, 15, 25, 17, 12, 0,
+  131, 97, 108, 105, 100, 0, 74, 119, 0, 12, 129, 0, 21, 140, 0, 24, 165,
+  0, 0, 17, 12, 22, 0, 131, 103, 110, 101, 100, 0, 25, 21, 8, 7, 0, 131,
+  105, 118, 101, 100, 0, 72, 147, 0, 24, 156, 0, 0, 9, 8, 21, 0, 129, 114,
+  101, 100, 0, 6, 6, 18, 0, 129, 114, 101, 100, 0, 15, 6, 17, 12, 0, 129,
+  100, 101, 0, 18, 22, 8, 21, 11, 23, 0, 130, 104, 111, 108, 100, 0, 4, 26,
+  18, 9, 0, 131, 114, 119, 97, 114, 100, 0, 68, 233, 0, 6, 246, 0, 7, 4, 1,
+  8, 16, 1, 10, 52, 1, 15, 81, 1, 21, 90, 1, 22, 117, 1, 23, 144, 1, 24,
+  215, 1, 25, 228, 1, 0, 6, 19, 22, 8, 16, 4, 17, 0, 130, 97, 99, 101, 0,
+  19, 4, 22, 8, 16, 4, 17, 0, 131, 112, 97, 99, 101, 0, 12, 21, 8, 25, 18,
+  0, 130, 114, 105, 100, 101, 0, 23, 0, 68, 25, 1, 17, 36, 1, 0, 21, 4, 24,
+  10, 0, 130, 110, 116, 101, 101, 0, 4, 21, 24, 4, 10, 0, 135, 117, 97,
+  114, 97, 110, 116, 101, 101, 0, 68, 59, 1, 7, 69, 1, 0, 24, 10, 44, 0,
+  131, 97, 117, 103, 101, 0, 8, 15, 12, 25, 12, 21, 19, 0, 130, 103, 101,
+  0, 22, 4, 9, 0, 130, 108, 115, 101, 0, 76, 97, 1, 24, 109, 1, 0, 24, 20,
+  4, 0, 132, 99, 113, 117, 105, 114, 101, 0, 23, 44, 0, 130, 114, 117, 101,
+  0, 4, 0, 79, 126, 1, 24, 134, 1, 0, 9, 0, 131, 97, 108, 115, 101, 0, 6,
+  8, 5, 0, 131, 97, 117, 115, 101, 0, 4, 0, 71, 156, 1, 19, 193, 1, 21,
+  203, 1, 0, 18, 16, 0, 80, 166, 1, 18, 181, 1, 0, 18, 6, 4, 0, 135, 99,
+  111, 109, 109, 111, 100, 97, 116, 101, 0, 6, 6, 4, 0, 132, 109, 111, 100,
+  97, 116, 101, 0, 7, 24, 0, 132, 112, 100, 97, 116, 101, 0, 8, 19, 8, 22,
+  0, 132, 97, 114, 97, 116, 101, 0, 10, 8, 15, 15, 18, 6, 0, 130, 97, 103,
+  117, 101, 0, 8, 12, 6, 8, 21, 0, 131, 101, 105, 118, 101, 0, 12, 8, 11,
+  6, 0, 130, 105, 101, 102, 0, 17, 0, 76, 3, 2, 21, 16, 2, 0, 15, 8, 12, 6,
+  0, 133, 101, 105, 108, 105, 110, 103, 0, 12, 23, 22, 0, 131, 114, 105,
+  110, 103, 0, 70, 33, 2, 23, 44, 2, 0, 12, 23, 26, 22, 0, 131, 105, 116,
+  99, 104, 0, 10, 12, 8, 11, 0, 129, 104, 116, 0, 72, 69, 2, 10, 80, 2, 18,
+  89, 2, 21, 156, 2, 24, 167, 2, 0, 22, 18, 18, 11, 6, 0, 131, 115, 101,
+  110, 0, 12, 21, 23, 22, 0, 129, 110, 103, 0, 12, 0, 86, 98, 2, 23, 124,
+  2, 0, 68, 105, 2, 22, 114, 2, 0, 12, 15, 0, 131, 105, 115, 111, 110, 0,
+  4, 6, 6, 18, 0, 131, 105, 111, 110, 0, 76, 131, 2, 22, 146, 2, 0, 23, 12,
+  19, 8, 21, 0, 134, 101, 116, 105, 116, 105, 111, 110, 0, 18, 19, 0, 131,
+  105, 116, 105, 111, 110, 0, 23, 24, 8, 21, 0, 131, 116, 117, 114, 110, 0,
+  85, 174, 2, 23, 183, 2, 0, 23, 8, 21, 0, 130, 117, 114, 110, 0, 8, 21, 0,
+  128, 114, 110, 0, 7, 8, 24, 22, 19, 0, 131, 101, 117, 100, 111, 0, 24,
+  18, 18, 15, 0, 129, 107, 117, 112, 0, 72, 219, 2, 18, 3, 3, 0, 76, 229,
+  2, 15, 238, 2, 17, 248, 2, 0, 11, 23, 44, 0, 130, 101, 105, 114, 0, 23,
+  12, 9, 0, 131, 108, 116, 101, 114, 0, 23, 22, 12, 15, 0, 130, 101, 110,
+  101, 114, 0, 23, 4, 21, 8, 23, 17, 12, 0, 135, 116, 101, 114, 97, 116,
+  111, 114, 0, 72, 30, 3, 17, 38, 3, 24, 51, 3, 0, 15, 4, 9, 0, 129, 115,
+  101, 0, 4, 12, 23, 17, 18, 6, 0, 131, 97, 105, 110, 115, 0, 22, 17, 8, 6,
+  17, 18, 6, 0, 133, 115, 101, 110, 115, 117, 115, 0, 74, 86, 3, 11, 96, 3,
+  15, 118, 3, 17, 129, 3, 22, 218, 3, 24, 232, 3, 0, 11, 24, 4, 6, 0, 130,
+  103, 104, 116, 0, 71, 103, 3, 10, 110, 3, 0, 12, 26, 0, 129, 116, 104, 0,
+  17, 8, 15, 0, 129, 116, 104, 0, 22, 24, 8, 21, 0, 131, 115, 117, 108,
+  116, 0, 68, 139, 3, 8, 150, 3, 22, 210, 3, 0, 21, 4, 19, 19, 4, 0, 130,
+  101, 110, 116, 0, 85, 157, 3, 25, 200, 3, 0, 68, 164, 3, 21, 175, 3, 0,
+  19, 4, 0, 132, 112, 97, 114, 101, 110, 116, 0, 4, 19, 0, 68, 185, 3, 19,
+  193, 3, 0, 133, 112, 97, 114, 101, 110, 116, 0, 4, 0, 131, 101, 110, 116,
+  0, 8, 15, 8, 21, 0, 130, 97, 110, 116, 0, 18, 6, 0, 130, 110, 115, 116,
+  0, 12, 9, 8, 17, 4, 16, 0, 132, 105, 102, 101, 115, 116, 0, 83, 239, 3,
+  23, 6, 4, 0, 87, 246, 3, 24, 254, 3, 0, 17, 12, 0, 131, 112, 117, 116, 0,
+  18, 0, 130, 116, 112, 117, 116, 0, 19, 24, 18, 0, 131, 116, 112, 117,
+  116, 0, 70, 29, 4, 8, 41, 4, 11, 51, 4, 21, 69, 4, 0, 8, 24, 20, 8, 21,
+  9, 0, 129, 110, 99, 121, 0, 23, 9, 4, 22, 0, 130, 101, 116, 121, 0, 6,
+  21, 4, 21, 12, 8, 11, 0, 135, 105, 101, 114, 97, 114, 99, 104, 121, 0, 4,
+  5, 12, 15, 0, 130, 114, 97, 114, 121, 0};
+```
+
+## Troubleshooting
+### Avoiding false triggers
+By default, typos are searched within words, to find typos within longer identifiers like maxFitlerOuput. While this is useful, a consequence is that autocorrection will falsely trigger when a typo happens to be a substring of a correctly-spelled word. For instance, if we had thier -> their as an entry, it would falsely trigger on (correct, though relatively uncommon) words like “wealthier” and “filthier.”
+
+The solution is to set a word break : before and/or after the typo to constrain matching. : matches space, period, comma, underscore, digits, and most other non-alpha characters.
+
+| Text | thier | :thier | thier: | :thier: |
+|------|-------|--------|--------|---------|
+|see thier typo|matches|matches|matches|matches|
+it’s thiers    |matches|matches|no|no|
+wealthier words|matches|no|matches|no|
+
+:thier: is most restrictive, matching only when thier is a whole word.
+
+The make_autocorrection_data.py script makes an effort to check for entries that would false trigger as substrings of correct words. It searches each typo against a dictionary of 25K English words from the english_words Python package, provided it’s installed.
+
+### Overriding autocorrection
+Occasionally you might actually want to type a typo (for instance, while editing autocorrection_dict.txt) without being autocorrected. Here is a way to do that:
+
+1. Begin typing the typo.
+2. Before typing the last letter, press and release the Ctrl or Alt key.
+3. Type the remaining letters.
+
+This works because the autocorrection implementation doesn’t understand hotkeys, so it resets itself whenever a modifier other than shift is held.
+
+Alternatively, the `AUTO_CTN` keycode will toggle autocorrection on and off.
+
+## Closing thoughts
+Based on my own use, an autocorrection dictionary of a few dozen entries is enough to help in day-to-day writing. On the other hand, it is of course far from comprehensively checking that every word is spelled correctly. Keyboard microcontrollers might not have the resources check against a full English dictionary any time soon, but a lot of editors and other software have good integrated spell check features.
+
+I suggest to enable and use spell check in combination with autocorrection:
+* Sublime: Open the View menu and enable “Spell Check.”
+* Eclipse: Open the Window menu, click Preferences, and search for “Spelling.”
+* Vim: Type :set spell, and misspellings will be highlighted. Use ]s to jump to the next misspelled word and z= to get suggested corrections for the word under the cursor. See the :help spell documentation. Vim also has an abbreviations feature that can autocorrect misspellings (see :help abbreviations).
+* Emacs: Use M-x flyspell-mode to enable Flyspell mode in the current buffer. Or for programming, use M-x flyspell-prog-mode to check comments and strings only. See the spelling documentation. There is also an abbreviations feature that can do autocorrection.
+
+Some useful resources:
+
+* Wikipedia has a [large list of common typos](https://en.wikipedia.org/wiki/Wikipedia:Lists_of_common_misspellings/For_machines).
+* EmacsWiki has another [list of typos](https://www.emacswiki.org/emacs/autocorrection_abbrev_defs).
+* You can find data on English word frequencies at https://www.wordfrequency.info/samples.asp.
+
+# Appendix: Trie binary data format
+This section details how the trie is serialized to byte data in autocorrection_data. You don’t need to care about this to use this autocorrection implementation. But I document it for the record in case anyone is interested in modifying the implementation, or just curious how it works.
+
+What I did here is fairly arbitrary, but it is simple to decode and gets the job done.
+
+## Encoding
+All autocorrection data is stored in a single flat array autocorrection_data. Each trie node is associated with a byte offset into this array, where data for that node is encoded, beginning with root at offset 0. There are three kinds of nodes. The highest two bits of the first byte of the node indicate what kind:
+
+* 00 ⇒ chain node: a trie node with a single child.
+* 01 ⇒ branching node: a trie node with multiple children.
+* 10 ⇒ leaf node: a leaf, corresponding to a typo and storing its correction.
+
+An example trie.
+Branching node. Each branch is encoded with one byte for the keycode (KC_A–KC_Z) followed by a link to the child node. Links between nodes are 16-bit byte offsets relative to the beginning of the array, serialized in little endian order.
+
+All branches are serialized this way, one after another, and terminated with a zero byte. As described above, the node is identified as a branch by setting the two high bits of the first byte to 01, done by bitwise ORing the first keycode with 64. keycode. The root node for the above figure would be serialized like:
+
+    +-------+-------+-------+-------+-------+-------+-------+
+    | R|64  |    node 2     |   T   |    node 3     |   0   |
+    +-------+-------+-------+-------+-------+-------+-------+
+
+Chain node. Tries tend to have long chains of single-child nodes, as seen in the example above with f-i-t-l in fitler. So to save space, we use a different format to encode chains than branching nodes. A chain is encoded as a string of keycodes, beginning with the node closest to the root, and terminated with a zero byte. The child of the last node in the chain is encoded immediately after. That child could be either a branching node or a leaf.
+
+In the figure above, the f-i-t-l chain is encoded as
+
+    +-------+-------+-------+-------+-------+
+    |   L   |   T   |   I   |   F   |   0   |
+    +-------+-------+-------+-------+-------+
+If we were to encode this chain using the same format used for branching nodes, we would encode a 16-bit node link with every node, costing 8 more bytes in this example. Across the whole trie, this adds up. Conveniently, we can point to intermediate points in the chain and interpret the bytes in the same way as before. E.g. starting at the i instead of the l, and the subchain has the same format.
+
+Leaf node. A leaf node corresponds to a particular typo and stores data to correct the typo. The leaf begins with a byte for the number of backspaces to type, and is followed by a null-terminated ASCII string of the replacement text. The idea is, after tapping backspace the indicated number of times, we can simply pass this string to QMK’s send_string_P function. For fitler, we need to tap backspace 3 times (not 4, because we catch the typo as the final ‘r’ is pressed) and replace it with lter. To identify the node as a leaf, the two high bits are set to 10 by ORing the backspace count with 128:
+
+    +-------+-------+-------+-------+-------+-------+
+    | 3|128 |  'l'  |  't'  |  'e'  |  'r'  |   0   |
+    +-------+-------+-------+-------+-------+-------+
+## Decoding
+This format is by design decodable with fairly simple logic. A 16-bit variable state represents our current position in the trie, initialized with 0 to start at the root node. Then, for each keycode, test the highest two bits in the byte at state to identify the kind of node.
+
+* 00 ⇒ chain node: If the node’s byte matches the keycode, increment state by one to go to the next byte. If the next byte is zero, increment again to go to the following node.
+* 01 ⇒ branching node: Search the branches for one that matches the keycode, and follow its node link.
+* 10 ⇒ leaf node: a typo has been found! We read its first byte for the number of backspaces to type, then pass its following bytes to send_string_P to type the correction.
diff --git a/users/drashna/keyrecords/caps_word.c b/users/drashna/keyrecords/caps_word.c
index 731568328a..cc9ca93b72 100644
--- a/users/drashna/keyrecords/caps_word.c
+++ b/users/drashna/keyrecords/caps_word.c
@@ -3,13 +3,17 @@
 
 #include "caps_word.h"
 
+#ifndef IS_COMMAND
+#    define IS_COMMAND() (get_mods() == MOD_MASK_SHIFT)
+#endif
+
 bool caps_word_enabled = false;
 bool caps_word_shifted = false;
 
 bool process_caps_word(uint16_t keycode, keyrecord_t* record) {
     if (!caps_word_enabled) {
         // Pressing both shift keys at the same time enables caps word.
-        if (((get_mods() | get_oneshot_mods()) & MOD_MASK_SHIFT) == MOD_MASK_SHIFT) {
+        if (IS_COMMAND()) {
             clear_mods();
             clear_oneshot_mods();
             caps_word_shifted = false;
diff --git a/users/drashna/keyrecords/capwords.md b/users/drashna/keyrecords/capwords.md
new file mode 100644
index 0000000000..1ca01ed853
--- /dev/null
+++ b/users/drashna/keyrecords/capwords.md
@@ -0,0 +1,36 @@
+# Cap Words
+
+This is taken from [Pascal Getreuer's implemenation](https://getreuer.info/posts/keyboards/caps-word/index.html), with a number of modifications. 
+
+To enable Caps Word, add `CAPS_WORD_ENABLE = yes` to your `rules.mk`.
+
+This is mostly a reproduction of Pascal's docs:
+
+## Overview
+
+All-caps identifiers like “MOD_MASK_ALT” are awkward to type.
+
+Caps Lock would be the standard solution to this problem, but it is awkward: it needs a dedicated key to toggle it (an imposition on smaller keyboards), and we need to remember to toggle it off after typing the word. Or with normal shifting, we either perform finger gymnastics or need to stop typing in the middle of the word to release shift with one hand to switch to holding shift with the other hand. In my experience, this is a nuisance especially if your shift keys are mod-taps, as in home row mods.
+
+Caps Word, implemented here, is a modern alternative to Caps Lock:
+
+* Caps Word is activated by pressing the left and right shift keys at the same time. This way you don’t need a dedicated key for using Caps Word.
+* Caps Word automatically disables itself at the end of the word.
+
+**Compatibility**: I’ve tested that this implementation works with one-shot mods and Space Cadet Shift, and it predictably handles key repeating.
+
+Unlike some other QMK Caps Word implementations, this library does not use the Caps Lock (KC_CAPS) keycode. It works even if the OS remaps Caps Lock to Ctrl or something else, as Emacs and Vim users often do.
+
+## Using Caps Word
+With the above flashed to your keyboard:
+
+1. **Activating**: Press and release both left and right shift keys at the same time. If your shift keys are mod-taps, activate Caps Word by holding both shift mod-tap keys until the tapping term, then release them.
+2. Then begin typing to get capitalized letters.
+3. **Disabling**: Caps Word disables itself when the next word breaking key is typed.
+
+If you want to explicitly stop Caps Word, press and release Ctrl or another non-shift modifier or layer key. This also disables Caps Word.
+
+## Explanation
+The code checks the mod bits on each key event, enabling Caps Word when both left and right shifts are active.
+
+While enabled, Caps Word automatically presses and releases left shift (KC_LSFT) as needed so that letters are shifted and other keys are not. The word continues while typing a–z, 0–9, -, _, and backspace. Any other key is considered “word breaking” and disables Caps Word. You can edit the switch statement at the end of the process_caps_word() function to adjust which keys count as word breaking.
diff --git a/users/drashna/keyrecords/keycodes.md b/users/drashna/keyrecords/keycodes.md
new file mode 100644
index 0000000000..348c68e46c
--- /dev/null
+++ b/users/drashna/keyrecords/keycodes.md
@@ -0,0 +1,18 @@
+
+# Custom Keycodes
+
+Keycodes are defined in the `process_record.h` file and need to be included in the keymap.c files, so that they can be used there. 
+
+A bunch of macros are present and are only included on boards that are not the Ergodox EZ or Orthodox, as they are not needed for those boards. 
+
+* `KC_MAKE` - outputs `qmk compile -kb (keyboard) -km (keymap)` and enter, to start compiling the currenct keyboard.  This uses generated variables to always use the current keyboard and keymap.  Will work with any keyboard and any keymap.
+  * If you are holding shift, it will use `qmk flash` instead of `qmk compile`.
+  * If `MAKE_BOOTLOADER` is defined, it will always use `qmk flash` instead of `qmk compile`.
+* `DEFAULT_LAYER_1` ... `DEFAULT_LAYER_4` - This sets layer 0-3 as the default layer, and writes that to eeprom, and plays a chime. 
+* `VRSN`, outputs the keyboard, keymap, commit and date info.  Eg:
+  * `handwired/tractyl_manuform/5x6_right/f411/drashna @ 0.15.9-162-g087d08, Built on: 2021-12-19-21:10:26`
+*  `KC_DIABLO_CLEAR` - clears the diablo tapdance status.
+* `KC_CCCV` - Copy on hold, paste on tap.
+* `KEYLOCK` - This unloads the host driver, and prevents any data from being sent to the host. Hitting it again loads the driver, back. 
+* `REBOOT` - Uses watchdog timer on AVR, and `NVIC_SystemReset()` on ChibiOS to reset the board, without jumping to the bootloader.
+* `EEP_RST` - Overrides the default behavior, disables EEPROM (which will trigger a reset on init), and reboots the keyboard as per `REBOOT` keycode. 
diff --git a/users/drashna/keyrecords/process_records.c b/users/drashna/keyrecords/process_records.c
index c7d4a925b0..f49ac6ef64 100644
--- a/users/drashna/keyrecords/process_records.c
+++ b/users/drashna/keyrecords/process_records.c
@@ -1,18 +1,5 @@
-/* Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
+// Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "drashna.h"
 #include "version.h"
@@ -22,6 +9,9 @@
 #ifdef AUTOCORRECTION_ENABLE
 #    include "autocorrection/autocorrection.h"
 #endif
+#ifdef __AVR__
+#include <avr/wdt.h>
+#endif
 
 uint16_t copy_paste_timer;
 bool     host_driver_disabled = false;
@@ -212,6 +202,28 @@ bool                       process_record_user(uint16_t keycode, keyrecord_t *re
             }
             break;
         }
+        case EEP_RST:
+            if (record->event.pressed) {
+                eeconfig_disable();
+                shutdown_user();
+#ifdef __AVR__
+                wdt_enable(WDTO_250MS);
+#else
+                NVIC_SystemReset();
+#endif
+            }
+            return false;
+        case REBOOT:
+            if (record->event.pressed) {
+                shutdown_user();
+#ifdef __AVR__
+                wdt_enable(WDTO_250MS);
+#else
+                NVIC_SystemReset();
+#endif
+            }
+            return false;
+
     }
     return true;
 }
diff --git a/users/drashna/keyrecords/process_records.h b/users/drashna/keyrecords/process_records.h
index df506b3647..d7a81d4607 100644
--- a/users/drashna/keyrecords/process_records.h
+++ b/users/drashna/keyrecords/process_records.h
@@ -1,18 +1,5 @@
-/* Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
+// Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 #include "drashna.h"
@@ -58,6 +45,7 @@ enum userspace_custom_keycodes {
     KC_ZALGO,
     KC_ACCEL,
     AUTO_CTN,                                 // Toggle Autocorrect status
+    REBOOT,
     NEW_SAFE_RANGE                            // use "NEWPLACEHOLDER for keymap specific codes
 };
 
@@ -66,7 +54,6 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record);
 void post_process_record_keymap(uint16_t keycode, keyrecord_t *record);
 #ifdef CUSTOM_UNICODE_ENABLE
 bool process_record_unicode(uint16_t keycode, keyrecord_t *record);
-void matrix_init_unicode(void);
 #endif
 
 #define LOWER     MO(_LOWER)
@@ -140,3 +127,21 @@ void matrix_init_unicode(void);
 #define ALT_APP ALT_T(KC_APP)
 
 #define MG_NKRO MAGIC_TOGGLE_NKRO
+
+
+/*
+Custom Keycodes for Diablo 3 layer
+But since TD() doesn't work when tap dance is disabled
+We use custom codes here, so we can substitute the right stuff
+*/
+#ifdef TAP_DANCE_ENABLE
+#    define KC_D3_1 TD(TD_D3_1)
+#    define KC_D3_2 TD(TD_D3_2)
+#    define KC_D3_3 TD(TD_D3_3)
+#    define KC_D3_4 TD(TD_D3_4)
+#else  // TAP_DANCE_ENABLE
+#    define KC_D3_1 KC_1
+#    define KC_D3_2 KC_2
+#    define KC_D3_3 KC_3
+#    define KC_D3_4 KC_4
+#endif  // TAP_DANCE_ENABLE
diff --git a/users/drashna/keyrecords/readme.md b/users/drashna/keyrecords/readme.md
new file mode 100644
index 0000000000..5f708f9edf
--- /dev/null
+++ b/users/drashna/keyrecords/readme.md
@@ -0,0 +1,9 @@
+# Keycode handling and interception
+
+  * [Autocorrection](autocorrection/readme.md)
+  * [Cap Words](capwords.md)
+  * [Diablo Tap Dancing](tap_dance.md)
+  * [Keymap Wrappers](wrappers.md)
+  * [Secret Macros](secrets.md)
+  * [Custom Keycodes](keycodes.md)
+  * [Unicode Input](unicode.md)
diff --git a/users/drashna/keyrecords/secrets.md b/users/drashna/keyrecords/secrets.md
new file mode 100644
index 0000000000..a9408dc2ef
--- /dev/null
+++ b/users/drashna/keyrecords/secrets.md
@@ -0,0 +1,123 @@
+# Secret Macros
+
+With help from gitter and Colinta, this adds the ability to add hidden macros from other users.  
+
+First, I have several files that are hidden/excluded from Git/GitHub.  These contain everything needed for the macros. To hide these files, open `.git/info/exclude` and add `secrets.c` and `secrets.h` to that file, below the comments.
+
+And this requires `KC_SECRET_1` through `KC_SECRET_5` to be added in your keycode enum (usually in your `<name>.h` file) the keycodes for the new macros. 
+
+## Git Exclusion 
+
+To prevent `git` from seeing, or committing the secret files, you can exclude them.   What's the point of having secrets if they're posted on GitHub for everyone to see!?!
+
+You can do this with the `.git/info/exclude` file, so that it's only ignored locally.  Unfortunately, that means it's not consistently handled on each system. 
+
+However, if you create a `.gitignore` file in the same folder, you keep things consistent between every system that the code is checked out on. 
+
+```c
+secrets.c
+secrets.h
+```
+
+## secrets.c
+
+Here is the magic. This handles including the "secrets", and adding the custom macros to send them. 
+
+```c
+#include "drashna.h"  // replace with your keymap's "h" file, or whatever file stores the keycodes
+
+#if (__has_include("secrets.h") && !defined(NO_SECRETS))
+#include "secrets.h"
+#else
+// `PROGMEM const char secret[][x]` may work better, but it takes up more space in the firmware
+// And I'm not familiar enough to know which is better or why...
+static const char * const secret[] = {
+  "test1",
+  "test2",
+  "test3",
+  "test4",
+  "test5"
+};
+#endif
+
+bool process_record_secrets(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case KC_SECRET_1 ... KC_SECRET_5: // Secrets!  Externally defined strings, not stored in repo
+      if (!record->event.pressed) {
+        clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED);
+        send_string_with_delay(secret[keycode - KC_SECRET_1], MACRO_TIMER);
+      }
+      return false;
+      break;
+  }
+  return true;
+}
+```
+
+## secrets.h
+
+Now, for the actual secrets!  The file needs to look like 
+
+```c
+static const char *  secrets[] = {
+  "secret1",
+  "secret2",
+  "secret3",
+  "secret4",
+  "secret5"
+};
+```
+
+Replacing the strings with the codes that you need.
+
+## Process Record
+
+In whichever file you have your `process_record_*` function in, you will want to add this to the top:
+
+```c
+__attribute__ ((weak))
+bool process_record_secrets(uint16_t keycode, keyrecord_t *record) {
+  return true;
+}
+```
+
+This is so that the function can be called here, and replaced in the `secrets.c` file, and so it won't error out if it doesn't exist.
+
+And then, in the `process_record_user` function, assuming you have `return process_record_keymap(keycode, record)` here,  you'll want to replace the "final" return with the following. Otherwise, you want to replace the `return true;` with `return process_record_secrets(keycode, record);`
+
+```c
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+    // your existing macro code here. 
+    return process_record_keymap(keycode, record) && process_record_secrets(keycode, record);
+}
+```
+
+## rules.mk
+
+Here, you want your `/users/<name>/rules.mk` file to "detect" the existence of the `secrets.c` file, and only add it if the file exists.  
+
+Additionally, to ensure that it's not added or processed in any way, it checks to see if `NO_SECRETS` is set. This way, if you run `make keyboard:name NO_SECRETS=yes`, it will remove the feature altogether. 
+
+```make
+ifneq ($(strip $(NO_SECRETS)), yes)
+    ifneq ("$(wildcard $(USER_PATH)/secrets.c)","")
+        SRC += secrets.c
+    endif
+endif
+```
+
+Alternately, if you want to make sure that you can disable the function without messing with the file, you need to add this to your `/users/<name>/rules.mk`, so that it catches the flag:
+
+```make
+ifneq ("$(wildcard $(USER_PATH)/secrets.c)","")
+  SRC += secrets.c
+endif
+
+ifeq ($(strip $(NO_SECRETS)), yes)
+    OPT_DEFS += -DNO_SECRETS
+endif
+```
+
+## Extras
+
+Additionally, because this file isn't present in the repo at all, you could add additional functionality that nobody else will see. 
diff --git a/users/drashna/keyrecords/tap_dance.md b/users/drashna/keyrecords/tap_dance.md
new file mode 100644
index 0000000000..0bf67cbd5a
--- /dev/null
+++ b/users/drashna/keyrecords/tap_dance.md
@@ -0,0 +1,121 @@
+# Diablo Tap Dances 
+
+My [Tap Dance](tap_dances.c) file includes the tap dance declarations, and everything needed for them. 
+
+To disable, add `CUSTOM_TAP_DANCE = no` to your `rules.mk`.
+
+This is used for making Diablo 3 much easier to plan, especially at high rift levels. 
+
+This works by using Tap Dances.  The taps don't actually "do anything". Instead, it sets up the interval for how often to send specific keypresses.  As you can tell, this makes automating things very easy. 
+
+For critics that think this is cheating, just search "[diablo 3 num lock auto cast](http://lmgtfy.com/?q=diablo+3+numlock+autocast)".  This is just a simpler method, that doesn't require a numpad. 
+
+
+## Custom Tap Dance Type 
+The real fun here is that the tap dances use a custom defined Tap Dance type: 
+
+```c 
+#define ACTION_TAP_DANCE_DIABLO(index, keycode) {  \
+    .fn = { NULL, (void *)diablo_tapdance_master, NULL }, \
+    .user_data = (void *)&((diable_keys_t) { index, keycode }),  \
+  }
+```
+This lets me set an index and keycode for the tap dance.  This isn't the cool part yet, but this allows for the really cool stuff.  
+
+The Index is needed because I don't know how to handle it otherwise. 
+
+## The Actual Dances
+
+These are the custom defined dances that I'm using.  It sets up everything for later, using the above custom dance type. 
+
+```c
+//Tap Dance Definitions, sets the index and the keycode.
+qk_tap_dance_action_t tap_dance_actions[] = {
+    // tap once to disable, and more to enable timed micros
+    [TD_D3_1] = ACTION_TAP_DANCE_DIABLO(0, KC_1),
+    [TD_D3_2] = ACTION_TAP_DANCE_DIABLO(1, KC_2),
+    [TD_D3_3] = ACTION_TAP_DANCE_DIABLO(2, KC_3),
+    [TD_D3_4] = ACTION_TAP_DANCE_DIABLO(3, KC_4),
+};
+```
+
+## Custom Data Structures
+
+First, to get this all working, there are a couple of things that need to be set up.  In a header file (or you could put it into the keymap), you need to create a couple of custom structures: 
+
+```c
+typedef struct {
+    uint16_t timer;
+    uint8_t key_interval;
+    uint8_t keycode;
+} diablo_timer_t;
+
+typedef struct {
+  uint8_t index;
+  uint8_t keycode;
+} diable_keys_t;
+```
+
+The first structure is for tracking each key that is being used. The second is to pass data from the Tap Dance action array to the actual function that we will need.
+
+
+## Custom Arrays
+
+To facilitate things, you will need a couple of arrays in your `c` file.
+
+```c
+//define diablo macro timer variables
+diablo_timer_t diablo_timer[4];
+
+// Set the default intervals.  Always start with 0 so that it will disable on first hit.
+// Otherwise, you will need to hit a bunch of times, or hit the "clear" command
+uint8_t diablo_times[] = { 0, 1, 3, 5, 10, 30 };
+```
+
+The first one (`diablo_timer`) is what keeps track of the timer used for the keys, the interval that it uses, and the actual keycode.  This makes managing it a lot easier.  
+
+The second array is a list of predefined intervals, in seconds.  You can add more here, or remove entries.  It doesn't matter how long the array is, as this is computed automatically. 
+
+## The Magic - Part 1: Master function
+
+The first part of the magic here is the `diablo_tapdance_master` function.  The Tap Dance feature calls this function, directly, and passes some data to the function.  Namely, it passes the array of the index and the keycode (`diablo_keys_t` from above).  This sets the keycode and the interval for the specific index of `diabolo_timer` based on the number of taps. If you hit it more than the number of items in the array, then it zeroes out the interval, disabling it.  
+
+```c
+// Cycle through the times for the macro, starting at 0, for disabled.
+void diablo_tapdance_master(qk_tap_dance_state_t *state, void *user_data) {
+    diable_keys_t *diablo_keys = (diable_keys_t *)user_data;
+    // Sets the keycode based on the index
+    diablo_timer[diablo_keys->index].keycode = diablo_keys->keycode;
+
+    // if the tapdance is hit more than the number of elemints in the array, reset
+    if (state->count >= (sizeof(diablo_times) / sizeof(uint8_t) ) ) {
+        diablo_timer[diablo_keys->index].key_interval = 0;
+        reset_tap_dance(state);
+    }  else { // else set the interval (tapdance count starts at 1, array starts at 0, so offset by one)
+        diablo_timer[diablo_keys->index].key_interval = diablo_times[state->count - 1];
+    }
+}
+```
+
+## The Magic - Part 2: The Coup de Grace
+
+The real core here is the `run_diablo_macro_check()` function.  You need to call this from `matrix_scan_user`, as this handles the timer check.  
+
+Specifically, it runs a check for each index of the timer.  It checks to see if it's enabled, and if enough time has passed. If enough time has passed, it resets the timer, and will tap the keycode that you set for that index, but only if the Diablo layer is enabled.  
+
+```c
+// Checks each of the 4 timers/keys to see if enough time has elapsed
+void run_diablo_macro_check(void) {
+    for (uint8_t index = 0; index < NUM_OF_DIABLO_KEYS; index++) {
+        // if key_interval is 0, it's disabled, so only run if it's set.  If it's set, check the timer.
+        if ( diablo_timer[index].key_interval && timer_elapsed( diablo_timer[index].timer ) > ( diablo_timer[index].key_interval * 1000 ) ) {
+            // reset the timer, since enough time has passed
+            diablo_timer[index].timer = timer_read();
+            // send keycode ONLY if we're on the diablo layer.
+            if (IS_LAYER_ON(_DIABLO)) {
+                tap_code(diablo_timer[index].keycode);
+            }
+        }
+    }
+}
+```
diff --git a/users/drashna/keyrecords/tap_dances.c b/users/drashna/keyrecords/tap_dances.c
index 01873489d8..63eb0c3348 100644
--- a/users/drashna/keyrecords/tap_dances.c
+++ b/users/drashna/keyrecords/tap_dances.c
@@ -1,18 +1,5 @@
-/* Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
+// Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "tap_dances.h"
 
diff --git a/users/drashna/keyrecords/tap_dances.h b/users/drashna/keyrecords/tap_dances.h
index 81e462ce29..d9baedc867 100644
--- a/users/drashna/keyrecords/tap_dances.h
+++ b/users/drashna/keyrecords/tap_dances.h
@@ -1,18 +1,5 @@
-/* Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
+// Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 #include "drashna.h"
diff --git a/users/drashna/keyrecords/tapping.c b/users/drashna/keyrecords/tapping.c
new file mode 100644
index 0000000000..9c4892b33d
--- /dev/null
+++ b/users/drashna/keyrecords/tapping.c
@@ -0,0 +1,64 @@
+// Copyright 2021 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "drashna.h"
+
+__attribute__((weak)) uint16_t get_tapping_term(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+        case BK_LWER:
+            return TAPPING_TERM + 25;
+        default:
+            return TAPPING_TERM;
+    }
+}
+
+__attribute__((weak)) bool get_permissive_hold(uint16_t keycode, keyrecord_t *record) {
+    // Immediately select the hold action when another key is tapped:
+    // return true;
+    // Do not select the hold action when another key is tapped.
+    // return false;
+    switch (keycode) {
+        default:
+            return false;
+    }
+}
+
+__attribute__((weak)) bool get_hold_on_other_key_press(uint16_t keycode, keyrecord_t *record) {
+    // Immediately select the hold action when another key is pressed.
+    // return true;
+    // Do not select the hold action when another key is pressed.
+    // return false;
+    switch (keycode) {
+        case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
+            return true;
+        default:
+            return false;
+    }
+}
+
+__attribute__((weak)) bool get_ignore_mod_tap_interrupt(uint16_t keycode, keyrecord_t *record) {
+    // Do not force the mod-tap key press to be handled as a modifier
+    // if any other key was pressed while the mod-tap key is held down.
+    // return true;
+    // Force the mod-tap key press to be handled as a modifier if any
+    // other key was pressed while the mod-tap key is held down.
+    // return false;
+    switch (keycode) {
+        default:
+            return true;
+    }
+}
+
+__attribute__((weak)) bool get_tapping_force_hold(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+        default:
+            return false;
+    }
+}
+
+__attribute__((weak)) bool get_retro_tapping(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+        default:
+            return false;
+    }
+}
diff --git a/users/drashna/keyrecords/unicode.c b/users/drashna/keyrecords/unicode.c
index 88df2c9df9..4010b9c1c6 100644
--- a/users/drashna/keyrecords/unicode.c
+++ b/users/drashna/keyrecords/unicode.c
@@ -1,34 +1,13 @@
-/* Copyright 2020 @ridingqwerty
- * Copyright 2020 @tzarc
- * Copyright 2021 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
+// Copyright 2020 @ridingqwerty
+// Copyright 2020 @tzarc
+// Copyright 2021 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
+// SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "drashna.h"
 #include "process_unicode_common.h"
 
 uint16_t typing_mode;
 
-void tap_code16_nomods(uint8_t kc) {
-    uint8_t temp_mod = get_mods();
-    clear_mods();
-    clear_oneshot_mods();
-    tap_code16(kc);
-    set_mods(temp_mod);
-}
-
 void tap_unicode_glyph_nomods(uint32_t glyph) {
     uint8_t temp_mod = get_mods();
     clear_mods();
@@ -188,6 +167,7 @@ bool process_record_aussie(uint16_t keycode, keyrecord_t *record) {
 bool process_record_zalgo(uint16_t keycode, keyrecord_t *record) {
     if ((KC_A <= keycode) && (keycode <= KC_0)) {
         if (record->event.pressed) {
+
             tap_code16_nomods(keycode);
 
             int number = (rand() % (8 + 1 - 2)) + 2;
@@ -247,9 +227,12 @@ bool process_record_unicode(uint16_t keycode, keyrecord_t *record) {
                 }
             }
             break;
+    }
 
-            break;
+    if (((get_mods() | get_oneshot_mods()) & ~MOD_MASK_SHIFT) != 0) {
+        return true;
     }
+
     if (((keycode >= QK_MOD_TAP && keycode <= QK_MOD_TAP_MAX) || (keycode >= QK_LAYER_TAP && keycode <= QK_LAYER_TAP_MAX)) && record->tap.count) {
         keycode &= 0xFF;
     }
diff --git a/users/drashna/keyrecords/unicode.md b/users/drashna/keyrecords/unicode.md
new file mode 100644
index 0000000000..1b3f696a82
--- /dev/null
+++ b/users/drashna/keyrecords/unicode.md
@@ -0,0 +1,27 @@
+# Custom Unicode
+
+To disable, add `CUSTOM_UNICODE_ENABLE = no` to the keymap's `rules.mk`.  
+
+This disables all of the various implementations of unicode, enables the common unicode core, and allows usage. 
+
+In addition to a number of unicode keycodes: 
+
+* `UC_FLIP` - `(ノಠ痊ಠ)ノ彡┻━┻`
+* `UC_TABL` - `┬─┬ノ( º _ ºノ)`
+* `UC_SHRG` - `¯\_(ツ)_/¯`
+* `UC_DISA` -  `ಠ_ಠ`
+* `UC_IRNY` - `⸮`
+* `UC_CLUE` - `‽`
+
+There are a number of unicode typing modes. This replaces the normal alpha keys with special unicodes. 
+
+* `KC_WIDE` - ｔｈｉｓ ｉｓ ｗｉｄｅ ｍｏｄｅ
+* `KC_SCRIPT` - 𝓽𝓱𝓲𝓼 𝓲𝓼 𝓼𝓬𝓻𝓲𝓹𝓽 𝓶𝓸𝓭𝓮
+* `KC_BLOCKS` - 🆃🅷🅸🆂 🅸🆂 🅱🅻🅾🅲🅺 🅼🅾🅳🅴
+* `KC_REGIONAL` - 🇹‌‌🇭‌‌🇮‌‌🇸‌‌ ‌‌🇮‌‌🇸‌‌ ‌‌🇷‌‌🇪‌‌🇬‌‌🇮‌‌🇴‌‌🇳‌‌🇦‌‌🇱‌‌ ‌‌🇲‌‌🇴‌‌🇩‌‌🇪‌‌
+* `KC_AUSSIE` - ǝpoɯ ǝᴉssnɐ sᴉ sᴉɥʇ
+* `KC_ZALGO` - t̨͕͙̺͍͐̾ĥ̻ï̳̻̗̜͔ͦs͎̠͈͓͗̀ i̶̫ͭ̆s̛̫̻̜̝͑͡ z̩͈̠͗a͚̜̓͜l͈̟g͋͢͝ò͚ͥ͘͡͞ ḿ̴̡̻̼̔ͪò͔̭̿ͪ̍ḏ̻̊̄̈e̳͕̤ͣͯ
+* `KC_NOMODE` - this is the normal typing mode with no unicode glyphs
+
+
+Credit goes to ridingqwerty and tzarc for the unicode typing modes. 
diff --git a/users/drashna/keyrecords/wrappers.h b/users/drashna/keyrecords/wrappers.h
index c1ae815579..cb8dc6189a 100644
--- a/users/drashna/keyrecords/wrappers.h
+++ b/users/drashna/keyrecords/wrappers.h
@@ -1,18 +1,6 @@
-/* Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
+// Copyright 2020 Christopher Courtney, aka Drashna Jael're  (@drashna) <drashna@live.com>
+// Copyright 2020 @jola5
+// SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 #include "drashna.h"
diff --git a/users/drashna/keyrecords/wrappers.md b/users/drashna/keyrecords/wrappers.md
new file mode 100644
index 0000000000..fd62ff1609
--- /dev/null
+++ b/users/drashna/keyrecords/wrappers.md
@@ -0,0 +1,11 @@
+## Keyboard Layout Templates
+
+This borrows from @jola5's "Not quite neo" code.  This allows me to maintain blocks of keymaps in the userspace, so that I can modify the userspace, and this is reflected in all of the keyboards that use it, at once.
+
+This makes adding tap/hold mods, or other special keycodes or functions to all keyboards super easy, as it's done to all of them at once. 
+
+The caveat here is that the keymap needs a processor/wrapper, as it doesn't like the substitutions.  However, this is as simple as just pushing it through a define. For instance:
+
+`#define LAYOUT_ergodox_wrapper(...)   LAYOUT_ergodox(__VA_ARGS__)`
+
+Once that's been done and you've switched the keymaps to use the "wrapper", it will read the substitution blocks just fine.