Update README with rules.mk ordering information.

Correct parsing of rules.mk for keyboard revisions
Previously, when looking for rules.mk files, we'd parse the individual folders (A/B/C/D/E) into 5 variables, (A/B/C/D/E, A/B/C/D, A/B/C, A/B, and A). Then, we'd get the final directory names and store _those_ in 5 new variables (A, B, C, D, and E). Then, when looking for the rules.mk, we'd look in root_dir/keyboards/(A|B|C|D|E)/rules.mk, instead of looking in root_dir/keyboards(A|A/B|A/B/C|A/B/C/D|A/B/C/D/E)/rules.mk. This commit changes that logic from the former to the latter.
2018-07-17 00:10:42 -04:00 · 2018-07-17 00:10:42 -04:00 · 2018-07-16 20:08:31 -07:00 · 2018-07-16 22:25:02 -04:00 · 2018-07-16 21:04:32 -04:00 · 2018-07-16 21:04:12 -04:00
2151 changed files with 82974 additions and 44569 deletions
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -11,6 +11,7 @@
        "*.h": "c",
        "*.c": "c",
        "*.cpp": "cpp",
-        "*.hpp": "cpp"
+        "*.hpp": "cpp",
+        "xstddef": "c"
    }
-}
+}
--- a/29
+++ b/29
@@ -67,7 +67,7 @@ $(eval $(call NEXT_PATH_ELEMENT))
 # It's really a very simple if else chain, if you squint enough,
 # but the makefile syntax makes it very verbose.
 # If we are in a subfolder of keyboards
-# 
+#
 # *** No longer needed **
 #
 # ifeq ($(CURRENT_PATH_ELEMENT),keyboards)
@@ -307,11 +307,6 @@ define PARSE_KEYBOARD
    KEYBOARD_FOLDER_PATH_3 := $$(patsubst %/,%,$$(dir $$(KEYBOARD_FOLDER_PATH_2)))
    KEYBOARD_FOLDER_PATH_4 := $$(patsubst %/,%,$$(dir $$(KEYBOARD_FOLDER_PATH_3)))
    KEYBOARD_FOLDER_PATH_5 := $$(patsubst %/,%,$$(dir $$(KEYBOARD_FOLDER_PATH_4)))
-    KEYBOARD_FOLDER_1 := $$(notdir $$(KEYBOARD_FOLDER_PATH_1))
-    KEYBOARD_FOLDER_2 := $$(notdir $$(KEYBOARD_FOLDER_PATH_2))
-    KEYBOARD_FOLDER_3 := $$(notdir $$(KEYBOARD_FOLDER_PATH_3))
-    KEYBOARD_FOLDER_4 := $$(notdir $$(KEYBOARD_FOLDER_PATH_4))
-    KEYBOARD_FOLDER_5 := $$(notdir $$(KEYBOARD_FOLDER_PATH_5))

    KEYMAPS :=
    # get a list of all keymaps
@@ -325,35 +320,35 @@ define PARSE_KEYBOARD
        $$(KEYBOARD_FOLDER_3) $$(KEYBOARD_FOLDER_4) $$(KEYBOARD_FOLDER_5), $$(KEYMAPS)))

    KEYBOARD_LAYOUTS :=
-    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_5)/rules.mk)","")
+    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_5)/rules.mk)","")
      LAYOUTS :=
-      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_5)/rules.mk)
+      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_5)/rules.mk)
      KEYBOARD_LAYOUTS := $$(sort $$(LAYOUTS) $$(KEYBOARD_LAYOUTS))
    endif
-    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_4)/rules.mk)","")
+    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_4)/rules.mk)","")
      LAYOUTS :=
-      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_4)/rules.mk)
+      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_4)/rules.mk)
      KEYBOARD_LAYOUTS := $$(sort $$(LAYOUTS) $$(KEYBOARD_LAYOUTS))
    endif
-    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_3)/rules.mk)","")
+    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_3)/rules.mk)","")
      LAYOUTS :=
-      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_3)/rules.mk)
+      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_3)/rules.mk)
      KEYBOARD_LAYOUTS := $$(sort $$(LAYOUTS) $$(KEYBOARD_LAYOUTS))
    endif
-    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_2)/rules.mk)","")
+    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_2)/rules.mk)","")
      LAYOUTS :=
-      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_2)/rules.mk)
+      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_2)/rules.mk)
      KEYBOARD_LAYOUTS := $$(sort $$(LAYOUTS) $$(KEYBOARD_LAYOUTS))
    endif
-    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_1)/rules.mk)","")
+    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_1)/rules.mk)","")
      LAYOUTS :=
-      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_1)/rules.mk)
+      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_1)/rules.mk)
      KEYBOARD_LAYOUTS := $$(sort $$(LAYOUTS) $$(KEYBOARD_LAYOUTS))
    endif

    LAYOUT_KEYMAPS :=
    $$(foreach LAYOUT,$$(KEYBOARD_LAYOUTS),$$(eval LAYOUT_KEYMAPS += $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/layouts/*/$$(LAYOUT)/*/.)))))
-    
+
    KEYMAPS := $$(sort $$(KEYMAPS) $$(LAYOUT_KEYMAPS))

    # if the rule after removing the start of it is empty (we haven't specified a kemap or target)
--- a/37
+++ b/37
@@ -2,27 +2,8 @@
 # vi: set ft=ruby :

 Vagrant.configure(2) do |config|
-  # You can only have one config.vm.box uncommented at a time
-
-  # Comment this and uncomment another if you don't want to use the minimal Arch box
-  #config.vm.box = "dragon788/arch-ala-elasticdog"
-
  # VMware/Virtualbox 64 bit
  config.vm.box = "phusion/ubuntu-14.04-amd64"
-  #
-  # VMware/Virtualbox 64 bit
-  #config.vm.box = "puphpet/centos65-x64"
-  #
-  # The opensuse boxes don't have dfu-util in their default repositories
-  #
-  # The virtualbox version has tools issues
-  # VMware/Virtualbox 64 bit
-  #config.vm.box = "bento/opensuse-13.2-x86_64"
-  #
-  # Virtualbox only
-  #config.vm.box = "bento/opensuse-13.2-i386"
-  # config.vm.box = ""
-  # config.vm.box = ""

  # This section allows you to customize the Virtualbox VM
  # settings, ie showing the GUI or upping the memory
@@ -81,18 +62,16 @@ Vagrant.configure(2) do |config|
  config.vm.provision "shell", run: "always", path: "./util/install_dependencies.sh", args: "-update"

  config.vm.post_up_message = <<-EOT
-  Log into the VM using 'vagrant ssh' on OSX or from Git Bash (Win)
-  or 'vagrant ssh-config' and Putty or Bitvise SSH or another SSH tool

-  Change directory (cd) to the keyboard you wish to program
-  (Optionally) modify your layout,
-  then run 'make clean'
-  and then 'make' to compile the .eep and .hex files.
-
-  Or you can copy and paste the example line below.
-
-  cd /vagrant; cd keyboards; cd ergodox; make clean; make
+  Log into the VM using 'vagrant ssh'. QMK directory synchronized with host is
+  located at /vagrant
+  To compile the .hex files use make command inside this directory.

+  QMK's make format recently changed to use folder locations and colons:
+     make project_folder:keymap[:target]
+  Examples:
+     make planck/rev4:default:dfu
+     make planck:default

  EOT
 end
--- a/bootloader.mk
+++ b/bootloader.mk
@@ -32,21 +32,41 @@
 ifeq ($(strip $(BOOTLOADER)), atmel-dfu)
    OPT_DEFS += -DBOOTLOADER_ATMEL_DFU
    OPT_DEFS += -DBOOTLOADER_DFU
-    BOOTLOADER_SIZE = 4096
+    ifeq ($(strip $(MCU)), atmega32u4)
+      BOOTLOADER_SIZE = 4096
+    endif
+    ifeq ($(strip $(MCU)), at90usb1286)
+      BOOTLOADER_SIZE = 8192
+    endif
 endif
 ifeq ($(strip $(BOOTLOADER)), lufa-dfu)
    OPT_DEFS += -DBOOTLOADER_LUFA_DFU
    OPT_DEFS += -DBOOTLOADER_DFU
-    BOOTLOADER_SIZE = 4096
+    ifeq ($(strip $(MCU)), atmega32u4)
+      BOOTLOADER_SIZE = 4096
+    endif
+    ifeq ($(strip $(MCU)), at90usb1286)
+      BOOTLOADER_SIZE = 8192
+    endif
 endif
 ifeq ($(strip $(BOOTLOADER)), qmk-dfu)
    OPT_DEFS += -DBOOTLOADER_QMK_DFU
    OPT_DEFS += -DBOOTLOADER_DFU
-    BOOTLOADER_SIZE = 4096
+    ifeq ($(strip $(MCU)), atmega32u4)
+      BOOTLOADER_SIZE = 4096
+    endif
+    ifeq ($(strip $(MCU)), at90usb1286)
+      BOOTLOADER_SIZE = 8192
+    endif
 endif
 ifeq ($(strip $(BOOTLOADER)), halfkay)
    OPT_DEFS += -DBOOTLOADER_HALFKAY
-    BOOTLOADER_SIZE = 512
+    ifeq ($(strip $(MCU)), atmega32u4)
+      BOOTLOADER_SIZE = 512
+    endif
+    ifeq ($(strip $(MCU)), at90usb1286)
+      BOOTLOADER_SIZE = 1024
+    endif
 endif
 ifeq ($(strip $(BOOTLOADER)), caterina)
    OPT_DEFS += -DBOOTLOADER_CATERINA
@@ -59,4 +79,4 @@ endif

 ifdef BOOTLOADER_SIZE
    OPT_DEFS += -DBOOTLOADER_SIZE=$(strip $(BOOTLOADER_SIZE))
-endif
+endif
--- a/build_keyboard.mk
+++ b/build_keyboard.mk
@@ -210,8 +210,8 @@ endif
 USER_PATH := users/$(USER_NAME)

 -include $(USER_PATH)/rules.mk
-ifneq ("$(wildcard users/$(KEYMAP)/config.h)","")
-    CONFIG_H += users/$(KEYMAP)/config.h
+ifneq ("$(wildcard $(USER_PATH)/config.h)","")
+    CONFIG_H += $(USER_PATH)/config.h
 endif


--- a/common.mk
+++ b/common.mk
@@ -3,16 +3,16 @@ include message.mk
 # Directory common source files exist
 TOP_DIR = .
 TMK_DIR = tmk_core
-TMK_PATH = $(TOP_DIR)/$(TMK_DIR)
-LIB_PATH = $(TOP_DIR)/lib
+TMK_PATH = $(TMK_DIR)
+LIB_PATH = lib

 QUANTUM_DIR = quantum
-QUANTUM_PATH = $(TOP_DIR)/$(QUANTUM_DIR)
+QUANTUM_PATH = $(QUANTUM_DIR)

 DRIVER_DIR = drivers
-DRIVER_PATH = $(TOP_DIR)/$(DRIVER_DIR)
+DRIVER_PATH = $(DRIVER_DIR)

-BUILD_DIR := $(TOP_DIR)/.build
+BUILD_DIR := .build

 COMMON_VPATH := $(TOP_DIR)
 COMMON_VPATH += $(TMK_PATH)
@@ -21,4 +21,5 @@ COMMON_VPATH += $(QUANTUM_PATH)/keymap_extras
 COMMON_VPATH += $(QUANTUM_PATH)/audio
 COMMON_VPATH += $(QUANTUM_PATH)/process_keycode
 COMMON_VPATH += $(QUANTUM_PATH)/api
-COMMON_VPATH += $(DRIVER_PATH)
+COMMON_VPATH += $(QUANTUM_PATH)/split_common
+COMMON_VPATH += $(DRIVER_PATH)
--- a/common_features.mk
+++ b/common_features.mk
@@ -114,6 +114,15 @@ ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
    endif
 endif

+ifeq ($(strip $(RGB_MATRIX_ENABLE)), yes)
+    OPT_DEFS += -DRGB_MATRIX_ENABLE
+    SRC += is31fl3731.c
+    SRC += i2c_master.c
+    SRC += $(QUANTUM_DIR)/color.c
+    SRC += $(QUANTUM_DIR)/rgb_matrix.c
+    CIE1931_CURVE = yes
+endif
+
 ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
    OPT_DEFS += -DTAP_DANCE_ENABLE
    SRC += $(QUANTUM_DIR)/process_keycode/process_tap_dance.c
@@ -188,6 +197,12 @@ ifeq ($(strip $(USB_HID_ENABLE)), yes)
    include $(TMK_DIR)/protocol/usb_hid.mk
 endif

+
+ifeq ($(strip $(HD44780_ENABLE)), yes)
+    SRC += drivers/avr/hd44780.c
+	OPT_DEFS += -DHD44780_ENABLE
+endif
+
 QUANTUM_SRC:= \
    $(QUANTUM_DIR)/quantum.c \
    $(QUANTUM_DIR)/keymap_common.c \
@@ -195,5 +210,17 @@ QUANTUM_SRC:= \
    $(QUANTUM_DIR)/process_keycode/process_leader.c

 ifndef CUSTOM_MATRIX
-    QUANTUM_SRC += $(QUANTUM_DIR)/matrix.c
+    ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
+        QUANTUM_SRC += $(QUANTUM_DIR)/split_common/matrix.c
+    else
+        QUANTUM_SRC += $(QUANTUM_DIR)/matrix.c
+    endif
+endif
+
+ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
+    OPT_DEFS += -DSPLIT_KEYBOARD
+    QUANTUM_SRC += $(QUANTUM_DIR)/split_common/split_flags.c \
+                $(QUANTUM_DIR)/split_common/split_util.c \
+                $(QUANTUM_DIR)/split_common/i2c.c \
+                $(QUANTUM_DIR)/split_common/serial.c  
 endif
