Yet another update to drashna keymaps and userspace (EEPROM, RGB indicators) (#2959)

* More Iris Tweaks

* Mess with iris arrow keys

* Massive layout overhaul to make everything more OLKB

* Additional tweaks

* Cleanup Userspace

Remove unused layer code, and properly set userspace eeprom structure.

* EEPROM stuff

* Only use indicators if layer indication is enabled

* Iris and Orthodox Tweaks (Status Indicators)

* Additional tweaks to finish tri layer conversion

* Disable ProMicro ligths globally

* Add Pro Micro hacking info

* Successfully get mod indication working on thumb clusters

* Enable printing when console is enabled

* Make Modifier Indicator lights more modular

* Keymap cleanup

* Tapping test changes

* Cleanup and minor tweaks

.vscode/settings.json

@@ -11,6 +11,7 @@
         "*.h": "c",
         "*.c": "c",
         "*.cpp": "cpp",
-        "*.hpp": "cpp"
+        "*.hpp": "cpp",
+        "xstddef": "c"
     }
-}
+}

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

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

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)

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.

docs/06_Keycodes/Advanced_Keycodes.md

@@ -1 +0,0 @@
-../05_Features/Advanced_Keycodes.md

docs/06_Keycodes/Backlight.md

@@ -1 +0,0 @@
-../05_Features/Backlight.md

docs/06_Keycodes/Bluetooth.md

@@ -1 +0,0 @@
-../05_Features/Bluetooth.md

docs/06_Keycodes/Bootmagic.md

@@ -1 +0,0 @@
-../05_Features/Bootmagic.md

docs/06_Keycodes/RGB_Lighting.md

@@ -1 +0,0 @@
-../05_Features/RGB_Lighting.md

docs/06_Keycodes/Stenography.md

@@ -1 +0,0 @@
-../05_Features/Stenography.md

docs/06_Keycodes/Thermal_Printer.md

@@ -1 +0,0 @@
-../05_Features/Thermal_Printer.md

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)

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)

docs/09_IDEs/index.md

@@ -1 +0,0 @@
-* [Eclipse](Eclipse.md)

docs/For_a_Deeper_Understanding/index.md

@@ -1,2 +0,0 @@
-* [How Keyboards Work](How_Keyboards_Work.md)
-* [Understanding QMK](Understanding_QMK.md)

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}
-

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
 

docs/_sidebar.md

