19 files changed, 590 insertions, 129 deletions
diff --git a/docs/_summary.md b/docs/_summary.md
index c467a7231..6bc747189 100644
--- a/docs/_summary.md
+++ b/docs/_summary.md
@@ -40,6 +40,7 @@
  * [Unit Testing](unit_testing.md)
  * [Useful Functions](ref_functions.md)
  * [Configurator Support](reference_configurator_support.md)
+  * [info.json Format](reference_info_json.md)
 * [Features](features.md)
  * [Basic Keycodes](keycodes_basic.md)
diff --git a/docs/config_options.md b/docs/config_options.md
index f5c2e76e7..5e2de6d04 100644
--- a/docs/config_options.md
+++ b/docs/config_options.md
@@ -87,7 +87,7 @@ This is a C header file that is one of the first things included, and will persi
  * 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)) )`
+* `#define IS_COMMAND() (get_mods() == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))`
  * key combination that allows the use of magic commands (useful for debugging)
 * `#define USB_MAX_POWER_CONSUMPTION`
  * sets the maximum power (in mA) over USB for the device (default: 500)
diff --git a/docs/custom_quantum_functions.md b/docs/custom_quantum_functions.md
index d44786e2d..cc84e141f 100644
--- a/docs/custom_quantum_functions.md
+++ b/docs/custom_quantum_functions.md
@@ -165,18 +165,35 @@ In addition, it is possible to specify the brightness level of all LEDs with `er
 Ergodox boards also define `LED_BRIGHTNESS_LO` for the lowest brightness and `LED_BRIGHTNESS_HI` for the highest brightness (which is the default).
-# Matrix Initialization Code
+# Keyboard Initialization Code
-Before a keyboard can be used the hardware must be initialized. QMK handles initialization of the keyboard matrix itself, but if you have other hardware like LEDs or i&#xb2;c controllers you will need to set up that hardware before it can be used.
+There are several steps in the keyboard initialization process.  Depending on what you want to do, it will influence which function you should use.
+These are the three main initialization functions, listed in the order that they're called.
-### Example `matrix_init_user()` Implementation
+* `keyboard_pre_init_*` - Happens before most anything is started. Good for hardware setup that you want running very early.
+* `matrix_init_*` - Happens midway through the firmware's startup process. Hardware is initialized, but features may not be yet.
+* `keyboard_post_init_*` - Happens at the end of the firmware's startup process. This is where you'd want to put "customization" code, for the most part.
+!> For most people, the `keyboard_post_init_user` function is what you want to call.  For instance, this is where you want to set up things for RGB Underglow.
+## Keyboard Pre Initialization code
+This runs very early during startup, even before the USB has been started. 
+Shortly after this, the matrix is initialized.
+For most users, this shouldn't be used, as it's primarily for hardware oriented initialization. 
+However, if you have hardware stuff that you need initialized, this is the best place for it (such as initializing LED pins).
+### Example `keyboard_pre_init_user()` Implementation
 This example, at the keyboard level, sets up B1, B2, and B3 as LED pins.
 ```c
