Revert "Merge branch 'master' of https://github.com/mogranjm/qmk_firmware"

This reverts commit a45f264ada, reversing changes made to 62349c3341.
2024-11-29 06:30:17 +00:00 · 2017-10-27 17:39:52 +11:00 · 2017-10-27 17:39:52 +11:00 · eae54fb3be
commit eae54fb3be
parent a45f264ada
343 changed files with 1406 additions and 11792 deletions
--- a/.gitignore
+++ b/.gitignore
@ -21,7 +21,6 @@ build/
 quantum/version.h
 .idea/
 CMakeLists.txt
 cmake-build-debug
 .DS_STORE
 /util/wsl_downloaded
 /util/win_downloaded
--- a/.travis.yml
+++ b/.travis.yml
@ -11,7 +11,7 @@ env:
  global:
  - secure: vBTSL34BDPxDilKUuTXqU4CJ26Pv5hogD2nghatkxSQkI1/jbdnLj/DQdPUrMJFDIY6TK3AltsBx72MaMsLQ1JO/Ou24IeHINHXzUC1FlS9yQa48cpxnhX5kzXNyGs3oa0qaFbvnr7RgYRWtmD52n4bIZuSuW+xpBv05x2OCizdT2ZonH33nATaHGFasxROm4qYZ241VfzcUv766V6RVHgL4x9V08warugs+RENVkfzxxwhk3NmkrISabze0gSVJLHBPHxroZC6EUcf/ocobcuDrCwFqtEt90i7pNIAFUE7gZsN2uE75LmpzAWin21G7lLPcPL2k4FJVd8an1HiP2WmscJU6U89fOfMb2viObnKcCzebozBCmKGtHEuXZo9FcReOx49AnQSpmESJGs+q2dL/FApkTjQiyT4J6O5dJpoww0/r57Wx0cmmqjETKBb5rSgXM51Etk3wO09mvcPHsEwrT7qH8r9XWdyCDoEn7FCLX3/LYnf/D4SmZ633YPl5gv3v9XEwxR5+04akjgnvWDSNIaDbWBdxHNb7l4pMc+WR1bwCyMyA7KXj0RrftEGOrm9ZRLe6BkbT4cycA+j77nbPOMcyZChliV9pPQos+4TOJoTzcK2L8yWVoY409aDNVuAjdP6Yum0R2maBGl/etLmIMpJC35C5/lZ+dUNjJAM=
 before_install:
-  - wget http://www.atmel.com/images/avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz || wget http://qmk.fm/avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz
+  - wget http://www.atmel.com/images/avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz
 install:
  - tar -zxf avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz
  - export PATH="$PATH:$TRAVIS_BUILD_DIR/avr8-gnu-toolchain-linux_x86_64/bin"
