Restructure the hardware and feature docs to make things easier to find (#1888)

* fix #1313 by documenting more config.h options * Clean up and organize documentation
2017-10-24 20:34:28 -07:00 · 2017-10-24 20:34:28 -07:00 · 67cc5cebc0
parent 8892c50336
commit 67cc5cebc0
23 changed files with 508 additions and 328 deletions
--- a/docs/_summary.md
+++ b/docs/_summary.md
@ -12,57 +12,61 @@
  * [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)
-  * [Layouts](feature_layouts.md)
+  * [Advanced Keycodes](feature_advanced_keycodes.md)
-  * [Common Shortcuts](feature_common_shortcuts.md)
+  * [Audio](feature_audio.md)
  * [Userspace](feature_userspace.md)
  * [Backlight](feature_backlight.md)
  * [Bootmagic](feature_bootmagic.md)
-  * [Dynamic Macros](dynamic_macros.md)
+  * [Dynamic Macros](feature_dynamic_macros.md)
-  * [Key Lock](key_lock.md)
+  * [Key Lock](feature_key_lock.md)
  * [Layouts](feature_layouts.md)
  * [Leader Key](feature_leader_key.md)
-  * [Macros](macros.md)
+  * [Macros](feature_macros.md)
-  * [Mouse keys](mouse_keys.md)
+  * [Mouse keys](feature_mouse_keys.md)
  * [Pointing Device](feature_pointing_device.md)
  * [PS2 Mouse](feature_ps2_mouse.md)
-  * [Space Cadet](space_cadet_shift.md)
+  * [Space Cadet](feature_space_cadet.md)
-  * [Tap Dance](tap_dance.md)
+  * [Stenography](feature_stenography.md)
-  * [Audio](feature_audio.md)
+  * [Tap Dance](feature_tap_dance.md)
  * [Thermal Printer](feature_thermal_printer.md)
  * [Stenography](stenography.md)
  * [Unicode](unicode.md)
  * [Terminal](feature_terminal.md)
  * [Thermal Printer](feature_thermal_printer.md)
  * [Unicode](feature_unicode.md)
  * [Userspace](feature_userspace.md)
 * Reference
  * [Config Options](config_options.md)
  * [Customizing Functionality](custom_quantum_functions.md)
  * [Documentation Best Practices](documentation_best_practices.md)
  * [Documentation Templates](documentation_templates.md)
  * [Glossary](glossary.md)
  * [Keymap overview](keymap.md)
  * [Keycodes](keycodes.md)
    * [Basic](keycodes_basic.md)
    * [Quantum](quantum_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_common_shortcuts.md#switching-and-toggling-layers)
    * [Mod+Key](feature_common_shortcuts.md#modifier-keys)
    * [Mod Tap](feature_common_shortcuts.md#mod-tap)
    * [One Shot Keys](feature_common_shortcuts.md#one-shot-keys)
-    * [Shifted Keys](feature_common_shortcuts.md#shifted-keycodes)
+    * [Quantum](quantum_keycodes.md)
    * [Stenography](stenography.md#keycode-reference)
    * [RGB Light](feature_rgblight.md#rgblight-keycodes)
    * [Shifted Keys](feature_common_shortcuts.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)
  * [The `config.h` File](config_options.md)
  * [Customizing Functionality](custom_quantum_functions.md)
  * [Documentation Best Practices](documentation_best_practices.md)
  * [Documentation Templates](documentation_templates.md)
  * [Unit Testing](unit_testing.md)
 * For Makers and Modders
  * [Adding a keyboard to QMK](adding_a_keyboard_to_qmk.md)
  * [Hand Wiring Guide](hand_wiring.md)
  * [ISP flashing guide](isp_flashing_guide.md)
  * [Modding your keyboard](modding_your_keyboard.md)
  * [Porting your keyboard to QMK](porting_your_keyboard_to_qmk.md)
 * For a Deeper Understanding
  * [How Keyboards Work](how_keyboards_work.md)
--- a/docs/config_options.md
+++ b/docs/config_options.md
@ -1,129 +1,198 @@
-# The `config.h` file
+# Configuring QMK
-This is a c header file that is one of the first things included, and will persist over the whole project (if included). Lots of variables can be set here and accessed elsewhere (namely keymaps). This file can exist at a couple different levels:
+QMK is nearly infinitely configurable. Wherever possible we err on the side of allowing users to customize their keyboard, even at the expense of code size. That level of flexibility makes for a daunting configuration experience, however.
 There are two main types of configuration files in QMK- `config.h` and `rules.mk`. These files exist at various levels in QMK and all files of the same type are combined to build the final configuration. The levels, from lowest priority to highest priority, are:
 * QMK Default
 * Keyboard
 * Folders (Up to 5 levels deep)
 * Keymap
 ## QMK Default
 Every available setting in QMK has a default. If that setting is not set at the Keyboard, Folder, or Keymap level this is the setting that will be used.
 ## Keyboard
-```c
+This level contains config options that should apply to the whole keyboard. Some settings won't change in revisions, or most keymaps. Other settings are merely defaults for this keyboard and can be overridden by folders and/or keymaps.
 #ifndef CONFIG_H
 #define CONFIG_H
-#include "config_common.h"
+## Folders
-// config options
+Some keyboards have folders and sub-folders to allow for different hardware configurations. Most keyboards only go 1 folder deep, but QMK supports structures up to 5 folders deep. Each folder can have its own `config.h` and `rules.mk` files that are incorporated into the final configuration.
 #endif
 ```
 This file contains config options that should apply to the whole keyboard, and won't change in revisions, or most keymaps. The revision block here only applies to keyboards with revisions.
 ## Revisions
 ```c
 #ifndef <revision>_CONFIG_H
 #define <revision>_CONFIG_H
 #include "config_common.h"
 // config options
 #endif
 ```
 For keyboards that have revisions, this file contains config options that should apply to only that revisions, and won't change in most keymaps.
 ## Keymap
-```c
+This level contains all of the options for that particular keymap. If you wish to override a previous declaration, you can use `#undef <variable>` to undefine it, where you can then redefine it without an error.
 #ifndef CONFIG_USER_H
 #define CONFIG_USER_H
-#include "config_common.h"
+# The `config.h` file
-// config options
+This is a C header file that is one of the first things included, and will persist over the whole project (if included). Lots of variables can be set here and accessed elsewhere.
-#endif
+## `config.h` Options
 ```
-This file contains all of the options for that particular keymap. If you wish to override a previous declaration, you can use `#undef <variable>` to undefine it, where you can then redefine it without an error.
+### Hardware Options
 * `#define VENDOR_ID 0x1234`
  * defines your VID, and for most DIY projects, can be whatever you want
 * `#define PRODUCT_ID 0x5678`
  * defines your PID, and for most DIY projects, can be whatever you want
 * `#define DEVICE_VER 0`
  * defines the device version (often used for revisions)
 * `#define MANUFACTURER Me`
  * generally who/whatever brand produced the board
 * `#define PRODUCT Board`
  * the name of the keyboard
 * `#define DESCRIPTION a keyboard`
  * a short description of what the keyboard is
 * `#define MATRIX_ROWS 5`
  * the number of rows in your keyboard's matrix
 * `#define MATRIX_COLS 15`
  * the number of columns in your keyboard's matrix
 * `#define MATRIX_ROW_PINS { D0, D5, B5, B6 }`
  * pins of the rows, from top to bottom
 * `#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }`
  * pins of the columns, from left to right
 * `#define UNUSED_PINS { D1, D2, D3, B1, B2, B3 }`
  * pins unused by the keyboard for reference
 * `#define MATRIX_HAS_GHOST`
  * define is matrix has ghost (unlikely)
 * `#define DIODE_DIRECTION COL2ROW`
  * COL2ROW or ROW2COL - how your matrix is configured. COL2ROW means the black mark on your diode is facing to the rows, and between the switch and the rows.
 * `#define AUDIO_VOICES`
  * turns on the alternate audio voices (to cycle through)
 * `#define C6_AUDIO`
  * enables audio on pin C6
 * `#define B5_AUDIO`
  * enables audio on pin B5 (duophony is enable if both are enabled)
 * `#define BACKLIGHT_PIN B7`
  * pin of the backlight - B5, B6, B7 use PWM, others use softPWM
 * `#define BACKLIGHT_LEVELS 3`
  * number of levels your backlight will have (not including off)
 * `#define DEBOUNCING_DELAY 5`
  * the delay when reading the value of the pin (5 is default)
 * `#define LOCKING_SUPPORT_ENABLE`
  * mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap
 * `#define LOCKING_RESYNC_ENABLE`
  * tries to keep switch state consistent with keyboard LED state
 * `#define IS_COMMAND() ( keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) )`
  * key combination that allows the use of magic commands (useful for debugging)
-# Config Options
+### Features That Can Be Disabled
-```c
+If you define these options you will disable the associated feature, which can save on code size.
 #define VENDOR_ID 0x1234 // defines your VID, and for most DIY projects, can be whatever you want
 #define PRODUCT_ID 0x5678 // defines your PID, and for most DIY projects, can be whatever you want  
 #define DEVICE_VER 0 // defines the device version (often used for revisions)
-#define MANUFACTURER Me // generally who/whatever brand produced the board
+* `#define NO_DEBUG`
-#define PRODUCT Board // the name of the keyboard
+  * disable debuging
-#define DESCRIPTION a keyboard // a short description of what the keyboard is
+* `#define NO_PRINT`
  * disable printing/debugging using hid_listen
 * `#define NO_ACTION_LAYER`
  * disable layers
 * `#define NO_ACTION_TAPPING`
  * disable tap dance and other tapping features
 * `#define NO_ACTION_ONESHOT`
  * disable one-shot modifiers
 * `#define NO_ACTION_MACRO`
  * disable all macro handling
 * `#define NO_ACTION_FUNCTION`
  * disable the action function (deprecated)
-#define MATRIX_ROWS 5 // the number of rows in your keyboard's matrix
+### Features That Can Be Enabled
 #define MATRIX_COLS 15 // the number of columns in your keyboard's matrix
-#define MATRIX_ROW_PINS { D0, D5, B5, B6 } // pins of the rows, from top to bottom
+If you define these options you will enable the associated feature, which may increase your code size.
 #define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 } // pins of the columns, from left to right
 #define UNUSED_PINS { D1, D2, D3, B1, B2, B3 } // pins unused by the keyboard for reference 
 #define MATRIX_HAS_GHOST // define is matrix has ghost (unlikely)
 #define DIODE_DIRECTION COL2ROW // COL2ROW or ROW2COL - how your matrix is configured
 // COL2ROW means the black mark on your diode is facing to the rows, and between the switch and the rows
-#define AUDIO_VOICES // turns on the alternate audio voices (to cycle through)
+* `#define FORCE_NKRO`
-#define C6_AUDIO // enables audio on pin C6
+  * NKRO by default requires to be turned on, this forces it on during keyboard startup regardless of eeprom setting. NKRO can still be turned off but will be turned on again if the keyboard reboots.
-#define B5_AUDIO // enables audio on pin B5 (duophony is enable if both are enabled)
+* `#define PREVENT_STUCK_MODIFIERS`
  * when switching layers, this will release all mods
-#define BACKLIGHT_PIN B7 // pin of the backlight - B5, B6, B7 use PWM, others use softPWM
+### Behaviors That Can Be Configured
 #define BACKLIGHT_LEVELS 3 // number of levels your backlight will have (not including off)
-#define DEBOUNCING_DELAY 5 // the delay when reading the value of the pin (5 is default)
+* `#define TAPPING_TERM 200`
  * how long before a tap becomes a hold
 * `#define TAPPING_TOGGLE 2`
  * how many taps before triggering the toggle
 * `#define PERMISSIVE_HOLD`
  * makes tap and hold keys work better for fast typers who don't want tapping term set above 500
 * `#define LEADER_TIMEOUT 300`
  * how long before the leader key times out
 * `#define ONESHOT_TIMEOUT 300`
  * how long before oneshot times out
 * `#define ONESHOT_TAP_TOGGLE 2`
  * how many taps before oneshot toggle is triggered
 * `#define IGNORE_MOD_TAP_INTERRUPT`
  * makes it possible to do rolling combos (zx) with keys that convert to other keys on hold
-#define LOCKING_SUPPORT_ENABLE // mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap
+### RGB Light Configuration
 #define LOCKING_RESYNC_ENABLE // tries to keep switch state consistent with keyboard LED state
-#define IS_COMMAND() ( \ // key combination that allows the use of magic commands (useful for debugging)
+* `#define RGB_DI_PIN D7`
-    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+  * pin the DI on the ws2812 is hooked-up to
-)
+* `#define RGBLIGHT_ANIMATIONS`
  * run RGB animations
 * `#define RGBLED_NUM 15`
  * number of LEDs
 * `#define RGBLIGHT_HUE_STEP 12`
  * units to step when in/decreasing hue
 * `#define RGBLIGHT_SAT_STEP 25`
  * units to step when in/decresing saturation
 * `#define RGBLIGHT_VAL_STEP 12`
  * units to step when in/decreasing value (brightness)
 * `#define RGBW_BB_TWI`
  * bit-bangs twi to EZ RGBW LEDs (only required for Ergodox EZ)
-// the following options can save on file size at the expense of that feature
+### Mouse Key Options
 #define NO_DEBUG // disable debuging (saves on file size)
 #define NO_PRINT // disable printing (saves of file size)
 #define NO_ACTION_LAYER // no layers
 #define NO_ACTION_TAPPING // no tapping for layers/mods
 #define NO_ACTION_ONESHOT // no oneshot for layers/mods
 #define NO_ACTION_MACRO // no macros
 #define NO_ACTION_FUNCTION // no functions
-#define FORCE_NKRO // NKRO by default requires to be turned on, this forces it to be on always
+* `#define MOUSEKEY_INTERVAL 20`
 * `#define MOUSEKEY_DELAY 0`
 * `#define MOUSEKEY_TIME_TO_MAX 60`
 * `#define MOUSEKEY_MAX_SPEED 7`
 * `#define MOUSEKEY_WHEEL_DELAY 0`
-#define PREVENT_STUCK_MODIFIERS // when switching layers, this will release all mods
+# The `rules.mk` File
-#define TAPPING_TERM 200 // how long before a tap becomes a hold
+This is a [make](https://www.gnu.org/software/make/manual/make.html) file that is included by the top-level `Makefile`. It is used to set some information about the MCU that we will be compiling for as well as enabling and disabling certain features.
 #define TAPPING_TOGGLE 2 // how many taps before triggering the toggle
-#define PERMISSIVE_HOLD // makes tap and hold keys work better for fast typers who don't want tapping term set above 500
+## `rules.mk` options
-#define LEADER_TIMEOUT 300 // how long before the leader key times out
+### Build Options
-#define ONESHOT_TIMEOUT 300 // how long before oneshot times out
+* `DEFAULT_FOLDER`
-#define ONESHOT_TAP_TOGGLE 2 // how many taps before oneshot toggle is triggered
+  * Used to specify a default folder when a keyboard has more than one sub-folder.
 * `SRC`
  * Used to add files to the compilation/linking list.
 * `LAYOUTS`
  * A list of [layouts](feature_layouts.md) this keyboard supports.
-#define IGNORE_MOD_TAP_INTERRUPT // makes it possible to do rolling combos (zx) with keys that convert to other keys on hold
+### AVR MCU Options
 * `MCU = atmega32u4`
 * `F_CPU = 16000000`
 * `ARCH = AVR8`
 * `F_USB = $(F_CPU)`
 * `OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT`
 * `OPT_DEFS += -DBOOTLOADER_SIZE=4096`
-// ws2812 options
+### Feature Options
 #define RGB_DI_PIN D7 // pin the DI on the ws2812 is hooked-up to
 #define RGBLIGHT_ANIMATIONS // run RGB animations
 #define RGBLED_NUM 15 // number of LEDs
 #define RGBLIGHT_HUE_STEP 12 // units to step when in/decreasing hue
 #define RGBLIGHT_SAT_STEP 25 // units to step when in/decresing saturation
 #define RGBLIGHT_VAL_STEP 12 // units to step when in/decreasing value (brightness)
-#define RGBW_BB_TWI // bit-bangs twi to EZ RGBW LEDs (only required for Ergodox EZ)
+Use these to enable or disable building certain features. The more you have enabled the bigger your firmware will be, and you run the risk of building a firmware too large for your MCU.
-// mousekey options (self-describing)
+* `BOOTMAGIC_ENABLE`
-#define MOUSEKEY_INTERVAL 20
+  * Virtual DIP switch configuration(+1000)
-#define MOUSEKEY_DELAY 0
+* `MOUSEKEY_ENABLE`
-#define MOUSEKEY_TIME_TO_MAX 60
+  * Mouse keys(+4700)
-#define MOUSEKEY_MAX_SPEED 7
+* `EXTRAKEY_ENABLE`
-#define MOUSEKEY_WHEEL_DELAY 0
+  * Audio control and System control(+450)
-
+* `CONSOLE_ENABLE`
-```
+  * Console for debug(+400)
 * `COMMAND_ENABLE`
  * Commands for debug and configuration
 * `NKRO_ENABLE`
  * USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 * `AUDIO_ENABLE`
  * Enable the audio subsystem.
 * `RGBLIGHT_ENABLE`
  * Enable keyboard underlight functionality
 * `MIDI_ENABLE`
  * MIDI controls
 * `UNICODE_ENABLE`
  * Unicode
 * `BLUETOOTH_ENABLE`
  * Enable Bluetooth with the Adafruit EZ-Key HID
--- a/docs/contributing.md
+++ b/docs/contributing.md
@ -144,4 +144,4 @@ To maintain a clear vision of how things are laid out in QMK we try to plan out
 # What does the Code of Conduct mean for me?
-Our Code of Conduct means that you are responsible for treating everyone on the project with respect and courtesy regardless of their identity. If you are the victim of any inappropriate behavior or comments as described in our Code of Conduct, we are here for you and will do the best to ensure that the abuser is reprimanded appropriately, per our code.
+Our [Code of Conduct](https://github.com/qmk/qmk_firmware/blob/master/CODE_OF_CONDUCT.md) means that you are responsible for treating everyone on the project with respect and courtesy regardless of their identity. If you are the victim of any inappropriate behavior or comments as described in our Code of Conduct, we are here for you and will do the best to ensure that the abuser is reprimanded appropriately, per our code.
--- a/docs/faq_keymap.md
+++ b/docs/faq_keymap.md
@ -7,6 +7,17 @@ See [Keycodes](keycodes.md) for an index of keycodes available to you. These lin
 Keycodes are actually defined in [common/keycode.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keycode.h).
 ## What Are The Default Keycodes?
 There are 3 standard keyboard layouts in use around the world- ANSI, ISO, and JIS. North America primarily uses ANSI, Europe and Africa primarily use ISO, and Japan uses JIS. Regions not mentioned typically use either ANSI or ISO. The keycodes corresponding to these layouts are shown here:
 <!-- Source for this image: http://www.keyboard-layout-editor.com/#/gists/9ce023dc6caadc0cf11c88c782350a8c -->
 ![Keyboard Layout Image](https://i.imgur.com/45m4mRf.png)
 ## The Menu Key Isn't Working
 The key found on most modern keyboards that is located between `KC_RGUI` and `KC_RCTL` is actually called `KC_APP`. This is because when that key was invented there was already a key named `MENU` in the relevant standards, so MS chose to call that the `APP` key.
 ## `KC_SYSREQ` isn't working
 Use keycode for Print Screen(`KC_PSCREEN` or `KC_PSCR`) instead of `KC_SYSREQ`. Key combination of 'Alt + Print Screen' is recognized as 'System request'.
--- a/docs/feature_advanced_keycodes.md
+++ b/docs/feature_advanced_keycodes.md
@ -1,6 +1,8 @@
-# Common Keymap Shortcuts
+# Advanced Keycodes
-Your keymap can include shortcuts to common operations, for example shifted keys. This page documents the functions that are available to you.
+Your keymap can include keycodes that are more advanced than normal, for example shifted keys. This page documents the functions that are available to you.
 ### Assigning Custom Names
 People often define custom names using `#define`. For example:
@ -15,7 +17,7 @@ This will allow you to use `FN_CAPS` and `ALT_TAB` in your `KEYMAP()`, keeping i
 Currently, the keycodes able to used with these functions are limited to the [Basic Keycodes](keycodes_basic.html), meaning you can't use keycodes like `KC_TILD`, or anything greater than 0xFF. For a full list of the keycodes able to be used see [Basic Keycodes](keycodes_basic.html).
-## Switching and toggling layers
+# Switching and toggling layers
 These functions allow you to activate layers in various ways.
@ -25,7 +27,7 @@ These functions allow you to activate layers in various ways.
 * `TO(layer)` - Goes to a layer. This code is special, because it lets you go either up or down the stack -- just goes directly to the layer you want. So while other codes only let you go _up_ the stack (from layer 0 to layer 3, for example), `TO(2)` is going to get you to layer 2, no matter where you activate it from -- even if you're currently on layer 5. This gets activated on keydown (as soon as the key is pressed).
 * `TT(layer)` - Layer Tap-Toggle. If you hold the key down, the layer becomes active, and then deactivates when you let go. And if you tap it, the layer simply becomes active (toggles on). It needs 5 taps by default, but you can set it by defining `TAPPING_TOGGLE`, for example, `#define TAPPING_TOGGLE 2` for just two taps.
-## Working With Layers
+# Working With Layers
 Care must be taken when switching layers, it's possible to lock yourself into a layer with no way to deactivate that layer (without unplugging your keyboard.) We've created some guidelines to help users avoid the most common problems.
@ -47,7 +49,7 @@ Once you have a good feel for how layers work and what you can do, you can get m
 Layers stack on top of each other in numerical order. When determining what a keypress does, QMK scans the layers from the top down, stopping when it reaches the first active layer that is not set to `KC_TRNS`. As a result if you activate a layer that is numerically lower than your current layer, and your current layer (or another layer that is active and higher than your target layer) has something other than `KC_TRNS`, that is the key that will be sent, not the key on the layer you just activated. This is the cause of most people's "why doesn't my layer get switched" problem.
-## Modifier keys
+# Modifier keys
 These functions allow you to combine a mod with a keycode. When pressed the keydown for the mod will be sent first, and then *kc* will be sent. When released the keyup for *kc* will be sent and then the mod will be sent.
@ -67,7 +69,7 @@ You can also chain these, like this:
    LALT(LCTL(KC_DEL)) -- this makes a key that sends Alt, Control, and Delete in a single keypress.
-## Shifted Keycodes
+# Shifted Keycodes
 The following shortcuts automatically add `LSFT()` to keycodes to get commonly used symbols.
@ -95,7 +97,7 @@ The following shortcuts automatically add `LSFT()` to keycodes to get commonly u
 | KC_PIPE | &#x7C; |
 | KC_COLN | : |
-## Mod Tap
+# Mod Tap
 `MT(mod, kc)` - is *mod* (modifier key - MOD_LCTL, MOD_LSFT) when held, and *kc* when tapped. In other words, you can have a key that sends Esc (or the letter O or whatever) when you tap it, but works as a Control key or a Shift key when you hold it down.
@ -125,7 +127,7 @@ We've added shortcuts to make common modifier/tap (mod-tap) mappings more compac
  * `LCAG_T(kc)` - is CtrlAltGui when held and *kc* when tapped
  * `MEH_T(kc)` - is like Hyper, but not as cool -- does not include the Cmd/Win key, so just sends Alt+Ctrl+Shift.
-## One Shot Keys
+# One Shot Keys
 One shot keys are keys that remain active until the next key is pressed, and then are releasd. This allows you to type keyboard combinations without pressing more than one key at a time.
--- a/docs/feature_dynamic_macros.md
+++ b/docs/feature_dynamic_macros.md
--- a/docs/feature_key_lock.md
+++ b/docs/feature_key_lock.md
--- a/docs/feature_macros.md
+++ b/docs/feature_macros.md
--- a/docs/feature_mouse_keys.md
+++ b/docs/feature_mouse_keys.md
--- a/docs/feature_space_cadet.md
+++ b/docs/feature_space_cadet.md
--- a/docs/feature_tap_dance.md
+++ b/docs/feature_tap_dance.md
--- a/docs/feature_unicode.md
+++ b/docs/feature_unicode.md
--- a/docs/features.md
+++ b/docs/features.md
@ -1,105 +1,24 @@
 # QMK Features
 QMK has a staggering number of features for building your keyboard. It can take some time to understand all of them and determine which one will acheive your goal.
 ## Space Cadet Shift: The future, built in
-Steve Losh [described](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/) the Space Cadet Shift quite well. Essentially, you hit the left Shift on its own, and you get an opening parenthesis; hit the right Shift on its own, and you get the closing one. When hit with other keys, the Shift key keeps working as it always does. Yes, it's as cool as it sounds. Head on over to the [Space Cadet Shift](space_cadet_shift.md) page to read about it.
+* [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.
-## The Leader key: A new kind of modifier
+* [Backlight](feature_backlight.md) - LED lighting support for your keyboard
-
+* [Bootmagic](feature_bootmagic.md) - Adjust the behavior of your keyboard using hotkeys
-Most modifiers have to be held or toggled. But what if you had a key that indicated the start of a sequence? You could press that key and then rapidly press 1-3 more keys to trigger a macro, or enter a special layer, or anything else you might want to do. To learn more about it check out the [Leader Key](feature_leader_key.md) page.
+* [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.
-## Tap Dance: A single key can do 3, 5, or 100 different things
+* [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.
-Hit the semicolon key once, send a semicolon. Hit it twice, rapidly -- send a colon. Hit it three times, and your keyboard's LEDs do a wild dance. That's just one example of what Tap Dance can do. Read more about it on the [Tap Dance](tap_dance.md) page.
+* [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
-## Temporarily setting the default layer
+* [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 ps2 mouse directly to your keyboard.
-`DF(layer)` - sets default layer to _layer_. The default layer is the one at the "bottom" of the layer stack - the ultimate fallback layer. This currently does not persist over power loss. When you plug the keyboard back in, layer 0 will always be the default. It is theoretically possible to work around that, but that's not what `DF` does.
+* [Space Cadet](feature_space_cadet_shift.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.
-## Macro shortcuts: Send a whole string when pressing just one key
+* [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
-How would you like a single keypress to send a whole word, sentence, paragraph, or even document? Head on over to the [Macros](macros.md) page to read up on all aspects of Simple and Dynamic Macros.
+* [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.
-## Additional keycode aliases for software-implemented layouts \(Colemak, Dvorak, etc\)
+* [Userspace](feature_userspace.md) - Share code between different keymaps and keyboards
 Everything is assuming you're in Qwerty \(in software\) by default, but there is built-in support for using a Colemak or Dvorak layout by including this at the top of your keymap:
 ```
 #include <keymap_colemak.h>
 ```
 If you use Dvorak, use `keymap_dvorak.h` instead of `keymap_colemak.h` for this line. After including this line, you will get access to:
 * `CM_*` for all of the Colemak-equivalent characters
 * `DV_*` for all of the Dvorak-equivalent characters
 These implementations assume you're using Colemak or Dvorak on your OS, not on your keyboard - this is referred to as a software-implemented layout. If your computer is in Qwerty and your keymap is in Colemak or Dvorak, this is referred to as a firmware-implemented layout, and you won't need these features.
 To give an example, if you're using software-implemented Colemak, and want to get an `F`, you would use `CM_F`. Using `KC_F` under these same circumstances would result in `T`.
 ## Backlight Breathing
 In order to enable backlight breathing, the following line must be added to your config.h file.
 ```
 #define BACKLIGHT_BREATHING
 ```
 The following function calls are used to control the breathing effect.
 * `breathing_enable()` - Enable the free-running breathing effect.
 * `breathing_disable()` - Disable the free-running breathing effect immediately.
 * `breathing_self_disable()` - Disable the free-running breathing effect after the current effect ends.
 * `breathing_toggle()` - Toggle the free-running breathing effect.
 * `breathing_defaults()` - Reset the speed and brightness settings of the breathing effect.
 The following function calls are used to control the maximum brightness of the breathing effect.
 * `breathing_intensity_set(value)` - Set the brightness of the breathing effect when it is at its max value.
 * `breathing_intensity_default()` - Reset the brightness of the breathing effect to the default value based on the current backlight intensity.
 The following function calls are used to control the cycling speed of the breathing effect.
 * `breathing_speed_set(value)` - Set the speed of the breathing effect - how fast it cycles.
 * `breathing_speed_inc(value)` - Increase the speed of the breathing effect by a fixed value.
 * `breathing_speed_dec(value)` - Decrease the speed of the breathing effect by a fixed value.
 * `breathing_speed_default()` - Reset the speed of the breathing effect to the default value.
 The following example shows how to enable the backlight breathing effect when the FUNCTION layer macro button is pressed:
 ```
 case MACRO_FUNCTION:
    if (record->event.pressed)
    {
        breathing_speed_set(3);
        breathing_enable();
        layer_on(LAYER_FUNCTION);
    }
    else
    {
        breathing_speed_set(1);
        breathing_self_disable();
        layer_off(LAYER_FUNCTION);
    }
    break;
 ```
 The following example shows how to pulse the backlight on-off-on when the RAISED layer macro button is pressed:
 ```
 case MACRO_RAISED:
  if (record->event.pressed)
  {
    layer_on(LAYER_RAISED);
    breathing_speed_set(2);
    breathing_pulse();
    update_tri_layer(LAYER_LOWER, LAYER_RAISED, LAYER_ADJUST);
  }
  else
  {
    layer_off(LAYER_RAISED);
    update_tri_layer(LAYER_LOWER, LAYER_RAISED, LAYER_ADJUST);
  }
  break;
 ```
--- a/docs/getting_started_make_guide.md
+++ b/docs/getting_started_make_guide.md
@ -131,7 +131,7 @@ This consumes about 5390 bytes.
 `KEY_LOCK_ENABLE`
-This enables [key lock](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
--- a/docs/glossary.md
+++ b/docs/glossary.md
@ -36,7 +36,7 @@ An alternative keyboard layout developed by Dr. August Dvorak in the 1930's. A s
 ## Dynamic Macro
 A macro which has been recorded on the keyboard and which will be lost when the keyboard is unplugged or the computer rebooted.
-* [Dynamic Macro Documentation](dynamic_macros.html)
+* [Dynamic Macro Documentation](feature_dynamic_macros.md)
 ## Eclipse
 An IDE that is popular with many C developers.
@ -93,7 +93,7 @@ A wiring pattern of columns and rows that enables the MCU to detect keypresses w
 ## Macro
 A feature that lets you send muiltple keypress events (hid reports) after having pressed only a single key.
-* [Macro Documentation](macros.html)
+* [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](mouse_keys.html)
+* [Mousekeys Documentation](feature_mouse_keys.html)
 ## N-Key Rollover (NKRO)
 A term that applies to keyboards that are capable of reporting any number of key-presses at once.
@ -133,7 +133,7 @@ A 1 byte number that is sent as part of a HID report over USB that represents a
 ## Space Cadet Shift
 A special set of shift keys which allow you to type various types of braces by tapping the left or right shift one or more times.
-* [Space Cadet Shift Documentation](space_cadet_shift.html)
+* [Space Cadet Shift Documentation](feature_space_cadet.html)
 ## Tap
 Pressing and releasing a key. In some situations you will need to distinguish between a key down and a key up event, and Tap always refers to both at once.
@ -141,7 +141,7 @@ Pressing and releasing a key. In some situations you will need to distinguish be
 ## Tap Dance
 A feature that lets you assign muiltple keycodes to the same key based on how many times you press it.
-* [Tap Dance Documentation](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 dollors more due to its halfkay bootloader, which makes flashing very simple.
@ -152,7 +152,7 @@ A generic term for LEDs that light the underside of the board. These LED's typic
 ## Unicode
 In the larger computer world Unicode is a set of encoding schemes for representing characters in any language. As it relates to QMK it means using various OS schemes to send unicode codepoints instead of scancodes.
-* [Unicode Documentation](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.
--- a/docs/hardware.md
+++ b/docs/hardware.md
@ -0,0 +1,8 @@
 # Hardware
 QMK runs on a variety of hardware. If your processor can be targetted by [LUFA](http://www.fourwalledcubicle.com/LUFA.php) or [ChibiOS](http://www.chibios.com) you can probably get QMK running on it. This section explores getting QMK running on, and communicating with, hardware of all kinds.
 * [Keyboard Guidelines](hardware_keyboard_guidelines.md)
 * [AVR Processors](hardware_avr.md)
 * ARM Processors (TBD)
 * [Drivers](hardware_drivers.md)
--- a/docs/hardware_avr.md
+++ b/docs/hardware_avr.md
@ -0,0 +1,157 @@
 # Keyboards With AVR Processors
 This page describes the support for for AVR processors in QMK. AVR processors include the atmega32u4, atmega32u2, at90usb1286, and other processors from Atmel Corporation. AVR processors are 8-bit MCU's that are designed to be easy to work with. The most common AVR processors in keyboards have on-board USB and plenty of GPIO for supporting large keyboard matrices. They are the most popular MCU for use in keyboards today.
 If you have not yet you should read the [Keyboard Guidelines](hardware_keyboard_guidelines.md) to get a sense of how keyboards fit into QMK.
 ## Adding Your AVR Keyboard to QMK
 QMK has a number of features to simplify working with AVR keyboards. For most keyboards you don't have to write a single line of code. To get started run the `util/new_project.sh` script:
 ```
 $ util/new_project.sh my_awesome_keyboard
 ######################################################
 # /keyboards/my_awesome_keyboard project created. To start
 # working on things, cd into keyboards/my_awesome_keyboard
 ######################################################
 ```
 This will create all the files needed to support your new keyboard, and populate the settings with default values. Now you just need to customize it for your keyboard.
 ## `readme.md`
 This is where you'll describe your keyboard. Please follow the [Keyboard Readme Template](documentation_templates.md#keyboard-readmemd-template) when writing your `readme.md`. You're encouraged to place an image at the top of your `readme.md`, please use an external service such as [Imgur](http://imgur.com) to host the images.
 ## `<keyboard>.c`
 This is where all the custom logic for your keyboard goes. Many keyboards do not need to put anything at all in here. You can learn more about writing custom logic in [Custom Quantum Functions](custom_quantum_functions.md).
 ## `<keyboard>.h`
 This is the file you define your [Layout Macro(s)](feature_layouts.md) in. At minumum you should have a `#define LAYOUT` for your keyboard that looks something like this:
 ```
 #define LAYOUT(          \
      k00, k01, k02,     \
      k10,   k11         \
 ) {                      \
    { k00, k01,   k02 }, \
    { k10, KC_NO, k11 }, \
 }
 ```
 The first half of the `LAYOUT` pre-processor macro defines the physical arrangement of keys. The second half of the macro defines the matrix the switches are connected to. This allows you to have a physical arrangement of keys that differs from the wiring matrix.
 Each of the `k__` variables needs to be unique, and typically they follow the format `k<row><col>`.
 The physical matrix (the second half) must have a number of rows equalling `MATRIX_ROWS`, and each row must have exactly `MATRIX_COLS` elements in it. If you do not have this many physical keys you can use `KC_NO` to fill in the blank spots.
 ## `config.h`
 The `config.h` file is where you configure the hardware and feature set for your keyboard. There are a lot of options that can be placed in that file, too many to list there. For a complete overview of available options see the [Config Options](config_options.md) page.
 ### Hardware Configuration
 At the top of the `config.h` you'll find USB related settings. These control how your keyboard appears to the Operating System. If you don't have a good reason to change you should leave the `VENDOR_ID` as `0xFEED`. For the `PRODUCT_ID` you should pick a number that is not yet in use.
 Do change the `MANUFACTURER`, `PRODUCT`, and `DESCRIPTION` lines to accurately reflect your keyboard.
 ```
 #define VENDOR_ID       0xFEED
 #define PRODUCT_ID      0x6060
 #define DEVICE_VER      0x0001
 #define MANUFACTURER    You
 #define PRODUCT         my_awesome_keyboard
 #define DESCRIPTION     A custom keyboard
 ```
 {% hint style='info' %}
 Note: On Windows and macOS the `MANUFACTURER`, `PRODUCT`, and `DESCRIPTION` fields will be displayed in the list of USB devices. On Linux these values will not be visible in `lsusb`, since Linux takes that information from the list published by the USB-IF.
 {% endhint %}
 ### Keyboard Matrix Configuration
 The next section of the `config.h` file deals with your keyboard's matrix. The first thing you should set is the matrix's size. This is usually, but not always, the same number of rows and columns as the physical key arrangement.
 ```
 #define MATRIX_ROWS 2
 #define MATRIX_COLS 3
 ```
 Once you've defined the size of your matrix you need to define which pins on your MCU are connected to rows and columns. To do so simply specify the names of those pins:
 ```
 #define MATRIX_ROW_PINS { D0, D5 }
 #define MATRIX_COL_PINS { F1, F0, B0 }
 #define UNUSED_PINS
 ```
 The number of `MATRIX_ROW_PINS` entries must be the same as the number you assigned to `MATRIX_ROWS`, and likewise for `MATRIX_COL_PINS` and `MATRIX_COLS`. You do not have to specify `UNUSED_PINS`, but you can if you want to document what pins are open.
 Finally, you can specify the direction your diodes point. This can be `COL2ROW`, `ROW2COL`, or `CUSTOM_MATRIX`.
 ```
 #define DIODE_DIRECTION COL2ROW
 ```
 ### Backlight Configuration
 By default QMK supports backlighting on pins `B5`, `B6`, and `B7`. If you are using one of those you can simply enable it here. For more details see the [Backlight Documentation](feature_backlight.md).
 ```
 #define BACKLIGHT_PIN B7
 #define BACKLIGHT_BREATHING
 #define BACKLIGHT_LEVELS 3
 ```
 {% hint style='info' %}
 You can use backlighting on any pin you like, but you will have to do more work to support that. See the [Backlight Documentation](feature_backlight.md) for more details.
 {% endhint %}
 ### Other Configuration Options
 There are a lot of features that can be configured or tuned in `config.h`. You should see the [Config Options](config_options.md) page for more details.
 ## `rules.mk`
 You use the `rules.mk` file to tell QMK what files to build and what features to enable. If you are building around an atmega32u4 you can largely leave these defaults alone. If you are using another MCU you may have to tweak some parameters.
 ### MCU Options
 These options tell the build system what CPU to build for. Be very careful if you change any of these settings, you can render your keyboard inoperable.
 ```
 MCU = atmega32u4
 F_CPU = 16000000
 ARCH = AVR8
 F_USB = $(F_CPU)
 OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
 ```
 ### Bootloader Size
 The bootloader is a special section of your MCU that allows you to upgrade the code stored on the MCU. Think of it like a Rescue Partition for your keyboard. If you are using a teensy 2.0, or a device like the Ergodox EZ that uses the teensy bootloader you should set this to `512`. Most other bootloaders should be set to `4096`, but `1024` and `2048` are other possible values you may encounter.
 #### Teensy 2.0 Bootloader Example
 ```
 OPT_DEFS += -DBOOTLOADER_SIZE=512
 ```
 #### Teensy 2.0++ Bootloader Example
 ```
 OPT_DEFS += -DBOOTLOADER_SIZE=1024
 ```
 #### Atmel DFU Loader Example
 ```
 OPT_DEFS += -DBOOTLOADER_SIZE=4096
 ```
 ### Build Options
 There are a number of features that can be turned on or off in `rules.mk`. See the [Config Options](config_options.md#feature-options) page for a detailed list and description.
--- a/docs/hardware_drivers.md
+++ b/docs/hardware_drivers.md
@ -0,0 +1,27 @@
 # QMK Hardware Drivers
 QMK is used on a lot of different hardware. While support for the most common MCU's and matrix configurations is built-in there are a number of drivers that can be added to a keyboard to support additional hardware. Examples include mice and other pointing devices, i/o expanders for split keyboards, bluetooth modules, and LCD, OLED, and TFT screens.
 <!-- FIXME: This should talk about how drivers are integrated into QMK and how you can add your own driver.
 # Driver System Overview
 -->
 # Available Drivers
 ## ProMicro (AVR only)
 Support for addressing pins on the ProMicro by their Arduino name rather than their AVR name. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 ## SSD1306 (AVR only)
 Support for SSD1306 based OLED displays. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 ## uGFX
 You can make use of uGFX within QMK to drive character and graphic LCD's, LED arrays, OLED, TFT, and other display technologies. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 ## WS2812 (AVR only)
 Support for WS2811/WS2812{a,b,c} LED's. For more information see the [RGB Light](feature_rgblight.md) page.
--- a/docs/hardware_keyboard_guidelines.md
+++ b/docs/hardware_keyboard_guidelines.md
@ -1,35 +1,49 @@
-# Adding your keyboard to QMK
+# QMK Keyboard Guidelines
 We welcome all keyboard projects into QMK, but ask that you try to stick to a couple guidelines that help us keep things organised and consistent.
-## Naming your directory/project
+## Naming your keyboard/project
-All names should be lowercase alphanumeric, and separated by an underscore (`_`), but not begin with one. Your directory and your `.h` and `.c` files should have exactly the same name. All folders should follow the same format. 
+All names should be lowercase alphanumeric, and separated by an underscore (`_`), but not begin with one. Your directory and your `.h` and `.c` files should have exactly the same name. All folders should follow the same format.
 ## `readme.md`
-All projects need to have a `readme.md` file that explains what the keyboard is, who made it, where it is available, and links to move information (template coming).
+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
-In an effort to keep the repo size down, we're no longer accepting images of any format in the repo, with few exceptions. Hosting them elsewhere (imgur) and linking them in the readme.md is the preferred method.
+In an effort to keep the repo size down, we're no longer accepting images of any format in the repo, with few exceptions. Hosting them elsewhere (imgur) and linking them in the `readme.md` is the preferred method.
-Any sort of hardware file (plate, case, pcb) can't be stored in qmk_firmware, but we have the [qmk.fm repo](https://github.com/qmk/qmk.fm) where such files (as well as in-depth info) can be store, and viewed on [qmk.fm](http://qmk.fm). Downloadable files are stored in `/<keyboard>/` (name follows the same format as above) which are served at `http://qmk.fm/<keyboard>/`, and pages are generated from `/_pages/<keyboard>/` which are served at the same location (.md files are generated into .html files through Jekyll). Check out the `lets_split` directory for an example.
+Any sort of hardware file (plate, case, pcb) can't be stored in qmk_firmware, but we have the [qmk.fm repo](https://github.com/qmk/qmk.fm) where such files (as well as in-depth info) can be stored and viewed on [qmk.fm](http://qmk.fm). Downloadable files are stored in `/<keyboard>/` (name follows the same format as above) which are served at `http://qmk.fm/<keyboard>/`, and pages are generated from `/_pages/<keyboard>/` which are served at the same location (.md files are generated into .html files through Jekyll). Check out the `lets_split` directory for an example.
 ## Non-production/handwired projects
-We're happy to accept any project that uses QMK, including prototypes and handwired ones, but we have a separate `/keyboards/handwired/` folder for them, so the main `/keyboards/` folder doesn't get overcrowded. If a prototype project becomes a production project at some point in the future, we'd be happy to move it to the main `/keyboards/` folder! 
+We're happy to accept any project that uses QMK, including prototypes and handwired ones, but we have a separate `/keyboards/handwired/` folder for them, so the main `/keyboards/` folder doesn't get overcrowded. If a prototype project becomes a production project at some point in the future, we'd be happy to move it to the main `/keyboards/` folder!
 ## Warnings as errors
 When developing your keyboard, keep in mind that all warnings will be treated as errors - these small warnings can build-up and cause larger errors down the road (and keeping them is generally a bad practice).
-## Licenses
+## Copyright Blurb
 If you're adapting your keyboard's setup from another project, but not using the same code, but sure to update the copyright header at the top of the files to show your name, in this format:
    Copyright 2017 Your Name <your@email.com>
-    
+
 If you are modifying someone else's code and have made only trivial changes you should leave their name in the copyright statement. If you have done significant work on the file you should add your name to theirs, like so:
    Copyright 2017 Their Name <original_author@example.com> Your Name <you@example.com>
 The year should be the first year the file is created. If work was done to that file in later years you can reflect that by appending the second year to the first, like so:
    Copyright 2015-2017 Your Name <you@example.com>
 ## License
 The core of QMK is licensed under the [GNU General Public License](https://www.gnu.org/licenses/licenses.en.html). If you are shipping binaries for AVR processors you may choose either [GPLv2](https://www.gnu.org/licenses/old-licenses/gpl-2.0.html) or [GPLv3](https://www.gnu.org/licenses/gpl.html). If you are shipping binaries for ARM processors you must choose [GPL Version 3](https://www.gnu.org/licenses/gpl.html) to comply with the [ChibiOS](http://www.chibios.org) GPLv3 license.
 If your keyboard makes use of the [uGFX](https://ugfx.io) features within QMK you must comply with the [uGFX License](https://ugfx.io/license.html), which requires a separate commercial license before selling a device containing uGFX.
 ## Technical details
-If you're looking for more information on making your keyboard work with QMK, [check out this guide](porting_your_keyboard_to_qmk.md)!
+If you're looking for more information on making your keyboard work with QMK, [check out the hardware section](hardware.md)!
--- a/docs/keycodes.md
+++ b/docs/keycodes.md
@ -187,22 +187,22 @@ When defining a [keymap](keymap.md) each key needs a valid key definition. This
 |`KC_KP_EQUAL_AS400`||Keypad Equal Sign|
 |`KC_NO`||Ignore this key. (NOOP) |
 |`KC_TRNS`||Make this key transparent to find the key on a lower layer.|
-|[`KC_MS_UP`](mouse_keys.md)|`KC_MS_U`|Mouse Cursor Up|
+|[`KC_MS_UP`](feature_mouse_keys.md)|`KC_MS_U`|Mouse Cursor Up|
-|[`KC_MS_DOWN`](mouse_keys.md)|`KC_MS_D`|Mouse Cursor Down|
+|[`KC_MS_DOWN`](feature_mouse_keys.md)|`KC_MS_D`|Mouse Cursor Down|
-|[`KC_MS_LEFT`](mouse_keys.md)|`KC_MS_L`|Mouse Cursor Left|
+|[`KC_MS_LEFT`](feature_mouse_keys.md)|`KC_MS_L`|Mouse Cursor Left|
-|[`KC_MS_RIGHT`](mouse_keys.md)|`KC_MS_R`|Mouse Cursor Right|
+|[`KC_MS_RIGHT`](feature_mouse_keys.md)|`KC_MS_R`|Mouse Cursor Right|
-|[`KC_MS_BTN1`](mouse_keys.md)|`KC_BTN1`|Mouse Button 1|
+|[`KC_MS_BTN1`](feature_mouse_keys.md)|`KC_BTN1`|Mouse Button 1|
-|[`KC_MS_BTN2`](mouse_keys.md)|`KC_BTN2`|Mouse Button 2|
+|[`KC_MS_BTN2`](feature_mouse_keys.md)|`KC_BTN2`|Mouse Button 2|
-|[`KC_MS_BTN3`](mouse_keys.md)|`KC_BTN3`|Mouse Button 3|
+|[`KC_MS_BTN3`](feature_mouse_keys.md)|`KC_BTN3`|Mouse Button 3|
-|[`KC_MS_BTN4`](mouse_keys.md)|`KC_BTN4`|Mouse Button 4|
+|[`KC_MS_BTN4`](feature_mouse_keys.md)|`KC_BTN4`|Mouse Button 4|
-|[`KC_MS_BTN5`](mouse_keys.md)|`KC_BTN5`|Mouse Button 5|
+|[`KC_MS_BTN5`](feature_mouse_keys.md)|`KC_BTN5`|Mouse Button 5|
-|[`KC_MS_WH_UP`](mouse_keys.md)|`KC_WH_U`|Mouse Wheel Up|
+|[`KC_MS_WH_UP`](feature_mouse_keys.md)|`KC_WH_U`|Mouse Wheel Up|
-|[`KC_MS_WH_DOWN`](mouse_keys.md)|`KC_WH_D`|Mouse Wheel Down|
+|[`KC_MS_WH_DOWN`](feature_mouse_keys.md)|`KC_WH_D`|Mouse Wheel Down|
-|[`KC_MS_WH_LEFT`](mouse_keys.md)|`KC_WH_L`|Mouse Wheel Left|
+|[`KC_MS_WH_LEFT`](feature_mouse_keys.md)|`KC_WH_L`|Mouse Wheel Left|
-|[`KC_MS_WH_RIGHT`](mouse_keys.md)|`KC_WH_R`|Mouse Wheel Right|
+|[`KC_MS_WH_RIGHT`](feature_mouse_keys.md)|`KC_WH_R`|Mouse Wheel Right|
-|[`KC_MS_ACCEL0`](mouse_keys.md)|`KC_ACL0`|Mouse Acceleration 0|
+|[`KC_MS_ACCEL0`](feature_mouse_keys.md)|`KC_ACL0`|Mouse Acceleration 0|
-|[`KC_MS_ACCEL1`](mouse_keys.md)|`KC_ACL1`|Mouse Acceleration 1|
+|[`KC_MS_ACCEL1`](feature_mouse_keys.md)|`KC_ACL1`|Mouse Acceleration 1|
-|[`KC_MS_ACCEL2`](mouse_keys.md)|`KC_ACL2`|Mouse Acceleration 2|
+|[`KC_MS_ACCEL2`](feature_mouse_keys.md)|`KC_ACL2`|Mouse Acceleration 2|
 |[`RESET`](quantum_keycodes.md#qmk-keycodes)||Put the keyboard into DFU mode for flashing|
 |[`DEBUG`](quantum_keycodes.md#qmk-keycodes)||Toggles debug mode|
 |[`KC_GESC`](quantum_keycodes.md#qmk-keycodes)|`GRAVE_ESC`|Acts as escape when pressed normally but when pressed with Shift or GUI will send a `~`|
@ -311,5 +311,5 @@ When defining a [keymap](keymap.md) each key needs a valid key definition. This
 |[`TT(layer)`](feature_common_shortcuts.md#switching-and-toggling-layers)||tap toggle? idk FIXME`|
 |[`OSM(mod)`](quantum_keycodes.md#one-shot-keys)||hold mod for one keypress|
 |[`OSL(layer)`](quantum_keycodes.md#one-shot-keys)||switch to layer for one keypress|
-|[`UNICODE(n)`](unicode.md)|[`UC(n)`](unicode.md)|if `UNICODE_ENABLE`, this will send characters up to `0x7FFF`|
+|[`UNICODE(n)`](feature_unicode.md)|[`UC(n)`](feature_unicode.md)|if `UNICODE_ENABLE`, this will send characters up to `0x7FFF`|
-|[`X(n)`](unicode.md)||if `UNICODEMAP_ENABLE`, also sends unicode via a different method|
+|[`X(n)`](feature_unicode.md)||if `UNICODEMAP_ENABLE`, also sends unicode via a different method|
--- a/docs/porting_your_keyboard_to_qmk.md
+++ b/docs/porting_your_keyboard_to_qmk.md
@ -1,63 +0,0 @@
 # Porting your keyboard to QMK
 This page describes the technical details of porting an existing keyboard to QMK. If you're looking to add your keyboard to QMK, please [look through these guidelines](adding_a_keyboard_to_qmk.md)!
 If your keyboard is running an Atmega chip (atmega32u4 and others), it's pretty easy to get things setup for compiling your own firmware to flash onto your board. There is a `/util/new_project.sh <keyboard>` script to help get you started - you can simply pass your keyboard's name into the script, and all of the necessary files will be created. The components of each are described below.
 ## `/keyboards/<keyboard>/config.h`
 The `USB Device descriptor parameter` block contains parameters are used to uniquely identify your keyboard, but they don't really matter to the machine.
 Your `MATRIX_ROWS` and `MATRIX_COLS` are the numbers of rows and cols in your keyboard matrix - this may be different than the number of actual rows and columns on your keyboard. There are some tricks you can pull to increase the number of keys in a given matrix, but most keyboards are pretty straight-forward.
 The `MATRIX_ROW_PINS` and `MATRIX_COL_PINS` are the pins your MCU uses on each row/column. Your schematic (if you have one) will have this information on it, and the values will vary depending on your setup. This is one of the most important things to double-check in getting your keyboard setup correctly.
 For the `DIODE_DIRECTION`, most hand-wiring guides will instruct you to wire the diodes in the `COL2ROW` position, but it's possible that they are in the other - people coming from EasyAVR often use `ROW2COL`. Nothing will function if this is incorrect.
 `BACKLIGHT_PIN` is the pin that your PWM-controlled backlight (if one exists) is hooked-up to. Currently only B5, B6, and B7 are supported.
 `BACKLIGHT_BREATHING` is a fancier backlight feature that adds breathing/pulsing/fading effects to the backlight. It uses the same timer as the normal backlight. These breathing effects must be called by code in your keymap.
 `BACKLIGHT_LEVELS` is how many levels exist for your backlight - max is 15, and they are computed automatically from this number.
 ## `/keyboards/<keyboard>/rules.mk`
 The values at the top likely won't need to be changed, since most boards use the `atmega32u4` chip. The `BOOTLOADER_SIZE` will need to be adjusted based on your MCU type. It's defaulted to the Teensy, since that's the most common controller. Below is quoted from the `Makefile`.
 ```
 # Boot Section Size in *bytes*
 #   Teensy halfKay   512
 #   Teensy++ halfKay 1024
 #   Atmel DFU loader 4096
 #   LUFA bootloader  4096
 #   USBaspLoader     2048
 OPT_DEFS += -DBOOTLOADER_SIZE=512
 ```
 At the bottom of the file, you'll find lots of features to turn on and off - all of these options should be set with `?=` to allow for the keymap overrides. `?=` only assigns if the variable was previously undefined. For the full documenation of these features, see the [Makefile options](getting_started_make_guide.md#makefile-options).
 ## `/keyboards/<keyboard>/readme.md`
 This is where you'll describe your keyboard - please write as much as you can about it! Talking about default functionality/features is useful here. Feel free to link to external pages/sites if necessary. Images can be included here as well, as long as they're hosted elsewhere (imgur).
 ## `/keyboards/<keyboard>/<keyboard>.c`
 This is where all of the custom logic for your keyboard goes - you may not need to put anything in this file, since a lot of things are configured automatically. All of the `*_kb()` functions are defined here. If you modify them, remember to keep the calls to `*_user()`, or things in the keymaps might not work. You can read more about the functions [here](custom_quantum_functions.md).
 ## `/keyboards/<keyboard>/<keyboard>.h`
 Here is where you can (optionally) define your `KEYMAP` function to remap your matrix into a more readable format. With ortholinear boards, this isn't always necessary, but it can help to accomodate the dead spots on your matrix, where there are keys that take up more than one space (2u, staggering, 6.25u, etc). The example shows the difference between the physical keys, and the matrix design:
 ```
 #define KEYMAP( \
    k00, k01, k02, \
      k10,  k11   \
 ) \
 { \
    { k00, k01,   k02 }, \
    { k10, KC_NO, k11 }, \
 }
 ```
 Each of the `kxx` variables needs to be unique, and usually follows the format `k<row><col>`. You can place `KC_NO` where your dead keys are in your matrix.
--- a/docs/quantum_keycodes.md
+++ b/docs/quantum_keycodes.md
@ -16,7 +16,7 @@ On this page we have documented keycodes between `0x00FF` and `0xFFFF` which are
 |`KC_LSPO`|Left shift when held, open paranthesis when tapped|
 |`KC_RSPC`|Right shift when held, close paranthesis when tapped|
 |`KC_LEAD`|The [leader key](feature_leader_key.md)|
-|`KC_LOCK`|The [lock key](key_lock.md)|
+|`KC_LOCK`|The [lock key](feature_key_lock.md)|
 |`FUNC(n)`/`F(n)`|Call `fn_action(n)` (deprecated)|
 |`M(n)`|to call macro n|
 |`MACROTAP(n)`|to macro-tap n idk FIXME|
--- a/docs/redirects.json
+++ b/docs/redirects.json
@ -1,12 +1,44 @@
 {
    "redirects": [
            {
                "from": "adding_a_keyboard_to_qmk.html",
                "to": "hardware_keyboard_guidelines.html"
            },
            {
                "from": "build_environment_setup.html",
                "to": "getting_started_build_tools.html"
            },
            {
                "from": "dynamic_macros.html",
                "to": "feature_dynamic_macros.html"
            },
            {
                "from": "feature_common_shortcuts.html",
                "to": "feature_advanced_keycodes.html"
            },
            {
                "from": "key_lock.html",
                "to": "feature_key_lock.html"
            },
            {
                "from": "make_instructions.html",
                "to": "getting_started_make_guide.html"
            },
            {
                "from": "porting_your_keyboard_to_qmk.html",
                "to": "hardware_avr.html"
            },
            {
                "from": "space_cadet_shift.html",
                "to": "feature_space_cadet.html"
            },
            {
                "from": "tap_dance.html",
                "to": "feature_tap_dance.html"
            },
            {
                "from": "unicode.html",
                "to": "feature_unicode.html"
            }
        ]
-}
+}
`@ -144,4 +144,4 @@ To maintain a clear vision of how things are laid out in QMK we try to plan out`

	`# What does the Code of Conduct mean for me?`	`# What does the Code of Conduct mean for me?`

	`Our Code of Conduct means that you are responsible for treating everyone on the project with respect and courtesy regardless of their identity. If you are the victim of any inappropriate behavior or comments as described in our Code of Conduct, we are here for you and will do the best to ensure that the abuser is reprimanded appropriately, per our code.`	`Our [Code of Conduct](https://github.com/qmk/qmk_firmware/blob/master/CODE_OF_CONDUCT.md) means that you are responsible for treating everyone on the project with respect and courtesy regardless of their identity. If you are the victim of any inappropriate behavior or comments as described in our Code of Conduct, we are here for you and will do the best to ensure that the abuser is reprimanded appropriately, per our code.`