-void matrix_init_user(void) {
+void keyboard_pre_init_user(void) {
-  // Call the keymap level matrix init.
+  // Call the keyboard pre init code.
  // Set our LED pins as output
  DDRB |= (1<<1);
@@ -185,11 +202,47 @@ void matrix_init_user(void) {
 }
 ```
+### `keyboard_pre_init_*` Function Documentation
+* Keyboard/Revision: `void keyboard_pre_init_kb(void)`
+* Keymap: `void keyboard_pre_init_user(void)`
+## Matrix Initialization Code
+This is called when the matrix is initialized, and after some of the hardware has been set up, but before many of the features have been initialized. 
+This is useful for setting up stuff that you may need elsewhere, but isn't hardware related nor is dependant on where it's started. 
 ### `matrix_init_*` Function Documentation
 * Keyboard/Revision: `void matrix_init_kb(void)`
 * Keymap: `void matrix_init_user(void)`
+## Keyboard Post Initialization code
+This is ran as the very last task in the keyboard initialization process. This is useful if you want to make changes to certain features, as they should be initialized by this point.
+### Example `keyboard_post_init_user()` Implementation
+This example, running after everything else has initialized, sets up the rgb underglow configuration.
+```c
+void keyboard_post_init_user(void) {
+  // Call the post init code.
+  rgblight_enable_noeeprom(); // enables Rgb, without saving settings
+  rgblight_sethsv_noeeprom(180, 255, 255): // sets the color to teal/cyan without saving
+  rgblight_mode_noeeprom(RGBLIGHT_MODE_BREATHING + 3); // sets mode to Fast breathing without saving
+}
+```
+### `keyboard_post_init_*` Function Documentation
+* Keyboard/Revision: `void keyboard_post_init_kb(void)`
+* Keymap: `void keyboard_post_init_user(void)`
 # Matrix Scanning Code
 Whenever possible you should customize your keyboard by using `process_record_*()` and hooking into events that way, to ensure that your code does not have a negative performance impact on your keyboard. However, in rare cases it is necessary to hook into the matrix scanning. Be extremely careful with the performance of code in these functions, as it will be called at least 10 times per second.
@@ -229,10 +282,9 @@ void suspend_wakeup_init_user(void)
 {
    rgb_matrix_set_suspend_state(false);
 }
 ```
-### `keyboard_init_*` Function Documentation
+### Keyboard suspend/wake  Function Documentation
 * Keyboard/Revision: `void suspend_power_down_kb(void)` and `void suspend_wakeup_init_user(void)`
 * Keymap: `void suspend_power_down_kb(void)` and `void suspend_wakeup_init_user(void)`
@@ -285,7 +337,7 @@ Keep in mind that EEPROM has a limited number of writes. While this is very high
 * If you don't understand the example, then you may want to avoid using this feature, as it is rather complicated. 
-### Example  Implementation
+### Example Implementation
 This is an example of how to add settings, and read and write it. We're using the user keymap for the example here.  This is a complex function, and has a lot going on.  In fact, it uses a lot of the above functions to work! 
diff --git a/docs/faq_build.md b/docs/faq_build.md
index 14c61a1e9..d920d27e2 100644
--- a/docs/faq_build.md
+++ b/docs/faq_build.md
@@ -37,6 +37,10 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2ff0", MODE:="066
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
 ```
+### Serial device is not detected in bootloader mode on Linux
+Make sure your kernel has appropriate support for your device. If your device uses USB ACM, such as 
+Pro Micro (Atmega32u4), make sure to include `CONFIG_USB_ACM=y`. Other devices may require `USB_SERIAL` and any of its sub options.
 ## Unknown Device for DFU Bootloader
 If you're using Windows to flash your keyboard, and you are running into issues, check the Device Manager.  If you see an "Unknown Device" when the keyboard is in "bootloader mode", then you may have a driver issue. 
diff --git a/docs/feature_advanced_keycodes.md b/docs/feature_advanced_keycodes.md
index 37a3d43fc..95c47355c 100644
--- a/docs/feature_advanced_keycodes.md
+++ b/docs/feature_advanced_keycodes.md
@@ -21,7 +21,7 @@ Additionally, if at least one right-handed modifier is specified in a Mod Tap or
 # 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](keymap.md#keymap-and-layers) When using momentary layer switching with MO(), LM(), TT(), or LT(), make sure to leave the key on the above layers transparent or it may not work as intended.
+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). When using momentary layer switching with MO(), LM(), TT(), or LT(), make sure to leave the key on the above layers transparent or it may not work as intended.
 * `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. 
@@ -161,6 +161,81 @@ For one shot mods, you need to call `set_oneshot_mods(MOD)` to set it, or `clear
 !> If you're having issues with OSM translating over Remote Desktop Connection, this can be fixed by opening the settings, going to the "Local Resources" tap, and in the keyboard section, change the drop down to "On this Computer".  This will fix the issue and allow OSM to function properly over Remote Desktop.
+## Callbacks
+When you'd like to perform custom logic when pressing a one shot key, there are several callbacks you can choose to implement. You could indicate changes in one shot keys by flashing an LED or making a sound, for example.
+There is a callback for `OSM(mod)`. It is called whenever the state of any one shot modifier key is changed: when it toggles on, but also when it is toggled off. You can use it like this:
+```c
+void oneshot_mods_changed_user(uint8_t mods) {
+  if (mods & MOD_MASK_SHIFT) {
+    println("Oneshot mods SHIFT");
+  }
+  if (mods & MOD_MASK_CTRL) {
+    println("Oneshot mods CTRL");
+  }
+  if (mods & MOD_MASK_ALT) {
+    println("Oneshot mods ALT");
+  }
+  if (mods & MOD_MASK_GUI) {
+    println("Oneshot mods GUI");
+  }
+  if (!mods) {
+    println("Oneshot mods off");
+  }
+}
+```
+The `mods` argument contains the active mods after the change, so it reflects the current state.
+When you use One Shot Tap Toggle (by adding `#define ONESHOT_TAP_TOGGLE 2` in your `config.h` file), you may lock a modifier key by pressing it the specified amount of times. There's a callback for that, too:
+```c
+void oneshot_locked_mods_changed_user(uint8_t mods) {
+  if (mods & MOD_MASK_SHIFT) {
+    println("Oneshot locked mods SHIFT");
+  }
+  if (mods & MOD_MASK_CTRL) {
+    println("Oneshot locked mods CTRL");
+  }
+  if (mods & MOD_MASK_ALT) {
+    println("Oneshot locked mods ALT");
+  }
+  if (mods & MOD_MASK_GUI) {
+    println("Oneshot locked mods GUI");
+  }
+  if (!mods) {
+    println("Oneshot locked mods off");
+  }
+}
+```
+Last, there is also a callback for the `OSL(layer)` one shot key:
+```c
+void oneshot_layer_changed_user(uint8_t layer) {
+  if (layer == 1) {
+    println("Oneshot layer 1 on");
+  }
+  if (!layer) {
+    println("Oneshot layer off");
+  }
+}
+```
+If any one shot layer is switched off, `layer` will be zero. When you're looking to do something on any layer change instead of one shot layer changes, `layer_state_set_user` is a better callback to use.
+If you are making your own keyboard, there are also `_kb` equivalent functions:
+```c
+void oneshot_locked_mods_changed_kb(uint8_t mods);
+void oneshot_mods_changed_kb(uint8_t mods);
+void oneshot_layer_changed_kb(uint8_t layer);
+```
+As with any callback, be sure to call the `_user` variant to allow for further customizability.
 # Tap-Hold Configuration Options
 While Tap-Hold options are fantastic, they are not without their issues.  We have tried to configure them with reasonal defaults, but that may still cause issues for some people. 
diff --git a/docs/feature_backlight.md b/docs/feature_backlight.md
index f7a35406c..c7a1f131e 100644
--- a/docs/feature_backlight.md
+++ b/docs/feature_backlight.md
@@ -40,6 +40,7 @@ To change the behaviour of the backlighting, `#define` these in your `config.h`:
 |---------------------|-------------|-------------------------------------------------------------------------------------------------------------|
 |`BACKLIGHT_PIN`      |`B7`         |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this|
 |`BACKLIGHT_LEVELS`   |`3`          |The number of brightness levels (maximum 15 excluding off)                                                   |
+|`BACKLIGHT_CAPS_LOCK`|*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED)                             |
 |`BACKLIGHT_BREATHING`|*Not defined*|Enable backlight breathing, if hardware PWM is used                                                          |
 |`BREATHING_PERIOD`   |`6`          |The length of one backlight "breath" in seconds                                                              |
diff --git a/docs/feature_bootmagic.md b/docs/feature_bootmagic.md
index 504fb90f4..39e4e47f4 100644
--- a/docs/feature_bootmagic.md
+++ b/docs/feature_bootmagic.md
@@ -127,7 +127,9 @@ Additionally, you may want to specify which key to use.  This is especially usef
 By default, these are set to 0 and 0, which is usually the "ESC" key on a majority of keyboards.
-And to trigger the bootloader, you hold this key down when plugging the keyboard in. Just the single key. 
+And to trigger the bootloader, you hold this key down when plugging the keyboard in. Just the single key.
+!> Using bootmagic lite will **always reset** the EEPROM, so you will lose any settings that have been saved.
 ## Advanced Bootmagic Lite
diff --git a/docs/feature_combo.md b/docs/feature_combo.md
index 05ffc0d72..a2fd1423c 100644
--- a/docs/feature_combo.md
+++ b/docs/feature_combo.md
@@ -29,7 +29,7 @@ If you want to add a list, then you'd use something like this:
 enum combos {
  AB_ESC,
  JK_TAB
-}
+};
 const uint16_t PROGMEM ab_combo[] = {KC_A, KC_B, COMBO_END};
 const uint16_t PROGMEM jk_combo[] = {KC_J, KC_K, COMBO_END};