--- a/3
+++ b/3
@ -304,8 +304,7 @@ define PARSE_KEYBOARD
    KEYMAPS += $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_3)/keymaps/*/.)))
    KEYMAPS += $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_4)/keymaps/*/.)))
    KEYMAPS += $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_5)/keymaps/*/.)))
-    # this might be needed, but in a different form
+    KEYMAPS := $$(sort $$(filter-out $$(KEYBOARD_FOLDER_1) $$(KEYBOARD_FOLDER_2) \
    #KEYMAPS := $$(sort $$(filter-out $$(KEYBOARD_FOLDER_1) $$(KEYBOARD_FOLDER_2) \
        $$(KEYBOARD_FOLDER_3) $$(KEYBOARD_FOLDER_4) $$(KEYBOARD_FOLDER_5), $$(KEYMAPS)))
    KEYBOARD_LAYOUTS :=
--- a/build_keyboard.mk
+++ b/build_keyboard.mk
@ -183,10 +183,6 @@ else
    # this state should never be reached
 endif
 # User space stuff
 USER_PATH := users/$(KEYMAP)
 -include $(USER_PATH)/rules.mk
 # Object files directory
 #     To put object files in current directory, use a dot (.), do NOT make
 #     this an empty or blank macro!
@ -208,7 +204,6 @@ SRC += $(KEYBOARD_SRC) \
 VPATH += $(KEYMAP_PATH)
 VPATH += $(KEYBOARD_PATHS)
 VPATH += $(COMMON_VPATH)
 VPATH += $(USER_PATH)
 include common_features.mk
 include $(TMK_PATH)/protocol.mk
--- a/docs/_summary.md
+++ b/docs/_summary.md
@ -12,61 +12,56 @@
  * [Debugging/Troubleshooting QMK](faq_debug.md)
  * [Keymap](faq_keymap.md)
 * [Hardware](hardware.md)
  * [Keyboard Guidelines](hardware_keyboard_guidelines.md)
  * [AVR Processors](hardware_avr.md)
  * ARM Processors (TBD)
  * [Drivers](hardware_drivers.md)
 * [Features](features.md)
-  * [Advanced Keycodes](feature_advanced_keycodes.md)
+  * [Layouts](feature_layouts.md)
-  * [Audio](feature_audio.md)
+  * [Common Shortcuts](feature_common_shortcuts.md)
  * [Backlight](feature_backlight.md)
  * [Bootmagic](feature_bootmagic.md)
-  * [Dynamic Macros](feature_dynamic_macros.md)
+  * [Dynamic Macros](dynamic_macros.md)
-  * [Key Lock](feature_key_lock.md)
+  * [Key Lock](key_lock.md)
  * [Layouts](feature_layouts.md)
  * [Leader Key](feature_leader_key.md)
-  * [Macros](feature_macros.md)
+  * [Macros](macros.md)
-  * [Mouse keys](feature_mouse_keys.md)
+  * [Mouse keys](mouse_keys.md)
  * [Pointing Device](feature_pointing_device.md)
  * [PS2 Mouse](feature_ps2_mouse.md)
-  * [Space Cadet](feature_space_cadet.md)
+  * [Space Cadet](space_cadet_shift.md)
-  * [Stenography](feature_stenography.md)
+  * [Tap Dance](tap_dance.md)
-  * [Tap Dance](feature_tap_dance.md)
+  * [Audio](feature_audio.md)
  * [Terminal](feature_terminal.md)
  * [Thermal Printer](feature_thermal_printer.md)
-  * [Unicode](feature_unicode.md)
+  * [Stenography](stenography.md)
-  * [Userspace](feature_userspace.md)
+  * [Unicode](unicode.md)
  * [Terminal](feature_terminal.md)
 * Reference
  * [Config Options](config_options.md)
  * [Customizing Functionality](custom_quantum_functions.md)
  * [Documentation Best Practices](documentation_best_practices.md)
  * [Documentation Templates](documentation_templates.md)
  * [Glossary](glossary.md)
  * [Keymap overview](keymap.md)
  * [Keycodes](keycodes.md)
    * [Backlight](feature_backlight.md#backlight-keycodes)
    * [Basic](keycodes_basic.md)
    * [Quantum](quantum_keycodes.md)
    * [Backlight](feature_backlight.md#backlight-keycodes)
    * [Bluetooth](feature_bluetooth.md#bluetooth-keycodes)
    * [Bootmagic](feature_bootmagic.md#bootmagic-keycodes)
    * [Layer Switching](feature_common_shortcuts.md#switching-and-toggling-layers)
    * [Mod+Key](feature_common_shortcuts.md#modifier-keys)
    * [Mod Tap](feature_common_shortcuts.md#mod-tap)
    * [One Shot Keys](feature_common_shortcuts.md#one-shot-keys)
    * [Quantum](quantum_keycodes.md)
    * [RGB Light](feature_rgblight.md#rgblight-keycodes)
    * [Shifted Keys](feature_common_shortcuts.md#shifted-keycodes)
-    * [Stenography](feature_stenography.md#keycode-reference)
+    * [Stenography](stenography.md#keycode-reference)
    * [RGB Light](feature_rgblight.md#rgblight-keycodes)
    * [Thermal Printer](feature_thermal_printer.md#thermal-printer-keycodes)
    * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
  * [The `config.h` File](config_options.md)
  * [Customizing Functionality](custom_quantum_functions.md)
  * [Documentation Best Practices](documentation_best_practices.md)
  * [Documentation Templates](documentation_templates.md)
  * [Unit Testing](unit_testing.md)
 * For Makers and Modders
  * [Adding a keyboard to QMK](adding_a_keyboard_to_qmk.md)
  * [Hand Wiring Guide](hand_wiring.md)
  * [ISP flashing guide](isp_flashing_guide.md)
  * [Modding your keyboard](modding_your_keyboard.md)
  * [Porting your keyboard to QMK](porting_your_keyboard_to_qmk.md)
 * For a Deeper Understanding
  * [How Keyboards Work](how_keyboards_work.md)
--- a/docs/hardware_keyboard_guidelines.md
+++ b/docs/hardware_keyboard_guidelines.md
@ -1,49 +1,35 @@
-# QMK Keyboard Guidelines
+# Adding your keyboard to QMK
 We welcome all keyboard projects into QMK, but ask that you try to stick to a couple guidelines that help us keep things organised and consistent.
-## Naming your keyboard/project
+## Naming your directory/project
-All names should be lowercase alphanumeric, and separated by an underscore (`_`), but not begin with one. Your directory and your `.h` and `.c` files should have exactly the same name. All folders should follow the same format.
+All names should be lowercase alphanumeric, and separated by an underscore (`_`), but not begin with one. Your directory and your `.h` and `.c` files should have exactly the same name. All folders should follow the same format. 
 ## `readme.md`
-All projects need to have a `readme.md` file that explains what the keyboard is, who made it, where it is available, and links to more information. Please follow the [published template](documentation_templates.md#keyboard-readmemd-template).
+All projects need to have a `readme.md` file that explains what the keyboard is, who made it, where it is available, and links to move information (template coming).
 ## Image/Hardware files
-In an effort to keep the repo size down, we're no longer accepting images of any format in the repo, with few exceptions. Hosting them elsewhere (imgur) and linking them in the `readme.md` is the preferred method.
+In an effort to keep the repo size down, we're no longer accepting images of any format in the repo, with few exceptions. Hosting them elsewhere (imgur) and linking them in the readme.md is the preferred method.
-Any sort of hardware file (plate, case, pcb) can't be stored in qmk_firmware, but we have the [qmk.fm repo](https://github.com/qmk/qmk.fm) where such files (as well as in-depth info) can be stored and viewed on [qmk.fm](http://qmk.fm). Downloadable files are stored in `/<keyboard>/` (name follows the same format as above) which are served at `http://qmk.fm/<keyboard>/`, and pages are generated from `/_pages/<keyboard>/` which are served at the same location (.md files are generated into .html files through Jekyll). Check out the `lets_split` directory for an example.
+Any sort of hardware file (plate, case, pcb) can't be stored in qmk_firmware, but we have the [qmk.fm repo](https://github.com/qmk/qmk.fm) where such files (as well as in-depth info) can be store, and viewed on [qmk.fm](http://qmk.fm). Downloadable files are stored in `/<keyboard>/` (name follows the same format as above) which are served at `http://qmk.fm/<keyboard>/`, and pages are generated from `/_pages/<keyboard>/` which are served at the same location (.md files are generated into .html files through Jekyll). Check out the `lets_split` directory for an example.
 ## Non-production/handwired projects
-We're happy to accept any project that uses QMK, including prototypes and handwired ones, but we have a separate `/keyboards/handwired/` folder for them, so the main `/keyboards/` folder doesn't get overcrowded. If a prototype project becomes a production project at some point in the future, we'd be happy to move it to the main `/keyboards/` folder!
+We're happy to accept any project that uses QMK, including prototypes and handwired ones, but we have a separate `/keyboards/handwired/` folder for them, so the main `/keyboards/` folder doesn't get overcrowded. If a prototype project becomes a production project at some point in the future, we'd be happy to move it to the main `/keyboards/` folder! 
 ## Warnings as errors
 When developing your keyboard, keep in mind that all warnings will be treated as errors - these small warnings can build-up and cause larger errors down the road (and keeping them is generally a bad practice).
-## Copyright Blurb
+## Licenses
 If you're adapting your keyboard's setup from another project, but not using the same code, but sure to update the copyright header at the top of the files to show your name, in this format:
    Copyright 2017 Your Name <your@email.com>
-
+    
 If you are modifying someone else's code and have made only trivial changes you should leave their name in the copyright statement. If you have done significant work on the file you should add your name to theirs, like so:
    Copyright 2017 Their Name <original_author@example.com> Your Name <you@example.com>
 The year should be the first year the file is created. If work was done to that file in later years you can reflect that by appending the second year to the first, like so:
    Copyright 2015-2017 Your Name <you@example.com>
 ## License
 The core of QMK is licensed under the [GNU General Public License](https://www.gnu.org/licenses/licenses.en.html). If you are shipping binaries for AVR processors you may choose either [GPLv2](https://www.gnu.org/licenses/old-licenses/gpl-2.0.html) or [GPLv3](https://www.gnu.org/licenses/gpl.html). If you are shipping binaries for ARM processors you must choose [GPL Version 3](https://www.gnu.org/licenses/gpl.html) to comply with the [ChibiOS](http://www.chibios.org) GPLv3 license.
 If your keyboard makes use of the [uGFX](https://ugfx.io) features within QMK you must comply with the [uGFX License](https://ugfx.io/license.html), which requires a separate commercial license before selling a device containing uGFX.
 ## Technical details
-If you're looking for more information on making your keyboard work with QMK, [check out the hardware section](hardware.md)!
+If you're looking for more information on making your keyboard work with QMK, [check out this guide](porting_your_keyboard_to_qmk.md)!
--- a/docs/config_options.md
+++ b/docs/config_options.md
@ -1,198 +1,129 @@
-# Configuring QMK
+# The `config.h` file
-QMK is nearly infinitely configurable. Wherever possible we err on the side of allowing users to customize their keyboard, even at the expense of code size. That level of flexibility makes for a daunting configuration experience, however.
+This is a c header file that is one of the first things included, and will persist over the whole project (if included). Lots of variables can be set here and accessed elsewhere (namely keymaps). This file can exist at a couple different levels:
 There are two main types of configuration files in QMK- `config.h` and `rules.mk`. These files exist at various levels in QMK and all files of the same type are combined to build the final configuration. The levels, from lowest priority to highest priority, are:
 * QMK Default
 * Keyboard
 * Folders (Up to 5 levels deep)
 * Keymap
 ## QMK Default
 Every available setting in QMK has a default. If that setting is not set at the Keyboard, Folder, or Keymap level this is the setting that will be used.
 ## Keyboard
-This level contains config options that should apply to the whole keyboard. Some settings won't change in revisions, or most keymaps. Other settings are merely defaults for this keyboard and can be overridden by folders and/or keymaps.
+```c
 #ifndef CONFIG_H
 #define CONFIG_H
-## Folders
+#include "config_common.h"
-Some keyboards have folders and sub-folders to allow for different hardware configurations. Most keyboards only go 1 folder deep, but QMK supports structures up to 5 folders deep. Each folder can have its own `config.h` and `rules.mk` files that are incorporated into the final configuration.
+// config options
 #endif
 ```
 This file contains config options that should apply to the whole keyboard, and won't change in revisions, or most keymaps. The revision block here only applies to keyboards with revisions.
 ## Revisions
 ```c
 #ifndef <revision>_CONFIG_H
 #define <revision>_CONFIG_H
 #include "config_common.h"
 // config options
 #endif
 ```
 For keyboards that have revisions, this file contains config options that should apply to only that revisions, and won't change in most keymaps.
 ## Keymap
-This level contains all of the options for that particular keymap. If you wish to override a previous declaration, you can use `#undef <variable>` to undefine it, where you can then redefine it without an error.
+```c
 #ifndef CONFIG_USER_H
 #define CONFIG_USER_H
-# The `config.h` file
+#include "config_common.h"
-This is a C header file that is one of the first things included, and will persist over the whole project (if included). Lots of variables can be set here and accessed elsewhere.
+// config options
-## `config.h` Options
+#endif
 ```
-### Hardware Options
+This file contains all of the options for that particular keymap. If you wish to override a previous declaration, you can use `#undef <variable>` to undefine it, where you can then redefine it without an error.
 * `#define VENDOR_ID 0x1234`
  * defines your VID, and for most DIY projects, can be whatever you want
 * `#define PRODUCT_ID 0x5678`
  * defines your PID, and for most DIY projects, can be whatever you want
 * `#define DEVICE_VER 0`
  * defines the device version (often used for revisions)
 * `#define MANUFACTURER Me`
  * generally who/whatever brand produced the board
 * `#define PRODUCT Board`
  * the name of the keyboard
 * `#define DESCRIPTION a keyboard`
  * a short description of what the keyboard is
 * `#define MATRIX_ROWS 5`
  * the number of rows in your keyboard's matrix
 * `#define MATRIX_COLS 15`
  * the number of columns in your keyboard's matrix
 * `#define MATRIX_ROW_PINS { D0, D5, B5, B6 }`
  * pins of the rows, from top to bottom
 * `#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }`
  * pins of the columns, from left to right
 * `#define UNUSED_PINS { D1, D2, D3, B1, B2, B3 }`
  * pins unused by the keyboard for reference
 * `#define MATRIX_HAS_GHOST`
  * define is matrix has ghost (unlikely)
 * `#define DIODE_DIRECTION COL2ROW`
  * COL2ROW or ROW2COL - how your matrix is configured. COL2ROW means the black mark on your diode is facing to the rows, and between the switch and the rows.
 * `#define AUDIO_VOICES`
  * turns on the alternate audio voices (to cycle through)
 * `#define C6_AUDIO`
  * enables audio on pin C6
 * `#define B5_AUDIO`
  * enables audio on pin B5 (duophony is enable if both are enabled)
 * `#define BACKLIGHT_PIN B7`
  * pin of the backlight - B5, B6, B7 use PWM, others use softPWM
 * `#define BACKLIGHT_LEVELS 3`
  * number of levels your backlight will have (not including off)
 * `#define DEBOUNCING_DELAY 5`
  * the delay when reading the value of the pin (5 is default)
 * `#define LOCKING_SUPPORT_ENABLE`
  * mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap
 * `#define LOCKING_RESYNC_ENABLE`
  * tries to keep switch state consistent with keyboard LED state
 * `#define IS_COMMAND() ( keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) )`
  * key combination that allows the use of magic commands (useful for debugging)
-### Features That Can Be Disabled
+# Config Options
-If you define these options you will disable the associated feature, which can save on code size.
+```c
 #define VENDOR_ID 0x1234 // defines your VID, and for most DIY projects, can be whatever you want
 #define PRODUCT_ID 0x5678 // defines your PID, and for most DIY projects, can be whatever you want  
 #define DEVICE_VER 0 // defines the device version (often used for revisions)
-* `#define NO_DEBUG`
+#define MANUFACTURER Me // generally who/whatever brand produced the board
-  * disable debuging
+#define PRODUCT Board // the name of the keyboard
-* `#define NO_PRINT`
+#define DESCRIPTION a keyboard // a short description of what the keyboard is
  * disable printing/debugging using hid_listen
 * `#define NO_ACTION_LAYER`
  * disable layers
 * `#define NO_ACTION_TAPPING`
  * disable tap dance and other tapping features
 * `#define NO_ACTION_ONESHOT`
  * disable one-shot modifiers
 * `#define NO_ACTION_MACRO`
  * disable all macro handling
 * `#define NO_ACTION_FUNCTION`
  * disable the action function (deprecated)
-### Features That Can Be Enabled
+#define MATRIX_ROWS 5 // the number of rows in your keyboard's matrix
 #define MATRIX_COLS 15 // the number of columns in your keyboard's matrix
-If you define these options you will enable the associated feature, which may increase your code size.
+#define MATRIX_ROW_PINS { D0, D5, B5, B6 } // pins of the rows, from top to bottom
 #define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 } // pins of the columns, from left to right
 #define UNUSED_PINS { D1, D2, D3, B1, B2, B3 } // pins unused by the keyboard for reference 
 #define MATRIX_HAS_GHOST // define is matrix has ghost (unlikely)
 #define DIODE_DIRECTION COL2ROW // COL2ROW or ROW2COL - how your matrix is configured
 // COL2ROW means the black mark on your diode is facing to the rows, and between the switch and the rows
-* `#define FORCE_NKRO`
+#define AUDIO_VOICES // turns on the alternate audio voices (to cycle through)
-  * NKRO by default requires to be turned on, this forces it on during keyboard startup regardless of eeprom setting. NKRO can still be turned off but will be turned on again if the keyboard reboots.
+#define C6_AUDIO // enables audio on pin C6
-* `#define PREVENT_STUCK_MODIFIERS`
+#define B5_AUDIO // enables audio on pin B5 (duophony is enable if both are enabled)
  * when switching layers, this will release all mods
-### Behaviors That Can Be Configured
+#define BACKLIGHT_PIN B7 // pin of the backlight - B5, B6, B7 use PWM, others use softPWM
 #define BACKLIGHT_LEVELS 3 // number of levels your backlight will have (not including off)
-* `#define TAPPING_TERM 200`
+#define DEBOUNCING_DELAY 5 // the delay when reading the value of the pin (5 is default)
  * how long before a tap becomes a hold
 * `#define TAPPING_TOGGLE 2`
  * how many taps before triggering the toggle
 * `#define PERMISSIVE_HOLD`
  * makes tap and hold keys work better for fast typers who don't want tapping term set above 500
 * `#define LEADER_TIMEOUT 300`
  * how long before the leader key times out
 * `#define ONESHOT_TIMEOUT 300`
  * how long before oneshot times out
 * `#define ONESHOT_TAP_TOGGLE 2`
  * how many taps before oneshot toggle is triggered
 * `#define IGNORE_MOD_TAP_INTERRUPT`
  * makes it possible to do rolling combos (zx) with keys that convert to other keys on hold
-### RGB Light Configuration
+#define LOCKING_SUPPORT_ENABLE // mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap
 #define LOCKING_RESYNC_ENABLE // tries to keep switch state consistent with keyboard LED state
-* `#define RGB_DI_PIN D7`
+#define IS_COMMAND() ( \ // key combination that allows the use of magic commands (useful for debugging)
-  * pin the DI on the ws2812 is hooked-up to
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
-* `#define RGBLIGHT_ANIMATIONS`
+)
  * run RGB animations
 * `#define RGBLED_NUM 15`
  * number of LEDs
 * `#define RGBLIGHT_HUE_STEP 12`
  * units to step when in/decreasing hue
 * `#define RGBLIGHT_SAT_STEP 25`
  * units to step when in/decresing saturation
 * `#define RGBLIGHT_VAL_STEP 12`
  * units to step when in/decreasing value (brightness)
 * `#define RGBW_BB_TWI`
  * bit-bangs twi to EZ RGBW LEDs (only required for Ergodox EZ)
-### Mouse Key Options
+// the following options can save on file size at the expense of that feature
 #define NO_DEBUG // disable debuging (saves on file size)
 #define NO_PRINT // disable printing (saves of file size)
 #define NO_ACTION_LAYER // no layers
 #define NO_ACTION_TAPPING // no tapping for layers/mods
 #define NO_ACTION_ONESHOT // no oneshot for layers/mods
 #define NO_ACTION_MACRO // no macros
 #define NO_ACTION_FUNCTION // no functions
-* `#define MOUSEKEY_INTERVAL 20`
+#define FORCE_NKRO // NKRO by default requires to be turned on, this forces it to be on always
 * `#define MOUSEKEY_DELAY 0`
 * `#define MOUSEKEY_TIME_TO_MAX 60`
 * `#define MOUSEKEY_MAX_SPEED 7`
 * `#define MOUSEKEY_WHEEL_DELAY 0`
-# The `rules.mk` File
+#define PREVENT_STUCK_MODIFIERS // when switching layers, this will release all mods
-This is a [make](https://www.gnu.org/software/make/manual/make.html) file that is included by the top-level `Makefile`. It is used to set some information about the MCU that we will be compiling for as well as enabling and disabling certain features.
+#define TAPPING_TERM 200 // how long before a tap becomes a hold
 #define TAPPING_TOGGLE 2 // how many taps before triggering the toggle
-## `rules.mk` options
+#define PERMISSIVE_HOLD // makes tap and hold keys work better for fast typers who don't want tapping term set above 500
-### Build Options
+#define LEADER_TIMEOUT 300 // how long before the leader key times out
-* `DEFAULT_FOLDER`
+#define ONESHOT_TIMEOUT 300 // how long before oneshot times out
-  * Used to specify a default folder when a keyboard has more than one sub-folder.
+#define ONESHOT_TAP_TOGGLE 2 // how many taps before oneshot toggle is triggered
 * `SRC`
  * Used to add files to the compilation/linking list.
 * `LAYOUTS`
  * A list of [layouts](feature_layouts.md) this keyboard supports.
-### AVR MCU Options
+#define IGNORE_MOD_TAP_INTERRUPT // makes it possible to do rolling combos (zx) with keys that convert to other keys on hold
 * `MCU = atmega32u4`
 * `F_CPU = 16000000`
 * `ARCH = AVR8`
 * `F_USB = $(F_CPU)`
 * `OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT`
 * `OPT_DEFS += -DBOOTLOADER_SIZE=4096`
-### Feature Options
+// ws2812 options
 #define RGB_DI_PIN D7 // pin the DI on the ws2812 is hooked-up to
 #define RGBLIGHT_ANIMATIONS // run RGB animations
 #define RGBLED_NUM 15 // number of LEDs
 #define RGBLIGHT_HUE_STEP 12 // units to step when in/decreasing hue
 #define RGBLIGHT_SAT_STEP 25 // units to step when in/decresing saturation
 #define RGBLIGHT_VAL_STEP 12 // units to step when in/decreasing value (brightness)
-Use these to enable or disable building certain features. The more you have enabled the bigger your firmware will be, and you run the risk of building a firmware too large for your MCU.
+#define RGBW_BB_TWI // bit-bangs twi to EZ RGBW LEDs (only required for Ergodox EZ)
-* `BOOTMAGIC_ENABLE`
+// mousekey options (self-describing)
-  * Virtual DIP switch configuration(+1000)
+#define MOUSEKEY_INTERVAL 20
-* `MOUSEKEY_ENABLE`
+#define MOUSEKEY_DELAY 0
-  * Mouse keys(+4700)
+#define MOUSEKEY_TIME_TO_MAX 60
-* `EXTRAKEY_ENABLE`
+#define MOUSEKEY_MAX_SPEED 7
-  * Audio control and System control(+450)
+#define MOUSEKEY_WHEEL_DELAY 0
-* `CONSOLE_ENABLE`
+
-  * Console for debug(+400)
+```
 * `COMMAND_ENABLE`
  * Commands for debug and configuration
 * `NKRO_ENABLE`
  * USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 * `AUDIO_ENABLE`
  * Enable the audio subsystem.
 * `RGBLIGHT_ENABLE`
  * Enable keyboard underlight functionality
 * `MIDI_ENABLE`
  * MIDI controls
 * `UNICODE_ENABLE`
  * Unicode
 * `BLUETOOTH_ENABLE`
  * Enable Bluetooth with the Adafruit EZ-Key HID
--- a/docs/contributing.md
+++ b/docs/contributing.md
@ -80,7 +80,7 @@ We have a few different types of changes in QMK, each requiring a different leve
 * Make sure your code change actually compiles.
  * Keymaps: Make sure that `make keyboard:your_new_keymap` does not return an error
  * Keyboards: Make sure that `make keyboard:all` does not return any errors
-  * Core: Make sure that `make all` does not return any errors.
+  * Core: Make sure that `make allkb` does not return any errors.
 * Make sure commit messages are understandable on their own. You should put a short description (no more than 70 characters) on the first line, the second line should be empty, and on the 3rd and later lines you should describe your commit in detail, if required. Example:
 ```
@ -144,4 +144,4 @@ To maintain a clear vision of how things are laid out in QMK we try to plan out
 # What does the Code of Conduct mean for me?
-Our [Code of Conduct](https://github.com/qmk/qmk_firmware/blob/master/CODE_OF_CONDUCT.md) means that you are responsible for treating everyone on the project with respect and courtesy regardless of their identity. If you are the victim of any inappropriate behavior or comments as described in our Code of Conduct, we are here for you and will do the best to ensure that the abuser is reprimanded appropriately, per our code.
+Our Code of Conduct means that you are responsible for treating everyone on the project with respect and courtesy regardless of their identity. If you are the victim of any inappropriate behavior or comments as described in our Code of Conduct, we are here for you and will do the best to ensure that the abuser is reprimanded appropriately, per our code.
--- a/docs/feature_dynamic_macros.md
+++ b/docs/feature_dynamic_macros.md
@ -1,6 +1,6 @@
 # Dynamic macros: record and replay macros in runtime
-QMK supports temporary macros created on the fly. We call these Dynamic Macros. They are defined by the user from the keyboard and are lost when the keyboard is unplugged or otherwise rebooted.
+QMK supports temporarily macros created on the fly. We call these Dynamic Macros. They are defined by the user from the keyboard and are lost when the keyboard is unplugged or otherwise rebooted.
 You can store one or two macros and they may have a combined total of 128 keypresses. You can increase this size at the cost of RAM.
@ -22,7 +22,7 @@ enum planck_keycodes {
 It must be the last element because `dynamic_macros.h` will add some more keycodes after it.
-Below it, include the `dynamic_macro.h` header:
+Below it include the `dynamic_macro.h` header:
 ```c
 	#include "dynamic_macro.h"`
@ -58,6 +58,6 @@ For users of the earlier versions of dynamic macros: It is still possible to fin
 	}
 ```
-If the LEDs start blinking during the recording with each keypress, it means there is no more space for the macro in the macro buffer. To fit the macro in, either make the other macro shorter (they share the same buffer) or increase the buffer size by setting the `DYNAMIC_MACRO_SIZE` preprocessor macro (default value: 128; please read the comments for it in the header).
+If the LED's start blinking during the recording with each keypress, it means there is no more space for the macro in the macro buffer. To fit the macro in, either make the other macro shorter (they share the same buffer) or increase the buffer size by setting the `DYNAMIC_MACRO_SIZE` preprocessor macro (default value: 128; please read the comments for it in the header).
 For the details about the internals of the dynamic macros, please read the comments in the `dynamic_macro.h` header.
--- a/docs/faq_build.md
+++ b/docs/faq_build.md
@ -62,7 +62,7 @@ https://github.com/tmk/tmk_keyboard/wiki/mbed-cortex-porting#compile-error-cstdd
 https://developer.mbed.org/forum/mbed/topic/5205/
-## `clock_prescale_set` and `clock_div_1` not available
+## 'clock_prescale_set' and 'clock_div_1' not available
 Your toolchain is too old to support the MCU. For example WinAVR 20100110 doesn't support ATMega32u2.
 ```
--- a/docs/faq_keymap.md
+++ b/docs/faq_keymap.md
@ -7,17 +7,6 @@ See [Keycodes](keycodes.md) for an index of keycodes available to you. These lin
 Keycodes are actually defined in [common/keycode.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keycode.h).
 ## What Are The Default Keycodes?
 There are 3 standard keyboard layouts in use around the world- ANSI, ISO, and JIS. North America primarily uses ANSI, Europe and Africa primarily use ISO, and Japan uses JIS. Regions not mentioned typically use either ANSI or ISO. The keycodes corresponding to these layouts are shown here:
 <!-- Source for this image: http://www.keyboard-layout-editor.com/#/gists/9ce023dc6caadc0cf11c88c782350a8c -->
 ![Keyboard Layout Image](https://i.imgur.com/45m4mRf.png)
 ## The Menu Key Isn't Working
 The key found on most modern keyboards that is located between `KC_RGUI` and `KC_RCTL` is actually called `KC_APP`. This is because when that key was invented there was already a key named `MENU` in the relevant standards, so MS chose to call that the `APP` key.
 ## `KC_SYSREQ` isn't working
 Use keycode for Print Screen(`KC_PSCREEN` or `KC_PSCR`) instead of `KC_SYSREQ`. Key combination of 'Alt + Print Screen' is recognized as 'System request'.
--- a/docs/feature_advanced_keycodes.md
+++ b/docs/feature_advanced_keycodes.md
@ -1,8 +1,6 @@
-# Advanced Keycodes
+# Common Keymap Shortcuts
-Your keymap can include keycodes that are more advanced than normal, for example shifted keys. This page documents the functions that are available to you.
+Your keymap can include shortcuts to common operations, for example shifted keys. This page documents the functions that are available to you.
 ### Assigning Custom Names
 People often define custom names using `#define`. For example:
@ -17,7 +15,7 @@ This will allow you to use `FN_CAPS` and `ALT_TAB` in your `KEYMAP()`, keeping i
 Currently, the keycodes able to used with these functions are limited to the [Basic Keycodes](keycodes_basic.html), meaning you can't use keycodes like `KC_TILD`, or anything greater than 0xFF. For a full list of the keycodes able to be used see [Basic Keycodes](keycodes_basic.html).
-# Switching and toggling layers
+## Switching and toggling layers
 These functions allow you to activate layers in various ways.
@ -27,7 +25,7 @@ These functions allow you to activate layers in various ways.
 * `TO(layer)` - Goes to a layer. This code is special, because it lets you go either up or down the stack -- just goes directly to the layer you want. So while other codes only let you go _up_ the stack (from layer 0 to layer 3, for example), `TO(2)` is going to get you to layer 2, no matter where you activate it from -- even if you're currently on layer 5. This gets activated on keydown (as soon as the key is pressed).
 * `TT(layer)` - Layer Tap-Toggle. If you hold the key down, the layer becomes active, and then deactivates when you let go. And if you tap it, the layer simply becomes active (toggles on). It needs 5 taps by default, but you can set it by defining `TAPPING_TOGGLE`, for example, `#define TAPPING_TOGGLE 2` for just two taps.
-# Working With Layers
+## Working With Layers
 Care must be taken when switching layers, it's possible to lock yourself into a layer with no way to deactivate that layer (without unplugging your keyboard.) We've created some guidelines to help users avoid the most common problems.
@ -49,7 +47,7 @@ Once you have a good feel for how layers work and what you can do, you can get m
 Layers stack on top of each other in numerical order. When determining what a keypress does, QMK scans the layers from the top down, stopping when it reaches the first active layer that is not set to `KC_TRNS`. As a result if you activate a layer that is numerically lower than your current layer, and your current layer (or another layer that is active and higher than your target layer) has something other than `KC_TRNS`, that is the key that will be sent, not the key on the layer you just activated. This is the cause of most people's "why doesn't my layer get switched" problem.
-# Modifier keys
+## Modifier keys
 These functions allow you to combine a mod with a keycode. When pressed the keydown for the mod will be sent first, and then *kc* will be sent. When released the keyup for *kc* will be sent and then the mod will be sent.
@ -69,7 +67,7 @@ You can also chain these, like this:
    LALT(LCTL(KC_DEL)) -- this makes a key that sends Alt, Control, and Delete in a single keypress.
-# Shifted Keycodes
+## Shifted Keycodes
 The following shortcuts automatically add `LSFT()` to keycodes to get commonly used symbols.
@ -97,7 +95,7 @@ The following shortcuts automatically add `LSFT()` to keycodes to get commonly u
 | KC_PIPE | &#x7C; |
 | KC_COLN | : |
-# Mod Tap
+## Mod Tap
 `MT(mod, kc)` - is *mod* (modifier key - MOD_LCTL, MOD_LSFT) when held, and *kc* when tapped. In other words, you can have a key that sends Esc (or the letter O or whatever) when you tap it, but works as a Control key or a Shift key when you hold it down.
@ -127,7 +125,7 @@ We've added shortcuts to make common modifier/tap (mod-tap) mappings more compac
  * `LCAG_T(kc)` - is CtrlAltGui when held and *kc* when tapped
  * `MEH_T(kc)` - is like Hyper, but not as cool -- does not include the Cmd/Win key, so just sends Alt+Ctrl+Shift.
-# One Shot Keys
+## One Shot Keys
 One shot keys are keys that remain active until the next key is pressed, and then are releasd. This allows you to type keyboard combinations without pressing more than one key at a time.
--- a/docs/feature_rgblight.md
+++ b/docs/feature_rgblight.md
@ -49,10 +49,8 @@ If you have `#define RGBLIGHT_ANIMATIONS` in your `config.h` you will have a num
 | Option | Default Value | Description |
 |--------|---------------|-------------|
 | `RGBLIGHT_ANIMATIONS` | | `#define` this to enable animation modes. |
-| `RGBLIGHT_EFFECT_BREATHE_CENTER` | 1.85 | Used to calculate the curve for the breathing animation. Valid values 1.0-2.7. |
+| `RGBLIGHT_EFFECT_SNAKE_LENGTH` | 4 | The number of LEDs to light up for the "snake" mode. |
-| `RGBLIGHT_EFFECT_BREATHE_MAX` | 255 | The maximum brightness for the breathing mode. Valid values 1-255. |
+| `RGBLIGHT_EFFECT_KNIGHT_LENGTH` | 3 | The number of LEDs to light up for the "knight" mode. |
 | `RGBLIGHT_EFFECT_SNAKE_LENGTH` | 4 | The number of LEDs to light up for the "snake" animation. |
 | `RGBLIGHT_EFFECT_KNIGHT_LENGTH` | 3 | The number of LEDs to light up for the "knight" animation. |
 | `RGBLIGHT_EFFECT_KNIGHT_OFFSET` | 0 | Start the knight animation this many LEDs from the start of the strip. |
 | `RGBLIGHT_EFFECT_KNIGHT_LED_NUM` | RGBLED_NUM | The number of LEDs to have the "knight" animation travel. |
 | `RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL` | 1000 | How long to wait between light changes for the "christmas" animation. Specified in ms. |
@ -88,7 +86,6 @@ These control the RGB Lighting functionality.
 |-----------|------------|-------------|
 ||`RGB_TOG`|toggle on/off|
 ||`RGB_MOD`|cycle through modes|
 ||`RGB_SMOD`|cycle through modes, use reverse direction when shift is hold|
 ||`RGB_HUI`|hue increase|
 ||`RGB_HUD`|hue decrease|
 ||`RGB_SAI`|saturation increase|
--- a/docs/feature_userspace.md
+++ b/docs/feature_userspace.md
@ -1,33 +0,0 @@
 # Userspace: sharing code between keymaps
 If you use more than one keyboard with a similar keymap, you might see the benefit in being able to share code between them. Create your own folder in `users/` named the same as your keymap (ideally your github username, `<name>`) with the following structure:
 * `/users/<name>/` (added to the path automatically)
  * `readme.md`
  * `rules.mk` (included automatically)
  * `<name>.h` (optional)
  * `<name>.c` (optional)
 `<name>.c` will need to be added to the SRC in `rules.mk` like this:
    SRC += <name>.c
 Additional files may be added in the same way - it's recommended you have one named `<name>`.c/.h though.
 All this only happens when you build a keymap named `<name>`, like this:
    make planck:<name>
 For example, 
    make planck:jack
 Will include the `/users/jack/` folder in the path, along with `/users/jack/rules.mk`.
 ## Readme
 Please include authorship (your name, github username, email), and optionally [a license that's GPL compatible](https://www.gnu.org/licenses/license-list.html#GPLCompatibleLicenses).
 ## Example
 For a brief example, checkout `/users/_example/` until we have more reasonable and useful examples.
--- a/docs/features.md
+++ b/docs/features.md
@ -1,24 +1,105 @@
 # QMK Features
 QMK has a staggering number of features for building your keyboard. It can take some time to understand all of them and determine which one will acheive your goal.
 ## Space Cadet Shift: The future, built in
-* [Advanced Keycodes](feature_advanced_keycodes.md) - Change layers, type shifted keys, and more. Go beyond typing simple characters.
+Steve Losh [described](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/) the Space Cadet Shift quite well. Essentially, you hit the left Shift on its own, and you get an opening parenthesis; hit the right Shift on its own, and you get the closing one. When hit with other keys, the Shift key keeps working as it always does. Yes, it's as cool as it sounds. Head on over to the [Space Cadet Shift](space_cadet_shift.md) page to read about it.
-* [Audio](feature_audio.md) - Connect a speaker to your keyboard for audio feedback, midi support, and music mode.
+
-* [Backlight](feature_backlight.md) - LED lighting support for your keyboard
+## The Leader key: A new kind of modifier
-* [Bootmagic](feature_bootmagic.md) - Adjust the behavior of your keyboard using hotkeys
+
-* [Dynamic Macros](feature_dynamic_macros.md) - Record and playback macros from the keyboard itself.
+Most modifiers have to be held or toggled. But what if you had a key that indicated the start of a sequence? You could press that key and then rapidly press 1-3 more keys to trigger a macro, or enter a special layer, or anything else you might want to do. To learn more about it check out the [Leader Key](feature_leader_key.md) page.
-* [Key Lock](feature_key_lock.md) - Lock a key in the "down" state.
+
-* [Layouts](feature_layouts.md) - Use one keymap with any keyboard that supports your layout.
+## Tap Dance: A single key can do 3, 5, or 100 different things
-* [Leader Key](feature_leader_key.md) - Tap the leader key followed by a sequence to trigger custom behavior.
+
-* [Macros](feature_macros.md) - Send multiple key presses when pressing only one physical key
+Hit the semicolon key once, send a semicolon. Hit it twice, rapidly -- send a colon. Hit it three times, and your keyboard's LEDs do a wild dance. That's just one example of what Tap Dance can do. Read more about it on the [Tap Dance](tap_dance.md) page.
-* [Mouse keys](feature_mouse_keys.md) - Control your mouse pointer from your keyboard
+
-* [Pointing Device](feature_pointing_device.md) - Framework for connecting your custom pointing device to your keyboard.
+## Temporarily setting the default layer
-* [PS2 Mouse](feature_ps2_mouse.md) - Driver for connecting a ps2 mouse directly to your keyboard.
+
-* [Space Cadet](feature_space_cadet_shift.md) - Use your left/right shift keys to type parenthesis and brackets.
+`DF(layer)` - sets default layer to _layer_. The default layer is the one at the "bottom" of the layer stack - the ultimate fallback layer. This currently does not persist over power loss. When you plug the keyboard back in, layer 0 will always be the default. It is theoretically possible to work around that, but that's not what `DF` does.
-* [Stenography](feature_stenography.md) - Put your keyboard into Plover mode for stenography use.
+
-* [Tap Dance](feature_tap_dance.md) - Make a single key do as many things as you want
+## Macro shortcuts: Send a whole string when pressing just one key
-* [Terminal](feature_terminal.md) - CLI interface to the internals of your keyboard
+
-* [Thermal Printer](feature_thermal_printer.md) - Connect a thermal printer to your keyboard to be able to toggle on a printed log of everything you type.
+How would you like a single keypress to send a whole word, sentence, paragraph, or even document? Head on over to the [Macros](macros.md) page to read up on all aspects of Simple and Dynamic Macros.
-* [Unicode](feature_unicode.md) - Unicode input support.
+
-* [Userspace](feature_userspace.md) - Share code between different keymaps and keyboards
+## Additional keycode aliases for software-implemented layouts \(Colemak, Dvorak, etc\)
 Everything is assuming you're in Qwerty \(in software\) by default, but there is built-in support for using a Colemak or Dvorak layout by including this at the top of your keymap:
 ```
 #include <keymap_colemak.h>
 ```
 If you use Dvorak, use `keymap_dvorak.h` instead of `keymap_colemak.h` for this line. After including this line, you will get access to:
 * `CM_*` for all of the Colemak-equivalent characters
 * `DV_*` for all of the Dvorak-equivalent characters
 These implementations assume you're using Colemak or Dvorak on your OS, not on your keyboard - this is referred to as a software-implemented layout. If your computer is in Qwerty and your keymap is in Colemak or Dvorak, this is referred to as a firmware-implemented layout, and you won't need these features.
 To give an example, if you're using software-implemented Colemak, and want to get an `F`, you would use `CM_F`. Using `KC_F` under these same circumstances would result in `T`.
 ## Backlight Breathing
 In order to enable backlight breathing, the following line must be added to your config.h file.
 ```
 #define BACKLIGHT_BREATHING
 ```
 The following function calls are used to control the breathing effect.
 * `breathing_enable()` - Enable the free-running breathing effect.
 * `breathing_disable()` - Disable the free-running breathing effect immediately.
 * `breathing_self_disable()` - Disable the free-running breathing effect after the current effect ends.
 * `breathing_toggle()` - Toggle the free-running breathing effect.
 * `breathing_defaults()` - Reset the speed and brightness settings of the breathing effect.
 The following function calls are used to control the maximum brightness of the breathing effect.
 * `breathing_intensity_set(value)` - Set the brightness of the breathing effect when it is at its max value.
 * `breathing_intensity_default()` - Reset the brightness of the breathing effect to the default value based on the current backlight intensity.
 The following function calls are used to control the cycling speed of the breathing effect.
 * `breathing_speed_set(value)` - Set the speed of the breathing effect - how fast it cycles.
 * `breathing_speed_inc(value)` - Increase the speed of the breathing effect by a fixed value.
 * `breathing_speed_dec(value)` - Decrease the speed of the breathing effect by a fixed value.
 * `breathing_speed_default()` - Reset the speed of the breathing effect to the default value.
 The following example shows how to enable the backlight breathing effect when the FUNCTION layer macro button is pressed:
 ```
 case MACRO_FUNCTION:
    if (record->event.pressed)
    {
        breathing_speed_set(3);
        breathing_enable();
        layer_on(LAYER_FUNCTION);
    }
    else
    {
        breathing_speed_set(1);
        breathing_self_disable();
        layer_off(LAYER_FUNCTION);
    }
    break;
 ```
 The following example shows how to pulse the backlight on-off-on when the RAISED layer macro button is pressed:
 ```
 case MACRO_RAISED:
  if (record->event.pressed)
  {
    layer_on(LAYER_RAISED);
    breathing_speed_set(2);
    breathing_pulse();
    update_tri_layer(LAYER_LOWER, LAYER_RAISED, LAYER_ADJUST);
  }
  else
  {
    layer_off(LAYER_RAISED);
    update_tri_layer(LAYER_LOWER, LAYER_RAISED, LAYER_ADJUST);
  }
  break;
 ```
--- a/docs/getting_started_make_guide.md
+++ b/docs/getting_started_make_guide.md
@ -131,7 +131,7 @@ This consumes about 5390 bytes.
 `KEY_LOCK_ENABLE`
-This enables [key lock](feature_key_lock.md). This consumes an additional 260 bytes.
+This enables [key lock](key_lock.md). This consumes an additional 260 bytes.
 ## Customizing Makefile options on a per-keymap basis
--- a/docs/glossary.md
+++ b/docs/glossary.md
@ -36,7 +36,7 @@ An alternative keyboard layout developed by Dr. August Dvorak in the 1930's. A s
 ## Dynamic Macro
 A macro which has been recorded on the keyboard and which will be lost when the keyboard is unplugged or the computer rebooted.
-* [Dynamic Macro Documentation](feature_dynamic_macros.md)
+* [Dynamic Macro Documentation](dynamic_macros.html)
 ## Eclipse
 An IDE that is popular with many C developers.
@ -93,7 +93,7 @@ A wiring pattern of columns and rows that enables the MCU to detect keypresses w
 ## Macro
 A feature that lets you send muiltple keypress events (hid reports) after having pressed only a single key.
-* [Macro Documentation](feature_macros.md)
+* [Macro Documentation](macros.html)
 ## MCU
 Microcontrol Unit, the processor that powers your keyboard.
@ -104,7 +104,7 @@ A key that is held down while typing another key to modify the action of that ke
 ## Mousekeys
 A feature that lets you control your mouse cursor and click from your keyboard.
-* [Mousekeys Documentation](feature_mouse_keys.html)
+* [Mousekeys Documentation](mouse_keys.html)
 ## N-Key Rollover (NKRO)
 A term that applies to keyboards that are capable of reporting any number of key-presses at once.
@ -133,7 +133,7 @@ A 1 byte number that is sent as part of a HID report over USB that represents a
 ## Space Cadet Shift
 A special set of shift keys which allow you to type various types of braces by tapping the left or right shift one or more times.
-* [Space Cadet Shift Documentation](feature_space_cadet.html)
+* [Space Cadet Shift Documentation](space_cadet_shift.html)
 ## Tap
 Pressing and releasing a key. In some situations you will need to distinguish between a key down and a key up event, and Tap always refers to both at once.
@ -141,7 +141,7 @@ Pressing and releasing a key. In some situations you will need to distinguish be
 ## Tap Dance
 A feature that lets you assign muiltple keycodes to the same key based on how many times you press it.
-* [Tap Dance Documentation](feature_tap_dance.md)
+* [Tap Dance Documentation](tap_dance.md)
 ## Teensy
 A low-cost AVR development board that is commonly used for hand-wired builds. A teensy is often chosen despite costing a few dollors more due to its halfkay bootloader, which makes flashing very simple.
@ -152,7 +152,7 @@ A generic term for LEDs that light the underside of the board. These LED's typic
 ## Unicode
 In the larger computer world Unicode is a set of encoding schemes for representing characters in any language. As it relates to QMK it means using various OS schemes to send unicode codepoints instead of scancodes.
-* [Unicode Documentation](feature_unicode.md)
+* [Unicode Documentation](unicode.md)
 ## Unit Testing
 A framework for running automated tests against QMK. Unit testing helps us be confident that our changes do not break anything.
--- a/docs/hardware.md
+++ b/docs/hardware.md
@ -1,8 +0,0 @@
 # Hardware
 QMK runs on a variety of hardware. If your processor can be targetted by [LUFA](http://www.fourwalledcubicle.com/LUFA.php) or [ChibiOS](http://www.chibios.com) you can probably get QMK running on it. This section explores getting QMK running on, and communicating with, hardware of all kinds.
 * [Keyboard Guidelines](hardware_keyboard_guidelines.md)
 * [AVR Processors](hardware_avr.md)
 * ARM Processors (TBD)
 * [Drivers](hardware_drivers.md)
--- a/docs/hardware_avr.md
+++ b/docs/hardware_avr.md
@ -1,157 +0,0 @@
 # Keyboards With AVR Processors
 This page describes the support for for AVR processors in QMK. AVR processors include the atmega32u4, atmega32u2, at90usb1286, and other processors from Atmel Corporation. AVR processors are 8-bit MCU's that are designed to be easy to work with. The most common AVR processors in keyboards have on-board USB and plenty of GPIO for supporting large keyboard matrices. They are the most popular MCU for use in keyboards today.
 If you have not yet you should read the [Keyboard Guidelines](hardware_keyboard_guidelines.md) to get a sense of how keyboards fit into QMK.
 ## Adding Your AVR Keyboard to QMK
 QMK has a number of features to simplify working with AVR keyboards. For most keyboards you don't have to write a single line of code. To get started run the `util/new_project.sh` script:
 ```
 $ util/new_project.sh my_awesome_keyboard
 ######################################################
 # /keyboards/my_awesome_keyboard project created. To start
 # working on things, cd into keyboards/my_awesome_keyboard
 ######################################################
 ```
 This will create all the files needed to support your new keyboard, and populate the settings with default values. Now you just need to customize it for your keyboard.
 ## `readme.md`
 This is where you'll describe your keyboard. Please follow the [Keyboard Readme Template](documentation_templates.md#keyboard-readmemd-template) when writing your `readme.md`. You're encouraged to place an image at the top of your `readme.md`, please use an external service such as [Imgur](http://imgur.com) to host the images.
 ## `<keyboard>.c`
 This is where all the custom logic for your keyboard goes. Many keyboards do not need to put anything at all in here. You can learn more about writing custom logic in [Custom Quantum Functions](custom_quantum_functions.md).
 ## `<keyboard>.h`
 This is the file you define your [Layout Macro(s)](feature_layouts.md) in. At minumum you should have a `#define LAYOUT` for your keyboard that looks something like this:
 ```
 #define LAYOUT(          \
      k00, k01, k02,     \
      k10,   k11         \
 ) {                      \
    { k00, k01,   k02 }, \
    { k10, KC_NO, k11 }, \
 }
 ```
 The first half of the `LAYOUT` pre-processor macro defines the physical arrangement of keys. The second half of the macro defines the matrix the switches are connected to. This allows you to have a physical arrangement of keys that differs from the wiring matrix.
 Each of the `k__` variables needs to be unique, and typically they follow the format `k<row><col>`.
 The physical matrix (the second half) must have a number of rows equalling `MATRIX_ROWS`, and each row must have exactly `MATRIX_COLS` elements in it. If you do not have this many physical keys you can use `KC_NO` to fill in the blank spots.
 ## `config.h`
 The `config.h` file is where you configure the hardware and feature set for your keyboard. There are a lot of options that can be placed in that file, too many to list there. For a complete overview of available options see the [Config Options](config_options.md) page.
 ### Hardware Configuration
 At the top of the `config.h` you'll find USB related settings. These control how your keyboard appears to the Operating System. If you don't have a good reason to change you should leave the `VENDOR_ID` as `0xFEED`. For the `PRODUCT_ID` you should pick a number that is not yet in use.
 Do change the `MANUFACTURER`, `PRODUCT`, and `DESCRIPTION` lines to accurately reflect your keyboard.
 ```
 #define VENDOR_ID       0xFEED
 #define PRODUCT_ID      0x6060
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    You
 #define PRODUCT         my_awesome_keyboard
 #define DESCRIPTION     A custom keyboard
 ```
 {% hint style='info' %}
 Note: On Windows and macOS the `MANUFACTURER`, `PRODUCT`, and `DESCRIPTION` fields will be displayed in the list of USB devices. On Linux these values will not be visible in `lsusb`, since Linux takes that information from the list published by the USB-IF.
 {% endhint %}
 ### Keyboard Matrix Configuration
 The next section of the `config.h` file deals with your keyboard's matrix. The first thing you should set is the matrix's size. This is usually, but not always, the same number of rows and columns as the physical key arrangement.
 ```
 #define MATRIX_ROWS 2
 #define MATRIX_COLS 3
 ```
 Once you've defined the size of your matrix you need to define which pins on your MCU are connected to rows and columns. To do so simply specify the names of those pins:
 ```
 #define MATRIX_ROW_PINS { D0, D5 }
 #define MATRIX_COL_PINS { F1, F0, B0 }
 #define UNUSED_PINS
 ```
 The number of `MATRIX_ROW_PINS` entries must be the same as the number you assigned to `MATRIX_ROWS`, and likewise for `MATRIX_COL_PINS` and `MATRIX_COLS`. You do not have to specify `UNUSED_PINS`, but you can if you want to document what pins are open.
 Finally, you can specify the direction your diodes point. This can be `COL2ROW`, `ROW2COL`, or `CUSTOM_MATRIX`.
 ```
 #define DIODE_DIRECTION COL2ROW
 ```
 ### Backlight Configuration
 By default QMK supports backlighting on pins `B5`, `B6`, and `B7`. If you are using one of those you can simply enable it here. For more details see the [Backlight Documentation](feature_backlight.md).
 ```
 #define BACKLIGHT_PIN B7
 #define BACKLIGHT_BREATHING
 #define BACKLIGHT_LEVELS 3
 ```
 {% hint style='info' %}
 You can use backlighting on any pin you like, but you will have to do more work to support that. See the [Backlight Documentation](feature_backlight.md) for more details.
 {% endhint %}
 ### Other Configuration Options
 There are a lot of features that can be configured or tuned in `config.h`. You should see the [Config Options](config_options.md) page for more details.
 ## `rules.mk`
 You use the `rules.mk` file to tell QMK what files to build and what features to enable. If you are building around an atmega32u4 you can largely leave these defaults alone. If you are using another MCU you may have to tweak some parameters.
 ### MCU Options
 These options tell the build system what CPU to build for. Be very careful if you change any of these settings, you can render your keyboard inoperable.
 ```
 MCU = atmega32u4
 F_CPU = 16000000
 ARCH = AVR8
 F_USB = $(F_CPU)
 OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
 ```
 ### Bootloader Size
 The bootloader is a special section of your MCU that allows you to upgrade the code stored on the MCU. Think of it like a Rescue Partition for your keyboard. If you are using a teensy 2.0, or a device like the Ergodox EZ that uses the teensy bootloader you should set this to `512`. Most other bootloaders should be set to `4096`, but `1024` and `2048` are other possible values you may encounter.
 #### Teensy 2.0 Bootloader Example
 ```
 OPT_DEFS += -DBOOTLOADER_SIZE=512
 ```
 #### Teensy 2.0++ Bootloader Example
 ```
 OPT_DEFS += -DBOOTLOADER_SIZE=1024
 ```
 #### Atmel DFU Loader Example
 ```
 OPT_DEFS += -DBOOTLOADER_SIZE=4096
 ```
 ### Build Options
 There are a number of features that can be turned on or off in `rules.mk`. See the [Config Options](config_options.md#feature-options) page for a detailed list and description.
--- a/docs/hardware_drivers.md
+++ b/docs/hardware_drivers.md
@ -1,27 +0,0 @@
 # QMK Hardware Drivers
 QMK is used on a lot of different hardware. While support for the most common MCU's and matrix configurations is built-in there are a number of drivers that can be added to a keyboard to support additional hardware. Examples include mice and other pointing devices, i/o expanders for split keyboards, bluetooth modules, and LCD, OLED, and TFT screens.
 <!-- FIXME: This should talk about how drivers are integrated into QMK and how you can add your own driver.
 # Driver System Overview
 -->
 # Available Drivers
 ## ProMicro (AVR only)
 Support for addressing pins on the ProMicro by their Arduino name rather than their AVR name. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 ## SSD1306 (AVR only)
 Support for SSD1306 based OLED displays. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 ## uGFX
 You can make use of uGFX within QMK to drive character and graphic LCD's, LED arrays, OLED, TFT, and other display technologies. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 ## WS2812 (AVR only)
 Support for WS2811/WS2812{a,b,c} LED's. For more information see the [RGB Light](feature_rgblight.md) page.
--- a/docs/feature_key_lock.md
+++ b/docs/feature_key_lock.md
--- a/docs/keycodes.md
+++ b/docs/keycodes.md
@ -187,22 +187,22 @@ When defining a [keymap](keymap.md) each key needs a valid key definition. This
 |`KC_KP_EQUAL_AS400`||Keypad Equal Sign|
 |`KC_NO`||Ignore this key. (NOOP) |
 |`KC_TRNS`||Make this key transparent to find the key on a lower layer.|
-|[`KC_MS_UP`](feature_mouse_keys.md)|`KC_MS_U`|Mouse Cursor Up|
+|[`KC_MS_UP`](mouse_keys.md)|`KC_MS_U`|Mouse Cursor Up|
-|[`KC_MS_DOWN`](feature_mouse_keys.md)|`KC_MS_D`|Mouse Cursor Down|
+|[`KC_MS_DOWN`](mouse_keys.md)|`KC_MS_D`|Mouse Cursor Down|
-|[`KC_MS_LEFT`](feature_mouse_keys.md)|`KC_MS_L`|Mouse Cursor Left|
+|[`KC_MS_LEFT`](mouse_keys.md)|`KC_MS_L`|Mouse Cursor Left|
-|[`KC_MS_RIGHT`](feature_mouse_keys.md)|`KC_MS_R`|Mouse Cursor Right|
+|[`KC_MS_RIGHT`](mouse_keys.md)|`KC_MS_R`|Mouse Cursor Right|
-|[`KC_MS_BTN1`](feature_mouse_keys.md)|`KC_BTN1`|Mouse Button 1|
+|[`KC_MS_BTN1`](mouse_keys.md)|`KC_BTN1`|Mouse Button 1|
-|[`KC_MS_BTN2`](feature_mouse_keys.md)|`KC_BTN2`|Mouse Button 2|
+|[`KC_MS_BTN2`](mouse_keys.md)|`KC_BTN2`|Mouse Button 2|
-|[`KC_MS_BTN3`](feature_mouse_keys.md)|`KC_BTN3`|Mouse Button 3|
+|[`KC_MS_BTN3`](mouse_keys.md)|`KC_BTN3`|Mouse Button 3|
-|[`KC_MS_BTN4`](feature_mouse_keys.md)|`KC_BTN4`|Mouse Button 4|
+|[`KC_MS_BTN4`](mouse_keys.md)|`KC_BTN4`|Mouse Button 4|
-|[`KC_MS_BTN5`](feature_mouse_keys.md)|`KC_BTN5`|Mouse Button 5|
+|[`KC_MS_BTN5`](mouse_keys.md)|`KC_BTN5`|Mouse Button 5|
-|[`KC_MS_WH_UP`](feature_mouse_keys.md)|`KC_WH_U`|Mouse Wheel Up|
+|[`KC_MS_WH_UP`](mouse_keys.md)|`KC_WH_U`|Mouse Wheel Up|
-|[`KC_MS_WH_DOWN`](feature_mouse_keys.md)|`KC_WH_D`|Mouse Wheel Down|
+|[`KC_MS_WH_DOWN`](mouse_keys.md)|`KC_WH_D`|Mouse Wheel Down|
-|[`KC_MS_WH_LEFT`](feature_mouse_keys.md)|`KC_WH_L`|Mouse Wheel Left|
+|[`KC_MS_WH_LEFT`](mouse_keys.md)|`KC_WH_L`|Mouse Wheel Left|
-|[`KC_MS_WH_RIGHT`](feature_mouse_keys.md)|`KC_WH_R`|Mouse Wheel Right|
+|[`KC_MS_WH_RIGHT`](mouse_keys.md)|`KC_WH_R`|Mouse Wheel Right|
-|[`KC_MS_ACCEL0`](feature_mouse_keys.md)|`KC_ACL0`|Mouse Acceleration 0|
+|[`KC_MS_ACCEL0`](mouse_keys.md)|`KC_ACL0`|Mouse Acceleration 0|
-|[`KC_MS_ACCEL1`](feature_mouse_keys.md)|`KC_ACL1`|Mouse Acceleration 1|
+|[`KC_MS_ACCEL1`](mouse_keys.md)|`KC_ACL1`|Mouse Acceleration 1|
-|[`KC_MS_ACCEL2`](feature_mouse_keys.md)|`KC_ACL2`|Mouse Acceleration 2|
+|[`KC_MS_ACCEL2`](mouse_keys.md)|`KC_ACL2`|Mouse Acceleration 2|
 |[`RESET`](quantum_keycodes.md#qmk-keycodes)||Put the keyboard into DFU mode for flashing|
 |[`DEBUG`](quantum_keycodes.md#qmk-keycodes)||Toggles debug mode|
 |[`KC_GESC`](quantum_keycodes.md#qmk-keycodes)|`GRAVE_ESC`|Acts as escape when pressed normally but when pressed with Shift or GUI will send a `~`|
@ -311,5 +311,5 @@ When defining a [keymap](keymap.md) each key needs a valid key definition. This
 |[`TT(layer)`](feature_common_shortcuts.md#switching-and-toggling-layers)||tap toggle? idk FIXME`|
 |[`OSM(mod)`](quantum_keycodes.md#one-shot-keys)||hold mod for one keypress|
 |[`OSL(layer)`](quantum_keycodes.md#one-shot-keys)||switch to layer for one keypress|
-|[`UNICODE(n)`](feature_unicode.md)|[`UC(n)`](feature_unicode.md)|if `UNICODE_ENABLE`, this will send characters up to `0x7FFF`|
+|[`UNICODE(n)`](unicode.md)|[`UC(n)`](unicode.md)|if `UNICODE_ENABLE`, this will send characters up to `0x7FFF`|
-|[`X(n)`](feature_unicode.md)||if `UNICODEMAP_ENABLE`, also sends unicode via a different method|
+|[`X(n)`](unicode.md)||if `UNICODEMAP_ENABLE`, also sends unicode via a different method|
--- a/docs/keymap.md
+++ b/docs/keymap.md
@ -79,7 +79,7 @@ Key with `KC_TRANS` (`KC_TRNS` and `_______` are the alias) doesn't has its own
 ## Anatomy Of A `keymap.c`
-For this example we will walk through the [default Clueboard 66% keymap](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard_66/keymaps/default/keymap.c). You'll find it helpful to open that file in another browser window so you can look at everything in context.
+For this example we will walk through the [default Clueboard keymap](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/keymaps/default/keymap.c). You'll find it helpful to open that file in another browser window so you can look at everything in context.
 There are 3 main sections of a `keymap.c` file you'll want to concern yourself with:
--- a/docs/feature_macros.md
+++ b/docs/feature_macros.md
--- a/docs/feature_mouse_keys.md
+++ b/docs/feature_mouse_keys.md
--- a/docs/porting_your_keyboard_to_qmk.md
+++ b/docs/porting_your_keyboard_to_qmk.md
@ -0,0 +1,63 @@
 # Porting your keyboard to QMK
 This page describes the technical details of porting an existing keyboard to QMK. If you're looking to add your keyboard to QMK, please [look through these guidelines](adding_a_keyboard_to_qmk.md)!
 If your keyboard is running an Atmega chip (atmega32u4 and others), it's pretty easy to get things setup for compiling your own firmware to flash onto your board. There is a `/util/new_project.sh <keyboard>` script to help get you started - you can simply pass your keyboard's name into the script, and all of the necessary files will be created. The components of each are described below.
 ## `/keyboards/<keyboard>/config.h`
 The `USB Device descriptor parameter` block contains parameters are used to uniquely identify your keyboard, but they don't really matter to the machine.
 Your `MATRIX_ROWS` and `MATRIX_COLS` are the numbers of rows and cols in your keyboard matrix - this may be different than the number of actual rows and columns on your keyboard. There are some tricks you can pull to increase the number of keys in a given matrix, but most keyboards are pretty straight-forward.
 The `MATRIX_ROW_PINS` and `MATRIX_COL_PINS` are the pins your MCU uses on each row/column. Your schematic (if you have one) will have this information on it, and the values will vary depending on your setup. This is one of the most important things to double-check in getting your keyboard setup correctly.
 For the `DIODE_DIRECTION`, most hand-wiring guides will instruct you to wire the diodes in the `COL2ROW` position, but it's possible that they are in the other - people coming from EasyAVR often use `ROW2COL`. Nothing will function if this is incorrect.
 `BACKLIGHT_PIN` is the pin that your PWM-controlled backlight (if one exists) is hooked-up to. Currently only B5, B6, and B7 are supported.
 `BACKLIGHT_BREATHING` is a fancier backlight feature that adds breathing/pulsing/fading effects to the backlight. It uses the same timer as the normal backlight. These breathing effects must be called by code in your keymap.
 `BACKLIGHT_LEVELS` is how many levels exist for your backlight - max is 15, and they are computed automatically from this number.
 ## `/keyboards/<keyboard>/rules.mk`
 The values at the top likely won't need to be changed, since most boards use the `atmega32u4` chip. The `BOOTLOADER_SIZE` will need to be adjusted based on your MCU type. It's defaulted to the Teensy, since that's the most common controller. Below is quoted from the `Makefile`.
 ```
 # Boot Section Size in *bytes*
 #   Teensy halfKay   512
 #   Teensy++ halfKay 1024
 #   Atmel DFU loader 4096
 #   LUFA bootloader  4096
 #   USBaspLoader     2048
 OPT_DEFS += -DBOOTLOADER_SIZE=512
 ```
 At the bottom of the file, you'll find lots of features to turn on and off - all of these options should be set with `?=` to allow for the keymap overrides. `?=` only assigns if the variable was previously undefined. For the full documenation of these features, see the [Makefile options](getting_started_make_guide.md#makefile-options).
 ## `/keyboards/<keyboard>/readme.md`
 This is where you'll describe your keyboard - please write as much as you can about it! Talking about default functionality/features is useful here. Feel free to link to external pages/sites if necessary. Images can be included here as well, as long as they're hosted elsewhere (imgur).
 ## `/keyboards/<keyboard>/<keyboard>.c`
 This is where all of the custom logic for your keyboard goes - you may not need to put anything in this file, since a lot of things are configured automatically. All of the `*_kb()` functions are defined here. If you modify them, remember to keep the calls to `*_user()`, or things in the keymaps might not work. You can read more about the functions [here](custom_quantum_functions.md).
 ## `/keyboards/<keyboard>/<keyboard>.h`
 Here is where you can (optionally) define your `KEYMAP` function to remap your matrix into a more readable format. With ortholinear boards, this isn't always necessary, but it can help to accomodate the dead spots on your matrix, where there are keys that take up more than one space (2u, staggering, 6.25u, etc). The example shows the difference between the physical keys, and the matrix design:
 ```
 #define KEYMAP( \
    k00, k01, k02, \
      k10,  k11   \
 ) \
 { \
    { k00, k01,   k02 }, \
    { k10, KC_NO, k11 }, \
 }
 ```
 Each of the `kxx` variables needs to be unique, and usually follows the format `k<row><col>`. You can place `KC_NO` where your dead keys are in your matrix.
--- a/docs/quantum_keycodes.md
+++ b/docs/quantum_keycodes.md
@ -16,7 +16,7 @@ On this page we have documented keycodes between `0x00FF` and `0xFFFF` which are
 |`KC_LSPO`|Left shift when held, open paranthesis when tapped|
 |`KC_RSPC`|Right shift when held, close paranthesis when tapped|
 |`KC_LEAD`|The [leader key](feature_leader_key.md)|
-|`KC_LOCK`|The [lock key](feature_key_lock.md)|
+|`KC_LOCK`|The [lock key](key_lock.md)|
 |`FUNC(n)`/`F(n)`|Call `fn_action(n)` (deprecated)|
 |`M(n)`|to call macro n|
 |`MACROTAP(n)`|to macro-tap n idk FIXME|
--- a/docs/redirects.json
+++ b/docs/redirects.json
@ -1,44 +1,12 @@
 {
    "redirects": [
            {
                "from": "adding_a_keyboard_to_qmk.html",
                "to": "hardware_keyboard_guidelines.html"
            },
            {
                "from": "build_environment_setup.html",
                "to": "getting_started_build_tools.html"
            },
            {
                "from": "dynamic_macros.html",
                "to": "feature_dynamic_macros.html"
            },
            {
                "from": "feature_common_shortcuts.html",
                "to": "feature_advanced_keycodes.html"
            },
            {
                "from": "key_lock.html",
                "to": "feature_key_lock.html"
            },
            {
                "from": "make_instructions.html",
                "to": "getting_started_make_guide.html"
            },
            {
                "from": "porting_your_keyboard_to_qmk.html",
                "to": "hardware_avr.html"
            },
            {
                "from": "space_cadet_shift.html",
                "to": "feature_space_cadet.html"
            },
            {
                "from": "tap_dance.html",
                "to": "feature_tap_dance.html"
            },
            {
                "from": "unicode.html",
                "to": "feature_unicode.html"
            }
        ]
-}
+}
--- a/docs/feature_space_cadet.md
+++ b/docs/feature_space_cadet.md
--- a/docs/feature_tap_dance.md
+++ b/docs/feature_tap_dance.md
@ -63,23 +63,20 @@ qk_tap_dance_action_t tap_dance_actions[] = {
 TD(TD_ESC_CAPS)
 ```
-## Complex Examples
+## Complex Example
-This section details several complex tap dance examples.
+Here's a more complex example involving custom actions:
 All the enums used in the examples are declared like this:
 ```c
 // Enums defined for all examples:
 enum {
 CT_SE = 0,
 CT_CLN,
 CT_EGG,
 CT_FLSH,
 X_TAP_DANCE
 };
-```
+
-### Example 1: Send `:` on single tap, `;` on double tap
+/* Have the above three on the keymap, TD(CT_SE), etc... */
-```c
+
 void dance_cln_finished (qk_tap_dance_state_t *state, void *user_data) {
  if (state->count == 1) {
    register_code (KC_RSFT);
@ -98,13 +95,6 @@ void dance_cln_reset (qk_tap_dance_state_t *state, void *user_data) {
  }
 }
 //All tap dance functions would go here. Only showing this one.
 qk_tap_dance_action_t tap_dance_actions[] = {
 [CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finished, dance_cln_reset)
 };
 ```
 ### Example 2: Send "Safety Dance!" after 100 taps
 ```c
 void dance_egg (qk_tap_dance_state_t *state, void *user_data) {
  if (state->count >= 100) {
    SEND_STRING ("Safety dance!");
@ -112,14 +102,6 @@ void dance_egg (qk_tap_dance_state_t *state, void *user_data) {
  }
 }
 qk_tap_dance_action_t tap_dance_actions[] = {
 [CT_EGG] = ACTION_TAP_DANCE_FN (dance_egg)
 };
 ```
 ### Example 3: Turn LED lights on then off, one at a time
 ```c
 // on each tap, light up one led, from right to left
 // on the forth tap, turn them off from right to left
 void dance_flsh_each(qk_tap_dance_state_t *state, void *user_data) {
@ -159,7 +141,6 @@ void dance_flsh_reset(qk_tap_dance_state_t *state, void *user_data) {
  ergodox_right_led_3_off();
 }
 //All tap dances now put together. Example 3 is "CT_FLASH"
 qk_tap_dance_action_t tap_dance_actions[] = {
  [CT_SE]  = ACTION_TAP_DANCE_DOUBLE (KC_SPC, KC_ENT)
 ,[CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finished, dance_cln_reset)
@ -167,84 +148,3 @@ qk_tap_dance_action_t tap_dance_actions[] = {
 ,[CT_FLSH] = ACTION_TAP_DANCE_FN_ADVANCED (dance_flsh_each, dance_flsh_finished, dance_flsh_reset)
 };
 ```
 ### Example 4: 'Quad Function Tap-Dance'
 By [DanielGGordon](https://github.com/danielggordon)
 Allow one key to have 4 (or more) functions, depending on number of presses, and if the key is held or tapped.
 Below is a specific example:
 *  Tap = Send `x`
 *  Hold = Send `Control`
 *  Double Tap = Send `Escape`
 *  Double Tap and Hold = Send `Alt`
 The following example can be easily expanded to more than 4 quite easily:
 ```c
 //**************** Definitions needed for quad function to work *********************//
 //Enums used to clearly convey the state of the tap dance
 enum {
  SINGLE_TAP = 1,
  SINGLE_HOLD = 2,
  DOUBLE_TAP = 3,
  DOUBLE_HOLD = 4, 
  DOUBLE_SINGLE_TAP = 5 //send SINGLE_TAP twice - NOT DOUBLE_TAP
  // Add more enums here if you want for triple, quadruple, etc. 
 };
 typedef struct {
  bool is_press_action;
  int state;
 } tap;
 int cur_dance (qk_tap_dance_state_t *state) {
  if (state->count == 1) {
    //If count = 1, and it has been interrupted - it doesn't matter if it is pressed or not: Send SINGLE_TAP
    if (state->interrupted || state->!pressed) return SINGLE_TAP;
    else return SINGLE_HOLD;
  }
  //If count = 2, and it has been interrupted - assume that user is trying to type the letter associated
  //with single tap. In example below, that means to send `xx` instead of `Escape`.
  else if (state->count = 2) {
    if (state->interrupted) return DOUBLE_SINGLE_TAP;
    else if (state->pressed) return DOUBLE_HOLD;
    else return DOUBLE_TAP;
  } 
  else return 6; //magic number. At some point this method will expand to work for more presses
 }
 //**************** Definitions needed for quad function to work *********************//
 //instanalize an instance of 'tap' for the 'x' tap dance.
 static tap xtap_state = { 
  .is_press_action = true,
  .state = 0
 };
 void x_finished (qk_tap_dance_state_t *state, void *user_data) {
  xtap_state.state = cur_dance(state);
  switch (xtap_state.state) {
    case SINGLE_TAP: register_code(KC_X); break;
    case SINGLE_HOLD: register_code(KC_LCTRL); break;
    case DOUBLE_TAP: register_code(KC_ESC); break;
    case DOUBLE_HOLD: register_code(KC_LALT); break;
    case DOUBLE_SINGLE_TAP: register_code(KC_X); unregister_code(KC_X); register_code(KC_X);
    //Last case is for fast typing. Assuming your key is `f`:
    //For example, when typing the word `buffer`, and you want to make sure that you send `ff` and not `Esc`.
    //In order to type `ff` when typing fast, the next character will have to be hit within the `TAPPING_TERM`, which by default is 200ms.
  }
 }
 void x_reset (qk_tap_dance_state_t *state, void *user_data) {
  switch (xtap_state.state) {
    case SINGLE_TAP: unregister_code(KC_X); break;
    case SINGLE_HOLD: unregister_code(KC_LCTRL); break;
    case DOUBLE_TAP: unregister_code(KC_ESC); break;
    case DOUBLE_HOLD: unregister_code(KC_LALT);
    case DOUBLE_SINGLE_TAP: unregister_code(KC_X);
  }
  xtap_state.state = 0;
 }
 ```
 And then simply add this to your list of tap dance functions:
 `[X_TAP_DANCE] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, x_finished, x_reset)`
--- a/docs/feature_unicode.md
+++ b/docs/feature_unicode.md
--- a/keyboards/amj40/keymaps/default/keymap.c
+++ b/keyboards/amj40/keymaps/default/keymap.c
@ -1,5 +1,7 @@
 // This is the canonical layout file for the Quantum project. If you want to add another keyboard,
 // this is the style you want to emulate.
 #include "amj40.h"
--- a/keyboards/amj60/keymaps/default/keymap.c
+++ b/keyboards/amj60/keymaps/default/keymap.c
@ -1,59 +0,0 @@
 #include "amj60.h"
 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
 // Layer names don't all need to be of the same length, obviously, and you can also skip them
 // entirely and just use numbers.
 #define _DEF 0
 #define _SPC 1
 // dual-role shortcuts
 #define SPACEDUAL LT(_SPC, KC_SPACE)
 // increase readability 
 #define _______ KC_TRNS
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    /* Keymap _DEF: Default Layer
     * ,-----------------------------------------------------------.
     * |Esc|  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =| \ | ~ |
     * |-----------------------------------------------------------|
     * |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]| bspc|
     * |-----------------------------------------------------------|
     * |Caps   | A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '| Return |
     * |-----------------------------------------------------------|
     * |Sft | Fn0|  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /| Sft |Fn2|
     * |-----------------------------------------------------------|
     * |Ctrl|Win |Alt |      Space/Fn0         |Alt |Win |Menu|RCtl|
     * `-----------------------------------------------------------'
     */
    [_DEF] = KEYMAP_MAX(
        KC_ESC,   KC_1,    KC_2,    KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9,    KC_0,    KC_MINS, KC_EQL, KC_BSLS, KC_GRV, \
        KC_TAB,   KC_Q,    KC_W,    KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O,    KC_P,    KC_LBRC, KC_RBRC,    KC_BSPC,  \
        KC_CAPS,  KC_A,    KC_S,    KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L,    KC_SCLN, KC_QUOT, KC_ENT,   \
        KC_LSFT,  F(0),    KC_Z,    KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,    F(1),     \
        KC_LCTL,  KC_LALT, KC_LGUI,             SPACEDUAL,                       KC_RGUI, KC_RALT, KC_RCTL,    F(2)),
    /* Keymap 1: F-and-vim Layer, modified with Space (by holding space)
     * ,-----------------------------------------------------------.
     * |PrSc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|   |  |
     * |-----------------------------------------------------------|
     * |    |Paus| Up| [ | ] |   |   |   | ( | ) |   |   |   | Del |
     * |-----------------------------------------------------------|
     * |      |Lft|Dwn|Rgt|   |   |Left|Down|Right|Up|  |   | PLAY |
     * |-----------------------------------------------------------|
     * |    |   |   |   | < | > |   |M0 |   |   |   |   | Vol+ |   |
     * |-----------------------------------------------------------|
     * |    |    |    |                        |Alt |Prev|Vol-|Next|
     * `-----------------------------------------------------------'
     */
    [_SPC] = KEYMAP_MAX(
        KC_PSCR, KC_F1,   KC_F2,   KC_F3,    KC_F4,   KC_F5,   KC_F6,    KC_F7,     KC_F8,     KC_F9,   KC_F10,  KC_F11,  KC_F12,  _______, _______,  \
        _______, KC_PAUS, KC_UP,   _______,  _______, _______, _______,  _______, _______, _______, _______, _______, _______, KC_DEL, \
        _______, KC_LEFT, KC_DOWN, KC_RIGHT, _______, _______, KC_LEFT,  KC_DOWN,   KC_UP,     KC_RGHT, _______, _______, KC_MPLY, \
        _______, _______, _______, _______,  _______, _______, KC_SPACE, M(0),      _______,   _______, _______, _______, KC_VOLU, _______, \
        _______, _______, _______,                                  _______,                                 _______, KC_MPRV, KC_VOLD, KC_MNXT),
 };