@@ -0,0 +1,99 @@
+* [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)
+  * [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)
+  * [Backlight](feature_backlight.md#backlight-keycodes)
+  * [Basic](keycodes_basic.md)
+  * [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)
+  * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
+  * [Quantum](quantum_keycodes.md)
+  * [RGB Light](feature_rgblight.md#rgblight-keycodes)
+  * [Shifted Keys](feature_advanced_keycodes.md#shifted-keycodes)
+  * [Stenography](feature_stenography.md#keycode-reference)
+  * [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)

docs/_summary.md

@@ -0,0 +1,98 @@
+* [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)
+  * [Space Cadet](feature_space_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)
+  * [Backlight](feature_backlight.md#backlight-keycodes)
+  * [Basic](keycodes_basic.md)
+  * [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)
+  * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
+  * [Quantum](quantum_keycodes.md)
+  * [RGB Light](feature_rgblight.md#rgblight-keycodes)
+  * [Shifted Keys](feature_advanced_keycodes.md#shifted-keycodes)
+  * [Stenography](feature_stenography.md#keycode-reference)
+  * [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)

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;> ",
-        "edit_on_github": "qmk/qmk_firmware/blob/master/docs",
-        "repo": "qmk/qmk_firmware",
-        "search": true,
-        "theme": "daux-navy",
-        "toggle_code": false
-    }
-}

docs/config_options.md

@@ -184,7 +184,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`

docs/contributing.md

@@ -122,7 +122,7 @@ 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)
 * [Open an Issue](https://github.com/qmk/qmk_firmware/issues/new)

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
 
@@ -183,7 +183,7 @@ Thir runs code every time that the layers get changed.  This can be useful for l
 
 ### 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 +212,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)

docs/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.

docs/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)

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)

docs/faq_build.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).

docs/faq_general.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.
 

docs/faq_keymap.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] = {

docs/feature_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
 

docs/feature_audio.md

@@ -64,7 +64,7 @@ The music mode maps your columns to a chromatic scale, and your rows to octaves.
 
 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 +89,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

docs/feature_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)
 

docs/feature_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
 

docs/feature_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
 

docs/feature_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.

docs/feature_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:
 

docs/feature_rgb_matrix.md

@@ -0,0 +1,143 @@
+# 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
+
+## 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);
+	}

docs/feature_tap_dance.md

@@ -19,8 +19,10 @@ First, you will need `TAP_DANCE_ENABLE=yes` in your `rules.mk`, because the feat
 This array specifies what actions shall be taken when a tap-dance key is in action. Currently, there are three 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_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.
 

docs/feature_userspace.md

@@ -48,7 +48,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,8 +118,8 @@ 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
-```
+```

docs/features.md

@@ -0,0 +1,26 @@
+# 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.
+* [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.
+* [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.
+* [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.

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

docs/getting_started_build_tools.md

@@ -139,4 +139,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).

docs/getting_started_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":
 

docs/getting_started_make_guide.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,7 @@ 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.
 
 ## Customizing Makefile Options on a Per-Keymap Basis
 

docs/hand_wire.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.
 

docs/hardware.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)

docs/hardware_avr.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.

docs/hardware_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.

docs/hardware_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
 
@@ -143,4 +143,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)!

docs/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
 

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>

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}
+

docs/keycodes.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                                    |
 |-----------------------|--------------------|-----------------------------------------------|
@@ -190,7 +190,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)
+## [Mouse Keys](feature_mouse_keys.md)
 
 |Key             |Aliases  |Description                |
 |----------------|---------|---------------------------|
@@ -211,7 +211,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`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 +220,13 @@ 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)
+## [Bootmagic](feature_bootmagic.md)
 
 |Key                               |Aliases  |Description                         |
 |----------------------------------|---------|------------------------------------|
@@ -250,7 +250,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)
+## [Backlighting](feature_backlight.md)
 
 |Key      |Description                               |
 |---------|------------------------------------------|
@@ -262,7 +262,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`BL_DEC` |Decrease the backlight level              |
 |`BL_BRTG`|Toggle backlight breathing                |
 
-## [RGB Lighting](05_Features/RGB_Lighting.md)
+## [RGB Lighting](feature_rgblight.md)
 
 |Key                |Aliases   |Description                                                         |
 |-------------------|----------|--------------------------------------------------------------------|
@@ -284,14 +284,14 @@ This is a reference only. Each group of keys links to the page documenting their
 |`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)
+## [Thermal Printer](feature_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 +299,7 @@ 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)
+## [Modifiers](quantum_keycodes.md#modifiers)
 
 |Key       |Aliases               |Description                                         |
 |----------|----------            |----------------------------------------------------|
@@ -320,7 +320,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](quantum_keycodes.md#mod-tap-keys)
 
 |Key         |Aliases                                |Description                                            |
 |------------|---------------------------------------|-------------------------------------------------------|
@@ -340,7 +340,7 @@ 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)
+## [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
 
 |Key                     |Aliases           |Description        |
 |------------------------|------------------|-------------------|
@@ -366,7 +366,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 +378,21 @@ 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](quantum_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)
+## [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|
 
-## [Swap Hands](05_Features/Swap_Hands.md)
+## [Swap Hands](feature_swap_hands.md)
 
 |Key        |Description                                                              |
 |-----------|-------------------------------------------------------------------------|

docs/keymap.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)!

docs/newbs.md

@@ -8,9 +8,9 @@ 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)
 
-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).
+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).

docs/newbs_building_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.

docs/newbs_flashing.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.

docs/newbs_getting_started.md

@@ -14,9 +14,7 @@ Before you can build keymaps you need to install some software and setup your bu
 
 You'll need a program that can edit and save **plain text** files. If you are on Windows you can make due with Notepad, and on Linux you can use Gedit, both of which are simple but functional text editors. On macOS you can not use TextEdit.app, it will not save plain text files. You will need to install another program such as Sublime Text.
 
-{% hint style='info' %}
-Not sure which text editor to use? Laurence Bradford wrote [a great introduction](https://learntocodewith.me/programming/basics/text-editors/) to the subject.
-{% endhint %}
+?> Not sure which text editor to use? Laurence Bradford wrote [a great introduction](https://learntocodewith.me/programming/basics/text-editors/) to the subject.
 
 ### QMK Toolbox
 
@@ -29,12 +27,9 @@ QMK Toolbox is a Windows and macOS program that allows you to both program and d
 
 We've tried to make QMK as easy to setup as possible. You only have to prepare your Linux or Unix environment and let QMK install the rest.
 
-{% hint style="info" %}
-If you haven't worked with the Linux/Unix command line before there are a few basic concepts and commands you should learn. These resources will teach you enough to work with QMK:
-
-* [Must Know Linux Commands](https://www.guru99.com/must-know-linux-commands.html)
-* [Some Basic Unix Commands](https://www.tjhsst.edu/~dhyatt/superap/unixcmd.html)
-{% endhint %}
+?> If you haven't worked with the Linux/Unix command line before there are a few basic concepts and commands you should learn. These resources will teach you enough to work with QMK:<br>
+[Must Know Linux Commands](https://www.guru99.com/must-know-linux-commands.html)<br>
+[Some Basic Unix Commands](https://www.tjhsst.edu/~dhyatt/superap/unixcmd.html)
 
 ### Windows
 
@@ -63,9 +58,7 @@ Once you have setup your Linux/Unix environment you are ready to download QMK. W
     git clone https://github.com/qmk/qmk_firmware.git
     cd qmk_firmware
 
-{% hint style='info' %}
-If you already know [how to use GitHub](01_Getting_Started/06_How_to_Use_GitHub.md) we recommend you create and clone your own fork instead. If you don't know what that means you can safely ignore this message.
-{% endhint %}
+?> If you already know [how to use GitHub](getting_started_github.md) we recommend you create and clone your own fork instead. If you don't know what that means you can safely ignore this message.
 
 ## Setup QMK
 
@@ -95,4 +88,4 @@ Checking file size of clueboard_66_rev2_default.hex
 
 ## Creating Your Layout
 
-Now you are ready to create your own personal layout. Move on to [Building Your First Firmware](02_Complete_Newbs_Guide/02_Building_Your_First_Firmware.md) for that.
+Now you are ready to create your own personal layout. Move on to [Building Your First Firmware](newbs_building_firmware.md) for that.

docs/newbs_testing_debugging.md

@@ -15,13 +15,13 @@ Note: These programs are not provided by or endorsed by QMK.
 
 ## Debugging With QMK Toolbox
 
-[QMK Toolbox](https://github.com/qmk/qmk_toolbox) will show messages from your keyboard if you have `CONSOLE_ENABLE = yes` in your `rules.mk`. By default the output is very limited, but you can turn on debug mode to increase the amount of debug output. Use the `DEBUG` keycode in your keymap, or use the [Command](05_Features/Command.md) feature to enable debug mode.
+[QMK Toolbox](https://github.com/qmk/qmk_toolbox) will show messages from your keyboard if you have `CONSOLE_ENABLE = yes` in your `rules.mk`. By default the output is very limited, but you can turn on debug mode to increase the amount of debug output. Use the `DEBUG` keycode in your keymap, or use the [Command](feature_command.md) feature to enable debug mode.
 
 <!-- FIXME: Describe the debugging messages here. -->
 
 ## Sending Your Own Debug Messages
 
-Sometimes it's useful to print debug messages from within your [custom code](07_Reference/Custom_Code.md). Doing so is pretty simple. Start by including `print.h` at the top of your file:
+Sometimes it's useful to print debug messages from within your [custom code](custom_quantum_functions.md). Doing so is pretty simple. Start by including `print.h` at the top of your file:
 
     #include <print.h>
 

docs/porting_your_keyboard_to_qmk_(arm_and_other_chibios_cpus).md

@@ -0,0 +1,70 @@
+Setting up your ARM based PCB is a little more involved than an Atmel MCU, but is easy enough. Start by using `util/new_project.sh <keyboard>` to create a new project:
+
+```
+$ util/new_project.sh simontester
+######################################################
+# /keyboards/simontester project created. To start
+# working on things, cd into keyboards/simontester
+######################################################
+```
+
+
+
+# END OF NEW ARM DOC, OLD ATMEL DOC FOLLOWS
+
+## `/keyboards/<keyboard>/config.h`
+
+The `USB Device descriptor parameter` block contains parameters are used to uniquely identify your keyboard, but they don't really matter to the machine.
+
+Your `MATRIX_ROWS` and `MATRIX_COLS` are the numbers of rows and cols in your keyboard matrix - this may be different than the number of actual rows and columns on your keyboard. There are some tricks you can pull to increase the number of keys in a given matrix, but most keyboards are pretty straight-forward.
+
+The `MATRIX_ROW_PINS` and `MATRIX_COL_PINS` are the pins your MCU uses on each row/column. Your schematic (if you have one) will have this information on it, and the values will vary depending on your setup. This is one of the most important things to double-check in getting your keyboard setup correctly.
+
+For the `DIODE_DIRECTION`, most hand-wiring guides will instruct you to wire the diodes in the `COL2ROW` position, but it's possible that they are in the other - people coming from EasyAVR often use `ROW2COL`. Nothing will function if this is incorrect.
+
+`BACKLIGHT_PIN` is the pin that your PWM-controlled backlight (if one exists) is hooked-up to. Currently only B5, B6, and B7 are supported.
+
+`BACKLIGHT_BREATHING` is a fancier backlight feature that adds breathing/pulsing/fading effects to the backlight. It uses the same timer as the normal backlight. These breathing effects must be called by code in your keymap.
+
+`BACKLIGHT_LEVELS` is how many levels exist for your backlight - max is 15, and they are computed automatically from this number.
+
+## `/keyboards/<keyboard>/Makefile`
+
+The values at the top likely won't need to be changed, since most boards use the `atmega32u4` chip. The `BOOTLOADER_SIZE` will need to be adjusted based on your MCU type. It's defaulted to the Teensy, since that's the most common controller. Below is quoted from the `Makefile`.
+
+```
+# Boot Section Size in *bytes*
+#   Teensy halfKay   512
+#   Teensy++ halfKay 1024
+#   Atmel DFU loader 4096
+#   LUFA bootloader  4096
+#   USBaspLoader     2048
+OPT_DEFS += -DBOOTLOADER_SIZE=512
+```
+
+At the bottom of the file, you'll find lots of features to turn on and off - all of these options should be set with `?=` to allow for the keymap overrides. `?=` only assigns if the variable was previously undefined. For the full documentation of these features, see the [Makefile options](#makefile-options).
+
+## `/keyboards/<keyboard>/readme.md`
+
+This is where you'll describe your keyboard - please write as much as you can about it! Talking about default functionality/features is useful here. Feel free to link to external pages/sites if necessary. Images can be included here as well. This file will be rendered into a webpage at qmk.fm/keyboards/<keyboard>/.
+
+## `/keyboards/<keyboard>/<keyboard>.c`
+
+This is where all of the custom logic for your keyboard goes - you may not need to put anything in this file, since a lot of things are configured automatically. All of the `*_kb()` functions are defined here. If you modify them, remember to keep the calls to `*_user()`, or things in the keymaps might not work. You can read more about the functions [here](#custom-quantum-functions-for-keyboards-and-keymaps)
+
+## `/keyboards/<keyboard>/<keyboard>.h`
+
+Here is where you can (optionally) define your `KEYMAP` function to remap your matrix into a more readable format. With ortholinear boards, this isn't always necessary, but it can help to accommodate the dead spots on your matrix, where there are keys that take up more than one space (2u, staggering, 6.25u, etc). The example shows the difference between the physical keys, and the matrix design:
+
+```
+#define KEYMAP( \
+    k00, k01, k02, \
+      k10,  k11   \
+) \
+{ \
+    { k00, k01,   k02 }, \
+    { k10, KC_NO, k11 }, \
+}
+```
+
+Each of the `kxx` variables needs to be unique, and usually follows the format `k<row><col>`. You can place `KC_NO` where your dead keys are in your matrix.

docs/qmk.css

@@ -0,0 +1,862 @@
+* {
+  -webkit-font-smoothing: antialiased;
+  -webkit-overflow-scrolling: touch;
+  -webkit-tap-highlight-color: rgba(0,0,0,0);
+  -webkit-text-size-adjust: none;
+  -webkit-touch-callout: none;
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+}
+body:not(.ready) {
+  overflow: hidden;
+}
+body:not(.ready) [data-cloak],
+body:not(.ready) .app-nav,
+body:not(.ready) > nav {
+  display: none;
+}
+div#app {
+  font-size: 30px;
+  font-weight: lighter;
+  margin: 40vh auto;
+  text-align: center;
+}
+div#app:empty::before {
+  content: 'Loading...';
+}
+.emoji {
+  height: 1.2rem;
+  vertical-align: middle;
+}
+.progress {
+  background-color: var(--theme-color, #ea6f5a);
+  height: 2px;
+  left: 0px;
+  position: fixed;
+  right: 0px;
+  top: 0px;
+  -webkit-transition: width 0.2s, opacity 0.4s;
+  transition: width 0.2s, opacity 0.4s;
+  width: 0%;
+  z-index: 999999;
+}
+.search a:hover {
+  color: var(--theme-color, #ea6f5a);
+}
+.search .search-keyword {
+  color: var(--theme-color, #ea6f5a);
+  font-style: normal;
+  font-weight: bold;
+}
+html,
+body {
+  height: 100%;
+}
+body {
+  -moz-osx-font-smoothing: grayscale;
+  -webkit-font-smoothing: antialiased;
+  color: #efefef;
+  font-family: 'Source Sans Pro', 'Helvetica Neue', Arial, sans-serif;
+  font-size: 15px;
+  letter-spacing: 0;
+  margin: 0;
+  overflow-x: hidden;
+}
+img {
+  max-width: 100%;
+}
+a[disabled] {
+  cursor: not-allowed;
+  opacity: 0.6;
+}
+kbd {
+  border: solid 1px #ccc;
+  border-radius: 3px;
+  display: inline-block;
+  font-size: 12px !important;
+  line-height: 12px;
+  margin-bottom: 3px;
+  padding: 3px 5px;
+  vertical-align: middle;
+}
+.task-list-item {
+  list-style-type: none;
+}
+li input[type='checkbox'] {
+  margin: 0 0.2em 0.25em -1.6em;
+  vertical-align: middle;
+}
+.app-nav {
+  margin: 25px 60px 0 0;
+  position: absolute;
+  right: 0;
+  text-align: right;
+  z-index: 10;
+/* navbar dropdown */
+}
+.app-nav.no-badge {
+  margin-right: 25px;
+}
+.app-nav p {
+  margin: 0;
+}
+.app-nav > a {
+  margin: 0 1rem;
+  padding: 5px 0;
+}
+.app-nav ul,
+.app-nav li {
+  display: inline-block;
+  list-style: none;
+  margin: 0;
+}
+.app-nav a {
+  color: inherit;
+  font-size: 16px;
+  text-decoration: none;
+  -webkit-transition: color 0.3s;
+  transition: color 0.3s;
+}
+.app-nav a:hover {
+  color: var(--theme-color, #ea6f5a);
+}
+.app-nav a.active {
+  border-bottom: 2px solid var(--theme-color, #ea6f5a);
+  color: var(--theme-color, #ea6f5a);
+}
+.app-nav li {
+  display: inline-block;
+  margin: 0 1rem;
+  padding: 5px 0;
+  position: relative;
+}
+.app-nav li ul {
+  background-color: #fff;
+  border: 1px solid #ddd;
+  border-bottom-color: #ccc;
+  border-radius: 4px;
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  display: none;
+  max-height: calc(100vh - 61px);
+  overflow-y: auto;
+  padding: 10px 0;
+  position: absolute;
+  right: -15px;
+  text-align: left;
+  top: 100%;
+  white-space: nowrap;
+}
+.app-nav li ul li {
+  display: block;
+  font-size: 14px;
+  line-height: 1rem;
+  margin: 0;
+  margin: 8px 14px;
+  white-space: nowrap;
+}
+.app-nav li ul a {
+  display: block;
+  font-size: inherit;
+  margin: 0;
+  padding: 0;
+}
+.app-nav li ul a.active {
+  border-bottom: 0;
+}
+.app-nav li:hover ul {
+  display: block;
+}
+.github-corner {
+  border-bottom: 0;
+  position: fixed;
+  right: 0;
+  text-decoration: none;
+  top: 0;
+  z-index: 1;
+}
+.github-corner:hover .octo-arm {
+  -webkit-animation: octocat-wave 560ms ease-in-out;
+          animation: octocat-wave 560ms ease-in-out;
+}
+.github-corner svg {
+  color: #3f3f3f;
+  fill: var(--theme-color, #ea6f5a);
+  height: 80px;
+  width: 80px;
+}
+main {
+  display: block;
+  position: relative;
+  width: 100vw;
+  height: 100%;
+  z-index: 0;
+}
+main.hidden {
+  display: none;
+}
+.anchor {
+  display: inline-block;
+  text-decoration: none;
+  -webkit-transition: all 0.3s;
+  transition: all 0.3s;
+}
+.anchor span {
+  color: #c8c8c8;
+}
+.anchor:hover {
+  text-decoration: underline;
+}
+.sidebar {
+  border-right: 1px solid rgba(0,0,0,0.07);
+  overflow-y: auto;
+  padding: 40px 0 0;
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  -webkit-transition: -webkit-transform 250ms ease-out;
+  transition: -webkit-transform 250ms ease-out;
+  transition: transform 250ms ease-out;
+  transition: transform 250ms ease-out, -webkit-transform 250ms ease-out;
+  width: 300px;
+  z-index: 20;
+}
+.sidebar > h1 {
+  margin: 0 auto 1rem;
+  font-size: 1.5rem;
+  font-weight: 300;
+  text-align: center;
+}
+.sidebar > h1 a {
+  color: inherit;
+  text-decoration: none;
+}
+.sidebar > h1 .app-nav {
+  display: block;
+  position: static;
+}
+.sidebar .sidebar-nav {
+  line-height: 2em;
+  padding-bottom: 40px;
+}
+.sidebar li.collapse .app-sub-sidebar {
+  display: none;
+}
+.sidebar ul {
+  margin: 0;
+  padding: 0;
+}
+.sidebar li > p {
+  font-weight: 700;
+  margin: 0;
+}
+.sidebar ul,
+.sidebar ul li {
+  list-style: none;
+}
+.sidebar ul li a {
+  border-bottom: none;
+  display: block;
+}
+.sidebar ul li ul {
+  padding-left: 20px;
+}
+.sidebar::-webkit-scrollbar {
+  width: 4px;
+}
+.sidebar::-webkit-scrollbar-thumb {
+  background: transparent;
+  border-radius: 4px;
+}
+.sidebar:hover::-webkit-scrollbar-thumb {
+  background: rgba(136,136,136,0.4);
+}
+.sidebar:hover::-webkit-scrollbar-track {
+  background: rgba(136,136,136,0.1);
+}
+.sidebar-toggle {
+  background-color: transparent;
+  background-color: rgba(63,63,63,0.8);
+  border: 0;
+  outline: none;
+  padding: 10px;
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  text-align: center;
+  -webkit-transition: opacity 0.3s;
+  transition: opacity 0.3s;
+  width: 284px;
+  z-index: 30;
+}
+.sidebar-toggle .sidebar-toggle-button:hover {
+  opacity: 0.4;
+}
+.sidebar-toggle span {
+  background-color: var(--theme-color, #ea6f5a);
+  display: block;
+  margin-bottom: 4px;
+  width: 16px;
+  height: 2px;
+}
+body.sticky .sidebar,
+body.sticky .sidebar-toggle {
+  position: fixed;
+}
+.content {
+  padding-top: 60px;
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 300px;
+  -webkit-transition: left 250ms ease;
+  transition: left 250ms ease;
+}
+.markdown-section {
+  margin: 0 auto;
+  max-width: 800px;
+  padding: 30px 15px 40px 15px;
+  position: relative;
+}
+.markdown-section > * {
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  font-size: inherit;
+}
+.markdown-section > :first-child {
+  margin-top: 0 !important;
+}
+.markdown-section hr {
+  border: none;
+  border-bottom: 1px solid #eee;
+  margin: 2em 0;
+}
+.markdown-section iframe {
+  border: 1px solid #eee;
+}
+.markdown-section table {
+  border-collapse: collapse;
+  border-spacing: 0;
+  display: block;
+  margin-bottom: 1rem;
+  overflow: auto;
+  width: 100%;
+}
+.markdown-section th {
+  border: 1px solid #ddd;
+  font-weight: bold;
+  padding: 6px 13px;
+}
+.markdown-section td {
+  border: 1px solid #ddd;
+  padding: 6px 13px;
+}
+.markdown-section tr {
+  border-top: 1px solid #ccc;
+}
+.markdown-section tr:nth-child(2n) {
+  background-color: #555555;
+}
+.markdown-section p.tip {
+  background-color: #555555;
+  border-bottom-right-radius: 2px;
+  border-left: 4px solid #f66;
+  border-top-right-radius: 2px;
+  margin: 2em 0;
+  padding: 12px 24px 12px 30px;
+  position: relative;
+}
+.markdown-section p.tip:before {
+  background-color: #f66;
+  border-radius: 100%;
+  color: #3f3f3f;
+  content: '!';
+  font-family: 'Dosis', 'Source Sans Pro', 'Helvetica Neue', Arial, sans-serif;
+  font-size: 14px;
+  font-weight: bold;
+  left: -12px;
+  line-height: 20px;
+  position: absolute;
+  height: 20px;
+  width: 20px;
+  text-align: center;
+  top: 14px;
+}
+.markdown-section p.tip code {
+  background-color: #efefef;
+}
+.markdown-section p.tip em {
+  color: #c8c8c8;
+}
+.markdown-section p.warn {
+  background: rgba(234,111,90,0.1);
+  border-radius: 2px;
+  padding: 1rem;
+}
+body.close .sidebar {
+  -webkit-transform: translateX(-300px);
+          transform: translateX(-300px);
+}
+body.close .sidebar-toggle {
+  width: auto;
+}
+body.close .content {
+  left: 0;
+}
+@media print {
+  .github-corner,
+  .sidebar-toggle,
+  .sidebar,
+  .app-nav {
+    display: none;
+  }
+}
+@media screen and (max-width: 768px) {
+  .github-corner,
+  .sidebar-toggle,
+  .sidebar {
+    position: fixed;
+  }
+  .app-nav {
+    margin-top: 16px;
+  }
+  .app-nav li ul {
+    top: 30px;
+  }
+  main {
+    height: auto;
+    overflow-x: hidden;
+  }
+  .sidebar {
+    left: -300px;
+    -webkit-transition: -webkit-transform 250ms ease-out;
+    transition: -webkit-transform 250ms ease-out;
+    transition: transform 250ms ease-out;
+    transition: transform 250ms ease-out, -webkit-transform 250ms ease-out;
+  }
+  .content {
+    left: 0;
+    max-width: 100vw;
+    position: static;
+    padding-top: 20px;
+    -webkit-transition: -webkit-transform 250ms ease;
+    transition: -webkit-transform 250ms ease;
+    transition: transform 250ms ease;
+    transition: transform 250ms ease, -webkit-transform 250ms ease;
+  }
+  .app-nav,
+  .github-corner {
+    -webkit-transition: -webkit-transform 250ms ease-out;
+    transition: -webkit-transform 250ms ease-out;
+    transition: transform 250ms ease-out;
+    transition: transform 250ms ease-out, -webkit-transform 250ms ease-out;
+  }
+  .sidebar-toggle {
+    background-color: transparent;
+    width: auto;
+    padding: 30px 30px 10px 10px;
+  }
+  body.close .sidebar {
+    -webkit-transform: translateX(300px);
+            transform: translateX(300px);
+  }
+  body.close .sidebar-toggle {
+    background-color: rgba(63,63,63,0.8);
+    -webkit-transition: 1s background-color;
+    transition: 1s background-color;
+    width: 284px;
+    padding: 10px;
+  }
+  body.close .content {
+    -webkit-transform: translateX(300px);
+            transform: translateX(300px);
+  }
+  body.close .app-nav,
+  body.close .github-corner {
+    display: none;
+  }
+  .github-corner:hover .octo-arm {
+    -webkit-animation: none;
+            animation: none;
+  }
+  .github-corner .octo-arm {
+    -webkit-animation: octocat-wave 560ms ease-in-out;
+            animation: octocat-wave 560ms ease-in-out;
+  }
+}
+@-webkit-keyframes octocat-wave {
+  0%, 100% {
+    -webkit-transform: rotate(0);
+            transform: rotate(0);
+  }
+  20%, 60% {
+    -webkit-transform: rotate(-25deg);
+            transform: rotate(-25deg);
+  }
+  40%, 80% {
+    -webkit-transform: rotate(10deg);
+            transform: rotate(10deg);
+  }
+}
+@keyframes octocat-wave {
+  0%, 100% {
+    -webkit-transform: rotate(0);
+            transform: rotate(0);
+  }
+  20%, 60% {
+    -webkit-transform: rotate(-25deg);
+            transform: rotate(-25deg);
+  }
+  40%, 80% {
+    -webkit-transform: rotate(10deg);
+            transform: rotate(10deg);
+  }
+}
+section.cover {
+  -webkit-box-align: center;
+      -ms-flex-align: center;
+          align-items: center;
+  background-position: center center;
+  background-repeat: no-repeat;
+  background-size: cover;
+  height: 100vh;
+  display: none;
+}
+section.cover.show {
+  display: -webkit-box;
+  display: -ms-flexbox;
+  display: flex;
+}
+section.cover.has-mask .mask {
+  background-color: #3f3f3f;
+  opacity: 0.8;
+  position: absolute;
+  top: 0;
+  height: 100%;
+  width: 100%;
+}
+section.cover .cover-main {
+  -webkit-box-flex: 1;
+      -ms-flex: 1;
+          flex: 1;
+  margin: -20px 16px 0;
+  text-align: center;
+  z-index: 1;
+}
+section.cover a {
+  color: inherit;
+  text-decoration: none;
+}
+section.cover a:hover {
+  text-decoration: none;
+}
+section.cover p {
+  line-height: 1.5rem;
+  margin: 1em 0;
+}
+section.cover h1 {
+  color: inherit;
+  font-size: 2.5rem;
+  font-weight: 300;
+  margin: 0.625rem 0 2.5rem;
+  position: relative;
+  text-align: center;
+}
+section.cover h1 a {
+  display: block;
+}
+section.cover h1 small {
+  bottom: -0.4375rem;
+  font-size: 1rem;
+  position: absolute;
+}
+section.cover blockquote {
+  font-size: 1.5rem;
+  text-align: center;
+}
+section.cover ul {
+  line-height: 1.8;
+  list-style-type: none;
+  margin: 1em auto;
+  max-width: 500px;
+  padding: 0;
+}
+section.cover .cover-main > p:last-child a {
+  border-color: var(--theme-color, #ea6f5a);
+  border-radius: 2rem;
+  border-style: solid;
+  border-width: 1px;
+  -webkit-box-sizing: border-box;
+          box-sizing: border-box;
+  color: var(--theme-color, #ea6f5a);
+  display: inline-block;
+  font-size: 1.05rem;
+  letter-spacing: 0.1rem;
+  margin: 0.5rem 1rem;
+  padding: 0.75em 2rem;
+  text-decoration: none;
+  -webkit-transition: all 0.15s ease;
+  transition: all 0.15s ease;
+}
+section.cover .cover-main > p:last-child a:last-child {
+  background-color: var(--theme-color, #ea6f5a);
+  color: #fff;
+}
+section.cover .cover-main > p:last-child a:last-child:hover {
+  color: inherit;
+  opacity: 0.8;
+}
+section.cover .cover-main > p:last-child a:hover {
+  color: inherit;
+}
+section.cover blockquote > p > a {
+  border-bottom: 2px solid var(--theme-color, #ea6f5a);
+  -webkit-transition: color 0.3s;
+  transition: color 0.3s;
+}
+section.cover blockquote > p > a:hover {
+  color: var(--theme-color, #ea6f5a);
+}
+body {
+  background-color: #3f3f3f;
+}
+/* sidebar */
+.sidebar {
+  background-color: #3f3f3f;
+  color: #c8c8c8;
+}
+.sidebar li {
+  margin: 6px 15px;
+}
+.sidebar ul li a {
+  color: #c8c8c8;
+  font-size: 14px;
+  overflow: hidden;
+  text-decoration: none;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.sidebar ul li a:hover {
+  text-decoration: underline;
+}
+.sidebar ul li ul {
+  padding: 0;
+}
+.sidebar ul li.active > a {
+  color: var(--theme-color, #ea6f5a);
+  font-weight: 600;
+}
+/* markdown content found on pages */
+.markdown-section h1,
+.markdown-section h2,
+.markdown-section h3,
+.markdown-section h4,
+.markdown-section strong {
+  color: #657b83;
+  font-weight: 600;
+}
+.markdown-section a {
+  color: var(--theme-color, #ea6f5a);
+  font-weight: 600;
+}
+.markdown-section h1 {
+  font-size: 2rem;
+  margin: 0 0 1rem;
+}
+.markdown-section h2 {
+  font-size: 1.75rem;
+  margin: 45px 0 0.8rem;
+}
+.markdown-section h3 {
+  font-size: 1.5rem;
+  margin: 40px 0 0.6rem;
+}
+.markdown-section h4 {
+  font-size: 1.25rem;
+}
+.markdown-section h5 {
+  font-size: 1rem;
+}
+.markdown-section h6 {
+  color: #777;
+  font-size: 1rem;
+}
+.markdown-section figure,
+.markdown-section p,
+.markdown-section ul,
+.markdown-section ol {
+  margin: 1.2em 0;
+}
+.markdown-section p,
+.markdown-section ul,
+.markdown-section ol {
+  line-height: 1.6rem;
+  word-spacing: 0.05rem;
+}
+.markdown-section ul,
+.markdown-section ol {
+  padding-left: 1.5rem;
+}
+.markdown-section blockquote {
+  border-left: 4px solid var(--theme-color, #ea6f5a);
+  color: #858585;
+  margin: 2em 0;
+  padding-left: 20px;
+}
+.markdown-section blockquote p {
+  font-weight: 600;
+  margin-left: 0;
+}
+.markdown-section iframe {
+  margin: 1em 0;
+}
+.markdown-section em {
+  color: #7f8c8d;
+}
+.markdown-section code {
+  background-color: #282828;
+  border-radius: 2px;
+  color: #aaaaaa;
+  font-family: 'Roboto Mono', Monaco, courier, monospace;
+  font-size: 0.8rem;
+  margin: 0 2px;
+  padding: 3px 5px;
+  white-space: pre-wrap;
+}
+.markdown-section pre {
+  -moz-osx-font-smoothing: initial;
+  -webkit-font-smoothing: initial;
+  background-color: #282828;
+  font-family: 'Roboto Mono', Monaco, courier, monospace;
+  line-height: 1.5rem;
+  margin: 1.2em 0;
+  overflow: auto;
+  padding: 0 1.4rem;
+  position: relative;
+  word-wrap: normal;
+}
+/* code highlight */
+.token.comment,
+.token.prolog,
+.token.doctype,
+.token.cdata {
+  color: #8e908c;
+}
+.token.namespace {
+  opacity: 0.7;
+}
+.token.boolean,
+.token.number {
+  color: #c76b29;
+}
+.token.punctuation {
+  color: #525252;
+}
+.token.property {
+  color: #c08b30;
+}
+.token.tag {
+  color: #2973b7;
+}
+.token.string {
+  color: var(--theme-color, #ea6f5a);
+}
+.token.selector {
+  color: #6679cc;
+}
+.token.attr-name {
+  color: #2973b7;
+}
+.token.entity,
+.token.url,
+.language-css .token.string,
+.style .token.string {
+  color: #22a2c9;
+}
+.token.attr-value,
+.token.control,
+.token.directive,
+.token.unit {
+  color: var(--theme-color, #ea6f5a);
+}
+.token.keyword {
+  color: #e96900;
+}
+.token.statement,
+.token.regex,
+.token.atrule {
+  color: #22a2c9;
+}
+.token.placeholder,
+.token.variable {
+  color: #3d8fd1;
+}
+.token.deleted {
+  text-decoration: line-through;
+}
+.token.inserted {
+  border-bottom: 1px dotted #202746;
+  text-decoration: none;
+}
+.token.italic {
+  font-style: italic;
+}
+.token.important,
+.token.bold {
+  font-weight: bold;
+}
+.token.important {
+  color: #c94922;
+}
+.token.entity {
+  cursor: help;
+}
+.markdown-section pre > code {
+  -moz-osx-font-smoothing: initial;
+  -webkit-font-smoothing: initial;
+  background-color: #282828;
+  border-radius: 2px;
+  color: #657b83;
+  display: block;
+  font-family: 'Roboto Mono', Monaco, courier, monospace;
+  font-size: 0.8rem;
+  line-height: inherit;
+  margin: 0 2px;
+  max-width: inherit;
+  overflow: inherit;
+  padding: 2.2em 5px;
+  white-space: inherit;
+}
+.markdown-section code::after,
+.markdown-section code::before {
+  letter-spacing: 0.05rem;
+}
+code .token {
+  -moz-osx-font-smoothing: initial;
+  -webkit-font-smoothing: initial;
+  min-height: 1.5rem;
+}
+pre::after {
+  color: #ccc;
+  content: attr(data-lang);
+  font-size: 0.6rem;
+  font-weight: 600;
+  height: 15px;
+  line-height: 15px;
+  padding: 5px 10px 0;
+  position: absolute;
+  right: 0;
+  text-align: right;
+  top: 0;
+}
+.markdown-section p.tip {
+  background-color: #282828;
+  color: #657b83;
+}
+input[type='search'] {
+  background: #4f4f4f;
+  border-color: #4f4f4f;
+  color: #c8c8c8;
+}

docs/quantum_keycodes.md

@@ -15,8 +15,8 @@ On this page we have documented keycodes between `0x00FF` and `0xFFFF` which are
 |`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                                              |

docs/reference_glossary.md

@@ -36,12 +36,12 @@ An alternative keyboard layout developed by Dr. August Dvorak in the 1930's. A s
 ## Dynamic Macro
 A macro which has been recorded on the keyboard and which will be lost when the keyboard is unplugged or the computer rebooted.
 
-* [Dynamic Macro Documentation](05_Features/Dynamic_Macros.md)
+* [Dynamic Macro Documentation](feature_dynamic_macros.md)
 
 ## Eclipse
 An IDE that is popular with many C developers.
 
-* [Eclipse Setup Instructions](09_IDEs/Eclipse.md)
+* [Eclipse Setup Instructions](eclipse.md)
 
 ## Firmware
 The software that controls your MCU.
@@ -62,7 +62,7 @@ In-system programming, a method of programming an AVR chip using external hardwa
 An interface for receiving debugging messages from your keyboard. You can view these messages using [QMK Flasher](https://github.com/qmk/qmk_flasher) or [PJRC's hid_listen](https://www.pjrc.com/teensy/hid_listen.html)
 
 ## Keycode
-A 2-byte number that represents a particular key. `0x00`-`0xFF` are used for [Basic Keycodes](06_Keycodes/Basic.md) while `0x100`-`0xFFFF` are used for [Quantum Keycodes](06_Keycodes/Quantum_Keycodes.md).
+A 2-byte number that represents a particular key. `0x00`-`0xFF` are used for [Basic Keycodes](keycodes_basic.md) while `0x100`-`0xFFFF` are used for [Quantum Keycodes](quantum_keycodes.md).
 
 ## Key Down
 An event that happens when a key is pressed down, but is completed before a key is released.
@@ -79,7 +79,7 @@ An abstraction used to allow a key to serve multiple purposes. The highest activ
 ## Leader Key
 A feature that allows you to tap the leader key followed by a sequence of 1, 2, or 3 keys to activate key presses or other quantum features.
 
-* [Leader Key Documentation](05_Features/Leader_Key.md)
+* [Leader Key Documentation](feature_leader_key.md)
 
 ## LED
 Light Emitting Diode, the most common device used for indicators on a keyboard.
@@ -93,7 +93,7 @@ A wiring pattern of columns and rows that enables the MCU to detect keypresses w
 ## Macro
 A feature that lets you send multiple keypress events (hid reports) after having pressed only a single key.
 
-* [Macro Documentation](05_Features/Macros.md)
+* [Macro Documentation](feature_macros.md)
 
 ## MCU
 Microcontrol Unit, the processor that powers your keyboard.
@@ -104,7 +104,7 @@ A key that is held down while typing another key to modify the action of that ke
 ## Mousekeys
 A feature that lets you control your mouse cursor and click from your keyboard.
 
-* [Mousekeys Documentation](05_Features/Mouse_Keys.md)
+* [Mousekeys Documentation](feature_mouse_keys.md)
 
 ## N-Key Rollover (NKRO)
 A term that applies to keyboards that are capable of reporting any number of key-presses at once.
@@ -133,7 +133,7 @@ A 1 byte number that is sent as part of a HID report over USB that represents a
 ## Space Cadet Shift
 A special set of shift keys which allow you to type various types of braces by tapping the left or right shift one or more times.
 
-* [Space Cadet Shift Documentation](05_Features/Space_Cadet_Shift.md)
+* [Space Cadet Shift Documentation](feature_space_cadet.md)
 
 ## Tap
 Pressing and releasing a key. In some situations you will need to distinguish between a key down and a key up event, and Tap always refers to both at once.
@@ -141,7 +141,7 @@ Pressing and releasing a key. In some situations you will need to distinguish be
 ## Tap Dance
 A feature that lets you assign multiple keycodes to the same key based on how many times you press it.
 
-* [Tap Dance Documentation](05_Features/Tap_Dance.md)
+* [Tap Dance Documentation](feature_tap_dance.md)
 
 ## Teensy
 A low-cost AVR development board that is commonly used for hand-wired builds. A teensy is often chosen despite costing a few dollars more due to its halfkay bootloader, which makes flashing very simple.
@@ -152,12 +152,12 @@ A generic term for LEDs that light the underside of the board. These LED's typic
 ## Unicode
 In the larger computer world Unicode is a set of encoding schemes for representing characters in any language. As it relates to QMK it means using various OS schemes to send unicode codepoints instead of scancodes.
 
-* [Unicode Documentation](05_Features/Unicode.md)
+* [Unicode Documentation](feature_unicode.md)
 
 ## Unit Testing
 A framework for running automated tests against QMK. Unit testing helps us be confident that our changes do not break anything.
 
-* [Unit Testing Documentation](07_Reference/Unit_Testing.md)
+* [Unit Testing Documentation](unit_testing.md)
 
 ## USB
 Universal Serial Bus, the most common wired interface for a keyboard.

docs/sidebar.css

@@ -0,0 +1,10 @@
+.sidebar-toggle {
+  position: absolute;
+  top: 0;
+  bottom: auto;
+  left: 0;
+}
+
+.search {
+  margin-top: 40px;
+}