--- a/keyboards/e6v2/keymaps/amnesia0287/rules.mk
+++ b/keyboards/e6v2/keymaps/amnesia0287/rules.mk
--- a/docs/01_Getting_Started/07_Getting_Help.md
+++ b/docs/01_Getting_Started/07_Getting_Help.md
@@ -1,21 +0,0 @@
-# Getting Help
-
-There are a lot of resources for getting help with QMK.
-
-## Realtime Chat
-
-You can find QMK developers and users on our main [gitter chat room](https://gitter.im/qmk/qmk_firmware). We also have other rooms for more specific discussion:
-
-* [Main Firmware Chat](https://gitter.im/qmk/qmk_firmware)
-* [QMK Toolbox](https://gitter.im/qmk/qmk_toolbox)
-* [Hardware Design Discussion](https://gitter.im/qmk/qmk_hardware)
-* [Web Configurator](https://gitter.im/qmk/qmk_configurator)
-* [Compiler API](https://gitter.im/qmk/qmk_compiler_api)
-
-## OLKB Subreddit
-
-The official QMK forum is [/r/olkb](https://reddit.com/r/olkb) on [reddit.com](https://reddit.com).
-
-## Github Issues
-
-You can open an [issue on GitHub](https://github.com/qmk/qmk_firmware/issues). This is especially handy when your issue will require long-term discussion or debugging.
--- a/docs/03_FAQ/index.md
+++ b/docs/03_FAQ/index.md
@@ -1,6 +0,0 @@
-# Frequently Asked Questions
-
-* [General](03_FAQ/02_General_FAQ.md)
-* [Building or Compiling QMK](03_FAQ/03_Build_Compile_QMK.md)
-* [Debugging and Troubleshooting QMK](03_FAQ/04_Debugging_and_Troubleshooting.md)
-* [Keymap](03_FAQ/05_Keymaps.md)
--- a/docs/05_Features/index.md
+++ b/docs/05_Features/index.md
@@ -1,27 +0,0 @@
-# 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 achieve your goal.
-
-
-* [Advanced Keycodes](Advanced_Keycodes.md) - Change layers, type shifted keys, and more. Go beyond typing simple characters.
-* [Audio](Audio.md) - Connect a speaker to your keyboard for audio feedback, midi support, and music mode.
-* [Auto Shift](Auto_Shift.md) - Tap for the normal key, hold slightly longer for its shifted state.
-* [Backlight](Backlight.md) - LED lighting support for your keyboard.
-* [Bootmagic](Bootmagic.md) - Adjust the behavior of your keyboard using hotkeys.
-* [Dynamic Macros](Dynamic_Macros.md) - Record and playback macros from the keyboard itself.
-* [Key Lock](Key_Lock.md) - Lock a key in the "down" state.
-* [Layouts](Layouts.md) - Use one keymap with any keyboard that supports your layout.
-* [Leader Key](Leader_Key.md) - Tap the leader key followed by a sequence to trigger custom behavior.
-* [Macros](Macros.md) - Send multiple key presses when pressing only one physical key.
-* [Mouse keys](Mouse_Keys.md) - Control your mouse pointer from your keyboard.
-* [Pointing Device](Pointing_Device.md) - Framework for connecting your custom pointing device to your keyboard.
-* [PS2 Mouse](PS_2_Mouse.md) - Driver for connecting a PS/2 mouse directly to your keyboard.
-* [RGB Light](RGB_Lighting.md) - RGB lighting for your keyboard.
-* [Space Cadet Shift](Space_Cadet_Shift.md) - Use your left/right shift keys to type parenthesis and brackets.
-* [Space Cadet Shift Enter](Space_Cadet_Shift_Enter.md) - Combined Shift/Enter keys
-* [Stenography](Stenography.md) - Put your keyboard into Plover mode for stenography use.
-* [Tap Dance](Tap_Dance.md) - Make a single key do as many things as you want.
-* [Terminal](Terminal.md) - CLI interface to the internals of your keyboard.
-* [Thermal Printer](Thermal_Printer.md) - Connect a thermal printer to your keyboard to be able to toggle on a printed log of everything you type.
-* [Unicode](Unicode.md) - Unicode input support.
-* [Userspace](Userspace.md) - Share code between different keymaps and keyboards.
--- a/docs/06_Keycodes/Advanced_Keycodes.md
+++ b/docs/06_Keycodes/Advanced_Keycodes.md
@@ -1 +0,0 @@
-../05_Features/Advanced_Keycodes.md
--- a/docs/06_Keycodes/Backlight.md
+++ b/docs/06_Keycodes/Backlight.md
@@ -1 +0,0 @@
-../05_Features/Backlight.md
--- a/docs/06_Keycodes/Bluetooth.md
+++ b/docs/06_Keycodes/Bluetooth.md
@@ -1 +0,0 @@
-../05_Features/Bluetooth.md
--- a/docs/06_Keycodes/Bootmagic.md
+++ b/docs/06_Keycodes/Bootmagic.md
@@ -1 +0,0 @@
-../05_Features/Bootmagic.md
--- a/docs/06_Keycodes/RGB_Lighting.md
+++ b/docs/06_Keycodes/RGB_Lighting.md
@@ -1 +0,0 @@
-../05_Features/RGB_Lighting.md
--- a/docs/06_Keycodes/Stenography.md
+++ b/docs/06_Keycodes/Stenography.md
@@ -1 +0,0 @@
-../05_Features/Stenography.md
--- a/docs/06_Keycodes/Thermal_Printer.md
+++ b/docs/06_Keycodes/Thermal_Printer.md
@@ -1 +0,0 @@
-../05_Features/Thermal_Printer.md
--- a/docs/07_Reference/index.md
+++ b/docs/07_Reference/index.md
@@ -1,9 +0,0 @@
-* [Keyboard Guidelines](01_Keyboard_Guidelines.md)
-* [Compatable Microcontrollers](Compatable_Microcontrollers.md)
-* [Config Options](Config_Options.md)
-* [Custom Code](Custom_Code.md)
-* [Documentation Best Practices](Documentation_Best_Practices.md)
-* [Documentation Templates](Documentation_Templates.md)
-* [Glossary](Glossary.md)
-* [Keymap Overview](Keymap_Overview.md)
-* [Unit Testing](Unit_Testing.md)
--- a/docs/08_For_Makers_And_Modders/index.md
+++ b/docs/08_For_Makers_And_Modders/index.md
@@ -1,2 +0,0 @@
-* [Hand Wiring Guide](Hand_Wiring_Guide.md)
-* [ISP Flashing Guide](ISP_Flashing_Guide.md)
--- a/docs/09_IDEs/index.md
+++ b/docs/09_IDEs/index.md
@@ -1 +0,0 @@
-* [Eclipse](Eclipse.md)
--- a/docs/CNAME
+++ b/docs/CNAME
@@ -0,0 +1 @@
+docs.qmk.fm
--- a/docs/For_a_Deeper_Understanding/index.md
+++ b/docs/For_a_Deeper_Understanding/index.md
@@ -1,2 +0,0 @@
-* [How Keyboards Work](How_Keyboards_Work.md)
-* [Understanding QMK](Understanding_QMK.md)
--- a/docs/Internals/internals_midi_device.md
+++ b/docs/Internals/internals_midi_device.md
@@ -1,143 +0,0 @@
-# group `midi_device` {#group__midi__device}
-
-You use the functions when you are implementing your own midi device.
-
-You set a send function to actually send bytes via your device, this method is called when you call a send function with this device, for instance midi_send_cc
-
-You use the midi_device_input to process input data from the device and pass it through the device's associated callbacks.
-
-You use the midi_device_set_pre_input_process_func if you want to have a function called at the beginning of the device's process function, generally to poll for input and pass that into midi_device_input
-
-## Summary
-
- Members                        | Descriptions                                
--------------------------------|---------------------------------------------
-`define `[`MIDI_INPUT_QUEUE_LENGTH`](#group__midi__device_1ga4aaa419caebdca2bbdfc1331e79781a8)            | 
-`enum `[`input_state_t`](#group__midi__device_1gac203e877d3df4275ceb8e7180a61f621)            | 
-`public void `[`midi_device_input`](#group__midi__device_1gad8d3db8eb35d9cfa51ef036a0a9d70db)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t cnt,uint8_t * input)`            | Process input bytes. This function parses bytes and calls the appropriate callbacks associated with the given device. You use this function if you are creating a custom device and you want to have midi input.
-`public void `[`midi_device_set_send_func`](#group__midi__device_1ga59f5a46bdd4452f186cc73d9e96d4673)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_var_byte_func_t send_func)`            | Set the callback function that will be used for sending output data bytes. This is only used if you're creating a custom device. You'll most likely want the callback function to disable interrupts so that you can call the various midi send functions without worrying about locking.
-`public void `[`midi_device_set_pre_input_process_func`](#group__midi__device_1ga4de0841b87c04fc23cb56b6451f33b69)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_no_byte_func_t pre_process_func)`            | Set a callback which is called at the beginning of the midi_device_process call. This can be used to poll for input data and send the data through the midi_device_input function. You'll probably only use this if you're creating a custom device.
-`struct `[`_midi_device`](Internals/internals_midi_device.md#struct__midi__device) | This structure represents the input and output functions and processing data for a midi device.
-
-## Members
-
-#### `define `[`MIDI_INPUT_QUEUE_LENGTH`](#group__midi__device_1ga4aaa419caebdca2bbdfc1331e79781a8) {#group__midi__device_1ga4aaa419caebdca2bbdfc1331e79781a8}
-
-#### `enum `[`input_state_t`](#group__midi__device_1gac203e877d3df4275ceb8e7180a61f621) {#group__midi__device_1gac203e877d3df4275ceb8e7180a61f621}
-
- Values                         | Descriptions                                
--------------------------------|---------------------------------------------
-IDLE            | 
-ONE_BYTE_MESSAGE            | 
-TWO_BYTE_MESSAGE            | 
-THREE_BYTE_MESSAGE            | 
-SYSEX_MESSAGE            | 
-
-#### `public void `[`midi_device_input`](#group__midi__device_1gad8d3db8eb35d9cfa51ef036a0a9d70db)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t cnt,uint8_t * input)` {#group__midi__device_1gad8d3db8eb35d9cfa51ef036a0a9d70db}
-
-Process input bytes. This function parses bytes and calls the appropriate callbacks associated with the given device. You use this function if you are creating a custom device and you want to have midi input.
-
-#### Parameters
-* `device` the midi device to associate the input with 
-
-* `cnt` the number of bytes you are processing 
-
-* `input` the bytes to process
-
-#### `public void `[`midi_device_set_send_func`](#group__midi__device_1ga59f5a46bdd4452f186cc73d9e96d4673)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_var_byte_func_t send_func)` {#group__midi__device_1ga59f5a46bdd4452f186cc73d9e96d4673}
-
-Set the callback function that will be used for sending output data bytes. This is only used if you're creating a custom device. You'll most likely want the callback function to disable interrupts so that you can call the various midi send functions without worrying about locking.
-
-#### Parameters
-* `device` the midi device to associate this callback with 
-
-* `send_func` the callback function that will do the sending
-
-#### `public void `[`midi_device_set_pre_input_process_func`](#group__midi__device_1ga4de0841b87c04fc23cb56b6451f33b69)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_no_byte_func_t pre_process_func)` {#group__midi__device_1ga4de0841b87c04fc23cb56b6451f33b69}
-
-Set a callback which is called at the beginning of the midi_device_process call. This can be used to poll for input data and send the data through the midi_device_input function. You'll probably only use this if you're creating a custom device.
-
-#### Parameters
-* `device` the midi device to associate this callback with 
-
-* `midi_no_byte_func_t` the actual callback function
-
-# struct `_midi_device` {#struct__midi__device}
-
-This structure represents the input and output functions and processing data for a midi device.
-
-A device can represent an actual physical device [serial port, usb port] or something virtual. You should not need to modify this structure directly.
-
-## Summary
-
- Members                        | Descriptions                                
--------------------------------|---------------------------------------------
-`public midi_var_byte_func_t `[`send_func`](Internals/internals_midi_device.md#struct__midi__device_1a25d4c94b4bbccd5b98f1032b469f3ff9) | 
-`public midi_three_byte_func_t `[`input_cc_callback`](Internals/internals_midi_device.md#struct__midi__device_1a6da5236c1bc73877728df92d213a78d1) | 
-`public midi_three_byte_func_t `[`input_noteon_callback`](Internals/internals_midi_device.md#struct__midi__device_1aa10b15cf1a7fb825a5df0d2abbe34a1c) | 
-`public midi_three_byte_func_t `[`input_noteoff_callback`](Internals/internals_midi_device.md#struct__midi__device_1aaf290043078534d3a5a0ea4c840eba84) | 
-`public midi_three_byte_func_t `[`input_aftertouch_callback`](Internals/internals_midi_device.md#struct__midi__device_1acb0b4901c545cec4b28b126f2d8c315f) | 
-`public midi_three_byte_func_t `[`input_pitchbend_callback`](Internals/internals_midi_device.md#struct__midi__device_1a305fea672caeb996f2233bf8cd2bef18) | 
-`public midi_three_byte_func_t `[`input_songposition_callback`](Internals/internals_midi_device.md#struct__midi__device_1a5f3f13638b3fef3fc561ed1bf301d586) | 
-`public midi_two_byte_func_t `[`input_progchange_callback`](Internals/internals_midi_device.md#struct__midi__device_1adaf1da617c9a10a9dcad00ab1959d3da) | 
-`public midi_two_byte_func_t `[`input_chanpressure_callback`](Internals/internals_midi_device.md#struct__midi__device_1ab7ca2925c539915d43974eff604d85f7) | 
-`public midi_two_byte_func_t `[`input_songselect_callback`](Internals/internals_midi_device.md#struct__midi__device_1a89bed8a5a55376120cfc0a62b42f057f) | 
-`public midi_two_byte_func_t `[`input_tc_quarterframe_callback`](Internals/internals_midi_device.md#struct__midi__device_1ad9813e75d22e284f9f65a907d20600f0) | 
-`public midi_one_byte_func_t `[`input_realtime_callback`](Internals/internals_midi_device.md#struct__midi__device_1a9448eba4afb7e43650434748db3777be) | 
-`public midi_one_byte_func_t `[`input_tunerequest_callback`](Internals/internals_midi_device.md#struct__midi__device_1a0cb8fd53e00cf1d4202d4fa04d038e8d) | 
-`public midi_sysex_func_t `[`input_sysex_callback`](Internals/internals_midi_device.md#struct__midi__device_1afff9a0ce641762aaef24c1e6953ec9a2) | 
-`public midi_var_byte_func_t `[`input_fallthrough_callback`](Internals/internals_midi_device.md#struct__midi__device_1abb974ec6d734001b4a0e370f292be503) | 
-`public midi_var_byte_func_t `[`input_catchall_callback`](Internals/internals_midi_device.md#struct__midi__device_1aae0d535129d4fd650edc98eb3f7584f8) | 
-`public midi_no_byte_func_t `[`pre_input_process_callback`](Internals/internals_midi_device.md#struct__midi__device_1aeb0bb8923d66c23d874e177dc4265754) | 
-`public uint8_t `[`input_buffer`](Internals/internals_midi_device.md#struct__midi__device_1a7c5684857d6af4ebc4dc12da27bd6b2a) | 
-`public input_state_t `[`input_state`](Internals/internals_midi_device.md#struct__midi__device_1a69a687d2d1c449ec15a11c07a5722e39) | 
-`public uint16_t `[`input_count`](Internals/internals_midi_device.md#struct__midi__device_1a68dea8e7b6151e89c85c95caa612ee5d) | 
-`public uint8_t `[`input_queue_data`](Internals/internals_midi_device.md#struct__midi__device_1ada41de021135dc423abedcbb30f366ff) | 
-`public `[`byteQueue_t`](#structbyte_queue__t)` `[`input_queue`](#struct__midi__device_1a49c8538a8a02193c58e28a56eb695d8f) | 
-
-## Members
-
-#### `public midi_var_byte_func_t `[`send_func`](Internals/internals_midi_device.md#struct__midi__device_1a25d4c94b4bbccd5b98f1032b469f3ff9) {#struct__midi__device_1a25d4c94b4bbccd5b98f1032b469f3ff9}
-
-#### `public midi_three_byte_func_t `[`input_cc_callback`](Internals/internals_midi_device.md#struct__midi__device_1a6da5236c1bc73877728df92d213a78d1) {#struct__midi__device_1a6da5236c1bc73877728df92d213a78d1}
-
-#### `public midi_three_byte_func_t `[`input_noteon_callback`](Internals/internals_midi_device.md#struct__midi__device_1aa10b15cf1a7fb825a5df0d2abbe34a1c) {#struct__midi__device_1aa10b15cf1a7fb825a5df0d2abbe34a1c}
-
-#### `public midi_three_byte_func_t `[`input_noteoff_callback`](Internals/internals_midi_device.md#struct__midi__device_1aaf290043078534d3a5a0ea4c840eba84) {#struct__midi__device_1aaf290043078534d3a5a0ea4c840eba84}
-
-#### `public midi_three_byte_func_t `[`input_aftertouch_callback`](Internals/internals_midi_device.md#struct__midi__device_1acb0b4901c545cec4b28b126f2d8c315f) {#struct__midi__device_1acb0b4901c545cec4b28b126f2d8c315f}
-
-#### `public midi_three_byte_func_t `[`input_pitchbend_callback`](Internals/internals_midi_device.md#struct__midi__device_1a305fea672caeb996f2233bf8cd2bef18) {#struct__midi__device_1a305fea672caeb996f2233bf8cd2bef18}
-
-#### `public midi_three_byte_func_t `[`input_songposition_callback`](Internals/internals_midi_device.md#struct__midi__device_1a5f3f13638b3fef3fc561ed1bf301d586) {#struct__midi__device_1a5f3f13638b3fef3fc561ed1bf301d586}
-
-#### `public midi_two_byte_func_t `[`input_progchange_callback`](Internals/internals_midi_device.md#struct__midi__device_1adaf1da617c9a10a9dcad00ab1959d3da) {#struct__midi__device_1adaf1da617c9a10a9dcad00ab1959d3da}
-
-#### `public midi_two_byte_func_t `[`input_chanpressure_callback`](Internals/internals_midi_device.md#struct__midi__device_1ab7ca2925c539915d43974eff604d85f7) {#struct__midi__device_1ab7ca2925c539915d43974eff604d85f7}
-
-#### `public midi_two_byte_func_t `[`input_songselect_callback`](Internals/internals_midi_device.md#struct__midi__device_1a89bed8a5a55376120cfc0a62b42f057f) {#struct__midi__device_1a89bed8a5a55376120cfc0a62b42f057f}
-
-#### `public midi_two_byte_func_t `[`input_tc_quarterframe_callback`](Internals/internals_midi_device.md#struct__midi__device_1ad9813e75d22e284f9f65a907d20600f0) {#struct__midi__device_1ad9813e75d22e284f9f65a907d20600f0}
-
-#### `public midi_one_byte_func_t `[`input_realtime_callback`](Internals/internals_midi_device.md#struct__midi__device_1a9448eba4afb7e43650434748db3777be) {#struct__midi__device_1a9448eba4afb7e43650434748db3777be}
-
-#### `public midi_one_byte_func_t `[`input_tunerequest_callback`](Internals/internals_midi_device.md#struct__midi__device_1a0cb8fd53e00cf1d4202d4fa04d038e8d) {#struct__midi__device_1a0cb8fd53e00cf1d4202d4fa04d038e8d}
-
-#### `public midi_sysex_func_t `[`input_sysex_callback`](Internals/internals_midi_device.md#struct__midi__device_1afff9a0ce641762aaef24c1e6953ec9a2) {#struct__midi__device_1afff9a0ce641762aaef24c1e6953ec9a2}
-
-#### `public midi_var_byte_func_t `[`input_fallthrough_callback`](Internals/internals_midi_device.md#struct__midi__device_1abb974ec6d734001b4a0e370f292be503) {#struct__midi__device_1abb974ec6d734001b4a0e370f292be503}
-
-#### `public midi_var_byte_func_t `[`input_catchall_callback`](Internals/internals_midi_device.md#struct__midi__device_1aae0d535129d4fd650edc98eb3f7584f8) {#struct__midi__device_1aae0d535129d4fd650edc98eb3f7584f8}
-
-#### `public midi_no_byte_func_t `[`pre_input_process_callback`](Internals/internals_midi_device.md#struct__midi__device_1aeb0bb8923d66c23d874e177dc4265754) {#struct__midi__device_1aeb0bb8923d66c23d874e177dc4265754}
-
-#### `public uint8_t `[`input_buffer`](Internals/internals_midi_device.md#struct__midi__device_1a7c5684857d6af4ebc4dc12da27bd6b2a) {#struct__midi__device_1a7c5684857d6af4ebc4dc12da27bd6b2a}
-
-#### `public input_state_t `[`input_state`](Internals/internals_midi_device.md#struct__midi__device_1a69a687d2d1c449ec15a11c07a5722e39) {#struct__midi__device_1a69a687d2d1c449ec15a11c07a5722e39}
-
-#### `public uint16_t `[`input_count`](Internals/internals_midi_device.md#struct__midi__device_1a68dea8e7b6151e89c85c95caa612ee5d) {#struct__midi__device_1a68dea8e7b6151e89c85c95caa612ee5d}
-
-#### `public uint8_t `[`input_queue_data`](Internals/internals_midi_device.md#struct__midi__device_1ada41de021135dc423abedcbb30f366ff) {#struct__midi__device_1ada41de021135dc423abedcbb30f366ff}
-
-#### `public `[`byteQueue_t`](#structbyte_queue__t)` `[`input_queue`](#struct__midi__device_1a49c8538a8a02193c58e28a56eb695d8f) {#struct__midi__device_1a49c8538a8a02193c58e28a56eb695d8f}
-
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,8 +1,15 @@
 # Quantum Mechanical Keyboard Firmware

+[![Current Version](https://img.shields.io/github/tag/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/tags)
+[![Build Status](https://travis-ci.org/qmk/qmk_firmware.svg?branch=master)](https://travis-ci.org/qmk/qmk_firmware)
+[![Discord](https://img.shields.io/discord/440868230475677696.svg)](https://discord.gg/Uq7gcHh)
+[![Docs Status](https://img.shields.io/badge/docs-ready-orange.svg)](https://docs.qmk.fm)
+[![GitHub contributors](https://img.shields.io/github/contributors/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/pulse/monthly)
+[![GitHub forks](https://img.shields.io/github/forks/qmk/qmk_firmware.svg?style=social&label=Fork)](https://github.com/qmk/qmk_firmware/)
+
 ## What is QMK Firmware?

-QMK (*Quantum Mechanical Keyboard*) is an open source community that maintains QMK Firmware, QMK Flasher, qmk.fm, and these docs. QMK Firmware is a keyboard firmware based on the [tmk\_keyboard](http://github.com/tmk/tmk_keyboard) with some useful features for Atmel AVR controllers, and more specifically, the [OLKB product line](http://olkb.com), the [ErgoDox EZ](http://www.ergodox-ez.com) keyboard, and the [Clueboard product line](http://clueboard.co/). It has also been ported to ARM chips using ChibiOS. You can use it to power your own hand-wired or custom keyboard PCB.
+QMK (*Quantum Mechanical Keyboard*) is an open source community that maintains QMK Firmware, QMK Toolbox, qmk.fm, and these docs. QMK Firmware is a keyboard firmware based on the [tmk\_keyboard](http://github.com/tmk/tmk_keyboard) with some useful features for Atmel AVR controllers, and more specifically, the [OLKB product line](http://olkb.com), the [ErgoDox EZ](http://www.ergodox-ez.com) keyboard, and the [Clueboard product line](http://clueboard.co/). It has also been ported to ARM chips using ChibiOS. You can use it to power your own hand-wired or custom keyboard PCB.

 ## How to Get It

@@ -12,7 +19,7 @@ Otherwise, you can either download it directly ([zip](https://github.com/qmk/qmk

 ## How to Compile

-Before you are able to compile, you'll need to [install an environment](01_Getting_Started/01_Install_Build_Tools.md) for AVR or/and ARM development. Once that is complete, you'll use the `make` command to build a keyboard and keymap with the following notation:
+Before you are able to compile, you'll need to [install an environment](getting_started_build_tools.md) for AVR or/and ARM development. Once that is complete, you'll use the `make` command to build a keyboard and keymap with the following notation:

    make planck/rev4:default

@@ -22,4 +29,4 @@ This would build the `rev4` revision of the `planck` with the `default` keymap.

 ## How to Customize

-QMK has lots of [features](05_Features/index.md) to explore, and a good deal of [reference documentation](http://docs.qmk.fm) to dig through. Most features are taken advantage of by modifying your [keymap](07_Reference/Keymap_Overview.md), and changing the [keycodes](06_Keycodes/index.md).
+QMK has lots of [features](features.md) to explore, and a good deal of [reference documentation](http://docs.qmk.fm) to dig through. Most features are taken advantage of by modifying your [keymap](keymap.md), and changing the [keycodes](keycodes.md).
--- a/docs/_sidebar.md
+++ b/docs/_sidebar.md
@@ -0,0 +1,104 @@
+* [Getting Started](README.md)
+  * [QMK Introduction](getting_started_introduction.md)
+  * [Install Build Tools](getting_started_build_tools.md)
+    * Alternative: [Vagrant Guide](getting_started_vagrant.md)
+  * [Build/Compile Instructions](getting_started_make_guide.md)
+  * [Flashing Firmware](flashing.md)
+  * [Contributing to QMK](contributing.md)
+  * [How to Use Github](getting_started_github.md)
+  * [Getting Help](getting_started_getting_help.md)
+
+* [Complete Newbs Guide](newbs.md)
+  * [Getting Started](newbs_getting_started.md)
+  * [Building Your First Firmware](newbs_building_firmware.md)
+  * [Flashing Firmware](newbs_flashing.md)
+  * [Testing and Debugging](newbs_testing_debugging.md)
+
+* [FAQ](faq.md)
+  * [General FAQ](faq_general.md)
+  * [Build/Compile QMK](faq_build.md)
+  * [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)
+  * [Audio](feature_audio.md)
+  * [Auto Shift](feature_auto_shift.md)
+  * [Backlight](feature_backlight.md)
+  * [Bootmagic](feature_bootmagic.md)
+  * [Command](feature_command.md)
+  * [Dynamic Macros](feature_dynamic_macros.md)
+  * [Grave Escape](feature_grave_esc.md)
+  * [Key Lock](feature_key_lock.md)
+  * [Layouts](feature_layouts.md)
+  * [Leader Key](feature_leader_key.md)
+  * [Macros](feature_macros.md)
+  * [Mouse Keys](feature_mouse_keys.md)
+  * [Pointing Device](feature_pointing_device.md)
+  * [PS/2 Mouse](feature_ps2_mouse.md)
+  * [RGB Lighting](feature_rgblight.md)
+  * [RGB Matrix](feature_rgb_matrix.md)
+  * [Space Cadet Shift](feature_space_cadet.md)
+  * [Space Cadet Shift Enter](feature_space_shift_cadet.md)
+  * [Stenography](feature_stenography.md)
+  * [Swap Hands](feature_swap_hands.md)
+  * [Tap Dance](feature_tap_dance.md)
+  * [Terminal](feature_terminal.md)
+  * [Thermal Printer](feature_thermal_printer.md)
+  * [Unicode](feature_unicode.md)
+  * [Userspace](feature_userspace.md)
+
+* [Keycodes](keycodes.md)
+  * [Basic](keycodes_basic.md)
+  * [Quantum](quantum_keycodes.md)
+  * [Audio](feature_audio.md#audio-keycodes)
+  * [Backlight](feature_backlight.md#backlight-keycodes)
+  * [Bluetooth](feature_bluetooth.md#bluetooth-keycodes)
+  * [Bootmagic](feature_bootmagic.md#bootmagic-keycodes)
+  * [Layer Switching](feature_advanced_keycodes.md#switching-and-toggling-layers)
+  * [Mod+Key](feature_advanced_keycodes.md#modifier-keys)
+  * [Mod Tap](feature_advanced_keycodes.md#mod-tap)
+  * [Mouse Keys](feature_mouse_keys.md#mapping-mouse-actions-to-keyboard-keys)
+  * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
+  * [RGB Light](feature_rgblight.md#rgblight-keycodes)
+  * [RGB Matrix](feature_rgb_matrix.md#keycodes)
+  * [Shifted Keys](feature_advanced_keycodes.md#shifted-keycodes)
+  * [Stenography](feature_stenography.md#keycode-reference)
+  * [Swap Hands](feature_swap_hands.md#swap-keycodes)
+  * [Thermal Printer](feature_thermal_printer.md#thermal-printer-keycodes)
+  * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.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](reference_glossary.md)
+  * [Keymap Overview](keymap.md)
+  * [Unit Testing](unit_testing.md)
+
+* For Makers and Modders
+  * [Hand Wiring Guide](hand_wire.md)
+  * [ISP Flashing Guide](isp_flashing_guide.md)
+
+* For a Deeper Understanding
+  * [How Keyboards Work](how_keyboards_work.md)
+  * [Understanding QMK](understanding_qmk.md)
+
+* Other Topics
+  * [Using Eclipse with QMK](eclipse.md)
+
+* QMK Internals (In Progress)
+  * [Defines](internals_defines.md)
+  * [Input Callback Reg](internals_input_callback_reg.md)
+  * [Midi Device](internals_midi_device.md)
+  * [Midi Device Setup Process](internals_midi_device_setup_process.md)
+  * [Midi Util](internals_midi_util.md)
+  * [Send Functions](internals_send_functions.md)
+  * [Sysex Tools](internals_sysex_tools.md)
--- a/docs/_summary.md
+++ b/docs/_summary.md
@@ -0,0 +1,104 @@
+* [Getting Started](README.md)
+  * [QMK Introduction](getting_started_introduction.md)
+  * [Install Build Tools](getting_started_build_tools.md)
+    * Alternative: [Vagrant Guide](getting_started_vagrant.md)
+  * [Build/Compile Instructions](getting_started_make_guide.md)
+  * [Flashing Firmware](flashing.md)
+  * [Contributing to QMK](contributing.md)
+  * [How to Use Github](getting_started_github.md)
+  * [Getting Help](getting_started_getting_help.md)
+
+* [Complete Newbs Guide](newbs.md)
+  * [Getting Started](newbs_getting_started.md)
+  * [Building Your First Firmware](newbs_building_firmware.md)
+  * [Flashing Firmware](newbs_flashing.md)
+  * [Testing and Debugging](newbs_testing_debugging.md)
+
+* [FAQ](faq.md)
+  * [General FAQ](faq_general.md)
+  * [Build/Compile QMK](faq_build.md)
+  * [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)
+  * [Audio](feature_audio.md)
+  * [Auto Shift](feature_auto_shift.md)
+  * [Backlight](feature_backlight.md)
+  * [Bootmagic](feature_bootmagic.md)
+  * [Command](feature_command.md)
+  * [Dynamic Macros](feature_dynamic_macros.md)
+  * [Grave Escape](feature_grave_esc.md)
+  * [Key Lock](feature_key_lock.md)
+  * [Layouts](feature_layouts.md)
+  * [Leader Key](feature_leader_key.md)
+  * [Macros](feature_macros.md)
+  * [Mouse Keys](feature_mouse_keys.md)
+  * [Pointing Device](feature_pointing_device.md)
+  * [PS/2 Mouse](feature_ps2_mouse.md)
+  * [RGB Lighting](feature_rgblight.md)
+  * [RGB Matrix](feature_rgb_matrix.md)
+  * [Space Cadet Shift](feature_space_cadet.md)
+  * [Space Cadet Shift Enter](feature_space_shift_cadet.md)
+  * [Stenography](feature_stenography.md)
+  * [Swap Hands](feature_swap_hands.md)
+  * [Tap Dance](feature_tap_dance.md)
+  * [Terminal](feature_terminal.md)
+  * [Thermal Printer](feature_thermal_printer.md)
+  * [Unicode](feature_unicode.md)
+  * [Userspace](feature_userspace.md)
+
+* [Keycodes](keycodes.md)
+  * [Basic](keycodes_basic.md)
+  * [Quantum](quantum_keycodes.md)
+  * [Audio](feature_audio.md#audio-keycodes)
+  * [Backlight](feature_backlight.md#backlight-keycodes)
+  * [Bluetooth](feature_bluetooth.md#bluetooth-keycodes)
+  * [Bootmagic](feature_bootmagic.md#bootmagic-keycodes)
+  * [Layer Switching](feature_advanced_keycodes.md#switching-and-toggling-layers)
+  * [Mod+Key](feature_advanced_keycodes.md#modifier-keys)
+  * [Mod Tap](feature_advanced_keycodes.md#mod-tap)
+  * [Mouse Keys](feature_mouse_keys.md#mapping-mouse-actions-to-keyboard-keys)
+  * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
+  * [RGB Light](feature_rgblight.md#rgblight-keycodes)
+  * [RGB Matrix](feature_rgb_matrix.md#keycodes)
+  * [Shifted Keys](feature_advanced_keycodes.md#shifted-keycodes)
+  * [Stenography](feature_stenography.md#keycode-reference)
+  * [Swap Hands](feature_swap_hands.md#swap-keycodes)
+  * [Thermal Printer](feature_thermal_printer.md#thermal-printer-keycodes)
+  * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.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](reference_glossary.md)
+  * [Keymap Overview](keymap.md)
+  * [Unit Testing](unit_testing.md)
+
+* For Makers and Modders
+  * [Hand Wiring Guide](hand_wire.md)
+  * [ISP Flashing Guide](isp_flashing_guide.md)
+
+* For a Deeper Understanding
+  * [How Keyboards Work](how_keyboards_work.md)
+  * [Understanding QMK](understanding_qmk.md)
+
+* Other Topics
+  * [Using Eclipse with QMK](eclipse.md)
+
+* QMK Internals (In Progress)
+  * [Defines](internals_defines.md)
+  * [Input Callback Reg](internals_input_callback_reg.md)
+  * [Midi Device](internals_midi_device.md)
+  * [Midi Device Setup Process](internals_midi_device_setup_process.md)
+  * [Midi Util](internals_midi_util.md)
+  * [Send Functions](internals_send_functions.md)
+  * [Sysex Tools](internals_sysex_tools.md)
--- a/docs/becoming_a_qmk_collaborator.md.notneeded
+++ b/docs/becoming_a_qmk_collaborator.md.notneeded
--- a/docs/07_Reference/Compatable_Microcontrollers.md
+++ b/docs/07_Reference/Compatable_Microcontrollers.md
--- a/docs/config.json
+++ b/docs/config.json
@@ -1,31 +0,0 @@
-{
-    "title": "QMK Firmware",
-    "tagline": "Keyboard controller firmware for Atmel AVR and ARM USB families",
-    "author": "QMK Community",
-    "image": "gitbook/images/favicon.png",
-    "ignore": {
-	"dirs": [
-            "Internals"
-        ],
-        "files": [
-            "internals_defines.md",
-            "internals_input_callback_reg.md",
-            "internals_midi_device.md",
-            "internals_midi_device_setup_process.md",
-            "internals_midi_util.md",
-            "internals_send_functions.md",
-            "internals_sysex_tools.md"
-        ]
-    },
-    "html": {
-        "auto_landing": false,
-        "auto_toc": true,
-        "breadcrumbs": true,
-        "breadcrumbs_separator": " &emdash;&gt; ",
-        "edit_on_github": "qmk/qmk_firmware/blob/master/docs",
-        "repo": "qmk/qmk_firmware",
-        "search": true,
-        "theme": "daux-navy",
-        "toggle_code": false
-    }
-}
--- a/docs/07_Reference/Config_Options.md
+++ b/docs/07_Reference/Config_Options.md
@@ -123,21 +123,27 @@ If you define these options you will enable the associated feature, which may in
 ## Behaviors That Can Be Configured

 * `#define TAPPING_TERM 200`
-  * how long before a tap becomes a hold
+  * how long before a tap becomes a hold, if set above 500, a key tapped during the tapping term will turn it into a hold too
 * `#define RETRO_TAPPING`
  * tap anyway, even after TAPPING_TERM, if there was no other key interruption between press and release
+  * See [Retro Tapping](feature_advanced_keycodes.md#retro-tapping) for details
 * `#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
+  * See [Permissive Hold](feature_advanced_keycodes.md#permissive-hold) for details
+* `#define IGNORE_MOD_TAP_INTERRUPT`
+  * makes it possible to do rolling combos (zx) with keys that convert to other keys on hold
+  * See [Mod tap interrupt](feature_advanced_keycodes.md#mod-tap-interrupt) for details
+* `#define TAPPING_FORCE_HOLD`
+  * makes it possible to use a dual role key as modifier shortly after having been tapped
+  * See [Hold after tap](feature_advanced_keycodes.md#hold-after-tap)
 * `#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
 * `#define QMK_KEYS_PER_SCAN 4`
  * Allows sending more than one key per scan. By default, only one key event gets
    sent via `process_record()` per scan. This has little impact on most typing, but
@@ -173,6 +179,16 @@ If you define these options you will enable the associated feature, which may in
 * `#define MOUSEKEY_MAX_SPEED 7`
 * `#define MOUSEKEY_WHEEL_DELAY 0`

+## Split Keyboard Options
+
+Split Keyboard specific options, make sure you have 'SPLIT_KEYBOARD = yes' in your rules.mk
+
+* `#define SPLIT_HAND_PIN B7`
+  * For using high/low pin to determine handedness, low = right hand, high = left hand. Replace 'B7' with the pin you are using. This is optional and you can still use the EEHANDS method or MASTER_LEFT / MASTER_RIGHT defines like the stock Let's Split uses.
+  
+* `#define USE_I2C`
+  * For using I2C instead of Serial (defaults to serial)
+
 # The `rules.mk` File

 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.
@@ -184,7 +200,7 @@ This is a [make](https://www.gnu.org/software/make/manual/make.html) file that i
 * `SRC`
  * Used to add files to the compilation/linking list.
 * `LAYOUTS`
-  * A list of [layouts](05_Features/Layouts.md) this keyboard supports.
+  * A list of [layouts](feature_layouts.md) this keyboard supports.

 ## AVR MCU Options
 * `MCU = atmega32u4`
@@ -226,3 +242,5 @@ Use these to enable or disable building certain features. The more you have enab
  * Unicode
 * `BLUETOOTH_ENABLE`
  * Enable Bluetooth with the Adafruit EZ-Key HID
+* `SPLIT_KEYBOARD`
+  * Enables split keyboard support (dual MCU like the let's split and bakingpy's boards) and includes all necessary files located at quantum/split_common
--- a/docs/01_Getting_Started/05_Contributing.md
+++ b/docs/01_Getting_Started/05_Contributing.md
@@ -11,7 +11,7 @@ Third-party contributions help us grow and improve QMK. We want to make the pull

 ## I Don't Want to Read This Whole Thing! I Just Have a Question!

-If you'd like to ask questions about QMK you can do so on the [OLKB Subreddit](https://reddit.com/r/olkb) or on [Gitter](https://gitter.im/qmk/qmk_firmware).
+If you'd like to ask questions about QMK you can do so on the [OLKB Subreddit](https://reddit.com/r/olkb) or on [Discord](https://discord.gg/Uq7gcHh).

 Please keep these things in mind:

@@ -29,7 +29,7 @@ QMK is largely written in C, with specific features and parts written in C++. It

 # Where Can I Go for Help?

-If you need help you can [open an issue](https://github.com/qmk/qmk_firmware/issues) or [chat on gitter](http://gitter.im/QMK/qmk_firmware).
+If you need help you can [open an issue](https://github.com/qmk/qmk_firmware/issues) or [chat on Discord](https://discord.gg/Uq7gcHh).

 # How Do I Make a Contribution?

@@ -101,7 +101,7 @@ You'll find all our documentation in the `qmk_firmware/docs` directory, or if yo

 Most first-time QMK contributors start with their personal keymaps. We try to keep keymap standards pretty casual (keymaps, after all, reflect the personality of their creators) but we do ask that you follow these guidelines to make it easier for others to discover and learn from your keymap.

-* Write a `readme.md` using [the template](https://docs.qmk.fm/documentation_templates.html#).
+* Write a `readme.md` using [the template](documentation_templates.md).
 * All Keymap PR's are squashed, so if you care about how your commits are squashed you should do it yourself
 * Do not lump features in with keymap PR's. Submit the feature first and then a second PR for the keymap.
 * Do not include `Makefile`s in your keymap folder (they're no longer used)
@@ -113,7 +113,7 @@ Keyboards are the raison d'être for QMK. Some keyboards are community maintaine

 We also ask that you follow these guidelines:

-* Write a `readme.md` using [the template](https://docs.qmk.fm/documentation_templates.html#).
+* Write a `readme.md` using [the template](documentation_templates.md).
 * Keep the number of commits reasonable or we will squash your PR
 * Do not lump core features in with new keyboards. Submit the feature first and then submit a separate PR for the keyboard.
 * Name `.c`/`.h` file after the immediate parent folder, eg `/keyboards/<kb1>/<kb2>/<kb2>.[ch]`
@@ -122,9 +122,9 @@ We also ask that you follow these guidelines:

 ## Quantum/TMK Core

-Before you put a lot of work into building your new feature you should make sure you are implementing it in the best way. You can get a basic understanding of QMK by reading [Understanding QMK](For_a_Deeper_Understanding/Understanding_QMK.md), which will take you on a tour of the QMK program flow. From here you should talk to us to get a sense of the best way to implement your idea. There are two main ways to do this:
+Before you put a lot of work into building your new feature you should make sure you are implementing it in the best way. You can get a basic understanding of QMK by reading [Understanding QMK](understanding_qmk.md), which will take you on a tour of the QMK program flow. From here you should talk to us to get a sense of the best way to implement your idea. There are two main ways to do this:

-* [Chat on Gitter](https://gitter.im/qmk/qmk_firmware)
+* [Chat on Discord](https://discord.gg/Uq7gcHh)
 * [Open an Issue](https://github.com/qmk/qmk_firmware/issues/new)

 Feature and Bug Fix PR's affect all keyboards. We are also in the process of restructuring QMK. For this reason it is especially important for significant changes to be discussed before implementation has happened. If you open a PR without talking to us first please be prepared to do some significant rework if your choices do not mesh well with our planned direction.
@@ -140,7 +140,7 @@ We also ask that you follow these guidelines:

 * Keep the number of commits reasonable or we will squash your PR
 * Do not lump keyboards or keymaps in with core changes. Submit your core changes first.
-* Write [Unit Tests](http://docs.qmk.fm/unit_testing.html) for your feature
+* Write [Unit Tests](unit_testing.md) for your feature
 * Follow the style of the file you are editing. If the style is unclear or there are mixed styles you should conform to the [coding conventions](#coding-conventions) above.

 ## Refactoring
--- a/docs/custom_quantum_functions.md
+++ b/docs/custom_quantum_functions.md
@@ -2,7 +2,7 @@

 For a lot of people a custom keyboard is about more than sending button presses to your computer. You want to be able to do things that are more complex than simple button presses and macros. QMK has hooks that allow you to inject code, override functionality, and otherwise customize how your keyboard behaves in different situations.

-This page does not assume any special knowledge about QMK, but reading [Understanding QMK](For_a_Deeper_Understanding/Understanding_QMK.md) will help you understand what is going on at a more fundamental level.
+This page does not assume any special knowledge about QMK, but reading [Understanding QMK](understanding_qmk.md) will help you understand what is going on at a more fundamental level.

 ## A Word on Core vs Keyboards vs Keymap

@@ -135,9 +135,11 @@ void led_set_user(uint8_t usb_led) {
 * Keyboard/Revision: `void led_set_kb(uint8_t usb_led)`
 * Keymap: `void led_set_user(uint8_t usb_led)`

+
 # Matrix Initialization Code

-Before a keyboard can be used the hardware must be initialized. QMK handles initialization of the keyboard matrix itself, but if you have other hardware like LED's or i&#xb2;c controllers you will need to set up that hardware before it can be used.
+Before a keyboard can be used the hardware must be initialized. QMK handles initialization of the keyboard matrix itself, but if you have other hardware like LED's or i&#xb2;c controllers you will need to set up that hardware before it can be used.  
+

 ### Example `matrix_init_user()` Implementation

@@ -165,7 +167,7 @@ Whenever possible you should customize your keyboard by using `process_record_*(

 ### Example `matrix_scan_*` Implementation

-This example has been deliberately omitted. You should understand enough about QMK internals to write this without an example before hooking into such a performance sensitive area. If you need help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) or [chat with us on gitter](https://gitter.im/qmk/qmk_firmware).
+This example has been deliberately omitted. You should understand enough about QMK internals to write this without an example before hooking into such a performance sensitive area. If you need help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) or [chat with us on Discord](https://discord.gg/Uq7gcHh).

 ### `matrix_scan_*` Function Documentation

@@ -177,13 +179,42 @@ This function gets called at every matrix scan, which is basically as often as t
 You should use this function if you need custom matrix scanning code. It can also be used for custom status output (such as LED's or a display) or other functionality that you want to trigger regularly even when the user isn't typing.


+# Keyboard Idling/Wake Code
+
+If the board supports it, it can be "idled", by stopping a number of functions.  A good example of this is RGB lights or backlights.   This can save on power consumption, or may be better behavior for your keyboard.  
+
+This is controlled by two functions: `suspend_power_down_*` and `suspend_wakeup_init_*`, which are called when the system is board is idled and when it wakes up, respectively. 
+
+
+### Example suspend_power_down_user() and suspend_wakeup_init_user() Implementation
+
+This example, at the keyboard level, sets up B1, B2, and B3 as LED pins.
+
+```
+void suspend_power_down_user(void)
+{
+    rgb_matrix_set_suspend_state(true);
+}
+
+void suspend_wakeup_init_user(void)
+{
+    rgb_matrix_set_suspend_state(false);
+}
+
+```
+
+### `keyboard_init_*` Function Documentation
+
+* Keyboard/Revision: `void suspend_power_down_kb(void)` and `void suspend_wakeup_init_user(void)`
+* Keymap: `void suspend_power_down_kb(void)` and `void suspend_wakeup_init_user(void)`
+
 # Layer Change Code

-Thir runs code every time that the layers get changed.  This can be useful for layer indication, or custom layer handling. 
+This runs code every time that the layers get changed.  This can be useful for layer indication, or custom layer handling. 

 ### Example `layer_state_set_*` Implementation

-This example shows how to set the [RGB Underglow](05_Features/RGB_Lighting.md) lights based on the layer, using the Planck as an example
+This example shows how to set the [RGB Underglow](feature_rgblight.md) lights based on the layer, using the Planck as an example

 ```
 uint32_t layer_state_set_user(uint32_t state) {
@@ -212,4 +243,4 @@ uint32_t layer_state_set_user(uint32_t state) {
 * Keyboard/Revision: `void uint32_t layer_state_set_kb(uint32_t state)`
 * Keymap: `uint32_t layer_state_set_user(uint32_t state)`

-The `state` is the bitmask of the active layers, as explained in the [Keymap Overview](07_Reference/Keymap_Overview.md#keymap-layer-status)
+The `state` is the bitmask of the active layers, as explained in the [Keymap Overview](keymap.md#keymap-layer-status)
--- a/docs/07_Reference/Documentation_Best_Practices.md
+++ b/docs/07_Reference/Documentation_Best_Practices.md
@@ -22,60 +22,27 @@ Your page should generally have multiple "H1" headings. Only H1 and H2 headings

 You can have styled hint blocks drawn around text to draw attention to it.

-```
-{% hint style='info' %}
-This uses `hint style='info'`
-{% endhint %}
-```
-
-### Examples:
-
-{% hint style='info' %}
-This uses `hint style='info'`
-{% endhint %}
-
-{% hint style='tip' %}
-This uses `hint style='tip'`
-{% endhint %}
-
-{% hint style='danger' %}
-This uses `hint style='danger'`
-{% endhint %}
-
-{% hint style='working' %}
-This uses `hint style='working'`
-{% endhint %}
-
-# Styled Terminal Blocks
-
-You can present styled terminal blocks by including special tokens inside your text block.
+### Important

 ```
-\`\`\`
-**[terminal]
-**[prompt foo@joe]**[path ~]**[delimiter  $ ]**[command ./myscript]
-Normal output line. Nothing special here...
-But...
-You can add some colors. What about a warning message?
-**[warning [WARNING] The color depends on the theme. Could look normal too]
-What about an error message?
-**[error [ERROR] This is not the error you are looking for]
-\`\`\`
+!> This is important
 ```

-### Example
+Renders as:
+
+!> This is important
+
+### General Tips

 ```
-**[terminal]
-**[prompt foo@joe]**[path ~]**[delimiter  $ ]**[command ./myscript]
-Normal output line. Nothing special here...
-But...
-You can add some colors. What about a warning message?
-**[warning [WARNING] The color depends on the theme. Could look normal too]
-What about an error message?
-**[error [ERROR] This is not the error you are looking for]
+?> This is a helpful tip.
 ```

+Renders as:
+
+?> This is a helpful tip.
+
+
 # Documenting Features

 If you create a new feature for QMK, create a documentation page for it. It doesn't have to be very long, a few sentences describing your feature and a table listing any relevant keycodes is enough. Here is a basic template:
@@ -94,4 +61,4 @@ This page describes my cool feature. You can use my cool feature to make coffee
 |KC_SUGAR||Order Sugar|
 ```

-Place your documentation into `docs/feature_<my_cool_feature>.md`, and add that file to the appropriate place in `docs/_summary.md`. If you have added any keycodes be sure to add them to `docs/06_Keycodes/index.md` with a link back to your feature page.
+Place your documentation into `docs/feature_<my_cool_feature>.md`, and add that file to the appropriate place in `docs/_sidebar.md`. If you have added any keycodes be sure to add them to `docs/keycodes.md` with a link back to your feature page.
--- a/docs/07_Reference/Documentation_Templates.md
+++ b/docs/07_Reference/Documentation_Templates.md
--- a/docs/09_IDEs/Eclipse.md
+++ b/docs/09_IDEs/Eclipse.md
@@ -17,7 +17,7 @@ Note that this set-up has been tested on Ubuntu 16.04 only for the moment.

 # Prerequisites
 ## Build Environment
-Before starting, you must have followed the [Getting Started](index.md#getting-started) section corresponding to your system. In particular, you must have been able to build the firmware with the `make` command.
+Before starting, you must have followed the [Getting Started](README.md#getting-started) section corresponding to your system. In particular, you must have been able to build the firmware with [the `make` command](../#the-make-command).

 ## Java
 Eclipse is a Java application, so you will need to install Java 8 or more recent to be able to run it. You may choose between the JRE or the JDK, the latter being useful if you intend to do Java development.
@@ -85,4 +85,4 @@ We will now configure a make target that cleans the project and builds the keyma
 8. Double-click the build target you created to trigger a build.
 9. Select the <kbd>Console</kbd> view at the bottom to view the running build.

-  [1]: https://en.wikipedia.org/wiki/Eclipse_(software)
+  [1]: https://en.wikipedia.org/wiki/Eclipse_(software)
--- a/docs/faq.md
+++ b/docs/faq.md
@@ -0,0 +1,6 @@
+# Frequently Asked Questions
+
+* [General](faq_general.md)
+* [Building or Compiling QMK](faq_build.md)
+* [Debugging and Troubleshooting QMK](faq_debug.md)
+* [Keymap](faq_keymap.md)
--- a/docs/03_FAQ/03_Build_Compile_QMK.md
+++ b/docs/03_FAQ/03_Build_Compile_QMK.md
@@ -1,6 +1,6 @@
 # Frequently Asked Build Questions

-This page covers questions about building QMK. If you haven't yet done so, you should read the [Build Environment Setup](01_Getting_Started/index.md) and [Make Instructions](01_Getting_Started/03_Build_Compile_Instructions.md) guides.
+This page covers questions about building QMK. If you haven't yet done so, you should read the [Build Environment Setup](getting_started_build_tools.md) and [Make Instructions](getting_started_make_guide.md) guides.

 ## Can't Program on Linux
 You will need proper permissions to operate a device. For Linux users, see the instructions regarding `udev` rules, below. If you have issues with `udev`, a work-around is to use the `sudo` command. If you are not familiar with this command, check its manual with `man sudo` or [see this webpage](https://linux.die.net/man/8/sudo).
@@ -104,3 +104,17 @@ brew install dfu-programmer
 brew install gcc-arm-none-eabi
 brew install avrdude
 ```
+
+### avr-gcc 8.1 and LUFA
+
+If you updated your avr-gcc to above 7 you may see errors involving LUFA. For example:
+
+`lib/lufa/LUFA/Drivers/USB/Class/Device/AudioClassDevice.h:380:5: error: 'const' attribute on function returning 'void'`
+
+For now, you need to rollback avr-gcc to 7 in brew.
+
+```
+brew uninstall --force avr-gcc
+brew install avr-gcc@7
+brew link avr-gcc@7
+```
--- a/docs/03_FAQ/04_Debugging_and_Troubleshooting.md
+++ b/docs/03_FAQ/04_Debugging_and_Troubleshooting.md
--- a/docs/03_FAQ/02_General_FAQ.md
+++ b/docs/03_FAQ/02_General_FAQ.md
@@ -12,7 +12,7 @@

 TMK was originally designed and implemented by [Jun Wako](https://github.com/tmk). QMK started as [Jack Humbert](https://github.com/jackhumbert)'s fork of TMK for the Planck. After a while Jack's fork had diverged quite a bit from TMK, and in 2015 Jack decided to rename his fork to QMK.

-From a technical standpoint QMK builds upon TMK by adding several new features. Most notably QMK has expanded the number of available keycodes and uses these to implement advanced features like `S()`, `LCTL()`, and `MO()`. You can see a complete list of these keycodes in [Keycodes](06_Keycodes/index.md).
+From a technical standpoint QMK builds upon TMK by adding several new features. Most notably QMK has expanded the number of available keycodes and uses these to implement advanced features like `S()`, `LCTL()`, and `MO()`. You can see a complete list of these keycodes in [Keycodes](keycodes.md).

 From a project and community management standpoint TMK maintains all the officially supported keyboards by himself, with a bit of community support. Separate community maintained forks exist or can be created for other keyboards. Only a few keymaps are provided by default, so users typically don't share keymaps with each other. QMK encourages sharing of both keyboards and keymaps through a centrally managed repository, accepting all pull requests that follow the quality standards. These are mostly community maintained, but the QMK team also helps when necessary.

--- a/docs/03_FAQ/05_Keymaps.md
+++ b/docs/03_FAQ/05_Keymaps.md
@@ -1,9 +1,9 @@
 # Keymap FAQ

-This page covers questions people often have about keymaps. If you haven't you should read [Keymap Overview](07_Reference/Keymap_Overview.md) first.
+This page covers questions people often have about keymaps. If you haven't you should read [Keymap Overview](keymap.md) first.

 ## What Keycodes Can I Use?
-See [Keycodes](06_Keycodes/index.md) for an index of keycodes available to you. These link to more extensive documentation when available.
+See [Keycodes](keycodes.md) for an index of keycodes available to you. These link to more extensive documentation when available.

 Keycodes are actually defined in [common/keycode.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keycode.h).

@@ -20,8 +20,8 @@ QMK has two features, Bootmagic and Command, which allow you to change the behav

 As a quick fix try holding down `Space`+`Backspace` while you plug in your keyboard. This will reset the stored settings on your keyboard, returning those keys to normal operation. If that doesn't work look here:

-* [Bootmagic](05_Features/Bootmagic.md)
-* [Command](05_Features/Command.md) 
+* [Bootmagic](feature_bootmagic.md)
+* [Command](feature_command.md) 

 ## The Menu Key Isn't Working

@@ -49,7 +49,7 @@ https://github.com/tmk/tmk_keyboard/issues/67
 Modifier keys or layers can be stuck unless layer switching is configured properly.
 For Modifier keys and layer actions you have to place `KC_TRANS` on same position of destination layer to  unregister the modifier key or return to previous layer on release event.

-* https://github.com/tmk/tmk_core/blob/master/doc/Reference/Keymap_Overview.md#31-momentary-switching
+* https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#31-momentary-switching
 * http://geekhack.org/index.php?topic=57008.msg1492604#msg1492604
 * https://github.com/tmk/tmk_keyboard/issues/248

@@ -136,7 +136,7 @@ https://github.com/tekezo/Karabiner/issues/403

 ## Esc and <code>&#96;</code> on a Single Key

-See the [Grave Escape](05_Features/Grave_Escape.md) feature.
+See the [Grave Escape](feature_grave_esc.md) feature.

 ## Arrow on Right Modifier Keys with Dual-Role
 This turns right modifier keys into arrow keys when the keys are tapped while still modifiers when the keys are hold. In TMK the dual-role function is dubbed **TAP**.
@@ -147,7 +147,7 @@ This turns right modifier keys into arrow keys when the keys are tapped while st

 /* Arrow keys on right modifier keys with TMK dual role feature
 *
- *  https://github.com/tmk/tmk_core/blob/master/doc/07_Reference/Keymap_Overview.md#213-modifier-with-tap-keydual-role
+ *  https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#213-modifier-with-tap-keydual-role
 *  https://en.wikipedia.org/wiki/Modifier_key#Dual-role_keys
 */
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
--- a/docs/05_Features/Advanced_Keycodes.md
+++ b/docs/05_Features/Advanced_Keycodes.md
@@ -15,13 +15,13 @@ This will allow you to use `FN_CAPS` and `ALT_TAB` in your `KEYMAP()`, keeping i

 ### Limits of These Aliases

-Currently, the keycodes able to used with these functions are limited to the [Basic Keycodes](06_Keycodes/Basic.md), 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](06_Keycodes/Basic.md).
+Currently, the keycodes able to used with these functions are limited to the [Basic Keycodes](keycodes_basic.md), 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.md).

 # Switching and Toggling Layers

-These functions allow you to activate layers in various ways. Note that layers are not generally independent layouts -- multiple layers can be activated at once, and it's typical for layers to use `KC_TRNS` to allow keypresses to pass through to lower layers. For a detailed explanation of layers, see [Keymap Overview](07_Reference/Keymap_Overview.md#keymap-and-layers)
+These functions allow you to activate layers in various ways. Note that layers are not generally independent layouts -- multiple layers can be activated at once, and it's typical for layers to use `KC_TRNS` to allow keypresses to pass through to lower layers. For a detailed explanation of layers, see [Keymap Overview](keymap.md#keymap-and-layers)

-* `DF(layer)` - switches the default layer. The default layer is the always-active base layer that other layers stack on top of. See below for more about the default layer. This might be used to switch from QWERTY to Dvorak layout. (Note that this is a temporary switch that only persists until the keyboard loses power. To modify the default layer in a persistent way requires deeper customization, such as calling the `set_single_persistent_default_layer` function inside of [process_record_user](07_Reference/Custom_Code.md#programming-the-behavior-of-any-keycode).)
+* `DF(layer)` - switches the default layer. The default layer is the always-active base layer that other layers stack on top of. See below for more about the default layer. This might be used to switch from QWERTY to Dvorak layout. (Note that this is a temporary switch that only persists until the keyboard loses power. To modify the default layer in a persistent way requires deeper customization, such as calling the `set_single_persistent_default_layer` function inside of [process_record_user](custom_quantum_functions.md#programming-the-behavior-of-any-keycode).)
 * `MO(layer)` - momentarily activates *layer*. As soon as you let go of the key, the layer is deactivated. 
 * `LM(layer, mod)` - Momentarily activates *layer* (like `MO`), but with modifier(s) *mod* active. Only supports layers 0-15 and the left modifiers.
 * `LT(layer, kc)` - momentarily activates *layer* when held, and sends *kc* when tapped.
@@ -131,11 +131,9 @@ 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.

-{% hint style='info' %}
-Due to the way that keycodes are structured, any modifiers specified as part of `kc`, such as `LCTL()` or `KC_LPRN`, will only activate when held instead of tapped.
+?> Due to the way that keycodes are structured, any modifiers specified as part of `kc`, such as `LCTL()` or `KC_LPRN`, will only activate when held instead of tapped.

-Additionally, if there is at least one right modifier, any other modifiers will turn into their right equivalents, so it is not possible to "mix and match" the two.
-{% endhint %}
+?> Additionally, if there is at least one right modifier, any other modifiers will turn into their right equivalents, so it is not possible to "mix and match" the two.

 # One Shot Keys

@@ -177,3 +175,37 @@ Example: (Tapping Term = 200ms)
 - SHFT_T(KC_A) Up

 With defaults, if above is typed within tapping term, this will emit `ax`. With permissive hold, if above is typed within tapping term, this will emit `X` (so, Shift+X).
+
+# Mod tap interrupt
+
+When a dual role key used for a modifier is quickly followed by another keys, it is interpreted as held even before the tapping term elapsed.  This is a problem if a key is used for example inside a rolling combo because the second key will be pressed before the first key is released.
+
+For example, when trying to type the rolling combo "zx" and z being configured to send Ctrl when hold, z rapidly followed by x actually sends Ctrl-x. That's bad.
+
+You can disable this behavior by defining `IGNORE_MOD_TAP_INTERRUPT` in `config.h`.
+
+Note that this only concerns modifiers and not layer switching keys.
+
+# Hold after tap
+
+When the user holds a key after tap, this repeats the tapped key rather to hold a modifier key.  This allows to use auto repeat for the tapped key.  If you prefer to hold a modifier instead, define `TAPPING_FORCE_HOLD` in `config.h`.
+
+Example:
+
+- SHFT_T(KC_A) Down
+- SHFT_T(KC_A) Up
+- SHFT_T(KC_A) Down
+- wait more than tapping term...
+- SHFT_T(KC_A) Up
+
+With default settings, `a` will be sent on the first release, then `a` will be sent on the second press allowing the computer to trigger its auto repeat function.
+
+With `TAPPING_FORCE_HOLD`, the second press will be interpreted as a Shift, allowing to use it as a modifier shortly after having used it as a tap.
+
+!> `TAPPING_FORCE_HOLD` will break anything that uses tapping toggles (Such as the `TT` layer keycode, and the One Shot Tapping Toggle).
+
+# Retro Tapping
+
+When you hold a dual function key, and haven't pressed anything when you release the key, normally nothing happens.  However, if you enable this, if you release the key without pressing another key, it will send the original key, even if it is outside of the tapping term. 
+
+For instance, if you're using `LT(2, KC_SPACE)`, if you hold the key, don't hit anything else and then release it, normally, nothing happens. But with `RETRO_TAPPING` defined in your `config.h`, it will send `KC_SPACE`. 
--- a/docs/05_Features/Audio.md
+++ b/docs/05_Features/Audio.md
@@ -3,6 +3,7 @@
 Your keyboard can make sounds! If you've got a Planck, Preonic, or basically any AVR keyboard that allows access to certain PWM-capable pins, you can hook up a simple speaker and make it beep. You can use those beeps to indicate layer transitions, modifiers, special keys, or just to play some funky 8bit tunes.

 Up to two simultaneous audio voices are supported, one driven by timer 1 and another driven by timer 3.  The following pins can be defined as audio outputs in config.h:
+
 Timer 1:
 `#define B5_AUDIO`
 `#define B6_AUDIO`
@@ -58,13 +59,20 @@ PLAY_LOOP(my_song);

 It's advised that you wrap all audio features in `#ifdef AUDIO_ENABLE` / `#endif` to avoid causing problems when audio isn't built into the keyboard.

+The available keycodes for audio are: 
+
+* `AU_ON` - Turn audio mode on
+* `AU_OFF` - Turn audio mode off
+* `AU_TOG` - Toggle audio mode
+
+
 ## Music Mode

 The music mode maps your columns to a chromatic scale, and your rows to octaves. This works best with ortholinear keyboards, but can be made to work with others. All keycodes less than `0xFF` get blocked, so you won't type while playing notes - if you have special keys/mods, those will still work. A work-around for this is to jump to a different layer with KC_NOs before (or after) enabling music mode.

 Recording is experimental due to some memory issues - if you experience some weird behavior, unplugging/replugging your keyboard will fix things.

-06_Keycodes available:
+Keycodes available:

 * `MU_ON` - Turn music mode on
 * `MU_OFF` - Turn music mode off
@@ -89,6 +97,20 @@ By default, `MUSIC_MASK` is set to `keycode < 0xFF` which means keycodes less th

 Which will capture all keycodes - be careful, this will get you stuck in music mode until you restart your keyboard!

+For a more advanced way to control which keycodes should still be processed, you can use `music_mask_kb(keycode)` in `<keyboard>.c` and `music_mask_user(keycode)` in your `keymap.c`:
+
+    bool music_mask_user(uint16_t keycode) {
+      switch (keycode) {
+        case RAISE:
+        case LOWER:
+          return false;
+        default:
+          return true;
+      }
+    }
+
+Things that return false are not part of the mask, and are always processed.
+
 The pitch standard (`PITCH_STANDARD_A`) is 440.0f by default - to change this, add something like this to your `config.h`:

    #define PITCH_STANDARD_A 432.0f
@@ -131,6 +153,23 @@ You can configure the default, min and max frequencies, the stepping and built i

 This is still a WIP, but check out `quantum/keymap_midi.c` to see what's happening. Enable from the Makefile.

+
+## Audio Keycodes
+
+|Key             |Aliases  |Description                       |
+|----------------|---------|----------------------------------|
+|`AU_ON`         |         |Audio mode on                     |
+|`AU_OFF`        |         |Audio mode off                    |
+|`AU_TOG`        |         |Toggles Audio mode                |
+|`CLICKY_TOGGLE` |`CK_TOGG`|Toggles Audio clicky mode         |
+|`CLICKY_UP`     |`CK_UP`  |Increases frequency of the clicks |
+|`CLICKY_DOWN`   |`CK_DOWN`|Decreases frequency of the clicks |
+|`CLICKY_RESET`  |`CK_RST` |Resets frequency to default       |
+|`MU_ON`         |         |Turns on Music Mode               |
+|`MU_OFF`        |         |Turns off Music Mode              |
+|`MU_TOG`        |         |Toggles Music Mode                |
+|`MU_MOD`        |         |Cycles through the music modes    |
+
 <!-- FIXME: this formatting needs work

 ## Audio
--- a/docs/05_Features/Auto_Shift.md
+++ b/docs/05_Features/Auto_Shift.md
@@ -88,10 +88,7 @@ occasion. This is simply due to habit and holding some keys a little longer
 than others. Once you find this value, work on tapping your problem keys a little
 quicker than normal and you will be set.

-{% hint style='info' %}
-Auto Shift has three special keys that can help you get this value right very
-quick. See "Auto Shift Setup" for more details!
-{% endhint %}
+?> Auto Shift has three special keys that can help you get this value right very quick. See "Auto Shift Setup" for more details!

 ### NO_AUTO_SHIFT_SPECIAL (simple define)

--- a/docs/05_Features/Backlight.md
+++ b/docs/05_Features/Backlight.md
--- a/docs/05_Features/Bluetooth.md
+++ b/docs/05_Features/Bluetooth.md
--- a/docs/05_Features/Bootmagic.md
+++ b/docs/05_Features/Bootmagic.md
@@ -6,7 +6,7 @@ Bootmagic is a system for configuring your keyboard while it initializes. To tri

 Bootmagic Keycodes allow you to access the Bootmagic functionality after your keyboard has initialized. To use Bootmagic Keycodes you assign keycodes starting with `MAGIC_`, much in the same way you define any other key.

-Command is a feature that allows you to control different aspects of your keyboard. Command used to be called Magic. Command is typically accessed by holding Left and Right Shift at the same time, although that can be customized. While it shares some functionality with Bootmagic it also allows you to access functionality that Bootmagic does not. For more information see the [Command](05_Features/Command.md) documentation page.
+Command is a feature that allows you to control different aspects of your keyboard. Command used to be called Magic. Command is typically accessed by holding Left and Right Shift at the same time, although that can be customized. While it shares some functionality with Bootmagic it also allows you to access functionality that Bootmagic does not. For more information see the [Command](feature_command.md) documentation page.

 ## Enabling Bootmagic

--- a/docs/05_Features/Command.md
+++ b/docs/05_Features/Command.md
@@ -1,6 +1,6 @@
 # Command (Formerly known as Magic)

-Command is a way to change your keyboard's behavior without having to flash or unplug it to use [Bootmagic](05_Features/Bootmagic.md). There is a lot of overlap between this functionality and the [Bootmagic Keycodes](05_Features/Bootmagic.md). Whenever possible we encourage you to use that functionality instead of Command.
+Command is a way to change your keyboard's behavior without having to flash or unplug it to use [Bootmagic](feature_bootmagic.md). There is a lot of overlap between this functionality and the [Bootmagic Keycodes](feature_bootmagic.md). Whenever possible we encourage you to use that functionality instead of Command.

 ## Enabling Command

--- a/docs/05_Features/Dynamic_Macros.md
+++ b/docs/05_Features/Dynamic_Macros.md
--- a/docs/05_Features/Grave_Escape.md
+++ b/docs/05_Features/Grave_Escape.md
--- a/docs/feature_hd44780.md
+++ b/docs/feature_hd44780.md
@@ -0,0 +1,56 @@
+# HD44780 LCD Displays
+
+This is an integration of Peter Fleury's LCD library. This page will explain the basics. [For in depth documentation visit his page.](http://homepage.hispeed.ch/peterfleury/doxygen/avr-gcc-libraries/group__pfleury__lcd.html)
+
+You can enable support for HD44780 Displays by setting the `HD44780_ENABLE` flag in your keyboards `rules.mk` to yes. This will use about 400 KB of extra space.
+
+## Configuration
+
+You will need to configure the pins used by your display and its number of lines and collumn in your keyboards `config.h`.
+
+Uncomment the section labled HD44780 and change the parameters as needed.
+````
+/*
+ * HD44780 LCD Display Configuration
+ */
+
+#define LCD_LINES           2     //< number of visible lines of the display
+#define LCD_DISP_LENGTH    16     //< visibles characters per line of the display
+#define LCD_IO_MODE      1            //< 0: memory mapped mode, 1: IO port mode
+#if LCD_IO_MODE
+#define LCD_PORT         PORTB        //< port for the LCD lines
+#define LCD_DATA0_PORT   LCD_PORT     //< port for 4bit data bit 0
+#define LCD_DATA1_PORT   LCD_PORT     //< port for 4bit data bit 1
+#define LCD_DATA2_PORT   LCD_PORT     //< port for 4bit data bit 2
+#define LCD_DATA3_PORT   LCD_PORT     //< port for 4bit data bit 3
+#define LCD_DATA0_PIN    4            //< pin for 4bit data bit 0
+#define LCD_DATA1_PIN    5            //< pin for 4bit data bit 1
+#define LCD_DATA2_PIN    6            //< pin for 4bit data bit 2 
+#define LCD_DATA3_PIN    7            //< pin for 4bit data bit 3
+#define LCD_RS_PORT      LCD_PORT     //< port for RS line        
+#define LCD_RS_PIN       3            //< pin  for RS line        
+#define LCD_RW_PORT      LCD_PORT     //< port for RW line        
+#define LCD_RW_PIN       2            //< pin  for RW line        
+#define LCD_E_PORT       LCD_PORT     //< port for Enable line     
+#define LCD_E_PIN        1            //< pin  for Enable line    
+#endif
+````
+
+Should you need to configure other properties you can copy them from `quantum/hd44780.h` and set them in your `config.h`
+
+## Usage 
+
+To initialize your display call lcd_init() with one of these parameters:
+````
+LCD_DISP_OFF             : display off
+LCD_DISP_ON              : display on, cursor off
+LCD_DISP_ON_CURSOR       : display on, cursor on
+LCD_DISP_ON_CURSOR_BLINK : display on, cursor on flashing 
+````
+This is best done in your keyboards `matrix_init_kb` or your keymaps `matrix_init_user`.  
+It is advised to clear the display before use.  
+To do so call `lcd_clrsrc()`.
+
+To now print something to your Display you first call `lcd_gotoxy(column, line)`. To go to the start of the first line you would call `lcd_gotoxy(0, 0)` and then print a string with `lcd_puts("example string")`.
+
+There are more posible methods to control the display. [For in depth documentation please visit the linked page.](http://homepage.hispeed.ch/peterfleury/doxygen/avr-gcc-libraries/group__pfleury__lcd.html)
--- a/docs/05_Features/Key_Lock.md
+++ b/docs/05_Features/Key_Lock.md
@@ -8,4 +8,4 @@ Here's how to use it:
 2. Enable key lock by including `KEY_LOCK_ENABLE = yes` in your Makefile.
 3. That's it!

-Important: switching layers does not cancel the key lock. Additionally, key lock is only able to hold standard action keys and One Shot modifier keys (for example, if you have your shift defined as `OSM(KC_LSFT)`; see [One Shot Keys](06_Keycodes/Quantum_Keycodes.md#one-shot-keys)). This does not include any of the QMK special functions (except One Shot modifiers), or shifted versions of keys such as KC_LPRN. If it's in the [Basic Keycodes](06_Keycodes/Basic.md) list, it can be held. If it's not, then it can't be.
+Important: switching layers does not cancel the key lock. Additionally, key lock is only able to hold standard action keys and One Shot modifier keys (for example, if you have your shift defined as `OSM(KC_LSFT)`; see [One Shot Keys](quantum_keycodes.md#one-shot-keys)). This does not include any of the QMK special functions (except One Shot modifiers), or shifted versions of keys such as KC_LPRN. If it's in the [Basic Keycodes](keycodes_basic.md) list, it can be held. If it's not, then it can't be.
--- a/docs/05_Features/Layouts.md
+++ b/docs/05_Features/Layouts.md
--- a/docs/05_Features/Leader_Key.md
+++ b/docs/05_Features/Leader_Key.md
@@ -17,14 +17,16 @@ void matrix_scan_user(void) {
    leader_end();

    SEQ_ONE_KEY(KC_F) {
-      register_code(KC_S);
-      unregister_code(KC_S);
+      // Anything you can do in a macro.
+      SEND_STRING("QMK is awesome.");
+    }
+    SEQ_TWO_KEYS(KC_D, KC_D) {
+      SEND_STRING(SS_LCTRL("a")SS_LCTRL("c"));
+    }
+    SEQ_THREE_KEYS(KC_D, KC_D, KC_S) {
+      SEND_STRING("https://start.duckduckgo.com"SS_TAP(X_ENTER));
    }
    SEQ_TWO_KEYS(KC_A, KC_S) {
-      register_code(KC_H);
-      unregister_code(KC_H);
-    }
-    SEQ_THREE_KEYS(KC_A, KC_S, KC_D) {
      register_code(KC_LGUI);
      register_code(KC_S);
      unregister_code(KC_S);
@@ -34,4 +36,6 @@ void matrix_scan_user(void) {
 }
 ```

-As you can see, you have three function. you can use - `SEQ_ONE_KEY` for single-key sequences (Leader followed by just one key), and `SEQ_TWO_KEYS` and `SEQ_THREE_KEYS` for longer sequences. Each of these accepts one or more keycodes as arguments. This is an important point: You can use keycodes from **any layer on your keyboard**. That layer would need to be active for the leader macro to fire, obviously.
+As you can see, you have a few function. You can use `SEQ_ONE_KEY` for single-key sequences (Leader followed by just one key), and `SEQ_TWO_KEYS`, `SEQ_THREE_KEYS` up to `SEQ_FIVE_KEYS` for longer sequences.
+
+Each of these accepts one or more keycodes as arguments. This is an important point: You can use keycodes from **any layer on your keyboard**. That layer would need to be active for the leader macro to fire, obviously.
--- a/docs/05_Features/Macros.md
+++ b/docs/05_Features/Macros.md
@@ -2,9 +2,7 @@

 Macros allow you to send multiple keystrokes when pressing just one key. QMK has a number of ways to define and use macros. These can do anything you want: type common phrases for you, copypasta, repetitive game movements, or even help you code.

-{% hint style='danger' %}
-**Security Note**: While it is possible to use macros to send passwords, credit card numbers, and other sensitive information it is a supremely bad idea to do so. Anyone who gets a hold of your keyboard will be able to access that information by opening a text editor.
-{% endhint %}
+!> **Security Note**: While it is possible to use macros to send passwords, credit card numbers, and other sensitive information it is a supremely bad idea to do so. Anyone who gets a hold of your keyboard will be able to access that information by opening a text editor.

 ## The New Way: `SEND_STRING()` & `process_record_user`

@@ -132,9 +130,7 @@ SEND_STRING(".."SS_TAP(X_END));

 ## The Old Way: `MACRO()` & `action_get_macro`

-{% hint style='info' %}
-This is inherited from TMK, and hasn't been updated - it's recommend that you use `SEND_STRING` and `process_record_user` instead.
-{% endhint %}
+?> This is inherited from TMK, and hasn't been updated - it's recommend that you use `SEND_STRING` and `process_record_user` instead.

 By default QMK assumes you don't have any macros. To define your macros you create an `action_get_macro()` function. For example:

--- a/docs/05_Features/Mouse_Keys.md
+++ b/docs/05_Features/Mouse_Keys.md
--- a/docs/05_Features/Pointing_Device.md
+++ b/docs/05_Features/Pointing_Device.md
--- a/docs/05_Features/PS_2_Mouse.md
+++ b/docs/05_Features/PS_2_Mouse.md
--- a/docs/feature_rgb_matrix.md
+++ b/docs/feature_rgb_matrix.md
@@ -0,0 +1,144 @@
+# RGB Matrix Lighting
+
+There is basic support for addressable RGB matrix lighting with the I2C IS31FL3731 RGB controller. To enable it, add this to your `rules.mk`:
+
+    RGB_MATRIX_ENABLE = yes
+
+Configure the hardware via your `config.h`:
+
+	// This is a 7-bit address, that gets left-shifted and bit 0
+	// set to 0 for write, 1 for read (as per I2C protocol)
+	// The address will vary depending on your wiring:
+	// 0b1110100 AD <-> GND
+	// 0b1110111 AD <-> VCC
+	// 0b1110101 AD <-> SCL
+	// 0b1110110 AD <-> SDA
+	#define DRIVER_ADDR_1 0b1110100
+	#define DRIVER_ADDR_2 0b1110110
+
+	#define DRIVER_COUNT 2
+	#define DRIVER_1_LED_TOTAL 25
+	#define DRIVER_2_LED_TOTAL 24
+	#define DRIVER_LED_TOTAL DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL
+
+Currently only 2 drivers are supported, but it would be trivial to support all 4 combinations.
+
+Define these arrays listing all the LEDs in your `<keyboard>.c`:
+
+	const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
+	/* Refer to IS31 manual for these locations
+	 *   driver
+	 *   |  R location
+	 *   |  |      G location
+	 *   |  |      |      B location
+	 *   |  |      |      | */
+	    {0, C1_3,  C2_3,  C3_3},
+	    ....
+	}
+
+Where `Cx_y` is the location of the LED in the matrix defined by [the datasheet](http://www.issi.com/WW/pdf/31FL3731.pdf). The `driver` is the index of the driver you defined in your `config.h` (`0` or `1` right now).
+
+	const rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
+	/* {row | col << 4}
+	 *    |           {x=0..224, y=0..64}
+	 *    |              |               modifier
+	 *    |              |                 | */
+	    {{0|(0<<4)},   {20.36*0, 21.33*0}, 1},
+	    {{0|(1<<4)},   {20.36*1, 21.33*0}, 1},
+	    ....
+	}
+
+The format for the matrix position used in this array is `{row | (col << 4)}`. The `x` is between (inclusive) 0-224, and `y` is between (inclusive) 0-64. The easiest way to calculate these positions is:
+
+    x = 224 / ( NUMBER_OF_ROWS - 1 ) * ROW_POSITION
+    y = 64 / (NUMBER_OF_COLS - 1 ) * COL_POSITION
+
+Where all variables are decimels/floats.
+
+`modifier` is a boolean, whether or not a certain key is considered a modifier (used in some effects).
+
+## Keycodes
+
+All RGB keycodes are currently shared with the RGBLIGHT system:
+
+	* `RGB_TOG` - toggle
+	* `RGB_MOD` - cycle through modes
+	* `RGB_HUI` - increase hue
+	* `RGB_HUD` - decrease hue
+	* `RGB_SAI` - increase saturation
+	* `RGB_SAD` - decrease saturation
+	* `RGB_VAI` - increase value
+	* `RGB_VAD` - decrease value
+	* `RGB_SPI` - increase speed effect (no EEPROM support)
+	* `RGB_SPD` - decrease speed effect (no EEPROM support)
+
+
+	* `RGB_MODE_*` keycodes will generally work, but are not currently mapped to the correct effects for the RGB Matrix system
+
+## RGB Matrix Effects
+
+These are the effects that are currently available:
+
+	enum rgb_matrix_effects {
+		RGB_MATRIX_SOLID_COLOR = 1,
+	    RGB_MATRIX_ALPHAS_MODS,
+	    RGB_MATRIX_DUAL_BEACON,
+	    RGB_MATRIX_GRADIENT_UP_DOWN,
+	    RGB_MATRIX_RAINDROPS,
+	    RGB_MATRIX_CYCLE_ALL,
+	    RGB_MATRIX_CYCLE_LEFT_RIGHT,
+	    RGB_MATRIX_CYCLE_UP_DOWN,
+	    RGB_MATRIX_RAINBOW_BEACON,
+	    RGB_MATRIX_RAINBOW_PINWHEELS,
+	    RGB_MATRIX_RAINBOW_MOVING_CHEVRON,
+	    RGB_MATRIX_JELLYBEAN_RAINDROPS,
+	#ifdef RGB_MATRIX_KEYPRESSES
+		RGB_MATRIX_SOLID_REACTIVE,
+	    RGB_MATRIX_SPLASH,
+	    RGB_MATRIX_MULTISPLASH,
+	    RGB_MATRIX_SOLID_SPLASH,
+	    RGB_MATRIX_SOLID_MULTISPLASH,
+	#endif
+	    RGB_MATRIX_EFFECT_MAX
+	};
+
+## Custom layer effects
+
+Custom layer effects can be done by defining this in your `<keyboard>.c`:
+
+    void rgb_matrix_indicators_kb(void) {
+    	// rgb_matrix_set_color(index, red, green, blue);
+    }
+
+A similar function works in the keymap as `rgb_matrix_indicators_user`.
+
+## Additional `config.h` Options
+
+	#define RGB_MATRIX_KEYPRESSES // reacts to keypresses (will slow down matrix scan by a lot)
+	#define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (not recommened)
+	#define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
+	#define RGB_DISABLE_WHEN_USB_SUSPENDED false // turn off effects when suspended
+    #define RGB_MATRIX_SKIP_FRAMES 1 // number of frames to skip when displaying animations (0 is full effect) if not defined defaults to 1
+    #define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
+
+## EEPROM storage
+
+The EEPROM for it is currently shared with the RGBLIGHT system (it's generally assumed only one RGB would be used at a time), but could be configured to use its own 32bit address with:
+
+    #define EECONFIG_RGB_MATRIX (uint32_t *)16
+
+Where `16` is an unused index from `eeconfig.h`.
+
+## Suspended state
+
+To use the suspend feature, add this to your `<keyboard>.c`:
+
+	void suspend_power_down_kb(void)
+	{
+	    rgb_matrix_set_suspend_state(true);
+	}
+
+	void suspend_wakeup_init_kb(void)
+	{
+	    rgb_matrix_set_suspend_state(false);
+	}
--- a/docs/05_Features/RGB_Lighting.md
+++ b/docs/05_Features/RGB_Lighting.md
@@ -88,11 +88,36 @@ const uint16_t RGBLED_GRADIENT_RANGES[] PROGMEM = {360, 240, 180, 120, 90};
 Look in `rgblights.h` for all available functions, but if you want to control all or some LEDs your goto functions are:

 ```c
-rgblight_disable();  // turn all lights off
-rgblight_enable();  // turn lights on, based on their previous state (stored in EEPROM)
+// turn all lights off (stored in EEPROM)
+rgblight_disable();
+// turn lights on, based on their previous state (stored in EEPROM)
+rgblight_enable(); 
+
+// turn all lights off (not stored in EEPROM)
+rgblight_disable_noeeprom();
+// turn lights on, based on their previous state (not stored in EEPROM)
+rgblight_enable_noeeprom();
+
+// where r/g/b is a number from 0..255.  Turns all the LEDs to this color (ignores mode, not stored in EEPROM). 
+rgblight_setrgb(r, g, b); 
+// HSV color control - h is a value from 0..360 and s/v is a value from 0..255 (stored in EEPROM)
+rgblight_sethsv(h, s, v);  
+// HSV color control - h is a value from 0..360 and s/v is a value from 0..255 (not stored in EEPROM)
+rgblight_sethsv_noeeprom(h, s, v);  
+
+// Sets the mode, if rgb animations are enabled (stored in eeprom)
+rgblight_mode(x);
+// Sets the mode, if rgb animations are enabled (not stored in eeprom)
+rgblight_mode_noeeprom(x);
+// MODE 1, solid color
+// MODE 2-5, breathing
+// MODE 6-8, rainbow mood
+// MODE 9-14, rainbow swirl
+// MODE 15-20, snake
+// MODE 21-23, knight
+// MODE 24, xmas
+// MODE 25-34, static rainbow

-rgblight_setrgb(r, g, b);  // where r/g/b is a number from 0..255.  Turns all the LEDs to this color
-rgblight_sethsv(h, s, v);  // HSV color control - h is a value from 0..360 and s/v is a value from 0..255
 rgblight_setrgb_at(r,g,b, LED);  // control a single LED.  0 <= LED < RGBLED_NUM
 rgblight_sethsv_at(h,s,v, LED);  // control a single LED.  0 <= LED < RGBLED_NUM
 ```
@@ -121,12 +146,13 @@ These control the RGB Lighting functionality.
 |`RGB_MODE_KNIGHT`  |`RGB_M_K` |"Knight Rider" animation mode                                       |
 |`RGB_MODE_XMAS`    |`RGB_M_X` |Christmas animation mode                                            |
 |`RGB_MODE_GRADIENT`|`RGB_M_G` |Static gradient animation mode                                      |
+|`RGB_MODE_RGBTEST `|`RGB_M_T` |Red,Green,Blue test animation mode                                  |

 note: for backwards compatibility, `RGB_SMOD` is an alias for `RGB_MOD`.

 ## Hardware Modification

-![Planck with RGB Underglow](https://raw.githubusercontent.com/qmk/qmk_firmware/master/keyboards/planck/keymaps/yang/planck-with-rgb-underglow.jpg)
+![Planck with RGB Underglow](https://raw.githubusercontent.com/qmk/qmk_firmware/3774a7fcdab5544fc787f4c200be05fcd417e31f/keyboards/planck/keymaps/yang/planck-with-rgb-underglow.jpg)

 Here is a quick demo on Youtube (with NPKC KC60) (https://www.youtube.com/watch?v=VKrpPAHlisY).

--- a/docs/05_Features/Space_Cadet_Shift.md
+++ b/docs/05_Features/Space_Cadet_Shift.md
--- a/docs/05_Features/Space_Cadet_Shift_Enter.md
+++ b/docs/05_Features/Space_Cadet_Shift_Enter.md
--- a/docs/05_Features/Stenography.md
+++ b/docs/05_Features/Stenography.md
--- a/docs/05_Features/Swap_Hands.md
+++ b/docs/05_Features/Swap_Hands.md
--- a/docs/05_Features/Tap_Dance.md
+++ b/docs/05_Features/Tap_Dance.md
@@ -6,9 +6,9 @@ Hit the semicolon key once, send a semicolon. Hit it twice, rapidly -- send a co

 With this feature one can specify keys that behave differently, based on the amount of times they have been tapped, and when interrupted, they get handled before the interrupter.

-To make it clear how this is different from `ACTION_FUNCTION_TAP`, lets explore a certain setup! We want one key to send `Space` on single tap, but `Enter` on double-tap.
+To make it clear how this is different from `ACTION_FUNCTION_TAP`, let's explore a certain setup! We want one key to send `Space` on single tap, but `Enter` on double-tap.

-With `ACTION_FUNCTION_TAP`, it is quite a rain-dance to set this up, and has the problem that when the sequence is interrupted, the interrupting key will be send first. Thus, `SPC a` will result in `a SPC` being sent, if they are typed within `TAPPING_TERM`. With the tap dance feature, that'll come out as `SPC a`, correctly.
+With `ACTION_FUNCTION_TAP`, it is quite a rain-dance to set this up, and has the problem that when the sequence is interrupted, the interrupting key will be sent first. Thus, `SPC a` will result in `a SPC` being sent, if they are typed within `TAPPING_TERM`. With the tap dance feature, that'll come out as `SPC a`, correctly.

 The implementation hooks into two parts of the system, to achieve this: into `process_record_quantum()`, and the matrix scan. We need the latter to be able to time out a tap sequence even when a key is not being pressed, so `SPC` alone will time out and register after `TAPPING_TERM` time.

@@ -16,11 +16,13 @@ But lets start with how to use it, first!

 First, you will need `TAP_DANCE_ENABLE=yes` in your `rules.mk`, because the feature is disabled by default. This adds a little less than 1k to the firmware size. Next, you will want to define some tap-dance keys, which is easiest to do with the `TD()` macro, that - similar to `F()`, takes a number, which will later be used as an index into the `tap_dance_actions` array.

-This array specifies what actions shall be taken when a tap-dance key is in action. Currently, there are three possible options:
+This array specifies what actions shall be taken when a tap-dance key is in action. Currently, there are five possible options:

 * `ACTION_TAP_DANCE_DOUBLE(kc1, kc2)`: Sends the `kc1` keycode when tapped once, `kc2` otherwise. When the key is held, the appropriate keycode is registered: `kc1` when pressed and held, `kc2` when tapped once, then pressed and held.
+* `ACTION_TAP_DANCE_DUAL_ROLE(kc, layer)`: Sends the `kc` keycode when tapped once, or moves to `layer`. (this functions like the `TO` layer keycode).
 * `ACTION_TAP_DANCE_FN(fn)`: Calls the specified function - defined in the user keymap - with the final tap count of the tap dance action.
-* `ACTION_TAP_DANCE_FN_ADVANCED(on_each_tap_fn, on_dance_finished_fn, on_dance_reset_fn)`: Calls the first specified function - defined in the user keymap - on every tap, the second function on when the dance action finishes (like the previous option), and the last function when the tap dance action resets.
+* `ACTION_TAP_DANCE_FN_ADVANCED(on_each_tap_fn, on_dance_finished_fn, on_dance_reset_fn)`: Calls the first specified function - defined in the user keymap - on every tap, the second function when the dance action finishes (like the previous option), and the last function when the tap dance action resets.
+* `ACTION_TAP_DANCE_FN_ADVANCED_TIME(on_each_tap_fn, on_dance_finished_fn, on_dance_reset_fn, tap_specific_tapping_term)`: This functions identically to the `ACTION_TAP_DANCE_FN_ADVANCED` function, but uses a custom tapping term for it, instead of the predefined `TAPPING_TERM`.

 The first option is enough for a lot of cases, that just want dual roles. For example, `ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT)` will result in `Space` being sent on single-tap, `Enter` otherwise.

--- a/docs/05_Features/Terminal.md
+++ b/docs/05_Features/Terminal.md
--- a/docs/05_Features/Thermal_Printer.md
+++ b/docs/05_Features/Thermal_Printer.md
--- a/docs/05_Features/Unicode.md
+++ b/docs/05_Features/Unicode.md
--- a/docs/05_Features/Userspace.md
+++ b/docs/05_Features/Userspace.md
@@ -31,6 +31,20 @@ The reason for this, is that `<name>.h` won't be added in time to add settings (

 So you should use the `config.h` for QMK settings, and the `<name>.h` file for user or keymap specific settings.

+`/users/<name>/rules.mk` will be included in the build _after_ the `rules.mk` from your keymap. This allows you to have features in your userspace `rules.mk` that depend on individual QMK features that may or may not be available on a specific keyboard. For example, if you have RGB control features shared between all your keyboards that support RGB lighting, you can `define RGB_ENABLE` in your keymap `rules.mk` and then check for the variable in your userspace `rules.mk` like this:
+```make
+ifdef RGB_ENABLE
+    # Include my fancy rgb functions source here
+endif
+```
+Because of this, any time you turn on QMK features in your `users/<name>/rules.mk`, you should conditionally enable them only if the flag isn't already defined, like this:
+```make
+ifndef TAP_DANCE_ENABLE
+    TAP_DANCE_ENABLE = yes
+endif
+```
+This will ensure that you can explicitly turn off features for an individual keymap.
+
 ## 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).
@@ -48,7 +62,7 @@ If you do add a `config,h` file, you want to make sure that it only gets process
 #endif // !USERSPACE_CONFIG_H
 ```

-You can use any option hre that you could use in your keymap's `config.h` file. You can find a list of vales [here](07_Reference/Config_Options.md).
+You can use any option hre that you could use in your keymap's `config.h` file. You can find a list of vales [here](config_options.md).

 ## Example

@@ -118,7 +132,7 @@ Additionally, this should flash the newly compiled firmware automatically, using

 ## Override default userspace

-By default the userspace used will be the same as the keymap name. In some situations this isn't desirable. For instance, if you use the [layout](05_Features/Layouts.md) feature you can't use the same name for different keymaps (e.g. ANSI and ISO). You can name your layouts `mylayout-ansi` and `mylayout-iso` and add the following line to your layout's `rules.mk`:
+By default the userspace used will be the same as the keymap name. In some situations this isn't desirable. For instance, if you use the [layout](feature_layouts.md) feature you can't use the same name for different keymaps (e.g. ANSI and ISO). You can name your layouts `mylayout-ansi` and `mylayout-iso` and add the following line to your layout's `rules.mk`:

 ```
 USER_NAME := mylayout
--- a/docs/features.md
+++ b/docs/features.md
@@ -0,0 +1,29 @@
+# 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 achieve your goal.
+
+
+* [Advanced Keycodes](feature_advanced_keycodes.md) - Change layers, type shifted keys, and more. Go beyond typing simple characters.
+* [Audio](feature_audio.md) - Connect a speaker to your keyboard for audio feedback, midi support, and music mode.
+* [Auto Shift](feature_auto_shift.md) - Tap for the normal key, hold slightly longer for its shifted state.
+* [Backlight](feature_backlight.md) - LED lighting support for your keyboard.
+* [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.
+* [HD44780 LCD Display](feature_hd44780.md) - Support for LCD character displays using the HD44780 standard.
+* [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.
+* [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.
+* [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.
+* [PS2 Mouse](feature_ps2_mouse.md) - Driver for connecting a PS/2 mouse directly to your keyboard.
+* [RGB Light](feature_rgblight.md) - RGB lighting for your keyboard.
+* [RGB Matrix](feature_rgb_matrix.md) - RGB Matrix lights for per key lighting.
+* [Space Cadet](feature_space_cadet.md) - Use your left/right shift keys to type parenthesis and brackets.
+* [Stenography](feature_stenography.md) - Put your keyboard into Plover mode for stenography use.
+* [Swap Hands](feature_swap_hands.md) - Mirror your keyboard for one handed usage.
+* [Tap Dance](feature_tap_dance.md) - Make a single key do as many things as you want.
+* [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.
+* [Unicode](feature_unicode.md) - Unicode input support.
+* [Userspace](feature_userspace.md) - Share code between different keymaps and keyboards.
--- a/docs/01_Getting_Started/04_Flashing_Firmware.md
+++ b/docs/01_Getting_Started/04_Flashing_Firmware.md
--- a/docs/foo
+++ b/docs/foo
@@ -1,89 +0,0 @@
-sed -i .bak \
-e s,Getting_Started,01_Getting_Started,g \
-e s,Complete_Newbs_Guide,02_Complete_Newbs_Guide,g \
-e s,FAQ,03_FAQ,g \
-e s,Hardware,04_Hardware,g \
-e s,Features,05_Features,g \
-e s,Keycodes,06_Keycodes,g \
-e s,Reference,07_Reference,g \
-e s,For_Makers_And_Modders,08_For_Makers_And_Modders,g \
-e s,IDEs,09_IDEs,g \
-$1
-
-exit 0
-sed -i .bak \
-e s,newbs.md,Complete_Newbs_Guide/00_Complete_Newbie\'s_Guide.md,g \
-e s,newbs_building_firmware.md,Complete_Newbs_Guide/02_Building_Your_First_Firmware.md,g \
-e s,newbs_flashing.md,Complete_Newbs_Guide/03_Flashing_Firmware.md,g \
-e s,newbs_testing_debugging.md,Complete_Newbs_Guide/04_Testing_and_Debugging.md,g \
-e s,newbs_getting_started.md,Complete_Newbs_Guide/index.md,g \
-e s,faq_general.md,FAQ/02_General_FAQ.md,g \
-e s,faq_build.md,FAQ/03_Build_Compile_QMK.md,g \
-e s,faq_debug.md,FAQ/04_Debugging_and_Troubleshooting.md,g \
-e s,faq_keymap.md,FAQ/05_Keymaps.md,g \
-e s,faq.md,FAQ/index.md,g \
-e s,feature_advanced_keycodes.md,Features/Advanced_Keycodes.md,g \
-e s,feature_audio.md,Features/Audio.md,g \
-e s,feature_auto_shift.md,Features/Auto_Shift.md,g \
-e s,feature_backlight.md,Features/Backlight.md,g \
-e s,feature_bluetooth.md,Features/Bluetooth.md,g \
-e s,feature_bootmagic.md,Features/Bootmagic.md,g \
-e s,feature_command.md,Features/Command.md,g \
-e s,feature_dynamic_macros.md,Features/Dynamic_Macros.md,g \
-e s,feature_grave_esc.md,Features/Grave_Escape.md,g \
-e s,feature_key_lock.md,Features/Key_Lock.md,g \
-e s,feature_layouts.md,Features/Layouts.md,g \
-e s,feature_leader_key.md,Features/Leader_Key.md,g \
-e s,feature_macros.md,Features/Macros.md,g \
-e s,feature_mouse_keys.md,Features/Mouse_Keys.md,g \
-e s,feature_ps2_mouse.md,Features/PS_2_Mouse.md,g \
-e s,feature_pointing_device.md,Features/Pointing_Device.md,g \
-e s,feature_rgblight.md,Features/RGB_Lighting.md,g \
-e s,feature_space_cadet.md,Features/Space_Cadet_Shift.md,g \
-e s,feature_space_shift_cadet.md,Features/Space_Cadet_Shift_Enter.md,g \
-e s,feature_stenography.md,Features/Stenography.md,g \
-e s,feature_swap_hands.md,Features/Swap_Hands.md,g \
-e s,feature_tap_dance.md,Features/Tap_Dance.md,g \
-e s,feature_terminal.md,Features/Terminal.md,g \
-e s,feature_thermal_printer.md,Features/Thermal_Printer.md,g \
-e s,feature_unicode.md,Features/Unicode.md,g \
-e s,feature_userspace.md,Features/Userspace.md,g \
-e s,features.md,Features/index.html,g \
-e s,hand_wire.md,For_Makers_And_Modders/Hand_Wiring_Guide.md,g \
-e s,isp_flashing_guide.md,For_Makers_And_Modders/ISP_Flashing_Guide.md,g \
-e s,how_keyboards_work.md,For_a_Deeper_Understanding/How_Keyboards_Work.md,g \
-e s,understanding_qmk.md,For_a_Deeper_Understanding/Understanding_QMK.md,g \
-e s,getting_started_vagrant.md,Getting_Started/02_Vagrant.md,g \
-e s,getting_started_make_guide.md,Getting_Started/03_Build_Compile_Instructions.md,g \
-e s,flashing.md,Getting_Started/04_Flashing_Firmware.md,g \
-e s,contributing.md,Getting_Started/05_Contributing.md,g \
-e s,getting_started_github.md,Getting_Started/06_How_to_Use_GitHub.md,g \
-e s,getting_started_getting_help.md,Getting_Started/07_Getting_Help.md,g \
-e s,getting_started_introduction.md,Getting_Started/index.html,g \
-e s,getting_started_build_tools.md,Getting_Started/index.md,g \
-e s,hardware_avr.md,Hardware/02_AVR_Processors.md,g \
-e s,hardware_drivers.md,Hardware/04_Drivers.md,g \
-e s,hardware.md,Hardware/index.md,g \
-e s,eclipse.md,IDEs/Eclipse.md,g \
-e s,internals_defines.md,Internals/internals_defines.md,g \
-e s,internals_input_callback_reg.md,Internals/internals_input_callback_reg.md,g \
-e s,internals_midi_device.md,Internals/internals_midi_device.md,g \
-e s,internals_midi_device_setup_process.md,Internals/internals_midi_device_setup_process.md,g \
-e s,internals_midi_util.md,Internals/internals_midi_util.md,g \
-e s,internals_send_functions.md,Internals/internals_send_functions.md,g \
-e s,internals_sysex_tools.md,Internals/internals_sysex_tools.md,g \
-e s,keycodes_basic.md,Keycodes/Basic.md,g \
-e s,quantum_keycodes.md,Keycodes/Quantum_Keycodes.md,g \
-e s,keycodes_us_ansi_shifted.md,Keycodes/US_ANSI_Shifted_keys.md,g \
-e s,keycodes.md,Keycodes/index.md,g \
-e s,hardware_keyboard_guidelines.md,Reference/01_Keyboard_Guidelines.md,g \
-e s,compatible_microcontrollers.md,Reference/Compatable_Microcontrollers.md,g \
-e s,config_options.md,Reference/Config_Options.md,g \
-e s,custom_quantum_functions.md,Reference/Custom_Code.md,g \
-e s,documentation_best_practices.md,Reference/Documentation_Best_Practices.md,g \
-e s,documentation_templates.md,Reference/Documentation_Templates.md,g \
-e s,reference_glossary.md,Reference/Glossary.md,g \
-e s,keymap.md,Reference/Keymap_Overview.md,g \
-e s,unit_testing.md,Reference/Unit_Testing.md,g \
-e s,README.md,index.md,g \
-$1
--- a/docs/01_Getting_Started/01_Install_Build_Tools/index.md
+++ b/docs/01_Getting_Started/01_Install_Build_Tools/index.md
@@ -4,6 +4,8 @@ This page describes setting up the build environment for QMK. These instructions

 <!-- FIXME: We should have ARM instructions somewhere. -->

+Note: If it is your first time here, Check out the "Complete Newbs guide" instead
+
 ## Linux

 To ensure you are always up to date, you can just run `sudo util/install_dependencies.sh`. That should always install all the dependencies needed. **This will run `apt-get upgrade`.**
@@ -54,7 +56,7 @@ If you're using [homebrew,](http://brew.sh/) you can use the following commands:
    brew tap osx-cross/avr
    brew tap PX4/homebrew-px4
    brew update
-    brew install avr-gcc
+    brew install avr-gcc@7
    brew install dfu-programmer
    brew install gcc-arm-none-eabi
    brew install avrdude
@@ -139,4 +141,4 @@ docker run -e keymap=default -e keyboard=ergodox_ez --rm -v D:/Users/Sacapuces/D
 This will compile the targeted keyboard/keymap and leave it in your QMK directory for you to flash.

 ## Vagrant
-If you have any problems building the firmware, you can try using a tool called Vagrant. It will set up a virtual computer with a known configuration that's ready-to-go for firmware building. OLKB does NOT host the files for this virtual computer. Details on how to set up Vagrant are in the [vagrant guide](01_Getting_Started/01_Install_Build_Tools/Vagrant.md).
+If you have any problems building the firmware, you can try using a tool called Vagrant. It will set up a virtual computer with a known configuration that's ready-to-go for firmware building. OLKB does NOT host the files for this virtual computer. Details on how to set up Vagrant are in the [vagrant guide](getting_started_vagrant.md).
--- a/docs/getting_started_getting_help.md
+++ b/docs/getting_started_getting_help.md
@@ -0,0 +1,15 @@
+# Getting Help
+
+There are a lot of resources for getting help with QMK.
+
+## Realtime Chat
+
+You can find QMK developers and users on our main [Discord server](https://discord.gg/Uq7gcHh). There are specific channels in the server for chatting about the firmware, Toolbox, hardware, and configurator.
+
+## OLKB Subreddit
+
+The official QMK forum is [/r/olkb](https://reddit.com/r/olkb) on [reddit.com](https://reddit.com).
+
+## Github Issues
+
+You can open an [issue on GitHub](https://github.com/qmk/qmk_firmware/issues). This is especially handy when your issue will require long-term discussion or debugging.
--- a/docs/01_Getting_Started/06_How_to_Use_GitHub.md
+++ b/docs/01_Getting_Started/06_How_to_Use_GitHub.md
@@ -2,9 +2,7 @@

 Github can be a little tricky to those that aren't familiar with it - this guide will walk through each step of forking, cloning, and submitting a pull request with QMK.

-{% hint style='info' %}
-This guide assumes you're somewhat comfortable with running things at the command line, and have git installed on your system.
-{% endhint %}
+?> This guide assumes you're somewhat comfortable with running things at the command line, and have git installed on your system.

 Start on the [QMK Github page](https://github.com/qmk/qmk_firmware), and you'll see a button in the upper right that says "Fork":

@@ -21,8 +19,7 @@ And be sure to select "HTTPS", and select the link and copy it:
 From here, enter `git clone ` into the command line, and then paste your link:

 ```
-**[terminal]
-**[prompt you@computer]**[path ~]**[delimiter  $ ]**[command git clone https://github.com/whoeveryouare/qmk_firmware.git]
+user@computer:~$ git clone https://github.com/whoeveryouare/qmk_firmware.git
 Cloning into 'qmk_firmware'...
 remote: Counting objects: 46625, done.
 remote: Compressing objects: 100% (2/2), done.
@@ -35,13 +32,12 @@ Checking out files: 100% (2799/2799), done.
 You now have your QMK fork on your local machine, and you can add your keymap, compile it and flash it to your board. Once you're happy with your changes, you can add, commit, and push them to your fork like this:

 ```
-**[terminal]
-**[prompt you@computer]**[path ~/qmk_firmware]**[delimiter  $ ]**[command git add .]
-**[prompt you@computer]**[path ~/qmk_firmware]**[delimiter  $ ]**[command git commit -m "adding my keymap"]
+user@computer:~$ git add .
+user@computer:~$ git commit -m "adding my keymap"
 [master cccb1608] adding my keymap
 1 file changed, 1 insertion(+)
 create mode 100644 keyboards/planck/keymaps/mine/keymap.c
-**[prompt you@computer]**[path ~/qmk_firmware]**[delimiter  $ ]**[command git push]
+user@computer:~$ git push
 Counting objects: 1, done.
 Delta compression using up to 4 threads.
 Compressing objects: 100% (1/1), done.
--- a/docs/getting_started_introduction.md
+++ b/docs/getting_started_introduction.md
@@ -6,12 +6,16 @@ This page attempts to explain the basic information you need to know to work wit

 QMK is a fork of [Jun Wako](https://github.com/tmk)'s [tmk_keyboard](https://github.com/tmk/tmk_keyboard) project. The original TMK code, with modifications, can be found in the `tmk` folder. The QMK additions to the project may be found in the `quantum` folder. Keyboard projects may be found in the `handwired` and `keyboard` folders.

+### Userspace Structure
+
+Within the folder `users` is a directory for each user. This is a place for users to put code that they might use between keyboards. See the docs for [Userspace feature](feature_userspace.md) for more information.
+
 ### Keyboard Project Structure

 Within the folder `keyboards` and its subfolder `handwired` is a directory for each keyboard project, for example `qmk_firmware/keyboards/clueboard`. Within it you'll find the following structure:

 * `keymaps/`: Different keymaps that can be built
-* `rules.mk`: The file that sets the default "make" options. Do not edit this file directly, instead use a keymap specific `Makefile`
+* `rules.mk`: The file that sets the default "make" options. Do not edit this file directly, instead use a keymap specific `rules.mk`.
 * `config.h`: The file that sets the default compile time options. Do not edit this file directly, instead use a keymap specific `config.h`.

 ### Keymap Structure
@@ -25,23 +29,26 @@ In every keymap folder, the following files may be found. Only `keymap.c` is req

 # The `config.h` File

-There are 2 `config.h` locations:
+There are 3 possible `config.h` locations:

 * keyboard (`/keyboards/<keyboard>/config.h`)
+* userspace (`/users/<user>/config.h`)
 * keymap (`/keyboards/<keyboard>/keymaps/<keymap>/config.h`)

-If the keymap `config.h` exists, that file is included by the build system and the keyboard `config.h` is not included. If you wish to override settings in your keymap's `config.h` you will need to include some glue code:
+The build system automatically picks up the config files in the above order. If you wish to override any setting set by a previous `config.h` you will need to first include some boilerplate code for the settings you wish to change.

 ```
-#ifndef CONFIG_USER_H
-#define CONFIG_USER_H
-
-#include "config_common.h"
+#pragma once
 ```

-If you want to override a setting from the parent `config.h` file, you need to `#undef` and then `#define` the setting again, like this:
+Then to override a setting from the previous `config.h` file you must `#undef` and then `#define` the setting again.

-```c
+The boilerplate code and setting look like this together:
+
+```
+#pragma once
+
+// overrides go here!
 #undef MY_SETTING
 #define MY_SETTING 4
 ```
--- a/docs/01_Getting_Started/03_Build_Compile_Instructions.md
+++ b/docs/01_Getting_Started/03_Build_Compile_Instructions.md
@@ -14,7 +14,7 @@ The full syntax of the `make` command is `<keyboard_folder>:<keymap>:<target>`,
 The `<target>` means the following
 * If no target is given, then it's the same as `all` below
 * `all` compiles as many keyboard/revision/keymap combinations as specified. For example, `make planck/rev4:default` will generate a single .hex, while `make planck/rev4:all` will generate a hex for every keymap available to the planck.
-* `dfu`, `teensy` or `dfu-util`, compile and upload the firmware to the keyboard. If the compilation fails, then nothing will be uploaded. The programmer to use depends on the keyboard. For most keyboards it's `dfu`, but for ChibiOS keyboards you should use `dfu-util`, and `teensy` for standard Teensys. To find out which command you should use for your keyboard, check the keyboard specific readme.
+* `dfu`, `teensy`, `avrdude` or `dfu-util`, compile and upload the firmware to the keyboard. If the compilation fails, then nothing will be uploaded. The programmer to use depends on the keyboard. For most keyboards it's `dfu`, but for ChibiOS keyboards you should use `dfu-util`, and `teensy` for standard Teensys. To find out which command you should use for your keyboard, check the keyboard specific readme.
 * **Note**: some operating systems need root access for these commands to work, so in that case you need to run for example `sudo make planck/rev4:default:dfu`.
 * `clean`, cleans the build output folders to make sure that everything is built from scratch. Run this before normal compilation if you have some unexplainable problems.

@@ -113,7 +113,7 @@ This allows you to interface with a Bluefruit EZ-key to send keycodes wirelessly

 `AUDIO_ENABLE`

-This allows you output audio on the C6 pin (needs abstracting). See the [audio page](05_Features/Audio.md) for more information.
+This allows you output audio on the C6 pin (needs abstracting). See the [audio page](feature_audio.md) for more information.

 `FAUXCLICKY_ENABLE`

@@ -121,7 +121,7 @@ Uses buzzer to emulate clicky switches. A cheap imitation of the Cherry blue swi

 `VARIABLE_TRACE`

-Use this to debug changes to variable values, see the [tracing variables](07_Reference/Unit_Testing.md#tracing-variables) section of the Unit Testing page for more information.
+Use this to debug changes to variable values, see the [tracing variables](unit_testing.md#tracing-variables) section of the Unit Testing page for more information.

 `API_SYSEX_ENABLE`

@@ -131,7 +131,11 @@ This consumes about 5390 bytes.

 `KEY_LOCK_ENABLE`

-This enables [key lock](05_Features/Key_Lock.md). This consumes an additional 260 bytes.
+This enables [key lock](feature_key_lock.md). This consumes an additional 260 bytes.
+
+`SPLIT_KEYBOARD`
+
+This enables split keyboard support (dual MCU like the let's split and bakingpy's boards) and includes all necessary files located at quantum/split_common

 ## Customizing Makefile Options on a Per-Keymap Basis

--- a/docs/01_Getting_Started/01_Install_Build_Tools/Vagrant.md
+++ b/docs/01_Getting_Started/01_Install_Build_Tools/Vagrant.md
--- a/docs/08_For_Makers_And_Modders/Hand_Wiring_Guide.md
+++ b/docs/08_For_Makers_And_Modders/Hand_Wiring_Guide.md
@@ -298,13 +298,13 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 ```

-Note that the layout of the keycodes is similar to the physical layout of our keyboard - this make it much easier to see what's going on. A lot of the keycodes should be fairly obvious, but for a full list of them, check out [Keycodes](06_Keycodes/index.md) - there are also a lot of aliases to condense your keymap file.
+Note that the layout of the keycodes is similar to the physical layout of our keyboard - this make it much easier to see what's going on. A lot of the keycodes should be fairly obvious, but for a full list of them, check out [Keycodes](keycodes.md) - there are also a lot of aliases to condense your keymap file.

 It's also important to use the `KEYMAP` function we defined earlier - this is what allows the firmware to associate our intended readable keymap with the actual wiring.

 ## Compiling Your Firmware

-After you've written out your entire keymap, you're ready to get the firmware compiled and onto your Teensy. Before compiling, you'll need to get your [development environment set-up](01_Getting_Started/index.md) - you can skip the dfu-programmer instructions, but you'll need to download and install the [Teensy Loader](https://www.pjrc.com/teensy/loader.html) to get the firmware on your Teensy.
+After you've written out your entire keymap, you're ready to get the firmware compiled and onto your Teensy. Before compiling, you'll need to get your [development environment set-up](getting_started_build_tools.md) - you can skip the dfu-programmer instructions, but you'll need to download and install the [Teensy Loader](https://www.pjrc.com/teensy/loader.html) to get the firmware on your Teensy.

 Once everything is installed, running `make` in the terminal should get you some output, and eventually a `<project_name>.hex` file in that folder. If you're having trouble with this step, see the end of the guide for the trouble-shooting section.

--- a/docs/04_Hardware/index.md
+++ b/docs/04_Hardware/index.md
@@ -2,7 +2,7 @@

 QMK runs on a variety of hardware. If your processor can be targeted 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](07_Reference/01_Keyboard_Guidelines.md)
-* [AVR Processors](04_Hardware/02_AVR_Processors.md)
+* [Keyboard Guidelines](hardware_keyboard_guidelines.md)
+* [AVR Processors](hardware_avr.md)
 * ARM Processors (TBD)
-* [Drivers](04_Hardware/04_Drivers.md)
+* [Drivers](hardware_drivers.md)
--- a/docs/04_Hardware/02_AVR_Processors.md
+++ b/docs/04_Hardware/02_AVR_Processors.md
@@ -2,7 +2,7 @@

 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](07_Reference/01_Keyboard_Guidelines.md) to get a sense of how keyboards fit into QMK.
+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

@@ -20,15 +20,15 @@ This will create all the files needed to support your new keyboard, and populate

 ## `readme.md`

-This is where you'll describe your keyboard. Please follow the [Keyboard Readme Template](07_Reference/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.
+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](07_Reference/Custom_Code.md).
+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)](05_Features/Layouts.md) in. At minimum you should have a `#define LAYOUT` for your keyboard that looks something like this:
+This is the file you define your [Layout Macro(s)](feature_layouts.md) in. At minimum you should have a `#define LAYOUT` for your keyboard that looks something like this:

 ```
 #define LAYOUT(          \
@@ -48,7 +48,7 @@ The physical matrix (the second half) must have a number of rows equaling `MATRI

 ## `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](07_Reference/Config_Options.md) page.
+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

@@ -66,9 +66,7 @@ Do change the `MANUFACTURER`, `PRODUCT`, and `DESCRIPTION` lines to accurately r
 #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 %}
+?> 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.

 ### Keyboard Matrix Configuration

@@ -97,7 +95,7 @@ Finally, you can specify the direction your diodes point. This can be `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](05_Features/Backlight.md).
+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
@@ -107,12 +105,12 @@ By default QMK supports backlighting on pins `B5`, `B6`, and `B7`. If you are us
 ```

 {% 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](05_Features/Backlight.md) for more details.
+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](07_Reference/Config_Options.md) page for more details.
+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`

@@ -154,4 +152,4 @@ 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](07_Reference/Config_Options.md#feature-options) page for a detailed list and description.
+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/04_Hardware/04_Drivers.md
+++ b/docs/04_Hardware/04_Drivers.md
@@ -24,4 +24,4 @@ You can make use of uGFX within QMK to drive character and graphic LCD's, LED ar

 ## WS2812 (AVR Only)

-Support for WS2811/WS2812{a,b,c} LED's. For more information see the [RGB Light](05_Features/RGB_Lighting.md) page.
+Support for WS2811/WS2812{a,b,c} LED's. For more information see the [RGB Light](feature_rgblight.md) page.
--- a/docs/07_Reference/01_Keyboard_Guidelines.md
+++ b/docs/07_Reference/01_Keyboard_Guidelines.md
@@ -8,7 +8,7 @@ All names should be lowercase alphanumeric, and separated by an underscore (`_`)

 ## `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](07_Reference/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 more information. Please follow the [published template](documentation_templates.md#keyboard-readmemd-template).

 ## Image/Hardware Files

@@ -22,7 +22,7 @@ Given the amount of functionality that QMK exposes it's very easy to confuse new

 ### Bootmagic and Command

-[Bootmagic](05_Features/Bootmagic.md) and [Command](05_Features/Command.md) are two related features that allow a user to control their keyboard in non-obvious ways. We recommend you think long and hard about if you're going to enable either feature, and how you will expose this functionality. Keep in mind that users who want this functionality can enable it in their personal keymaps without affecting all the novice users who may be using your keyboard as their first programmable board.
+[Bootmagic](feature_bootmagic.md) and [Command](feature_command.md) are two related features that allow a user to control their keyboard in non-obvious ways. We recommend you think long and hard about if you're going to enable either feature, and how you will expose this functionality. Keep in mind that users who want this functionality can enable it in their personal keymaps without affecting all the novice users who may be using your keyboard as their first programmable board.

 By far the most common problem new users encounter is accidentally triggering Bootmagic while they're plugging in their keyboard. They're holding the keyboard by the bottom, unknowingly pressing in alt and spacebar, and then they find that these keys have been swapped on them. We recommend leaving this feature disabled by default, but if you do turn it on consider setting `BOOTMAGIC_KEY_SALT` to a key that is hard to press while plugging your keyboard in.

@@ -30,7 +30,7 @@ If your keyboard does not have 2 shift keys you should provide a working default

 ## Custom Keyboard Programming

-As documented on [Customizing Functionality](07_Reference/Custom_Code.md) you can define custom functions for your keyboard. Please keep in mind that your users may want to customize that behavior as well, and make it possible for them to do that. If you are providing a custom function, for example `process_record_kb()`, make sure that your function calls the `_user()` version of the call too. You should also take into account the return value of the `_user()` version, and only run your custom code if the user returns `true`.
+As documented on [Customizing Functionality](custom_quantum_functions.md) you can define custom functions for your keyboard. Please keep in mind that your users may want to customize that behavior as well, and make it possible for them to do that. If you are providing a custom function, for example `process_record_kb()`, make sure that your function calls the `_user()` version of the call too. You should also take into account the return value of the `_user()` version, and only run your custom code if the user returns `true`.

 ## Keyboard Metadata

@@ -47,16 +47,6 @@ The `info.json` file is a JSON formatted dictionary with the following keys avai
  * Example: `Clueboard 66%`
 * `url`
  * A URL to the keyboard's product page, [QMK.fm/keyboards](https://qmk.fm/keyboards) page, or other page describing information about the keyboard.
-* `bootloader`
-  * What bootloader this keyboard uses. Available options:
-    * `atmel-dfu`
-    * `kiibohd-dfu-util`
-    * `lufa-dfu`
-    * `qmk-dfu`
-    * `stm32-dfu-util`
-    * `caterina`
-    * `halfkay`
-    * `bootloadHID`
 * `maintainer`
  * GitHub username of the maintainer, or `qmk` for community maintained boards
 * `width`
@@ -143,4 +133,4 @@ If your keyboard makes use of the [uGFX](https://ugfx.io) features within QMK yo

 ## Technical Details

-If you're looking for more information on making your keyboard work with QMK, [check out the hardware section](04_Hardware/index.md)!
+If you're looking for more information on making your keyboard work with QMK, [check out the hardware section](hardware.md)!
--- a/docs/For_a_Deeper_Understanding/How_Keyboards_Work.md
+++ b/docs/For_a_Deeper_Understanding/How_Keyboards_Work.md
@@ -51,7 +51,7 @@ layout is set to QWERTY, a sample of the matching table is as follow:

 ## Back to the Firmware

-As the layout is generally fixed (unless you create your own), the firmware can actually call a keycode by its layout name directly to ease things for you. This is exactly what is done here with `KC_A` actually representing `0x04` in QWERTY. The full list can be found in [keycodes](06_Keycodes/index.md).
+As the layout is generally fixed (unless you create your own), the firmware can actually call a keycode by its layout name directly to ease things for you. This is exactly what is done here with `KC_A` actually representing `0x04` in QWERTY. The full list can be found in [keycodes](keycodes.md).

 ## List of Characters You Can Send

--- a/docs/index.html
+++ b/docs/index.html
@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>QMK Firmware</title>
+  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
+  <meta name="description" content="Description">
+  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
+  <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/vue.css" title="light">
+  <link rel="stylesheet" href="qmk.css" title="dark" disabled>
+  <link rel="stylesheet" href="sidebar.css" />
+</head>
+<body>
+  <div id="app"></div>
+  <script>
+    window.$docsify = {
+      name: 'QMK Firmware',
+      nameLink: 'https://qmk.fm/',
+      repo: 'qmk/qmk_firmware',
+      loadSidebar: true,
+      auto2top: true,
+      formatUpdated: '{YYYY}/{MM}/{DD} {HH}:{mm}',
+      search: {
+        paths: 'auto',
+        placeholder: 'Search Documentation...',
+        noData: 'We could not find any documents matching your search.',
+        depth: 6
+      }
+    }
+  </script>
+  <script src="//unpkg.com/docsify/lib/docsify.min.js"></script>
+  <script src="//unpkg.com/docsify/lib/plugins/search.min.js"></script>
+  <script src="//unpkg.com/docsify/lib/plugins/emoji.min.js"></script>
+  <script src="//unpkg.com/prismjs/components/prism-bash.min.js"></script>
+  <script src="//unpkg.com/prismjs/components/prism-c.min.js"></script>
+  <script src="//unpkg.com/prismjs/components/prism-cpp.min.js"></script>
+  <script src="//unpkg.com/prismjs/components/prism-json.min.js"></script>
+  <script src="//unpkg.com/prismjs/components/prism-makefile.min.js"></script>
+  <script>
+    // Register the offline cache worker
+    if (typeof navigator.serviceWorker !== 'undefined') {
+      navigator.serviceWorker.register('sw.js')
+    }
+  </script>
+</body>
+</html>
--- a/docs/Internals/internals_defines.md
+++ b/docs/Internals/internals_defines.md
--- a/docs/Internals/internals_input_callback_reg.md
+++ b/docs/Internals/internals_input_callback_reg.md
--- a/docs/internals_midi_device.md
+++ b/docs/internals_midi_device.md
@@ -0,0 +1,143 @@
+# group `midi_device` {#group__midi__device}
+
+You use the functions when you are implementing your own midi device.
+
+You set a send function to actually send bytes via your device, this method is called when you call a send function with this device, for instance midi_send_cc
+
+You use the midi_device_input to process input data from the device and pass it through the device's associated callbacks.
+
+You use the midi_device_set_pre_input_process_func if you want to have a function called at the beginning of the device's process function, generally to poll for input and pass that into midi_device_input
+
+## Summary
+
+ Members                        | Descriptions                                
+--------------------------------|---------------------------------------------
+`define `[`MIDI_INPUT_QUEUE_LENGTH`](#group__midi__device_1ga4aaa419caebdca2bbdfc1331e79781a8)            | 
+`enum `[`input_state_t`](#group__midi__device_1gac203e877d3df4275ceb8e7180a61f621)            | 
+`public void `[`midi_device_input`](#group__midi__device_1gad8d3db8eb35d9cfa51ef036a0a9d70db)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t cnt,uint8_t * input)`            | Process input bytes. This function parses bytes and calls the appropriate callbacks associated with the given device. You use this function if you are creating a custom device and you want to have midi input.
+`public void `[`midi_device_set_send_func`](#group__midi__device_1ga59f5a46bdd4452f186cc73d9e96d4673)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_var_byte_func_t send_func)`            | Set the callback function that will be used for sending output data bytes. This is only used if you're creating a custom device. You'll most likely want the callback function to disable interrupts so that you can call the various midi send functions without worrying about locking.
+`public void `[`midi_device_set_pre_input_process_func`](#group__midi__device_1ga4de0841b87c04fc23cb56b6451f33b69)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_no_byte_func_t pre_process_func)`            | Set a callback which is called at the beginning of the midi_device_process call. This can be used to poll for input data and send the data through the midi_device_input function. You'll probably only use this if you're creating a custom device.
+`struct `[`_midi_device`](docs/api_midi_device.md#struct__midi__device) | This structure represents the input and output functions and processing data for a midi device.
+
+## Members
+
+#### `define `[`MIDI_INPUT_QUEUE_LENGTH`](#group__midi__device_1ga4aaa419caebdca2bbdfc1331e79781a8) {#group__midi__device_1ga4aaa419caebdca2bbdfc1331e79781a8}
+
+#### `enum `[`input_state_t`](#group__midi__device_1gac203e877d3df4275ceb8e7180a61f621) {#group__midi__device_1gac203e877d3df4275ceb8e7180a61f621}
+
+ Values                         | Descriptions                                
+--------------------------------|---------------------------------------------
+IDLE            | 
+ONE_BYTE_MESSAGE            | 
+TWO_BYTE_MESSAGE            | 
+THREE_BYTE_MESSAGE            | 
+SYSEX_MESSAGE            | 
+
+#### `public void `[`midi_device_input`](#group__midi__device_1gad8d3db8eb35d9cfa51ef036a0a9d70db)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t cnt,uint8_t * input)` {#group__midi__device_1gad8d3db8eb35d9cfa51ef036a0a9d70db}
+
+Process input bytes. This function parses bytes and calls the appropriate callbacks associated with the given device. You use this function if you are creating a custom device and you want to have midi input.
+
+#### Parameters
+* `device` the midi device to associate the input with 
+
+* `cnt` the number of bytes you are processing 
+
+* `input` the bytes to process
+
+#### `public void `[`midi_device_set_send_func`](#group__midi__device_1ga59f5a46bdd4452f186cc73d9e96d4673)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_var_byte_func_t send_func)` {#group__midi__device_1ga59f5a46bdd4452f186cc73d9e96d4673}
+
+Set the callback function that will be used for sending output data bytes. This is only used if you're creating a custom device. You'll most likely want the callback function to disable interrupts so that you can call the various midi send functions without worrying about locking.
+
+#### Parameters
+* `device` the midi device to associate this callback with 
+
+* `send_func` the callback function that will do the sending
+
+#### `public void `[`midi_device_set_pre_input_process_func`](#group__midi__device_1ga4de0841b87c04fc23cb56b6451f33b69)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_no_byte_func_t pre_process_func)` {#group__midi__device_1ga4de0841b87c04fc23cb56b6451f33b69}
+
+Set a callback which is called at the beginning of the midi_device_process call. This can be used to poll for input data and send the data through the midi_device_input function. You'll probably only use this if you're creating a custom device.
+
+#### Parameters
+* `device` the midi device to associate this callback with 
+
+* `midi_no_byte_func_t` the actual callback function
+
+# struct `_midi_device` {#struct__midi__device}
+
+This structure represents the input and output functions and processing data for a midi device.
+
+A device can represent an actual physical device [serial port, usb port] or something virtual. You should not need to modify this structure directly.
+
+## Summary
+
+ Members                        | Descriptions                                
+--------------------------------|---------------------------------------------
+`public midi_var_byte_func_t `[`send_func`](docs/api_midi_device.md#struct__midi__device_1a25d4c94b4bbccd5b98f1032b469f3ff9) | 
+`public midi_three_byte_func_t `[`input_cc_callback`](docs/api_midi_device.md#struct__midi__device_1a6da5236c1bc73877728df92d213a78d1) | 
+`public midi_three_byte_func_t `[`input_noteon_callback`](docs/api_midi_device.md#struct__midi__device_1aa10b15cf1a7fb825a5df0d2abbe34a1c) | 
+`public midi_three_byte_func_t `[`input_noteoff_callback`](docs/api_midi_device.md#struct__midi__device_1aaf290043078534d3a5a0ea4c840eba84) | 
+`public midi_three_byte_func_t `[`input_aftertouch_callback`](docs/api_midi_device.md#struct__midi__device_1acb0b4901c545cec4b28b126f2d8c315f) | 
+`public midi_three_byte_func_t `[`input_pitchbend_callback`](docs/api_midi_device.md#struct__midi__device_1a305fea672caeb996f2233bf8cd2bef18) | 
+`public midi_three_byte_func_t `[`input_songposition_callback`](docs/api_midi_device.md#struct__midi__device_1a5f3f13638b3fef3fc561ed1bf301d586) | 
+`public midi_two_byte_func_t `[`input_progchange_callback`](docs/api_midi_device.md#struct__midi__device_1adaf1da617c9a10a9dcad00ab1959d3da) | 
+`public midi_two_byte_func_t `[`input_chanpressure_callback`](docs/api_midi_device.md#struct__midi__device_1ab7ca2925c539915d43974eff604d85f7) | 
+`public midi_two_byte_func_t `[`input_songselect_callback`](docs/api_midi_device.md#struct__midi__device_1a89bed8a5a55376120cfc0a62b42f057f) | 
+`public midi_two_byte_func_t `[`input_tc_quarterframe_callback`](docs/api_midi_device.md#struct__midi__device_1ad9813e75d22e284f9f65a907d20600f0) | 
+`public midi_one_byte_func_t `[`input_realtime_callback`](docs/api_midi_device.md#struct__midi__device_1a9448eba4afb7e43650434748db3777be) | 
+`public midi_one_byte_func_t `[`input_tunerequest_callback`](docs/api_midi_device.md#struct__midi__device_1a0cb8fd53e00cf1d4202d4fa04d038e8d) | 
+`public midi_sysex_func_t `[`input_sysex_callback`](docs/api_midi_device.md#struct__midi__device_1afff9a0ce641762aaef24c1e6953ec9a2) | 
+`public midi_var_byte_func_t `[`input_fallthrough_callback`](docs/api_midi_device.md#struct__midi__device_1abb974ec6d734001b4a0e370f292be503) | 
+`public midi_var_byte_func_t `[`input_catchall_callback`](docs/api_midi_device.md#struct__midi__device_1aae0d535129d4fd650edc98eb3f7584f8) | 
+`public midi_no_byte_func_t `[`pre_input_process_callback`](docs/api_midi_device.md#struct__midi__device_1aeb0bb8923d66c23d874e177dc4265754) | 
+`public uint8_t `[`input_buffer`](docs/api_midi_device.md#struct__midi__device_1a7c5684857d6af4ebc4dc12da27bd6b2a) | 
+`public input_state_t `[`input_state`](docs/api_midi_device.md#struct__midi__device_1a69a687d2d1c449ec15a11c07a5722e39) | 
+`public uint16_t `[`input_count`](docs/api_midi_device.md#struct__midi__device_1a68dea8e7b6151e89c85c95caa612ee5d) | 
+`public uint8_t `[`input_queue_data`](docs/api_midi_device.md#struct__midi__device_1ada41de021135dc423abedcbb30f366ff) | 
+`public `[`byteQueue_t`](#structbyte_queue__t)` `[`input_queue`](#struct__midi__device_1a49c8538a8a02193c58e28a56eb695d8f) | 
+
+## Members
+
+#### `public midi_var_byte_func_t `[`send_func`](docs/api_midi_device.md#struct__midi__device_1a25d4c94b4bbccd5b98f1032b469f3ff9) {#struct__midi__device_1a25d4c94b4bbccd5b98f1032b469f3ff9}
+
+#### `public midi_three_byte_func_t `[`input_cc_callback`](docs/api_midi_device.md#struct__midi__device_1a6da5236c1bc73877728df92d213a78d1) {#struct__midi__device_1a6da5236c1bc73877728df92d213a78d1}
+
+#### `public midi_three_byte_func_t `[`input_noteon_callback`](docs/api_midi_device.md#struct__midi__device_1aa10b15cf1a7fb825a5df0d2abbe34a1c) {#struct__midi__device_1aa10b15cf1a7fb825a5df0d2abbe34a1c}
+
+#### `public midi_three_byte_func_t `[`input_noteoff_callback`](docs/api_midi_device.md#struct__midi__device_1aaf290043078534d3a5a0ea4c840eba84) {#struct__midi__device_1aaf290043078534d3a5a0ea4c840eba84}
+
+#### `public midi_three_byte_func_t `[`input_aftertouch_callback`](docs/api_midi_device.md#struct__midi__device_1acb0b4901c545cec4b28b126f2d8c315f) {#struct__midi__device_1acb0b4901c545cec4b28b126f2d8c315f}
+
+#### `public midi_three_byte_func_t `[`input_pitchbend_callback`](docs/api_midi_device.md#struct__midi__device_1a305fea672caeb996f2233bf8cd2bef18) {#struct__midi__device_1a305fea672caeb996f2233bf8cd2bef18}
+
+#### `public midi_three_byte_func_t `[`input_songposition_callback`](docs/api_midi_device.md#struct__midi__device_1a5f3f13638b3fef3fc561ed1bf301d586) {#struct__midi__device_1a5f3f13638b3fef3fc561ed1bf301d586}
+
+#### `public midi_two_byte_func_t `[`input_progchange_callback`](docs/api_midi_device.md#struct__midi__device_1adaf1da617c9a10a9dcad00ab1959d3da) {#struct__midi__device_1adaf1da617c9a10a9dcad00ab1959d3da}
+
+#### `public midi_two_byte_func_t `[`input_chanpressure_callback`](docs/api_midi_device.md#struct__midi__device_1ab7ca2925c539915d43974eff604d85f7) {#struct__midi__device_1ab7ca2925c539915d43974eff604d85f7}
+
+#### `public midi_two_byte_func_t `[`input_songselect_callback`](docs/api_midi_device.md#struct__midi__device_1a89bed8a5a55376120cfc0a62b42f057f) {#struct__midi__device_1a89bed8a5a55376120cfc0a62b42f057f}
+
+#### `public midi_two_byte_func_t `[`input_tc_quarterframe_callback`](docs/api_midi_device.md#struct__midi__device_1ad9813e75d22e284f9f65a907d20600f0) {#struct__midi__device_1ad9813e75d22e284f9f65a907d20600f0}
+
+#### `public midi_one_byte_func_t `[`input_realtime_callback`](docs/api_midi_device.md#struct__midi__device_1a9448eba4afb7e43650434748db3777be) {#struct__midi__device_1a9448eba4afb7e43650434748db3777be}
+
+#### `public midi_one_byte_func_t `[`input_tunerequest_callback`](docs/api_midi_device.md#struct__midi__device_1a0cb8fd53e00cf1d4202d4fa04d038e8d) {#struct__midi__device_1a0cb8fd53e00cf1d4202d4fa04d038e8d}
+
+#### `public midi_sysex_func_t `[`input_sysex_callback`](docs/api_midi_device.md#struct__midi__device_1afff9a0ce641762aaef24c1e6953ec9a2) {#struct__midi__device_1afff9a0ce641762aaef24c1e6953ec9a2}
+
+#### `public midi_var_byte_func_t `[`input_fallthrough_callback`](docs/api_midi_device.md#struct__midi__device_1abb974ec6d734001b4a0e370f292be503) {#struct__midi__device_1abb974ec6d734001b4a0e370f292be503}
+
+#### `public midi_var_byte_func_t `[`input_catchall_callback`](docs/api_midi_device.md#struct__midi__device_1aae0d535129d4fd650edc98eb3f7584f8) {#struct__midi__device_1aae0d535129d4fd650edc98eb3f7584f8}
+
+#### `public midi_no_byte_func_t `[`pre_input_process_callback`](docs/api_midi_device.md#struct__midi__device_1aeb0bb8923d66c23d874e177dc4265754) {#struct__midi__device_1aeb0bb8923d66c23d874e177dc4265754}
+
+#### `public uint8_t `[`input_buffer`](docs/api_midi_device.md#struct__midi__device_1a7c5684857d6af4ebc4dc12da27bd6b2a) {#struct__midi__device_1a7c5684857d6af4ebc4dc12da27bd6b2a}
+
+#### `public input_state_t `[`input_state`](docs/api_midi_device.md#struct__midi__device_1a69a687d2d1c449ec15a11c07a5722e39) {#struct__midi__device_1a69a687d2d1c449ec15a11c07a5722e39}
+
+#### `public uint16_t `[`input_count`](docs/api_midi_device.md#struct__midi__device_1a68dea8e7b6151e89c85c95caa612ee5d) {#struct__midi__device_1a68dea8e7b6151e89c85c95caa612ee5d}
+
+#### `public uint8_t `[`input_queue_data`](docs/api_midi_device.md#struct__midi__device_1ada41de021135dc423abedcbb30f366ff) {#struct__midi__device_1ada41de021135dc423abedcbb30f366ff}
+
+#### `public `[`byteQueue_t`](#structbyte_queue__t)` `[`input_queue`](#struct__midi__device_1a49c8538a8a02193c58e28a56eb695d8f) {#struct__midi__device_1a49c8538a8a02193c58e28a56eb695d8f}
+
--- a/docs/Internals/internals_midi_device_setup_process.md
+++ b/docs/Internals/internals_midi_device_setup_process.md
--- a/docs/Internals/internals_midi_util.md
+++ b/docs/Internals/internals_midi_util.md
--- a/docs/Internals/internals_send_functions.md
+++ b/docs/Internals/internals_send_functions.md
--- a/docs/Internals/internals_sysex_tools.md
+++ b/docs/Internals/internals_sysex_tools.md
--- a/docs/08_For_Makers_And_Modders/ISP_Flashing_Guide.md
+++ b/docs/08_For_Makers_And_Modders/ISP_Flashing_Guide.md
--- a/docs/06_Keycodes/index.md
+++ b/docs/06_Keycodes/index.md
@@ -1,10 +1,10 @@
 # Keycodes Overview

-When defining a [keymap](07_Reference/Keymap_Overview.md) each key needs a valid key definition. This page documents the symbols that correspond to keycodes that are available to you in QMK.
+When defining a [keymap](keymap.md) each key needs a valid key definition. This page documents the symbols that correspond to keycodes that are available to you in QMK.

 This is a reference only. Each group of keys links to the page documenting their functionality in more detail.

-## [Basic Keycodes](06_Keycodes/Basic.md)
+## [Basic Keycodes](keycodes_basic.md)

 |Key                    |Aliases             |Description                                    |
 |-----------------------|--------------------|-----------------------------------------------|
@@ -167,6 +167,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`KC_MEDIA_STOP`        |`KC_MSTP`           |Stop Track                                     |
 |`KC_MEDIA_PLAY_PAUSE`  |`KC_MPLY`           |Play/Pause Track                               |
 |`KC_MEDIA_SELECT`      |`KC_MSEL`           |                                               |
+|`KC_MEDIA_EJECT`       |`KC_EJCT`           |Eject (macOS)                                  |
 |`KC_NUMLOCK`           |`KC_NLCK`           |Keypad Num Lock and Clear                      |
 |`KC_KP_SLASH`          |`KC_PSLS`           |Keypad `/`                                     |
 |`KC_KP_ASTERISK`       |`KC_PAST`           |Keypad `*`                                     |
@@ -190,28 +191,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`KC_NO`                |                    |Ignore this key (NOOP)                         |
 |`KC_TRANSPARENT`       |`KC_TRNS`           |Use the next lowest non-transparent key        |

-## [Mouse Keys](05_Features/Mouse_Keys.md)
-
-|Key             |Aliases  |Description                |
-|----------------|---------|---------------------------|
-|`KC_MS_UP`      |`KC_MS_U`|Mouse Cursor Up            |
-|`KC_MS_DOWN`    |`KC_MS_D`|Mouse Cursor Down          |
-|`KC_MS_LEFT`    |`KC_MS_L`|Mouse Cursor Left          |
-|`KC_MS_RIGHT`   |`KC_MS_R`|Mouse Cursor Right         |
-|`KC_MS_BTN1`    |`KC_BTN1`|Mouse Button 1             |
-|`KC_MS_BTN2`    |`KC_BTN2`|Mouse Button 2             |
-|`KC_MS_BTN3`    |`KC_BTN3`|Mouse Button 3             |
-|`KC_MS_BTN4`    |`KC_BTN4`|Mouse Button 4             |
-|`KC_MS_BTN5`    |`KC_BTN5`|Mouse Button 5             |
-|`KC_MS_WH_UP`   |`KC_WH_U`|Mouse Wheel Up             |
-|`KC_MS_WH_DOWN` |`KC_WH_D`|Mouse Wheel Down           |
-|`KC_MS_WH_LEFT` |`KC_WH_L`|Mouse Wheel Left           |
-|`KC_MS_WH_RIGHT`|`KC_WH_R`|Mouse Wheel Right          |
-|`KC_MS_ACCEL0`  |`KC_ACL0`|Set mouse acceleration to 0|
-|`KC_MS_ACCEL1`  |`KC_ACL1`|Set mouse acceleration to 1|
-|`KC_MS_ACCEL2`  |`KC_ACL2`|Set mouse acceleration to 2|
-
-## [Quantum Keycodes](06_Keycodes/Quantum_Keycodes.md#qmk-keycodes)
+## [Quantum Keycodes](quantum_keycodes.md#qmk-keycodes)

 |Key          |Aliases    |Description                                                          |
 |-------------|-----------|---------------------------------------------------------------------|
@@ -220,13 +200,43 @@ This is a reference only. Each group of keys links to the page documenting their
 |`KC_GESC`    |`GRAVE_ESC`|Escape when tapped, <code>&#96;</code> when pressed with Shift or GUI|
 |`KC_LSPO`    |           |Left Shift when held, `(` when tapped                                |
 |`KC_RSPC`    |           |Right Shift when held, `)` when tapped                               |
-|`KC_LEAD`    |           |The [Leader key](05_Features/Leader_Key.md)                              |
-|`KC_LOCK`    |           |The [Lock key](05_Features/Key_Lock.md)                                  |
+|`KC_LEAD`    |           |The [Leader key](feature_leader_key.md)                              |
+|`KC_LOCK`    |           |The [Lock key](feature_key_lock.md)                                  |
 |`FUNC(n)`    |`F(n)`     |Call `fn_action(n)` (deprecated)                                     |
 |`M(n)`       |           |Call macro `n`                                                       |
 |`MACROTAP(n)`|           |Macro-tap `n` idk FIXME                                              |

-## [Bootmagic](05_Features/Bootmagic.md)
+## [Audio Keys](feature_audio.md)
+
+|Key             |Aliases  |Description                       |
+|----------------|---------|----------------------------------|
+|`AU_ON`         |         |Audio mode on                     |
+|`AU_OFF`        |         |Audio mode off                    |
+|`AU_TOG`        |         |Toggles Audio mode                |
+|`CLICKY_TOGGLE` |`CK_TOGG`|Toggles Audio clicky mode         |
+|`CLICKY_UP`     |`CK_UP`  |Increases frequency of the clicks |
+|`CLICKY_DOWN`   |`CK_DOWN`|Decreases frequency of the clicks |
+|`CLICKY_RESET`  |`CK_RST` |Resets frequency to default       |
+|`MU_ON`         |         |Turns on Music Mode               |
+|`MU_OFF`        |         |Turns off Music Mode              |
+|`MU_TOG`        |         |Toggles Music Mode                |
+|`MU_MOD`        |         |Cycles through the music modes    |
+
+
+
+## [Backlighting](feature_backlight.md)
+
+|Key      |Description                               |
+|---------|------------------------------------------|
+|`BL_TOGG`|Turn the backlight on or off              |
+|`BL_STEP`|Cycle through backlight levels            |
+|`BL_ON`  |Set the backlight to max brightness       |
+|`BL_OFF` |Turn the backlight off                    |
+|`BL_INC` |Increase the backlight level              |
+|`BL_DEC` |Decrease the backlight level              |
+|`BL_BRTG`|Toggle backlight breathing                |
+
+## [Bootmagic](feature_bootmagic.md)

 |Key                               |Aliases  |Description                         |
 |----------------------------------|---------|------------------------------------|
@@ -250,48 +260,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`MAGIC_UNSWAP_ALT_GUI`            |`AG_NORM`|Unswap Alt and GUI on both sides    |
 |`MAGIC_TOGGLE_NKRO`               |         |Turn NKRO on or off                 |

-## [Backlighting](05_Features/Backlight.md)
-
-|Key      |Description                               |
-|---------|------------------------------------------|
-|`BL_TOGG`|Turn the backlight on or off              |
-|`BL_STEP`|Cycle through backlight levels            |
-|`BL_ON`  |Set the backlight to max brightness       |
-|`BL_OFF` |Turn the backlight off                    |
-|`BL_INC` |Increase the backlight level              |
-|`BL_DEC` |Decrease the backlight level              |
-|`BL_BRTG`|Toggle backlight breathing                |
-
-## [RGB Lighting](05_Features/RGB_Lighting.md)
-
-|Key                |Aliases   |Description                                                         |
-|-------------------|----------|--------------------------------------------------------------------|
-|`RGB_TOG`          |          |Toggle RGB lighting on or off                                       |
-|`RGB_MODE_FORWARD` |`RGB_MOD` |Cycle through modes, reverse direction when Shift is held           |
-|`RGB_MODE_REVERSE` |`RGB_RMOD`|Cycle through modes in reverse, forward direction when Shift is held|
-|`RGB_HUI`          |          |Increase hue                                                        |
-|`RGB_HUD`          |          |Decrease hue                                                        |
-|`RGB_SAI`          |          |Increase saturation                                                 |
-|`RGB_SAD`          |          |Decrease saturation                                                 |
-|`RGB_VAI`          |          |Increase value (brightness)                                         |
-|`RGB_VAD`          |          |Decrease value (brightness)                                         |
-|`RGB_MODE_PLAIN`   |`RGB_M_P `|Static (no animation) mode                                          |
-|`RGB_MODE_BREATHE` |`RGB_M_B` |Breathing animation mode                                            |
-|`RGB_MODE_RAINBOW` |`RGB_M_R` |Rainbow animation mode                                              |
-|`RGB_MODE_SWIRL`   |`RGB_M_SW`|Swirl animation mode                                                |
-|`RGB_MODE_SNAKE`   |`RGB_M_SN`|Snake animation mode                                                |
-|`RGB_MODE_KNIGHT`  |`RGB_M_K` |"Knight Rider" animation mode                                       |
-|`RGB_MODE_XMAS`    |`RGB_M_X` |Christmas animation mode                                            |
-|`RGB_MODE_GRADIENT`|`RGB_M_G` |Static gradient animation mode                                      |
-
-## [Thermal Printer](05_Features/Thermal_Printer.md)
-
-|Key        |Description                             |
-|-----------|----------------------------------------|
-|`PRINT_ON` |Start printing everything the user types|
-|`PRINT_OFF`|Stop printing everything the user types |
-
-## [Bluetooth](05_Features/Bluetooth.md)
+## [Bluetooth](feature_bluetooth.md)

 |Key       |Description                                   |
 |----------|----------------------------------------------|
@@ -299,7 +268,41 @@ This is a reference only. Each group of keys links to the page documenting their
 |`OUT_USB` |USB only                                      |
 |`OUT_BT`  |Bluetooth only                                |

-## [Modifiers](06_Keycodes/Quantum_Keycodes.md#modifiers)
+
+## [Layer Switching](feature_advanced_keycodes.md# Switching and Toggling Layers)
+
+|Key         |Description                                                               |
+|-----------------|---------------------------------------------------------------------|
+|`DF(layer)`      |Switches the default layer                                           |
+|`MO(layer)`      |Momentarily activates layer, switches off when you let go            |
+|`LM(layer, mod)` |As `MO(layer)` but with `mod` active                                 |
+|`LT(layer, kc)`  |Momentarily activates layer if held, sends kc if tapped              |
+|`TG(layer)`      |Toggles the layer (enables it if no active, and vise versa)          |
+|`TO(layer)`      |Activates layer and deactivates all other layers                     |
+|`TT(layer)`      |Momentarily activates layer if held, toggles it if tapped repeatedly |
+
+## [Mouse Keys](feature_mouse_keys.md)
+
+|Key             |Aliases  |Description                |
+|----------------|---------|---------------------------|
+|`KC_MS_UP`      |`KC_MS_U`|Mouse Cursor Up            |
+|`KC_MS_DOWN`    |`KC_MS_D`|Mouse Cursor Down          |
+|`KC_MS_LEFT`    |`KC_MS_L`|Mouse Cursor Left          |
+|`KC_MS_RIGHT`   |`KC_MS_R`|Mouse Cursor Right         |
+|`KC_MS_BTN1`    |`KC_BTN1`|Mouse Button 1             |
+|`KC_MS_BTN2`    |`KC_BTN2`|Mouse Button 2             |
+|`KC_MS_BTN3`    |`KC_BTN3`|Mouse Button 3             |
+|`KC_MS_BTN4`    |`KC_BTN4`|Mouse Button 4             |
+|`KC_MS_BTN5`    |`KC_BTN5`|Mouse Button 5             |
+|`KC_MS_WH_UP`   |`KC_WH_U`|Mouse Wheel Up             |
+|`KC_MS_WH_DOWN` |`KC_WH_D`|Mouse Wheel Down           |
+|`KC_MS_WH_LEFT` |`KC_WH_L`|Mouse Wheel Left           |
+|`KC_MS_WH_RIGHT`|`KC_WH_R`|Mouse Wheel Right          |
+|`KC_MS_ACCEL0`  |`KC_ACL0`|Set mouse acceleration to 0|
+|`KC_MS_ACCEL1`  |`KC_ACL1`|Set mouse acceleration to 1|
+|`KC_MS_ACCEL2`  |`KC_ACL2`|Set mouse acceleration to 2|
+
+## [Modifiers](feature_advanced_keycodes.md#modifier-keys)

 |Key       |Aliases               |Description                                         |
 |----------|----------            |----------------------------------------------------|
@@ -320,7 +323,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`SGUI(kc)`|`SCMD(kc)`, `SWIN(kc)`|Hold Left Shift and GUI and press `kc`              |
 |`LCA(kc)` |                      |Hold Left Control and Alt and press `kc`            |

-## [Mod-Tap Keys](06_Keycodes/Quantum_Keycodes.md#mod-tap-keys)
+## [Mod-Tap Keys](feature_advanced_keycodes.md#mod-tap)

 |Key         |Aliases                                |Description                                            |
 |------------|---------------------------------------|-------------------------------------------------------|
@@ -340,7 +343,53 @@ This is a reference only. Each group of keys links to the page documenting their
 |`SCMD_T(kc)`|`SWIN_T(kc)`                           |Left Shift and GUI when held, `kc` when tapped         |
 |`LCA_T(kc)` |                                       |Left Control and Alt when held, `kc` when tapped       |

-## [US ANSI Shifted Keys](06_Keycodes/US_ANSI_Shifted_keys.md)
+## [RGB Lighting](feature_rgblight.md)
+
+|Key                |Aliases   |Description                                                         |
+|-------------------|----------|--------------------------------------------------------------------|
+|`RGB_TOG`          |          |Toggle RGB lighting on or off                                       |
+|`RGB_MODE_FORWARD` |`RGB_MOD` |Cycle through modes, reverse direction when Shift is held           |
+|`RGB_MODE_REVERSE` |`RGB_RMOD`|Cycle through modes in reverse, forward direction when Shift is held|
+|`RGB_HUI`          |          |Increase hue                                                        |
+|`RGB_HUD`          |          |Decrease hue                                                        |
+|`RGB_SAI`          |          |Increase saturation                                                 |
+|`RGB_SAD`          |          |Decrease saturation                                                 |
+|`RGB_VAI`          |          |Increase value (brightness)                                         |
+|`RGB_VAD`          |          |Decrease value (brightness)                                         |
+|`RGB_MODE_PLAIN`   |`RGB_M_P `|Static (no animation) mode                                          |
+|`RGB_MODE_BREATHE` |`RGB_M_B` |Breathing animation mode                                            |
+|`RGB_MODE_RAINBOW` |`RGB_M_R` |Rainbow animation mode                                              |
+|`RGB_MODE_SWIRL`   |`RGB_M_SW`|Swirl animation mode                                                |
+|`RGB_MODE_SNAKE`   |`RGB_M_SN`|Snake animation mode                                                |
+|`RGB_MODE_KNIGHT`  |`RGB_M_K` |"Knight Rider" animation mode                                       |
+|`RGB_MODE_XMAS`    |`RGB_M_X` |Christmas animation mode                                            |
+|`RGB_MODE_GRADIENT`|`RGB_M_G` |Static gradient animation mode                                      |
+|`RGB_MODE_RGBTEST` |`RGB_M_T` |Red,Green,Blue test animation mode                                  |
+
+## [RGB Matrix Lighting](feature_rgb_matrix.md)
+
+|Key                |Aliases   |Description                                                         |
+|-------------------|----------|--------------------------------------------------------------------|
+|`RGB_TOG`          |          |Toggle RGB lighting on or off                                       |
+|`RGB_MODE_FORWARD` |`RGB_MOD` |Cycle through modes, reverse direction when Shift is held           |
+|`RGB_MODE_REVERSE` |`RGB_RMOD`|Cycle through modes in reverse, forward direction when Shift is held|
+|`RGB_HUI`          |          |Increase hue                                                        |
+|`RGB_HUD`          |          |Decrease hue                                                        |
+|`RGB_SAI`          |          |Increase saturation                                                 |
+|`RGB_SAD`          |          |Decrease saturation                                                 |
+|`RGB_VAI`          |          |Increase value (brightness)                                         |
+|`RGB_VAD`          |          |Decrease value (brightness)                                         |
+|`RGB_SPI`          |          |Increase effect speed (does no support eeprom yet)                  |
+|`RGB_SPD`          |          |Decrease effect speed (does no support eeprom yet)                  |
+
+## [Thermal Printer](feature_thermal_printer.md)
+
+|Key        |Description                             |
+|-----------|----------------------------------------|
+|`PRINT_ON` |Start printing everything the user types|
+|`PRINT_OFF`|Stop printing everything the user types |
+
+## [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)

 |Key                     |Aliases           |Description        |
 |------------------------|------------------|-------------------|
@@ -366,7 +415,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`KC_RIGHT_ANGLE_BRACKET`|`KC_GT`/`KC_RABK` |`>`                |
 |`KC_QUESTION`           |`KC_QUES`         |`?`                |

-## [Switching and Toggling Layers](05_Features/Advanced_Keycodes.md#switching-and-toggling-layers)
+## [Switching and Toggling Layers](feature_advanced_keycodes.md#switching-and-toggling-layers)

 |Key             |Description                                                                       |
 |----------------|----------------------------------------------------------------------------------|
@@ -378,21 +427,15 @@ This is a reference only. Each group of keys links to the page documenting their
 |`TT(layer)`     |Normally acts like MO unless it's tapped multiple times, which toggles `layer` on |
 |`LM(layer, mod)`|Momentarily turn on `layer` (like MO) with `mod` active as well.                  |

-## [One Shot Keys](06_Keycodes/Quantum_Keycodes.md#one-shot-keys)
+## [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)

 |Key         |Description                       |
 |------------|----------------------------------|
 |`OSM(mod)`  |Hold `mod` for one keypress       |
 |`OSL(layer)`|Switch to `layer` for one keypress|

-## [Unicode Support](05_Features/Unicode.md)

-|Key         |Aliases|                                                 |
-|------------|-------|-------------------------------------------------|
-|`UNICODE(n)`|`UC(n)`|Send Unicode character `n`                       |
-|`X(n)`      |       |Send Unicode character `n` via a different method|
-
-## [Swap Hands](05_Features/Swap_Hands.md)
+## [Swap Hands](feature_swap_hands.md)

 |Key        |Description                                                              |
 |-----------|-------------------------------------------------------------------------|
@@ -403,3 +446,9 @@ This is a reference only. Each group of keys links to the page documenting their
 |`SH_MOFF`  |Momentarily turns off swap.                                              |
 |`SH_TG`    |Toggles swap on and off with every key press.                            |
 |`SH_TT`    |Toggles with a tap; momentary when held.                                 |
+## [Unicode Support](feature_unicode.md)
+
+|Key         |Aliases|                                                 |
+|------------|-------|-------------------------------------------------|
+|`UNICODE(n)`|`UC(n)`|Send Unicode character `n`                       |
+|`X(n)`      |       |Send Unicode character `n` via a different method|
--- a/docs/06_Keycodes/Basic.md
+++ b/docs/06_Keycodes/Basic.md
@@ -194,6 +194,7 @@ Windows and macOS use different keycodes for "next track" and "previous track".
 |`KC_MEDIA_STOP`        |`KC_MSTP`|Stop Track                       |
 |`KC_MEDIA_PLAY_PAUSE`  |`KC_MPLY`|Play/Pause Track                 |
 |`KC_MEDIA_SELECT`      |`KC_MSEL`|                                 |
+|`KC_MEDIA_EJECT`       |`KC_EJCT`|Eject (macOS)                    |

 ## Number Pad

--- a/docs/06_Keycodes/US_ANSI_Shifted_keys.md
+++ b/docs/06_Keycodes/US_ANSI_Shifted_keys.md
--- a/docs/07_Reference/Keymap_Overview.md
+++ b/docs/07_Reference/Keymap_Overview.md
@@ -215,7 +215,7 @@ To actually handle the keypress event we define an `action_function()`. This fun

 This should have given you a basic overview for creating your own keymap. For more details see the following resources:

-* [Keycodes](06_Keycodes/index.md)
-* [Keymap FAQ](03_FAQ/05_Keymaps.md)
+* [Keycodes](keycodes.md)
+* [Keymap FAQ](faq_keymap.md)

 We are actively working to improve these docs. If you have suggestions for how they could be made better please [file an issue](https://github.com/qmk/qmk_firmware/issues/new)!
--- a/docs/02_Complete_Newbs_Guide/00_Complete_Newbie's_Guide.md
+++ b/docs/02_Complete_Newbs_Guide/00_Complete_Newbie's_Guide.md
@@ -1,4 +1,4 @@
-# The Compelete Newbs Guide To QMK
+# The Complete Newbs Guide To QMK

 QMK is a powerful Open Source firmware for your mechanical keyboard. You can use QMK to customize your keyboard in ways both simple and powerful. People of all skill levels, from complete newbie to master programmer, have successfully used QMK to customize their keyboard. This guide will help you do the same, no matter your skill level.

@@ -8,9 +8,11 @@ Not sure if your keyboard can run QMK? If it's a mechanical keyboard you built y

 There are 4 main sections to this guide:

-* [Getting Started](02_Complete_Newbs_Guide/index.md)
-* [Building Your First Firmware](02_Complete_Newbs_Guide/02_Building_Your_First_Firmware.md)
-* [Flashing Firmware](02_Complete_Newbs_Guide/03_Flashing_Firmware.md)
-* [Testing and Debugging](02_Complete_Newbs_Guide/04_Testing_and_Debugging.md)
+* [Getting Started](newbs_getting_started.md)
+* [Building Your First Firmware](newbs_building_firmware.md)
+* [Flashing Firmware](newbs_flashing.md)
+* [Testing and Debugging](newbs_testing_debugging.md)
+* [Learn More with these Resources](newbs_learn_more_resources.md)
+
+This guide is focused on helping someone who has never compiled software before. It makes choices and recommendations based on that viewpoint. There are alternative methods for many of these procedures, and we support most of those alternatives. If you have any doubt about how to accomplish a task you can [ask us for guidance](getting_started_getting_help.md).

-This guide is focused on helping someone who has never compiled software before. It makes choices and recommendations based on that viewpoint. There are alternative methods for many of these procedures, and we support most of those alternatives. If you have any doubt about how to accomplish a task you can [ask us for guidance](01_Getting_Started/07_Getting_Help.md).
--- a/docs/02_Complete_Newbs_Guide/02_Building_Your_First_Firmware.md
+++ b/docs/02_Complete_Newbs_Guide/02_Building_Your_First_Firmware.md
@@ -8,17 +8,15 @@ If you have closed and reopened your terminal window since following the first p

 Start by navigating to the `keymaps` folder for your keyboard.

-{% hint style='info' %}
-If you are on macOS or Windows there are commands you can use to easily open the keymaps folder.
+?> If you are on macOS or Windows there are commands you can use to easily open the keymaps folder.

-macOS:
+?> macOS:

    open keyboards/<keyboard_folder>/keymaps

-Windows:
+?> Windows:

    start keyboards/<keyboard_folder>/keymaps
-{% endhint %}

 ## Create a Copy Of The `default` Keymap

@@ -32,21 +30,17 @@ Open up your `keymap.c`. Inside this file you'll find the structure that control

 This line indicates the start of the list of Layers. Below that you'll find lines containing either `LAYOUT` or `KEYMAP`, and these lines indicate the start of a layer. Below that line is the list of keys that comprise a that particular layer.

-{% hint style='danger' %}
-When editing your keymap file be careful not to add or remove any commas. If you do you will prevent your firmware from compiling and it may not be easy to figure out where the extra, or missing, comma is.
-{% endhint %}
+!> When editing your keymap file be careful not to add or remove any commas. If you do you will prevent your firmware from compiling and it may not be easy to figure out where the extra, or missing, comma is.

 ## Customize The Layout To Your Liking

 How to complete this step is entirely up to you. Make the one change that's been bugging you, or completely rework everything. You can remove layers if you don't need all of them, or add layers up to a total of 32. Check the following documentation to find out what you can define here:

-* [Keycodes](06_Keycodes/index.md)
-* [Features](05_Features/index.html)
-* [FAQ](03_FAQ/index.md)
+* [Keycodes](keycodes.md)
+* [Features](features.md)
+* [FAQ](faq.md)

-{% hint style='info' %}
-While you get a feel for how keymaps work, keep each change small. Bigger changes make it harder to debug any problems that arise.
-{% endhint %}
+?> While you get a feel for how keymaps work, keep each change small. Bigger changes make it harder to debug any problems that arise.

 ## Build Your Firmware

@@ -70,4 +64,4 @@ Checking file size of planck_rev5_xyverz.hex

 ## Flash Your Firmware

-Move on to [Flashing Firmware](02_Complete_Newbs_Guide/03_Flashing_Firmware.md) to learn how to write your new firmware to your keyboard.
+Move on to [Flashing Firmware](newbs_flashing.md) to learn how to write your new firmware to your keyboard.
--- a/docs/02_Complete_Newbs_Guide/03_Flashing_Firmware.md
+++ b/docs/02_Complete_Newbs_Guide/03_Flashing_Firmware.md
@@ -6,23 +6,21 @@ Now that you've built a custom firmware file you'll want to flash your keyboard.

 The simplest way to flash your keyboard will be with the [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases). 

-However, the QMK Toolbox is only available for Windows and macOS currently.  If you're using Linux (or just wish to flash the firmware from the command line), you'll have to use the [method outlined below](02_Complete_Newbs_Guide/03_Flashing_Firmware.md#flash-your-keyboard-from-the-command-line).
+However, the QMK Toolbox is only available for Windows and macOS currently.  If you're using Linux (or just wish to flash the firmware from the command line), you'll have to use the [method outlined below](newbs_flashing.md#flash-your-keyboard-from-the-command-line).

 ### Load The File Into QMK Toolbox

 Begin by opening the QMK Toolbox application. You'll want to locate the firmware file in Finder or Explorer. Your keyboard firmware may be in one of two formats- `.hex` or `.bin`. QMK tries to copy the appropriate one for your keyboard into the root `qmk_firmware` directory.

-{% hint style='info' %}
-If you are on Windows or macOS there are commands you can use to easily open the current firmware folder in Explorer or Finder.
+?> If you are on Windows or macOS there are commands you can use to easily open the current firmware folder in Explorer or Finder.

-Windows:
+?> Windows:

    start .

-macOS:
+?> macOS:

    open .
-{% endhint %}

 The firmware file always follows this naming format:

@@ -82,7 +80,7 @@ Click the `Flash` button in QMK Toolbox. You will see output similar to the foll

 First thing you'll need to know is which bootloader that your keyboard uses.  There are four main bootloaders that are used, usually. Pro-Micro and clones use CATERINA, and Teensy's use Halfkay, OLKB boards use QMK-DFU, and other atmega32u4 chips use DFU. 

-You can find more information about the bootloaders in the [Flashing Instructions and Bootloader Information](01_Getting_Started/04_Flashing_Firmware.md) page. 
+You can find more information about the bootloaders in the [Flashing Instructions and Bootloader Information](flashing.md) page. 

 If you know what bootloader that you're using, then when compiling the firmware, you can actually add some extra text to the `make` command to automate the flashing process. 

@@ -239,4 +237,4 @@ Booting

 Congrats! Your custom firmware has been programmed to your keyboard!

-Give it a try and make sure everything works the way you want it to. We've written [Testing and Debugging](02_Complete_Newbs_Guide/04_Testing_and_Debugging.md) to round out this Newbie Guide, so head over there to learn about how to troubleshoot your custom functionality.
+Give it a try and make sure everything works the way you want it to. We've written [Testing and Debugging](newbs_testing_debugging.md) to round out this Newbie Guide, so head over there to learn about how to troubleshoot your custom functionality.
--- a/Show More
+++ b/Show More