--- a/keyboards/amj60/keymaps/iso_split_rshift/keymap.c
+++ b/keyboards/amj60/keymaps/iso_split_rshift/keymap.c
@ -1,3 +1,5 @@
 // This is the canonical layout file for the Quantum project. If you want to add another keyboard,
 // this is the style you want to emulate.
 #include "amj60.h"
--- a/keyboards/amj60/keymaps/maximized/keymap.c
+++ b/keyboards/amj60/keymaps/maximized/keymap.c
@ -1,3 +1,5 @@
 // This is the canonical layout file for the Quantum project. If you want to add another keyboard,
 // this is the style you want to emulate.
 #include "amj60.h"
--- a/keyboards/clueboard/66/66.c
+++ b/keyboards/clueboard/66/66.c
@ -1 +0,0 @@
 #include "66.h"
--- a/keyboards/clueboard/card/keymaps/default/readme.md
+++ b/keyboards/clueboard/card/keymaps/default/readme.md
@ -1,3 +0,0 @@
 # The default keymap for cluecard
 Note that this keymap has audio enabled, so the RGB mode button does not go through the different effects.  So the LEDs will still show a static light, that is configurable with the hue, staturation and brightness buttons. You can of course also turn them on and off with the on/off button.
--- a/keyboards/clueboard/readme.md
+++ b/keyboards/clueboard/readme.md
@ -1,13 +0,0 @@
 # Clueboard
 ![Clueboard Logo](https://static1.squarespace.com/static/55c13bdee4b099be5dcb82eb/t/59c9703318b27d1ab34f40df/1508257572555/)
 Clueboard makes fully customizable custom keyboards in a variety of formfactors. Inside this directory you'll find support for the entire line of Clueboard products.
 * Maintainer: [Zach White](https://github.com/skullydazed)
 * Hardware Supported:
  * [`17`](17/): Clueboard "Cluepad" PCB
  * [`60`](60/): Clueboard 60% PCB
  * [`66`](66/): Clueboard 66% PCB
  * [`card`](card/): Special Cluecard PCB
 * Hardware Availability: [clueboard.co](https://clueboard.co/)
--- a/keyboards/clueboard_17/clueboard_17.c
+++ b/keyboards/clueboard_17/clueboard_17.c
@ -1,4 +1,4 @@
-#include "17.h"
+#include "clueboard_17.h"
 int pwm_level;
--- a/keyboards/clueboard_17/clueboard_17.h
+++ b/keyboards/clueboard_17/clueboard_17.h
--- a/keyboards/clueboard_17/config.h
+++ b/keyboards/clueboard_17/config.h
--- a/keyboards/clueboard_17/keymaps/default/keymap.c
+++ b/keyboards/clueboard_17/keymaps/default/keymap.c
@ -1,4 +1,4 @@
-#include "17.h"
+#include "clueboard_17.h"
 #include "backlight.h"
--- a/keyboards/clueboard_17/readme.md
+++ b/keyboards/clueboard_17/readme.md
@ -1,16 +1,15 @@
-# Clueboard 17% (Formerly Cluepad)
+# Cluepad
-![Clueboard 17%](https://static1.squarespace.com/static/55c13bdee4b099be5dcb82eb/5842fbdce3df28eae5ec557e/5844fb2cb8a79bbdfd63bad1/1498501250178/IMGP3931.jpg?format=750w)
+![Cluepad](https://static1.squarespace.com/static/55c13bdee4b099be5dcb82eb/5842fbdce3df28eae5ec557e/5844fb2cb8a79bbdfd63bad1/1498501250178/IMGP3931.jpg?format=750w)
 A basic 17 key numpad PCB.
 * Keyboard Maintainer: [Zach White](https://github.com/skullydazed)
-* Hardware Supported:
+* Hardware Supported: Cluepad PCB 1.0
  * Cluepad PCB 1.0
 * Hardware Availability: [clueboard.co](https://clueboard.co/)
 Make example for this keyboard (after setting up your build environment):
-    make clueboard/17:default
+    make clueboard_17:default
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
--- a/keyboards/clueboard_17/rules.mk
+++ b/keyboards/clueboard_17/rules.mk
--- a/keyboards/clueboard_60/boards/GENERIC_STM32_F303XC/board.c
+++ b/keyboards/clueboard_60/boards/GENERIC_STM32_F303XC/board.c
--- a/keyboards/clueboard_60/boards/GENERIC_STM32_F303XC/board.h
+++ b/keyboards/clueboard_60/boards/GENERIC_STM32_F303XC/board.h
--- a/keyboards/clueboard_60/boards/GENERIC_STM32_F303XC/board.mk
+++ b/keyboards/clueboard_60/boards/GENERIC_STM32_F303XC/board.mk
--- a/keyboards/clueboard_60/bootloader_defs.h
+++ b/keyboards/clueboard_60/bootloader_defs.h
--- a/keyboards/clueboard_60/chconf.h
+++ b/keyboards/clueboard_60/chconf.h
--- a/keyboards/clueboard_60/clueboard_60.c
+++ b/keyboards/clueboard_60/clueboard_60.c
@ -13,7 +13,7 @@
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-#include "60.h"
+#include "clueboard_60.h"
 void matrix_init_kb(void) {
--- a/keyboards/clueboard_60/clueboard_60.h
+++ b/keyboards/clueboard_60/clueboard_60.h
--- a/keyboards/clueboard_60/config.h
+++ b/keyboards/clueboard_60/config.h
--- a/keyboards/clueboard_60/halconf.h
+++ b/keyboards/clueboard_60/halconf.h
--- a/keyboards/clueboard_60/keymaps/default/keymap.c
+++ b/keyboards/clueboard_60/keymaps/default/keymap.c
@ -1,4 +1,4 @@
-#include "60.h"
+#include "clueboard_60.h"
 #define _______ KC_TRNS
--- a/keyboards/clueboard_60/keymaps/default/readme.md
+++ b/keyboards/clueboard_60/keymaps/default/readme.md
--- a/keyboards/clueboard_60/keymaps/default_aek/keymap.c
+++ b/keyboards/clueboard_60/keymaps/default_aek/keymap.c
@ -1,4 +1,4 @@
-#include "60.h"
+#include "clueboard_60.h"
 #define _______ KC_TRNS
--- a/keyboards/clueboard_60/keymaps/default_aek/readme.md
+++ b/keyboards/clueboard_60/keymaps/default_aek/readme.md
--- a/keyboards/clueboard_60/led.c
+++ b/keyboards/clueboard_60/led.c
--- a/keyboards/clueboard_60/matrix.c
+++ b/keyboards/clueboard_60/matrix.c
--- a/keyboards/clueboard_60/mcuconf.h
+++ b/keyboards/clueboard_60/mcuconf.h
--- a/keyboards/clueboard_60/readme.md
+++ b/keyboards/clueboard_60/readme.md
@ -9,6 +9,6 @@ A fully customizable 60% keyboard.
 Make example for this keyboard (after setting up your build environment):
-    make clueboard/60:default
+    make clueboard_60:default:dfu-util
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
--- a/keyboards/clueboard_60/rules.mk
+++ b/keyboards/clueboard_60/rules.mk
--- a/keyboards/clueboard_66/clueboard_66.c
+++ b/keyboards/clueboard_66/clueboard_66.c
@ -0,0 +1 @@
 #include "clueboard_66.h"
--- a/keyboards/clueboard_66/clueboard_66.h
+++ b/keyboards/clueboard_66/clueboard_66.h
--- a/keyboards/clueboard_66/config.h
+++ b/keyboards/clueboard_66/config.h
@ -15,8 +15,8 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-#ifndef CLUEBOARD_66_CONFIG_H
+#ifndef CONFIG_H
-#define CLUEBOARD_66_CONFIG_H
+#define CONFIG_H
 #include "config_common.h"
--- a/keyboards/clueboard_66/keymaps/bloodlvst/Makefile
+++ b/keyboards/clueboard_66/keymaps/bloodlvst/Makefile
--- a/keyboards/clueboard_66/keymaps/bloodlvst/config.h
+++ b/keyboards/clueboard_66/keymaps/bloodlvst/config.h
--- a/keyboards/clueboard_66/keymaps/bloodlvst/keymap.c
+++ b/keyboards/clueboard_66/keymaps/bloodlvst/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/bloodlvst/readme.md
+++ b/keyboards/clueboard_66/keymaps/bloodlvst/readme.md
--- a/keyboards/clueboard_66/keymaps/bloodlvst/rules.mk
+++ b/keyboards/clueboard_66/keymaps/bloodlvst/rules.mk
--- a/keyboards/clueboard_66/keymaps/caps_fn/keymap.c
+++ b/keyboards/clueboard_66/keymaps/caps_fn/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/caps_fn/readme.md
+++ b/keyboards/clueboard_66/keymaps/caps_fn/readme.md
--- a/keyboards/clueboard_66/keymaps/colemak/keymap.c
+++ b/keyboards/clueboard_66/keymaps/colemak/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/default/keymap.c
+++ b/keyboards/clueboard_66/keymaps/default/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/default/readme.md
+++ b/keyboards/clueboard_66/keymaps/default/readme.md
--- a/keyboards/clueboard_66/keymaps/jokrik/keymap.c
+++ b/keyboards/clueboard_66/keymaps/jokrik/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/jokrik/readme.md
+++ b/keyboards/clueboard_66/keymaps/jokrik/readme.md
--- a/keyboards/clueboard_66/keymaps/mac_optimized/keymap.c
+++ b/keyboards/clueboard_66/keymaps/mac_optimized/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/mac_optimized/readme.md
+++ b/keyboards/clueboard_66/keymaps/mac_optimized/readme.md
--- a/keyboards/clueboard_66/keymaps/magicmonty/Makefile
+++ b/keyboards/clueboard_66/keymaps/magicmonty/Makefile
--- a/keyboards/clueboard_66/keymaps/magicmonty/config.h
+++ b/keyboards/clueboard_66/keymaps/magicmonty/config.h
--- a/keyboards/clueboard_66/keymaps/magicmonty/keymap.c
+++ b/keyboards/clueboard_66/keymaps/magicmonty/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/magicmonty/readme.md
+++ b/keyboards/clueboard_66/keymaps/magicmonty/readme.md
--- a/keyboards/clueboard_66/keymaps/magicmonty/rules.mk
+++ b/keyboards/clueboard_66/keymaps/magicmonty/rules.mk
--- a/keyboards/clueboard_66/keymaps/maximised/keymap.c
+++ b/keyboards/clueboard_66/keymaps/maximised/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/maximised/readme.md
+++ b/keyboards/clueboard_66/keymaps/maximised/readme.md
--- a/keyboards/clueboard_66/keymaps/mouse_keys/Makefile
+++ b/keyboards/clueboard_66/keymaps/mouse_keys/Makefile
--- a/keyboards/clueboard_66/keymaps/mouse_keys/keymap.c
+++ b/keyboards/clueboard_66/keymaps/mouse_keys/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/mouse_keys/readme.md
+++ b/keyboards/clueboard_66/keymaps/mouse_keys/readme.md
--- a/keyboards/clueboard_66/keymaps/mouse_keys/rules.mk
+++ b/keyboards/clueboard_66/keymaps/mouse_keys/rules.mk
--- a/keyboards/clueboard_66/keymaps/serubin/Makefile
+++ b/keyboards/clueboard_66/keymaps/serubin/Makefile
--- a/keyboards/clueboard_66/keymaps/serubin/keymap.c
+++ b/keyboards/clueboard_66/keymaps/serubin/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/serubin/readme.md
+++ b/keyboards/clueboard_66/keymaps/serubin/readme.md
--- a/keyboards/clueboard_66/keymaps/serubin/rules.mk
+++ b/keyboards/clueboard_66/keymaps/serubin/rules.mk
--- a/keyboards/clueboard_66/keymaps/shift_fn/keymap.c
+++ b/keyboards/clueboard_66/keymaps/shift_fn/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/shift_fn/readme.md
+++ b/keyboards/clueboard_66/keymaps/shift_fn/readme.md
--- a/keyboards/clueboard_66/keymaps/skully/keymap.c
+++ b/keyboards/clueboard_66/keymaps/skully/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Helpful defines
 #define _______ KC_TRNS
--- a/keyboards/clueboard_66/keymaps/skully/readme.md
+++ b/keyboards/clueboard_66/keymaps/skully/readme.md
--- a/keyboards/clueboard_66/keymaps/smt/keymap.c
+++ b/keyboards/clueboard_66/keymaps/smt/keymap.c
@ -1,4 +1,4 @@
-#include "66.h"
+#include "clueboard_66.h"
 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
--- a/keyboards/clueboard_66/keymaps/smt/readme.md
+++ b/keyboards/clueboard_66/keymaps/smt/readme.md
--- a/Show More
+++ b/Show More
		`@ -1,3 +0,0 @@`
			`# The default keymap for cluecard`

			`Note that this keymap has audio enabled, so the RGB mode button does not go through the different effects. So the LEDs will still show a static light, that is configurable with the hue, staturation and brightness buttons. You can of course also turn them on and off with the on/off button.`
`@ -1,4 +1,4 @@`
	`#include "17.h"`	`#include "clueboard_17.h"`

	`int pwm_level;`	`int pwm_level;`
`@ -1,4 +1,4 @@`
	`#include "60.h"`	`#include "clueboard_60.h"`

	`#define _______ KC_TRNS`	`#define _______ KC_TRNS`