diff --git a/docs/feature_command.md b/docs/feature_command.md
index ca2ecce0d..53a140a11 100644
--- a/docs/feature_command.md
+++ b/docs/feature_command.md
@@ -16,35 +16,35 @@ To use Command, hold down the key combination defined by the `IS_COMMAND()` macr
 If you would like to change the key assignments for Command, `#define` these in your `config.h` at either the keyboard or keymap level. All keycode assignments here must omit the `KC_` prefix.
-|Define                              |Default                                                                               |Description                                     |
+|Define                              |Default                                                                    |Description                                     |
-|------------------------------------|--------------------------------------------------------------------------------------|------------------------------------------------|
+|------------------------------------|---------------------------------------------------------------------------|------------------------------------------------|
-|`IS_COMMAND()`                      |<code>(keyboard_report->mods == (MOD_BIT(KC_LSHIFT) &#124; MOD_BIT(KC_RSHIFT)))</code>|The key combination to activate Command         |
+|`IS_COMMAND()`                      |<code>(get_mods() == (MOD_BIT(KC_LSHIFT) &#124; MOD_BIT(KC_RSHIFT)))</code>|The key combination to activate Command         |
-|`MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS` |`true`                                                                                |Set default layer with the Function row         |
+|`MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS` |`true`                                                                     |Set default layer with the Function row         |
-|`MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS` |`true`                                                                                |Set default layer with the number keys          |
+|`MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS` |`true`                                                                     |Set default layer with the number keys          |
-|`MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM`|`false`                                                                               |Set default layer with `MAGIC_KEY_LAYER0..9`    |
+|`MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM`|`false`                                                                    |Set default layer with `MAGIC_KEY_LAYER0..9`    |
-|`MAGIC_KEY_DEBUG`                   |`D`                                                                                   |Toggle debugging over serial                    |
+|`MAGIC_KEY_DEBUG`                   |`D`                                                                        |Toggle debugging over serial                    |
-|`MAGIC_KEY_DEBUG_MATRIX`            |`X`                                                                                   |Toggle key matrix debugging                     |
+|`MAGIC_KEY_DEBUG_MATRIX`            |`X`                                                                        |Toggle key matrix debugging                     |
-|`MAGIC_KEY_DEBUG_KBD`               |`K`                                                                                   |Toggle keyboard debugging                       |
+|`MAGIC_KEY_DEBUG_KBD`               |`K`                                                                        |Toggle keyboard debugging                       |
-|`MAGIC_KEY_DEBUG_MOUSE`             |`M`                                                                                   |Toggle mouse debugging                          |
+|`MAGIC_KEY_DEBUG_MOUSE`             |`M`                                                                        |Toggle mouse debugging                          |
-|`MAGIC_KEY_CONSOLE`                 |`C`                                                                                   |Enable the Command console                      |
+|`MAGIC_KEY_CONSOLE`                 |`C`                                                                        |Enable the Command console                      |
-|`MAGIC_KEY_VERSION`                 |`V`                                                                                   |Print the running QMK version to the console    |
+|`MAGIC_KEY_VERSION`                 |`V`                                                                        |Print the running QMK version to the console    |
-|`MAGIC_KEY_STATUS`                  |`S`                                                                                   |Print the current keyboard status to the console|
+|`MAGIC_KEY_STATUS`                  |`S`                                                                        |Print the current keyboard status to the console|
-|`MAGIC_KEY_HELP1`                   |`H`                                                                                   |Print Command help to the console               |
+|`MAGIC_KEY_HELP1`                   |`H`                                                                        |Print Command help to the console               |
-|`MAGIC_KEY_HELP2`                   |`SLASH`                                                                               |Print Command help to the console (alternate)   |
+|`MAGIC_KEY_HELP2`                   |`SLASH`                                                                    |Print Command help to the console (alternate)   |
-|`MAGIC_KEY_LAYER0`                  |`0`                                                                                   |Make layer 0 the default layer                  |
+|`MAGIC_KEY_LAYER0`                  |`0`                                                                        |Make layer 0 the default layer                  |
-|`MAGIC_KEY_LAYER1`                  |`1`                                                                                   |Make layer 1 the default layer                  |
+|`MAGIC_KEY_LAYER1`                  |`1`                                                                        |Make layer 1 the default layer                  |
-|`MAGIC_KEY_LAYER2`                  |`2`                                                                                   |Make layer 2 the default layer                  |
+|`MAGIC_KEY_LAYER2`                  |`2`                                                                        |Make layer 2 the default layer                  |
-|`MAGIC_KEY_LAYER3`                  |`3`                                                                                   |Make layer 3 the default layer                  |
+|`MAGIC_KEY_LAYER3`                  |`3`                                                                        |Make layer 3 the default layer                  |
-|`MAGIC_KEY_LAYER4`                  |`4`                                                                                   |Make layer 4 the default layer                  |
+|`MAGIC_KEY_LAYER4`                  |`4`                                                                        |Make layer 4 the default layer                  |
-|`MAGIC_KEY_LAYER5`                  |`5`                                                                                   |Make layer 5 the default layer                  |
+|`MAGIC_KEY_LAYER5`                  |`5`                                                                        |Make layer 5 the default layer                  |
-|`MAGIC_KEY_LAYER6`                  |`6`                                                                                   |Make layer 6 the default layer                  |
+|`MAGIC_KEY_LAYER6`                  |`6`                                                                        |Make layer 6 the default layer                  |
-|`MAGIC_KEY_LAYER7`                  |`7`                                                                                   |Make layer 7 the default layer                  |
+|`MAGIC_KEY_LAYER7`                  |`7`                                                                        |Make layer 7 the default layer                  |
-|`MAGIC_KEY_LAYER8`                  |`8`                                                                                   |Make layer 8 the default layer                  |
+|`MAGIC_KEY_LAYER8`                  |`8`                                                                        |Make layer 8 the default layer                  |
-|`MAGIC_KEY_LAYER9`                  |`9`                                                                                   |Make layer 9 the default layer                  |
+|`MAGIC_KEY_LAYER9`                  |`9`                                                                        |Make layer 9 the default layer                  |
-|`MAGIC_KEY_LAYER0_ALT1`             |`ESC`                                                                                 |Make layer 0 the default layer (alternate)      |
+|`MAGIC_KEY_LAYER0_ALT1`             |`ESC`                                                                      |Make layer 0 the default layer (alternate)      |
-|`MAGIC_KEY_LAYER0_ALT2`             |`GRAVE`                                                                               |Make layer 0 the default layer (alternate)      |
+|`MAGIC_KEY_LAYER0_ALT2`             |`GRAVE`                                                                    |Make layer 0 the default layer (alternate)      |
-|`MAGIC_KEY_BOOTLOADER`              |`PAUSE`                                                                               |Enter the bootloader                            |
+|`MAGIC_KEY_BOOTLOADER`              |`PAUSE`                                                                    |Enter the bootloader                            |
-|`MAGIC_KEY_LOCK`                    |`CAPS`                                                                                |Lock the keyboard so nothing can be typed       |
+|`MAGIC_KEY_LOCK`                    |`CAPS`                                                                     |Lock the keyboard so nothing can be typed       |
-|`MAGIC_KEY_EEPROM`                  |`E`                                                                                   |Clear the EEPROM                                |
+|`MAGIC_KEY_EEPROM`                  |`E`                                                                        |Clear the EEPROM                                |
-|`MAGIC_KEY_NKRO`                    |`N`                                                                                   |Toggle N-Key Rollover (NKRO)                    |
+|`MAGIC_KEY_NKRO`                    |`N`                                                                        |Toggle N-Key Rollover (NKRO)                    |
-|`MAGIC_KEY_SLEEP_LED`               |`Z`                                                                                   |Toggle LED when computer is sleeping            |
+|`MAGIC_KEY_SLEEP_LED`               |`Z`                                                                        |Toggle LED when computer is sleeping            |
diff --git a/docs/feature_layouts.md b/docs/feature_layouts.md
index 1ee8b5e35..b34fd442d 100644
--- a/docs/feature_layouts.md
+++ b/docs/feature_layouts.md
@@ -51,6 +51,35 @@ The folder name must be added to the keyboard's `rules.mk`:
 but the `LAYOUT_<layout>` variable must be defined in `<folder>.h` as well.
+## Building a Keymap
+You should be able to build the keyboard keymap with a command in this format:
+    make <keyboard>:<layout>
+### Conflicting layouts
+When a keyboard supports multiple layout options,
+    LAYOUTS = ortho_4x4 ortho_4x12
+And a layout exists for both options,
+```
+layouts/
+ community/
+| + ortho_4x4/
+| | + <layout>/
+| | | + ...
+| + ortho_4x12/
+| | + <layout>/
+| | | + ...
+| + ...
+```
+The FORCE_LAYOUT argument can be used to specify which layout to build
+    make <keyboard>:<layout> FORCE_LAYOUT=ortho_4x4
+    make <keyboard>:<layout> FORCE_LAYOUT=ortho_4x12
 ## Tips for Making Layouts Keyboard-Agnostic
 ### Includes
diff --git a/docs/feature_led_matrix.md b/docs/feature_led_matrix.md
new file mode 100644
index 000000000..372407b90
--- /dev/null
+++ b/docs/feature_led_matrix.md
@@ -0,0 +1,90 @@
+# LED Matrix Lighting
+This feature allows you to use LED matrices driven by external drivers. It hooks into the backlight system so you can use the same keycodes as backlighting to control it.
+If you want to use RGB LED's you should use the [RGB Matrix Subsystem](feature_rgb_matrix.md) instead.
+## Driver configuration
+### IS31FL3731
+There is basic support for addressable LED matrix lighting with the I2C IS31FL3731 RGB controller. To enable it, add this to your `rules.mk`:
+    LED_MATRIX_ENABLE = IS31FL3731
+    
+You can use between 1 and 4 IS31FL3731 IC's. Do not specify `LED_DRIVER_ADDR_<N>` defines for IC's that are not present on your keyboard. You can define the following items in `config.h`:
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `ISSI_TIMEOUT` | (Optional) How long to wait for i2c messages | 100 |
+| `ISSI_PERSISTENCE` | (Optional) Retry failed messages this many times | 0 |
+| `LED_DRIVER_COUNT` | (Required) How many LED driver IC's are present | |
+| `LED_DRIVER_LED_COUNT` | (Required) How many LED lights are present across all drivers | |
+| `LED_DRIVER_ADDR_1` | (Required) Address for the first LED driver | |
+| `LED_DRIVER_ADDR_2` | (Optional) Address for the second LED driver | |
+| `LED_DRIVER_ADDR_3` | (Optional) Address for the third LED driver | |
+| `LED_DRIVER_ADDR_4` | (Optional) Address for the fourth LED driver | |
+Here is an example using 2 drivers.
+        // 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 LED_DRIVER_ADDR_1 0b1110100
+        #define LED_DRIVER_ADDR_2 0b1110110
+        #define LED_DRIVER_COUNT 2
+        #define LED_DRIVER_1_LED_COUNT 25
+        #define LED_DRIVER_2_LED_COUNT 24
+        #define LED_DRIVER_LED_COUNT LED_DRIVER_1_LED_TOTAL + LED_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
+         *   |  LED address
+         *   |  | */
+            {0, 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) and the header file `drivers/issi/is31fl3731-simple.h`. The `driver` is the index of the driver you defined in your `config.h` (`0`, `1`, `2`, or `3` ).
+## Keycodes
+All LED matrix keycodes are currently shared with the [backlight system](feature_backlight.md).
+## LED Matrix Effects
+Currently no LED matrix effects have been created.
+## Custom layer effects
+Custom layer effects can be done by defining this in your `<keyboard>.c`:
+    void led_matrix_indicators_kb(void) {
+        led_matrix_set_index_value(index, value);
+    }
+A similar function works in the keymap as `led_matrix_indicators_user`.
+## Suspended state
+To use the suspend feature, add this to your `<keyboard>.c`:
+        void suspend_power_down_kb(void)
+        {
+            led_matrix_set_suspend_state(true);
+        }
+        void suspend_wakeup_init_kb(void)
+        {
+            led_matrix_set_suspend_state(false);
+        }
diff --git a/docs/feature_rgb_matrix.md b/docs/feature_rgb_matrix.md
index 0af1e4947..e955eb26f 100644
--- a/docs/feature_rgb_matrix.md
+++ b/docs/feature_rgb_matrix.md
@@ -1,5 +1,9 @@
 # RGB Matrix Lighting
+This feature allows you to use RGB LED matrices driven by external drivers. It hooks into the RGBLIGHT system so you can use the same keycodes as RGBLIGHT to control it.
+If you want to use single color LED's you should use the [LED Matrix Subsystem](feature_led_matrix.md) instead.
 ## Driver configuration
 ### IS31FL3731
diff --git a/docs/feature_space_cadet_shift.md b/docs/feature_space_cadet_shift.md
index bec7cbd3d..427d2a581 100644
--- a/docs/feature_space_cadet_shift.md
+++ b/docs/feature_space_cadet_shift.md
@@ -25,9 +25,13 @@ COMMAND_ENABLE = no
 By default Space Cadet assumes a US ANSI layout, but if your layout uses different keys for parentheses, you can redefine them in your `config.h`.
 You can also disable the rollover, allowing you to use the opposite Shift key to cancel the Space Cadet state in the event of an erroneous press, instead of emitting a pair of parentheses when the keys are released.
+Also, by default, the Space Cadet applies modifiers LSPO_MOD and RSPC_MOD to keys defined by LSPO_KEY and RSPC_KEY. You can override this behavior by redefining those variables in your `config.h`. You can also prevent the Space Cadet to apply a modifier by defining DISABLE_SPACE_CADET_MODIFIER in your `config.h`.
-|Define                        |Default      |Description                                                 |
-|------------------------------|-------------|------------------------------------------------------------|
+|Define                        |Default      |Description                                                                     |
-|`LSPO_KEY`                    |`KC_9`       |The keycode to send when Left Shift is tapped               |
+|------------------------------|-------------|--------------------------------------------------------------------------------|
-|`RSPC_KEY`                    |`KC_0`       |The keycode to send when Right Shift is tapped              |
+|`LSPO_KEY`                    |`KC_9`       |The keycode to send when Left Shift is tapped                                   |
-|`DISABLE_SPACE_CADET_ROLLOVER`|*Not defined*|If defined, use the opposite Shift key to cancel Space Cadet|
+|`RSPC_KEY`                    |`KC_0`       |The keycode to send when Right Shift is tapped                                  |
+|`LSPO_MOD`                    |`KC_LSFT`    |The keycode to send when Left Shift is tapped                                   |
+|`RSPC_MOD`                    |`KC_RSFT`    |The keycode to send when Right Shift is tapped                                  |
+|`DISABLE_SPACE_CADET_ROLLOVER`|*Not defined*|If defined, use the opposite Shift key to cancel Space Cadet                    |
+|`DISABLE_SPACE_CADET_MODIFIER`|*Not defined*|If defined, prevent the Space Cadet to apply a modifier to LSPO_KEY and RSPC_KEY|
diff --git a/docs/hardware_keyboard_guidelines.md b/docs/hardware_keyboard_guidelines.md
index 67af78838..c8aec40e0 100644
--- a/docs/hardware_keyboard_guidelines.md
+++ b/docs/hardware_keyboard_guidelines.md
@@ -1,107 +1,120 @@
 # 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.
+Since starting, QMK has grown by leaps and bounds thanks to people like you who contribute to creating and maintaining our community keyboards. As we've grown we've discovered some patterns that work well, and ask that you conform to them to make it easier for other people to benefit from your hard work.
 ## 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. `test`, `keyboard`, and `all` are reserved by make and are not a valid name for a keyboard.
+All keyboard names are in lower case, consisting only of letters, numbers, and underscore (`_`). Names may not begin with an underscore. Forward slash (`/`) is used as a sub-folder separation character.
-## `readme.md`
+The names `test`, `keyboard`, and `all` are reserved for make commands and may not be used as a keyboard or subfolder name.
-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).
+Valid Examples:
-## Image/Hardware Files
+* `412_64`
+* `chimera_ortho`
+* `clueboard/66/rev3`
+* `planck`
+* `v60_type_r`
-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.
+## Sub-folders
-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.
+QMK uses sub-folders both for organization and to share code between revisions of the same keyboard. You can nest folders up to 4 levels deep:
-## Keyboard Defaults
+    qmk_firmware/keyboards/top_folder/sub_1/sub_2/sub_3/sub_4
-Given the amount of functionality that QMK exposes it's very easy to confuse new users. When putting together the default firmware for your keyboard we recommend limiting your enabled features and options to the minimal set needed to support your hardware. Recommendations for specific features follow.
+If a sub-folder has a `rules.mk` file it will be considered a compilable keyboard. It will be available in QMK Configurator and tested with `make all`. If you are using a folder to organize several keyboards from the same maker you should not have a `rules.mk` file.
-### Bootmagic and Command
+Example:
-[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.
+Clueboard uses sub-folders for both purposes, organization and keyboard revisions.
-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.
+* [`qmk_firmware`](https://github.com/qmk/qmk_firmware/tree/master)
+  * [`keyboards`](https://github.com/qmk/qmk_firmware/tree/master/keyboards)
+    * [`clueboard`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard)  &larr; This is the organization folder, there's no `rules.mk` file
+      * [`60`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/60)  &larr; This is a compilable keyboard, it has a `rules.mk` file
+      * [`66`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/66) &larr; This is also compilable- it uses `DEFAULT_FOLDER` to specify `rev3` as the default revision
+        * [`rev1`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/66/rev1) &larr; compilable: `make clueboard/66/rev1`
+        * [`rev2`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/66/rev2) &larr; compilable: `make clueboard/66/rev2`
+        * [`rev3`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/66/rev3) &larr; compilable: `make clueboard/66/rev3` or `make clueboard/66`
-If your keyboard does not have 2 shift keys you should provide a working default for `IS_COMMAND`, even when you have set `COMMAND_ENABLE = no`. This will give your users a default to conform to if they do enable Command.
+## Keyboard Folder Structure
-## Custom Keyboard Programming
+Your keyboard should be located in `qmk_firmware/keyboards/` and the folder name should be your keyboard's name as described in the previous section. Inside this folder should be several files:
-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`.
+* `readme.md`
+* `info.json`
+* `config.h`
+* `rules.mk`
+* `<keyboard_name>.c`
+* `<keyboard_name>.h`
+### `readme.md`
+All projects need to have a `readme.md` file that explains what the keyboard is, who made it and where it's available. If applicable, it should also contain links to more information, such as the maker's website. Please follow the [published template](documentation_templates.md#keyboard-readmemd-template).
+### `info.json`
+This file is used by the [QMK API](https://github.com/qmk/qmk_api). It contains the information [QMK Configurator](https://config.qmk.fm/) needs to display a representation of your keyboard. You can also set metadata here. For more information see the [reference page](reference_info_json.md).
+### `config.h`
+All projects need to have a `config.h` file that sets things like the matrix size, product name, USB VID/PID, description and other settings. In general, use this file to set essential information and defaults for your keyboard that will always work.
-## Keyboard Metadata
+### `rules.mk`
-As QMK grows so does the ecosystem surrounding QMK. To make it easier for projects in that ecosystem to tie into QMK as we make changes we are developing a metadata system to expose information about keyboards in QMK.
+The presence of this file means that the folder is a keyboard target and can be used in `make` commands. This is where you setup the build environment for your keyboard and configure the default set of features.
-You can create `info.json` files at every level under `qmk_firmware/keyboards/<name>` to specify this metadata. These files are combined, with more specific files overriding keys in less specific files. This means you do not need to duplicate your metadata information. For example, `qmk_firmware/keyboards/clueboard/info.json` specifies `manufacturer` and `maintainer`, while `qmk_firmware/keyboards/clueboard/66/info.json` specifies more specific information about Clueboard 66%.
+### `<keyboard_name.c>`
-### `info.json` Format
+This is where you will write custom code for your keyboard. Typically you will write code to initialize and interface with the hardware in your keyboard. If your keyboard consists of only a key matrix with no LEDs, speakers, or other auxillary hardware this file can be blank.
-The `info.json` file is a JSON formatted dictionary with the following keys available to be set. You do not have to set all of them, merely the keys that apply to your keyboard.
+The following functions are typically defined in this file:
-* `keyboard_name`
+* `void matrix_init_kb(void)`
-  * A free-form text string describing the keyboard.
+* `void matrix_scan_kb(void)`
-  * Example: `Clueboard 66%`
+* `bool process_record_kb(uint16_t keycode, keyrecord_t *record)`
-* `url`
+* `void led_set_kb(uint8_t usb_led)`
-  * A URL to the keyboard's product page, [QMK.fm/keyboards](https://qmk.fm/keyboards) page, or other page describing information about the keyboard.
-* `maintainer`
-  * GitHub username of the maintainer, or `qmk` for community maintained boards
-* `width`
-  * Width of the board in Key Units
-* `height`
-  * Height of the board in Key Units
-* `layouts`
-  * Physical Layout representations. See the next section for more detail.
-#### Layout Format
+### `<keyboard_name.h>`
-Within our `info.json` file the `layouts` portion of the dictionary contains several nested dictionaries. The outer layer consists of QMK layout macros, for example `LAYOUT_ansi` or `LAYOUT_iso`. Within each layout macro are keys for `width`, `height`, and `key_count`, each of which should be self-explanatory.
+This file is used to define the matrix for your keyboard. You should define at least one C macro which translates an array into a matrix representing the physical switch matrix for your keyboard. If it's possible to build your keyboard with multiple layouts you should define additional macros.
-* `width`
+If you have only a single layout you should call this macro `LAYOUT`.
-  * Optional: The width of the layout in Key Units
-* `height`
-  * Optional: The height of the layout in Key Units
-* `key_count`
-  * **Required**: The number of keys in this layout
-* `layout`
-  * A list of Key Dictionaries describing the physical layout. See the next section for more details.
-#### Key Dictionary Format
+When defining multiple layouts you should have a base layout, named `LAYOUT_all`, that supports all possible switch positions on your matrix, even if that layout is impossible to build physically. This is the macro you should use in your `default` keymap. You should then have additional keymaps named `default_<layout>` that use your other layout macros. This will make it easier for people to use the layouts you define.
-Each Key Dictionary in a layout describes the physical properties of a key. If you are familiar with the Raw Code for <http://keyboard-layout-editor.com> you will find many of the concepts the same. We re-use the same key names and layout choices wherever possible, but unlike keyboard-layout-editor each key is stateless, inheriting no properties from the keys that came before it.
+Layout macro names are entirely lowercase, except for the word `LAYOUT` at the front.
-All key positions and rotations are specified in relation to the top-left corner of the keyboard, and the top-left corner of each key.
+As an example, if you have a 60% PCB that supports ANSI and ISO you might define the following layouts and keymaps:
-* `X`
+| Layout Name | Keymap Name | Description |
-  * **Required**: The absolute position of the key in the horizontal axis, in Key Units.
+|-------------|-------------|-------------|
-* `Y`
+| LAYOUT_all | default | A layout that supports both ISO and ANSI |
-  * **Required**: The absolute position of the key in the vertical axis, in Key Units.
+| LAYOUT_ansi | default_ansi | An ANSI layout |
-* `W`
+| LAYOUT_iso | default_iso | An ISO layout |
-  * The width of the key, in Key Units. Ignored if `ks` is provided. Default: `1`
-* `H`
-  * The height of the key, in Key Units. Ignored if `ks` is provided. Default: `1`
-* `R`
-  * How many degrees clockwise to rotate the key.
-* `RX`
-  * The absolute position of the point to rotate the key around in the horizontal axis. Default: `x`
-* `RY`
-  * The absolute position of the point to rotate the key around in the vertical axis. Default: `y`
-* `KS`
-  * Key Shape: define a polygon by providing a list of points, in Key Units.
-  * **Important**: These are relative to the top-left of the key, not absolute.
-  * Example ISO Enter: `[ [0,0], [1.5,0], [1.5,2], [0.25,2], [0.25,1], [0,1], [0,0] ]`
-### How is the Metadata Exposed?
+## Image/Hardware Files
+In an effort to keep the repo size down we're no longer accepting binary files of any format, with few exceptions. Hosting them elsewhere (such as <https://imgur.com>) and linking them in the `readme.md` is preferred.
+Hardware files (such as plates, cases, pcb) can be contributed to the [qmk.fm repo](https://github.com/qmk/qmk.fm) and they will be made available 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` folder for an example.
+## Keyboard Defaults
+Given the amount of functionality that QMK exposes it's very easy to confuse new users. When putting together the default firmware for your keyboard we recommend limiting your enabled features and options to the minimal set needed to support your hardware. Recommendations for specific features follow.
+### Bootmagic and Command
+[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.
-This metadata is primarily used in two ways:
+If your keyboard does not have 2 shift keys you should provide a working default for `IS_COMMAND`, even when you have set `COMMAND_ENABLE = no`. This will give your users a default to conform to if they do enable Command.
-* To allow web-based configurators to dynamically generate UI
+## Custom Keyboard Programming
-* To support the new `make keyboard:keymap:qmk` target, which bundles this metadata up with the firmware to allow QMK Toolbox to be smarter.
-Configurator authors can see the [QMK Compiler](https://docs.compile.qmk.fm/api_docs.html) docs for more information on using the JSON API.
+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`.
 ## Non-Production/Handwired Projects
diff --git a/docs/i2c_driver.md b/docs/i2c_driver.md
index ea24dc64f..18546fc62 100644
--- a/docs/i2c_driver.md
+++ b/docs/i2c_driver.md
@@ -33,8 +33,8 @@ The following defines can be used to configure the I2C master driver.
 |Variable          |Description                                        |Default|
 |------------------|---------------------------------------------------|-------|
-|`#F_SCL`          |Clock frequency in Hz                              |400KHz |
+|`F_SCL`           |Clock frequency in Hz                              |400KHz |
-|`#Prescaler`      |Divides master clock to aid in I2C clock selection |1      |
+|`Prescaler`       |Divides master clock to aid in I2C clock selection |1      |
 AVRs usually have set GPIO which turn into I2C pins, therefore no further configuration is required.
@@ -63,20 +63,24 @@ Lastly, we need to assign the correct GPIO pins depending on the I2C hardware dr
 By default the I2C1 hardware driver is assumed to be used. If another hardware driver is used,  `#define I2C_DRIVER I2CDX` should be added to the `config.h` file with X being the number of hardware driver used. For example is I2C3 is enabled, the `config.h` file should contain `#define I2C_DRIVER I2CD3`. This aligns the QMK I2C driver with the Chibios I2C driver.
-STM32 MCUs allows a variety of pins to be configured as I2C pins depending on the hardware driver used. By default B6 and B7 are set to I2C.
+STM32 MCUs allows a variety of pins to be configured as I2C pins depending on the hardware driver used. By default B6 and B7 are set to I2C. You can use these defines to set your i2c pins:
-This can be changed by declaring the `i2c_init` function which intentionally has a weak attribute. Please consult the datasheet of your MCU for the available GPIO configurations. The following is an example initialization function:
+| Variable    | Description                                  | Default |
+|-------------|----------------------------------------------|---------|
+| `I2C1_BANK` | The bank of pins (`GPIOA`, `GPIOB`, `GPIOC`) | `GPIOB` |
+| `I2C1_SCL`  | The pin number for the SCL pin (0-9)         | `6`     |
+| `I2C1_SDA`  | The pin number for the SDA pin (0-9)         | `7`     |
+You can also overload the `void i2c_init(void)` function, which has a weak attribute. If you do this the configuration variables above will not be used. Please consult the datasheet of your MCU for the available GPIO configurations. The following is an example initialization function:
 ```C
 void i2c_init(void)
 {
  setPinInput(B6); // Try releasing special pins for a short time
  setPinInput(B7);
-  chThdSleepMilliseconds(10); // Wait for the release to happen
+  wait_ms(10); // Wait for the release to happen
  palSetPadMode(GPIOB, 6, PAL_MODE_ALTERNATE(4) | PAL_STM32_OTYPE_OPENDRAIN | PAL_STM32_PUPDR_PULLUP); // Set B6 to I2C function
  palSetPadMode(GPIOB, 7, PAL_MODE_ALTERNATE(4) | PAL_STM32_OTYPE_OPENDRAIN | PAL_STM32_PUPDR_PULLUP); // Set B7 to I2C function
 }
 ```
diff --git a/docs/newbs.md b/docs/newbs.md
index 4f115c3c7..904a52945 100644
--- a/docs/newbs.md
+++ b/docs/newbs.md
@@ -6,10 +6,11 @@ Not sure if your keyboard can run QMK? If it's a mechanical keyboard you built y
 ## Overview
-There are 6 main sections to this guide:
+There are 7 main sections to this guide:
 * [Getting Started](newbs_getting_started.md)
-* [Building Your First Firmware](newbs_building_firmware.md)
+* [Building Your First Firmware using the command line](newbs_building_firmware.md)
+* [Building Your First Firmware using the online GUI](newbs_building_firmware_configurator.md)
 * [Flashing Firmware](newbs_flashing.md)
 * [Testing and Debugging](newbs_testing_debugging.md)
 * [Git Best Practices](newbs_best_practices.md)
diff --git a/docs/newbs_building_firmware_configurator.md b/docs/newbs_building_firmware_configurator.md
new file mode 100644
index 000000000..0ad609304
--- /dev/null
+++ b/docs/newbs_building_firmware_configurator.md
@@ -0,0 +1,105 @@
+# QMK Configurator
+The [QMK Configurator](https://config.qmk.fm) is an online graphical user interface that generates QMK Firmware hex files.  
+?> **Please follow these steps in order.**
+Watch the [Video Tutorial](https://youtu.be/7RH-1pAbjvw)
+The QMK Configurator works best with Chrome/Firefox. 
+!> **Files from other tools such as KLE, or kbfirmware will not be compatible with QMK Configurator. Do not load them, do not import them. QMK Configurator is a DIFFERENT tool. **
+## Selecting your keyboard
+Click the drop down box and select the keyboard you want to create a keymap for. 
+?> If your keyboard has several versions, make sure you select the correct one.** 
+I'll say that again because it's important
+!> **MAKE SURE YOU SELECT THE RIGHT VERSION!**
+If your keyboard has been advertised to be powered by QMK but is not in the list, chances are a developer hasn't gotten to it yet or we haven't had a chance to merge it in yet. File an issue at [qmk_firmware](https://github.com/qmk/qmk_firmware/issues) requesting to support that particular keyboard, if there is no active [Pull Request](https://github.com/qmk/qmk_firmware/pulls?q=is%3Aopen+is%3Apr+label%3Akeyboard) for it. There are also QMK powered keyboards that are in their manufacturer's own github accounts. Double check for that as well. 
+## Selecting your keyboard layout
+Choose the layout that best represents the keymap you want to create. Some keyboards do not have enough layouts or correct layouts defined yet. They will be supported in the future. 
+## Keymap Name
+Call this keymap what you want. 
+?> If you are running into issues when compiling, it may be worth changing this name, as it may already exist in the QMK  Firmware repo.
+## Creating Your Keymap
+Keycode Entry is accomplished in 3 ways.  
+1. Drag and dropping 
+2. Clicking on an empty spot on the layout and clicking the keycode you desire
+3. Clicking on an empty spot on the layout, pressing the physical key on your keyboard. 
+Hover your mouse over a key and a short blurb will tell you what that keycode does. For a more verbose description please see    
+[Basic Keycode Reference](https://docs.qmk.fm/#/keycodes_basic)    
+[Advanced Keycode Reference](https://docs.qmk.fm/#/feature_advanced_keycodes)    
+In the event that you can't find a layout that supports your keymap, for example three spots for spacebar, or two spots for backspace, or 2 spots for shift etc etc, Fill them ALL up. 
+### Example:
+3 spots for spacebar: Fill them ALL with spacebar
+2 spots for backspace: Fill them BOTH with backspace
+2 spots for right shift: Fill them BOTH with right shift
+1 spot for left shift and 1 spot for iso support: Fill them both with left shift
+5 spots, but only 4 keys: Guess and check or ask someone who has done it before. 
+## Saving Your Keymap for Future Edits
+When you're satisfied with your keymap or just want to work on it later, press the `Export Keymap` button. It will save your keymap as the name you chose above appended with .json. 
+You can then load this .json file in the future by pressing the `Import Keymap` button. 
+!> **CAUTION:** This is not the same type of .json file used for kbfirmware.com or any other tool. If you try to use this for those tools, or the .json from those tools with QMK Configurator, there is a chance your keyboard will **explode**. 
+## Generating your firmware file
+Press the green `Compile` button.
+When the compilation is done, you will be able to press the green `Download Firmware` button. 
+## Flashing Your Keyboard
+Please refer to [Flashing Firmware](newbs_flashing.md)
+## Troubleshooting
+#### My .json file is not working
+If the .json file was generated with QMK Configurator, congratulations you have stumbled upon a bug. File an issue at [qmk_configurator](https://github.com/qmk/qmk_configurator/issues)
+If not....how did you miss my big bold message at the top saying not to use other .json files? 
+#### There are extra spaces in my layout? What do I do? 
+If you're referring to having three spots for space bar, the best course of action is to just fill them all with space bar. The same can be done for backspace and shifts
+#### What is the keycode for.......
+Please see
+[Basic Keycode Reference](https://docs.qmk.fm/#/keycodes_basic)    
+[Advanced Keycode Reference](https://docs.qmk.fm/#/feature_advanced_keycodes)    
+#### It won't compile
+Please double check the other layers of your keymap to make sure there are no random keys present. 
+## Problems and Bugs
+We are always accepting customer requests and bug reports. Please file them at [qmk_configurator](https://github.com/qmk/qmk_configurator/issues)
diff --git a/docs/newbs_getting_started.md b/docs/newbs_getting_started.md
index 276c7fec3..aefa1b738 100644
--- a/docs/newbs_getting_started.md
+++ b/docs/newbs_getting_started.md
@@ -6,7 +6,10 @@ QMK tries to put a lot of power into your hands by making easy things easy, and
 # Getting Started
-Before you can build keymaps, you need to install some software and set up your build environment. This only has to be done once no matter how many keyboards you plan to compile firmware for.
+Before you can build keymaps, you need to install some software and set up your build environment. This only has to be done once no matter how many keyboards you plan to compile firmware for. 
+If you would prefer a more graphical user interface approach, please consider using the online [QMK Configurator](https://config.qmk.fm). Please refer to [Building Your First Firmware using the online GUI](newbs_building_firmware_configurator.md). 
 ## Download Software
diff --git a/docs/reference_info_json.md b/docs/reference_info_json.md
new file mode 100644
index 000000000..badfabd91
--- /dev/null
+++ b/docs/reference_info_json.md
@@ -0,0 +1,73 @@
+# `info.json`
+This file is used by the [QMK API](https://github.com/qmk/qmk_api). It contains the information [QMK Configurator](https://config.qmk.fm/) needs to display a representation of your keyboard. You can also set metadata here.
+You can create `info.json` files at every level under `qmk_firmware/keyboards/<name>` to specify this metadata. These files are combined, with more specific files overriding keys in less specific files. This means you do not need to duplicate your metadata information. For example, `qmk_firmware/keyboards/clueboard/info.json` specifies `manufacturer` and `maintainer`, while `qmk_firmware/keyboards/clueboard/66/info.json` specifies more specific information about Clueboard 66%.
+## `info.json` Format
+The `info.json` file is a JSON formatted dictionary with the following keys available to be set. You do not have to set all of them, merely the keys that apply to your keyboard.
+* `keyboard_name`
+  * A free-form text string describing the keyboard.
+  * Example: `Clueboard 66%`
+* `url`
+  * A URL to the keyboard's product page, [QMK.fm/keyboards](https://qmk.fm/keyboards) page, or other page describing information about the keyboard.
+* `maintainer`
+  * GitHub username of the maintainer, or `qmk` for community maintained boards
+* `width`
+  * Width of the board in Key Units
+* `height`
+  * Height of the board in Key Units
+* `layouts`
+  * Physical Layout representations. See the next section for more detail.
+### Layout Format
+Within our `info.json` file the `layouts` portion of the dictionary contains several nested dictionaries. The outer layer consists of QMK layout macros, for example `LAYOUT_ansi` or `LAYOUT_iso`. Within each layout macro are keys for `width`, `height`, and `key_count`, each of which should be self-explanatory.
+* `width`
+  * Optional: The width of the layout in Key Units
+* `height`
+  * Optional: The height of the layout in Key Units
+* `key_count`
+  * **Required**: The number of keys in this layout
+* `layout`
+  * A list of Key Dictionaries describing the physical layout. See the next section for more details.
+### Key Dictionary Format
+Each Key Dictionary in a layout describes the physical properties of a key. If you are familiar with the Raw Code for <http://keyboard-layout-editor.com> you will find many of the concepts the same. We re-use the same key names and layout choices wherever possible, but unlike keyboard-layout-editor each key is stateless, inheriting no properties from the keys that came before it.
+All key positions and rotations are specified in relation to the top-left corner of the keyboard, and the top-left corner of each key.
+* `x`
+  * **Required**: The absolute position of the key in the horizontal axis, in Key Units.
+* `y`
+  * **Required**: The absolute position of the key in the vertical axis, in Key Units.
+* `w`
+  * The width of the key, in Key Units. Ignored if `ks` is provided. Default: `1`
+* `h`
+  * The height of the key, in Key Units. Ignored if `ks` is provided. Default: `1`
+* `r`
+  * How many degrees clockwise to rotate the key.
+* `rx`
+  * The absolute position of the point to rotate the key around in the horizontal axis. Default: `x`
+* `ry`
+  * The absolute position of the point to rotate the key around in the vertical axis. Default: `y`
+* `ks`
+  * Key Shape: define a polygon by providing a list of points, in Key Units.
+  * **Important**: These are relative to the top-left of the key, not absolute.
+  * Example ISO Enter: `[ [0,0], [1.5,0], [1.5,2], [0.25,2], [0.25,1], [0,1], [0,0] ]`
+* `label`
+  * What to name this position in the matrix.
+  * This should usually be the same name as what is silkscreened on the PCB at this location.
+## How is the Metadata Exposed?
+This metadata is primarily used in two ways:
+* To allow web-based configurators to dynamically generate UI
+* To support the new `make keyboard:keymap:qmk` target, which bundles this metadata up with the firmware to allow QMK Toolbox to be smarter.
+Configurator authors can see the [QMK Compiler](https://docs.api.qmk.fm/using-the-api) docs for more information on using the JSON API.