Update a bunch of docs

docs/README.md

@@ -1,23 +1,16 @@
 # Quantum Mechanical Keyboard Firmware
 
-## Getting started
+## What is QMK Firmware? {#what-is-qmk-firmware}
-
-* [What is QMK Firmware?](#what-is-qmk-firmware)
-* [How to get it](#how-to-get-it)
-* [How to compile](#how-to-compile)
-* [How to customize](#how-to-customize)
-
-### What is QMK Firmware? {#what-is-qmk-firmware}
 
 QMK (*Quantum Mechanical Keyboard*) is an open source community that maintains QMK Firmware, QMK Flasher, qmk.fm, and these docs. QMK Firmware is a keyboard firmware based on the [tmk\_keyboard](http://github.com/tmk/tmk_keyboard) with some useful features for Atmel AVR controllers, and more specifically, the [OLKB product line](http://olkb.com), the [ErgoDox EZ](http://www.ergodox-ez.com) keyboard, and the [Clueboard product line](http://clueboard.co/). It has also been ported to ARM chips using ChibiOS. You can use it to power your own hand-wired or custom keyboard PCB.
 
-### How to get it {#how-to-get-it}
+## How to get it {#how-to-get-it}
 
 If you plan on contributing a keymap, keyboard, or features to QMK, the easiest thing to do is [fork the repo through Github](https://github.com/qmk/qmk_firmware#fork-destination-box), and clone your repo locally to make your changes, push them, then open a [Pull Request](https://github.com/qmk/qmk_firmware/pulls) from your fork.
 
 Otherwise, you can either download it directly ([zip](https://github.com/qmk/qmk_firmware/zipball/master), [tar](https://github.com/qmk/qmk_firmware/tarball/master)), or clone it via git (`git@github.com:qmk/qmk_firmware.git`), or https (`https://github.com/qmk/qmk_firmware.git`).
 
-### How to compile {#how-to-compile}
+## How to compile {#how-to-compile}
 
 Before you are able to compile, you'll need to [install an environment](build_environment_setup.md) for AVR or/and ARM development. Once that is complete, you'll use the `make` command to build a keyboard and keymap with the following notation:
 
@@ -27,6 +20,6 @@ This would build the `rev4` revision of the `planck` with the `default` keymap.
 
     make preonic-default
 
-### How to customize {#how-to-customize}
+## How to customize {#how-to-customize}
 
 QMK has lots of [features](features/README.md) to explore, and a good deal of [reference documentation](reference/README.md) to dig through. Most features are taken advantage of by modifying your [keymap](keymap.md), and changing the [keycodes](keycodes.md).

docs/_summary.md

@@ -23,15 +23,16 @@
     * [Quantum Keycodes](quantum_keycodes.md)
   * [The Config File](config_options.md)
   * [Customizing Functionality](custom_quantum_functions.md)
+  * [Documentation Best Practices](documentation_best_practices.md)
   
 * For makers and modders
   * [Adding a keyboard to QMK](adding_a_keyboard_to_qmk.md)
   * [Porting your keyboard to QMK](porting_your_keyboard_to_qmk.md)
   * [Modding your keyboard](modding_your_keyboard.md)
+  * [Understanding QMK](understanding_qmk.md)
   * [Adding features to QMK](adding_features_to_qmk.md)
   * [ISP flashing guide](isp_flashing_guide.md)
   
 * Other topics
   * [General FAQ](faq.md)
-  * [Differences from TMK](differences_from_tmk.md)
   * [Using Eclipse with QMK](eclipse.md)

docs/adding_features_to_qmk.md

@@ -1,7 +1,16 @@
-If you have an idea for a custom feature or extra hardware connection, we'd love to accept it into QMK! These are generally done via [pull request](https://github.com/qmk/qmk_firmware/pulls) after forking, and here are some things to keep in mind when creating one:
+# How To Add Features To QMK
 
-* **Disable by default** - memory is a pretty limited on most chips QMK supports, and it's important that current keymaps aren't broken, so please allow your feature to be turned **on**, rather than being turned off. If you think it should be on by default, or reduces the size of the code, [open an issue](https://github.com/qmk/qmk_firmware/issues) for everyone to discuss it!
+If you have an idea for a custom feature or extra hardware connection, we'd love to accept it into QMK! 
+
+Before you put a lot of work into building your new feature you should make sure you are implementing it in the best way. You can get a basic understanding of QMK by reading [Understaning QMK](understanding_qmk.html), which will take you on a tour of the QMK program flow. From here you should talk to us to get a sense of the best way to implement your idea. There are two main ways to do this:
+
+* [Chat on Gitter](https://gitter.im/qmk/qmk_firmware)
+* [Open an Issue](https://github.com/qmk/qmk_firmware/issues/new)
+
+Once you have implemented your new feature you will generally submit a [pull request](https://github.com/qmk/qmk_firmware/pulls). Here are some things to keep in mind when creating one:
+
+* **Disabled by default** - memory is a pretty limited on most chips QMK supports, and it's important that current keymaps aren't broken, so please allow your feature to be turned **on**, rather than being turned off. If you think it should be on by default, or reduces the size of the code, please talk with us about it.
 * **Compile locally before submitting** - hopefully this one is obvious, but things need to compile! Our Travis system will catch any issues, but it's generally faster for you to compile a few keyboards locally instead of waiting for the results to come back.
 * **Consider subprojects and different chip-bases** - there are several keyboards that have subprojects that have allow for slightly different configurations, and even different chip-bases. Try to make a feature supported in ARM and AVR, or automatically disabled in one that doesn't work.
-* **Explain your feature** - submitting a markdown write-up of what your feature does with your PR may be needed, and it will allow a collaborator to easily copy it into the wiki for documentation (after proofing and editing).
+* **Explain your feature** - Document it in `docs/`, either as a new file or as part of an existing file. If you don't document it other people won't be able to benefit from your hard work.
 * **Don't refactor code** - to maintain a clear vision of how things are laid out in QMK, we try to plan out refactors in-depth, and have a collaborator make the changes. If you have an idea for refactoring, or suggestions, [open an issue](https://github.com/qmk/qmk_firmware/issues).

docs/build_environment_setup.md

@@ -1,19 +1,25 @@
-### Windows 10
+# Build Environment Setup
 
-#### Creators Update
+This page describes setting up the build environment for QMK. These instructions cover AVR processors (such as the atmega32u4.)
+
+<!-- FIXME: We should have ARM instructions somewhere. -->
+
+# Windows 10
+
+## Creators Update
 If you have Windows 10 with Creators Update or later, you can build and flash the firmware directly. Before the Creators Update, only building was possible. If you don't have it yet or if are unsure, follow [these instructions](https://support.microsoft.com/en-us/instantanswers/d4efb316-79f0-1aa1-9ef3-dcada78f3fa0/get-the-windows-10-creators-update).
 
-#### Windows Subsystem for Linux
+## Windows Subsystem for Linux
 In addition to the Creators Update, you need Windows 10 Subystem for Linux, so install it following [these instructions](http://www.howtogeek.com/249966/how-to-install-and-use-the-linux-bash-shell-on-windows-10/). If you already have the Windows 10 Subsystem for Linux from the Anniversary update it's recommended that you [upgrade](https://betanews.com/2017/04/14/upgrade-windows-subsystem-for-linux/) it to 16.04LTS, because some keyboards don't compile with the toolchains included in 14.04LTS. Note that you need to know what your are doing if you chose the `sudo do-release-upgrade` method.
 
-#### Git
+## Git
 If you already have cloned the repository on your Windows file system you can ignore this section.
 
 You will need to clone the repository to your Windows file system using the normal Git for Windows and **not** the WSL Git. So if you haven't installed Git before, [download](https://git-scm.com/download/win) and install it. Then [set it up](https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup), it's important that you setup the e-mail and user name, especially if you are planning to contribute. 
 
 Once Git is installed, open the Git bash command and change the directory to where you want to clone QMK, note that you have to use forward slashes, and that your c drive is accessed like this `/c/path/to/where/you/want/to/go`. Then run `git clone --recurse-submodules https://github.com/qmk/qmk_firmware`, this will create a new folder `qmk_firmware` as a subfolder of the current one.
 
-#### Toolchain setup
+## Toolchain setup
 The Toolchain setup is done through the Windows Subsystem for Linux, and the process is fully automated. If you want to do everything manually, there are no other instructions than the scripts themselves, but you can always open issues and ask for more information.
 
 1. Open "Bash On Ubuntu On Windows" from the start menu. 
@@ -22,13 +28,13 @@ The Toolchain setup is done through the Windows Subsystem for Linux, and the pro
 4. Close the Bash command window, and re-open it.
 5. You are ready to compile and flash the firmware!
 
-#### Some important things to keep in mind
+## Some important things to keep in mind
 * You can run `util/wsl_install.sh` again to get all the newest updates.
 * Your QMK repository need to be on a Windows file system path, since WSL can't run executables outside it.
 * The WSL Git is **not** compatible with the Windows Git, so use the Windows Git Bash or a windows Git GUI for all Git operations
 * You can edit files either inside WSL or normally using Windows, but note that if you edit makefiles or shell scripts, make sure you are using an editor that saves the files with Unix line endings. Otherwise the compilation might not work.
 
-### Windows (Vista and later)
+# Windows (Vista and later)
 1. If you have ever installed WinAVR, uninstall it.
 2. Install [MHV AVR Tools](https://infernoembedded.com/sites/default/files/project/MHV_AVR_Tools_20131101.exe). Disable smatch, but **be sure to leave the option to add the tools to the PATH checked**.
 3. If you are going to flash Infinity based keyboards you will need to install dfu-util, refer to the instructions by [Input Club](https://github.com/kiibohd/controller/wiki/Loading-DFU-Firmware).
@@ -40,7 +46,7 @@ The Toolchain setup is done through the Windows Subsystem for Linux, and the pro
 
 If you have trouble and want to ask for help, it is useful to generate a *Win_Check_Output.txt* file by running `Win_Check.bat` in the `\util` folder.
 
-### Mac
+# Mac
 If you're using [homebrew,](http://brew.sh/) you can use the following commands:
 
     brew tap osx-cross/avr
@@ -59,7 +65,7 @@ If you are going to flash Infinity based keyboards you will also need dfu-util
 
     brew install dfu-util
 
-### Linux
+# Linux
 
 To ensure you are always up to date, you can just run `sudo util/install_dependencies.sh`. That should always install all the dependencies needed. **This will run `apt-get upgrade`.**
 
@@ -91,7 +97,7 @@ Debian/Ubuntu example:
     sudo apt-get update
     sudo apt-get install gcc unzip wget zip gcc-avr binutils-avr avr-libc dfu-programmer dfu-util gcc-arm-none-eabi binutils-arm-none-eabi libnewlib-arm-none-eabi
 
-### Docker
+# Docker
 
 If this is a bit complex for you, Docker might be the turn-key solution you need. After installing [Docker](https://www.docker.com/products/docker), run the following command at the root of the QMK folder to build a keyboard/keymap:
 
@@ -109,10 +115,10 @@ docker run -e keymap=default -e subproject=ez -e keyboard=ergobox --rm -v D:/Use
 
 This will compile the targeted keyboard/keymap and leave it in your QMK directory for you to flash.
 
-### Vagrant
+# Vagrant
 If you have any problems building the firmware, you can try using a tool called Vagrant. It will set up a virtual computer with a known configuration that's ready-to-go for firmware building. OLKB does NOT host the files for this virtual computer. Details on how to set up Vagrant are in the [vagrant guide](vagrant_guide.md).
 
-## Verify Your Installation
+# Verify Your Installation
 1. If you haven't already, obtain this repository ([https://github.com/qmk/qmk_firmware](https://github.com/qmk/qmk_firmware)). You can either download it as a zip file and extract it, or clone it using the command line tool git or the Github Desktop application.
 2. Open up a terminal or command prompt and navigate to the `qmk_firmware` folder using the `cd` command. The command prompt will typically open to your home directory. If, for example, you cloned the repository to your Documents folder, then you would type `cd Documents/qmk_firmware`. If you extracted the file from a zip, then it may be named `qmk_firmware-master` instead.
 3. To confirm that you're in the correct location, you can display the contents of your current folder using the `dir` command on Windows, or the `ls` command on Linux or Mac. You should see several files, including `readme.md` and a `quantum` folder. From here, you need to navigate to the appropriate folder under `keyboards/`. For example, if you're building for a Planck, run `cd keyboards/planck`.

docs/custom_quantum_functions.md

@@ -34,9 +34,9 @@ enum my_keycodes {
 };
 ```
 
-## Programming The Behavior Of A Keycode
+## Programming The Behavior Of Any Keycode
 
-When you want to override the behavior of an existing key, or define the behavior for a new key, you should use the `process_record_{kb,user}()` functions. These are called by QMK during key processing before the actual key event is handled. If these functions return `true` QMK will process the keycodes as usual. That can be handy for extending the functionality of a key rather than replacing it. If these functions return `false` QMK will skip the normal key handling, and it will be up you to send and key up or down events that are required.
+When you want to override the behavior of an existing key, or define the behavior for a new key, you should use the `process_record_kb()' and `process_record_user()` functions. These are called by QMK during key processing before the actual key event is handled. If these functions return `true` QMK will process the keycodes as usual. That can be handy for extending the functionality of a key rather than replacing it. If these functions return `false` QMK will skip the normal key handling, and it will be up you to send any key up or down events that are required.
 
 These function are called every time a key is pressed or released.
 
@@ -57,7 +57,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
     case KC_ENTER:
       // Play a tone when enter is pressed
       if (record->event.pressed) {
-        PLAY_NOTE_ARRAY(tone_enter);
+        PLAY_NOTE_ARRAY(tone_qwerty);
       }
       return true; // Let QMK send the enter press/release events
   }

docs/differences_from_tmk.md

@@ -1,7 +0,0 @@
-Understanding the essential changes made on the [tmk_keyboard firmware](http://github.com/tmk/tmk_keyboard) should help you understand the QMK Firmware.
-
-| Firmware                     |TMK                    |QMK                      |
-|------------------------------|-----------------------|-------------------------|
-| Maintainer                   |hasu  (@tmk)           |Jack Humbert et al.      |
-| Build path customization     | `TMK_DIR = ...`       | `include .../Makefile`  |
-| `keymaps` array data | 3D array of `uint8_t`  holding **keycode**      | 3D array of `uint16_t` holding **keycode**  |

docs/documentation_best_practices.md

@@ -0,0 +1,39 @@
+# Documentation Best Practices
+
+This page exists to document best practices when writing documentation for QMK. Following these guidelines will help to keep a consistent tone and style, which will in turn help other people more easily understand QMK.
+
+# Page Opening
+
+Your documentation page should generally start with an H1 heading, followed by a 1 paragrah description of what the user will find on this page. Keep in mind that this heading and paragraph will sit next to the Table of Contents, so keep the heading short and avoid long strings with no whitespace.
+
+Example:
+
+```
+# My Page Title
+
+This page covers my super cool feature. You can use this feature to make coffee, squeeze fresh oj, and have an egg mcmuffin and hashbrowns delivered from your local macca's by drone.
+```
+
+# Headings
+
+Your page should generally have multiple "H1" headings. Only H1 and H2 headings will included in the Table of Contents, so plan them out appropriately. Excess width should be avoided in H1 and H2 headings to prevent the Table of Contents from getting too wide.
+
+# Styled Hint Blocks
+
+You can have styled hint blocks drawn around text to draw attention to it.
+
+{% hint style='info' %}
+This uses \{\% hint style='info' \%\}
+{% endhint %}
+
+{% hint style='tip' %}
+This uses \{\% hint style='tip' \%\}
+{% endhint %}
+
+{% hint style='danger' %}
+This uses \{\% hint style='danger' \%\}
+{% endhint %}
+
+{% hint style='working' %}
+This uses \{\% hint style='working' \%\}
+{% endhint %}

docs/eclipse.md

@@ -1,3 +1,5 @@
+# Setting Up Eclipse for QMK Development
+
 [Eclipse](https://en.wikipedia.org/wiki/Eclipse_(software)) is an open-source [Integrated Development Environment](https://en.wikipedia.org/wiki/Integrated_development_environment) (IDE) widely used for Java development, but with an extensible plugin system that allows to customize it for other languages and usages.
 
 Using an IDE such as Eclipse provides many advantages over a plain text editor, such as:

docs/faq.md

@@ -1,31 +1,33 @@
-## READ FIRST
+# Frequently Asked Questions
-- **README** of top directory : https://github.com/tmk/tmk_keyboard/blob/master/README.md
-- **README** of target project(keyboard/converter) directory.
 
-Note that you'll need to read **both**.
+## What is QMK?
 
+[QMK](https://github.com/qmk), short for Quantum Mechanical Keyboard, is a group of people building tools for custom keyboards. We started with the [QMK firmware](https://github.com/qmk/qmk_firmware), a heavily modified fork of [TMK](https://github.com/tmk/tmk_keyboard).
 
-# Build
+## What Differences Are There Between QMK and TMK?
-- [[FAQ/Build]]
 
+TMK was originally designed and implemented by [Jun Wako](https://github.com/tmk). QMK started as [Jack Humbert's](https://github.com/jackhumbert) fork of TMK for the Planck. After a while Jack's fork had diverged quite a bit from TMK, and in 2015 Jack decided to rename his fork to QMK.
 
-# Keymap
+From a technical standpoint QMK builds upon TMK by adding several new features. Most notably QMK has expanded the number of available keycodes and uses these to implement advanced features like `S()`, `LCTL()`, and `MO()`. You can see a complete list of these keycodes in [Quantum Keycodes](quantum_keycodes.html).
-- [[FAQ/Keymap]]
 
+From a project and community management standpoint TMK prefers to have keyboards maintained in separate forks while QMK prefers to have keyboards maintained in one central repository. 
 
 # Debug Console
 ## hid_listen can't recognize device
 When debug console of your device is not ready you will see like this:
 
-    Waiting for device:.........
+```
+Waiting for device:.........
+```
 
 once the device is pluged in then *hid_listen* finds it you will get this message:
 
-    Waiting for new device:.........................
+```
-    Listening:
+Waiting for new device:.........................
+Listening:
+```
 
-Check if you can't get this 'Listening:' message:
+If you can't get this 'Listening:' message try building with `CONSOLE_ENABLE=yes` in [Makefile]
-- build with `CONSOLE_ENABLE=yes` in **Makefile**.
 
 You may need privilege to access the device on OS like Linux.
 - try `sudo hid_listen`
@@ -73,41 +75,13 @@ Without reset circuit you will have inconsistent reuslt due to improper initiali
 
 
 ## Can't read column of matrix beyond 16 
-Use `1UL<<16` instead of `1<<16` in `read_cols()` in **matrix.h** when your columns goes beyond 16.
+Use `1UL<<16` instead of `1<<16` in `read_cols()` in [matrix.h] when your columns goes beyond 16.
 
-In C `1` means one of **int** type which is **16bit** in case of AVR so you can't shift left more than 15. You will get unexpected zero when you say `1<<16`. You have to use **unsigned long** type with `1UL`.
+In C `1` means one of [int] type which is [16bit] in case of AVR so you can't shift left more than 15. You will get unexpected zero when you say `1<<16`. You have to use [unsigned long] type with `1UL`.
 
 http://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
 
 
-
-## Pull-up Resistor
-In some case converters needed to have pull-up resistors to work correctly. Place the resistor between VCC and signal line in parallel.
-
-For example:
-```
-Keyboard       Conveter
-               ,------.
-5V------+------|VCC   |
-        |      |      |
-        R      |      |
-        |      |      |
-Signal--+------|PD0   |
-               |      |
-GND------------|GND   |
-               `------'
-R: 1K Ohm resistor
-```
-
-https://github.com/tmk/tmk_keyboard/issues/71
-
-
-## Arduino Micro's pin naming is confusing
-Note that Arduino Micro PCB marking is different from real AVR port name. D0 of Arduino Micro is not PD0, PD0 is D3. Check schematic yourself.
-http://arduino.cc/en/uploads/Main/arduino-micro-schematic.pdf
-
-
-
 ## Bootloader jump doesn't work
 Properly configure bootloader size in **Makefile**. With wrong section size bootloader won't probably start with **Magic command** and **Boot Magic**.
 ```
@@ -157,20 +131,20 @@ https://github.com/tmk/tmk_keyboard/issues/179
 
 
 ## Special Extra key doesn't work(System, Audio control keys)
-You need to define `EXTRAKEY_ENABLE` in **makefile** to use them in TMK.
+You need to define `EXTRAKEY_ENABLE` in `rules.mk` to use them in QMK.
+
 ```
 EXTRAKEY_ENABLE = yes          # Audio control and System control
 ```
-http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-60.html#p157919
-
 
 ## Wakeup from sleep doesn't work
+
 In Windows check `Allow this device to wake the computer` setting in Power **Management property** tab of **Device Manager**. Also check BIOS setting.
 
 Pressing any key during sleep should wake host.
 
-
 ## Using Arduino?
+
 **Note that Arduino pin naming is different from actual chip.** For example, Arduino pin `D0` is not `PD0`. Check circuit with its schematics yourself.
 
 - http://arduino.cc/en/uploads/Main/arduino-leonardo-schematic_3b.pdf

docs/faq_build.md

@@ -1,5 +1,6 @@
-## READ FIRST
+# Frequently Asked Build Questions
-- https://github.com/qmk/qmk_firmware/blob/master/docs/build_guide.md
+
+This page covers questions about building QMK. If you have not yet you should read the [Build Guide](https://github.com/qmk/qmk_firmware/blob/master/docs/build_guide.md).
 
 In short,
 
@@ -8,12 +9,10 @@ In short,
     $ make [-f Makefile.<variant>] [KEYMAP=...] dfu
 
 
-## Can't program on Linux and Mac
+## Can't program on Linux
 You will need proper permission to operate a device. For Linux users see udev rules below.
 Easy way is to use `sudo` command, if you are not familiar with this command check its manual with `man sudo` or this page on line.
 
-https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man8/sudo.8.html
-
 In short when your controller is ATMega32u4,
     
     $ sudo dfu-programmer atmega32u4 erase --force
@@ -26,63 +25,14 @@ or just
 
 But to run `make` with root privilege is not good idea. Use former method as possible.
 
-## Do 'make clean' before 'make'
-You'll need `make clean` after you edit **config.h** or change options like `KEYMAP`.
-
-Frist remove all files made in previous build,
-
-    $ make clean
-
-then build new firmware. 
-
-    $ make [KEYMAP=...]
-
-Also you can always try `make clean` when you get other strange result during build.
-
-
 ## WINAVR is obsolete
 It is no longer recommended and may cause some problem.
 See [Issue #99](https://github.com/tmk/tmk_keyboard/issues/99).
 
-## USB stack: LUFA or PJRC?
-Use **LUFA**.
-
-**PJRC** stack won't be supported actively anymore. There is no reason to hesitate to use LUFA except for binary size(about 1KB lager?). But **PJRC** is still very useful for debug and development purpose.
-See also [Issue #50](https://github.com/tmk/tmk_keyboard/issues/50) and [Issue #58](https://github.com/tmk/tmk_keyboard/issues/58).
-
-## Edit configuration but not change
-You will need followings after editing `CONSOLE_ENABLE`, `NKRO_ENABLE`, `EXTRAKEY_ENABLE` or `MOUSEKEY_ENABLE` option in **Makefile**.
-
-### 1. make clean
-This will be needed when you edit **config.h**.
-
-### 2. Remove Drivers from Device Manager(Windows)
-**Windows only.** Linux, OSX and other OS's doesn't require this. It looks like Windows keeps using driver installed when device was connected first time even after the device changes its configuration. To load proper drivers for new configuration you need to remove existent drivers from **Drvice Manager**.
-
-### 3. Build with different VID:PID
-**Windows only.** If method 2. does't work fou you try this. Change Vendor ID or Product ID in **config.h** and build firmware. Windows should recognize it as whole new device and start drivers install process.
-
-### 4. Just try other ports
-This will be useful and the easiest workaround for **Windows**.
-
-
-
 ## USB VID and PID
 You can use any ID you want with editing `config.h`. Using any presumably unused ID will be no problem in fact except for very least chance of collision with other product.
 
-For example TMK uses following numbers by default.
+Most boards in QMK use `0xFEED` as the vendor ID. You should look through other keyboards to make sure you pick a unique Product ID.
-```
-keyboard:
-hhkb: FEED:CAFE
-gh60: FEED:6060
-
-converter:
-x68k: FEED:6800
-ps2: FEED:6512
-adb: FEED:0ADB
-ibm4704: FEED:4704
-pc98: FEED:9898
-```
 
 Also see this.
 https://github.com/tmk/tmk_keyboard/issues/150
@@ -112,7 +62,6 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
 ```
 
 
-
 ## Cortex: cstddef: No such file or directory
 GCC 4.8 of Ubuntu 14.04 had this problem and had to update to 4.9 with this PPA.
 https://launchpad.net/~terry.guo/+archive/ubuntu/gcc-arm-embedded

docs/faq_keymap.md

@@ -1,10 +1,13 @@
-## READ FIRST
+# Frequently Asked Keymap Questions
-https://github.com/tmk/tmk_core/blob/master/doc/keymap.md
 
-## How to get keycode
+This page covers questions people often have about keymaps. If you haven't you should read [Keymap Overview](keymap.html) first.
-See [Keycodes](Keycodes). Keycodes are actually defined in [common/keycode.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keycode.h).
 
-## Sysrq key
+## What Keycodes Can I Use?
+See [Basic Keycodes](keycodes.html) and [Quantum Keycodes](quantum_keycodes.html) for most of the keys you can define.
+
+Keycodes are actually defined in [common/keycode.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keycode.h).
+
+## `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'.
 
 See [issue #168](https://github.com/tmk/tmk_keyboard/issues/168) and
@@ -16,7 +19,7 @@ Use `KC_PWR` instead of `KC_POWER` or vice versa.
 - `KC_PWR` works with Windows and Linux, not with OSX.
 - `KC_POWER` works with OSX and Linux, not with Windows.
 
-http://geekhack.org/index.php?topic=14290.msg1327264#msg1327264
+More info: http://geekhack.org/index.php?topic=14290.msg1327264#msg1327264
 
 ## Oneshot modifier
 Solves my personal 'the' problem. I often got 'the' or 'THe' wrongly instead of 'The'.  Oneshot Shift mitgates this for me.
@@ -32,15 +35,17 @@ For Modifier keys and layer actions you have to place `KC_TRANS` on same positio
 
 
 ## Mechanical Lock Switch Support
-https://github.com/tmk/tmk_keyboard#mechanical-locking-support
 
-This feature is for *mechanical lock switch* like this Alps one.
+This feature is for *mechanical lock switch* like [this Alps one](http://deskthority.net/wiki/Alps_SKCL_Lock). You can enable it by adding this to your `config.h`:
-http://deskthority.net/wiki/Alps_SKCL_Lock
  
-Using enabling this feature and using keycodes `LCAP`, `LNUM` or `LSCR` in keymap you can use physical locking CapsLock, NumLock or ScrollLock keys as you expected.
+```
+#define LOCKING_SUPPORT_ENABLE
+#define LOCKING_RESYNC_ENABLE
+```
 
-Old vintage mechanical keyboards occasionally have lock switches but modern ones don't have. ***You don't need this feature in most case and just use keycodes `CAPS`, `NLCK` and `SLCK`.***
+After enabling this feature use keycodes `KC_LCAP`, `KC_LNUM` and `KC_LSCR` in your keymap instead.
 
+Old vintage mechanical keyboards occasionally have lock switches but modern ones don't have. ***You don't need this feature in most case and just use keycodes `KC_CAPS`, `KC_NLCK` and `KC_SLCK`.***
 
 ## Input special charactors other than ASCII like Cédille 'Ç'
 NO UNIVERSAL METHOD TO INPUT THOSE WORKS OVER ALL SYSTEMS. You have to define **MACRO** in way specific to your OS or layout.
@@ -111,68 +116,12 @@ https://github.com/tekezo/Karabiner/issues/403
 
 ## Esc and `~ on a key
 
-You can define FC660 and Poker style ESC with `ACTION_LAYER_MODS`.
+Use `GRAVE_ESC` or `KC_GESC` in your keymap.
-https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#35-momentary-switching-with-modifiers
-
-```
-#include "keymap_common.h"
-
-
-/* Leopold FC660
- * https://elitekeyboards.com/products.php?sub=leopold,compact&pid=fc660c
- * Shift + Esc = ~
- * Fn    + Esc = `
- *
- * Votex Poker II
- * https://adprice.fedorapeople.org/poker2_manual.pdf
- * Fn         + Esc = `
- * Fn + Shift + Esc = ~
- */
-const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    /* 0: qwerty */
-    [0] = KEYMAP( \
-        ESC, 1,   2,   3,   4,   5,   6,   7,   8,   9,   0,   MINS,EQL, NUHS,BSPC, \
-        TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,BSLS, \
-        LCTL,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,ENT,  \
-        FN0, NUBS,Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,RSFT,ESC, \
-        LCTL,LGUI,LALT,          SPC,                     RALT,FN1, RGUI,RCTL),
-    [1] = KEYMAP( \
-        GRV, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,\
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \
-        TRNS,TRNS,TRNS,          TRNS,                    TRNS,TRNS,TRNS,TRNS),
-    [2] = KEYMAP( \
-        GRV, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12, TRNS,TRNS, \
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,\
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \
-        TRNS,TRNS,TRNS,          TRNS,                    TRNS,TRNS,TRNS,TRNS),
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-    // https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#35-momentary-switching-with-modifiers
-    [0] = ACTION_LAYER_MODS(1, MOD_LSFT),
-    [1] = ACTION_LAYER_MOMENTARY(2),
-};
-```
-
-Otherwise, you can write code, see this.
-https://github.com/p3lim/keyboard_firmware/commit/fd799c12b69a5ab5addd1d4c03380a1b8ef8e9dc
-
-
-## 32 Fn keys are not enough?
-### actionmap
-It uses 16 bit codes and has no limitation of 32 Fn at the expense of memory space. TMK keymap is actually is 8 bit codes as subset of the actionmap.
-https://github.com/tmk/tmk_keyboard/issues?utf8=%E2%9C%93&q=is%3Aissue+actionmap
-
-### extension for modified keys
-https://geekhack.org/index.php?topic=41989.msg1885526#msg1885526
-
 
 ## Arrow on Right Modifier keys with Dual-Role
 This turns right modifer keys into arrow keys when the keys are tapped while still modifiers when the keys are hold. In TMK the dual-role function is dubbed **TAP**.
 ```
+
 #include "keymap_common.h"
 
 
@@ -211,18 +160,16 @@ const uint16_t PROGMEM fn_actions[] = {
 
 ```
 
-
 Dual-role key: https://en.wikipedia.org/wiki/Modifier_key#Dual-role_keys
 
 
 ## Eject on Mac OSX
-`EJCT` keycode works on OSX. https://github.com/tmk/tmk_keyboard/issues/250
+`KC_EJCT` keycode works on OSX. https://github.com/tmk/tmk_keyboard/issues/250
 It seems Windows 10 ignores the code and Linux/Xorg recognizes but has no mapping by default.
 
 Not sure what keycode Eject is on genuine Apple keyboard actually. HHKB uses `F20` for Eject key(`Fn+f`) on Mac mode but this is not same as Apple Eject keycode probably.
 
 
-
 ## What's weak_mods and real_mods in action_util.c
 ___TO BE IMPROVED___
 
@@ -262,4 +209,3 @@ if (timer_elapsed(key_timer) < 100) {
 ```
 
 It's best to declare the `static uint16_t key_timer;` at the top of the file, outside of any code blocks you're using it in.
-

docs/glossary.md

@@ -1,10 +1,29 @@
 # Glossary of QMK terms
 
-git
+## Dynamic Macro
-: versioning software used at the commandline
+A macro which has been recorded on the keyboard and which will be lost when the keyboard is unplugged or the computer rebooted.
 
-keymap
+## git
-: an array of keycodes mapped to a physical keyboard layout, which are processed on key presses and releases
+Versioning software used at the commandline
 
-matrix
+## Keycode
-: a wiring pattern of columns and rows (and usually diodes) that enables the MCU to detect keypresses with a fewer number of pins
+A 2-byte number that represents a particular key. `0x00`-`0xFF` are used for [Basic Keycodes](keycodes.html) while `0x100`-`0xFFFF` are used for [Quantum Keycodes](quantum_keycodes.html).
+
+## Keymap
+An array of keycodes mapped to a physical keyboard layout, which are processed on key presses and releases
+
+## Matrix
+A wiring pattern of columns and rows (and usually diodes) that enables the MCU to detect keypresses with a fewer number of pins
+
+## Macro
+A feature that lets you send muiltple keypress events (hid reports) after having pressed only a single key.
+
+## Mousekeys
+A feature that lets you control your mouse cursor and click from your keyboard.
+
+* [Mousekeys Documentation](mouse_keys.html)
+
+## 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.html)

docs/key_functions.md

@@ -2,20 +2,18 @@
 
 Your keymap can include shortcuts to common operations (called "function actions" in tmk).
 
-These functions work the same way that their `ACTION_*` functions do - they're just quick aliases. To dig into all of the tmk `ACTION_*` functions, please see the [TMK documentation](keymap.md#2-action).
+These functions work the same way that their `ACTION_*` functions do - they're just quick aliases. To dig into all of the qmk `ACTION_*` functions, please see the [Keymap documentation](keymap.md#2-action).
 
 Instead of using `FNx` when defining `ACTION_*` functions, you can use `F(x)` - the benefit here is being able to use more than 32 function actions (up to 4096), if you happen to need them.
 
-### Limits of these aliases
+## Limits of these aliases
 
-Currently, the keycodes able to used with these functions are limited to the TMK ones, 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 this list](keycode.txt).
+Currently, the keycodes able to used with these functions are limited to the [Basic Keycodes](keycodes.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 this list](keycodes.html).
 
-### Switching and toggling layers
+# Switching and toggling layers
 
 `MO(layer)` - momentary switch to *layer*. As soon as you let go of the key, the layer is deactivated and you pop back out to the previous layer. When you apply this to a key, that same key must be set as `KC_TRNS` on the destination layer. Otherwise, you won't make it back to the original layer when you release the key (and you'll get a keycode sent). You can only switch to layers *above* your current layer. If you're on layer 0 and you use `MO(1)`, that will switch to layer 1 just fine. But if you include `MO(3)` on layer 5, that won't do anything for you -- because layer 3 is lower than layer 5 on the stack.
 
-`OSL(layer)` - momentary switch to *layer*, as a one-shot operation. So if you have a key that's defined as `OSL(1)`, and you tap that key, then only the very next keystroke would come from layer 1. You would drop back to layer zero immediately after that one keystroke. That's handy if you have a layer full of custom shortcuts -- for example, a dedicated key for closing a window. So you tap your one-shot layer mod, then tap that magic 'close window' key, and keep typing like a boss. Layer 1 would remain active as long as you hold that key down, too (so you can use it like a momentary toggle-layer key with extra powers).
-
 `LT(layer, kc)` - momentary switch to *layer* when held, and *kc* when tapped. Like `MO()`, this only works upwards in the layer stack (`layer` must be higher than the current layer).
 
 `TG(layer)` - toggles a layer on or off. As with `MO()`, you should set this key as `KC_TRNS` in the destination layer so that tapping it again actually toggles back to the original layer. Only works upwards in the layer stack.
@@ -25,7 +23,7 @@ Currently, the keycodes able to used with these functions are limited to the TMK
 `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 1` for just one tap.
 
 
-### Fun with modifier keys
+# Modifier keys
 
 * `LSFT(kc)` - applies left Shift to *kc* (keycode) - `S(kc)` is an alias
 * `RSFT(kc)` - applies right Shift to *kc*
@@ -43,6 +41,8 @@ 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
+
 The following shortcuts automatically add `LSFT()` to keycodes to get commonly used symbols. Their long names are also available and documented in `quantum/quantum_keycodes.h`.
 
     KC_TILD  ~
@@ -67,8 +67,15 @@ The following shortcuts automatically add `LSFT()` to keycodes to get commonly u
     KC_PIPE  |
     KC_COLN  :
 
+# One Shot 
+
 `OSM(mod)` - this is a "one shot" modifier. So let's say you have your left Shift key defined as `OSM(MOD_LSFT)`. Tap it, let go, and Shift is "on" -- but only for the next character you'll type. So to write "The", you don't need to hold down Shift -- you tap it, tap t, and move on with life. And if you hold down the left Shift key, it just works as a left Shift key, as you would expect (so you could type THE). There's also a magical, secret way to "lock" a modifier by tapping it multiple times. If you want to learn more about that, open an issue. :)
 
+`OSL(layer)` - momentary switch to *layer*, as a one-shot operation. So if you have a key that's defined as `OSL(1)`, and you tap that key, then only the very next keystroke would come from layer 1. You would drop back to layer zero immediately after that one keystroke. That's handy if you have a layer full of custom shortcuts -- for example, a dedicated key for closing a window. So you tap your one-shot layer mod, then tap that magic 'close window' key, and keep typing like a boss. Layer 1 would remain active as long as you hold that key down, too (so you can use it like a momentary toggle-layer key with extra powers).
+
+
+# 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.
 
 These are the values you can use for the `mod` in `MT()` and `OSM()`:
@@ -97,7 +104,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.
 
-##### Permissive Hold
+# Permissive Hold
 
 As of [PR#1359](https://github.com/qmk/qmk_firmware/pull/1359/), there is a new `config.h` option:
 

docs/macros.md

@@ -1,8 +1,10 @@
-# Macros - Send multiple keystrokes when pressing just one key
+# Macros
 
-QMK has a number of ways to define and use macros. These can do anything you want- type common phrases for you, copypasta, repetitive game movements, or even help you code. 
+Macros allow you to send multiple keystrokes when pressing just one key. QMK has a number of ways to define and use macros. These can do anything you want- type common phrases for you, copypasta, repetitive game movements, or even help you code. 
 
+{% hint style='danger' %}
 **Security Note**: While it is possible to use macros to send passwords, credit card numbers, and other sensitive information it is a supremely bad idea to do so. Anyone who gets ahold of your keyboard will be able to access that information by opening a text editor.
+{% endhint %}
 
 # Macro Definitions
 
@@ -135,7 +137,7 @@ This will clear all mods currently pressed.
 
 This will clear all keys besides the mods currently pressed.
 
-# Advanced Example: Single-key copy/paste (hold to copy, tap to paste)
+# Advanced Example: Single-key copy/paste
 
 This example defines a macro which sends `Ctrl-C` when pressed down, and `Ctrl-V` when released. 
 

docs/make_instructions.md

@@ -48,7 +48,7 @@ Here are some examples commands
 * `make ergodox-infinity-algernon-clean` will clean the build output of the Ergodox Infinity keyboard. This example uses the full syntax and can be run from any folder with a `Makefile`
 * `make dfu COLOR=false` from within a keymap folder, builds and uploads the keymap, but without color output.
 
-## The `Makefile`
+# The `Makefile`
 
 There are 5 different `make` and `Makefile` locations:
 
@@ -62,7 +62,7 @@ The root contains the code used to automatically figure out which keymap or keym
 
 For keyboards and subprojects, the make files are split in two parts `Makefile` and `rules.mk`. All settings can be found in the `rules.mk` file, while the `Makefile` is just there for support and including the root `Makefile`. Keymaps contain just one `Makefile` for simplicity.
 
-### Makefile options
+## Makefile options
 
 Set these variables to `no` to disable them, and `yes` to enable them.
 
@@ -158,7 +158,7 @@ This enables using the Quantum SYSEX API to send strings (somewhere?)
 
 This consumes about 5390 bytes.
 
-### Customizing Makefile options on a per-keymap basis
+## Customizing Makefile options on a per-keymap basis
 
 If your keymap directory has a file called `Makefile` (note the filename), any Makefile options you set in that file will take precedence over other Makefile options for your particular keyboard.
 

docs/quantum_keycodes.md

@@ -4,7 +4,7 @@ All keycodes within quantum are numbers between `0x0000` and `0xFFFF`. Within yo
 
 On this page we have documented keycodes between `0x00FF` and `0xFFFF` which are used to implement advanced quantum features. If you define your own custom keycodes they will be put into this range as well. Keycodes above `0x00FF` may not be used with any of the mod/layer-tap keys listed 
 
-# Quantum keycodes
+## QMK keycodes
 
 |Name|Description|
 |----|-----------|
@@ -18,7 +18,7 @@ On this page we have documented keycodes between `0x00FF` and `0xFFFF` which are
 |`M(n)`|to call macro n|
 |`MACROTAP(n)`|to macro-tap n idk FIXME|
 
-# Bootmagic Keycodes
+## Bootmagic Keycodes
 
 Shortcuts for bootmagic options (these work even when bootmagic is off.)
 
@@ -44,7 +44,7 @@ Shortcuts for bootmagic options (these work even when bootmagic is off.)
 |`MAGIC_UNSWAP_ALT_GUI`/`AG_NORM`|Disable the Alt/GUI switching|
 |`MAGIC_TOGGLE_NKRO`|Turn NKRO on or off|
 
-# Audio
+## Audio
 
 ```c
 #ifdef AUDIO_ENABLE
@@ -69,7 +69,7 @@ Shortcuts for bootmagic options (these work even when bootmagic is off.)
 #endif
 ```
 
-## Midi
+### Midi
 
 #if !MIDI_ENABLE_STRICT || (defined(MIDI_ENABLE) && defined(MIDI_BASIC))
     MI_ON,  // send midi notes when music mode is enabled
@@ -157,7 +157,7 @@ MI_MODSD, // decrease modulation speed
 MI_MODSU, // increase modulation speed
 #endif // MIDI_ADVANCED
 
-# Backlight
+## Backlight
 
 These keycodes control the backlight. Most keyboards use this for single color in-switch lighting.
 
@@ -171,7 +171,7 @@ These keycodes control the backlight. Most keyboards use this for single color i
 |`BL_TOGG`|Toggle the backlight on or off|
 |`BL_STEP`|Step through backlight levels, wrapping around to 0 when you reach the top.|
 
-# RGBLIGHT WS2818 LEDs
+## RGBLIGHT WS2818 LEDs
 
 This controls the `RGBLIGHT` functionality. Most keyboards use WS2812 (and compatible) LEDs for underlight or case lighting.
 
@@ -203,7 +203,7 @@ This is used when multiple keyboard outputs can be selected. Currently this only
 |`OUT_USB`|usb only|
 |`OUT_BT`|bluetooth (when `BLUETOOTH_ENABLE`)|
 
-# Modifiers
+## Modifiers
 
 These are special keycodes that simulate pressing several modifiers at once.
 
@@ -219,7 +219,7 @@ These are special keycodes that simulate pressing several modifiers at once.
  * |`KC_LCA`|`LCTL` + `LALT`|
  */
 
-## Modifiers with keys
+### Modifiers with keys
 
 |Name|Description|
 |----|-----------|
@@ -238,7 +238,7 @@ These are special keycodes that simulate pressing several modifiers at once.
 |`SCMD(kc)`/`SWIN(kc)`|`LGUI` + `LSFT` + `kc`|
 |`LCA(kc)`|`LCTL` + `LALT` + `kc`|
 
-## One Shot Keys
+### One Shot Keys
 
 Most modifiers work by being held down while you push another key. You can use `OSM()` to setup a "One Shot" modifier. When you tap a one shot mod it will remain is a pressed state until you press another key. 
 
@@ -249,7 +249,7 @@ To specify a your modifier you need to pass the `MOD` form of the key. For examp
 |`OSM(mod)`|use mod for one keypress|
 |`OSL(layer)`|switch to layer for one keypress|
 
-## Mod-tap keys
+### Mod-tap keys
 
 These keycodes will press the mod(s) when held, and the key when tapped. They only work with [basic keycodes](basic_keycodes.md). 
 
@@ -271,7 +271,7 @@ These keycodes will press the mod(s) when held, and the key when tapped. They on
 |`SCMD_T(kc)`/`SWIN_T(kc)`|`LGUI` + `LSFT` when held, `kc` when tapped|
 |`LCA_T(kc)`|`LCTL` + `LALT` when held, `kc` when tapped|
 
-# US ANSI Shifted symbols
+## US ANSI Shifted symbols
 
 These keycodes correspond to characters that are "shifted" on a standard US ANSI keyboards. They do not have dedicated keycodes but are instead typed by holding down shift and then sending a keycode. 
 
@@ -301,7 +301,7 @@ It's important to remember that all of these keycodes send a left shift - this m
 |`KC_QUES`|`KC_QUESTION`|question mark `?`|
 |`KC_DQT`/`KC_DQUO`|`KC_DOUBLE_QUOTE`|double quote `"`|
 
-# Layer Changes
+## Layer Changes
 
 These are keycodes that can be used to change the current layer.
 
@@ -315,7 +315,7 @@ These are keycodes that can be used to change the current layer.
 |`TT(layer)`|tap toggle? idk FIXME|
 |`OSL(layer)`|switch to layer for one keycode|
 
-# Unicode
+## Unicode
 
 These keycodes can be used in conjuction with the [Unicode](unicode_and_additional_language_support.md) support.
 

docs/tap_dance.md

@@ -1,5 +1,7 @@
 # Tap Dance: A single key can do 3, 5, or 100 different things
 
+<!-- FIXME: Break this up into multiple sections -->
+
 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. It's one of the nicest community-contributed features in the firmware, conceived and created by [algernon](https://github.com/algernon) in [#451](https://github.com/qmk/qmk_firmware/pull/451). Here's how algernon describes the feature:
 
 With this feature one can specify keys that behave differently, based on the amount of times they have been tapped, and when interrupted, they get handled before the interrupter.
@@ -34,7 +36,9 @@ Our next stop is `matrix_scan_tap_dance()`. This handles the timeout of tap-danc
 
 For the sake of flexibility, tap-dance actions can be either a pair of keycodes, or a user function. The latter allows one to handle higher tap counts, or do extra things, like blink the LEDs, fiddle with the backlighting, and so on. This is accomplished by using an union, and some clever macros.
 
-### Examples
+# Examples
+
+## Simple Example
 
 Here's a simple example for a single definition:
 
@@ -59,6 +63,8 @@ qk_tap_dance_action_t tap_dance_actions[] = {
 TD(TD_ESC_CAPS)
 ```
 
+## Complex Example
+
 Here's a more complex example involving custom actions:
 
 ```c

docs/understanding_qmk.md

@@ -1,7 +1,5 @@
 # Understanding QMK's Code
 
-<!-- toc -->
-
 This document attempts to explain how the QMK firmware works from a very high level. It assumes you understand basic programming concepts but does not (except where needed to demonstrate) assume familiarity with C. It assumes that you have a basic understanding of the following documents:
 
 * [QMK Overview](qmk_overview.md)
@@ -12,45 +10,27 @@ This document attempts to explain how the QMK firmware works from a very high le
 
 You can think of QMK as no different from any other computer program. It is started, performs its tasks, and then ends. The entry point for the program is the `main()` function, just like it is on any other C program. However, for a newcomer to QMK it can be confusing because the `main()` function appears in multiple places, and it can be hard to tell which one to look at.
 
-The reason for this is the different platforms that QMK supports. The most common platform is `lufa`, which runs on AVR processors such at the atmega32u4. We also support `chibios`, `pjrc`, `vusb`, and `bluefruit`, and may support more in the future.
+The reason for this is the different platforms that QMK supports. The most common platform is `lufa`, which runs on AVR processors such at the atmega32u4. We also support `chibios` and `vusb`.
 
-Let's focus on AVR processors for the moment, which use the `lufa` platform. You can find the `main()` function in [tmk_core/protocol/lufa/lufa.c](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/protocol/lufa/lufa.c#L1129). If you browse through that function you'll find that it initializes any hardware that has been configured (including USB to the host) and then it starts the core part of the program with a [`while(1)`](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/protocol/lufa/lufa.c#L1182). This is [The Main Loop](#the_main_loop).
+We'll focus on AVR processors for the moment, which use the `lufa` platform. You can find the `main()` function in [tmk_core/protocol/lufa/lufa.c](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/protocol/lufa/lufa.c#L1129). If you browse through that function you'll find that it initializes any hardware that has been configured (including USB to the host) and then it starts the core part of the program with a [`while(1)`](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/protocol/lufa/lufa.c#L1182). This is [The Main Loop](#the_main_loop).
 
 ## The Main Loop
 
-This section of code is called "The Main Loop" because it's responsible for looping over the same set of instructions forever. This is where QMK dispatches out to the functions responsible for making the keyboard do everything it is supposed to. At first glance it can look like a lot of functionality but most of the time the code will be disabled by `#define`'s.
+This section of code is called "The Main Loop" because it's responsible for looping over the same set of instructions forever. This is where QMK dispatches out to the functions responsible for making the keyboard do everything it is supposed to do. At first glance it can look like a lot of functionality but most of the time the code will be disabled by `#define`'s.
-
-### USB Suspend
-
-```
-    #if !defined(NO_USB_STARTUP_CHECK)
-    while (USB_DeviceState == DEVICE_STATE_Suspended) {
-        print("[s]");
-        suspend_power_down();
-        if (USB_Device_RemoteWakeupEnabled && suspend_wakeup_condition()) {
-                USB_Device_SendRemoteWakeup();
-        }
-    }
-    #endif
-```
-
-This section of code handles the USB suspend state. This state is entered when the computer the keyboard is plugged into is suspended. In this state we don't do anything but wait for the computer we're plugged into to wake up.
-
-### `keyboard_task()`
 
 ```
     keyboard_task();
 ```
 
-This is where all the keyboard specific functionality is dispatched. The source code for `keyboard_task()` can be found in [tmk_core/common/keyboard.c](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keyboard.c#L154), and it is responsible for detecting changes in the matrix and turning LED's on and off.
+This is where all the keyboard specific functionality is dispatched. The source code for `keyboard_task()` can be found in [tmk_core/common/keyboard.c](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keyboard.c#L154), and it is responsible for detecting changes in the matrix and turning status LED's on and off.
 
 Within `keyboard_task()` you'll find code to handle:
 
-* Matrix Scanning
+* [Matrix Scanning](#matrix-scanning)
 * Mouse Handling
 * Serial Link(s)
 * Visualizer
-* Keyboard state LED's (Caps Lock, Num Lock, Scroll Lock)
+* Keyboard status LED's (Caps Lock, Num Lock, Scroll Lock)
 
 #### Matrix Scanning
 
@@ -60,18 +40,18 @@ While there are different strategies for doing the actual matrix detection, they
 
 
 ```
-    {
+{
     {0,0,0,0},
     {0,0,0,0},
     {0,0,0,0},
     {0,0,0,0},
     {0,0,0,0}
-    }
+}
 ```
 
 That datastructure is a direct representation of the matrix for a 4 row by 5 column numpad. When a key is pressed that key's position within the matrix will be returned as `1` instead of `0`.
 
-Matrix Scanning runs many times per second. The exact rate varies but typically it runs at least 10 times per second to avoid perceptable lag.
+Matrix Scanning runs many times per second. The exact rate varies but typically it runs at least 10 times per second to avoid perceptible lag.
 
 ##### Matrix to Physical Layout Map
 
@@ -114,67 +94,65 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 }
 ```
 
-Notice how all of these arguments match up with the first half of the `KEYMAP()` macro from the last section? This is basically where we take a keycode and map it to our Matrix Scan from earlier. 
+Notice how all of these arguments match up with the first half of the `KEYMAP()` macro from the last section? This is how we take a keycode and map it to our Matrix Scan from earlier. 
 
 ##### State Change Detection
 
 The matrix scanning described above tells us the state of the matrix at a given moment, but your computer only wants to know about changes, it doesn't care about the current state. QMK stores the results from the last matrix scan and compares the results from this matrix to determine when a key has been pressed or released. 
 
-Let's look at an example. We'll hop into the middle of a keyboard scanning look to find that our previous scan looks like this:
+Let's look at an example. We'll hop into the middle of a keyboard scanning loop to find that our previous scan looks like this:
 
 ```
-    {
+{
     {0,0,0,0},
     {0,0,0,0},
     {0,0,0,0},
     {0,0,0,0},
     {0,0,0,0}
-    }
+}
 ```
 
 And when our current scan completes it will look like this:
 
 ```
-    {
+{
     {1,0,0,0},
     {0,0,0,0},
     {0,0,0,0},
     {0,0,0,0},
     {0,0,0,0}
-    }
+}
 ```
 
 Comparing against our keymap we can see that the pressed key is KC_NLCK. From here we dispatch to the `process_record` set of functions.
 
-(FIXME: Feels like this section could be fleshed out more.)
+<!-- FIXME: Magic happens between here and process_record -->
-
-(FIXME: Magic happens between here and process_record)
 
 ##### Process Record
 
-The `process_record()` function itself is deceptively simple, but hidden within is a gateway to overriding functionality at various levels of QMK. The chain of events looks something like this:
+The `process_record()` function itself is deceptively simple, but hidden within is a gateway to overriding functionality at various levels of QMK. The chain of events is described below, using cluecard whenever we need to look at the keyboard/keymap level functions.
 
-* `void process_record(keyrecord_t *record)`
+* [`void process_record(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action.c#L128)
-  * `bool process_record_quantum(keyrecord_t *record)`
+  * [`bool process_record_quantum(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L140)
-    * Map this record to a keycode
+    * [Map this record to a keycode](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L143)
-    * `bool process_record_kb(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_record_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/cluecard.c#L20)
-      * `bool process_record_user(uint16_t keycode, keyrecord_t *record)`
+      * [`bool process_record_user(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/keymaps/default/keymap.c#L58)
-    * `bool process_midi(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_midi(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_midi.c#L102)
-    * `bool process_audio(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_audio(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_audio.c#L10)
-    * `bool process_music(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_music(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_music.c#L69)
-    * `bool process_tap_dance(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_tap_dance(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_tap_dance.c#L75)
-    * `bool process_leader(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_leader(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_leader.c#L32)
-    * `bool process_chording(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_chording(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_chording.c#L41)
-    * `bool process_combo(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_combo(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_combo.c#L115)
-    * `bool process_unicode(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_unicode(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_unicode.c#L22)
-    * `bool process_ucis(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_ucis(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_ucis.c#L91)
-    * `bool process_printer(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_printer(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_printer.c#L77)
-    * `bool process_unicode_map(uint16_t keycode, keyrecord_t *record)`
+    * [`bool process_unicode_map(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_unicodemap.c#L47)
-    * Identify and process quantum specific keycodes
+    * [Identify and process quantum specific keycodes](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L211)
-  * Identify and process standard keycodes
   
-At any step during this chain of events a function (such as `process_record_kb()`) can `return false` and processing of that keypress will end immediately.
+At any step during this chain of events a function (such as `process_record_kb()`) can `return false` to halt all further processing.
 
+<!--
 #### Mouse Handling
 
 FIXME: This needs to be written
@@ -190,3 +168,5 @@ FIXME: This needs to be written
 #### Keyboard state LED's (Caps Lock, Num Lock, Scroll Lock)
 
 FIXME: This needs to be written
+
+-->