add keys

.clang-format

@@ -1,26 +0,0 @@
----
-BasedOnStyle: Google
-AlignAfterOpenBracket: Align
-AlignConsecutiveAssignments: 'true'
-AlignConsecutiveDeclarations: 'true'
-AlignOperands: 'true'
-AllowAllParametersOfDeclarationOnNextLine: 'false'
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: 'false'
-BinPackArguments: 'true'
-BinPackParameters: 'true'
-ColumnLimit: '1000'
-IndentCaseLabels: 'true'
-IndentPPDirectives: AfterHash
-IndentWidth: '4'
-MaxEmptyLinesToKeep: '1'
-PointerAlignment: Right
-SortIncludes: 'false'
-SpaceBeforeAssignmentOperators: 'true'
-SpaceBeforeParens: ControlStatements
-SpaceInEmptyParentheses: 'false'
-TabWidth: '4'
-UseTab: Never
-
-...

.editorconfig

@@ -5,7 +5,7 @@ root = true
 
 [*]
 indent_style = space
-indent_size = 4
+indent_size = 2
 
 # We recommend you to keep these unchanged
 charset = utf-8
@@ -16,18 +16,12 @@ insert_final_newline = true
 trim_trailing_whitespace = false
 indent_size = 4
 
-[{qmk,*.py}]
-charset = utf-8
-max_line_length = 200
-
 # Make these match what we have in .gitattributes
 [*.mk]
 end_of_line = lf
-indent_style = tab
 
 [Makefile]
 end_of_line = lf
-indent_style = tab
 
 [*.sh]
 end_of_line = lf

.github/ISSUE_TEMPLATE/blank.md

@@ -1,5 +0,0 @@
----
-name: Blank issue
-about: If you're 100% sure that you don't need one of the other issue templates, use this one instead. 
-
----

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,32 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve the QMK Firmware
----
-<!-- Provide a general summary of the bug in the title above. -->
-
-<!--- This template is entirely optional and can be removed, but is here to help both you and us. -->
-<!--- Anything on lines wrapped in comments like these will not show up in the final text. -->
-
-## Describe the Bug
-
-<!-- A clear and concise description of what the bug is. -->
-
-## System Information
-
- - Keyboard:  
-   - Revision (if applicable):  
- - Operating system:
- - AVR GCC version: 
-<!-- Run `avr-gcc --version` to find this out. -->
- - ARM GCC version: 
-<!-- Run `arm-none-eabi-gcc --version` to find this out. -->
- - QMK Firmware version:
-<!-- Run `git describe --abbrev=0 --tags` to find this out. -->
- - Any keyboard related software installed? 
-   - [ ] AutoHotKey
-   - [ ] Karabiner
-   - [ ] Other:
-
-## Additional Context
-
-<!-- Add any other relevant information about the problem here. -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,19 +0,0 @@
----
-name: Feature request
-about: Suggest a new feature or changes to existing features 
----
-<!--- Provide a general summary of the changes you want in the title above. -->
-
-<!--- This template is entirely optional and can be removed, but is here to help both you and us. -->
-<!--- Anything on lines wrapped in comments like these will not show up in the final text. -->
-
-## Feature Request Type
-
-- [ ] Core functionality
-- [ ] Add-on hardware support (eg. audio, RGB, OLED screen, etc.)
-- [ ] Alteration (enhancement/optimization) of existing feature(s)
-- [ ] New behavior
-
-## Description
-
-<!-- A few sentences describing what it is that you'd like to see in QMK. Additional information (such as links to spec sheets, licensing info, other related issues or PRs, etc) would be helpful. -->

.github/ISSUE_TEMPLATE/other_issues.md

@@ -1,9 +0,0 @@
----
-name: Other issues
-about: Anything else that doesn't fall into the above categories. 
----
-<!--- Provide a general summary of the changes you want in the title above. -->
-
-<!--- Anything on lines wrapped in comments like these will not show up in the final text. -->
-
-<!-- Please check https://docs.qmk.fm/#/support for additional resources first. If that doesn't answer your question, choose the bug report template instead, as that may be more appropriate. -->

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,34 +0,0 @@
-<!--- Provide a general summary of your changes in the title above. -->
-
-<!--- This template is entirely optional and can be removed, but is here to help both you and us. -->
-<!--- Anything on lines wrapped in comments like these will not show up in the final text. -->
-
-## Description
-
-<!--- Describe your changes in detail here. -->
-
-## Types of Changes
-
-<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply. -->
-- [ ] Core
-- [ ] Bugfix
-- [ ] New feature
-- [ ] Enhancement/optimization
-- [ ] Keyboard (addition or update)
-- [ ] Keymap/layout/userspace (addition or update)
-- [ ] Documentation
-
-## Issues Fixed or Closed by This PR
-
-* 
-
-## Checklist
-
-<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
-<!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
-- [ ] My code follows the code style of this project.
-- [ ] My change requires a change to the documentation.
-- [ ] I have updated the documentation accordingly.
-- [ ] I have read the [**CONTRIBUTING** document](https://docs.qmk.fm/#/contributing).
-- [ ] I have added tests to cover my changes.
-- [ ] I have tested the changes and verified that they work and don't break anything (as well as I can manage).

.gitignore

@@ -1,4 +1,3 @@
-.history/
 .dep
 *.o
 *.bin
@@ -54,7 +53,6 @@ util/Win_Check_Output.txt
 .vscode/tasks.json
 .vscode/last.sql
 .vscode/temp.sql
-.vscode/ipch/
 .stfolder
 .tags
 
@@ -70,6 +68,3 @@ util/Win_Check_Output.txt
 secrets.tar
 id_rsa_*
 /.vs
-
-# python things
-__pycache__

.gitmodules

@@ -11,6 +11,3 @@
 [submodule "lib/googletest"]
 	path = lib/googletest
 	url = https://github.com/google/googletest
-[submodule "lib/lufa"]
-	path = lib/lufa
-	url = https://github.com/qmk/lufa

.travis.yml

@@ -10,24 +10,30 @@ branches:
 env:
   global:
   - secure: vBTSL34BDPxDilKUuTXqU4CJ26Pv5hogD2nghatkxSQkI1/jbdnLj/DQdPUrMJFDIY6TK3AltsBx72MaMsLQ1JO/Ou24IeHINHXzUC1FlS9yQa48cpxnhX5kzXNyGs3oa0qaFbvnr7RgYRWtmD52n4bIZuSuW+xpBv05x2OCizdT2ZonH33nATaHGFasxROm4qYZ241VfzcUv766V6RVHgL4x9V08warugs+RENVkfzxxwhk3NmkrISabze0gSVJLHBPHxroZC6EUcf/ocobcuDrCwFqtEt90i7pNIAFUE7gZsN2uE75LmpzAWin21G7lLPcPL2k4FJVd8an1HiP2WmscJU6U89fOfMb2viObnKcCzebozBCmKGtHEuXZo9FcReOx49AnQSpmESJGs+q2dL/FApkTjQiyT4J6O5dJpoww0/r57Wx0cmmqjETKBb5rSgXM51Etk3wO09mvcPHsEwrT7qH8r9XWdyCDoEn7FCLX3/LYnf/D4SmZ633YPl5gv3v9XEwxR5+04akjgnvWDSNIaDbWBdxHNb7l4pMc+WR1bwCyMyA7KXj0RrftEGOrm9ZRLe6BkbT4cycA+j77nbPOMcyZChliV9pPQos+4TOJoTzcK2L8yWVoY409aDNVuAjdP6Yum0R2maBGl/etLmIMpJC35C5/lZ+dUNjJAM=
-  - MAKEFLAGS="-j3 --output-sync"
-services:
-  - docker
+before_install:
+  - wget http://ww1.microchip.com/downloads/en/DeviceDoc/avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz || wget http://qmk.fm/avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz
 install:
+  - tar -zxf avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz
+  - export PATH="$PATH:$TRAVIS_BUILD_DIR/avr8-gnu-toolchain-linux_x86_64/bin"
   - npm install -g moxygen
+before_script:
+  - avr-gcc --version
 script:
-  - git rev-parse --short HEAD
-  - bash util/travis_test.sh
-  - bash util/travis_build.sh
-  - bash util/travis_docs.sh
+- make test:all AUTOGEN=false
+- bash util/travis_build.sh
+- bash util/travis_docs.sh
 addons:
   apt:
     packages:
+    - dfu-programmer
     - pandoc
+    - gcc-arm-none-eabi
+    - binutils-arm-none-eabi
+    - libnewlib-arm-none-eabi
     - diffutils
     - dos2unix
     - doxygen
-after_script:
+after_success: 
   bash util/travis_compiled_push.sh
 notifications:
   webhooks:

.vscode/extensions.json

@@ -1,11 +1,6 @@
 // Suggested extensions
 {
   "recommendations": [
-    "EditorConfig.EditorConfig",
-    "xaver.clang-format",
-    "ms-vscode.cpptools",
-    "bierner.github-markdown-preview",
-    "donjayamanne.git-extension-pack",
-    "CoenraadS.bracket-pair-colorizer-2"
+    "EditorConfig.EditorConfig"
   ]
 }

.vscode/settings.json

@@ -8,12 +8,10 @@
         "**/*.hex": true
     },
     "files.associations": {
-      "*.h": "c",
-      "*.c": "c",
-      "*.cpp": "cpp",
-      "*.hpp": "cpp",
-      "xstddef": "c",
-      "type_traits": "c",
-      "utility": "c"
+        "*.h": "c",
+        "*.c": "c",
+        "*.cpp": "cpp",
+        "*.hpp": "cpp",
+        "xstddef": "c"
     }
 }

CODE_OF_CONDUCT.md

@@ -8,17 +8,8 @@ Our users, contributors, and collaborators are expected to treat each other with
 
 * The use of sexualized language or imagery
 * Unwelcome advances, sexual or otherwise
-* Deliberate intimidation, stalking, or following
 * Insults or derogatory comments, or personal or political attacks
 * Publishing others’ private information without explicit permission
-* Sustained disruption of talks or other events
 * Other conduct which could reasonably be considered inappropriate in a professional setting
-* Advocating for, or encouraging, any of the above behaviour
 
-# Reporting
-
-If someone is violating this Code of Conduct, please email hello@qmk.fm or reach out to one of the Collaborators to bring it to our attention. All complaints will be reviewed and investigated.
-
-QMK will seek to use the least punitive means available to resolve an issue. If the circumstances require asking an offender to leave, we will do that.
-
-Reports will be taken and kept in strict confidence. You will not be required to confront an offender directly.
+If someone is violating this Code of Conduct you may email hello@qmk.fm to bring your concern to the Members. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. 

Dockerfile

@@ -1,7 +1,28 @@
-FROM qmkfm/base_container
+FROM debian:jessie
+MAINTAINER Erik Dasque <erik@frenchguys.com>
 
-VOLUME /qmk_firmware
-WORKDIR /qmk_firmware
-COPY . .
+RUN apt-get update && apt-get install --no-install-recommends -y build-essential \
+    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 \
+    git \
+    software-properties-common \
+    avrdude \
+    && rm -rf /var/lib/apt/lists/*
 
-CMD make all:default
+ENV keyboard=ergodox
+ENV subproject=ez
+ENV keymap=default
+
+VOLUME /qmk
+WORKDIR /qmk
+CMD make clean ; make keyboard=${keyboard} subproject=${subproject} keymap=${keymap}

Makefile

@@ -20,10 +20,7 @@ endif
 override SILENT := false
 
 ifndef SUB_IS_SILENT
-ifndef SKIP_GIT
-    QMK_VERSION := $(shell git describe --abbrev=0 --tags 2>/dev/null)
-endif
-
+QMK_VERSION := $(shell git describe --abbrev=0 --tags 2>/dev/null)
 ifneq ($(QMK_VERSION),)
 $(info QMK Firmware $(QMK_VERSION))
 endif
@@ -97,7 +94,6 @@ $(eval $(call NEXT_PATH_ELEMENT))
 # endif
 
 define GET_KEYBOARDS
-ifndef ALT_GET_KEYBOARDS
     All_RULES_MK := $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/rules.mk))
     All_RULES_MK += $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/*/rules.mk))
     All_RULES_MK += $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/*/*/rules.mk))
@@ -109,9 +105,6 @@ ifndef ALT_GET_KEYBOARDS
     KEYMAPS_MK += $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/*/*/*/keymaps/*/rules.mk))
 
     KEYBOARDS := $$(sort $$(filter-out $$(KEYMAPS_MK), $$(All_RULES_MK)))
-else
-    KEYBOARDS := $(shell find keyboards/ -type f -iname "rules.mk" | grep -v keymaps | sed 's!keyboards/\(.*\)/rules.mk!\1!' | sort | uniq)
-endif
 endef
 
 $(eval $(call GET_KEYBOARDS))
@@ -119,29 +112,23 @@ $(eval $(call GET_KEYBOARDS))
 # Only consider folders with makefiles, to prevent errors in case there are extra folders
 #KEYBOARDS += $(patsubst $(ROOD_DIR)/keyboards/%/rules.mk,%,$(wildcard $(ROOT_DIR)/keyboards/*/*/rules.mk))
 
-.PHONY: list-keyboards
 list-keyboards:
 	echo $(KEYBOARDS)
+	exit 0
 
 define PRINT_KEYBOARD
 	$(info $(PRINTING_KEYBOARD))
 endef
 
-.PHONY: generate-keyboards-file
 generate-keyboards-file:
 	$(foreach PRINTING_KEYBOARD,$(KEYBOARDS),$(eval $(call PRINT_KEYBOARD)))
+	exit 0
 
-.PHONY: clean
 clean:
-	echo -n 'Deleting .build/ ... '
+	echo -n 'Deleting .build ... '
 	rm -rf $(BUILD_DIR)
-	echo 'done.'
-
-.PHONY: distclean
-distclean: clean
-	echo -n 'Deleting *.bin and *.hex ... '
-	rm -f *.bin *.hex
-	echo 'done.'
+	echo 'done'
+	exit 0
 
 #Compatibility with the old make variables, anything you specify directly on the command line
 # always overrides the detected folders
@@ -371,9 +358,6 @@ define PARSE_KEYBOARD
     # The same if all was specified
     else ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,all),true)
         $$(eval $$(call PARSE_ALL_KEYMAPS))
-    # List all keymaps for the given keyboard
-    else ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,list-keymaps),true)
-        $$(eval $$(call LIST_ALL_KEYMAPS))
     # Try to match the specified keyamp with the list of known keymaps
     else ifeq ($$(call TRY_TO_MATCH_RULE_FROM_LIST,$$(KEYMAPS)),true)
         $$(eval $$(call PARSE_KEYMAP,$$(MATCHED_ITEM)))
@@ -410,16 +394,6 @@ endef
 #     endif
 # endef
 
-# Prints a list of all known keymaps for the given keyboard
-define LIST_ALL_KEYMAPS
-    COMMAND_true_LIST_KEYMAPS := \
-        printf "$$(KEYMAPS)\n";
-    COMMAND_false_LIST_KEYMAPS := \
-        printf "$$(MSG_AVAILABLE_KEYMAPS)\n"; \
-        printf "$$(KEYMAPS)\n";
-    COMMANDS += LIST_KEYMAPS
-endef
-
 # $1 Keymap
 # This is the meat of compiling a keyboard, when entering this, everything is known
 # keyboard, subproject, and keymap
@@ -554,14 +528,11 @@ endef
 %:
 	# Check if we have the CMP tool installed
 	cmp $(ROOT_DIR)/Makefile $(ROOT_DIR)/Makefile >/dev/null 2>&1; if [ $$? -gt 0 ]; then printf "$(MSG_NO_CMP)"; exit 1; fi;
-	# Ensure that python3 is installed. This check can be removed after python is used in more places.
-	if ! python3 --version 1> /dev/null 2>&1; then printf "$(MSG_PYTHON_MISSING)"; fi
 	# Check if the submodules are dirty, and display a warning if they are
 ifndef SKIP_GIT
-	if [ ! -e lib/chibios ]; then git submodule sync lib/chibios && git submodule update --depth 1 --init lib/chibios; fi
-	if [ ! -e lib/chibios-contrib ]; then git submodule sync lib/chibios-contrib && git submodule update --depth 1 --init lib/chibios-contrib; fi
-	if [ ! -e lib/ugfx ]; then git submodule sync lib/ugfx && git submodule update --depth 1 --init lib/ugfx; fi
-	if [ ! -e lib/lufa ]; then git submodule sync lib/lufa && git submodule update --depth 1 --init lib/lufa; fi
+	if [ ! -e lib/chibios ]; then git submodule sync lib/chibios && git submodule update --init lib/chibios; fi
+	if [ ! -e lib/chibios-contrib ]; then git submodule sync lib/chibios-contrib && git submodule update --init lib/chibios-contrib; fi
+	if [ ! -e lib/ugfx ]; then git submodule sync lib/ugfx && git submodule update --init lib/ugfx; fi
 	git submodule status --recursive 2>/dev/null | \
 	while IFS= read -r x; do \
 		case "$$x" in \
@@ -577,10 +548,9 @@ endif
 	# it has to be there to allow parallel execution of the submake
 	# This always tries to compile everything, even if error occurs in the middle
 	# But we return the error code at the end, to trigger travis failures
-	# The sort at this point is to remove duplicates
-	$(foreach COMMAND,$(sort $(COMMANDS)),$(RUN_COMMAND))
+	$(foreach COMMAND,$(COMMANDS),$(RUN_COMMAND))
 	if [ -f $(ERROR_FILE) ]; then printf "$(MSG_ERRORS)" & exit 1; fi;
-	$(foreach TEST,$(sort $(TESTS)),$(RUN_TEST))
+	$(foreach TEST,$(TESTS),$(RUN_TEST))
 	if [ -f $(ERROR_FILE) ]; then printf "$(MSG_ERRORS)" & exit 1; fi;
 
 # These no longer work because of the colon system
@@ -606,7 +576,6 @@ lib/%:
 	git submodule sync $?
 	git submodule update --init $?
 
-.PHONY: git-submodule
 git-submodule:
 	git submodule sync --recursive
 	git submodule update --init --recursive --progress

Vagrantfile

@@ -2,13 +2,8 @@
 # vi: set ft=ruby :
 
 Vagrant.configure(2) do |config|
-  # define a name instead of just 'default'
-  config.vm.define "qmk_firmware"
-
-  # VMware/Virtualbox ( and also Hyperv/Parallels) 64 bit
-  config.vm.box = "generic/debian9"
-  
-  config.vm.synced_folder '.', '/vagrant'
+  # VMware/Virtualbox 64 bit
+  config.vm.box = "phusion/ubuntu-14.04-amd64"
 
   # This section allows you to customize the Virtualbox VM
   # settings, ie showing the GUI or upping the memory
@@ -20,16 +15,13 @@ Vagrant.configure(2) do |config|
     # your Teensy via the VM rather than your host OS
     #vb.customize ['modifyvm', :id, '--usb', 'on']
     #vb.customize ['usbfilter', 'add', '0',
-    #         '--target', :id,
-    #         '--name', 'teensy',
-    #         '--vendorid', '0x16c0',
-    #         '--productid','0x0478'
-    #        ]
+    #    	  '--target', :id,
+    #    	  '--name', 'teensy',
+    #    	  '--vendorid', '0x16c0',
+    #    	  '--productid','0x0478'
+    #		 ]
     # Customize the amount of memory on the VM:
     vb.memory = "512"
-    # Uncomment the below lines if you have time sync
-    # issues with make and incremental builds
-    #vb.customize [ "guestproperty", "set", :id, "/VirtualBox/GuestAdd/VBoxService/--timesync-set-threshold", 1000 ]
   end
 
   # This section allows you to customize the VMware VM
@@ -52,41 +44,31 @@ Vagrant.configure(2) do |config|
   end
 
   # Docker provider pulls from hub.docker.com respecting docker.image if
-  # config.vm.box is nil. In this case, we adhoc build util/vagrant/Dockerfile.
-  # Note that this bind-mounts from the current dir to
+  # config.vm.box is nil. Note that this bind-mounts from the current dir to
   # /vagrant in the guest, so unless your UID is 1000 to match vagrant in the
   # image, you'll need to: chmod -R a+rw .
   config.vm.provider "docker" do |docker, override|
     override.vm.box = nil
-    docker.build_dir = "util/vagrant"
+    docker.image = "jesselang/debian-vagrant:jessie"
     docker.has_ssh = true
   end
 
-  # Unless we are running the docker container directly
-  #   1. run container detached on vm
-  #   2. attach on 'vagrant ssh'
-  ["virtualbox", "vmware_workstation", "vmware_fusion"].each do |type|
-    config.vm.provider type do |virt, override|
-      override.vm.provision "docker" do |d|
-        d.run "qmkfm/base_container",
-          cmd: "tail -f /dev/null",
-          args: "--privileged -v /dev:/dev -v '/vagrant:/vagrant'"
-      end
+  # This script ensures the required packages for AVR programming are installed
+  # It also ensures the system always gets the latest updates when powered on
+  # If this causes issues you can run a 'vagrant destroy' and then
+  # add a # before ,args: and run 'vagrant up' to get a working
+  # non-updated box and then attempt to troubleshoot or open a Github issue
 
-      override.vm.provision "shell", inline: <<-SHELL
-        echo 'docker restart qmkfm-base_container && exec docker exec -it qmkfm-base_container /bin/bash -l' >> ~vagrant/.bashrc
-      SHELL
-    end
-  end
+  config.vm.provision "shell", run: "always", path: "./util/qmk_install.sh", args: "-update"
 
   config.vm.post_up_message = <<-EOT
 
-  Log into the environment using 'vagrant ssh'. QMK directory synchronized with
-  host is located at /vagrant
-  To compile the .hex files use make command inside this directory, e.g.
-     cd /vagrant
-     make <keyboard>:default
+  Log into the VM using 'vagrant ssh'. QMK directory synchronized with host is
+  located at /vagrant
+  To compile the .hex files use make command inside this directory.
 
+  QMK's make format recently changed to use folder locations and colons:
+     make project_folder:keymap[:target]
   Examples:
      make planck/rev4:default:dfu
      make planck:default

bin/qmk

@@ -1,103 +0,0 @@
-#!/usr/bin/env python3
-"""CLI wrapper for running QMK commands.
-"""
-import os
-import subprocess
-import sys
-from glob import glob
-from time import strftime
-from importlib import import_module
-from importlib.util import find_spec
-
-# Add the QMK python libs to our path
-script_dir = os.path.dirname(os.path.realpath(__file__))
-qmk_dir = os.path.abspath(os.path.join(script_dir, '..'))
-python_lib_dir = os.path.abspath(os.path.join(qmk_dir, 'lib', 'python'))
-sys.path.append(python_lib_dir)
-
-# Change to the root of our checkout
-os.environ['ORIG_CWD'] = os.getcwd()
-os.chdir(qmk_dir)
-
-# Make sure our modules have been setup
-with open('requirements.txt', 'r') as fd:
-    for line in fd.readlines():
-        line = line.strip().replace('<', '=').replace('>', '=')
-
-        if line[0] == '#':
-            continue
-
-        if '#' in line:
-            line = line.split('#')[0]
-
-        module = line.split('=')[0] if '=' in line else line
-        if not find_spec(module):
-            print('Your QMK build environment is not fully setup!\n')
-            print('Please run `./util/qmk_install.sh` to setup QMK.')
-            exit(255)
-
-# Figure out our version
-command = ['git', 'describe', '--abbrev=6', '--dirty', '--always', '--tags']
-result = subprocess.run(command, universal_newlines=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-
-if result.returncode == 0:
-    os.environ['QMK_VERSION'] = 'QMK ' + result.stdout.strip()
-else:
-    os.environ['QMK_VERSION'] = 'QMK ' + strftime('%Y-%m-%d-%H:%M:%S')
-
-# Setup the CLI
-import milc
-milc.EMOJI_LOGLEVELS['INFO'] = '{fg_blue}Ψ{style_reset_all}'
-
-# If we were invoked as `qmk <cmd>` massage sys.argv into `qmk-<cmd>`.
-# This means we can't accept arguments to the qmk script itself.
-script_name = os.path.basename(sys.argv[0])
-if script_name == 'qmk':
-    if len(sys.argv) == 1:
-        milc.cli.log.error('No subcommand specified!\n')
-
-    if len(sys.argv) == 1 or sys.argv[1] in ['-h', '--help']:
-        milc.cli.echo('usage: qmk <subcommand> [...]')
-        milc.cli.echo('\nsubcommands:')
-        subcommands = glob(os.path.join(qmk_dir, 'bin', 'qmk-*'))
-        for subcommand in sorted(subcommands):
-            subcommand = os.path.basename(subcommand).split('-', 1)[1]
-            milc.cli.echo('\t%s', subcommand)
-        milc.cli.echo('\nqmk <subcommand> --help for more information')
-        exit(1)
-
-    if sys.argv[1] in ['-V', '--version']:
-        milc.cli.echo(os.environ['QMK_VERSION'])
-        exit(0)
-
-    sys.argv[0] = script_name = '-'.join((script_name, sys.argv[1]))
-    del sys.argv[1]
-
-# Look for which module to import
-if script_name == 'qmk':
-    milc.cli.print_help()
-    exit(0)
-elif not script_name.startswith('qmk-'):
-    milc.cli.log.error('Invalid symlink, must start with "qmk-": %s', script_name)
-else:
-    subcommand = script_name.replace('-', '.').replace('_', '.').split('.')
-    subcommand.insert(1, 'cli')
-    subcommand = '.'.join(subcommand)
-
-    try:
-        import_module(subcommand)
-    except ModuleNotFoundError as e:
-        if e.__class__.__name__ != subcommand:
-            raise
-
-        milc.cli.log.error('Invalid subcommand! Could not import %s.', subcommand)
-        exit(1)
-
-if __name__ == '__main__':
-    return_code = milc.cli()
-    if return_code is False:
-        exit(1)
-    elif return_code is not True and isinstance(return_code, int) and return_code < 256:
-        exit(return_code)
-    else:
-        exit(0)

bin/qmk-compile-json

@@ -1 +0,0 @@
-qmk

bin/qmk-doctor

@@ -1 +0,0 @@
-qmk

bin/qmk-hello

@@ -1 +0,0 @@
-qmk

bin/qmk-json-keymap

@@ -1 +0,0 @@
-qmk

bootloader.mk

@@ -19,14 +19,12 @@
 #
 # Sets the bootloader defined in the keyboard's/keymap's rules.mk
 # Current options:
-#
-# halfkay        PJRC Teensy
-# caterina       Pro Micro (Sparkfun/generic)
-# atmel-dfu      Atmel factory DFU
-# lufa-dfu       LUFA DFU
-# qmk-dfu        QMK DFU (LUFA + blinkenlight)
-# bootloadHID    HIDBootFlash compatible (ATmega32A)
-# USBasp         USBaspLoader (ATmega328P)
+#   atmel-dfu
+#   lufa-dfu
+#   qmk-dfu
+#   halfkay
+#   caterina
+#   bootloadHID
 #
 # BOOTLOADER_SIZE can still be defined manually, but it's recommended
 # you add any possible configuration to this list
@@ -34,40 +32,40 @@
 ifeq ($(strip $(BOOTLOADER)), atmel-dfu)
     OPT_DEFS += -DBOOTLOADER_ATMEL_DFU
     OPT_DEFS += -DBOOTLOADER_DFU
-    ifneq (,$(filter $(MCU), at90usb646 atmega16u2 atmega16u4 atmega32u2 atmega32u4))
-        BOOTLOADER_SIZE = 4096
+    ifeq ($(strip $(MCU)), atmega32u4)
+      BOOTLOADER_SIZE = 4096
     endif
     ifeq ($(strip $(MCU)), at90usb1286)
-        BOOTLOADER_SIZE = 8192
+      BOOTLOADER_SIZE = 8192
     endif
 endif
 ifeq ($(strip $(BOOTLOADER)), lufa-dfu)
     OPT_DEFS += -DBOOTLOADER_LUFA_DFU
     OPT_DEFS += -DBOOTLOADER_DFU
-    ifneq (,$(filter $(MCU), at90usb646 atmega16u2 atmega16u4 atmega32u2 atmega32u4))
-        BOOTLOADER_SIZE = 4096
+    ifeq ($(strip $(MCU)), atmega32u4)
+      BOOTLOADER_SIZE = 4096
     endif
     ifeq ($(strip $(MCU)), at90usb1286)
-        BOOTLOADER_SIZE = 8192
+      BOOTLOADER_SIZE = 8192
     endif
 endif
 ifeq ($(strip $(BOOTLOADER)), qmk-dfu)
     OPT_DEFS += -DBOOTLOADER_QMK_DFU
     OPT_DEFS += -DBOOTLOADER_DFU
-    ifneq (,$(filter $(MCU), at90usb646 atmega16u2 atmega16u4 atmega32u2 atmega32u4))
-        BOOTLOADER_SIZE = 4096
+    ifeq ($(strip $(MCU)), atmega32u4)
+      BOOTLOADER_SIZE = 4096
     endif
     ifeq ($(strip $(MCU)), at90usb1286)
-        BOOTLOADER_SIZE = 8192
+      BOOTLOADER_SIZE = 8192
     endif
 endif
 ifeq ($(strip $(BOOTLOADER)), halfkay)
     OPT_DEFS += -DBOOTLOADER_HALFKAY
     ifeq ($(strip $(MCU)), atmega32u4)
-        BOOTLOADER_SIZE = 512
+      BOOTLOADER_SIZE = 512
     endif
     ifeq ($(strip $(MCU)), at90usb1286)
-        BOOTLOADER_SIZE = 1024
+      BOOTLOADER_SIZE = 1024
     endif
 endif
 ifeq ($(strip $(BOOTLOADER)), caterina)
@@ -78,10 +76,6 @@ ifeq ($(strip $(BOOTLOADER)), bootloadHID)
     OPT_DEFS += -DBOOTLOADER_BOOTLOADHID
     BOOTLOADER_SIZE = 4096
 endif
-ifeq ($(strip $(BOOTLOADER)), USBasp)
-    OPT_DEFS += -DBOOTLOADER_USBASP
-    BOOTLOADER_SIZE = 4096
-endif
 
 ifdef BOOTLOADER_SIZE
     OPT_DEFS += -DBOOTLOADER_SIZE=$(strip $(BOOTLOADER_SIZE))

build_json.mk

@@ -1,27 +0,0 @@
-# Look for a json keymap file
-ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_5)/keymap.json)","")
-    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
-    KEYMAP_JSON := $(MAIN_KEYMAP_PATH_5)/keymap.json
-    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_5)
-else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_4)/keymap.json)","")
-    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
-    KEYMAP_JSON := $(MAIN_KEYMAP_PATH_4)/keymap.json
-    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_4)
-else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_3)/keymap.json)","")
-    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
-    KEYMAP_JSON := $(MAIN_KEYMAP_PATH_3)/keymap.json
-    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_3)
-else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_2)/keymap.json)","")
-    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
-    KEYMAP_JSON := $(MAIN_KEYMAP_PATH_2)/keymap.json
-    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_2)
-else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.json)","")
-    KEYMAP_C := $(KEYBOARD_OUTPUT)/src/keymap.c
-    KEYMAP_JSON := $(MAIN_KEYMAP_PATH_1)/keymap.json
-    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_1)
-endif
-
-# Generate the keymap.c
-ifneq ("$(KEYMAP_JSON)","")
-    _ = $(shell test -e $(KEYMAP_C) || bin/qmk-json-keymap $(KEYMAP_JSON) -o $(KEYMAP_C))
-endif

build_keyboard.mk

@@ -35,10 +35,6 @@ $(error MASTER does not have a valid value(left/right))
     endif
 endif
 
-ifdef SKIP_VERSION
-    OPT_DEFS += -DSKIP_VERSION
-endif
-
 # Determine which subfolders exist.
 KEYBOARD_FOLDER_PATH_1 := $(KEYBOARD)
 KEYBOARD_FOLDER_PATH_2 := $(patsubst %/,%,$(dir $(KEYBOARD_FOLDER_PATH_1)))
@@ -91,59 +87,9 @@ ifneq ("$(wildcard $(KEYBOARD_PATH_1)/rules.mk)","")
     include $(KEYBOARD_PATH_1)/rules.mk
 endif
 
-
-MAIN_KEYMAP_PATH_1 := $(KEYBOARD_PATH_1)/keymaps/$(KEYMAP)
-MAIN_KEYMAP_PATH_2 := $(KEYBOARD_PATH_2)/keymaps/$(KEYMAP)
-MAIN_KEYMAP_PATH_3 := $(KEYBOARD_PATH_3)/keymaps/$(KEYMAP)
-MAIN_KEYMAP_PATH_4 := $(KEYBOARD_PATH_4)/keymaps/$(KEYMAP)
-MAIN_KEYMAP_PATH_5 := $(KEYBOARD_PATH_5)/keymaps/$(KEYMAP)
-
-# Check for keymap.json first, so we can regenerate keymap.c
-include build_json.mk
-
-ifeq ("$(wildcard $(KEYMAP_PATH))", "")
-    # Look through the possible keymap folders until we find a matching keymap.c
-    ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_5)/keymap.c)","")
-        -include $(MAIN_KEYMAP_PATH_5)/rules.mk
-        KEYMAP_C := $(MAIN_KEYMAP_PATH_5)/keymap.c
-        KEYMAP_PATH := $(MAIN_KEYMAP_PATH_5)
-    else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_4)/keymap.c)","")
-        -include $(MAIN_KEYMAP_PATH_4)/rules.mk
-        KEYMAP_C := $(MAIN_KEYMAP_PATH_4)/keymap.c
-        KEYMAP_PATH := $(MAIN_KEYMAP_PATH_4)
-    else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_3)/keymap.c)","")
-        -include $(MAIN_KEYMAP_PATH_3)/rules.mk
-        KEYMAP_C := $(MAIN_KEYMAP_PATH_3)/keymap.c
-        KEYMAP_PATH := $(MAIN_KEYMAP_PATH_3)
-    else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_2)/keymap.c)","")
-        -include $(MAIN_KEYMAP_PATH_2)/rules.mk
-        KEYMAP_C := $(MAIN_KEYMAP_PATH_2)/keymap.c
-        KEYMAP_PATH := $(MAIN_KEYMAP_PATH_2)
-    else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.c)","")
-        -include $(MAIN_KEYMAP_PATH_1)/rules.mk
-        KEYMAP_C := $(MAIN_KEYMAP_PATH_1)/keymap.c
-        KEYMAP_PATH := $(MAIN_KEYMAP_PATH_1)
-    else ifneq ($(LAYOUTS),)
-        # If we haven't found a keymap yet fall back to community layouts
-        include build_layout.mk
-    else
-        $(error Could not find keymap)
-        # this state should never be reached
-    endif
-endif
-
-ifeq ($(strip $(CTPC)), yes)
-  CONVERT_TO_PROTON_C=yes
-endif
-
-ifeq ($(strip $(CONVERT_TO_PROTON_C)), yes)
-    TARGET := $(TARGET)_proton_c
+ifeq ($(strip $(PROTON)), yes)
+    OPT_DEFS += -DPROTON_CONVERSION
     include $(STM32_PATH)/proton_c.mk
-    OPT_DEFS += -DCONVERT_TO_PROTON_C
-endif
-
-ifneq ($(FORCE_LAYOUT),)
-    TARGET := $(TARGET)_$(FORCE_LAYOUT)
 endif
 
 include quantum/mcu_selection.mk
@@ -287,28 +233,44 @@ ifneq ("$(wildcard $(KEYBOARD_PATH_1)/config.h)","")
     CONFIG_H += $(KEYBOARD_PATH_1)/config.h
 endif
 
-POST_CONFIG_H :=
-ifneq ("$(wildcard $(KEYBOARD_PATH_1)/post_config.h)","")
-    POST_CONFIG_H += $(KEYBOARD_PATH_1)/post_config.h
-endif
-ifneq ("$(wildcard $(KEYBOARD_PATH_2)/post_config.h)","")
-    POST_CONFIG_H += $(KEYBOARD_PATH_2)/post_config.h
-endif
-ifneq ("$(wildcard $(KEYBOARD_PATH_3)/post_config.h)","")
-    POST_CONFIG_H += $(KEYBOARD_PATH_3)/post_config.h
-endif
-ifneq ("$(wildcard $(KEYBOARD_PATH_4)/post_config.h)","")
-    POST_CONFIG_H += $(KEYBOARD_PATH_4)/post_config.h
-endif
-ifneq ("$(wildcard $(KEYBOARD_PATH_5)/post_config.h)","")
-    POST_CONFIG_H += $(KEYBOARD_PATH_5)/post_config.h
-endif
-
 # Save the defines and includes here, so we don't include any keymap specific ones
 PROJECT_DEFS := $(OPT_DEFS)
 PROJECT_INC := $(VPATH) $(EXTRAINCDIRS) $(KEYBOARD_PATHS)
 PROJECT_CONFIG := $(CONFIG_H)
 
+MAIN_KEYMAP_PATH_1 := $(KEYBOARD_PATH_1)/keymaps/$(KEYMAP)
+MAIN_KEYMAP_PATH_2 := $(KEYBOARD_PATH_2)/keymaps/$(KEYMAP)
+MAIN_KEYMAP_PATH_3 := $(KEYBOARD_PATH_3)/keymaps/$(KEYMAP)
+MAIN_KEYMAP_PATH_4 := $(KEYBOARD_PATH_4)/keymaps/$(KEYMAP)
+MAIN_KEYMAP_PATH_5 := $(KEYBOARD_PATH_5)/keymaps/$(KEYMAP)
+
+ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_5)/keymap.c)","")
+    -include $(MAIN_KEYMAP_PATH_5)/rules.mk
+    KEYMAP_C := $(MAIN_KEYMAP_PATH_5)/keymap.c
+    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_5)
+else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_4)/keymap.c)","")
+    -include $(MAIN_KEYMAP_PATH_4)/rules.mk
+    KEYMAP_C := $(MAIN_KEYMAP_PATH_4)/keymap.c
+    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_4)
+else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_3)/keymap.c)","")
+    -include $(MAIN_KEYMAP_PATH_3)/rules.mk
+    KEYMAP_C := $(MAIN_KEYMAP_PATH_3)/keymap.c
+    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_3)
+else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_2)/keymap.c)","")
+    -include $(MAIN_KEYMAP_PATH_2)/rules.mk
+    KEYMAP_C := $(MAIN_KEYMAP_PATH_2)/keymap.c
+    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_2)
+else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.c)","")
+    -include $(MAIN_KEYMAP_PATH_1)/rules.mk
+    KEYMAP_C := $(MAIN_KEYMAP_PATH_1)/keymap.c
+    KEYMAP_PATH := $(MAIN_KEYMAP_PATH_1)
+else ifneq ($(LAYOUTS),)
+    include build_layout.mk
+else
+    $(error Could not find keymap)
+    # this state should never be reached
+endif
+
 # Userspace setup and definitions
 ifeq ("$(USER_NAME)","")
     USER_NAME := $(KEYMAP)
@@ -320,6 +282,7 @@ ifneq ("$(wildcard $(USER_PATH)/config.h)","")
     CONFIG_H += $(USER_PATH)/config.h
 endif
 
+
 # Object files directory
 #     To put object files in current directory, use a dot (.), do NOT make
 #     this an empty or blank macro!
@@ -329,7 +292,7 @@ ifneq ("$(wildcard $(KEYMAP_PATH)/config.h)","")
     CONFIG_H += $(KEYMAP_PATH)/config.h
 endif
 
-# project specific files
+# # project specific files
 SRC += $(KEYBOARD_SRC) \
     $(KEYMAP_C) \
     $(QUANTUM_SRC)
@@ -339,17 +302,15 @@ SRC += $(KEYBOARD_SRC) \
 
 # Search Path
 VPATH += $(KEYMAP_PATH)
-VPATH += $(USER_PATH)
 VPATH += $(KEYBOARD_PATHS)
 VPATH += $(COMMON_VPATH)
+VPATH += $(USER_PATH)
 
 include common_features.mk
 include $(TMK_PATH)/protocol.mk
 include $(TMK_PATH)/common.mk
 include bootloader.mk
 
-SRC += $(patsubst %.c,%.clib,$(LIB_SRC))
-SRC += $(patsubst %.c,%.clib,$(QUANTUM_LIB_SRC))
 SRC += $(TMK_COMMON_SRC)
 OPT_DEFS += $(TMK_COMMON_DEFS)
 EXTRALDFLAGS += $(TMK_COMMON_LDFLAGS)
@@ -378,7 +339,6 @@ ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
     include $(VISUALIZER_PATH)/visualizer.mk
 endif
 
-CONFIG_H += $(POST_CONFIG_H)
 ALL_CONFIGS := $(PROJECT_CONFIG) $(CONFIG_H)
 
 OUTPUTS := $(KEYMAP_OUTPUT) $(KEYBOARD_OUTPUT)
@@ -397,8 +357,5 @@ $(KEYBOARD_OUTPUT)_CONFIG := $(PROJECT_CONFIG)
 # Default target.
 all: build check-size
 build: elf cpfirmware
-check-size: build
-objs-size: build
 
-include show_options.mk
 include $(TMK_PATH)/rules.mk

build_layout.mk

@@ -15,13 +15,4 @@ define SEARCH_LAYOUTS
     $$(foreach LAYOUTS_REPO,$$(LAYOUTS_REPOS),$$(eval $$(call SEARCH_LAYOUTS_REPO)))
 endef
 
-ifneq ($(FORCE_LAYOUT),)
-    ifneq (,$(findstring $(FORCE_LAYOUT),$(LAYOUTS)))
-        $(info Forcing layout: $(FORCE_LAYOUT))
-        LAYOUTS := $(FORCE_LAYOUT)
-    else
-        $(error Forced layout does not exist)
-    endif
-endif
-
 $(foreach LAYOUT,$(LAYOUTS),$(eval $(call SEARCH_LAYOUTS)))

common.mk

@@ -21,4 +21,5 @@ COMMON_VPATH += $(QUANTUM_PATH)/keymap_extras
 COMMON_VPATH += $(QUANTUM_PATH)/audio
 COMMON_VPATH += $(QUANTUM_PATH)/process_keycode
 COMMON_VPATH += $(QUANTUM_PATH)/api
+COMMON_VPATH += $(QUANTUM_PATH)/split_common
 COMMON_VPATH += $(DRIVER_PATH)

common_features.mk

@@ -103,9 +103,7 @@ ifeq ($(strip $(UNICODE_COMMON)), yes)
 endif
 
 ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
-    POST_CONFIG_H += $(QUANTUM_DIR)/rgblight_post_config.h
     OPT_DEFS += -DRGBLIGHT_ENABLE
-    SRC += $(QUANTUM_DIR)/color.c
     SRC += $(QUANTUM_DIR)/rgblight.c
     CIE1931_CURVE = yes
     LED_BREATHING_TABLE = yes
@@ -116,28 +114,8 @@ ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
     endif
 endif
 
-VALID_MATRIX_TYPES := yes IS31FL3731 IS31FL3733 IS31FL3737 WS2812 custom
-
-LED_MATRIX_ENABLE ?= no
-ifneq ($(strip $(LED_MATRIX_ENABLE)), no)
-    ifeq ($(filter $(LED_MATRIX_ENABLE),$(VALID_MATRIX_TYPES)),)
-        $(error LED_MATRIX_ENABLE="$(LED_MATRIX_ENABLE)" is not a valid matrix type)
-    else
-        OPT_DEFS += -DLED_MATRIX_ENABLE -DBACKLIGHT_ENABLE -DBACKLIGHT_CUSTOM_DRIVER
-        SRC += $(QUANTUM_DIR)/led_matrix.c
-        SRC += $(QUANTUM_DIR)/led_matrix_drivers.c
-    endif
-endif
-
-ifeq ($(strip $(LED_MATRIX_ENABLE)), IS31FL3731)
-    OPT_DEFS += -DIS31FL3731
-    COMMON_VPATH += $(DRIVER_PATH)/issi
-    SRC += is31fl3731-simple.c
-    QUANTUM_LIB_SRC += i2c_master.c
-endif
-
 RGB_MATRIX_ENABLE ?= no
-
+VALID_MATRIX_TYPES := yes IS31FL3731 IS31FL3733 custom
 ifneq ($(strip $(RGB_MATRIX_ENABLE)), no)
 ifeq ($(filter $(RGB_MATRIX_ENABLE),$(VALID_MATRIX_TYPES)),)
     $(error RGB_MATRIX_ENABLE="$(RGB_MATRIX_ENABLE)" is not a valid matrix type)
@@ -154,37 +132,17 @@ ifeq ($(strip $(RGB_MATRIX_ENABLE)), yes)
 endif
 
 ifeq ($(strip $(RGB_MATRIX_ENABLE)), IS31FL3731)
-    OPT_DEFS += -DIS31FL3731 -DSTM32_I2C -DHAL_USE_I2C=TRUE
+    OPT_DEFS += -DIS31FL3731
     COMMON_VPATH += $(DRIVER_PATH)/issi
     SRC += is31fl3731.c
-    QUANTUM_LIB_SRC += i2c_master.c
+    SRC += i2c_master.c
 endif
 
 ifeq ($(strip $(RGB_MATRIX_ENABLE)), IS31FL3733)
-    OPT_DEFS += -DIS31FL3733 -DSTM32_I2C -DHAL_USE_I2C=TRUE
+    OPT_DEFS += -DIS31FL3733
     COMMON_VPATH += $(DRIVER_PATH)/issi
     SRC += is31fl3733.c
-    QUANTUM_LIB_SRC += i2c_master.c
-endif
-
-ifeq ($(strip $(RGB_MATRIX_ENABLE)), IS31FL3737)
-    OPT_DEFS += -DIS31FL3737 -DSTM32_I2C -DHAL_USE_I2C=TRUE
-    COMMON_VPATH += $(DRIVER_PATH)/issi
-    SRC += is31fl3737.c
-    QUANTUM_LIB_SRC += i2c_master.c
-endif
-
-ifeq ($(strip $(RGB_MATRIX_ENABLE)), WS2812)
-    OPT_DEFS += -DWS2812
-    SRC += ws2812.c
-endif
-
-ifeq ($(strip $(RGB_MATRIX_CUSTOM_KB)), yes)
-    OPT_DEFS += -DRGB_MATRIX_CUSTOM_KB
-endif
-
-ifeq ($(strip $(RGB_MATRIX_CUSTOM_USER)), yes)
-    OPT_DEFS += -DRGB_MATRIX_CUSTOM_USER
+    SRC += i2c_master.c
 endif
 
 ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
@@ -233,7 +191,7 @@ ifeq ($(strip $(BACKLIGHT_ENABLE)), yes)
     ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
         CIE1931_CURVE = yes
     endif
-    ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes)
+        ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes)
         OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER
     endif
 endif
@@ -267,34 +225,11 @@ ifeq ($(strip $(ENCODER_ENABLE)), yes)
     OPT_DEFS += -DENCODER_ENABLE
 endif
 
-HAPTIC_ENABLE ?= no
-ifneq ($(strip $(HAPTIC_ENABLE)),no)
-	COMMON_VPATH += $(DRIVER_PATH)/haptic
-	SRC += haptic.c
-	OPT_DEFS += -DHAPTIC_ENABLE
-endif
-
-ifneq ($(filter DRV2605L, $(HAPTIC_ENABLE)), )
-    SRC += DRV2605L.c
-    QUANTUM_LIB_SRC += i2c_master.c
-    OPT_DEFS += -DDRV2605L
-endif
-
-ifneq ($(filter SOLENOID, $(HAPTIC_ENABLE)), )
-    SRC += solenoid.c
-    OPT_DEFS += -DSOLENOID_ENABLE
-endif
-
 ifeq ($(strip $(HD44780_ENABLE)), yes)
     SRC += drivers/avr/hd44780.c
     OPT_DEFS += -DHD44780_ENABLE
 endif
 
-ifeq ($(strip $(VELOCIKEY_ENABLE)), yes)
-    OPT_DEFS += -DVELOCIKEY_ENABLE
-    SRC += $(QUANTUM_DIR)/velocikey.c
-endif
-
 ifeq ($(strip $(DYNAMIC_KEYMAP_ENABLE)), yes)
     OPT_DEFS += -DDYNAMIC_KEYMAP_ENABLE
     SRC += $(QUANTUM_DIR)/dynamic_keymap.c
@@ -305,14 +240,11 @@ ifeq ($(strip $(LEADER_ENABLE)), yes)
   OPT_DEFS += -DLEADER_ENABLE
 endif
 
-include $(DRIVER_PATH)/qwiic/qwiic.mk
-
 QUANTUM_SRC:= \
     $(QUANTUM_DIR)/quantum.c \
     $(QUANTUM_DIR)/keymap_common.c \
     $(QUANTUM_DIR)/keycode_config.c
 
-# Include the standard or split matrix code if needed
 ifneq ($(strip $(CUSTOM_MATRIX)), yes)
     ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
         QUANTUM_SRC += $(QUANTUM_DIR)/split_common/matrix.c
@@ -321,47 +253,10 @@ ifneq ($(strip $(CUSTOM_MATRIX)), yes)
     endif
 endif
 
-DEBOUNCE_DIR:= $(QUANTUM_DIR)/debounce
-# Debounce Modules. Set DEBOUNCE_TYPE=custom if including one manually.
-DEBOUNCE_TYPE?= sym_g
-ifneq ($(strip $(DEBOUNCE_TYPE)), custom)
-    QUANTUM_SRC += $(DEBOUNCE_DIR)/$(strip $(DEBOUNCE_TYPE)).c
-endif
-
 ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
-    POST_CONFIG_H += $(QUANTUM_DIR)/split_common/post_config.h
     OPT_DEFS += -DSPLIT_KEYBOARD
-
-    # Include files used by all split keyboards
-    QUANTUM_SRC += $(QUANTUM_DIR)/split_common/split_util.c
-
-    # Determine which (if any) transport files are required
-    ifneq ($(strip $(SPLIT_TRANSPORT)), custom)
-        QUANTUM_SRC += $(QUANTUM_DIR)/split_common/transport.c
-        # Functions added via QUANTUM_LIB_SRC are only included in the final binary if they're called.
-        # Unused functions are pruned away, which is why we can add multiple drivers here without bloat.
-        QUANTUM_LIB_SRC += $(QUANTUM_DIR)/split_common/serial.c \
-                           i2c_master.c \
-                           i2c_slave.c
-    endif
-    COMMON_VPATH += $(QUANTUM_PATH)/split_common
-endif
-
-ifeq ($(strip $(OLED_DRIVER_ENABLE)), yes)
-    OPT_DEFS += -DOLED_DRIVER_ENABLE
-    COMMON_VPATH += $(DRIVER_PATH)/oled
-    QUANTUM_LIB_SRC += i2c_master.c
-    SRC += oled_driver.c
-endif
-
-SPACE_CADET_ENABLE ?= yes
-ifeq ($(strip $(SPACE_CADET_ENABLE)), yes)
-  SRC += $(QUANTUM_DIR)/process_keycode/process_space_cadet.c
-  OPT_DEFS += -DSPACE_CADET_ENABLE
-endif
-
-
-ifeq ($(strip $(DIP_SWITCH_ENABLE)), yes)
-  SRC += $(QUANTUM_DIR)/dip_switch.c
-  OPT_DEFS += -DDIP_SWITCH_ENABLE
+    QUANTUM_SRC += $(QUANTUM_DIR)/split_common/split_flags.c \
+                $(QUANTUM_DIR)/split_common/split_util.c \
+                $(QUANTUM_DIR)/split_common/i2c.c \
+                $(QUANTUM_DIR)/split_common/serial.c
 endif

docs/ChangeLog/20190830.md

@@ -1,53 +0,0 @@
-# QMK Breaking Change - 2019 Aug 30
-
-Four times a year QMK runs a process for merging Breaking Changes. A Breaking Change is any change which modifies how QMK behaves in a way that is incompatible or potentially dangerous. We limit these changes to 4 times per year so that users can have confidence that updating their QMK tree will not break their keymaps.
-
-This document marks the inaugural Breaking Change merge. A list of changes follows.
-
-## Core code formatting with clang-format
-
-* All core files (`drivers/`, `quantum/`, `tests/`, and `tmk_core/`) have been formatted with clang-format
-* A travis process to reformat PR's on merge has been instituted
-* You can use the new CLI command `qmk cformat` to format before submitting your PR if you wish.
-
-## LUFA USB descriptor cleanup
-
-* Some code cleanups related to the USB HID descriptors on AVR keyboards, to make them easier to read and understand
-* More information: see https://github.com/qmk/qmk_firmware/pull/4871
-* No behaviour changes anticipated and no keymaps modified
-
-## Migrating `ACTION_LAYER_MOMENTARY()` entries in `fn_actions` to `MO()` keycodes
-
-* `fn_actions` is deprecated, and its functionality has been superseded by direct keycodes and `process_record_user()`
-* The end result of removing this obsolete feature should result in a decent reduction in firmware size and code complexity
-* All keymaps affected are recommended to switch away from `fn_actions` in favour of the [custom keycode](https://docs.qmk.fm/#/custom_quantum_functions) and [macro](https://docs.qmk.fm/#/feature_macros) features
-
-## Update Atreus to current code conventions
-
-* Duplicate include guards have bypassed the expected header processing behavior
-* All keymaps affected are recommended to remove duplication of `<keyboard>/config.h` to `<keyboard>/keymaps/<user>/config.h` and only provide overrides at the keymap level
-
-## Backport changes to keymap language files from ZSA fork
-
-* Fixes an issue in the `keymap_br_abnt2.h` file that includes the wrong source (`keymap_common.h` instead of `keymap.h`)
-* Updates the `keymap_swedish.h` file to be specific to swedish, and not just "nordic" in general. 
-* Any keymaps using this will need to remove `NO_*` and replace it with `SE_*`. 
-
-## Update repo to use LUFA as a git submodule
-
-* `/lib/LUFA` removed from the repo
-* LUFA set as a submodule, pointing to qmk/lufa
-* This should allow more flexibility with LUFA, and allow us to keep the sub-module up to date, a lot more easily.  It was ~2 years out of date with no easy path to fix that.  This prevents that from being an issue in the future
-  
-## Migrating `ACTION_BACKLIGHT_*()` entries in `fn_actions` to `BL_` keycodes
-
-* `fn_actions` is deprecated, and its functionality has been superseded by direct keycodes and `process_record_user()`
-* All keymaps using these actions have had the relevant `KC_FN*` keys replaced with the equivalent `BL_*` keys
-* If you currently use `KC_FN*` you will need to replace `fn_actions` with the [custom keycode](https://docs.qmk.fm/#/custom_quantum_functions) and [macro](https://docs.qmk.fm/#/feature_macros) features
-
-## Remove `KC_DELT` alias in favor of `KC_DEL`
-
-* `KC_DELT` was a redundant, undocumented alias for `KC_DELETE`
-* It has been removed and all its uses replaced with the more common `KC_DEL` alias
-* Around 90 keymaps (mostly for ErgoDox boards) have been modified as a result
-

docs/LANGS.md

@@ -1,4 +0,0 @@
-# Languages
-
-* [English](/)
-* [Chinese](zh/)

docs/_sidebar.md

@@ -0,0 +1,99 @@
+* [Complete Newbs Guide](newbs.md)
+  * [Getting Started](newbs_getting_started.md)
+  * [Building Your First Firmware](newbs_building_firmware.md)
+  * [Flashing Firmware](newbs_flashing.md)
+  * [Testing and Debugging](newbs_testing_debugging.md)
+  * [Best Practices](newbs_best_practices.md)
+  * [Learning Resources](newbs_learn_more_resources.md)
+
+* [QMK Basics](README.md)
+  * [QMK Introduction](getting_started_introduction.md)
+  * [Contributing to QMK](contributing.md)
+  * [How to Use Github](getting_started_github.md)
+  * [Getting Help](getting_started_getting_help.md)
+
+* [FAQ](faq.md)
+  * [General FAQ](faq_general.md)
+  * [Build/Compile QMK](faq_build.md)
+  * [Debugging/Troubleshooting QMK](faq_debug.md)
+  * [Keymap](faq_keymap.md)
+
+* Detailed Guides
+  * [Install Build Tools](getting_started_build_tools.md)
+  * [Vagrant Guide](getting_started_vagrant.md)
+  * [Build/Compile Instructions](getting_started_make_guide.md)
+  * [Flashing Firmware](flashing.md)
+  * [Customizing Functionality](custom_quantum_functions.md)
+  * [Keymap Overview](keymap.md)
+
+* [Hardware](hardware.md)
+  * [AVR Processors](hardware_avr.md)
+  * [Drivers](hardware_drivers.md)
+
+* Reference
+  * [Keyboard Guidelines](hardware_keyboard_guidelines.md)
+  * [Config Options](config_options.md)
+  * [Keycodes](keycodes.md)
+  * [Documentation Best Practices](documentation_best_practices.md)
+  * [Documentation Templates](documentation_templates.md)
+  * [Glossary](reference_glossary.md)
+  * [Unit Testing](unit_testing.md)
+  * [Useful Functions](ref_functions.md)
+  * [Configurator Support](reference_configurator_support.md)
+
+* [Features](features.md)
+  * [Basic Keycodes](keycodes_basic.md)
+  * [Quantum Keycodes](quantum_keycodes.md)
+  * [Advanced Keycodes](feature_advanced_keycodes.md)
+  * [Audio](feature_audio.md)
+  * [Auto Shift](feature_auto_shift.md)
+  * [Backlight](feature_backlight.md)
+  * [Bluetooth](feature_bluetooth.md)
+  * [Bootmagic](feature_bootmagic.md)
+  * [Combos](feature_combo)
+  * [Command](feature_command.md)
+  * [Dynamic Macros](feature_dynamic_macros.md)
+  * [Encoders](feature_encoders.md)
+  * [Grave Escape](feature_grave_esc.md)
+  * [Key Lock](feature_key_lock.md)
+  * [Layouts](feature_layouts.md)
+  * [Leader Key](feature_leader_key.md)
+  * [Macros](feature_macros.md)
+  * [Mouse Keys](feature_mouse_keys.md)
+  * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
+  * [Pointing Device](feature_pointing_device.md)
+  * [PS/2 Mouse](feature_ps2_mouse.md)
+  * [RGB Lighting](feature_rgblight.md)
+  * [RGB Matrix](feature_rgb_matrix.md)
+  * [Space Cadet Shift](feature_space_cadet_shift.md)
+  * [Space Cadet Shift Enter](feature_space_cadet_shift_enter.md)
+  * [Stenography](feature_stenography.md)
+  * [Swap Hands](feature_swap_hands.md)
+  * [Tap Dance](feature_tap_dance.md)
+  * [Terminal](feature_terminal.md)
+  * [Thermal Printer](feature_thermal_printer.md)
+  * [Unicode](feature_unicode.md)
+  * [Userspace](feature_userspace.md)
+  * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
+
+* For Makers and Modders
+  * [Hand Wiring Guide](hand_wire.md)
+  * [ISP Flashing Guide](isp_flashing_guide.md)
+  * [ARM Debugging Guide](arm_debugging.md)
+  * [I2C Driver](i2c_driver.md)
+
+* For a Deeper Understanding
+  * [How Keyboards Work](how_keyboards_work.md)
+  * [Understanding QMK](understanding_qmk.md)
+
+* Other Topics
+  * [Using Eclipse with QMK](eclipse.md)
+
+* QMK Internals (In Progress)
+  * [Defines](internals_defines.md)
+  * [Input Callback Reg](internals_input_callback_reg.md)
+  * [Midi Device](internals_midi_device.md)
+  * [Midi Device Setup Process](internals_midi_device_setup_process.md)
+  * [Midi Util](internals_midi_util.md)
+  * [Send Functions](internals_send_functions.md)
+  * [Sysex Tools](internals_sysex_tools.md)

docs/_summary.md

@@ -3,25 +3,20 @@
   * [Building Your First Firmware](newbs_building_firmware.md)
   * [Flashing Firmware](newbs_flashing.md)
   * [Testing and Debugging](newbs_testing_debugging.md)
-  * [Git Best Practices](newbs_best_practices.md)
+  * [Best Practices](newbs_best_practices.md)
   * [Learning Resources](newbs_learn_more_resources.md)
 
 * [QMK Basics](README.md)
   * [QMK Introduction](getting_started_introduction.md)
-  * [QMK CLI](cli.md)
   * [Contributing to QMK](contributing.md)
   * [How to Use Github](getting_started_github.md)
   * [Getting Help](getting_started_getting_help.md)
 
-* [Breaking Changes](breaking_changes.md)
-  * [2019 Aug 30](ChangeLog/20190830.md)
-
 * [FAQ](faq.md)
   * [General FAQ](faq_general.md)
   * [Build/Compile QMK](faq_build.md)
   * [Debugging/Troubleshooting QMK](faq_debug.md)
   * [Keymap](faq_keymap.md)
-  * [Driver Installation with Zadig](driver_installation_zadig.md)
 
 * Detailed Guides
   * [Install Build Tools](getting_started_build_tools.md)
@@ -39,20 +34,15 @@
   * [Keyboard Guidelines](hardware_keyboard_guidelines.md)
   * [Config Options](config_options.md)
   * [Keycodes](keycodes.md)
-  * [Coding Conventions - C](coding_conventions_c.md)
-  * [Coding Conventions - Python](coding_conventions_python.md)
   * [Documentation Best Practices](documentation_best_practices.md)
   * [Documentation Templates](documentation_templates.md)
   * [Glossary](reference_glossary.md)
   * [Unit Testing](unit_testing.md)
   * [Useful Functions](ref_functions.md)
   * [Configurator Support](reference_configurator_support.md)
-  * [info.json Format](reference_info_json.md)
-  * [Python Development](python_development.md)
 
 * [Features](features.md)
   * [Basic Keycodes](keycodes_basic.md)
-  * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
   * [Quantum Keycodes](quantum_keycodes.md)
   * [Advanced Keycodes](feature_advanced_keycodes.md)
   * [Audio](feature_audio.md)
@@ -60,29 +50,23 @@
   * [Backlight](feature_backlight.md)
   * [Bluetooth](feature_bluetooth.md)
   * [Bootmagic](feature_bootmagic.md)
-  * [Combos](feature_combo.md)
+  * [Combos](feature_combo)
   * [Command](feature_command.md)
-  * [Debounce API](feature_debounce_type.md)
-  * [DIP Switch](feature_dip_switch.md)
   * [Dynamic Macros](feature_dynamic_macros.md)
   * [Encoders](feature_encoders.md)
   * [Grave Escape](feature_grave_esc.md)
-  * [Haptic Feedback](feature_haptic_feedback.md)
-  * [HD44780 LCD Controller](feature_hd44780.md)
   * [Key Lock](feature_key_lock.md)
   * [Layouts](feature_layouts.md)
   * [Leader Key](feature_leader_key.md)
-  * [LED Matrix](feature_led_matrix.md)
   * [Macros](feature_macros.md)
   * [Mouse Keys](feature_mouse_keys.md)
-  * [OLED Driver](feature_oled_driver.md)
   * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
   * [Pointing Device](feature_pointing_device.md)
   * [PS/2 Mouse](feature_ps2_mouse.md)
   * [RGB Lighting](feature_rgblight.md)
   * [RGB Matrix](feature_rgb_matrix.md)
-  * [Space Cadet](feature_space_cadet.md)
-  * [Split Keyboard](feature_split_keyboard.md)
+  * [Space Cadet Shift](feature_space_cadet_shift.md)
+  * [Space Cadet Shift Enter](feature_space_cadet_shift_enter.md)
   * [Stenography](feature_stenography.md)
   * [Swap Hands](feature_swap_hands.md)
   * [Tap Dance](feature_tap_dance.md)
@@ -90,24 +74,20 @@
   * [Thermal Printer](feature_thermal_printer.md)
   * [Unicode](feature_unicode.md)
   * [Userspace](feature_userspace.md)
-  * [Velocikey](feature_velocikey.md)
+  * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
 
 * For Makers and Modders
   * [Hand Wiring Guide](hand_wire.md)
   * [ISP Flashing Guide](isp_flashing_guide.md)
   * [ARM Debugging Guide](arm_debugging.md)
   * [I2C Driver](i2c_driver.md)
-  * [GPIO Controls](internals_gpio_control.md)
-  * [Proton C Conversion](proton_c_conversion.md)
 
 * For a Deeper Understanding
   * [How Keyboards Work](how_keyboards_work.md)
   * [Understanding QMK](understanding_qmk.md)
 
 * Other Topics
-  * [Using Eclipse with QMK](other_eclipse.md)
-  * [Using VSCode with QMK](other_vscode.md)
-  * [Support](support.md)
+  * [Using Eclipse with QMK](eclipse.md)
 
 * QMK Internals (In Progress)
   * [Defines](internals_defines.md)

docs/breaking_changes.md

@@ -1,108 +0,0 @@
-# Breaking Changes
-
-This document describes QMK's Breaking Change process. A Breaking Change is any change which modifies how QMK behaves in a way that in incompatible or potentially dangerous. We limit these changes so that users can have confidence that updating their QMK tree will not break their keymaps.
-
-The breaking change period is when we will merge PR's that change QMK in dangerous or unexpected ways. There is a built-in period of testing so we are confident that any problems caused are rare or unable to be predicted.
-
-## What has been included in past Breaking Changes?
-
-* [2019 Aug 30](ChangeLog/20190830.md)
-
-## When is the next Breaking Change?
-
-The next Breaking Change is scheduled for Nov 29.
-
-### Important Dates
-
-* [ ] 2019 Oct 04 - `future` is created. It will be rebased weekly.
-* [ ] 2019 Nov 01 - `future` closed to new PR's.
-* [ ] 2019 Nov 01 - Call for testers.
-* [ ] 2019 Nov 27 - `master` is locked, no PR's merged.
-* [ ] 2019 Nov 29 - Merge `future` to `master`.
-* [ ] 2019 Nov 30 - `master` is unlocked. PR's can be merged again.
-
-## What changes will be included?
-
-To see a list of breaking change candidates you can look at the [`breaking_change` label](https://github.com/qmk/qmk_firmware/pulls?q=is%3Aopen+label%3Abreaking_change+is%3Apr). New changes might be added between now and when `future` is closed, and a PR with that label applied is not guaranteed to be merged.
-
-If you want your breaking change to be included in this round you need to create a PR with the `breaking_change` label and have it accepted before `future` closes. After `future` closes no new breaking changes will be accepted.
-
-Criteria for acceptance:
-
-* PR is complete and ready to merge
-* PR has a ChangeLog
-
-# Checklists
-
-This section documents various processes we use when running the Breaking Changes process.
-
-## Rebase `future` from `master`
-
-This is run every Friday while `future` is open.
-
-Process:
-
-```
-cd qmk_firmware
-git checkout master
-git pull --ff-only
-git checkout future
-git rebase master
-git push --force
-```
-
-## 8 Weeks Before Merge
-
-* `qmk_firmware` git commands
-    * [ ] `git checkout master`
-    * [ ] `git pull --ff-only`
-    * [ ] `git checkout -b future`
-    * [ ] Edit `readme.md`
-        * [ ] Add a big notice at the top that this is a testing branch.
-        * [ ] Include a link to this document
-    * [ ] `git commit -m 'Branch point for <DATE> Breaking Change'`
-    * [ ] `git tag breakpoint_<YYYY>_<MM>_<DD>`
-    * [ ] `git tag <next_version>` # Prevent the breakpoint tag from confusing version incrementing
-    * [ ] `git push origin future`
-    * [ ] `git push --tags`
-* GitHub Actions
-    * [ ] Switch all [breaking_change PR's](https://github.com/qmk/qmk_firmware/pulls?utf8=%E2%9C%93&q=is%3Apr+is%3Aopen+label%3Abreaking_change) to `future`
-    * [ ] Any that have a ChangeLog entry may be merged immediately.
-
-## 4 Weeks Before Merge
-
-* `future` is now closed to new PR's, only fixes for current PR's may be merged
-* Post call for testers
-    * [ ] Discord
-    * [ ] GitHub PR
-    * [ ] https://reddit.com/r/olkb
-
-## 1 Week Before Merge
-
-* Announce that master will be closed from <2 Days Before> to <Day of Merge>
-    * [ ] Discord
-    * [ ] GitHub PR
-    * [ ] https://reddit.com/r/olkb
-
-## 2 Days Before Merge
-
-* Announce that master is closed for 2 days
-    * [ ] Discord
-    * [ ] GitHub PR
-    * [ ] https://reddit.com/r/olkb
-
-## Day Of Merge
-
-* `qmk_firmware` git commands
-    * [ ] `git checkout future`
-    * [ ] `git pull --ff-only`
-    * [ ] `git rebase origin/master`
-    * [ ] Edit `readme.md`
-        * [ ] Remove the notes about `future`
-    * [ ] Roll up the ChangeLog into one file.
-    * [ ] `git commit -m 'Merge point for <DATE> Breaking Change'`
-    * [ ] `git push origin future`
-* Github Actions
-    * [ ] Create a PR for `future`
-    * [ ] Make sure travis comes back clean
-    * [ ] Merge `future` PR

docs/cli.md

@@ -1,48 +0,0 @@
-# QMK CLI
-
-This page describes how to setup and use the QMK CLI.
-
-# Overview
-
-The QMK CLI makes building and working with QMK keyboards easier. We have provided a number of commands to help you work with QMK:
-
-* `qmk compile`
-* `qmk doctor`
-
-# Setup
-
-Simply add the `qmk_firmware/bin` directory to your `PATH`. You can run the `qmk` commands from any directory.
-
-```
-export PATH=$PATH:$HOME/qmk_firmware/bin
-```
-
-You may want to add this to your `.profile`, `.bash_profile`, `.zsh_profile`, or other shell startup scripts.
-
-# Commands
-
-## `qmk compile`
-
-This command allows you to compile firmware from any directory. You can compile JSON exports from <https://config.qmk.fm> or compile keymaps in the repo.
-
-**Usage for Configurator Exports**:
-
-```
-qmk compile <configuratorExport.json>
-```
-
-**Usage for Keymaps**:
-
-```
-qmk compile -kb <keyboard_name> -km <keymap_name>
-```
-
-## `qmk cformat`
-
-This command formats C code using clang-format. Run it with no arguments to format all core code, or pass filenames on the command line to run it on specific files.
-
-**Usage**:
-
-```
-qmk cformat [file1] [file2] [...] [fileN]
-```

docs/coding_conventions_c.md

@@ -1,58 +0,0 @@
-# Coding Conventions (C)
-
-Most of our style is pretty easy to pick up on, but right now it's not entirely consistent. You should match the style of the code surrounding your change, but if that code is inconsistent or unclear use the following guidelines:
-
-* We indent using four (4) spaces (soft tabs)
-* We use a modified One True Brace Style
-  * Opening Brace: At the end of the same line as the statement that opens the block
-  * Closing Brace: Lined up with the first character of the statement that opens the block
-  * Else If: Place the closing brace at the beginning of the line and the next opening brace at the end of the same line.
-  * Optional Braces: Always include optional braces.
-    * Good: if (condition) { return false; }
-    * Bad: if (condition) return false;
-* We encourage use of C style comments: `/* */`
-  * Think of them as a story describing the feature
-  * Use them liberally to explain why particular decisions were made.
-  * Do not write obvious comments
-  * If you not sure if a comment is obvious, go ahead and include it.
-* In general we don't wrap lines, they can be as long as needed. If you do choose to wrap lines please do not wrap any wider than 76 columns.
-* We use `#pragma once` at the start of header files rather than old-style include guards (`#ifndef THIS_FILE_H`, `#define THIS_FILE_H`, ..., `#endif`)
-* We accept both forms of preprocessor if's: `#ifdef DEFINED` and `#if defined(DEFINED)`
-  * If you are not sure which to prefer use the `#if defined(DEFINED)` form.
-  * Do not change existing code from one style to the other, except when moving to a multiple condition `#if`.
-  * Do not put whitespace between `#` and `if`.
-  * When deciding how (or if) to indent directives keep these points in mind:
-    * Readability is more important than consistency.
-    * Follow the file's existing style. If the file is mixed follow the style that makes sense for the section you are modifying.
-    * When choosing to indent you can follow the indention level of the surrounding C code, or preprocessor directives can have their own indent level. Choose the style that best communicates the intent of your code.
-
-Here is an example for easy reference:
-
-```c
-/* Enums for foo */
-enum foo_state {
-  FOO_BAR,
-  FOO_BAZ,
-};
-
-/* Returns a value */
-int foo(void) {
-  if (some_condition) {
-    return FOO_BAR;
-  } else {
-    return -1;
-  }
-}
-```
-
-# Auto-formatting with clang-format
-
-[Clang-format](https://clang.llvm.org/docs/ClangFormat.html) is part of LLVM and can automatically format your code for you, because ain't nobody got time to do it manually. We supply a configuration file for it that applies most of the coding conventions listed above. It will only change whitespace and newlines, so you will still have to remember to include optional braces yourself.
-
-Use the [full LLVM installer](http://llvm.org/builds/) to get clang-format on Windows, or use `sudo apt install clang-format` on Ubuntu.
-
-If you run it from the command-line, pass `-style=file` as an option and it will automatically find the .clang-format configuration file in the QMK root directory.
-
-If you use VSCode, the standard C/C++ plugin supports clang-format, alternatively there is a [separate extension](https://marketplace.visualstudio.com/items?itemName=LLVMExtensions.ClangFormat) for it.
-
-Some things (like LAYOUT macros) are destroyed by clang-format, so either don't run it on those files, or wrap the sensitive code in `// clang-format off` and `// clang-format on`.

docs/coding_conventions_python.md

@@ -1,314 +0,0 @@
-# Coding Conventions (Python)
-
-Most of our style follows PEP8 with some local modifications to make things less nit-picky. 
-
-* We target Python 3.5 for compatability with all supported platforms.
-* We indent using four (4) spaces (soft tabs)
-* We encourage liberal use of comments
-  * Think of them as a story describing the feature
-  * Use them liberally to explain why particular decisions were made.
-  * Do not write obvious comments
-  * If you not sure if a comment is obvious, go ahead and include it.
-* We require useful docstrings for all functions.
-* In general we don't wrap lines, they can be as long as needed. If you do choose to wrap lines please do not wrap any wider than 76 columns.
-* Some of our practices conflict with the wider python community to make our codebase more approachable to non-pythonistas.
-
-# YAPF
-
-You can use [yapf](https://github.com/google/yapf) to style your code. We provide a config in [setup.cfg](setup.cfg).
-
-# Imports
-
-We don't have a hard and fast rule for when to use `import ...` vs `from ... import ...`. Understandability and maintainability is our ultimate goal.
-
-Generally we prefer to import specific function and class names from a module to keep code shorter and easier to understand. Sometimes this results in a name that is ambiguous, and in such cases we prefer to import the module instead. You should avoid using the "as" keyword when importing, unless you are importing a compatability module.
-
-Imports should be one line per module. We group import statements together using the standard python rules- system, 3rd party, local.
-
-Do not use `from foo import *`. Supply a list of objects you want to import instead, or import the whole module.
-
-## Import Examples
-
-Good:
-
-```
-from qmk import effects
-
-effects.echo()
-```
-
-Bad:
-
-```
-from qmk.effects import echo
-
-echo()  # It's unclear where echo comes from
-```
-
-Good:
-
-```
-from qmk.keymap import compile_firmware
-
-compile_firmware()
-```
-
-OK, but the above is better:
-
-```
-import qmk.keymap
-
-qmk.keymap.compile_firmware()
-```
-
-# Statements
-
-One statement per line.
-
-Even when allowed (EG `if foo: bar`) we do not combine 2 statements onto a single line.
-
-# Naming
-
-`module_name`, `package_name`, `ClassName`, `method_name`, `ExceptionName`, `function_name`, `GLOBAL_CONSTANT_NAME`, `global_var_name`, `instance_var_name`, `function_parameter_name`, `local_var_name`.
-
-Function names, variable names, and filenames should be descriptive; eschew abbreviation. In particular, do not use abbreviations that are ambiguous or unfamiliar to readers outside your project, and do not abbreviate by deleting letters within a word.
-
-Always use a .py filename extension. Never use dashes.
-
-## Names to Avoid
-
-* single character names except for counters or iterators. You may use "e" as an exception identifier in try/except statements.
-* dashes (-) in any package/module name
-* __double_leading_and_trailing_underscore__ names (reserved by Python)
-
-# Docstrings
-
-To maintain consistency with our docstrings we've set out the following guidelines.
-
-* Use markdown formatting
-* Always use triple-dquote docstrings with at least one linebreak: `"""\n"""`
-* First line is a short (< 70 char) description of what the function does
-* If you need more in your docstring leave a blank line between the description and the rest.
-* Start indented lines at the same indent level as the opening triple-dquote
-* Document all function arguments using the format described below
-* If present, Args:, Returns:, and Raises: should be the last three things in the docstring, separated by a blank line each.
-
-## Simple docstring example
-
-```
-def my_awesome_function():
-    """Return the number of seconds since 1970 Jan 1 00:00 UTC.
-    """
-    return int(time.time())
-```
-
-## Complex docstring example
-
-```
-def my_awesome_function():
-    """Return the number of seconds since 1970 Jan 1 00:00 UTC.
-
-    This function always returns an integer number of seconds.
-    """
-    return int(time.time())
-```
-
-## Function arguments docstring example
-
-```
-def my_awesome_function(start=None, offset=0):
-    """Return the number of seconds since 1970 Jan 1 00:00 UTC.
-
-    This function always returns an integer number of seconds.
-
-
-    Args:
-        start
-            The time to start at instead of 1970 Jan 1 00:00 UTC
-
-        offset
-            Return an answer that has this number of seconds subtracted first
-
-    Returns:
-        An integer describing a number of seconds.
-
-    Raises:
-        ValueError
-            When `start` or `offset` are not positive numbers
-    """
-    if start < 0 or offset < 0:
-        raise ValueError('start and offset must be positive numbers.')
-
-    if not start:
-        start = time.time()
-
-    return int(start - offset)
-```
-
-# Exceptions
-
-Exceptions are used to handle exceptional situations. They should not be used for flow control. This is a break from the python norm of "ask for forgiveness." If you are catching an exception it should be to handle a situation that is unusual.
-
-If you use a catch-all exception for any reason you must log the exception and stacktrace using cli.log.
-
-Make your try/except blocks as short as possible. If you need a lot of try statements you may need to restructure your code.
-
-# Tuples
-
-When defining one-item tuples always include a trailing comma so that it is obvious you are using a tuple. Do not rely on implicit one-item tuple unpacking. Better still use a list which is unambiguous.
-
-This is particularly important when using the printf-style format strings that are commonly used.
-
-# Lists and Dictionaries
-
-We have configured YAPF to differentiate between sequence styles with a trailing comma. When a trailing comma is omitted YAPF will format the sequence as a single line. When a trailing comma is included YAPF will format the sequence with one item per line.
-
-You should generally prefer to keep short definition on a single line. Break out to multiple lines sooner rather than later to aid readability and maintainability.
-
-# Parentheses
-
-Avoid excessive parentheses, but do use parentheses to make code easier to understand. Do not use them in return statements unless you are explicitly returning a tuple, or it is part of a math expression.
-
-# Format Strings
-
-We generally prefer printf-style format strings. Example:
-
-```
-name = 'World'
-print('Hello, %s!' % (name,))
-```
-
-This style is used by the logging module, which we make use of extensively, and we have adopted it in other places for consistency. It is also more familiar to C programmers, who are a big part of our casual audience.
-
-Our included CLI module has support for using these without using the percent (%) operator. Look at `cli.echo()` and the various `cli.log` functions (EG, `cli.log.info()`) for more details.
-
-# Comprehensions & Generator Expressions
-
-We encourage the liberal use of comprehensions and generators, but do not let them get too complex. If you need complexity fall back to a for loop that is easier to understand.
-
-# Lambdas
-
-OK to use but probably should be avoided. With comprehensions and generators the need for lambdas is not as strong as it once was.
-
-# Conditional Expressions
-
-OK in variable assignment, but otherwise should be avoided.
-
-Conditional expressions are if statements that are in line with code. For example:
-
-```
-x = 1 if cond else 2
-```
-
-It's generally not a good idea to use these as function arguments, sequence items, etc. It's too easy to overlook.
-
-# Default Argument Values
-
-Encouraged, but values must be immutable objects.
-
-When specifying default values in argument lists always be careful to specify objects that can't be modified in place. If you use a mutable object the changes you make will persist between calls, which is usually not what you want. Even if that is what you intend to do it is confusing for others and will hinder understanding.
-
-Bad:
-
-```
-def my_func(foo={}):
-    pass
-```
-
-Good:
-
-```
-def my_func(foo=None):
-    if not foo:
-        foo = {}
-```
-
-# Properties
-
-Always use properties instead of getter and setter functions.
-
-```
-class Foo(object):
-    def __init__(self):
-        self._bar = None
-
-    @property
-    def bar(self):
-        return self._bar
-
-    @bar.setter
-    def bar(self, bar):
-        self._bar = bar
-```
-
-# True/False Evaluations
-
-You should generally prefer the implicit True/False evaluation in if statements, rather than checking equivalency.
-
-Bad:
-
-```
-if foo == True:
-    pass
-
-if bar == False:
-    pass
-```
-
-Good:
-
-```
-if foo:
-    pass
-
-if not bar:
-    pass
-```
-
-# Decorators
-
-Use when appropriate. Try to avoid too much magic unless it helps with understanding.
-
-# Threading and Multiprocessing
-
-Should be avoided. If you need this you will have to make a strong case before we merge your code.
-
-# Power Features
-
-Python is an extremely flexible language and gives you many fancy features such as custom metaclasses, access to bytecode, on-the-fly compilation, dynamic inheritance, object reparenting, import hacks, reflection, modification of system internals, etc.
-
-Don't use these.
-
-Performance is not a critical concern for us, and code understandability is. We want our codebase to be approachable by someone who only has a day or two to play with it. These features generally come with a cost to easy understanding, and we would prefer to have code that can be readily understood over faster or more compact code.
-
-Note that some standard library modules use these techniques and it is ok to make use of those modules. But please keep readability and understandability in mind when using them.
-
-# Type Annotated Code
-
-For now we are not using any type annotation system, and would prefer that code remain unannotated. We may revisit this in the future.
-
-# Function length
-
-Prefer small and focused functions.
-
-We recognize that long functions are sometimes appropriate, so no hard limit is placed on function length. If a function exceeds about 40 lines, think about whether it can be broken up without harming the structure of the program.
-
-Even if your long function works perfectly now, someone modifying it in a few months may add new behavior. This could result in bugs that are hard to find. Keeping your functions short and simple makes it easier for other people to read and modify your code.
-
-You could find long and complicated functions when working with some code. Do not be intimidated by modifying existing code: if working with such a function proves to be difficult, you find that errors are hard to debug, or you want to use a piece of it in several different contexts, consider breaking up the function into smaller and more manageable pieces.
-
-# FIXMEs
-
-It is OK to leave FIXMEs in code. Why? Encouraging people to at least document parts of code that need to be thought out more (or that are confusing) is better than leaving this code undocumented.
-
-All FIXMEs should be formatted like:
-
-```
-FIXME(username): Revisit this code when the frob feature is done.
-```
-
-...where username is your GitHub username.
-
-# Unit Tests
-
-These are good. We should have some one day.

docs/config_options.md

@@ -59,8 +59,6 @@ This is a C header file that is one of the first things included, and will persi
   * define is matrix has ghost (unlikely)
 * `#define DIODE_DIRECTION COL2ROW`
   * COL2ROW or ROW2COL - how your matrix is configured. COL2ROW means the black mark on your diode is facing to the rows, and between the switch and the rows.
-* `#define DIRECT_PINS { { F1, F0, B0, C7 }, { F4, F5, F6, F7 } }`
-  * pins mapped to rows and columns, from left to right. Defines a matrix where each switch is connected to a separate pin and ground.
 * `#define AUDIO_VOICES`
   * turns on the alternate audio voices (to cycle through)
 * `#define C4_AUDIO`
@@ -70,33 +68,31 @@ This is a C header file that is one of the first things included, and will persi
 * `#define C6_AUDIO`
   * enables audio on pin C6
 * `#define B5_AUDIO`
-  * enables audio on pin B5 (duophony is enables if one of B[5-7]\_AUDIO is enabled along with one of C[4-6]\_AUDIO)
+  * enables audio on pin B5 (duophony is enables if one of B[5-7]_AUDIO is enabled along with one of C[4-6]_AUDIO)
 * `#define B6_AUDIO`
-  * enables audio on pin B6 (duophony is enables if one of B[5-7]\_AUDIO is enabled along with one of C[4-6]\_AUDIO)
+  * enables audio on pin B6 (duophony is enables if one of B[5-7]_AUDIO is enabled along with one of C[4-6]_AUDIO)
 * `#define B7_AUDIO`
-  * enables audio on pin B7 (duophony is enables if one of B[5-7]\_AUDIO is enabled along with one of C[4-6]\_AUDIO)
+  * enables audio on pin B7 (duophony is enables if one of B[5-7]_AUDIO is enabled along with one of C[4-6]_AUDIO)
 * `#define BACKLIGHT_PIN B7`
-  * pin of the backlight
+  * pin of the backlight - B5, B6, B7 use PWM, others use softPWM
 * `#define BACKLIGHT_LEVELS 3`
   * number of levels your backlight will have (maximum 15 excluding off)
 * `#define BACKLIGHT_BREATHING`
-  * enables backlight breathing
+  * enables backlight breathing (only works with backlight pins B5, B6 and B7)
 * `#define BREATHING_PERIOD 6`
   * the length of one backlight "breath" in seconds
-* `#define DEBOUNCE 5`
+* `#define DEBOUNCING_DELAY 5`
   * the delay when reading the value of the pin (5 is default)
 * `#define LOCKING_SUPPORT_ENABLE`
   * mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap
 * `#define LOCKING_RESYNC_ENABLE`
   * tries to keep switch state consistent with keyboard LED state
-* `#define IS_COMMAND() (get_mods() == MOD_MASK_SHIFT)`
+* `#define IS_COMMAND() ( keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) )`
   * key combination that allows the use of magic commands (useful for debugging)
-* `#define USB_MAX_POWER_CONSUMPTION 500`
+* `#define USB_MAX_POWER_CONSUMPTION`
   * sets the maximum power (in mA) over USB for the device (default: 500)
-* `#define USB_POLLING_INTERVAL_MS 10`
-  * sets the USB polling rate in milliseconds for the keyboard, mouse, and shared (NKRO/media keys) interfaces
-* `#define F_SCL 100000L`
-  * sets the I2C clock rate speed for keyboards using I2C. The default is `400000L`, except for keyboards using `split_common`, where the default is `100000L`.
+* `#define SCL_CLOCK 100000L`
+  * sets the SCL_CLOCK speed for split keyboards. The default is `100000L` but some boards can be set to `400000L`.
 
 ## Features That Can Be Disabled
 
@@ -113,9 +109,9 @@ If you define these options you will disable the associated feature, which can s
 * `#define NO_ACTION_ONESHOT`
   * disable one-shot modifiers
 * `#define NO_ACTION_MACRO`
-  * disable old style macro handling: MACRO() & action_get_macro
+  * disable all macro handling
 * `#define NO_ACTION_FUNCTION`
-  * disable calling of action_function() from the fn_actions array (deprecated)
+  * disable the action function (deprecated)
 
 ## Features That Can Be Enabled
 
@@ -130,8 +126,6 @@ If you define these options you will enable the associated feature, which may in
 
 * `#define TAPPING_TERM 200`
   * how long before a tap becomes a hold, if set above 500, a key tapped during the tapping term will turn it into a hold too
-* `#define TAPPING_TERM_PER_KEY`
-  * enables handling for per key `TAPPING_TERM` settings
 * `#define RETRO_TAPPING`
   * tap anyway, even after TAPPING_TERM, if there was no other key interruption between press and release
   * See [Retro Tapping](feature_advanced_keycodes.md#retro-tapping) for details
@@ -149,11 +143,6 @@ If you define these options you will enable the associated feature, which may in
   * Breaks any Tap Toggle functionality (`TT` or the One Shot Tap Toggle)
 * `#define LEADER_TIMEOUT 300`
   * how long before the leader key times out
-    * If you're having issues finishing the sequence before it times out, you may need to increase the timeout setting. Or you may want to enable the `LEADER_PER_KEY_TIMING` option, which resets the timeout after each key is tapped.
-* `#define LEADER_PER_KEY_TIMING`
-  * sets the timer for leader key chords to run on each key press rather than overall
-* `#define LEADER_KEY_STRICT_KEY_PROCESSING`
-  * Disables keycode filtering for Mod-Tap and Layer-Tap keycodes. Eg, if you enable this, you would need to specify `MT(MOD_CTL, KC_A)` if you want to use `KC_A`.
 * `#define ONESHOT_TIMEOUT 300`
   * how long before oneshot times out
 * `#define ONESHOT_TAP_TOGGLE 2`
@@ -171,25 +160,15 @@ If you define these options you will enable the associated feature, which may in
   * Set this to the number of combos that you're using in the [Combo](feature_combo.md) feature.
 * `#define COMBO_TERM 200`
   * how long for the Combo keys to be detected. Defaults to `TAPPING_TERM` if not defined.
-* `#define TAP_CODE_DELAY 100`
-  * Sets the delay between `register_code` and `unregister_code`, if you're having issues with it registering properly (common on VUSB boards). The value is in milliseconds.
-* `#define TAP_HOLD_CAPS_DELAY 80`
-  * Sets the delay for Tap Hold keys (`LT`, `MT`) when using `KC_CAPSLOCK` keycode, as this has some special handling on MacOS.  The value is in milliseconds, and defaults to 80 ms if not defined. For macOS, you may want to set this to 200 or higher.
 
 ## RGB Light Configuration
 
 * `#define RGB_DI_PIN D7`
-  * pin the DI on the WS2812 is hooked-up to
+  * pin the DI on the ws2812 is hooked-up to
 * `#define RGBLIGHT_ANIMATIONS`
   * run RGB animations
-* `#define RGBLED_NUM 12`
+* `#define RGBLED_NUM 15`
   * number of LEDs
-* `#define RGBLIGHT_SPLIT`
-  * Needed if both halves of the board have RGB LEDs wired directly to the RGB output pin on the controllers instead of passing the output of the left half to the input of the right half
-* `#define RGBLED_SPLIT { 6, 6 }`
-  * number of LEDs connected that are directly wired to `RGB_DI_PIN` on each half of a split keyboard
-  * First value indicates number of LEDs for left half, second value is for the right half
-  * When RGBLED_SPLIT is defined, RGBLIGHT_SPLIT is implicitly defined.
 * `#define RGBLIGHT_HUE_STEP 12`
   * units to step when in/decreasing hue
 * `#define RGBLIGHT_SAT_STEP 25`
@@ -211,61 +190,12 @@ If you define these options you will enable the associated feature, which may in
 
 Split Keyboard specific options, make sure you have 'SPLIT_KEYBOARD = yes' in your rules.mk
 
-* `SPLIT_TRANSPORT = custom`
-  * Allows replacing the standard split communication routines with a custom one. ARM based split keyboards must use this at present.
-
-### Setting Handedness
-
-One thing to remember, the side that the USB port is plugged into is always the master half. The side not plugged into USB is the slave.
-
-There are a few different ways to set handedness for split keyboards (listed in order of precedence):
-
-1. Set `SPLIT_HAND_PIN`: Reads a pin to determine handedness. If pin is high, it's the left side, if low, the half is determined to be the right side
-2. Set `EE_HANDS` and flash `eeprom-lefthand.eep`/`eeprom-righthand.eep` to each half
-   * For boards with DFU bootloader you can use `:dfu-split-left`/`:dfu-split-right` to flash these EEPROM files
-   * For boards with Caterina bootloader (like stock Pro Micros), use `:avrdude-split-left`/`:avrdude-split-right`
-3. Set `MASTER_RIGHT`: Half that is plugged into the USB port is determined to be the master and right half (inverse of the default)
-4. Default: The side that is plugged into the USB port is the master half and is assumed to be the left half. The slave side is the right half
-
-#### Defines for handedness
-
 * `#define SPLIT_HAND_PIN B7`
-  * For using high/low pin to determine handedness, low = right hand, high = left hand. Replace `B7` with the pin you are using. This is optional, and if you leave `SPLIT_HAND_PIN` undefined, then you can still use the EE_HANDS method or MASTER_LEFT / MASTER_RIGHT defines like the stock Let's Split uses.
-
-* `#define EE_HANDS` (only works if `SPLIT_HAND_PIN` is not defined)
-  * Reads the handedness value stored in the EEPROM after `eeprom-lefthand.eep`/`eeprom-righthand.eep` has been flashed to their respective halves.
-
-* `#define MASTER_RIGHT`
-  * Master half is defined to be the right half.
-
-### Other Options
-
+  * For using high/low pin to determine handedness, low = right hand, high = left hand. Replace 'B7' with the pin you are using. This is optional and you can still use the EEHANDS method or MASTER_LEFT / MASTER_RIGHT defines like the stock Let's Split uses.
+  
 * `#define USE_I2C`
   * For using I2C instead of Serial (defaults to serial)
 
-* `#define SOFT_SERIAL_PIN D0`
-  * When using serial, define this. `D0` or `D1`,`D2`,`D3`,`E6`.
-
-* `#define MATRIX_ROW_PINS_RIGHT { <row pins> }`
-* `#define MATRIX_COL_PINS_RIGHT { <col pins> }`
-  * If you want to specify a different pinout for the right half than the left half, you can define `MATRIX_ROW_PINS_RIGHT`/`MATRIX_COL_PINS_RIGHT`. Currently, the size of `MATRIX_ROW_PINS` must be the same as `MATRIX_ROW_PINS_RIGHT` and likewise for the definition of columns.
-
-* `#define DIRECT_PINS_RIGHT { { F1, F0, B0, C7 }, { F4, F5, F6, F7 } }`
-  * If you want to specify a different direct pinout for the right half than the left half, you can define `DIRECT_PINS_RIGHT`. Currently, the size of `DIRECT_PINS` must be the same as `DIRECT_PINS_RIGHT`.
-
-* `#define RGBLED_SPLIT { 6, 6 }`
-  * See [RGB Light Configuration](#rgb-light-configuration)
-
-* `#define SELECT_SOFT_SERIAL_SPEED <speed>` (default speed is 1)
-  * Sets the protocol speed when using serial communication
-  * Speeds:
-    * 0: about 189kbps (Experimental only)
-    * 1: about 137kbps (default)
-    * 2: about 75kbps
-    * 3: about 39kbps
-    * 4: about 26kbps
-    * 5: about 20kbps
-
 # The `rules.mk` File
 
 This is a [make](https://www.gnu.org/software/make/manual/make.html) file that is included by the top-level `Makefile`. It is used to set some information about the MCU that we will be compiling for as well as enabling and disabling certain features.
@@ -294,7 +224,6 @@ This is a [make](https://www.gnu.org/software/make/manual/make.html) file that i
   * `halfkay`
   * `caterina`
   * `bootloadHID`
-  * `USBasp`
 
 ## Feature Options
 
@@ -318,8 +247,6 @@ Use these to enable or disable building certain features. The more you have enab
   * Enable the audio subsystem.
 * `RGBLIGHT_ENABLE`
   * Enable keyboard underlight functionality
-* `LEADER_ENABLE`
-  * Enable leader key chording
 * `MIDI_ENABLE`
   * MIDI controls
 * `UNICODE_ENABLE`
@@ -330,16 +257,10 @@ Use these to enable or disable building certain features. The more you have enab
   * Current options are AdafruitEzKey, AdafruitBLE, RN42
 * `SPLIT_KEYBOARD`
   * Enables split keyboard support (dual MCU like the let's split and bakingpy's boards) and includes all necessary files located at quantum/split_common
-* `CUSTOM_MATRIX`
-  * Allows replacing the standard matrix scanning routine with a custom one.
-* `DEBOUNCE_TYPE`
-  * Allows replacing the standard key debouncing routine with an alternative or custom one.
 * `WAIT_FOR_USB`
   * Forces the keyboard to wait for a USB connection to be established before it starts up
 * `NO_USB_STARTUP_CHECK`
   * Disables usb suspend check after keyboard startup. Usually the keyboard waits for the host to wake it up before any tasks are performed. This is useful for split keyboards as one half will not get a wakeup call but must send commands to the master.
-* `LINK_TIME_OPTIMIZATION_ENABLE`
-  = Enables Link Time Optimization (`LTO`) when compiling the keyboard.  This makes the process take longer, but can significantly reduce the compiled size (and since the firmware is small, the added time is not noticable).  However, this will automatically disable the old Macros and Functions features automatically, as these break when `LTO` is enabled.  It does this by automatically defining `NO_ACTION_MACRO` and `NO_ACTION_FUNCTION` 
 
 ## USB Endpoint Limitations
 

docs/contributing.md

@@ -54,10 +54,42 @@ Never made an open source contribution before? Wondering how contributions work
 
 # Coding Conventions
 
-Most of our style is pretty easy to pick up on. If you are familiar with either C or Python you should not have too much trouble with our local styles.
+Most of our style is pretty easy to pick up on, but right now it's not entirely consistent. You should match the style of the code surrounding your change, but if that code is inconsistent or unclear use the following guidelines:
 
-* [Coding Conventions - C](coding_conventions_c.md)
-* [Coding Conventions - Python](coding_conventions_python.md)
+* We indent using two spaces (soft tabs)
+* We use a modified One True Brace Style
+  * Opening Brace: At the end of the same line as the statement that opens the block
+  * Closing Brace: Lined up with the first character of the statement that opens the block
+  * Else If: Place the closing brace at the beginning of the line and the next opening brace at the end of the same line.
+  * Optional Braces: Always include optional braces.
+    * Good: if (condition) { return false; }
+    * Bad: if (condition) return false;
+* We encourage use of C style comments: `/* */`
+  * Think of them as a story describing the feature
+  * Use them liberally to explain why particular decisions were made.
+  * Do not write obvious comments
+  * If you not sure if a comment is obvious, go ahead and include it.
+* In general we don't wrap lines, they can be as long as needed. If you do choose to wrap lines please do not wrap any wider than 76 columns.
+* We use `#pragma once` at the start of header files rather than old-style include guards (`#ifndef THIS_FILE_H`, `#define THIS_FILE_H`, ..., `#endif`)
+
+Here is an example for easy reference:
+
+```c
+/* Enums for foo */
+enum foo_state {
+  FOO_BAR,
+  FOO_BAZ,
+};
+
+/* Returns a value */
+int foo(void) {
+  if (some_condition) {
+    return FOO_BAR;
+  } else {
+    return -1;
+  }
+}
+```
 
 # General Guidelines
 
@@ -85,20 +117,6 @@ Documentation is one of the easiest ways to get started contributing to QMK. Fin
 
 You'll find all our documentation in the `qmk_firmware/docs` directory, or if you'd rather use a web based workflow you can click "Suggest An Edit" at the top of each page on http://docs.qmk.fm/.
 
-When providing code examples in your documentation, try to observe naming conventions used elsewhere in the docs. For example, standardizing enums as `my_layers` or `my_keycodes` for consistency:
-
-```c
-enum my_layers {
-  _FIRST_LAYER,
-  _SECOND_LAYER
-};
-
-enum my_keycodes {
-  FIRST_LAYER = SAFE_RANGE,
-  SECOND_LAYER
-};
-```
-
 ## Keymaps
 
 Most first-time QMK contributors start with their personal keymaps. We try to keep keymap standards pretty casual (keymaps, after all, reflect the personality of their creators) but we do ask that you follow these guidelines to make it easier for others to discover and learn from your keymap.
@@ -107,7 +125,7 @@ Most first-time QMK contributors start with their personal keymaps. We try to ke
 * All Keymap PR's are squashed, so if you care about how your commits are squashed you should do it yourself
 * Do not lump features in with keymap PR's. Submit the feature first and then a second PR for the keymap.
 * Do not include `Makefile`s in your keymap folder (they're no longer used)
-* Update copyrights in file headers (look for `%YOUR_NAME%`)
+* Update copyrights in file headers (look for `REPLACE_WITH_YOUR_NAME `)
 
 ## Keyboards
 
@@ -120,7 +138,7 @@ We also ask that you follow these guidelines:
 * Do not lump core features in with new keyboards. Submit the feature first and then submit a separate PR for the keyboard.
 * Name `.c`/`.h` file after the immediate parent folder, eg `/keyboards/<kb1>/<kb2>/<kb2>.[ch]`
 * Do not include `Makefile`s in your keyboard folder (they're no longer used)
-* Update copyrights in file headers (look for `%YOUR_NAME%`)
+* Update copyrights in file headers (look for `REPLACE_WITH_YOUR_NAME `)
 
 ## Quantum/TMK Core
 

docs/custom_quantum_functions.md

@@ -90,7 +90,7 @@ keyrecord_t record {
 
 # LED Control
 
-QMK provides methods to read the 5 LEDs defined as part of the HID spec:
+This allows you to control the 5 LED's defined as part of the USB Keyboard spec. It will be called when the state of one of those 5 LEDs changes.
 
 * `USB_LED_NUM_LOCK`
 * `USB_LED_CAPS_LOCK`
@@ -98,47 +98,34 @@ QMK provides methods to read the 5 LEDs defined as part of the HID spec:
 * `USB_LED_COMPOSE`
 * `USB_LED_KANA`
 
-These five constants correspond to the positional bits of the host LED state.
-There are two ways to get the host LED state:
-
-* by implementing `led_set_user()`
-* by calling `host_keyboard_leds()`
-
-## `led_set_user()`
-
-This function will be called when the state of one of those 5 LEDs changes. It receives the LED state as a parameter.
-Use the `IS_LED_ON(usb_led, led_name)` and `IS_LED_OFF(usb_led, led_name)` macros to check the LED status.
-
-!> `host_keyboard_leds()` may already reflect a new value before `led_set_user()` is called.
-
 ### Example `led_set_user()` Implementation
 
 ```c
 void led_set_user(uint8_t usb_led) {
-    if (IS_LED_ON(usb_led, USB_LED_NUM_LOCK)) {
-        writePinLow(B0);
+    if (usb_led & (1<<USB_LED_NUM_LOCK)) {
+        PORTB |= (1<<0);
     } else {
-        writePinHigh(B0);
+        PORTB &= ~(1<<0);
     }
-    if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK)) {
-        writePinLow(B1);
+    if (usb_led & (1<<USB_LED_CAPS_LOCK)) {
+        PORTB |= (1<<1);
     } else {
-        writePinHigh(B1);
+        PORTB &= ~(1<<1);
     }
-    if (IS_LED_ON(usb_led, USB_LED_SCROLL_LOCK)) {
-        writePinLow(B2);
+    if (usb_led & (1<<USB_LED_SCROLL_LOCK)) {
+        PORTB |= (1<<2);
     } else {
-        writePinHigh(B2);
+        PORTB &= ~(1<<2);
     }
-    if (IS_LED_ON(usb_led, USB_LED_COMPOSE)) {
-        writePinLow(B3);
+    if (usb_led & (1<<USB_LED_COMPOSE)) {
+        PORTB |= (1<<3);
     } else {
-        writePinHigh(B3);
+        PORTB &= ~(1<<3);
     }
-    if (IS_LED_ON(usb_led, USB_LED_KANA)) {
-        writePinLow(B4);
+    if (usb_led & (1<<USB_LED_KANA)) {
+        PORTB |= (1<<4);
     } else {
-        writePinHigh(B4);
+        PORTB &= ~(1<<4);
     }
 }
 ```
@@ -148,103 +135,32 @@ void led_set_user(uint8_t usb_led) {
 * Keyboard/Revision: `void led_set_kb(uint8_t usb_led)`
 * Keymap: `void led_set_user(uint8_t usb_led)`
 
-## `host_keyboard_leds()`
 
-Call this function to get the last received LED state. This is useful for reading the LED state outside `led_set_*`, e.g. in [`matrix_scan_user()`](#matrix-scanning-code).
-For convenience, you can use the `IS_HOST_LED_ON(led_name)` and `IS_HOST_LED_OFF(led_name)` macros instead of calling and checking `host_keyboard_leds()` directly.
+# Matrix Initialization Code
 
-## Setting Physical LED State
+Before a keyboard can be used the hardware must be initialized. QMK handles initialization of the keyboard matrix itself, but if you have other hardware like LED's or i&#xb2;c controllers you will need to set up that hardware before it can be used.
 
-Some keyboard implementations provide convenience methods for setting the state of the physical LEDs.
 
-### Ergodox Boards
+### Example `matrix_init_user()` Implementation
 
-The Ergodox implementations provide `ergodox_right_led_1`/`2`/`3_on`/`off()` to turn individual LEDs on or off, as well as `ergodox_right_led_on`/`off(uint8_t led)` to turn them on or off by their index.
-
-In addition, it is possible to specify the brightness level of all LEDs with `ergodox_led_all_set(uint8_t n)`; of individual LEDs with `ergodox_right_led_1`/`2`/`3_set(uint8_t n)`; or by index with `ergodox_right_led_set(uint8_t led, uint8_t n)`.
-
-Ergodox boards also define `LED_BRIGHTNESS_LO` for the lowest brightness and `LED_BRIGHTNESS_HI` for the highest brightness (which is the default).
-
-# Keyboard Initialization Code
-
-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.
-
-* `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 B0, B1, B2, B3, and B4 as LED pins.
+This example, at the keyboard level, sets up B1, B2, and B3 as LED pins.
 
 ```c
-void keyboard_pre_init_user(void) {
-  // Call the keyboard pre init code.
+void matrix_init_user(void) {
+  // Call the keymap level matrix init.
 
   // Set our LED pins as output
-  setPinOutput(B0);
-  setPinOutput(B1);
-  setPinOutput(B2);
-  setPinOutput(B3);
-  setPinOutput(B4);
+  DDRB |= (1<<1);
+  DDRB |= (1<<2);
+  DDRB |= (1<<3);
 }
 ```
 
-### `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.
@@ -260,30 +176,34 @@ This example has been deliberately omitted. You should understand enough about Q
 
 This function gets called at every matrix scan, which is basically as often as the MCU can handle. Be careful what you put here, as it will get run a lot.
 
-You should use this function if you need custom matrix scanning code. It can also be used for custom status output (such as LEDs or a display) or other functionality that you want to trigger regularly even when the user isn't typing.
+You should use this function if you need custom matrix scanning code. It can also be used for custom status output (such as LED's or a display) or other functionality that you want to trigger regularly even when the user isn't typing.
 
 
 # Keyboard Idling/Wake Code
 
 If the board supports it, it can be "idled", by stopping a number of functions.  A good example of this is RGB lights or backlights.   This can save on power consumption, or may be better behavior for your keyboard.
 
-This is controlled by two functions: `suspend_power_down_*` and `suspend_wakeup_init_*`, which are called when the system board is idled and when it wakes up, respectively.
+This is controlled by two functions: `suspend_power_down_*` and `suspend_wakeup_init_*`, which are called when the system is board is idled and when it wakes up, respectively.
 
 
 ### Example suspend_power_down_user() and suspend_wakeup_init_user() Implementation
 
+This example, at the keyboard level, sets up B1, B2, and B3 as LED pins.
 
 ```c
-void suspend_power_down_user(void) {
+void suspend_power_down_user(void)
+{
     rgb_matrix_set_suspend_state(true);
 }
 
-void suspend_wakeup_init_user(void) {
+void suspend_wakeup_init_user(void)
+{
     rgb_matrix_set_suspend_state(false);
 }
+
 ```
 
-### Keyboard suspend/wake  Function Documentation
+### `keyboard_init_*` Function Documentation
 
 * Keyboard/Revision: `void suspend_power_down_kb(void)` and `void suspend_wakeup_init_user(void)`
 * Keymap: `void suspend_power_down_kb(void)` and `void suspend_wakeup_init_user(void)`
@@ -297,8 +217,8 @@ This runs code every time that the layers get changed.  This can be useful for l
 This example shows how to set the [RGB Underglow](feature_rgblight.md) lights based on the layer, using the Planck as an example
 
 ```c
-layer_state_t layer_state_set_user(layer_state_t state) {
-    switch (get_highest_layer(state)) {
+uint32_t layer_state_set_user(uint32_t state) {
+    switch (biton32(state)) {
     case _RAISE:
         rgblight_setrgb (0x00,  0x00, 0xFF);
         break;
@@ -320,9 +240,8 @@ layer_state_t layer_state_set_user(layer_state_t state) {
 ```
 ### `layer_state_set_*` Function Documentation
 
-* Keyboard/Revision: `layer_state_t layer_state_set_kb(layer_state_t state)`
-* Keymap: `layer_state_t layer_state_set_user(layer_state_t state)`
-
+* Keyboard/Revision: `void uint32_t layer_state_set_kb(uint32_t state)`
+* Keymap: `uint32_t layer_state_set_user(uint32_t state)`
 
 The `state` is the bitmask of the active layers, as explained in the [Keymap Overview](keymap.md#keymap-layer-status)
 
@@ -337,13 +256,13 @@ 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! 
 
 
 In your keymap.c file, add this to the top:
-```c
+```
 typedef union {
   uint32_t raw;
   struct {
@@ -356,11 +275,11 @@ user_config_t user_config;
 
 This sets up a 32 bit structure that we can store settings with in memory, and write to the EEPROM. Using this removes the need to define variables, since they're defined in this structure. Remember that `bool` (boolean) values use 1 bit, `uint8_t` uses 8 bits, `uint16_t` uses up 16 bits.  You can mix and match, but changing the order can cause issues, as it will change the values that are read and written. 
 
-We're using `rgb_layer_change`, for the `layer_state_set_*` function, and use `keyboard_post_init_user` and `process_record_user` to configure everything. 
+We're using `rgb_layer_change`, for the `layer_state_set_*` function, and use `matrix_init_user` and `process_record_user` to configure everything. 
 
-Now, using the `keyboard_post_init_user` code above, you want to add `eeconfig_read_user()` to it, to populate the structure you've just created. And you can then immediately use this structure to control functionality in your keymap.  And It should look like: 
-```c
-void keyboard_post_init_user(void) {
+Now, using the `matrix_init_user` code above, you want to add `eeconfig_read_user()` to it, to populate the structure you've just created. And you can then immediately use this structure to control functionality in your keymap.  And It should look like: 
+```
+void matrix_init_user(void) {
   // Call the keymap level matrix init.
 
   // Read the user config from EEPROM
@@ -376,9 +295,9 @@ void keyboard_post_init_user(void) {
 ```
 The above function will use the EEPROM config immediately after reading it, to set the default layer's RGB color. The "raw" value of it is converted in a usable structure based on the "union" that you created above. 
 
-```c
-layer_state_t layer_state_set_user(layer_state_t state) {
-    switch (get_highest_layer(state)) {
+```
+uint32_t layer_state_set_user(uint32_t state) {
+    switch (biton32(state)) {
     case _RAISE:
         if (user_config.rgb_layer_change) { rgblight_sethsv_noeeprom_magenta(); rgblight_mode_noeeprom(1); }
         break;
@@ -398,8 +317,8 @@ layer_state_t layer_state_set_user(layer_state_t state) {
   return state;
 }
 ```
-This will cause the RGB underglow to be changed ONLY if the value was enabled.  Now to configure this value, create a new keycode for `process_record_user` called `RGB_LYR`. Additionally, we want to make sure that if you use the normal RGB codes, that it turns off  Using the example above, make it look this:
-```c
+This will cause the RGB underglow to be changed ONLY if the value was enabled.  Now to configure this value, create a new keycode for `process_record_user` called `RGB_LYR` and `EPRM`. Additionally, we want to make sure that if you use the normal RGB codes, that it turns off  Using the example above, make it look this:
+```
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
@@ -416,6 +335,11 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
             PLAY_NOTE_ARRAY(tone_qwerty);
         }
         return true; // Let QMK send the enter press/release events
+    case EPRM:
+        if (record->event.pressed) {
+            eeconfig_init(); // resets the EEPROM to default
+        }
+        return false;
     case RGB_LYR:  // This allows me to use underglow as layer indication, or as normal
         if (record->event.pressed) { 
             user_config.rgb_layer_change ^= 1; // Toggles the status
@@ -438,11 +362,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   }
 }
 ```
-And lastly, you want to add the `eeconfig_init_user` function, so that when the EEPROM is reset, you can specify default values, and even custom actions. To force an EEPROM reset, use the `EEP_RST` keycode or [Bootmagic](feature_bootmagic.md) functionallity. For example, if you want to set rgb layer indication by default, and save the default valued. 
+And lastly, you want to add the `eeconfig_init_user` function, so that when the EEPROM is reset, you can specify default values, and even custom actions. For example, if you want to set rgb layer indication by default, and save the default valued. 
 
-```c
+```
 void eeconfig_init_user(void) {  // EEPROM is getting reset! 
-  user_config.raw = 0;
   user_config.rgb_layer_change = true; // We want this enabled by default
   eeconfig_update_user(user_config.raw); // Write default value to EEPROM now
 
@@ -461,31 +384,3 @@ And you're done.  The RGB layer indication will only work if you want it to. And
 * Keymap: `void eeconfig_init_user(void)`, `uint32_t eeconfig_read_user(void)` and `void eeconfig_update_user(uint32_t val)`
 
 The `val` is the value of the data that you want to write to EEPROM.  And the `eeconfig_read_*` function return a 32 bit (DWORD) value from the EEPROM. 
-
-# Custom Tapping Term
-
-By default, the tapping term is defined globally, and is not configurable by key.  For most users, this is perfectly fine.  But in come cases, dual function keys would be greatly improved by different timeouts than `LT` keys, or because some keys may be easier to hold than others.  Instead of using custom key codes for each, this allows for per key configurable `TAPPING_TERM`.
-
-To enable this functionality, you need to add `#define TAPPING_TERM_PER_KEY` to your `config.h`, first.  
-
-
-## Example `get_tapping_term` Implementation
-
-To change the `TAPPING TERM` based on the keycode, you'd want to add something like the following to your `keymap.c` file: 
-
-```c
-uint16_t get_tapping_term(uint16_t keycode) {
-  switch (keycode) {
-    case SFT_T(KC_SPC):
-      return TAPPING_TERM + 1250;
-    case LT(1, KC_GRV):
-      return 130;
-    default:
-      return TAPPING_TERM;
-  }
-}
-```
-
-### `get_tapping_term` Function Documentation
-
-Unlike many of the other functions here, there isn't a need (or even reason) to have a quantum or keyboard level function. Only a user level function is useful here, so no need to mark it as such.

docs/driver_installation_zadig.md

@@ -1,46 +0,0 @@
-# Bootloader Driver Installation with Zadig
-
-QMK presents itself to the host as a regular HID keyboard device, and as such requires no special drivers. However, in order to flash your keyboard on Windows, the bootloader device that appears when you reset the board often *does*.
-
-There are two notable exceptions: the Caterina bootloader, usually seen on Pro Micros, and the Halfkay bootloader shipped with PJRC Teensys, appear as a serial port and a generic HID device respectively, and so do not require a driver.
-
-We recommend the use of the [Zadig](https://zadig.akeo.ie/) utility. If you have set up the development environment with Msys2 or WSL, the `qmk_install.sh` script will have asked if you want it to install the drivers for you.
-
-## Installation
-
-Put your keyboard into bootloader mode, either by hitting the `RESET` keycode (which may be on a different layer), or by pressing the reset switch that's usually located on the underside of the board. If your keyboard has neither, try holding Escape or Space+`B` as you plug it in (see the [Bootmagic](feature_bootmagic.md) docs for more details). Some boards use [Command](feature_command.md) instead of Bootmagic; in this case, you can enter bootloader mode by hitting Left Shift+Right Shift+`B` or Left Shift+Right Shift+Escape at any point while the keyboard is plugged in.
-Some keyboards may have specific instructions for entering the bootloader. For example, the [Bootmagic Lite](feature_bootmagic.md#bootmagic-lite) key (default: Escape) might be on a different key, e.g. Left Control; or the magic combination for Command (default: Left Shift+Right Shift) might require you to hold something else, e.g. Left Control+Right Control. Refer to the board's README file if you are unsure.
-
-To put a device in bootloader mode with USBaspLoader, tap the `RESET` button while holding down the `BOOT` button.
-Alternatively, hold `BOOT` while inserting the USB cable.
-
-Zadig will automatically detect the bootloader device. You may sometimes need to check **Options → List All Devices**.
-
- - For keyboards with Atmel AVR MCUs, the bootloader will be named something similar to `ATm32U4DFU`, and have a Vendor ID of `03EB`.
- - USBasp bootloaders will appear as `USBasp`, with a VID/PID of `16C0:05DC`.
- - AVR keyboards flashed with the QMK-DFU bootloader will be named `<keyboard name> Bootloader` and will also have the VID `03EB`.
- - For most ARM keyboards, it will be called `STM32 BOOTLOADER`, and have a VID/PID of `0483:DF11`.
-
-!> If Zadig lists one or more devices with the `HidUsb` driver, your keyboard is probably not in bootloader mode. The arrow will be colored orange and you will be asked to confirm modifying a system driver. **Do not** proceed if this is the case!
-
-If the arrow appears green, select the driver, and click **Install Driver**. The `libusb-win32` driver will usually work for AVR, and `WinUSB` for ARM, but if you still cannot flash the board, try installing a different driver from the list. For flashing a USBaspLoader device via command line with msys2, the `libusbk` driver is recommended, otherwise `libusb-win32` will work fine if you are using QMK Toolbox for flashing.
-
-![Zadig with a bootloader driver correctly installed](https://i.imgur.com/b8VgXzx.png)
-
-Finally, unplug and replug the keyboard to make sure the new driver has been loaded. If you are using the QMK Toolbox to flash, exit and restart it too, as it can sometimes fail to recognize the driver change.
-
-## Recovering from Installation to Wrong Device
-
-If you find that you can no longer type with the keyboard, you may have installed the driver onto the keyboard itself instead of the bootloader. You can easily confirm this in Zadig - a healthy keyboard has the `HidUsb` driver installed on all of its interfaces:
-
-![A healthy keyboard as seen by Zadig](https://i.imgur.com/Hx0E5kC.png)
-
-Open the Device Manager and look for a device that looks like your keyboard.
-
-![The board with the wrong driver installed, in Device Manager](https://i.imgur.com/L3wvX8f.png)
-
-Right-click it and hit **Uninstall device**. Make sure to tick **Delete the driver software for this device** first.
-
-![The Device Uninstall dialog, with the "delete driver" checkbox ticked](https://i.imgur.com/aEs2RuA.png)
-
-Click **Action → Scan for hardware changes**. At this point, you should be able to type again. Double check in Zadig that the keyboard device(s) are using the `HidUsb` driver. If so, you're all done, and your board should be functional again!

docs/faq_build.md

@@ -15,15 +15,11 @@ or just:
 
     $ sudo make <keyboard>:<keymap>:dfu
 
-Note that running `make` with `sudo` is generally ***not*** a good idea, and you should use one of the former methods, if possible.
+Note that running `make` with `sudo` is generally *not* a good idea, and you should use one of the former methods, if possible.
 
 ### Linux `udev` Rules
 On Linux, you'll need proper privileges to access the MCU. You can either use
-`sudo` when flashing firmware, or place these files in `/etc/udev/rules.d/`. Once added run the following:
-```console
-sudo udevadm control --reload-rules
-sudo udevadm trigger
-```
+`sudo` when flashing firmware, or place these files in `/etc/udev/rules.d/`.
 
 **/etc/udev/rules.d/50-atmel-dfu.rules:**
 ```
@@ -40,46 +36,14 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2ff0", MODE:="066
 # tmk keyboard products     https://github.com/tmk/tmk_keyboard
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
 ```
-**/etc/udev/rules.d/54-input-club-keyboard.rules:**
-
-```
-# Input Club keyboard bootloader
-SUBSYSTEMS=="usb", ATTRS{idVendor}=="1c11", MODE:="0666"
-```
-
-**/etc/udev/rules.d/55-catalina.rules:**
-```
-# ModemManager should ignore the following devices
-ATTRS{idVendor}=="2a03", ENV{ID_MM_DEVICE_IGNORE}="1"
-ATTRS{idVendor}=="2341", ENV{ID_MM_DEVICE_IGNORE}="1"
-```
-
-**Note:** ModemManager filtering only works when not in strict mode, the following commands can update that settings:
-```console
-sudo sed -i 's/--filter-policy=strict/--filter-policy=default/' /lib/systemd/system/ModemManager.service
-sudo systemctl daemon-reload
-sudo systemctl restart ModemManager
-```
-
-**/etc/udev/rules.d/56-dfu-util.rules:**
-```
-# stm32duino
-SUBSYSTEMS=="usb", ATTRS{idVendor}=="1eaf", ATTRS{idProduct}=="0003", MODE:="0666"
-# Generic stm32
-SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", 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
 
-Issues encountered when flashing keyboards on Windows are most often due to having the wrong drivers installed for the bootloader, or none at all.
+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. 
 
-Re-running the QMK installation script (`./util/qmk_install.sh` from the `qmk_firmware` directory in MSYS2 or WSL) or reinstalling the QMK Toolbox may fix the issue. Alternatively, you can download and run the [`qmk_driver_installer`](https://github.com/qmk/qmk_driver_installer) package manually.
+Re-running the installation script for MSYS2 may help (eg run `./util/qmk_install.sh` from MSYS2/WSL) or reinstalling the QMK Toolbox may fix the issue. 
 
-If that doesn't work, then you may need to download and run Zadig. See [Bootloader Driver Installation with Zadig](driver_installation_zadig.md) for more detailed information.
+If that doesn't work, then you may need to grab the [Zadig Utility](https://zadig.akeo.ie/). Download this, find the device in question, and select the `WinUS(libusb-1.0)` option, and hit "Reinstall driver". Once you've done that, try flashing your board, again. 
 
 ## WINAVR is Obsolete
 It is no longer recommended and may cause some problem.
@@ -134,9 +98,9 @@ OPT_DEFS += -DBOOTLOADER_SIZE=2048
 ```
 
 ## `avr-gcc: internal compiler error: Abort trap: 6 (program cc1)` on MacOS
-This is an issue with updating on brew, causing symlinks that avr-gcc depend on getting mangled.
+This is an issue with updating on brew, causing symlinks that avr-gcc depend on getting mangled. 
 
-The solution is to remove and reinstall all affected modules.
+The solution is to remove and reinstall all affected modules. 
 
 ```
 brew rm avr-gcc
@@ -161,14 +125,6 @@ For now, you need to rollback avr-gcc to 7 in brew.
 
 ```
 brew uninstall --force avr-gcc
-brew install avr-gcc@8
-brew link --force avr-gcc@8
+brew install avr-gcc@7
+brew link --force avr-gcc@7
 ```
-
-### I just flashed my keyboard and it does nothing/keypresses don't register - it's also ARM (rev6 planck, clueboard 60, hs60v2, etc...) (Feb 2019)
-Due to how EEPROM works on ARM based chips, saved settings may no longer be valid.  This affects the default layers, and *may*, under certain circumstances we are still figuring out, make the keyboard unusable.  Resetting the EEPROM will correct this.
-
-[Planck rev6 reset EEPROM](https://cdn.discordapp.com/attachments/473506116718952450/539284620861243409/planck_rev6_default.bin) can be used to force an eeprom reset. After flashing this image, flash your normal firmware again which should restore your keyboard to _normal_ working order.
-[Preonic rev3 reset EEPROM](https://cdn.discordapp.com/attachments/473506116718952450/537849497313738762/preonic_rev3_default.bin)
-
-If bootmagic is enabled in any form, you should be able to do this too (see [Bootmagic docs](feature_bootmagic.md) and keyboard info for specifics on how to do this).

docs/faq_debug.md

@@ -87,7 +87,6 @@ Size after:
 - EEPROM has around a 100000 write cycle.  You shouldn't rewrite the
   firmware repeatedly and continually; that'll burn the EEPROM
   eventually.
-
 ## NKRO Doesn't work
 First you have to compile firmware with this build option `NKRO_ENABLE` in **Makefile**.
 
@@ -184,15 +183,22 @@ Pressing any key during sleep should wake host.
 
 Arduino Leonardo and micro have **ATMega32U4** and can be used for TMK, though Arduino bootloader may be a problem.
 
-## Enabling JTAG
 
-By default, the JTAG debugging interface is disabled as soon as the keyboard starts up. JTAG-capable MCUs come from the factory with the `JTAGEN` fuse set, and it takes over certain pins of the MCU that the board may be using for the switch matrix, LEDs, etc.
+## Using PF4-7 Pins of USB AVR?
+You need to set JTD bit of MCUCR yourself to use PF4-7 as GPIO. Those pins are configured to serve JTAG function by default. MCUs like ATMega*U* or AT90USB* are affected with this.
 
-If you would like to keep JTAG enabled, just add the following to your `config.h`:
+If you are using Teensy this isn't needed. Teensy is shipped with JTAGEN fuse bit unprogrammed to disable the function.
 
-```c
-#define NO_JTAG_DISABLE
+See this code.
 ```
+    // JTAG disable for PORT F. write JTD bit twice within four cycles.
+    MCUCR |= (1<<JTD);
+    MCUCR |= (1<<JTD);
+```
+https://github.com/tmk/tmk_keyboard/blob/master/keyboard/hbkb/matrix.c#L67
+
+And read **26.5.1 MCU Control Register – MCUCR** of ATMega32U4 datasheet.
+
 
 ## Adding LED Indicators of Lock Keys
 You need your own LED indicators for CapsLock, ScrollLock and NumLock? See this post.

docs/faq_keymap.md

@@ -11,8 +11,8 @@ Keycodes are actually defined in [common/keycode.h](https://github.com/qmk/qmk_f
 
 There are 3 standard keyboard layouts in use around the world- ANSI, ISO, and JIS. North America primarily uses ANSI, Europe and Africa primarily use ISO, and Japan uses JIS. Regions not mentioned typically use either ANSI or ISO. The keycodes corresponding to these layouts are shown here:
 
-<!-- Source for this image: http://www.keyboard-layout-editor.com/#/gists/bf431647d1001cff5eff20ae55621e9a -->
-![Keyboard Layout Image](https://i.imgur.com/5wsh5wM.png)
+<!-- Source for this image: http://www.keyboard-layout-editor.com/#/gists/070a530eedaed36a2d77f3f6fd455677 -->
+![Keyboard Layout Image](https://i.imgur.com/gvlNUpQ.png)
 
 ## Some Of My Keys Are Swapped Or Not Working
 
@@ -151,13 +151,13 @@ This turns right modifier keys into arrow keys when the keys are tapped while st
  */
 const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     /* 0: qwerty */
-    [0] = LAYOUT( \
+    [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,  \
         LSFT,NUBS,Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,FN0, ESC, \
         FN4, LGUI,LALT,          SPC,                     APP, FN2, FN1, FN3),
-    [1] = LAYOUT( \
+    [1] = 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, \
@@ -211,3 +211,20 @@ here real_mods lost state for 'physical left shift'.
 
 weak_mods is ORed with real_mods when keyboard report is sent.
 https://github.com/tmk/tmk_core/blob/master/common/action_util.c#L57
+
+## Timer Functionality
+
+It's possible to start timers and read values for time-specific events - here's an example:
+
+```c
+static uint16_t key_timer;
+key_timer = timer_read();
+
+if (timer_elapsed(key_timer) < 100) {
+  // do something if less than 100ms have passed
+} else {
+  // do something if 100ms or more have passed
+}
+```
+
+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/feature_advanced_keycodes.md

@@ -11,21 +11,21 @@ People often define custom names using `#define`. For example:
 #define ALT_TAB LALT(KC_TAB)
 ```
 
-This will allow you to use `FN_CAPS` and `ALT_TAB` in your keymap, keeping it more readable.
+This will allow you to use `FN_CAPS` and `ALT_TAB` in your `KEYMAP()`, keeping it more readable.
 
 ## Caveats
 
-Currently, `LT()` and `MT()` are limited to the [Basic Keycode set](keycodes_basic.md), meaning you can't use keycodes like `LCTL()`, `KC_TILD`, or anything greater than `0xFF`. Modifiers specified as part of a Layer Tap or Mod Tap's keycode will be ignored. If you need to apply modifiers to your tapped keycode, [Tap Dance](https://github.com/qmk/qmk_firmware/blob/master/docs/feature_tap_dance.md#example-5-using-tap-dance-for-advanced-mod-tap-and-layer-tap-keys) can be used to accomplish this.
+Currently, `LT()` and `MT()` are limited to the [Basic Keycode set](keycodes_basic.md), meaning you can't use keycodes like `LCTL()`, `KC_TILD`, or anything greater than `0xFF`. Modifiers specified as part of a Layer Tap or Mod Tap's keycode will be ignored.
 
 Additionally, if at least one right-handed modifier is specified in a Mod Tap or Layer Tap, it will cause all modifiers specified to become right-handed, so it is not possible to mix and match the two.
 
 # 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)
 
 * `DF(layer)` - switches the default layer. The default layer is the always-active base layer that other layers stack on top of. See below for more about the default layer. This might be used to switch from QWERTY to Dvorak layout. (Note that this is a temporary switch that only persists until the keyboard loses power. To modify the default layer in a persistent way requires deeper customization, such as calling the `set_single_persistent_default_layer` function inside of [process_record_user](custom_quantum_functions.md#programming-the-behavior-of-any-keycode).)
 * `MO(layer)` - momentarily activates *layer*. As soon as you let go of the key, the layer is deactivated. 
-* `LM(layer, mod)` - Momentarily activates *layer* (like `MO`), but with modifier(s) *mod* active. Only supports layers 0-15 and the left modifiers: `MOD_LCTL`, `MOD_LSFT`, `MOD_LALT`, `MOD_LGUI` (note the use of `MOD_` constants instead of `KC_`). These modifiers can be combined using bitwise OR, e.g. `LM(_RAISE, MOD_LCTL | MOD_LALT)`.
+* `LM(layer, mod)` - Momentarily activates *layer* (like `MO`), but with modifier(s) *mod* active. Only supports layers 0-15 and the left modifiers.
 * `LT(layer, kc)` - momentarily activates *layer* when held, and sends *kc* when tapped. Only supports layers 0-15.
 * `OSL(layer)` - momentarily activates *layer* until the next key is pressed. See [One Shot Keys](#one-shot-keys) for details and additional functionality.
 * `TG(layer)` - toggles *layer*, activating it if it's inactive and vice versa
@@ -60,21 +60,21 @@ Sometimes, you might want to switch between layers in a macro or as part of a ta
 
 These allow you to combine a modifier with a keycode. When pressed, the keydown event for the modifier, then `kc` will be sent. On release, the keyup event for `kc`, then the modifier will be sent.
 
-|Key       |Aliases                        |Description                                         |
-|----------|-------------------------------|----------------------------------------------------|
-|`LCTL(kc)`|`C(kc)`                        |Hold Left Control and press `kc`                    |
-|`LSFT(kc)`|`S(kc)`                        |Hold Left Shift and press `kc`                      |
-|`LALT(kc)`|`A(kc)`                        |Hold Left Alt and press `kc`                        |
-|`LGUI(kc)`|`G(kc)`, `LCMD(kc)`, `LWIN(kc)`|Hold Left GUI and press `kc`                        |
-|`RCTL(kc)`|                               |Hold Right Control and press `kc`                   |
-|`RSFT(kc)`|                               |Hold Right Shift and press `kc`                     |
-|`RALT(kc)`|`ALGR(kc)`                     |Hold Right Alt and press `kc`                       |
-|`RGUI(kc)`|`RCMD(kc)`, `LWIN(kc)`         |Hold Right GUI and press `kc`                       |
-|`SGUI(kc)`|`SCMD(kc)`, `SWIN(kc)`         |Hold Left Shift and GUI and press `kc`              |
-|`LCA(kc)` |                               |Hold Left Control and Alt and press `kc`            |
-|`LCAG(kc)`|                               |Hold Left Control, Alt and GUI and press `kc`       |
-|`MEH(kc)` |                               |Hold Left Control, Shift and Alt and press `kc`     |
-|`HYPR(kc)`|                               |Hold Left Control, Shift, Alt and GUI and press `kc`|
+|Key       |Aliases               |Description                                         |
+|----------|----------------------|----------------------------------------------------|
+|`LCTL(kc)`|                      |Hold Left Control and press `kc`                    |
+|`LSFT(kc)`|`S(kc)`               |Hold Left Shift and press `kc`                      |
+|`LALT(kc)`|                      |Hold Left Alt and press `kc`                        |
+|`LGUI(kc)`|`LCMD(kc)`, `LWIN(kc)`|Hold Left GUI and press `kc`                        |
+|`RCTL(kc)`|                      |Hold Right Control and press `kc`                   |
+|`RSFT(kc)`|                      |Hold Right Shift and press `kc`                     |
+|`RALT(kc)`|                      |Hold Right Alt and press `kc`                       |
+|`RGUI(kc)`|`RCMD(kc)`, `LWIN(kc)`|Hold Right GUI and press `kc`                       |
+|`HYPR(kc)`|                      |Hold Left Control, Shift, Alt and GUI and press `kc`|
+|`MEH(kc)` |                      |Hold Left Control, Shift and Alt and press `kc`     |
+|`LCAG(kc)`|                      |Hold Left Control, Alt and GUI and press `kc`       |
+|`SGUI(kc)`|`SCMD(kc)`, `SWIN(kc)`|Hold Left Shift and GUI and press `kc`              |
+|`LCA(kc)` |                      |Hold Left Control and Alt and press `kc`            |
 
 You can also chain them, for example `LCTL(LALT(KC_DEL))` makes a key that sends Control+Alt+Delete with a single keypress.
 
@@ -92,7 +92,7 @@ The modifiers this keycode and `OSM()` accept are prefixed with `MOD_`, not `KC_
 |`MOD_LGUI`|Left GUI (Windows/Command/Meta key)     |
 |`MOD_RCTL`|Right Control                           |
 |`MOD_RSFT`|Right Shift                             |
-|`MOD_RALT`|Right Alt (AltGr)                       |
+|`MOD_RALT`|Right Alt                               |
 |`MOD_RGUI`|Right GUI (Windows/Command/Meta key)    |
 |`MOD_HYPR`|Hyper (Left Control, Shift, Alt and GUI)|
 |`MOD_MEH` |Meh (Left Control, Shift, and Alt)      |
@@ -107,23 +107,23 @@ This key would activate Left Control and Left Shift when held, and send Escape w
 
 For convenience, QMK includes some Mod-Tap shortcuts to make common combinations more compact in your keymap:
 
-|Key         |Aliases                                                          |Description                                            |
-|------------|-----------------------------------------------------------------|-------------------------------------------------------|
-|`LCTL_T(kc)`|`CTL_T(kc)`                                                      |Left Control when held, `kc` when tapped               |
-|`LSFT_T(kc)`|`SFT_T(kc)`                                                      |Left Shift when held, `kc` when tapped                 |
-|`LALT_T(kc)`|`ALT_T(kc)`                                                      |Left Alt when held, `kc` when tapped                   |
-|`LGUI_T(kc)`|`LCMD_T(kc)`, `LWIN_T(kc)`, `GUI_T(kc)`, `CMD_T(kc)`, `WIN_T(kc)`|Left GUI when held, `kc` when tapped                   |
-|`RCTL_T(kc)`|                                                                 |Right Control when held, `kc` when tapped              |
-|`RSFT_T(kc)`|                                                                 |Right Shift when held, `kc` when tapped                |
-|`RALT_T(kc)`|`ALGR_T(kc)`                                                     |Right Alt when held, `kc` when tapped                  |
-|`RGUI_T(kc)`|`RCMD_T(kc)`, `RWIN_T(kc)`                                       |Right GUI when held, `kc` when tapped                  |
-|`SGUI_T(kc)`|`SCMD_T(kc)`, `SWIN_T(kc)`                                       |Left Shift and GUI when held, `kc` when tapped         |
-|`LCA_T(kc)` |                                                                 |Left Control and Alt when held, `kc` when tapped       |
-|`LCAG_T(kc)`|                                                                 |Left Control, Alt and GUI when held, `kc` when tapped  |
-|`RCAG_T(kc)`|                                                                 |Right Control, Alt and GUI when held, `kc` when tapped |
-|`C_S_T(kc)` |                                                                 |Left Control and Shift when held, `kc` when tapped     |
-|`MEH_T(kc)` |                                                                 |Left Control, Shift and Alt when held, `kc` when tapped|
-|`HYPR_T(kc)`|`ALL_T(kc)`                                                      |Left Control, Shift, Alt and GUI when held, `kc` when tapped - more info [here](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)|
+|Key         |Aliases                                |Description                                            |
+|------------|---------------------------------------|-------------------------------------------------------|
+|`LCTL_T(kc)`|`CTL_T(kc)`                            |Left Control when held, `kc` when tapped               |
+|`RCTL_T(kc)`|                                       |Right Control when held, `kc` when tapped              |
+|`LSFT_T(kc)`|`SFT_T(kc)`                            |Left Shift when held, `kc` when tapped                 |
+|`RSFT_T(kc)`|                                       |Right Shift when held, `kc` when tapped                |
+|`LALT_T(kc)`|`ALT_T(kc)`                            |Left Alt when held, `kc` when tapped                   |
+|`RALT_T(kc)`|`ALGR_T(kc)`                           |Right Alt when held, `kc` when tapped                  |
+|`LGUI_T(kc)`|`LCMD_T(kc)`, `RWIN_T(kc)`, `GUI_T(kc)`|Left GUI when held, `kc` when tapped                   |
+|`RGUI_T(kc)`|`RCMD_T(kc)`, `RWIN_T(kc)`             |Right GUI when held, `kc` when tapped                  |
+|`C_S_T(kc)` |                                       |Left Control and Shift when held, `kc` when tapped     |
+|`MEH_T(kc)` |                                       |Left Control, Shift and Alt when held, `kc` when tapped|
+|`LCAG_T(kc)`|                                       |Left Control, Alt and GUI when held, `kc` when tapped  |
+|`RCAG_T(kc)`|                                       |Right Control, Alt and GUI when held, `kc` when tapped |
+|`ALL_T(kc)` |                                       |Left Control, Shift, Alt and GUI when held, `kc` when tapped - more info [here](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)|
+|`SGUI_T(kc)`|`SCMD_T(kc)`, `SWIN_T(kc)`             |Left Shift and GUI when held, `kc` when tapped         |
+|`LCA_T(kc)` |                                       |Left Control and Alt when held, `kc` when tapped       |
 
 ## Caveats
 
@@ -146,7 +146,7 @@ Additionally, hitting keys five times in a short period will lock that key. This
 You can control the behavior of one shot keys by defining these in `config.h`:
 
 ```c
-#define ONESHOT_TAP_TOGGLE 5  /* Tapping this number of times holds the key until tapped once again. */
+#define ONESHOT_TAP_TOGGLE 5  /* Tapping this number of times holds the key until tapped this number of times again. */
 #define ONESHOT_TIMEOUT 5000  /* Time (in ms) before the one shot key is released */
 ```
 
@@ -161,88 +161,8 @@ 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. 
-
-These options let you modify the behavior of the Tap-Hold keys.
-
-## Permissive Hold
+# Permissive Hold
 
 As of [PR#1359](https://github.com/qmk/qmk_firmware/pull/1359/), there is a new `config.h` option:
 
@@ -256,16 +176,16 @@ If you press a Mod Tap key, tap another key (press and release) and then release
 
 For Instance:
 
-- `SFT_T(KC_A)` Down
+- `SHFT_T(KC_A)` Down
 - `KC_X` Down
 - `KC_X` Up
-- `SFT_T(KC_A)` Up
+- `SHFT_T(KC_A)` Up
 
 Normally, if you do all this within the `TAPPING_TERM` (default: 200ms) this will be registered as `ax` by the firmware and host system. With permissive hold enabled, this modifies how this is handled by considering the Mod Tap keys as a Mod if another key is tapped, and would registered as `X` (`SHIFT`+`x`). 
 
 ?> If you have `Ignore Mod Tap Interrupt` enabled, as well, this will modify how both work. The regular key has the modifier added if the first key is released first or if both keys are held longer than the `TAPPING_TERM`.
 
-## Ignore Mod Tap Interrupt
+# Ignore Mod Tap Interrupt
 
 To enable this setting, add this to your `config.h`:
 
@@ -279,9 +199,9 @@ Setting `Ignore Mod Tap Interrupt` requires  holding both keys for the `TAPPING_
 
 For Instance:
 
-- `SFT_T(KC_A)` Down
+- `SHFT_T(KC_A)` Down
 - `KC_X` Down
-- `SFT_T(KC_A)` Up
+- `SHFT_T(KC_A)` Up
 - `KC_X` Up
 
 Normally, this would send `X` (`SHIFT`+`x`). With `Ignore Mod Tap Interrupt` enabled, holding both keys are required for the `TAPPING_TERM` to register the hold action. A quick tap will output `ax` in this case, while a hold on both will still output `X`  (`SHIFT`+`x`).
@@ -291,7 +211,7 @@ Normally, this would send `X` (`SHIFT`+`x`). With `Ignore Mod Tap Interrupt` ena
 
 ?> If you have `Permissive Hold` enabled, as well, this will modify how both work. The regular key has the modifier added if the first key is released first or if both keys are held longer than the `TAPPING_TERM`.
 
-## Tapping Force Hold
+# Tapping Force Hold
 
 To enable `tapping force hold`, add the following to your `config.h`: 
 
@@ -303,11 +223,11 @@ When the user holds a key after tap, this repeats the tapped key rather to hold
 
 Example:
 
-- SFT_T(KC_A) Down
-- SFT_T(KC_A) Up
-- SFT_T(KC_A) Down
+- SHFT_T(KC_A) Down
+- SHFT_T(KC_A) Up
+- SHFT_T(KC_A) Down
 - wait more than tapping term...
-- SFT_T(KC_A) Up
+- SHFT_T(KC_A) Up
 
 With default settings, `a` will be sent on the first release, then `a` will be sent on the second press allowing the computer to trigger its auto repeat function.
 
@@ -315,7 +235,7 @@ With `TAPPING_FORCE_HOLD`, the second press will be interpreted as a Shift, allo
 
 !> `TAPPING_FORCE_HOLD` will break anything that uses tapping toggles (Such as the `TT` layer keycode, and the One Shot Tapping Toggle).
 
-## Retro Tapping
+# Retro Tapping
 
 To enable `retro tapping`, add the following to your `config.h`: 
 

docs/feature_audio.md

@@ -21,8 +21,6 @@ STARTUP_SONG // plays when the keyboard starts up (audio.c)
 GOODBYE_SONG // plays when you press the RESET key (quantum.c)
 AG_NORM_SONG // plays when you press AG_NORM (quantum.c)
 AG_SWAP_SONG // plays when you press AG_SWAP (quantum.c)
-CG_NORM_SONG // plays when you press CG_NORM (quantum.c)
-CG_SWAP_SONG // plays when you press CG_SWAP (quantum.c)
 MUSIC_ON_SONG // plays when music mode is activated (process_music.c)
 MUSIC_OFF_SONG // plays when music mode is deactivated (process_music.c)
 CHROMATIC_SONG // plays when the chromatic music mode is selected (process_music.c)
@@ -63,19 +61,10 @@ It's advised that you wrap all audio features in `#ifdef AUDIO_ENABLE` / `#endif
 
 The available keycodes for audio are: 
 
-* `AU_ON` - Turn Audio Feature on
-* `AU_OFF` - Turn Audio Feature off
-* `AU_TOG` - Toggle Audio Feature state
+* `AU_ON` - Turn audio mode on
+* `AU_OFF` - Turn audio mode off
+* `AU_TOG` - Toggle audio mode
 
-!> These keycodes turn all of the audio functionality on and off.  Turning it off means that audio feedback, audio clicky, music mode, etc. are disabled, completely. 
-
-## ARM Audio Volume
-
-For ARM devices, you can adjust the DAC sample values. If your board is too loud for you or your coworkers, you can set the max using `DAC_SAMPLE_MAX` in your `config.h`:
-
-```c
-#define DAC_SAMPLE_MAX 65535U
-```
 
 ## Music Mode
 
@@ -102,16 +91,6 @@ In music mode, the following keycodes work differently, and don't pass through:
 * `KC_UP` - speed-up playback
 * `KC_DOWN` - slow-down playback
 
-The pitch standard (`PITCH_STANDARD_A`) is 440.0f by default - to change this, add something like this to your `config.h`:
-
-    #define PITCH_STANDARD_A 432.0f
-
-You can completely disable Music Mode as well. This is useful, if you're pressed for space on your controller.  To disable it, add this to your `config.h`:
-
-    #define NO_MUSIC_MODE
-
-### Music Mask
-
 By default, `MUSIC_MASK` is set to `keycode < 0xFF` which means keycodes less than `0xFF` are turned into notes, and don't output anything. You can change this by defining this in your `config.h` like this:
 
     #define MUSIC_MASK keycode != KC_NO
@@ -132,26 +111,13 @@ For a more advanced way to control which keycodes should still be processed, you
 
 Things that return false are not part of the mask, and are always processed.
 
-### Music Map
+The pitch standard (`PITCH_STANDARD_A`) is 440.0f by default - to change this, add something like this to your `config.h`:
 
-By default, the Music Mode uses the columns and row to determine the scale for the keys. For a board that uses a rectangular matrix that matches the keyboard layout, this is just fine.  However, for boards that use a more complicated matrix (such as the Planck Rev6, or many split keyboards) this would result in a very skewed experience.  
+    #define PITCH_STANDARD_A 432.0f
 
-However, the Music Map option allows you to remap the scaling for the music mode, so it fits the layout, and is more natural. 
+You can completely disable Music Mode as well. This is useful, if you're pressed for space on your controller.  To disable it, add this to your `config.h`:
 
-To enable this feature, add `#define MUSIC_MAP` to your `config.h` file, and then you will want to add a `uint8_t music_map` to your keyboard's `c` file, or your `keymap.c`.
-
-```c
-const uint8_t music_map[MATRIX_ROWS][MATRIX_COLS] = LAYOUT_ortho_4x12(
-	36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-	24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
-	12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
-	 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11
-);
-```
-
-You will want to use whichever `LAYOUT` macro that your keyboard uses here.  This maps it to the correct key location.  Start in  the bottom left of the keyboard layout, and  move to the right, and then upwards.  Fill in all the entries until you have a complete matrix.  
-
-You can look at the [Planck Keyboard](https://github.com/qmk/qmk_firmware/blob/e9ace1487887c1f8b4a7e8e6d87c322988bec9ce/keyboards/planck/planck.c#L24-L29) as an example of how to implement this. 
+    #define NO_MUSIC_MODE
 
 ## Audio Click
 
@@ -177,16 +143,15 @@ You can configure the default, min and max frequencies, the stepping and built i
 | `AUDIO_CLICKY_FREQ_DEFAULT` | 440.0f | Sets the default/starting audio frequency for the clicky sounds. |
 | `AUDIO_CLICKY_FREQ_MIN` | 65.0f | Sets the lowest frequency (under 60f are a bit buggy). |
 | `AUDIO_CLICKY_FREQ_MAX` | 1500.0f | Sets the the highest frequency. Too high may result in coworkers attacking you. |
-| `AUDIO_CLICKY_FREQ_FACTOR` | 1.18921f| Sets the stepping of UP/DOWN key codes.  This is a multiplicative factor.  The default steps the frequency up/down by a musical minor third.  |
+| `AUDIO_CLICKY_FREQ_FACTOR` | 1.18921f| Sets the stepping of UP/DOWN key codes. |
 | `AUDIO_CLICKY_FREQ_RANDOMNESS`     |  0.05f |  Sets a factor of randomness for the clicks, Setting this to `0f` will make each click identical, and `1.0f` will make this sound much like the 90's computer screen scrolling/typing effect. | 
-| `AUDIO_CLICKY_DELAY_DURATION` | 1 | An integer note duration where 1 is 1/16th of the tempo, or a sixty-fourth note (see `quantum/audio/musical_notes.h` for implementation details). The main clicky effect will be delayed by this duration.  Adjusting this to values around 6-12 will help compensate for loud switches. |
 
 
 
 
 ## MIDI Functionality
 
-This is still a WIP, but check out `quantum/process_keycode/process_midi.c` to see what's happening. Enable from the Makefile.
+This is still a WIP, but check out `quantum/keymap_midi.c` to see what's happening. Enable from the Makefile.
 
 
 ## Audio Keycodes

docs/feature_backlight.md

@@ -30,33 +30,7 @@ You should then be able to use the keycodes below to change the backlight level.
 
 This feature is distinct from both the [RGB underglow](feature_rgblight.md) and [RGB matrix](feature_rgb_matrix.md) features as it usually allows for only a single colour per switch, though you can obviously use multiple different coloured LEDs on a keyboard.
 
-Hardware PWM is supported according to the following table:
-
-|Backlight Pin|AT90USB64/128|ATmega16/32U4|ATmega16/32U2|ATmega32A|ATmega328P|
-|-------------|-------------|-------------|-------------|---------|----------|
-|`B1`         |             |             |             |         |Timer 1   |
-|`B2`         |             |             |             |         |Timer 1   |
-|`B5`         |Timer 1      |Timer 1      |             |         |          |
-|`B6`         |Timer 1      |Timer 1      |             |         |          |
-|`B7`         |Timer 1      |Timer 1      |Timer 1      |         |          |
-|`C4`         |Timer 3      |             |             |         |          |
-|`C5`         |Timer 3      |             |Timer 1      |         |          |
-|`C6`         |Timer 3      |Timer 3      |Timer 1      |         |          |
-|`D4`         |             |             |             |Timer 1  |          |
-|`D5`         |             |             |             |Timer 1  |          |
-
-All other pins will use software PWM. If the [Audio](feature_audio.md) feature is disabled or only using one timer, the backlight PWM can be triggered by a hardware timer:
-
-|Audio Pin|Audio Timer|Software PWM Timer|
-|---------|-----------|------------------|
-|`C4`     |Timer 3    |Timer 1           |
-|`C5`     |Timer 3    |Timer 1           |
-|`C6`     |Timer 3    |Timer 1           |
-|`B5`     |Timer 1    |Timer 3           |
-|`B6`     |Timer 1    |Timer 3           |
-|`B7`     |Timer 1    |Timer 3           |
-
-When both timers are in use for Audio, the backlight PWM will not use a hardware timer, but will instead be triggered during the matrix scan. In this case, breathing is not supported, and the backlight might flicker, because the PWM computation may not be called with enough timing precision.
+Hardware PWM is only supported on certain pins of the MCU, so if the backlighting is not connected to one of them, a software implementation will be used, and backlight breathing will not be available. Currently the supported pins are `B5`, `B6`, `B7`, and `C6`.
 
 ## Configuration
 
@@ -65,33 +39,9 @@ To change the behaviour of the backlighting, `#define` these in your `config.h`:
 |Define               |Default      |Description                                                                                                  |
 |---------------------|-------------|-------------------------------------------------------------------------------------------------------------|
 |`BACKLIGHT_PIN`      |`B7`         |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this|
-|`BACKLIGHT_PINS`     |*Not defined*|experimental: see below for more information                                                                 |
-|`BACKLIGHT_LEVELS`   |`3`          |The number of brightness levels (maximum 31 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 supported                                                                     |
+|`BACKLIGHT_LEVELS`   |`3`          |The number of brightness levels (maximum 15 excluding off)                                                   |
+|`BACKLIGHT_BREATHING`|*Not defined*|Enable backlight breathing, if hardware PWM is used                                                          |
 |`BREATHING_PERIOD`   |`6`          |The length of one backlight "breath" in seconds                                                              |
-|`BACKLIGHT_ON_STATE` |`0`          |The state of the backlight pin when the backlight is "on" - `1` for high, `0` for low                        |
-
-## Backlight On State
-
-Most backlight circuits are driven by an N-channel MOSFET or NPN transistor. This means that to turn the transistor *on* and light the LEDs, you must drive the backlight pin, connected to the gate or base, *high*.
-Sometimes, however, a P-channel MOSFET, or a PNP transistor is used. In this case, when the transistor is on, the pin is driven *low* instead.
-
-This functionality is configured at the keyboard level with the `BACKLIGHT_ON_STATE` define.
-
-## Multiple backlight pins
-
-Most keyboards have only one backlight pin which control all backlight LEDs (especially if the backlight is connected to an hardware PWM pin).
-In software PWM, it is possible to define multiple backlight pins. All those pins will be turned on and off at the same time during the PWM duty cycle.
-This feature allows to set for instance the Caps Lock LED (or any other controllable LED) brightness at the same level as the other LEDs of the backlight. This is useful if you have mapped LCTRL in place of Caps Lock and you need the Caps Lock LED to be part of the backlight instead of being activated when Caps Lock is on.
-
-To activate multiple backlight pins, you need to add something like this to your user `config.h`:
-
-~~~c
-#define BACKLIGHT_LED_COUNT 2
-#undef BACKLIGHT_PIN
-#define BACKLIGHT_PINS { F5, B2 }
-~~~
 
 ## Hardware PWM Implementation
 
@@ -102,15 +52,6 @@ In this way `OCRxx` essentially controls the duty cycle of the LEDs, and thus th
 The breathing effect is achieved by registering an interrupt handler for `TIMER1_OVF_vect` that is called whenever the counter resets, roughly 244 times per second.
 In this handler, the value of an incrementing counter is mapped onto a precomputed brightness curve. To turn off breathing, the interrupt handler is simply disabled, and the brightness reset to the level stored in EEPROM.
 
-## Software PWM Implementation
-
-When `BACKLIGHT_PIN` is not set to a hardware backlight pin, QMK will use a hardware timer configured to trigger software interrupts. This time will count up to `ICRx` (by default `0xFFFF`) before resetting to 0.
-When resetting to 0, the CPU will fire an OVF (overflow) interrupt that will turn the LEDs on, starting the duty cycle.
-The desired brightness is calculated and stored in the `OCRxx` register. When the counter reaches this value, the CPU will fire a Compare Output match interrupt, which will turn the LEDs off.
-In this way `OCRxx` essentially controls the duty cycle of the LEDs, and thus the brightness, where `0x0000` is completely off and `0xFFFF` is completely on.
-
-The breathing effect is the same as in the hardware PWM implementation.
-
 ## Backlight Functions
 
 |Function  |Description                                                |
@@ -121,8 +62,7 @@ The breathing effect is the same as in the hardware PWM implementation.
 |`backlight_step()`      |Cycle through backlight levels               |
 |`backlight_increase()`  |Increase the backlight level                 |
 |`backlight_decrease()`  |Decrease the backlight level                 |
-|`backlight_level(x)`    |Sets the backlight level, from 0 to          |
-|                        |`BACKLIGHT_LEVELS`                           |
+|`backlight_level(x)`    |Sets the backlight level to specified level  |
 |`get_backlight_level()` |Return the current backlight level           |
 |`is_backlight_enabled()`|Return whether the backlight is currently on |
 

docs/feature_bootmagic.md

@@ -64,11 +64,8 @@ Hold down the Bootmagic key (Space by default) and the desired hotkey while plug
 |`MAGIC_NO_GUI`                    |         |Disable the GUI keys (useful when gaming) |
 |`MAGIC_UNNO_GUI`                  |         |Enable the GUI keys                       |
 |`MAGIC_SWAP_ALT_GUI`              |`AG_SWAP`|Swap Alt and GUI on both sides (for macOS)|
-|`MAGIC_UNSWAP_ALT_GUI`            |`AG_NORM`|Unswap Alt and GUI                        |
-|`MAGIC_TOGGLE_ALT_GUI`            |`AG_TOGG`|Toggle Alt and GUI swap                   |
-|`MAGIC_SWAP_CTL_GUI`              |`CG_SWAP`|Swap Ctrl and GUI on both sides (for macOS)|
-|`MAGIC_UNSWAP_CTL_GUI`            |`CG_NORM`|Unswap Ctrl and GUI                       |
-|`MAGIC_TOGGLE_CTL_GUI`            |`CG_TOGG`|Toggle Ctrl and GUI swap                  |
+|`MAGIC_UNSWAP_ALT_GUI`            |`AG_NORM`|Unswap Left Alt and Left GUI              |
+|`MAGIC_TOGGLE_ALT_GUI`            |`AG_TOGG`|Toggle Left Alt and GUI swap              |
 |`MAGIC_SWAP_BACKSLASH_BACKSPACE`  |         |Swap `\` and Backspace                    |
 |`MAGIC_UNSWAP_BACKSLASH_BACKSPACE`|         |Unswap `\` and Backspace                  |
 |`MAGIC_SWAP_CONTROL_CAPSLOCK`     |         |Swap Left Control and Caps Lock           |
@@ -79,10 +76,6 @@ Hold down the Bootmagic key (Space by default) and the desired hotkey while plug
 |`MAGIC_UNSWAP_LALT_LGUI`          |         |Unswap Left Alt and Left GUI              |
 |`MAGIC_SWAP_RALT_RGUI`            |         |Swap Right Alt and Right GUI              |
 |`MAGIC_UNSWAP_RALT_RGUI`          |         |Unswap Right Alt and Right GUI            |
-|`MAGIC_SWAP_LCTL_LGUI`            |         |Swap Left Control and Left GUI            |
-|`MAGIC_UNSWAP_LCTL_LGUI`          |         |Unswap Left Control and Left GUI          |
-|`MAGIC_SWAP_RCTL_RGUI`            |         |Swap Right Control and Right GUI          |
-|`MAGIC_UNSWAP_RCTL_RGUI`          |         |Unswap Right Control and Right GUI        |
 
 ## Configuration
 
@@ -134,9 +127,7 @@ 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.
-
-!> Using bootmagic lite will **always reset** the EEPROM, so you will lose any settings that have been saved.
+And to trigger the bootloader, you hold this key down when plugging the keyboard in. Just the single key. 
 
 ## Advanced Bootmagic Lite
 
@@ -147,7 +138,7 @@ To replace the function, all you need to do is add something like this to your c
 ```c
 void bootmagic_lite(void) {
     matrix_scan();
-    wait_ms(DEBOUNCE * 2);
+    wait_ms(DEBOUNCING_DELAY * 2);
     matrix_scan();
 
     if (matrix_get_row(BOOTMAGIC_LITE_ROW) & (1 << BOOTMAGIC_LITE_COLUMN)) {

docs/feature_combo.md

@@ -2,7 +2,7 @@
 
 The Combo feature is a chording type solution for adding custom actions.  It lets you hit multiple keys at once and produce a different effect.  For instance, hitting `A` and `S` within the tapping term would hit `ESC` instead, or have it perform even more complex tasks.
 
-To enable this feature, you need to add `COMBO_ENABLE = yes` to your `rules.mk`.
+To enable this feature, yu need to add `COMBO_ENABLE = yes` to your `rules.mk`.
 
 Additionally, in your `config.h`, you'll need to specify the number of combos that you'll be using, by adding `#define COMBO_COUNT 1` (replacing 1 with the number that you're using).
 <!-- At this time, this is necessary -->
@@ -19,6 +19,7 @@ combo_t key_combos[COMBO_COUNT] = {COMBO(test_combo, KC_ESC)};
 This will send "Escape" if you hit the A and B keys.
 
 !> This method only supports [basic keycodes](keycodes_basic.md). See the examples for more control.
+!> You cannot reuse (share) keys in combos. Each key should only belong to a single combo.  
 
 ## Examples
 
@@ -28,8 +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};
 
@@ -45,7 +45,7 @@ For a more complicated implementation, you can use the `process_combo_event` fun
 enum combo_events {
   ZC_COPY,
   XV_PASTE
-};
+  };
 
 const uint16_t PROGMEM copy_combo[] = {KC_Z, KC_C, COMBO_END};
 const uint16_t PROGMEM paste_combo[] = {KC_X, KC_V, COMBO_END};
@@ -59,12 +59,19 @@ void process_combo_event(uint8_t combo_index, bool pressed) {
   switch(combo_index) {
     case ZC_COPY:
       if (pressed) {
-        tap_code16(LCTL(KC_C));
+        register_code(KC_LCTL);
+        register_code(KC_C);
+        unregister_code(KC_C);
+        unregister_code(KC_LCTL);
       }
       break;
+
     case XV_PASTE:
       if (pressed) {
-        tap_code16(LCTL(KC_V));
+        register_code(KC_LCTL);
+        register_code(KC_V);
+        unregister_code(KC_V);
+        unregister_code(KC_LCTL);
       }
       break;
   }
@@ -80,24 +87,3 @@ If you're using long combos, or even longer combos, you may run into issues with
 In this case, you can add either `#define EXTRA_LONG_COMBOS` or `#define EXTRA_EXTRA_LONG_COMBOS` in your `config.h` file.
 
 You may also be able to enable action keys by defining `COMBO_ALLOW_ACTION_KEYS`.
-
-## Keycodes 
-
-You can enable, disable and toggle the Combo feature on the fly.  This is useful if you need to disable them temporarily, such as for a game. 
-
-|Keycode   |Description                      |
-|----------|---------------------------------|
-|`CMB_ON`  |Turns on Combo feature           |
-|`CMB_OFF` |Turns off Combo feature          |
-|`CMB_TOG` |Toggles Combo feature on and off |
-
-## User callbacks
-
-In addition to the keycodes, there are a few functions that you can use to set the status, or check it:
-
-|Function   |Description                                                         |
-|-----------|--------------------------------------------------------------------|
-| `combo_enable()`     | Enables the combo feature                               |
-| `combo_disable()`    | Disables the combo feature, and clears the combo buffer |
-| `combo_toggle()`     | Toggles the state of the combo feature                  |
-| `is_combo_enabled()` | Returns the status of the combo feature state (true or false) |

docs/feature_command.md

@@ -16,36 +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                                     |
-|------------------------------------|--------------------------------|------------------------------------------------|
-|`IS_COMMAND()`                      |`(get_mods() == MOD_MASK_SHIFT)`|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_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_DEBUG`                   |`D`                             |Toggle debugging over serial                    |
-|`MAGIC_KEY_DEBUG_MATRIX`            |`X`                             |Toggle key matrix debugging                     |
-|`MAGIC_KEY_DEBUG_KBD`               |`K`                             |Toggle keyboard debugging                       |
-|`MAGIC_KEY_DEBUG_MOUSE`             |`M`                             |Toggle mouse debugging                          |
-|`MAGIC_KEY_CONSOLE`                 |`C`                             |Enable the Command 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_HELP`                    |`H`                             |Print Command help to the console               |
-|`MAGIC_KEY_HELP_ALT`                |`SLASH`                         |Print Command help to the console (alternate)   |
-|`MAGIC_KEY_LAYER0`                  |`0`                             |Make layer 0 the default layer                  |
-|`MAGIC_KEY_LAYER0_ALT`              |`GRAVE`                         |Make layer 0 the default layer (alternate)      |
-|`MAGIC_KEY_LAYER1`                  |`1`                             |Make layer 1 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_LAYER4`                  |`4`                             |Make layer 4 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_LAYER7`                  |`7`                             |Make layer 7 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_BOOTLOADER`              |`B`                             |Jump to bootloader                              |
-|`MAGIC_KEY_BOOTLOADER_ALT`          |`ESC`                           |Jump to bootloader (alternate)                  |
-|`MAGIC_KEY_LOCK`                    |`CAPS`                          |Lock the keyboard so nothing can be typed       |
-|`MAGIC_KEY_EEPROM`                  |`E`                             |Print stored EEPROM config to the console       |
-|`MAGIC_KEY_EEPROM_CLEAR`            |`BSPACE`                        |Clear the EEPROM                                |
-|`MAGIC_KEY_NKRO`                    |`N`                             |Toggle N-Key Rollover (NKRO)                    |
-|`MAGIC_KEY_SLEEP_LED`               |`Z`                             |Toggle LED when computer is sleeping            |
+|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         |
+|`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_CUSTOM`|`false`                                                                               |Set default layer with `MAGIC_KEY_LAYER0..9`    |
+|`MAGIC_KEY_DEBUG`                   |`D`                                                                                   |Toggle debugging over serial                    |
+|`MAGIC_KEY_DEBUG_MATRIX`            |`X`                                                                                   |Toggle key matrix debugging                     |
+|`MAGIC_KEY_DEBUG_KBD`               |`K`                                                                                   |Toggle keyboard debugging                       |
+|`MAGIC_KEY_DEBUG_MOUSE`             |`M`                                                                                   |Toggle mouse debugging                          |
+|`MAGIC_KEY_CONSOLE`                 |`C`                                                                                   |Enable the Command 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_HELP1`                   |`H`                                                                                   |Print Command help to the console               |
+|`MAGIC_KEY_HELP2`                   |`SLASH`                                                                               |Print Command help to the console (alternate)   |
+|`MAGIC_KEY_LAYER0`                  |`0`                                                                                   |Make layer 0 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_LAYER3`                  |`3`                                                                                   |Make layer 3 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_LAYER6`                  |`6`                                                                                   |Make layer 6 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_LAYER9`                  |`9`                                                                                   |Make layer 9 the default layer                  |
+|`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_BOOTLOADER`              |`PAUSE`                                                                               |Enter the bootloader                            |
+|`MAGIC_KEY_LOCK`                    |`CAPS`                                                                                |Lock the keyboard so nothing can be typed       |
+|`MAGIC_KEY_EEPROM`                  |`E`                                                                                   |Clear the EEPROM                                |
+|`MAGIC_KEY_NKRO`                    |`N`                                                                                   |Toggle N-Key Rollover (NKRO)                    |
+|`MAGIC_KEY_SLEEP_LED`               |`Z`                                                                                   |Toggle LED when computer is sleeping            |

docs/feature_debounce_type.md

@@ -1,42 +0,0 @@
-# Debounce algorithm
-
-QMK supports multiple debounce algorithms through its debounce API.
-
-The logic for which debounce method called is below. It checks various defines that you have set in rules.mk
-
-```
-DEBOUNCE_DIR:= $(QUANTUM_DIR)/debounce
-DEBOUNCE_TYPE?= sym_g
-ifneq ($(strip $(DEBOUNCE_TYPE)), custom)
-    QUANTUM_SRC += $(DEBOUNCE_DIR)/$(strip $(DEBOUNCE_TYPE)).c
-endif
-```
-
-# Debounce selection
-
-| DEBOUNCE_TYPE    | Description                                          | What else is needed           |
-| -------------    | ---------------------------------------------------  | ----------------------------- |
-| Not defined      | Use the default algorithm, currently sym_g           | Nothing                       |
-| custom           | Use your own debounce.c                              | ```SRC += debounce.c``` add your own debounce.c and implement necessary functions |
-| anything_else    | Use another algorithm from quantum/debounce/*        | Nothing                       |
-
-**Regarding split keyboards**:
-The debounce code is compatible with split keyboards.
-
-# Use your own debouncing code
-* Set ```DEBOUNCE_TYPE = custom ```.
-* Add ```SRC += debounce.c```
-* Add your own ```debounce.c```. Look at current implementations in ```quantum/debounce``` for examples.
-* Debouncing occurs after every raw matrix scan.
-* Use num_rows rather than MATRIX_ROWS, so that split keyboards are supported correctly.
-
-# Changing between included debouncing methods
-You can either use your own code, by including your own debounce.c, or switch to another included one.
-Included debounce methods are:
-* eager_pr - debouncing per row. On any state change, response is immediate, followed by locking the row ```DEBOUNCE_DELAY``` milliseconds of no further input for that row. 
-For use in keyboards where refreshing ```NUM_KEYS``` 8-bit counters is computationally expensive / low scan rate, and fingers usually only hit one row at a time. This could be
-appropriate for the ErgoDox models; the matrix is rotated 90°, and hence its "rows" are really columns, and each finger only hits a single "row" at a time in normal use.
-* eager_pk - debouncing per key. On any state change, response is immediate, followed by ```DEBOUNCE_DELAY``` milliseconds of no further input for that key
-* sym_g - debouncing per keyboard. On any state change, a global timer is set. When ```DEBOUNCE_DELAY``` milliseconds of no changes has occured, all input changes are pushed.
-
-

docs/feature_dip_switch.md

@@ -1,90 +0,0 @@
-# DIP Switches
-
-DIP switches are supported by adding this to your `rules.mk`:
-
-    DIP_SWITCH_ENABLE = yes
-
-and this to your `config.h`:
-
-```c
-#define DIP_SWITCH_PINS { B14, A15, A10, B9 }
-```
-
-## Callbacks
-
-The callback functions can be inserted into your `<keyboard>.c`:
-
-```c
-void dip_switch_update_kb(uint8_t index, bool active) { 
-    dip_switch_update_user(index, active); 
-}
-```
-
-
-or `keymap.c`:
-
-```c
-void dip_switch_update_user(uint8_t index, bool active) { 
-    switch (index) {
-        case 0:
-            if(active) { audio_on(); } else { audio_off(); }
-            break;
-        case 1:
-            if(active) { clicky_on(); } else { clicky_off(); }
-            break;
-        case 2:
-            if(active) { music_on(); } else { music_off(); }
-            break;
-        case 3:
-            if (active) {
-                #ifdef AUDIO_ENABLE
-                    PLAY_SONG(plover_song);
-                #endif
-                layer_on(_PLOVER);
-            } else {
-                #ifdef AUDIO_ENABLE
-                    PLAY_SONG(plover_gb_song);
-                #endif
-                layer_off(_PLOVER);
-            }
-            break;
-    }
-}
-```
-
-Additionally, we support bit mask functions which allow for more complex handling. 
-
-
-```c
-void dip_switch_update_mask_kb(uint32_t state) { 
-    dip_switch_update_mask_user(state); 
-}
-```
-
-
-or `keymap.c`:
-
-```c
-void dip_switch_update_mask_user(uint32_t state) { 
-    if (state & (1UL<<0) && state & (1UL<<1)) {
-        layer_on(_ADJUST); // C on esc
-    } else {
-        layer_off(_ADJUST);
-    }
-    if (state & (1UL<<0)) {
-        layer_on(_TEST_A); // A on ESC
-    } else {
-        layer_off(_TEST_A);
-    }
-    if (state & (1UL<<1)) {
-        layer_on(_TEST_B); // B on esc
-    } else {
-        layer_off(_TEST_B);
-    }
-}
-```
-
-
-## Hardware
-
-One side of the DIP switch should be wired directly to the pin on the MCU, and the other side to ground.  It should not matter which side is connected to which, as it should be functionally the same. 

docs/feature_encoders.md

@@ -6,13 +6,14 @@ Basic encoders are supported by adding this to your `rules.mk`:
 
 and this to your `config.h`:
 
+    #define NUMBER_OF_ENCODERS 1
     #define ENCODERS_PAD_A { B12 }
     #define ENCODERS_PAD_B { B13 }
 
 Each PAD_A/B variable defines an array so multiple encoders can be defined, e.g.:
 
     #define ENCODERS_PAD_A { encoder1a, encoder2a }
-    #define ENCODERS_PAD_B { encoder1b, encoder2b }
+    #define ENCODERS_PAD_B { encoder1a, encoder2b }
 
 If your encoder's clockwise directions are incorrect, you can swap the A & B pad definitions.
 
@@ -20,15 +21,6 @@ Additionally, the resolution can be specified in the same file (the default & su
 
     #define ENCODER_RESOLUTION 4
 
-## Split Keyboards
-
-If you are using different pinouts for the encoders on each half of a split keyboard, you can define the pinout for the right half like this:
-
-```c
-#define ENCODERS_PAD_A_RIGHT { encoder1a, encoder2a }
-#define ENCODERS_PAD_B_RIGHT { encoder1b, encoder2b }
-```
-
 ## Callbacks
 
 The callback functions can be inserted into your `<keyboard>.c`:
@@ -40,19 +32,15 @@ The callback functions can be inserted into your `<keyboard>.c`:
 or `keymap.c`:
 
     void encoder_update_user(uint8_t index, bool clockwise) {
-      if (index == 0) { /* First encoder */
-        if (clockwise) {
-          tap_code(KC_PGDN);
-        } else {
-          tap_code(KC_PGUP);
+        if (index == 0) {
+            if (clockwise) {
+                register_code(KC_PGDN);
+                unregister_code(KC_PGDN);
+            } else {
+                register_code(KC_PGUP);
+                unregister_code(KC_PGUP);
+            }
         }
-      } else if (index == 1) { /* Second encoder */  
-        if (clockwise) {
-          tap_code(KC_UP);
-        } else {
-          tap_code(KC_DOWN);
-        }
-      }
     }
 
 ## Hardware

docs/feature_grave_esc.md

@@ -4,11 +4,7 @@ If you're using a 60% keyboard, or any other layout with no F-row, you will have
 
 ## Usage
 
-Replace the `KC_GRAVE` key in your keymap (usually to the left of the `1` key) with `KC_GESC`. Most of the time this key will output `KC_ESC` when pressed. However, when Shift or GUI are held down it will output `KC_GRV` instead.
-
-## What Your OS Sees
-
-If Mary presses GESC on her keyboard, the OS will see an KC_ESC character. Now if Mary holds Shift down and presses GESC it will output `~`, or a shifted backtick. Now if she holds GUI/CMD/WIN, it will output a simple <code>&#96;</code> character.
+Replace the `KC_GRAVE` key in your keymap (usually to the left of the `1` key) with `KC_GESC`. When pressed it will behave like `KC_ESC`, but with Shift or GUI held it will send `KC_GRAVE`.
 
 ## Keycodes
 
@@ -16,10 +12,6 @@ If Mary presses GESC on her keyboard, the OS will see an KC_ESC character. Now i
 |---------|-----------|------------------------------------------------------------------|
 |`KC_GESC`|`GRAVE_ESC`|Escape when pressed, <code>&#96;</code> when Shift or GUI are held|
 
-### Caveats
-
-On macOS, Command+<code>&#96;</code> is by default mapped to "Move focus to next window" so it will not output a backtick. Additionally, Terminal always recognises this shortcut to cycle between windows, even if the shortcut is changed in the Keyboard preferences.
-
 ## Configuration
 
 There are several possible key combinations this will break, among them Control+Shift+Escape on Windows and Command+Option+Escape on macOS. To work around this, you can `#define` these options in your `config.h`:

docs/feature_haptic_feedback.md

@@ -1,154 +0,0 @@
-# Haptic Feedback
-
-## Haptic feedback rules.mk options
-
-The following options are currently available for haptic feedback in `rule.mk`:
-
-`HAPTIC_ENABLE += DRV2605L`
-
-`HAPTIC_ENABLE += SOLENOID`
-
-## Known Supported Hardware
-
-| Name               | Description                                     |
-|--------------------|-------------------------------------------------|
-| [LV061228B-L65-A](https://www.digikey.com/product-detail/en/jinlong-machinery-electronics-inc/LV061228B-L65-A/1670-1050-ND/7732325) | z-axis 2v LRA |
-| [Mini Motor Disc](https://www.adafruit.com/product/1201)  | small 2-5v ERM |
-
-## Haptic Keycodes
-
-Not all keycodes below will work depending on which haptic mechanism you have chosen.
-
-| Name      | Description                                           |
-|-----------|-------------------------------------------------------|
-|`HPT_ON`   | Turn haptic feedback on                               |
-|`HPT_OFF`  | Turn haptic feedback on                               |
-|`HPT_TOG`  | Toggle haptic feedback on/off                         |
-|`HPT_RST`  | Reset haptic feedback config to default               |
-|`HPT_FBK`  | Toggle feedback to occur on keypress, release or both |
-|`HPT_BUZ`  | Toggle solenoid buzz on/off                           |
-|`HPT_MODI` | Go to next DRV2605L waveform                          |
-|`HPT_MODD` | Go to previous DRV2605L waveform                      |
-|`HPT_CONT` | Toggle continuous haptic mode on/off                  |
-|`HPT_CONI` | Increase DRV2605L continous haptic strength           |
-|`HPT_COND` | Decrease DRV2605L continous haptic strength           |
-|`HPT_DWLI` | Increase Solenoid dwell time                          |
-|`HPT_DWLD` | Decrease Solenoid dwell time                          |
-
-### Solenoids
-
-First you will need a build a circuit to drive the solenoid through a mosfet as most MCU will not be able to provide the current needed to drive the coil in the solenoid.
-
-[Wiring diagram provided by Adafruit](https://playground.arduino.cc/uploads/Learning/solenoid_driver.pdf)
-
-Select a pin that has PWM for the signal pin
-
-```
-#define SOLENOID_PIN *pin*
-```
-
-Beware that some pins may be powered during bootloader (ie. A13 on the STM32F303 chip) and will result in the solenoid kept in the on state through the whole flashing process. This may overheat and damage the solenoid. If you find that the pin the solenoid is connected to is triggering the solenoid during bootloader/DFU, select another pin.
-
-### DRV2605L
-
-DRV2605L is controlled over i2c protocol, and has to be connected to the SDA and SCL pins, these varies depending on the MCU in use.
-
-#### Feedback motor setup
-
-This driver supports 2 different feedback motors. Set the following in your `config.h` based on which motor you have selected.
-
-##### ERM
-
-Eccentric Rotating Mass vibration motors (ERM) is motor with a off-set weight attached so when drive signal is attached, the off-set weight spins and causes a sinusoidal wave that translate into vibrations.
-
-```
-#define FB_ERM_LRA 0
-#define FB_BRAKEFACTOR 3 /* For 1x:0, 2x:1, 3x:2, 4x:3, 6x:4, 8x:5, 16x:6, Disable Braking:7 */
-#define FB_LOOPGAIN 1 /* For  Low:0, Medium:1, High:2, Very High:3 */
-
-/* Please refer to your datasheet for the optimal setting for your specific motor. */
-#define RATED_VOLTAGE 3
-#define V_PEAK 5
-```
-##### LRA
-
-Linear resonant actuators (LRA, also know as a linear vibrator) works different from a ERM. A LRA has a weight and magnet suspended by springs and a voice coil. When the drive signal is applied, the weight would be vibrate on a single axis (side to side or up and down). Since the weight is attached to a spring, there is a resonance effect at a specific frequency. This frequency is where the LRA will operate the most efficiently. Refer to the motor's datasheet for the recommanded range for this frequency.
-
-``` 
-#define FB_ERM_LRA 1
-#define FB_BRAKEFACTOR 3 /* For 1x:0, 2x:1, 3x:2, 4x:3, 6x:4, 8x:5, 16x:6, Disable Braking:7 */
-#define FB_LOOPGAIN 1 /* For  Low:0, Medium:1, High:2, Very High:3 */
-
-/* Please refer to your datasheet for the optimal setting for your specific motor. */
-#define RATED_VOLTAGE 2
-#define V_PEAK 2.8
-#define V_RMS 2.0 
-#define V_PEAK 2.1
-#define F_LRA 205 /* resonance freq */
-```
-
-#### DRV2605L waveform library
-
-DRV2605L comes with preloaded library of various waveform sequences that can be called and played. If writing a macro, these waveforms can be played using `DRV_pulse(*sequence name or number*)`
-
-List of waveform sequences from the datasheet:
-
-|seq# | Sequence name          |seq# | Sequence name                  |seq# |Sequence name                           |
-|-----|---------------------|-----|-----------------------------------|-----|--------------------------------------|
-| 1   | strong_click 		| 43  | lg_dblclick_med_60                | 85  | transition_rampup_med_smooth2        |
-| 2   | strong_click_60 	| 44  | lg_dblsharp_tick                  | 86  | transition_rampup_short_smooth1      |
-| 3   | strong_click_30 	| 45  | lg_dblsharp_tick_80               | 87  | transition_rampup_short_smooth2      |
-| 4   | sharp_click 		| 46  | lg_dblsharp_tick_60               | 88  | transition_rampup_long_sharp1        |
-| 5   | sharp_click_60      | 47  | buzz                              | 89  | transition_rampup_long_sharp2        |
-| 6   | sharp_click_30      | 48  | buzz_80				              | 90  | transition_rampup_med_sharp1         |
-| 7   | soft_bump           | 49  | buzz_60		                      | 91  | transition_rampup_med_sharp2         |
-| 8   | soft_bump_60        | 50  | buzz_40				              | 92  | transition_rampup_short_sharp1       |
-| 9   | soft_bump_30        | 51  | buzz_20				              | 93  | transition_rampup_short_sharp2       |
-| 10  | dbl_click           | 52  | pulsing_strong                    | 94  | transition_rampdown_long_smooth1_50  |
-| 11  | dbl_click_60        | 53  | pulsing_strong_80                 | 95  | transition_rampdown_long_smooth2_50  |
-| 12  | trp_click           | 54  | pulsing_medium                    | 96  | transition_rampdown_med_smooth1_50   |
-| 13  | soft_fuzz           | 55  | pulsing_medium_80                 | 97  | transition_rampdown_med_smooth2_50   |
-| 14  | strong_buzz         | 56  | pulsing_sharp                     | 98  | transition_rampdown_short_smooth1_50 |
-| 15  | alert_750ms         | 57  | pulsing_sharp_80                  | 99  | transition_rampdown_short_smooth2_50 |
-| 16  | alert_1000ms        | 58  | transition_click	              | 100 | transition_rampdown_long_sharp1_50   |
-| 17  | strong_click1       | 59  | transition_click_80               | 101 | transition_rampdown_long_sharp2_50   |
-| 18  | strong_click2_80    | 60  | transition_click_60	              | 102 | transition_rampdown_med_sharp1_50    |
-| 19  | strong_click3_60    | 61  | transition_click_40	              | 103 | transition_rampdown_med_sharp2_50    |
-| 20  | strong_click4_30    | 62  | transition_click_20	              | 104 | transition_rampdown_short_sharp1_50  |
-| 21  | medium_click1       | 63  | transition_click_10	              | 105 | transition_rampdown_short_sharp2_50  |
-| 22  | medium_click2_80    | 64  | transition_hum                    | 106 | transition_rampup_long_smooth1_50    |
-| 23  | medium_click3_60    | 65  | transition_hum_80                 | 107 | transition_rampup_long_smooth2_50    |
-| 24  | sharp_tick1         | 66  | transition_hum_60                 | 108 | transition_rampup_med_smooth1_50     |
-| 25  | sharp_tick2_80      | 67  | transition_hum_40                 | 109 | transition_rampup_med_smooth2_50     |
-| 26  | sharp_tick3_60      | 68  | transition_hum_20                 | 110 | transition_rampup_short_smooth1_50   |
-| 27  | sh_dblclick_str     | 69  | transition_hum_10                 | 111 | transition_rampup_short_smooth2_50   |
-| 28  | sh_dblclick_str_80  | 70  | transition_rampdown_long_smooth1  | 112 | transition_rampup_long_sharp1_50     |
-| 29  | sh_dblclick_str_60  | 71  | transition_rampdown_long_smooth2  | 113 | transition_rampup_long_sharp2_50     |
-| 30  | sh_dblclick_str_30  | 72  | transition_rampdown_med_smooth1   | 114 | transition_rampup_med_sharp1_50      |
-| 31  | sh_dblclick_med     | 73  | transition_rampdown_med_smooth2   | 115 | transition_rampup_med_sharp2_50      |
-| 32  | sh_dblclick_med_80  | 74  | transition_rampdown_short_smooth1 | 116 | transition_rampup_short_sharp1_50    |
-| 33  | sh_dblclick_med_60  | 75  | transition_rampdown_short_smooth2 | 117 | transition_rampup_short_sharp2_50    |
-| 34  | sh_dblsharp_tick    | 76  | transition_rampdown_long_sharp1   | 118 | long_buzz_for_programmatic_stopping  |
-| 35  | sh_dblsharp_tick_80 | 77  | transition_rampdown_long_sharp2   | 119 | smooth_hum1_50                       |
-| 36  | sh_dblsharp_tick_60 | 78  | transition_rampdown_med_sharp1    | 120 | smooth_hum2_40                       |
-| 37  | lg_dblclick_str     | 79  | transition_rampdown_med_sharp2    | 121 | smooth_hum3_30                       |
-| 38  | lg_dblclick_str_80  | 80  | transition_rampdown_short_sharp1  | 122 | smooth_hum4_20                       |
-| 39  | lg_dblclick_str_60  | 81  | transition_rampdown_short_sharp2  | 123 | smooth_hum5_10                       |
-| 40  | lg_dblclick_str_30  | 82  | transition_rampup_long_smooth1    |     |                                      |
-| 41  | lg_dblclick_med     | 83  | transition_rampup_long_smooth2    |     |                                      |
-| 42  | lg_dblclick_med_80  | 84  | transition_rampup_med_smooth1     |     |                                      |
-### Optional DRV2605L defines
-
-```
-#define DRV_GREETING *sequence name or number*
-```
-If haptic feedback is enabled, the keyboard will vibrate to a specific sqeuence during startup. That can be selected using the following define:
-
-```
-#define DRV_MODE_DEFAULT *sequence name or number*
-```
-This will set what sequence HPT_RST will set as the active mode. If not defined, mode will be set to 1 when HPT_RST is pressed.
-
-### DRV2605L Continuous Haptic Mode
-
-This mode sets continuous haptic feedback with the option to increase or decrease strength. 

docs/feature_layouts.md

@@ -51,35 +51,6 @@ 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

docs/feature_leader_key.md

@@ -5,11 +5,10 @@ If you've ever used Vim, you know what a Leader key is. If not, you're about to
 That's what `KC_LEAD` does. Here's an example:
 
 1. Pick a key on your keyboard you want to use as the Leader key. Assign it the keycode `KC_LEAD`. This key would be dedicated just for this -- it's a single action key, can't be used for anything else.
-2. Include the line `#define LEADER_TIMEOUT 300` in your `config.h`. This sets the timeout for the `KC_LEAD` key.  Specifically, when you press the `KC_LEAD` key, you only have a certain amount of time to complete the Leader Key sequence.  The `300` here sets that to 300ms, and you can increase this value to give you more time to hit the sequence. But any keys pressed during this timeout are intercepted and not sent, so you may want to keep this value low. .  
-   * By default, this timeout is how long after pressing `KC_LEAD` to complete your entire sequence. This may be very low for some people. So you may want to increase this timeout.  Optionally, you may want to enable the `LEADER_PER_KEY_TIMING` option, which resets the timeout after each key is tapped.  This allows you to maintain a low value here, but still be able to use the longer sequences.   To enable this option, add `#define LEADER_PER_KEY_TIMING` to your `config.h`.
-3. Within your `matrix_scan_user` function, add something like this:
+2. Include the line `#define LEADER_TIMEOUT 300` in your config.h. The 300 there is 300ms -- that's how long you have for the sequence of keys following the leader. You can tweak this value for comfort, of course.
+3. Within your `matrix_scan_user` function, do something like this:
 
-```c
+```
 LEADER_EXTERNS();
 
 void matrix_scan_user(void) {
@@ -45,102 +44,6 @@ Each of these accepts one or more keycodes as arguments. This is an important po
 
 To add support for Leader Key you simply need to add a single line to your keymap's `rules.mk`:
 
-```make
+```
 LEADER_ENABLE = yes
 ```
-
-## Per Key Timing on Leader keys
-
-Rather than relying on an incredibly high timeout for long leader key strings or those of us without 200wpm typing skills, we can enable per key timing to ensure that each key pressed provides us with more time to finish our stroke. This is incredibly helpful with leader key emulation of tap dance (read: multiple taps of the same key like C, C, C).
-
-In order to enable this, place this in your `config.h`:
-```c
-#define LEADER_PER_KEY_TIMING
-```
-
-After this, it's recommended that you lower your `LEADER_TIMEOUT` to something less that 300ms.
-
-```c
-#define LEADER_TIMEOUT 250
-```
-
-Now, something like this won't seem impossible to do without a 1000MS leader key timeout:
-
-```c
-SEQ_THREE_KEYS(KC_C, KC_C, KC_C) {
-  SEND_STRING("Per key timing is great!!!");
-}
-```
-
-## Strict Key Processing
-
-By default, the Leader Key feature will filter the keycode out of [`Mod-Tap`](feature_advanced_keycodes.md#mod-tap) and [`Layer Tap`](feature_advanced_keycodes.md#switching-and-toggling-layers) functions when checking for the Leader sequences. That means if you're using `LT(3, KC_A)`, it will pick this up as `KC_A` for the sequence, rather than `LT(3, KC_A)`, giving a more expected behavior for newer users.
-
-While, this may be fine for most, if you want to specify the whole keycode (eg, `LT(3, KC_A)` from the example above) in the sequence, you can enable this by added `#define LEADER_KEY_STRICT_KEY_PROCESSING` to your `config.h` file.  This well then disable the filtering, and you'll need to specify the whole keycode.
-
-## Customization 
-
-The Leader Key feature has some additional customization to how the Leader Key feature works.  It has two functions that can be called at certain parts of the process.  Namely `leader_start()` and `leader_end()`.
-
-The `leader_start()` function is called when you tap the `KC_LEAD` key, and the `leader_end()` function is called when either the leader sequence is completed, or the leader timeout is hit. 
-
-You can add these functions to your code (`keymap.c` usually) to add feedback to the Leader sequences (such as beeping or playing music).
-
-```c
-void leader_start(void) {
-  // sequence started
-}
-
-void leader_end(void) {
-  // sequence ended (no success/failuer detection)
-}
-```
-
-### Example
-
-This example will play the Mario "One Up" sound when you hit `KC_LEAD` to start the Leader Sequence, and will play "All Star" if it completes successfully or "Rick Roll" you if it fails. 
-
-```c
-bool did_leader_succeed;
-#ifdef AUDIO_ENABLE
-float leader_start[][2] = SONG(ONE_UP_SOUND );
-float leader_succeed[][2] = SONG(ALL_STAR);
-float leader_fail[][2] = SONG(RICK_ROLL);
-#endif
-LEADER_EXTERNS();
-
-void matrix_scan_user(void) {
-  LEADER_DICTIONARY() {
-    did_leader_succeed = leading = false;
-
-    SEQ_ONE_KEY(KC_E) {
-      // Anything you can do in a macro.
-      SEND_STRING(SS_LCTRL(SS_LSFT("t")));
-      did_leader_succeed = true;
-    } else 
-    SEQ_TWO_KEYS(KC_E, KC_D) {
-      SEND_STRING(SS_LGUI("r")"cmd"SS_TAP(KC_ENTER)SS_LCTRL("c"));
-      did_leader_succeed = true;
-    }
-    leader_end();
-  }
-}
-
-void leader_start(void) {
-#ifdef AUDIO_ENABLE
-    PLAY_SONG(leader_start);
-#endif
-}
-
-void leader_end(void) {
-  if (did_leader_succeed) {
-#ifdef AUDIO_ENABLE
-    PLAY_SONG(leader_succeed);
-#endif
-  } else {
-#ifdef AUDIO_ENABLE
-    PLAY_SONG(leader_fail);
-#endif
-  }
-}
-```

docs/feature_led_matrix.md

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

docs/feature_macros.md

@@ -12,28 +12,24 @@ Here is an example `keymap.c` for a two-key keyboard:
 
 ```c
 enum custom_keycodes {
-  QMKBEST = SAFE_RANGE,
+	MY_CUSTOM_MACRO = SAFE_RANGE
 };
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  switch (keycode) {
-    case QMKBEST:
-      if (record->event.pressed) {
-        // when keycode QMKBEST is pressed
-        SEND_STRING("QMK is the best thing ever!");
-      } else {
-        // when keycode QMKBEST is released
-      }
-      break;
-
-  }
-  return true;
+	if (record->event.pressed) {
+		switch(keycode) {
+			case MY_CUSTOM_MACRO:
+				SEND_STRING("QMK is the best thing ever!"); // this is our macro!
+				return false;
+		}
+	}
+	return true;
 };
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [0] = {
-    {QMKBEST, KC_ESC}
-  }
+	[0] = {
+	  {MY_CUSTOM_MACRO, KC_ESC}
+	}
 };
 ```
 
@@ -41,7 +37,7 @@ What happens here is this:
 We first define a new custom keycode in the range not occupied by any other keycodes.
 Then we use the `process_record_user` function, which is called whenever a key is pressed or released, to check if our custom keycode has been activated.
 If yes, we send the string `"QMK is the best thing ever!"` to the computer via the `SEND_STRING` macro (this is a C preprocessor macro, not to be confused with QMK macros).
-We return `true` to indicate to the caller that the key press we just processed should continue to be processed as normal (as we didn't replace or alter the functionality).
+We return `false` to indicate to the caller that the key press we just processed need not be processed any further.
 Finally, we define the keymap so that the first button activates our macro and the second button is just an escape button.
 
 You might want to add more than one macro.
@@ -49,42 +45,28 @@ You can do that by adding another keycode and adding another case to the switch
 
 ```c
 enum custom_keycodes {
-  QMKBEST = SAFE_RANGE,
-  QMKURL,
-  MY_OTHER_MACRO
+	MY_CUSTOM_MACRO = SAFE_RANGE,
+	MY_OTHER_MACRO
 };
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  switch (keycode) {
-    case QMKBEST:
-      if (record->event.pressed) {
-        // when keycode QMKBEST is pressed
-        SEND_STRING("QMK is the best thing ever!");
-      } else {
-        // when keycode QMKBEST is released
-      }
-      break;
-    case QMKURL:
-      if (record->event.pressed) {
-        // when keycode QMKURL is pressed
-        SEND_STRING("https://qmk.fm/" SS_TAP(X_ENTER));
-      } else {
-        // when keycode QMKURL is released
-      }
-      break;
-    case MY_OTHER_MACRO:
-      if (record->event.pressed) {
-                SEND_STRING(SS_LCTRL("ac")); // selects all and copies
-      }
-      break;
-  }
-  return true;
+	if (record->event.pressed) {
+		switch(keycode) {
+			case MY_CUSTOM_MACRO:
+				SEND_STRING("QMK is the best thing ever!");
+				return false;
+			case MY_OTHER_MACRO:
+				SEND_STRING(SS_LCTRL("ac")); // selects all and copies
+				return false;
+		}
+	}
+	return true;
 };
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-  [0] = {
-    {MY_CUSTOM_MACRO, MY_OTHER_MACRO}
-  }
+	[0] = {
+	  {MY_CUSTOM_MACRO, MY_OTHER_MACRO}
+	}
 };
 ```
 
@@ -146,122 +128,29 @@ send_string(my_str);
 SEND_STRING(".."SS_TAP(X_END));
 ```
 
+## The Old Way: `MACRO()` & `action_get_macro`
 
-## Advanced Macro Functions
-
-There are some functions you may find useful in macro-writing. Keep in mind that while you can write some fairly advanced code within a macro, if your functionality gets too complex you may want to define a custom keycode instead. Macros are meant to be simple.
-
-### `record->event.pressed`
-
-This is a boolean value that can be tested to see if the switch is being pressed or released. An example of this is
-
-```c
-    if (record->event.pressed) {
-        // on keydown
-    } else {
-        // on keyup
-    }
-```
-
-### `register_code(<kc>);`
-
-This sends the `<kc>` keydown event to the computer. Some examples would be `KC_ESC`, `KC_C`, `KC_4`, and even modifiers such as `KC_LSFT` and `KC_LGUI`.
-
-### `unregister_code(<kc>);`
-
-Parallel to `register_code` function, this sends the `<kc>` keyup event to the computer. If you don't use this, the key will be held down until it's sent.
-
-### `tap_code(<kc>);`
-
-This will send `register_code(<kc>)` and then `unregister_code(<kc>)`. This is useful if you want to send both the press and release events ("tap" the key, rather than hold it).
-
-If you're having issues with taps (un)registering, you can add a delay between the register and unregister events by setting `#define TAP_CODE_DELAY 100` in your `config.h` file. The value is in milliseconds.
-
-### `register_code16(<kc>);`, `unregister_code16(<kc>);` and `tap_code16(<kc>);`
-
-These functions work similar to their regular counterparts, but allow you to use modded keycodes (with Shift, Alt, Control, and/or GUI applied to them).
-
-Eg, you could use `register_code16(S(KC_5));` instead of registering the mod, then registering the keycode.
-
-### `clear_keyboard();`
-
-This will clear all mods and keys currently pressed.
-
-### `clear_mods();`
-
-This will clear all mods currently pressed.
-
-### `clear_keyboard_but_mods();`
-
-This will clear all keys besides the mods currently pressed.
-
-## Advanced Example: 
-
-### Super ALT↯TAB
-
-This macro will register `KC_LALT` and tap `KC_TAB`, then wait for 1000ms. If the key is tapped again, it will send another `KC_TAB`; if there is no tap, `KC_LALT` will be unregistered, thus allowing you to cycle through windows. 
-
-```c
-bool is_alt_tab_active = false;    # ADD this near the begining of keymap.c
-uint16_t alt_tab_timer = 0;        # we will be using them soon.
-
-enum custom_keycodes {             # Make sure have the awesome keycode ready
-  ALT_TAB = SAFE_RANGE,
-};
-
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  switch (keycode) {               # This will do most of the grunt work with the keycodes.
-    case ALT_TAB:
-      if (record->event.pressed) {
-        if (!is_alt_tab_active) {
-          is_alt_tab_active = true;
-          register_code(KC_LALT);
-        } 
-        alt_tab_timer = timer_read();
-        register_code(KC_TAB);
-      } else {
-        unregister_code(KC_TAB);
-      }
-      break;
-  }
-  return true;
-}
-
-void matrix_scan_user(void) {     # The very important timer. 
-  if (is_alt_tab_active) {
-    if (timer_elapsed(alt_tab_timer) > 1000) {
-      unregister_code(KC_LALT);
-      is_alt_tab_active = false;
-    }
-  }
-}
-```
-
----
-
-##  **(DEPRECATED)** The Old Way: `MACRO()` & `action_get_macro`
-
-!> This is inherited from TMK, and hasn't been updated - it's recommended that you use `SEND_STRING` and `process_record_user` instead.
+?> This is inherited from TMK, and hasn't been updated - it's recommend that you use `SEND_STRING` and `process_record_user` instead.
 
 By default QMK assumes you don't have any macros. To define your macros you create an `action_get_macro()` function. For example:
 
 ```c
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
-    if (record->event.pressed) {
-        switch(id) {
-            case 0:
-                return MACRO(D(LSFT), T(H), U(LSFT), T(I), D(LSFT), T(1), U(LSFT), END);
-            case 1:
-                return MACRO(D(LSFT), T(B), U(LSFT), T(Y), T(E), D(LSFT), T(1), U(LSFT), END);
-        }
-    }
-    return MACRO_NONE;
+	if (record->event.pressed) {
+		switch(id) {
+			case 0:
+				return MACRO(D(LSFT), T(H), U(LSFT), T(I), D(LSFT), T(1), U(LSFT), END);
+			case 1:
+				return MACRO(D(LSFT), T(B), U(LSFT), T(Y), T(E), D(LSFT), T(1), U(LSFT), END);
+		}
+	}
+	return MACRO_NONE;
 };
 ```
 
 This defines two macros which will be run when the key they are assigned to is pressed. If instead you'd like them to run when the key is released you can change the if statement:
 
-    if (!record->event.pressed) {
+	if (!record->event.pressed) {
 
 ### Macro Commands
 
@@ -276,25 +165,25 @@ A macro can include the following commands:
 
 ### Mapping a Macro to a Key
 
-Use the `M()` function within your keymap to call a macro. For example, here is the keymap for a 2-key keyboard:
+Use the `M()` function within your `KEYMAP()` to call a macro. For example, here is the keymap for a 2-key keyboard:
 
 ```c
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [0] = LAYOUT(
-        M(0), M(1)
-    ),
+	[0] = KEYMAP(
+		M(0), M(1)
+	),
 };
 
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
-    if (record->event.pressed) {
-        switch(id) {
-            case 0:
-                return MACRO(D(LSFT), T(H), U(LSFT), T(I), D(LSFT), T(1), U(LSFT), END);
-            case 1:
-                return MACRO(D(LSFT), T(B), U(LSFT), T(Y), T(E), D(LSFT), T(1), U(LSFT), END);
-        }
-    }
-    return MACRO_NONE;
+	if (record->event.pressed) {
+		switch(id) {
+			case 0:
+				return MACRO(D(LSFT), T(H), U(LSFT), T(I), D(LSFT), T(1), U(LSFT), END);
+			case 1:
+				return MACRO(D(LSFT), T(B), U(LSFT), T(Y), T(E), D(LSFT), T(1), U(LSFT), END);
+		}
+	}
+	return MACRO_NONE;
 };
 ```
 
@@ -309,31 +198,68 @@ If you have a bunch of macros you want to refer to from your keymap while keepin
 #define M_BYE M(1)
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [0] = LAYOUT(
-        M_HI, M_BYE
-    ),
+	[0] = KEYMAP(
+		M_HI, M_BYE
+	),
 };
 ```
 
+## Advanced Macro Functions
 
-## Advanced Example: 
+There are some functions you may find useful in macro-writing. Keep in mind that while you can write some fairly advanced code within a macro if your functionality gets too complex you may want to define a custom keycode instead. Macros are meant to be simple.
 
-### Single-Key Copy/Paste
+### `record->event.pressed`
+
+This is a boolean value that can be tested to see if the switch is being pressed or released. An example of this is
+
+```c
+	if (record->event.pressed) {
+		// on keydown
+	} else {
+		// on keyup
+	}
+```
+
+### `register_code(<kc>);`
+
+This sends the `<kc>` keydown event to the computer. Some examples would be `KC_ESC`, `KC_C`, `KC_4`, and even modifiers such as `KC_LSFT` and `KC_LGUI`.
+
+### `unregister_code(<kc>);`
+
+Parallel to `register_code` function, this sends the `<kc>` keyup event to the computer. If you don't use this, the key will be held down until it's sent.
+
+### `tap_code(<kc>);`
+
+This will send `register_code(<kc>)` and then `unregister_code(<kc>)`. This is useful if you want to send both the press and release events ("tap" the key, rather than hold it).
+
+### `clear_keyboard();`
+
+This will clear all mods and keys currently pressed.
+
+### `clear_mods();`
+
+This will clear all mods currently pressed.
+
+### `clear_keyboard_but_mods();`
+
+This will clear all keys besides the mods currently pressed.
+
+## Advanced Example: Single-Key Copy/Paste
 
 This example defines a macro which sends `Ctrl-C` when pressed down, and `Ctrl-V` when released.
 
 ```c
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
-    switch(id) {
-        case 0: {
-            if (record->event.pressed) {
-                return MACRO( D(LCTL), T(C), U(LCTL), END  );
-            } else {
-                return MACRO( D(LCTL), T(V), U(LCTL), END  );
-            }
-            break;
-        }
-    }
-    return MACRO_NONE;
+	switch(id) {
+		case 0: {
+			if (record->event.pressed) {
+				return MACRO( D(LCTL), T(C), U(LCTL), END  );
+			} else {
+				return MACRO( D(LCTL), T(V), U(LCTL), END  );
+			}
+			break;
+		}
+	}
+	return MACRO_NONE;
 };
 ```

docs/feature_mouse_keys.md

@@ -1,119 +1,81 @@
-# Mouse keys
+# Mousekeys
 
-Mouse keys is a feature that allows you to emulate a mouse using your keyboard. You can move the pointer at different speeds, press 5 buttons and scroll in 8 directions.
 
-## Adding mouse keys to your keyboard
+Mousekeys is a feature that allows you to emulate a mouse using your keyboard. You can move the pointer around, click up to 5 buttons, and even scroll in all 4 directions. QMK uses the same algorithm as the X Window System MouseKeysAccel feature. You can read more about it [on Wikipedia](https://en.wikipedia.org/wiki/Mouse_keys).
 
-To use mouse keys, you must at least enable mouse keys support and map mouse actions to keys on your keyboard.
+## Adding Mousekeys to a Keymap
 
-### Enabling mouse keys
+There are two steps to adding Mousekeys support to your keyboard. You must enable support in the `rules.mk` file and you must map mouse actions to keys on your keyboard.
 
-To enable mouse keys, add the following line to your keymap’s `rules.mk`:
+### Adding Mousekeys Support in the `rules.mk`
 
-```c
+To add support for Mousekeys you simply need to add a single line to your keymap's `rules.mk`:
+
+```
 MOUSEKEY_ENABLE = yes
 ```
 
-### Mapping mouse actions
+You can see an example here: https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/66/keymaps/mouse_keys/rules.mk
 
-In your keymap you can use the following keycodes to map key presses to mouse actions:
+### Mapping Mouse Actions to Keyboard Keys
 
-|Key             |Aliases  |Description      |
-|----------------|---------|-----------------|
-|`KC_MS_UP`      |`KC_MS_U`|Move cursor up   |
-|`KC_MS_DOWN`    |`KC_MS_D`|Move cursor down |
-|`KC_MS_LEFT`    |`KC_MS_L`|Move cursor left |
-|`KC_MS_RIGHT`   |`KC_MS_R`|Move cursor right|
-|`KC_MS_BTN1`    |`KC_BTN1`|Press button 1   |
-|`KC_MS_BTN2`    |`KC_BTN2`|Press button 2   |
-|`KC_MS_BTN3`    |`KC_BTN3`|Press button 3   |
-|`KC_MS_BTN4`    |`KC_BTN4`|Press button 4   |
-|`KC_MS_BTN5`    |`KC_BTN5`|Press button 5   |
-|`KC_MS_WH_UP`   |`KC_WH_U`|Move wheel up    |
-|`KC_MS_WH_DOWN` |`KC_WH_D`|Move wheel down  |
-|`KC_MS_WH_LEFT` |`KC_WH_L`|Move wheel left  |
-|`KC_MS_WH_RIGHT`|`KC_WH_R`|Move wheel right |
-|`KC_MS_ACCEL0`  |`KC_ACL0`|Set speed to 0   |
-|`KC_MS_ACCEL1`  |`KC_ACL1`|Set speed to 1   |
-|`KC_MS_ACCEL2`  |`KC_ACL2`|Set speed to 2   |
+You can use these keycodes within your keymap to map button presses to mouse actions:
 
-## Configuring mouse keys
+|Key             |Aliases  |Description                |
+|----------------|---------|---------------------------|
+|`KC_MS_UP`      |`KC_MS_U`|Mouse Cursor Up            |
+|`KC_MS_DOWN`    |`KC_MS_D`|Mouse Cursor Down          |
+|`KC_MS_LEFT`    |`KC_MS_L`|Mouse Cursor Left          |
+|`KC_MS_RIGHT`   |`KC_MS_R`|Mouse Cursor Right         |
+|`KC_MS_BTN1`    |`KC_BTN1`|Mouse Button 1             |
+|`KC_MS_BTN2`    |`KC_BTN2`|Mouse Button 2             |
+|`KC_MS_BTN3`    |`KC_BTN3`|Mouse Button 3             |
+|`KC_MS_BTN4`    |`KC_BTN4`|Mouse Button 4             |
+|`KC_MS_BTN5`    |`KC_BTN5`|Mouse Button 5             |
+|`KC_MS_WH_UP`   |`KC_WH_U`|Mouse Wheel Up             |
+|`KC_MS_WH_DOWN` |`KC_WH_D`|Mouse Wheel Down           |
+|`KC_MS_WH_LEFT` |`KC_WH_L`|Mouse Wheel Left           |
+|`KC_MS_WH_RIGHT`|`KC_WH_R`|Mouse Wheel Right          |
+|`KC_MS_ACCEL0`  |`KC_ACL0`|Set mouse acceleration to 0|
+|`KC_MS_ACCEL1`  |`KC_ACL1`|Set mouse acceleration to 1|
+|`KC_MS_ACCEL2`  |`KC_ACL2`|Set mouse acceleration to 2|
 
-Mouse keys supports two different modes to move the cursor:
+You can see an example in the `_ML` here: https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/66/keymaps/mouse_keys/keymap.c#L46
 
-* **Accelerated (default):** Holding movement keys accelerates the cursor until it reaches its maximum speed.
-* **Constant:** Holding movement keys moves the cursor at constant speeds.
+## Configuring the Behavior of Mousekeys
 
-The same principle applies to scrolling.
+The default speed for controlling the mouse with the keyboard is intentionally slow. You can adjust these parameters by adding these settings to your keymap's `config.h` file. All times are specified in milliseconds (ms).
 
-Configuration options that are times, intervals or delays are given in milliseconds. Scroll speed is given as multiples of the default scroll step. For example, a scroll speed of 8 means that each scroll action covers 8 times the length of the default scroll step as defined by your operating system or application.
-
-### Accelerated mode
-
-This is the default mode. You can adjust the cursor and scrolling acceleration using the following settings in your keymap’s `config.h` file:
-
-|Define                      |Default|Description                                              |
-|----------------------------|-------|---------------------------------------------------------|
-|`MOUSEKEY_DELAY`            |300    |Delay between pressing a movement key and cursor movement|
-|`MOUSEKEY_INTERVAL`         |50     |Time between cursor movements                            |
-|`MOUSEKEY_MAX_SPEED`        |10     |Maximum cursor speed at which acceleration stops         |
-|`MOUSEKEY_TIME_TO_MAX`      |20     |Time until maximum cursor speed is reached               |
-|`MOUSEKEY_WHEEL_MAX_SPEED`  |8      |Maximum number of scroll steps per scroll action         |
-|`MOUSEKEY_WHEEL_TIME_TO_MAX`|40     |Time until maximum scroll speed is reached               |
-
-Tips:
-
-* Setting `MOUSEKEY_DELAY` too low makes the cursor unresponsive. Setting it too high makes small movements difficult.
-* For smoother cursor movements, lower the value of `MOUSEKEY_INTERVAL`. If the refresh rate of your display is 60Hz, you could set it to `16` (1/60). As this raises the cursor speed significantly, you may want to lower `MOUSEKEY_MAX_SPEED`.
-* Setting `MOUSEKEY_TIME_TO_MAX` or `MOUSEKEY_WHEEL_TIME_TO_MAX` to `0` will disable acceleration for the cursor or scrolling respectively. This way you can make one of them constant while keeping the other accelerated, which is not possible in constant speed mode.
-
-Cursor acceleration uses the same algorithm as the X Window System MouseKeysAccel feature. You can read more about it [on Wikipedia](https://en.wikipedia.org/wiki/Mouse_keys).
-
-### Constant mode
-
-In this mode you can define multiple different speeds for both the cursor and the mouse wheel. There is no acceleration. `KC_ACL0`, `KC_ACL1` and `KC_ACL2` change the cursor and scroll speed to their respective setting.
-
-You can choose whether speed selection is momentary or tap-to-select:
-
-* **Momentary:** The chosen speed is only active while you hold the respective key. When the key is raised, mouse keys returns to the unmodified speed.
-* **Tap-to-select:** The chosen speed is activated when you press the respective key and remains active even after the key has been raised. The default speed is that of `KC_ACL1`. There is no unmodified speed.
-
-The default speeds from slowest to fastest are as follows:
-
-* **Momentary:** `KC_ACL0` < `KC_ACL1` < *unmodified* < `KC_ACL2`
-* **Tap-to-select:** `KC_ACL0` < `KC_ACL1` < `KC_ACL2`
-
-To use constant speed mode, you must at least define `MK_3_SPEED` in your keymap’s `config.h` file:
-
-```c
-#define MK_3_SPEED
+```
+#define MOUSEKEY_DELAY             300
+#define MOUSEKEY_INTERVAL          50
+#define MOUSEKEY_MAX_SPEED         10
+#define MOUSEKEY_TIME_TO_MAX       20
+#define MOUSEKEY_WHEEL_MAX_SPEED   8
+#define MOUSEKEY_WHEEL_TIME_TO_MAX 40
 ```
 
-To enable momentary mode, also define `MK_MOMENTARY_ACCEL`:
 
-```c
-#define MK_MOMENTARY_ACCEL
-```
+### `MOUSEKEY_DELAY`
 
-Use the following settings if you want to adjust cursor movement or scrolling:
+When one of the mouse movement buttons is pressed this setting is used to define the delay between that button press and the mouse cursor moving. Some people find that small movements are impossible if this setting is too low, while settings that are too high feel sluggish.
 
-|Define               |Default      |Description                                |
-|---------------------|-------------|-------------------------------------------|
-|`MK_3_SPEED`         |*Not defined*|Enable constant cursor speeds              |
-|`MK_MOMENTARY_ACCEL` |*Not defined*|Enable momentary speed selection           |
-|`MK_C_OFFSET_UNMOD`  |16           |Cursor offset per movement (unmodified)    |
-|`MK_C_INTERVAL_UNMOD`|16           |Time between cursor movements (unmodified) |
-|`MK_C_OFFSET_0`      |1            |Cursor offset per movement (`KC_ACL0`)     |
-|`MK_C_INTERVAL_0`    |32           |Time between cursor movements (`KC_ACL0`)  |
-|`MK_C_OFFSET_1`      |4            |Cursor offset per movement (`KC_ACL1`)     |
-|`MK_C_INTERVAL_1`    |16           |Time between cursor movements (`KC_ACL1`)  |
-|`MK_C_OFFSET_2`      |32           |Cursor offset per movement (`KC_ACL2`)     |
-|`MK_C_INTERVAL_2`    |16           |Time between cursor movements (`KC_ACL2`)  |
-|`MK_W_OFFSET_UNMOD`  |1            |Scroll steps per scroll action (unmodified)|
-|`MK_W_INTERVAL_UNMOD`|40           |Time between scroll steps (unmodified)     |
-|`MK_W_OFFSET_0`      |1            |Scroll steps per scroll action (`KC_ACL0`) |
-|`MK_W_INTERVAL_0`    |360          |Time between scroll steps (`KC_ACL0`)      |
-|`MK_W_OFFSET_1`      |1            |Scroll steps per scroll action (`KC_ACL1`) |
-|`MK_W_INTERVAL_1`    |120          |Time between scroll steps (`KC_ACL1`)      |
-|`MK_W_OFFSET_2`      |1            |Scroll steps per scroll action (`KC_ACL2`) |
-|`MK_W_INTERVAL_2`    |20           |Time between scroll steps (`KC_ACL2`)      |
+### `MOUSEKEY_INTERVAL`
+
+When a movement key is held down this specifies how long to wait between each movement report. Lower settings will translate into an effectively higher mouse speed.
+
+### `MOUSEKEY_MAX_SPEED`
+
+As a movement key is held down the speed of the mouse cursor will increase until it reaches `MOUSEKEY_MAX_SPEED`.
+
+### `MOUSEKEY_TIME_TO_MAX`
+
+How long you want to hold down a movement key for until `MOUSEKEY_MAX_SPEED` is reached. This controls how quickly your cursor will accelerate.
+
+### `MOUSEKEY_WHEEL_MAX_SPEED`
+
+The top speed for scrolling movements.
+
+### `MOUSEKEY_WHEEL_TIME_TO_MAX`
+
+How long you want to hold down a scroll key for until `MOUSEKEY_WHEEL_MAX_SPEED` is reached. This controls how quickly your scrolling will accelerate.

docs/feature_oled_driver.md

@@ -1,291 +0,0 @@
-# OLED Driver
-
-## OLED Supported Hardware
-
-OLED modules using SSD1306 or SH1106 driver ICs, communicating over I2C.
-Tested combinations:
-
-| IC driver |   Size | Keyboard Platform | Notes                    |
-|-----------|--------|-------------------|--------------------------|
-| SSD1306   | 128x32 | AVR               | Primary support          |
-| SSD1306   | 128x64 | AVR               | Verified working         |
-| SSD1306   | 128x32 | ARM               |                          |
-| SH1106    | 128x64 | AVR               | No rotation or scrolling |
-
-Hardware configurations using ARM-based microcontrollers or different sizes of OLED modules may be compatible, but are untested.
-
-!> Warning: This OLED Driver currently uses the new i2c_master driver from split common code. If your split keyboard uses I2C to communicate between sides, this driver could cause an address conflict (serial is fine). Please contact your keyboard vendor and ask them to migrate to the latest split common code to fix this. In addition, the display timeout system to reduce OLED burn-in also uses split common to detect keypresses, so you will need to implement custom timeout logic for non-split common keyboards.
-
-## Usage
-
-To enable the OLED feature, there are three steps. First, when compiling your keyboard, you'll need to set `OLED_DRIVER_ENABLE=yes` in `rules.mk`, e.g.:
-
-```
-OLED_DRIVER_ENABLE = yes
-```
-
-This enables the feature and the `OLED_DRIVER_ENABLE` define. Then in your `keymap.c` file, you will need to implement the user task call, e.g:
-
-```C++
-#ifdef OLED_DRIVER_ENABLE
-void oled_task_user(void) {
-  // Host Keyboard Layer Status
-  oled_write_P(PSTR("Layer: "), false);
-  switch (get_highest_layer(layer_state)) {
-    case _QWERTY:
-      oled_write_P(PSTR("Default\n"), false);
-      break;
-    case _FN:
-      oled_write_P(PSTR("FN\n"), false);
-      break;
-    case _ADJ:
-      oled_write_P(PSTR("ADJ\n"), false);
-      break;
-    default:
-      // Or use the write_ln shortcut over adding '\n' to the end of your string
-      oled_write_ln_P(PSTR("Undefined"), false);
-  }
-
-  // Host Keyboard LED Status
-  uint8_t led_usb_state = host_keyboard_leds();
-  oled_write_P(led_usb_state & (1<<USB_LED_NUM_LOCK) ? PSTR("NUMLCK ") : PSTR("       "), false);
-  oled_write_P(led_usb_state & (1<<USB_LED_CAPS_LOCK) ? PSTR("CAPLCK ") : PSTR("       "), false);
-  oled_write_P(led_usb_state & (1<<USB_LED_SCROLL_LOCK) ? PSTR("SCRLCK ") : PSTR("       "), false);
-}
-#endif
-```
-
-## Logo Example
-
-In the default font, ranges in the font file are reserved for a QMK Logo. To Render this logo to the oled screen, use the following code example:
-
-```C++
-static void render_logo(void) {
-  static const char PROGMEM qmk_logo[] = {
-    0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,
-    0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,
-    0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,0};
-
-  oled_write_P(qmk_logo, false);
-}
-```
-
-## Other Examples
-
-In split keyboards, it is very common to have two OLED displays that each render different content and oriented flipped differently. You can do this by switching which content to render by using the return from `is_keyboard_master()` or `is_keyboard_left()` found in `split_util.h`, e.g:
-
-```C++
-#ifdef OLED_DRIVER_ENABLE
-oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-  if (!is_keyboard_master())
-    return OLED_ROTATION_180;  // flips the display 180 degrees if offhand
-  return rotation;
-}
-
-void oled_task_user(void) {
-  if (is_keyboard_master()) {
-    render_status();     // Renders the current keyboard state (layer, lock, caps, scroll, etc)
-  } else {
-    render_logo();       // Renders a statuc logo
-    oled_scroll_left();  // Turns on scrolling
-  }
-}
-#endif
-```
-
-
- ## Basic Configuration
-
-| Define                     | Default           | Description                                                                                                                |
-|----------------------------|-------------------|----------------------------------------------------------------------------------------------------------------------------|
-| `OLED_DISPLAY_ADDRESS`     | `0x3C`            | The i2c address of the OLED Display                                                                                        |
-| `OLED_FONT_H`              | `"glcdfont.c"`    | The font code file to use for custom fonts                                                                                 |
-| `OLED_FONT_START`          | `0`               | The starting characer index for custom fonts                                                                               |
-| `OLED_FONT_END`            | `224`             | The ending characer index for custom fonts                                                                                 |
-| `OLED_FONT_WIDTH`          | `6`               | The font width                                                                                                             |
-| `OLED_FONT_HEIGHT`         | `8`               | The font height (untested)                                                                                                 |
-| `OLED_TIMEOUT`             | `60000`           | Turns off the OLED screen after 60000ms of keyboard inactivity. Helps reduce OLED Burn-in. Set to 0 to disable.            |
-| `OLED_SCROLL_TIMEOUT`      | `0`               | Scrolls the OLED screen after 0ms of OLED inactivity. Helps reduce OLED Burn-in. Set to 0 to disable.                      |
-| `OLED_SCROLL_TIMEOUT_RIGHT`| *Not defined*     | Scroll timeout direction is right when defined, left when undefined.                                                       |
-| `OLED_IC`                  | `OLED_IC_SSD1306` | Set to `OLED_IC_SH1106` if you're using the SH1106 OLED controller.                                                        |
-| `OLED_COLUMN_OFFSET`       | `0`               | (SH1106 only.) Shift output to the right this many pixels.<br />Useful for 128x64 displays centered on a 132x64 SH1106 IC. |
-
- ## 128x64 & Custom sized OLED Displays
-
- The default display size for this feature is 128x32 and all necessary defines are precalculated with that in mind. We have added a define, `OLED_DISPLAY_128X64`, to switch all the values to be used in a 128x64 display, as well as added a custom define, `OLED_DISPLAY_CUSTOM`, that allows you to provide the necessary values to the driver.
-
-|Define                 |Default        |Description                                                      |
-|-----------------------|---------------|-----------------------------------------------------------------|
-|`OLED_DISPLAY_128X64`  |*Not defined*  |Changes the display defines for use with 128x64 displays.        |
-|`OLED_DISPLAY_CUSTOM`  |*Not defined*  |Changes the display defines for use with custom displays.<br />Requires user to implement the below defines. |
-|`OLED_DISPLAY_WIDTH`   |`128`          |The width of the OLED display.                                   |
-|`OLED_DISPLAY_HEIGHT`  |`32`           |The height of the OLED display.                                  |
-|`OLED_MATRIX_SIZE`     |`512`          |The local buffer size to allocate.<br />`(OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH)`. |
-|`OLED_BLOCK_TYPE`      |`uint16_t`     |The unsigned integer type to use for dirty rendering. |
-|`OLED_BLOCK_COUNT`     |`16`           |The number of blocks the display is divided into for dirty rendering.<br />`(sizeof(OLED_BLOCK_TYPE) * 8)`. |
-|`OLED_BLOCK_SIZE`      |`32`           |The size of each block for dirty rendering<br />`(OLED_MATRIX_SIZE / OLED_BLOCK_COUNT)`. |
-|`OLED_COM_PINS`        |`COM_PINS_SEQ` |How the SSD1306 chip maps it's memory to display.<br />Options are `COM_PINS_SEQ`, `COM_PINS_ALT`, `COM_PINS_SEQ_LR`, & `COM_PINS_ALT_LR`. |
-|`OLED_SOURCE_MAP`      |`{ 0, ... N }` |Precalculated source array to use for mapping source buffer to target OLED memory in 90 degree rendering.         |
-|`OLED_TARGET_MAP`      |`{ 24, ... N }`|Precalculated target array to use for mapping source buffer to target OLED memory in 90 degree rendering.         |
-
-
-### 90 Degree Rotation - Technical Mumbo Jumbo 
-
-!> Rotation is unsupported on the SH1106.
-
-```C
-// OLED Rotation enum values are flags
-typedef enum {
-    OLED_ROTATION_0   = 0,
-    OLED_ROTATION_90  = 1,
-    OLED_ROTATION_180 = 2,
-    OLED_ROTATION_270 = 3, // OLED_ROTATION_90 | OLED_ROTATION_180
-} oled_rotation_t;
-```
-
- OLED displays driven by SSD1306 drivers only natively support in hard ware 0 degree and 180 degree rendering. This feature is done in software and not free. Using this feature will increase the time to calculate what data to send over i2c to the OLED. If you are strapped for cycles, this can cause keycodes to not register. In testing however, the rendering time on an `atmega32u4` board only went from 2ms to 5ms and keycodes not registering was only noticed once we hit 15ms. 
- 
- 90 Degree Rotated Rendering is achieved by using bitwise operations to rotate each 8 block of memory and uses two precalculated arrays to remap buffer memory to OLED memory. The memory map defines are precalculated for remap performance and are calculated based on the OLED Height, Width, and Block Size. For example, in the 128x32 implementation with a `uint8_t` block type, we have a 64 byte block size. This gives us eight 8 byte blocks that need to be rotated and rendered. The OLED renders horizontally two 8 byte blocks before moving down a page, e.g:
-
-|   |   |   |   |   |   |
-|---|---|---|---|---|---|
-| 0 | 1 |   |   |   |   |
-| 2 | 3 |   |   |   |   |
-| 4 | 5 |   |   |   |   |
-| 6 | 7 |   |   |   |   |
-
-However the local buffer is stored as if it was Height x Width display instead of Width x Height, e.g:
-
-|   |   |   |   |   |   |
-|---|---|---|---|---|---|
-| 3 | 7 |   |   |   |   |
-| 2 | 6 |   |   |   |   |
-| 1 | 5 |   |   |   |   |
-| 0 | 4 |   |   |   |   |
-
-So those precalculated arrays just index the memory offsets in the order in which each one iterates its data.
-
-## OLED API
-
-```C++
-// OLED Rotation enum values are flags
-typedef enum {
-    OLED_ROTATION_0   = 0,
-    OLED_ROTATION_90  = 1,
-    OLED_ROTATION_180 = 2,
-    OLED_ROTATION_270 = 3, // OLED_ROTATION_90 | OLED_ROTATION_180
-} oled_rotation_t;
-
-// Initialize the OLED display, rotating the rendered output based on the define passed in.
-// Returns true if the OLED was initialized successfully
-bool oled_init(oled_rotation_t rotation);
-
-// Called at the start of oled_init, weak function overridable by the user
-// rotation - the value passed into oled_init
-// Return new oled_rotation_t if you want to override default rotation
-oled_rotation_t oled_init_user(oled_rotation_t rotation);
-
-// Clears the display buffer, resets cursor position to 0, and sets the buffer to dirty for rendering
-void oled_clear(void);
-
-// Renders the dirty chunks of the buffer to OLED display
-void oled_render(void);
-
-// Moves cursor to character position indicated by column and line, wraps if out of bounds
-// Max column denoted by 'oled_max_chars()' and max lines by 'oled_max_lines()' functions
-void oled_set_cursor(uint8_t col, uint8_t line);
-
-// Advances the cursor to the next page, writing ' ' if true
-// Wraps to the begining when out of bounds
-void oled_advance_page(bool clearPageRemainder);
-
-// Moves the cursor forward 1 character length
-// Advance page if there is not enough room for the next character
-// Wraps to the begining when out of bounds
-void oled_advance_char(void);
-
-// Writes a single character to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Main handler that writes character data to the display buffer
-void oled_write_char(const char data, bool invert);
-
-// Writes a string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-void oled_write(const char *data, bool invert);
-
-// Writes a string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
-void oled_write_ln(const char *data, bool invert);
-
-// Writes a PROGMEM string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Remapped to call 'void oled_write(const char *data, bool invert);' on ARM
-void oled_write_P(const char *data, bool invert);
-
-// Writes a PROGMEM string to the buffer at current cursor position
-// Advances the cursor while writing, inverts the pixels if true
-// Advances the cursor to the next page, wiring ' ' to the remainder of the current page
-// Remapped to call 'void oled_write_ln(const char *data, bool invert);' on ARM
-void oled_write_ln_P(const char *data, bool invert);
-
-// Can be used to manually turn on the screen if it is off
-// Returns true if the screen was on or turns on
-bool oled_on(void);
-
-// Can be used to manually turn off the screen if it is on
-// Returns true if the screen was off or turns off
-bool oled_off(void);
-
-// Basically it's oled_render, but with timeout management and oled_task_user calling!
-void oled_task(void);
-
-// Called at the start of oled_task, weak function overridable by the user
-void oled_task_user(void);
-
-// Scrolls the entire display right
-// Returns true if the screen was scrolling or starts scrolling
-// NOTE: display contents cannot be changed while scrolling
-bool oled_scroll_right(void);
-
-// Scrolls the entire display left
-// Returns true if the screen was scrolling or starts scrolling
-// NOTE: display contents cannot be changed while scrolling
-bool oled_scroll_left(void);
-
-// Turns off display scrolling
-// Returns true if the screen was not scrolling or stops scrolling
-bool oled_scroll_off(void);
-
-// Returns the maximum number of characters that will fit on a line
-uint8_t oled_max_chars(void);
-
-// Returns the maximum number of lines that will fit on the OLED
-uint8_t oled_max_lines(void);
-```
-
-!> Scrolling and rotation are unsupported on the SH1106.
-
-## SSD1306.h driver conversion guide
-
-|Old API                    |Recommended New API                |
-|---------------------------|-----------------------------------|
-|`struct CharacterMatrix`   |*removed - delete all references*  |
-|`iota_gfx_init`            |`oled_init`                        |
-|`iota_gfx_on`              |`oled_on`                          |
-|`iota_gfx_off`             |`oled_off`                         |
-|`iota_gfx_flush`           |`oled_render`                      |
-|`iota_gfx_write_char`      |`oled_write_char`                  |
-|`iota_gfx_write`           |`oled_write`                       |
-|`iota_gfx_write_P`         |`oled_write_P`                     |
-|`iota_gfx_clear_screen`    |`oled_clear`                       |
-|`matrix_clear`             |*removed - delete all references*  |
-|`matrix_write_char_inner`  |`oled_write_char`                  |
-|`matrix_write_char`        |`oled_write_char`                  |
-|`matrix_write`             |`oled_write`                       |
-|`matrix_write_ln`          |`oled_write_ln`                    |
-|`matrix_write_P`           |`oled_write_P`                     |
-|`matrix_write_ln_P`        |`oled_write_ln_P`                  |
-|`matrix_render`            |`oled_render`                      |
-|`iota_gfx_task`            |`oled_task`                        |
-|`iota_gfx_task_user`       |`oled_task_user`                   |

docs/feature_rgb_matrix.md

@@ -1,404 +1,217 @@
 # 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
 
 There is basic support for addressable RGB matrix lighting with the I2C IS31FL3731 RGB controller. To enable it, add this to your `rules.mk`:
 
-```C
-RGB_MATRIX_ENABLE = IS31FL3731
-```
+    RGB_MATRIX_ENABLE = IS31FL3731
 
 Configure the hardware via your `config.h`:
 
-```C
-// This is a 7-bit address, that gets left-shifted and bit 0
-// set to 0 for write, 1 for read (as per I2C protocol)
-// The address will vary depending on your wiring:
-// 0b1110100 AD <-> GND
-// 0b1110111 AD <-> VCC
-// 0b1110101 AD <-> SCL
-// 0b1110110 AD <-> SDA
-#define DRIVER_ADDR_1 0b1110100
-#define DRIVER_ADDR_2 0b1110110
+	// This is a 7-bit address, that gets left-shifted and bit 0
+	// set to 0 for write, 1 for read (as per I2C protocol)
+	// The address will vary depending on your wiring:
+	// 0b1110100 AD <-> GND
+	// 0b1110111 AD <-> VCC
+	// 0b1110101 AD <-> SCL
+	// 0b1110110 AD <-> SDA
+	#define DRIVER_ADDR_1 0b1110100
+	#define DRIVER_ADDR_2 0b1110110
 
-#define DRIVER_COUNT 2
-#define DRIVER_1_LED_TOTAL 25
-#define DRIVER_2_LED_TOTAL 24
-#define DRIVER_LED_TOTAL (DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL)
-```
-
-!> Note the parentheses, this is so when `DRIVER_LED_TOTAL` is used in code and expanded, the values are added together before any additional math is applied to them. As an example, `rand() % (DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL)` will give very different results than `rand() % DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL`.
+	#define DRIVER_COUNT 2
+	#define DRIVER_1_LED_TOTAL 25
+	#define DRIVER_2_LED_TOTAL 24
+	#define DRIVER_LED_TOTAL DRIVER_1_LED_TOTAL + DRIVER_2_LED_TOTAL
 
 Currently only 2 drivers are supported, but it would be trivial to support all 4 combinations.
 
 Define these arrays listing all the LEDs in your `<keyboard>.c`:
 
-```C
-const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
-/* Refer to IS31 manual for these locations
- *   driver
- *   |  R location
- *   |  |      G location
- *   |  |      |      B location
- *   |  |      |      | */
-    {0, C1_3,  C2_3,  C3_3},
-    ....
-}
-```
+	const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
+	/* Refer to IS31 manual for these locations
+	 *   driver
+	 *   |  R location
+	 *   |  |      G location
+	 *   |  |      |      B location
+	 *   |  |      |      | */
+	    {0, C1_3,  C2_3,  C3_3},
+	    ....
+	}
 
 Where `Cx_y` is the location of the LED in the matrix defined by [the datasheet](http://www.issi.com/WW/pdf/31FL3731.pdf) and the header file `drivers/issi/is31fl3731.h`. The `driver` is the index of the driver you defined in your `config.h` (`0` or `1` right now).
 
----
-###  IS31FL3733/IS31FL3737
-
-!> For the IS31FL3737, replace all instances of `IS31FL3733` below with `IS31FL3737`.
+###  IS31FL3733
 
 There is basic support for addressable RGB matrix lighting with the I2C IS31FL3733 RGB controller. To enable it, add this to your `rules.mk`:
 
-```C
-RGB_MATRIX_ENABLE = IS31FL3733
-```
+    RGB_MATRIX_ENABLE = IS31FL3733
 
 Configure the hardware via your `config.h`:
 
-```C
-// 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:
-// 00 <-> GND
-// 01 <-> SCL
-// 10 <-> SDA
-// 11 <-> VCC
-// ADDR1 represents A1:A0 of the 7-bit address.
-// ADDR2 represents A3:A2 of the 7-bit address.
-// The result is: 0b101(ADDR2)(ADDR1)
-#define DRIVER_ADDR_1 0b1010000
-#define DRIVER_ADDR_2 0b1010000 // this is here for compliancy reasons.
+	// 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:
+	// 00 <-> GND
+	// 01 <-> SCL
+	// 10 <-> SDA
+	// 11 <-> VCC
+	// ADDR1 represents A1:A0 of the 7-bit address.
+	// ADDR2 represents A3:A2 of the 7-bit address.
+	// The result is: 0b101(ADDR2)(ADDR1)
+	#define DRIVER_ADDR_1 0b1010000
+	#define DRIVER_ADDR_2 0b1010000 // this is here for compliancy reasons.
 
-#define DRIVER_COUNT 2
-#define DRIVER_1_LED_TOTAL 64
-#define DRIVER_LED_TOTAL DRIVER_1_LED_TOTAL
-```
+	#define DRIVER_COUNT 1
+	#define DRIVER_1_LED_TOTAL 64
+	#define DRIVER_LED_TOTAL DRIVER_1_LED_TOTAL
 
 Currently only a single drivers is supported, but it would be trivial to support all 4 combinations. For now define `DRIVER_ADDR_2` as `DRIVER_ADDR_1`
 
 Define these arrays listing all the LEDs in your `<keyboard>.c`:
 
-```C
-const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
-/* Refer to IS31 manual for these locations
- *   driver
- *   |  R location
- *   |  |       G location
- *   |  |       |       B location
- *   |  |       |       | */
-    {0, B_1,    A_1,    C_1},
-    ....
-}
-```
+	const is31_led g_is31_leds[DRIVER_LED_TOTAL] = {
+	/* Refer to IS31 manual for these locations
+	 *   driver
+	 *   |  R location
+	 *   |  |       G location
+	 *   |  |       |       B location
+	 *   |  |       |       | */
+	    {0, B_1,    A_1,    C_1},
+	    ....
+	}
 
 Where `X_Y` is the location of the LED in the matrix defined by [the datasheet](http://www.issi.com/WW/pdf/31FL3733.pdf) and the header file `drivers/issi/is31fl3733.h`. The `driver` is the index of the driver you defined in your `config.h` (Only `0` right now).
 
----
+From this point forward the configuration is the same for all the drivers. 
 
-### WS2812 (AVR only)
+	const rgb_led g_rgb_leds[DRIVER_LED_TOTAL] = {
+	/* {row | col << 4}
+	 *    |           {x=0..224, y=0..64}
+	 *    |              |               modifier
+	 *    |              |                 | */
+	    {{0|(0<<4)},   {20.36*0, 21.33*0}, 1},
+	    {{0|(1<<4)},   {20.36*1, 21.33*0}, 1},
+	    ....
+	}
 
-There is basic support for addressable RGB matrix lighting with a WS2811/WS2812{a,b,c} addressable LED strand. To enable it, add this to your `rules.mk`:
+The format for the matrix position used in this array is `{row | (col << 4)}`. The `x` is between (inclusive) 0-224, and `y` is between (inclusive) 0-64. The easiest way to calculate these positions is:
 
-```C
-RGB_MATRIX_ENABLE = WS2812
-```
+    x = 224 / ( NUMBER_OF_ROWS - 1 ) * ROW_POSITION
+    y = 64 / (NUMBER_OF_COLS - 1 ) * COL_POSITION
 
-Configure the hardware via your `config.h`:
+Where all variables are decimels/floats.
 
-```C
-// The pin connected to the data pin of the LEDs
-#define RGB_DI_PIN D7
-// The number of LEDs connected
-#define DRIVER_LED_TOTAL 70
-```
-
----
-
-From this point forward the configuration is the same for all the drivers. The `led_config_t` struct provides a key electrical matrix to led index lookup table, what the physical position of each LED is on the board, and what type of key or usage the LED if the LED represents. Here is a brief example:
-
-```C
-const led_config_t g_led_config = { {
-  // Key Matrix to LED Index
-  {   5, NO_LED, NO_LED,   0 },
-  { NO_LED, NO_LED, NO_LED, NO_LED },
-  {   4, NO_LED, NO_LED,   1 },
-  {   3, NO_LED, NO_LED,   2 }
-}, {
-  // LED Index to Physical Position
-  { 188,  16 }, { 187,  48 }, { 149,  64 }, { 112,  64 }, {  37,  48 }, {  38,  16 }
-}, {
-  // LED Index to Flag
-  1, 4, 4, 4, 4, 1
-} };
-```
-
-The first part, `// Key Matrix to LED Index`, tells the system what key this LED represents by using the key's electrical matrix row & col. The second part, `// LED Index to Physical Position` represents the LED's physical `{ x, y }` position on the keyboard. The default expected range of values for `{ x, y }` is the inclusive range `{ 0..224, 0..64 }`. This default expected range is due to effects that calculate the center of the keyboard for their animations. The easiest way to calculate these positions is imagine your keyboard is a grid, and the top left of the keyboard represents `{ x, y }` coordinate `{ 0, 0 }` and the bottom right of your keyboard represents `{ 224, 64 }`. Using this as a basis, you can use the following formula to calculate the physical position:
-
-```C
-x = 224 / (NUMBER_OF_COLS - 1) * COL_POSITION
-y =  64 / (NUMBER_OF_ROWS - 1) * ROW_POSITION
-```
-
-Where NUMBER_OF_COLS, NUMBER_OF_ROWS, COL_POSITION, & ROW_POSITION are all based on the physical layout of your keyboard, not the electrical layout. 
-
-As mentioned earlier, the center of the keyboard by default is expected to be `{ 112, 32 }`, but this can be changed if you want to more accurately calculate the LED's physical `{ x, y }` positions. Keyboard designers can implement `#define RGB_MATRIX_CENTER { 112, 32 }` in their config.h file with the new center point of the keyboard, or where they want it to be allowing more possibilities for the `{ x, y }` values. Do note that the maximum value for x or y is 255, and the recommended maximum is 224 as this gives animations runoff room before they reset.
-
-`// LED Index to Flag` is a bitmask, whether or not a certain LEDs is of a certain type. It is recommended that LEDs are set to only 1 type.
-
-## Flags
-
-|Define                              |Description                                |
-|------------------------------------|-------------------------------------------|
-|`#define HAS_FLAGS(bits, flags)`    |Returns true if `bits` has all `flags` set.|
-|`#define HAS_ANY_FLAGS(bits, flags)`|Returns true if `bits` has any `flags` set.|
-|`#define LED_FLAG_NONE      0x00`   |If this LED has no flags.                  |
-|`#define LED_FLAG_ALL       0xFF`   |If this LED has all flags.                 |
-|`#define LED_FLAG_MODIFIER  0x01`   |If the Key for this LED is a modifier.     |
-|`#define LED_FLAG_UNDERGLOW 0x02`   |If the LED is for underglow.               |
-|`#define LED_FLAG_KEYLIGHT  0x04`   |If the LED is for key backlight.           |
+`modifier` is a boolean, whether or not a certain key is considered a modifier (used in some effects).
 
 ## Keycodes
 
 All RGB keycodes are currently shared with the RGBLIGHT system:
 
-* `RGB_TOG` - toggle
-* `RGB_MOD` - cycle through modes
-* `RGB_HUI` - increase hue
-* `RGB_HUD` - decrease hue
-* `RGB_SAI` - increase saturation
-* `RGB_SAD` - decrease saturation
-* `RGB_VAI` - increase value
-* `RGB_VAD` - decrease value
-* `RGB_SPI` - increase speed effect (no EEPROM support)
-* `RGB_SPD` - decrease speed effect (no EEPROM support)
-* `RGB_MODE_*` keycodes will generally work, but are not currently mapped to the correct effects for the RGB Matrix system
+	* `RGB_TOG` - toggle
+	* `RGB_MOD` - cycle through modes
+	* `RGB_HUI` - increase hue
+	* `RGB_HUD` - decrease hue
+	* `RGB_SAI` - increase saturation
+	* `RGB_SAD` - decrease saturation
+	* `RGB_VAI` - increase value
+	* `RGB_VAD` - decrease value
+	* `RGB_SPI` - increase speed effect (no EEPROM support)
+	* `RGB_SPD` - decrease speed effect (no EEPROM support)
+
+
+	* `RGB_MODE_*` keycodes will generally work, but are not currently mapped to the correct effects for the RGB Matrix system
 
 ## RGB Matrix Effects
 
-All effects have been configured to support current configuration values (Hue, Saturation, Value, & Speed) unless otherwise noted below. These are the effects that are currently available:
-
-```C
-enum rgb_matrix_effects {
-    RGB_MATRIX_NONE = 0,
-    RGB_MATRIX_SOLID_COLOR = 1,     // Static single hue, no speed support
-    RGB_MATRIX_ALPHAS_MODS,         // Static dual hue, speed is hue for secondary hue
-    RGB_MATRIX_GRADIENT_UP_DOWN,    // Static gradient top to bottom, speed controls how much gradient changes
-    RGB_MATRIX_BREATHING,           // Single hue brightness cycling animation
-    RGB_MATRIX_BAND_SAT,        // Single hue band fading saturation scrolling left to right
-    RGB_MATRIX_BAND_VAL,        // Single hue band fading brightness scrolling left to right
-    RGB_MATRIX_BAND_PINWHEEL_SAT,   // Single hue 3 blade spinning pinwheel fades saturation
-    RGB_MATRIX_BAND_PINWHEEL_VAL,   // Single hue 3 blade spinning pinwheel fades brightness
-    RGB_MATRIX_BAND_SPIRAL_SAT,     // Single hue spinning spiral fades saturation
-    RGB_MATRIX_BAND_SPIRAL_VAL,     // Single hue spinning spiral fades brightness
-    RGB_MATRIX_CYCLE_ALL,           // Full keyboard solid hue cycling through full gradient
-    RGB_MATRIX_CYCLE_LEFT_RIGHT,    // Full gradient scrolling left to right
-    RGB_MATRIX_CYCLE_UP_DOWN,       // Full gradient scrolling top to bottom
-    RGB_MATRIX_CYCLE_OUT_IN,        // Full gradient scrolling out to in
-    RGB_MATRIX_CYCLE_OUT_IN_DUAL,   // Full dual gradients scrolling out to in
-    RGB_MATRIX_RAINBOW_MOVING_CHEVRON,  // Full gradent Chevron shapped scrolling left to right
-    RGB_MATRIX_CYCLE_PINWHEEL,      // Full gradient spinning pinwheel around center of keyboard
-    RGB_MATRIX_CYCLE_SPIRAL,        // Full gradient spinning spiral around center of keyboard
-    RGB_MATRIX_DUAL_BEACON,         // Full gradient spinning around center of keyboard
-    RGB_MATRIX_RAINBOW_BEACON,      // Full tighter gradient spinning around center of keyboard
-    RGB_MATRIX_RAINBOW_PINWHEELS,   // Full dual gradients spinning two halfs of keyboard
-    RGB_MATRIX_RAINDROPS,           // Randomly changes a single key's hue
-    RGB_MATRIX_JELLYBEAN_RAINDROPS, // Randomly changes a single key's hue and saturation
-#if define(RGB_MATRIX_FRAMEBUFFER_EFFECTS)
-    RGB_MATRIX_TYPING_HEATMAP,      // How hot is your WPM!
-    RGB_MATRIX_DIGITAL_RAIN,        // That famous computer simulation
-#endif
-#if defined(RGB_MATRIX_KEYPRESSES) || defined(RGB_MATRIX_KEYRELEASES)
-    RGB_MATRIX_SOLID_REACTIVE_SIMPLE,   // Pulses keys hit to hue & value then fades value out
-    RGB_MATRIX_SOLID_REACTIVE,      // Static single hue, pulses keys hit to shifted hue then fades to current hue
-    RGB_MATRIX_SOLID_REACTIVE_WIDE       // Hue & value pulse near a single key hit then fades value out
-    RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE  // Hue & value pulse near multiple key hits then fades value out
-    RGB_MATRIX_SOLID_REACTIVE_CROSS      // Hue & value pulse the same column and row of a single key hit then fades value out
-    RGB_MATRIX_SOLID_REACTIVE_MULTICROSS // Hue & value pulse the same column and row of multiple key hits then fades value out
-    RGB_MATRIX_SOLID_REACTIVE_NEXUS      // Hue & value pulse away on the same column and row of a single key hit then fades value out
-    RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS // Hue & value pulse away on the same column and row of multiple key hits then fades value out
-    RGB_MATRIX_SPLASH,              // Full gradient & value pulse away from a single key hit then fades value out
-    RGB_MATRIX_MULTISPLASH,         // Full gradient & value pulse away from multiple key hits then fades value out
-    RGB_MATRIX_SOLID_SPLASH,        // Hue & value pulse away from a single key hit then fades value out
-    RGB_MATRIX_SOLID_MULTISPLASH,   // Hue & value pulse away from multiple key hits then fades value out
-#endif
-    RGB_MATRIX_EFFECT_MAX
-};
-```
+These are the effects that are currently available:
 
+	enum rgb_matrix_effects {
+	    RGB_MATRIX_SOLID_COLOR = 1,
+	    RGB_MATRIX_ALPHAS_MODS,
+	    RGB_MATRIX_DUAL_BEACON,
+	    RGB_MATRIX_GRADIENT_UP_DOWN,
+	    RGB_MATRIX_RAINDROPS,
+	    RGB_MATRIX_CYCLE_ALL,
+	    RGB_MATRIX_CYCLE_LEFT_RIGHT,
+	    RGB_MATRIX_CYCLE_UP_DOWN,
+	    RGB_MATRIX_RAINBOW_BEACON,
+	    RGB_MATRIX_RAINBOW_PINWHEELS,
+	    RGB_MATRIX_RAINBOW_MOVING_CHEVRON,
+	    RGB_MATRIX_JELLYBEAN_RAINDROPS,
+	    RGB_MATRIX_DIGITAL_RAIN,
+	#ifdef RGB_MATRIX_KEYPRESSES
+	    RGB_MATRIX_SOLID_REACTIVE,
+	    RGB_MATRIX_SPLASH,
+	    RGB_MATRIX_MULTISPLASH,
+	    RGB_MATRIX_SOLID_SPLASH,
+	    RGB_MATRIX_SOLID_MULTISPLASH,
+	#endif
+	    RGB_MATRIX_EFFECT_MAX
+	};
+    
 You can disable a single effect by defining `DISABLE_[EFFECT_NAME]` in your `config.h`:
 
 
-|Define                                                 |Description                                    |
-|-------------------------------------------------------|-----------------------------------------------|
-|`#define DISABLE_RGB_MATRIX_ALPHAS_MODS`               |Disables `RGB_MATRIX_ALPHAS_MODS`              |
-|`#define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN`          |Disables `RGB_MATRIX_GRADIENT_UP_DOWN`         |
-|`#define DISABLE_RGB_MATRIX_BREATHING`                 |Disables `RGB_MATRIX_BREATHING`                |
-|`#define DISABLE_RGB_MATRIX_BAND_SAT`                  |Disables `RGB_MATRIX_BAND_SAT`                 |
-|`#define DISABLE_RGB_MATRIX_BAND_VAL`                  |Disables `RGB_MATRIX_BAND_VAL`                 |
-|`#define DISABLE_RGB_MATRIX_BAND_PINWHEEL_SAT`         |Disables `RGB_MATRIX_BAND_PINWHEEL_SAT`        |
-|`#define DISABLE_RGB_MATRIX_BAND_PINWHEEL_VAL`         |Disables `RGB_MATRIX_BAND_PINWHEEL_VAL`        |
-|`#define DISABLE_RGB_MATRIX_BAND_SPIRAL_SAT`           |Disables `RGB_MATRIX_BAND_SPIRAL_SAT`          |
-|`#define DISABLE_RGB_MATRIX_BAND_SPIRAL_VAL`           |Disables `RGB_MATRIX_BAND_SPIRAL_VAL`          |
-|`#define DISABLE_RGB_MATRIX_CYCLE_ALL`                 |Disables `RGB_MATRIX_CYCLE_ALL`                |
-|`#define DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT`          |Disables `RGB_MATRIX_CYCLE_LEFT_RIGHT`         |
-|`#define DISABLE_RGB_MATRIX_CYCLE_UP_DOWN`             |Disables `RGB_MATRIX_CYCLE_UP_DOWN`            |
-|`#define DISABLE_RGB_MATRIX_CYCLE_OUT_IN`              |Disables `RGB_MATRIX_CYCLE_OUT_IN`             |
-|`#define DISABLE_RGB_MATRIX_CYCLE_OUT_IN_DUAL`         |Disables `RGB_MATRIX_CYCLE_OUT_IN_DUAL`        |
-|`#define DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON`    |Disables `RGB_MATRIX_RAINBOW_MOVING_CHEVRON`   |
-|`#define DISABLE_RGB_MATRIX_DUAL_BEACON`               |Disables `RGB_MATRIX_DUAL_BEACON`              |
-|`#define DISABLE_RGB_MATRIX_CYCLE_PINWHEEL`            |Disables `RGB_MATRIX_CYCLE_PINWHEEL`           |
-|`#define DISABLE_RGB_MATRIX_CYCLE_SPIRAL`              |Disables `RGB_MATRIX_CYCLE_SPIRAL`             |
-|`#define DISABLE_RGB_MATRIX_RAINBOW_BEACON`            |Disables `RGB_MATRIX_RAINBOW_BEACON`           |
-|`#define DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS`         |Disables `RGB_MATRIX_RAINBOW_PINWHEELS`        |
-|`#define DISABLE_RGB_MATRIX_RAINDROPS`                 |Disables `RGB_MATRIX_RAINDROPS`                |
-|`#define DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS`       |Disables `RGB_MATRIX_JELLYBEAN_RAINDROPS`      |
-|`#define DISABLE_RGB_MATRIX_TYPING_HEATMAP`            |Disables `RGB_MATRIX_TYPING_HEATMAP`           |
-|`#define DISABLE_RGB_MATRIX_DIGITAL_RAIN`              |Disables `RGB_MATRIX_DIGITAL_RAIN`             |
-|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE`            |Disables `RGB_MATRIX_SOLID_REACTIVE`           |
-|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE`     |Disables `RGB_MATRIX_SOLID_REACTIVE_SIMPLE`    |
-|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_WIDE`       |Disables `RGB_MATRIX_SOLID_REACTIVE_WIDE`      |
-|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE`  |Disables `RGB_MATRIX_SOLID_REACTIVE_MULTIWIDE` |
-|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_CROSS`      |Disables `RGB_MATRIX_SOLID_REACTIVE_CROSS`     |
-|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTICROSS` |Disables `RGB_MATRIX_SOLID_REACTIVE_MULTICROSS`|
-|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_NEXUS`      |Disables `RGB_MATRIX_SOLID_REACTIVE_NEXUS`     |
-|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS` |Disables `RGB_MATRIX_SOLID_REACTIVE_MULTINEXUS`|
-|`#define DISABLE_RGB_MATRIX_SPLASH`                    |Disables `RGB_MATRIX_SPLASH`                   |
-|`#define DISABLE_RGB_MATRIX_MULTISPLASH`               |Disables `RGB_MATRIX_MULTISPLASH`              |
-|`#define DISABLE_RGB_MATRIX_SOLID_SPLASH`              |Disables `RGB_MATRIX_SOLID_SPLASH`             |
-|`#define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH`         |Disables `RGB_MATRIX_SOLID_MULTISPLASH`        |
+|Define                                             |Description                                 |
+|---------------------------------------------------|--------------------------------------------|
+|`#define DISABLE_RGB_MATRIX_ALPHAS_MODS`           |Disables `RGB_MATRIX_ALPHAS_MODS`           |
+|`#define DISABLE_RGB_MATRIX_DUAL_BEACON`           |Disables `RGB_MATRIX_DUAL_BEACON`           |
+|`#define DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN`      |Disables `RGB_MATRIX_GRADIENT_UP_DOWN`      |
+|`#define DISABLE_RGB_MATRIX_RAINDROPS`             |Disables `RGB_MATRIX_RAINDROPS`             |
+|`#define DISABLE_RGB_MATRIX_CYCLE_ALL`             |Disables `RGB_MATRIX_CYCLE_ALL`             |
+|`#define DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT`      |Disables `RGB_MATRIX_CYCLE_LEFT_RIGHT`      |
+|`#define DISABLE_RGB_MATRIX_CYCLE_UP_DOWN`         |Disables `RGB_MATRIX_CYCLE_UP_DOWN`         |
+|`#define DISABLE_RGB_MATRIX_RAINBOW_BEACON`        |Disables `RGB_MATRIX_RAINBOW_BEACON`        |
+|`#define DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS`     |Disables `RGB_MATRIX_RAINBOW_PINWHEELS`     |
+|`#define DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON`|Disables `RGB_MATRIX_RAINBOW_MOVING_CHEVRON`|
+|`#define DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS`   |Disables `RGB_MATRIX_JELLYBEAN_RAINDROPS`   |
+|`#define DISABLE_RGB_MATRIX_DIGITAL_RAIN`          |Disables `RGB_MATRIX_DIGITAL_RAIN`          |
+|`#define DISABLE_RGB_MATRIX_SOLID_REACTIVE`        |Disables `RGB_MATRIX_SOLID_REACTIVE`        |
+|`#define DISABLE_RGB_MATRIX_SPLASH`                |Disables `RGB_MATRIX_SPLASH`                |
+|`#define DISABLE_RGB_MATRIX_MULTISPLASH`           |Disables `RGB_MATRIX_MULTISPLASH`           |
+|`#define DISABLE_RGB_MATRIX_SOLID_SPLASH`          |Disables `RGB_MATRIX_SOLID_SPLASH`          |
+|`#define DISABLE_RGB_MATRIX_SOLID_MULTISPLASH`     |Disables `RGB_MATRIX_SOLID_MULTISPLASH`     |
 
 
-## Custom RGB Matrix Effects
+## Custom layer effects
 
-By setting `RGB_MATRIX_CUSTOM_USER` (and/or `RGB_MATRIX_CUSTOM_KB`) in `rule.mk`, new effects can be defined directly from userspace, without having to edit any QMK core files.
+Custom layer effects can be done by defining this in your `<keyboard>.c`:
 
-To declare new effects, create a new `rgb_matrix_user/kb.inc` that looks something like this:
-
-`rgb_matrix_user.inc` should go in the root of the keymap directory.
-`rgb_matrix_kb.inc` should go in the root of the keyboard directory.
-
-```C
-// !!! DO NOT ADD #pragma once !!! //
-
-// Step 1.
-// Declare custom effects using the RGB_MATRIX_EFFECT macro
-// (note the lack of semicolon after the macro!)
-RGB_MATRIX_EFFECT(my_cool_effect)
-RGB_MATRIX_EFFECT(my_cool_effect2)
-
-// Step 2.
-// Define effects inside the `RGB_MATRIX_CUSTOM_EFFECT_IMPLS` ifdef block
-#ifdef RGB_MATRIX_CUSTOM_EFFECT_IMPLS
-
-// e.g: A simple effect, self-contained within a single method
-static bool my_cool_effect(effect_params_t* params) {
-  RGB_MATRIX_USE_LIMITS(led_min, led_max);
-  for (uint8_t i = led_min; i < led_max; i++) {
-    rgb_matrix_set_color(i, 0xff, 0xff, 0x00);
-  }
-  return led_max < DRIVER_LED_TOTAL;
-}
-
-// e.g: A more complex effect, relying on external methods and state, with
-// dedicated init and run methods
-static uint8_t some_global_state;
-static void my_cool_effect2_complex_init(effect_params_t* params) {
-  some_global_state = 1;
-}
-static bool my_cool_effect2_complex_run(effect_params_t* params) {
-  RGB_MATRIX_USE_LIMITS(led_min, led_max);
-  for (uint8_t i = led_min; i < led_max; i++) {
-    rgb_matrix_set_color(i, 0xff, some_global_state++, 0xff);
-  }
-
-  return led_max < DRIVER_LED_TOTAL;
-}
-static bool my_cool_effect2(effect_params_t* params) {
-  if (params->init) my_cool_effect2_complex_init(params);
-  return my_cool_effect2_complex_run(params);
-}
-
-#endif // RGB_MATRIX_CUSTOM_EFFECT_IMPLS
-```
-
-For inspiration and examples, check out the built-in effects under `quantum/rgb_matrix_animation/`
-
-
-## Colors
-
-These are shorthands to popular colors. The `RGB` ones can be passed to the `setrgb` functions, while the `HSV` ones to the `sethsv` functions.
-
-|RGB                |HSV                |
-|-------------------|-------------------|
-|`RGB_WHITE`        |`HSV_WHITE`        |
-|`RGB_RED`          |`HSV_RED`          |
-|`RGB_CORAL`        |`HSV_CORAL`        |
-|`RGB_ORANGE`       |`HSV_ORANGE`       |
-|`RGB_GOLDENROD`    |`HSV_GOLDENROD`    |
-|`RGB_GOLD`         |`HSV_GOLD`         |
-|`RGB_YELLOW`       |`HSV_YELLOW`       |
-|`RGB_CHARTREUSE`   |`HSV_CHARTREUSE`   |
-|`RGB_GREEN`        |`HSV_GREEN`        |
-|`RGB_SPRINGGREEN`  |`HSV_SPRINGGREEN`  |
-|`RGB_TURQUOISE`    |`HSV_TURQUOISE`    |
-|`RGB_TEAL`         |`HSV_TEAL`         |
-|`RGB_CYAN`         |`HSV_CYAN`         |
-|`RGB_AZURE`        |`HSV_AZURE`        |
-|`RGB_BLUE`         |`HSV_BLUE`         |
-|`RGB_PURPLE`       |`HSV_PURPLE`       |
-|`RGB_MAGENTA`      |`HSV_MAGENTA`      |
-|`RGB_PINK`         |`HSV_PINK`         |
-
-These are defined in [`rgblight_list.h`](https://github.com/qmk/qmk_firmware/blob/master/quantum/rgblight_list.h). Feel free to add to this list!
+    void rgb_matrix_indicators_kb(void) {
+        rgb_matrix_set_color(index, red, green, blue);
+    }
 
+A similar function works in the keymap as `rgb_matrix_indicators_user`.
 
 ## Additional `config.h` Options
 
-```C
-#define RGB_MATRIX_KEYPRESSES // reacts to keypresses
-#define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (instead of keypresses)
-#define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
-#define RGB_DISABLE_WHEN_USB_SUSPENDED false // turn off effects when suspended
-#define RGB_MATRIX_LED_PROCESS_LIMIT (DRIVER_LED_TOTAL + 4) / 5 // limits the number of LEDs to process in an animation per task run (increases keyboard responsiveness)
-#define RGB_MATRIX_LED_FLUSH_LIMIT 16 // limits in milliseconds how frequently an animation will update the LEDs. 16 (16ms) is equivalent to limiting to 60fps (increases keyboard responsiveness)
-#define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
-#define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_CYCLE_LEFT_RIGHT // Sets the default mode, if none has been set
-```
+	#define RGB_MATRIX_KEYPRESSES // reacts to keypresses (will slow down matrix scan by a lot)
+	#define RGB_MATRIX_KEYRELEASES // reacts to keyreleases (not recommened)
+	#define RGB_DISABLE_AFTER_TIMEOUT 0 // number of ticks to wait until disabling effects
+	#define RGB_DISABLE_WHEN_USB_SUSPENDED false // turn off effects when suspended
+    #define RGB_MATRIX_SKIP_FRAMES 1 // number of frames to skip when displaying animations (0 is full effect) if not defined defaults to 1
+    #define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
 
 ## EEPROM storage
 
 The EEPROM for it is currently shared with the RGBLIGHT system (it's generally assumed only one RGB would be used at a time), but could be configured to use its own 32bit address with:
 
-```C
-#define EECONFIG_RGB_MATRIX (uint32_t *)28
-```
+    #define EECONFIG_RGB_MATRIX (uint32_t *)16
 
-Where `28` is an unused index from `eeconfig.h`.
+Where `16` is an unused index from `eeconfig.h`.
 
 ## Suspended state
 
 To use the suspend feature, add this to your `<keyboard>.c`:
 
-```C
-void suspend_power_down_kb(void)
-{
-    rgb_matrix_set_suspend_state(true);
-}
+	void suspend_power_down_kb(void)
+	{
+	    rgb_matrix_set_suspend_state(true);
+	}
 
-void suspend_wakeup_init_kb(void)
-{
-    rgb_matrix_set_suspend_state(false);
-}
-```
+	void suspend_wakeup_init_kb(void)
+	{
+	    rgb_matrix_set_suspend_state(false);
+	}

docs/feature_rgblight.md

@@ -23,11 +23,10 @@ RGBLIGHT_ENABLE = yes
 
 At minimum you must define the data pin your LED strip is connected to, and the number of LEDs in the strip, in your `config.h`. If your keyboard has onboard RGB LEDs, and you are simply creating a keymap, you usually won't need to modify these.
 
-|Define         |Description                                                                                              |
-|---------------|---------------------------------------------------------------------------------------------------------|
-|`RGB_DI_PIN`   |The pin connected to the data pin of the LEDs                                                            |
-|`RGBLED_NUM`   |The number of LEDs connected                                                                             |
-|`RGBLED_SPLIT` |(Optional) For split keyboards, the number of LEDs connected on each half directly wired to `RGB_DI_PIN` |
+|Define      |Description                                  |
+|------------|---------------------------------------------|
+|`RGB_DI_PIN`|The pin connected to the data pin of the LEDs|
+|`RGBLED_NUM`|The number of LEDs connected                 |
 
 Then you should be able to use the keycodes below to change the RGB lighting to your liking.
 
@@ -37,9 +36,9 @@ QMK uses [Hue, Saturation, and Value](https://en.wikipedia.org/wiki/HSL_and_HSV)
 
 <img src="gitbook/images/color-wheel.svg" alt="HSV Color Wheel" width="250"/>
 
-Changing the **Hue** cycles around the circle.<br>
-Changing the **Saturation** moves between the inner and outer sections of the wheel, affecting the intensity of the color.<br>
-Changing the **Value** sets the overall brightness.<br>
+Changing the **Hue** cycles around the circle.  
+Changing the **Saturation** moves between the inner and outer sections of the wheel, affecting the intensity of the color.  
+Changing the **Value** sets the overall brightness.
 
 ## Keycodes
 
@@ -64,6 +63,8 @@ Changing the **Value** sets the overall brightness.<br>
 |`RGB_MODE_GRADIENT`|`RGB_M_G` |Static gradient animation mode                                      |
 |`RGB_MODE_RGBTEST` |`RGB_M_T` |Red, Green, Blue test animation mode                                |
 
+?> For backwards compatibility, `RGB_SMOD` is another alias of `RGB_MOD`.
+
 ## Configuration
 
 Your RGB lighting can be configured by placing these `#define`s in your `config.h`:
@@ -75,9 +76,9 @@ Your RGB lighting can be configured by placing these `#define`s in your `config.
 |`RGBLIGHT_VAL_STEP`  |`17`         |The number of steps to increment the brightness by                           |
 |`RGBLIGHT_LIMIT_VAL` |`255`        |The maximum brightness level                                                 |
 |`RGBLIGHT_SLEEP`     |*Not defined*|If defined, the RGB lighting will be switched off when the host goes to sleep|
-|`RGBLIGHT_SPLIT`     |*Not defined*|If defined, synchronization functionality for split keyboards is added|
 
-## Effects and Animations
+## Animations
+
 
 Not only can this lighting be whatever color you want,
 if `RGBLIGHT_EFFECT_xxxx` or `RGBLIGHT_ANIMATIONS` is defined, you also have a number of animation modes at your disposal:
@@ -99,59 +100,32 @@ Check out [this video](https://youtube.com/watch?v=VKrpPAHlisY) for a demonstrat
 
 Note: For versions older than 0.6.117, The mode numbers were written directly. In `quantum/rgblight.h` there is a contrast table between the old mode number and the current symbol.
 
-### Effect and Animation Toggles
-
-Use these defines to add or remove animations from the firmware. When you are running low on flash space, it can be helpful to disable animations you are not using.
+The following options can be used to tweak the various animations:
 
 |Define                              |Default      |Description                                                                          |
 |------------------------------------|-------------|-------------------------------------------------------------------------------------|
-|`RGBLIGHT_ANIMATIONS`               |*Not defined*|Enable all additional animation modes.                                   |
-|`RGBLIGHT_EFFECT_ALTERNATING`       |*Not defined*|Enable alternating animation mode.                                       |
-|`RGBLIGHT_EFFECT_BREATHING`         |*Not defined*|Enable breathing animation mode.                                         |
-|`RGBLIGHT_EFFECT_CHRISTMAS`         |*Not defined*|Enable christmas animation mode.                                         |
-|`RGBLIGHT_EFFECT_KNIGHT`            |*Not defined*|Enable knight animation mode.                                            |
-|`RGBLIGHT_EFFECT_RAINBOW_MOOD`      |*Not defined*|Enable rainbow mood animation mode.                                      |
-|`RGBLIGHT_EFFECT_RAINBOW_SWIRL`     |*Not defined*|Enable rainbow swirl animation mode.                                     |
-|`RGBLIGHT_EFFECT_RGB_TEST`          |*Not defined*|Enable RGB test animation mode.                                          |
-|`RGBLIGHT_EFFECT_SNAKE`             |*Not defined*|Enable snake animation mode.                                             |
-|`RGBLIGHT_EFFECT_STATIC_GRADIENT`   |*Not defined*|Enable static gradient mode.                                             |
-
-### Effect and Animation Settings
-
-The following options are used to tweak the various animations:
-
-|Define                              |Default      |Description                                                                          |
-|------------------------------------|-------------|-------------------------------------------------------------------------------------|
-|`RGBLIGHT_EFFECT_BREATHE_CENTER`    |*Not defined*|If defined, used to calculate the curve for the breathing animation. Valid values are 1.0 to 2.7 |
+|`RGBLIGHT_EFFECT_BREATHING`         |*Not defined*|If defined, enable breathing animation mode.                                         |
+|`RGBLIGHT_EFFECT_RAINBOW_MOOD`      |*Not defined*|If defined, enable rainbow mood animation mode.                                      |
+|`RGBLIGHT_EFFECT_RAINBOW_SWIRL`     |*Not defined*|If defined, enable rainbow swirl animation mode.                                     |
+|`RGBLIGHT_EFFECT_SNAKE`             |*Not defined*|If defined, enable snake animation mode.                                             |
+|`RGBLIGHT_EFFECT_KNIGHT`            |*Not defined*|If defined, enable knight animation mode.                                            |
+|`RGBLIGHT_EFFECT_CHRISTMAS`         |*Not defined*|If defined, enable christmas animation mode.                                         |
+|`RGBLIGHT_EFFECT_STATIC_GRADIENT`   |*Not defined*|If defined, enable static gradient mode.                                             |
+|`RGBLIGHT_EFFECT_RGB_TEST`          |*Not defined*|If defined, enable RGB test animation mode.                                          |
+|`RGBLIGHT_EFFECT_ALTERNATING`       |*Not defined*|If defined, enable alternating animation mode.                                       |
+|`RGBLIGHT_ANIMATIONS`               |*Not defined*|If defined, enables all additional animation modes                                   |
+|`RGBLIGHT_EFFECT_BREATHE_CENTER`    |`1.85`       |Used to calculate the curve for the breathing animation. Valid values are 1.0 to 2.7 |
 |`RGBLIGHT_EFFECT_BREATHE_MAX`       |`255`        |The maximum brightness for the breathing mode. Valid values are 1 to 255             |
-|`RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL`|`1000`       |How long to wait between light changes for the "Christmas" animation, in milliseconds|
-|`RGBLIGHT_EFFECT_CHRISTMAS_STEP`    |`2`          |The number of LEDs to group the red/green colors by for the "Christmas" animation    |
-|`RGBLIGHT_EFFECT_KNIGHT_LED_NUM`    |`RGBLED_NUM` |The number of LEDs to have the "Knight" animation travel                             |
+|`RGBLIGHT_EFFECT_SNAKE_LENGTH`      |`4`          |The number of LEDs to light up for the "Snake" animation                             |
 |`RGBLIGHT_EFFECT_KNIGHT_LENGTH`     |`3`          |The number of LEDs to light up for the "Knight" animation                            |
 |`RGBLIGHT_EFFECT_KNIGHT_OFFSET`     |`0`          |The number of LEDs to start the "Knight" animation from the start of the strip by    |
-|`RGBLIGHT_RAINBOW_SWIRL_RANGE`      |`255`        |Range adjustment for the rainbow swirl effect to get different swirls                |
-|`RGBLIGHT_EFFECT_SNAKE_LENGTH`      |`4`          |The number of LEDs to light up for the "Snake" animation                             |
-
-### Example Usage to Reduce Memory Footprint
-  1. Remove `RGBLIGHT_ANIMATIONS` from `config.h`.
-  1. Selectively add the animations you want to enable. The following would enable two animations and save about 4KiB:
-
-```diff
- #undef RGBLED_NUM
--#define RGBLIGHT_ANIMATIONS
-+#define RGBLIGHT_EFFECT_STATIC_GRADIENT
-+#define RGBLIGHT_EFFECT_RAINBOW_SWIRL
- #define RGBLED_NUM 12
- #define RGBLIGHT_HUE_STEP 8
- #define RGBLIGHT_SAT_STEP 8
-```
-
-### Animation Speed
+|`RGBLIGHT_EFFECT_KNIGHT_LED_NUM`    |`RGBLED_NUM` |The number of LEDs to have the "Knight" animation travel                             |
+|`RGBLIGHT_EFFECT_CHRISTMAS_INTERVAL`|`1000`       |How long to wait between light changes for the "Christmas" animation, in milliseconds|
+|`RGBLIGHT_EFFECT_CHRISTMAS_STEP`    |`2`          |The number of LEDs to group the red/green colors by for the "Christmas" animation    |
+|`RGBLIGHT_RAINBOW_SWIRL_RANGE`      |`360`        |Range adjustment for the rainbow swirl effect to get different swirls                |
 
 You can also modify the speeds that the different modes animate at:
 
-Here is a quick demo on Youtube (with NPKC KC60) (https://www.youtube.com/watch?v=VKrpPAHlisY).
-
 ```c
 // How long (in milliseconds) to wait between animation steps for each of the "Solid color breathing" animations
 const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5};
@@ -169,216 +143,28 @@ const uint8_t RGBLED_SNAKE_INTERVALS[] PROGMEM = {100, 50, 20};
 const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {127, 63, 31};
 
 // These control which hues are selected for each of the "Static gradient" modes
-const uint8_t RGBLED_GRADIENT_RANGES[] PROGMEM = {255, 170, 127, 85, 64};
+const uint16_t RGBLED_GRADIENT_RANGES[] PROGMEM = {360, 240, 180, 120, 90};
 ```
 
 ## Functions
 
 If you need to change your RGB lighting in code, for example in a macro to change the color whenever you switch layers, QMK provides a set of functions to assist you. See [`rgblight.h`](https://github.com/qmk/qmk_firmware/blob/master/quantum/rgblight.h) for the full list, but the most commonly used functions include:
 
-### Utility Functions
-|Function                                    |Description                                                        |
-|--------------------------------------------|-------------------------------------------------------------------|
-|`sethsv(hue, sat, val, ledbuf)`             |Set ledbuf to the given HSV value                                  |
-|`sethsv_raw(hue, sat, val, ledbuf)`         |Set ledbuf to the given HSV value without RGBLIGHT_LIMIT_VAL check |
-|`setrgb(r, g, b, ledbuf)`                   |Set ledbuf to the given RGB value where `r`/`g`/`b`                |
+|Function                           |Description                                                                                                                                                            |
+|-----------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|`rgblight_enable()`                |Turn LEDs on, based on their previous state                                                                                                                            |
+|`rgblight_enable_noeeprom()`       |Turn LEDs on, based on their previous state (not written to EEPROM)                                                                                                    |
+|`rgblight_disable()`               |Turn LEDs off                                                                                                                                                          |
+|`rgblight_disable_noeeprom()`      |Turn LEDs off (not written to EEPROM)                                                                                                                                  |
+|`rgblight_mode(x)`                 |Set the mode, if RGB animations are enabled                                                                                                                            |
+|`rgblight_mode_noeeprom(x)`        |Set the mode, if RGB animations are enabled (not written to EEPROM)                                                                                                    |
+|`rgblight_setrgb(r, g, b)`         |Set all LEDs to the given RGB value where `r`/`g`/`b` are between 0 and 255 (not written to EEPROM)                                                                    |
+|`rgblight_setrgb_at(r, g, b, led)` |Set a single LED to the given RGB value, where `r`/`g`/`b` are between 0 and 255 and `led` is between 0 and `RGBLED_NUM` (not written to EEPROM)                       |
+|`rgblight_sethsv(h, s, v)`         |Set all LEDs to the given HSV value where `h` is between 0 and 360 and `s`/`v` are between 0 and 255                                                                   |
+|`rgblight_sethsv_noeeprom(h, s, v)`|Set all LEDs to the given HSV value where `h` is between 0 and 360 and `s`/`v` are between 0 and 255 (not written to EEPROM)                                           |
+|`rgblight_sethsv_at(h, s, v, led)` |Set a single LED to the given HSV value, where `h` is between 0 and 360, `s`/`v` are between 0 and 255, and `led` is between 0 and `RGBLED_NUM` (not written to EEPROM)|
 
-### Low level Functions
-|Function                                    |Description                                |
-|--------------------------------------------|-------------------------------------------|
-|`rgblight_set()`                            |Flash out led buffers to LEDs              |
-|`rgblight_set_clipping_range(pos, num)`     |Set clipping Range. see [Clipping Range](#clipping-range) |
-
-Example:
-```c
-sethsv(HSV_WHITE, (LED_TYPE *)&led[0]); // led 0
-sethsv(HSV_RED,   (LED_TYPE *)&led[1]); // led 1
-sethsv(HSV_GREEN, (LED_TYPE *)&led[2]); // led 2
-rgblight_set(); // Utility functions do not call rgblight_set() automatically, so they need to be called explicitly.
-```
-
-### Effects and Animations Functions
-#### effect range setting
-|Function                                    |Description       |
-|--------------------------------------------|------------------|
-|`rgblight_set_effect_range(pos, num)`       |Set Effects Range |
-
-#### direct operation
-|Function                                    |Description  |
-|--------------------------------------------|-------------|
-|`rgblight_setrgb_at(r, g, b, index)`          |Set a single LED to the given RGB value, where `r`/`g`/`b` are between 0 and 255 and `index` is between 0 and `RGBLED_NUM` (not written to EEPROM) |
-|`rgblight_sethsv_at(h, s, v, index)`          |Set a single LED to the given HSV value, where `h`/`s`/`v` are between 0 and 255, and `index` is between 0 and `RGBLED_NUM` (not written to EEPROM) |
-|`rgblight_setrgb_range(r, g, b, start, end)`|Set a continuous range of LEDs to the given RGB value, where `r`/`g`/`b` are between 0 and 255 and `start`(included) and `stop`(excluded) are between 0 and `RGBLED_NUM` (not written to EEPROM)|
-|`rgblight_sethsv_range(h, s, v, start, end)`|Set a continuous range of LEDs to the given HSV value, where `h`/`s`/`v` are between 0 and 255, and `start`(included) and `stop`(excluded) are between 0 and `RGBLED_NUM` (not written to EEPROM)|
-|`rgblight_setrgb(r, g, b)`                  |Set effect range LEDs to the given RGB value where `r`/`g`/`b` are between 0 and 255 (not written to EEPROM) |
-|`rgblight_setrgb_master(r, g, b)`           |Set the LEDs on the master side  to the given RGB value, where `r`/`g`/`b` are between 0 and 255 (not written to EEPROM) |
-|`rgblight_setrgb_slave(r, g, b)`            |Set the LEDs on the slave side  to the given RGB value, where `r`/`g`/`b` are between 0 and 255 (not written to EEPROM) |
-|`rgblight_sethsv_master(h, s, v)`           |Set the LEDs on the master side to the given HSV value, where `h`/`s`/`v` are between 0 and 255 (not written to EEPROM) |
-|`rgblight_sethsv_slave(h, s, v)`            |Set the LEDs on the slave side to the given HSV value, where `h`/`s`/`v` are between 0 and 255 (not written to EEPROM) |
-
-Example:
-```c
-rgblight_sethsv(HSV_WHITE, 0); // led 0
-rgblight_sethsv(HSV_RED,   1); // led 1
-rgblight_sethsv(HSV_GREEN, 2); // led 2
-// The above functions automatically calls rgblight_set(), so there is no need to call it explicitly.
-// Note that it is inefficient to call repeatedly.
-```
-
-#### effect mode change
-|Function                                    |Description  |
-|--------------------------------------------|-------------|
-|`rgblight_mode(x)`                          |Set the mode, if RGB animations are enabled |
-|`rgblight_mode_noeeprom(x)`                 |Set the mode, if RGB animations are enabled (not written to EEPROM) |
-|`rgblight_step()`                           |Change the mode to the next RGB animation in the list of enabled RGB animations |
-|`rgblight_step_noeeprom()`                  |Change the mode to the next RGB animation in the list of enabled RGB animations (not written to EEPROM) |
-|`rgblight_step_reverse()`                   |Change the mode to the previous RGB animation in the list of enabled RGB animations |
-|`rgblight_step_reverse_noeeprom()`          |Change the mode to the previous RGB animation in the list of enabled RGB animations (not written to EEPROM) |
-
-#### effects mode disable/enable
-|Function                                    |Description  |
-|--------------------------------------------|-------------|
-|`rgblight_toggle()`                         |Toggle effect range LEDs between on and off |
-|`rgblight_toggle_noeeprom()`                |Toggle effect range LEDs between on and off (not written to EEPROM) |
-|`rgblight_enable()`                         |Turn effect range LEDs on, based on their previous state |
-|`rgblight_enable_noeeprom()`                |Turn effect range LEDs on, based on their previous state (not written to EEPROM) |
-|`rgblight_disable()`                        |Turn effect range LEDs off |
-|`rgblight_disable_noeeprom()`               |Turn effect range LEDs off (not written to EEPROM) |
-
-#### hue, sat, val change
-|Function                                    |Description  |
-|--------------------------------------------|-------------|
-|`rgblight_increase_hue()`                   |Increase the hue for effect range LEDs. This wraps around at maximum hue |
-|`rgblight_increase_hue_noeeprom()`          |Increase the hue for effect range LEDs. This wraps around at maximum hue (not written to EEPROM) |
-|`rgblight_decrease_hue()`                   |Decrease the hue for effect range LEDs. This wraps around at minimum hue |
-|`rgblight_decrease_hue_noeeprom()`          |Decrease the hue for effect range LEDs. This wraps around at minimum hue (not written to EEPROM) |
-|`rgblight_increase_sat()`                   |Increase the saturation for effect range LEDs. This wraps around at maximum saturation |
-|`rgblight_increase_sat_noeeprom()`          |Increase the saturation for effect range LEDs. This wraps around at maximum saturation (not written to EEPROM) |
-|`rgblight_decrease_sat()`                   |Decrease the saturation for effect range LEDs. This wraps around at minimum saturation |
-|`rgblight_decrease_sat_noeeprom()`          |Decrease the saturation for effect range LEDs. This wraps around at minimum saturation (not written to EEPROM) |
-|`rgblight_increase_val()`                   |Increase the value for effect range LEDs. This wraps around at maximum value |
-|`rgblight_increase_val_noeeprom()`          |Increase the value for effect range LEDs. This wraps around at maximum value (not written to EEPROM) |
-|`rgblight_decrease_val()`                   |Decrease the value for effect range LEDs. This wraps around at minimum value |
-|`rgblight_decrease_val_noeeprom()`          |Decrease the value for effect range LEDs. This wraps around at minimum value (not written to EEPROM) |
-|`rgblight_sethsv(h, s, v)`                  |Set effect range LEDs to the given HSV value where `h`/`s`/`v` are between 0 and 255 |
-|`rgblight_sethsv_noeeprom(h, s, v)`         |Set effect range LEDs to the given HSV value where `h`/`s`/`v` are between 0 and 255 (not written to EEPROM) |
-
-#### query
-|Function               |Description      |
-|-----------------------|-----------------|
-|`rgblight_get_mode()`  |Get current mode |
-|`rgblight_get_hue()`   |Get current hue  |
-|`rgblight_get_sat()`   |Get current sat  |
-|`rgblight_get_val()`   |Get current val  |
-
-## Colors
-
-These are shorthands to popular colors. The `RGB` ones can be passed to the `setrgb` functions, while the `HSV` ones to the `sethsv` functions.
-
-|RGB                |HSV                |
-|-------------------|-------------------|
-|`RGB_WHITE`        |`HSV_WHITE`        |
-|`RGB_RED`          |`HSV_RED`          |
-|`RGB_CORAL`        |`HSV_CORAL`        |
-|`RGB_ORANGE`       |`HSV_ORANGE`       |
-|`RGB_GOLDENROD`    |`HSV_GOLDENROD`    |
-|`RGB_GOLD`         |`HSV_GOLD`         |
-|`RGB_YELLOW`       |`HSV_YELLOW`       |
-|`RGB_CHARTREUSE`   |`HSV_CHARTREUSE`   |
-|`RGB_GREEN`        |`HSV_GREEN`        |
-|`RGB_SPRINGGREEN`  |`HSV_SPRINGGREEN`  |
-|`RGB_TURQUOISE`    |`HSV_TURQUOISE`    |
-|`RGB_TEAL`         |`HSV_TEAL`         |
-|`RGB_CYAN`         |`HSV_CYAN`         |
-|`RGB_AZURE`        |`HSV_AZURE`        |
-|`RGB_BLUE`         |`HSV_BLUE`         |
-|`RGB_PURPLE`       |`HSV_PURPLE`       |
-|`RGB_MAGENTA`      |`HSV_MAGENTA`      |
-|`RGB_PINK`         |`HSV_PINK`         |
-
-```c
-rgblight_setrgb(RGB_ORANGE);
-rgblight_sethsv_noeeprom(HSV_GREEN);
-rgblight_setrgb_at(RGB_GOLD, 3);
-rgblight_sethsv_range(HSV_WHITE, 0, 6);
-```
-
-These are defined in [`rgblight_list.h`](https://github.com/qmk/qmk_firmware/blob/master/quantum/rgblight_list.h). Feel free to add to this list!
-
-
-## Changing the order of the LEDs
-
-If you want to make the logical order of LEDs different from the electrical connection order, you can do this by defining the `RGBLIGHT_LED_MAP` macro in your `config.h`.
-
-Normally, the contents of the LED buffer are output to the LEDs in the same order.
-<img src="https://user-images.githubusercontent.com/2170248/55743718-01866c80-5a6e-11e9-8134-25419928327a.JPG" alt="simple dicrect" width="50%"/>
-
-By defining `RGBLIGHT_LED_MAP` as in the example below, you can specify the LED with addressing in reverse order of the electrical connection order.
-
-```c
-// config.h
-
-#define RGBLED_NUM 4
-#define RGBLIGHT_LED_MAP { 3, 2, 1, 0 }
-
-```
-<img src="https://user-images.githubusercontent.com/2170248/55743725-08ad7a80-5a6e-11e9-83ed-126a2b0209fc.JPG" alt="simple mapped" width="50%"/>
-
-For keyboards that use the RGB LEDs as a backlight for each key, you can also define it as in the example below.
-
-```c
-// config.h
-
-#define RGBLED_NUM 30
-
-/* RGB LED Conversion macro from physical array to electric array */
-#define LED_LAYOUT( \
-    L00, L01, L02, L03, L04, L05,  \
-    L10, L11, L12, L13, L14, L15,  \
-    L20, L21, L22, L23, L24, L25,  \
-    L30, L31, L32, L33, L34, L35,  \
-    L40, L41, L42, L43, L44, L45 ) \
-  { \
-    L05, L04, L03, L02, L01, L00,   \
-    L10, L11, L12, L13, L14, L15,   \
-    L25, L24, L23, L22, L21, L20,   \
-    L30, L31, L32, L33, L34, L35,   \
-    L46, L45, L44, L43, L42, L41    \
-  }
-
-/* RGB LED logical order map */
-/* Top->Bottom, Right->Left */
-#define RGBLIGHT_LED_MAP LED_LAYOUT( \
-  25, 20, 15, 10,  5,  0,       \
-  26, 21, 16, 11,  6,  1,       \
-  27, 22, 17, 12,  7,  2,       \
-  28, 23, 18, 13,  8,  3,       \
-  29, 24, 19, 14,  9,  4 )
-
-```
-## Clipping Range
-
-Using the `rgblight_set_clipping_range()` function, you can prepare more buffers than the actual number of LEDs, and output some of the buffers to the LEDs. This is useful if you want the split keyboard to treat left and right LEDs as logically contiguous.
-
-You can set the Clipping Range by executing the following code.
-
-```c
-// some soruce
-  rgblight_set_clipping_range(3, 4);
-```
-<img src="https://user-images.githubusercontent.com/2170248/55743785-2bd82a00-5a6e-11e9-9d4b-1b4ffaf4932b.JPG" alt="clip direct" width="70%"/>
-
-In addition to setting the Clipping Range, you can use `RGBLIGHT_LED_MAP` together.
-
-```c
-// config.h
-#define RGBLED_NUM 8
-#define RGBLIGHT_LED_MAP { 7, 6, 5, 4, 3, 2, 1, 0 }
-
-// some soruce
-  rgblight_set_clipping_range(3, 4);
-```
-<img src="https://user-images.githubusercontent.com/2170248/55743747-119e4c00-5a6e-11e9-91e5-013203ffae8a.JPG" alt="clip mapped" width="70%"/>
+Additionally, [`rgblight_list.h`](https://github.com/qmk/qmk_firmware/blob/master/quantum/rgblight_list.h) defines several predefined shortcuts for various colors. Feel free to add to this list!
 
 ## Hardware Modification
 

docs/feature_space_cadet.md

@@ -1,60 +0,0 @@
-# Space Cadet: The Future, Built In
-
-Steve Losh described the [Space Cadet Shift](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/) quite well. Essentially, when you tap Left Shift on its own, you get an opening parenthesis; tap Right Shift on its own and you get the closing one. When held, the Shift keys function as normal. Yes, it's as cool as it sounds, and now even cooler supporting Control and Alt as well!
-
-## Usage
-
-Firstly, in your keymap, do one of the following:
-- Replace the Left Shift key with `KC_LSPO` (Left Shift, Parenthesis Open), and Right Shift with `KC_RSPC` (Right Shift, Parenthesis Close).
-- Replace the Left Control key with `KC_LCPO` (Left Control, Parenthesis Open), and Right Control with `KC_RCPC` (Right Control, Parenthesis Close).
-- Replace the Left Alt key with `KC_LAPO` (Left Alt, Parenthesis Open), and Right Alt with `KC_RAPC` (Right Alt, Parenthesis Close).
-- Replace any Shift key in your keymap with `KC_SFTENT` (Right Shift, Enter).
-
-## Keycodes
-
-|Keycode    |Description                                |
-|-----------|-------------------------------------------|
-|`KC_LSPO`  |Left Shift when held, `(` when tapped      |
-|`KC_RSPC`  |Right Shift when held, `)` when tapped     |
-|`KC_LCPO`  |Left Control when held, `(` when tapped    |
-|`KC_RCPC`  |Right Control when held, `)` when tapped   |
-|`KC_LAPO`  |Left Alt when held, `(` when tapped        |
-|`KC_RAPC`  |Right Alt when held, `)` when tapped       |
-|`KC_SFTENT`|Right Shift when held, Enter when tapped   |
-
-## Caveats
-
-Space Cadet's functionality can conflict with the default Command functionality when both Shift keys are held at the same time. See the [Command feature](feature_command.md) for info on how to change it, or make sure that Command is disabled in your `rules.mk` with:
-
-```make
-COMMAND_ENABLE = no
-```
-
-## Configuration
-
-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`. In addition, you can redefine the modifier to send on tap, or even send no modifier at all. The new configuration defines bundle all options up into a single define of 3 key codes in this order: the `Modifier` when held or when used with other keys, the `Tap Modifer` sent when tapped (no modifier if `KC_TRNS`), finally the `Keycode` sent when tapped. Now keep in mind, mods from other keys will still apply to the `Keycode` if say `KC_RSFT` is held while tapping `KC_LSPO` key with `KC_TRNS` as the `Tap Modifer`.
-
-|Define          |Default                        |Description                                                                      |
-|----------------|-------------------------------|---------------------------------------------------------------------------------|
-|`LSPO_KEYS`     |`KC_LSFT, LSPO_MOD, LSPO_KEY`  |Send `KC_LSFT` when held, the mod and  key defined by `LSPO_MOD` and `LSPO_KEY`. |
-|`RSPC_KEYS`     |`KC_RSFT, RSPC_MOD, RSPC_KEY`  |Send `KC_RSFT` when held, the mod and  key defined by `RSPC_MOD` and `RSPC_KEY`. |
-|`LCPO_KEYS`     |`KC_LCTL, KC_LSFT, KC_9`       |Send `KC_LCTL` when held, the mod `KC_LSFT` with the key `KC_9` when tapped.     |
-|`RCPC_KEYS`     |`KC_RCTL, KC_RSFT, KC_0`       |Send `KC_RCTL` when held, the mod `KC_RSFT` with the key `KC_0` when tapped.     |
-|`LAPO_KEYS`     |`KC_LALT, KC_LSFT, KC_9`       |Send `KC_LALT` when held, the mod `KC_LSFT` with the key `KC_9` when tapped.     |
-|`RAPC_KEYS`     |`KC_RALT, KC_RSFT, KC_0`       |Send `KC_RALT` when held, the mod `KC_RSFT` with the key `KC_0` when tapped.     |
-|`SFTENT_KEYS`   |`KC_RSFT, KC_TRNS, SFTENT_KEY` |Send `KC_RSFT` when held, no mod with the key `SFTENT_KEY` when tapped.          |
-|`SPACE_CADET_MODIFIER_CARRYOVER`   |*Not defined* |Store current modifiers before the hold mod is pressed and use them with the tap mod and keycode. Useful for when you frequently release a modifier before triggering Space Cadet.  |
-
-
-## Obsolete Configuration
-
-These defines are used in the above defines internally to support backwards compatibility, so you may continue to use them, however the above defines open up a larger range of flexibility than before. As an example, say you want to not send any modifier when you tap just `KC_LSPO`, with the old defines you had an all or nothing choice of using the `DISABLE_SPACE_CADET_MODIFIER` define. Now you can define that key as: `#define LSPO_KEYS KC_LSFT, KC_TRNS, KC_9`. This tells the system to set Left Shift if held or used with other keys, then on tap send no modifier (transparent) with the `KC_9`.
-
-|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_MOD`                    |`KC_LSFT`    |The modifier to apply to `LSPO_KEY`                               |
-|`RSPC_MOD`                    |`KC_RSFT`    |The modifier to apply to `RSPC_KEY`                               |
-|`SFTENT_KEY`                  |`KC_ENT`     |The keycode to send when the Shift key is tapped                  |
-|`DISABLE_SPACE_CADET_MODIFIER`|*Not defined*|If defined, prevent the Space Cadet from applying a modifier      |

docs/feature_space_cadet_shift.md

@@ -0,0 +1,33 @@
+# Space Cadet Shift: The Future, Built In
+
+Steve Losh described the [Space Cadet Shift](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/) quite well. Essentially, when you tap Left Shift on its own, you get an opening parenthesis; tap Right Shift on its own and you get the closing one. When held, the Shift keys function as normal. Yes, it's as cool as it sounds.
+
+## Usage
+
+Replace the Left Shift key in your keymap with `KC_LSPO` (Left Shift, Parenthesis Open), and Right Shift with `KC_RSPC` (Right Shift, Parenthesis Close).
+
+## Keycodes
+
+|Keycode  |Description                           |
+|---------|--------------------------------------|
+|`KC_LSPO`|Left Shift when held, `(` when tapped |
+|`KC_RSPC`|Right Shift when held, `)` when tapped|
+
+## Caveats
+
+Space Cadet's functionality can conflict with the default Command functionality when both Shift keys are held at the same time. Make sure that Command is disabled in your `rules.mk` with:
+
+```make
+COMMAND_ENABLE = no
+```
+
+## Configuration
+
+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.
+
+|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              |
+|`DISABLE_SPACE_CADET_ROLLOVER`|*Not defined*|If defined, use the opposite Shift key to cancel Space Cadet|

docs/feature_space_cadet_shift_enter.md

@@ -0,0 +1,31 @@
+# Space Cadet Shift Enter
+
+Based on the [Space Cadet Shift](feature_space_cadet_shift.md) feature. Tap the Shift key on its own, and it behaves like Enter. When held, the Shift functions as normal.
+
+## Usage
+
+Replace any Shift key in your keymap with `KC_SFTENT` (Shift, Enter), and you're done.
+
+## Keycodes
+
+|Keycode    |Description                             |
+|-----------|----------------------------------------|
+|`KC_SFTENT`|Right Shift when held, Enter when tapped|
+
+## Caveats
+
+As with Space Cadet Shift, this feature may conflict with Command, so it should be disabled in your `rules.mk` with:
+
+```make
+COMMAND_ENABLE = no
+```
+
+This feature also uses the same timers as Space Cadet Shift, so using them in tandem may produce strange results.
+
+## Configuration
+
+By default Space Cadet assumes a US ANSI layout, but if you'd like to use a different key for Enter, you can redefine it in your `config.h`:
+
+|Define      |Default |Description                                     |
+|------------|--------|------------------------------------------------|
+|`SFTENT_KEY`|`KC_ENT`|The keycode to send when the Shift key is tapped|

docs/feature_split_keyboard.md

@@ -1,197 +0,0 @@
-# Split Keyboard 
-
-Many keyboards in the QMK Firmware repo are "split" keyboards. They use two controllers—one plugging into USB, and the second connected by a serial or an I<sup>2</sup>C connection over a TRRS or similar cable. 
-
-Split keyboards can have a lot of benefits, but there is some additional work needed to get them enabled.  
-
-QMK Firmware has a generic implementation that is usable by any board, as well as numerous board specific implementations. 
-
-For this, we will mostly be talking about the generic implementation used by the Let's Split and other keyboards. 
-
-!> ARM is not yet supported for Split Keyboards.  Progress is being made, but we are not quite there, yet. 
-
-
-## Hardware Configuration
-
-This assumes that you're using two Pro Micro-compatible controllers, and are using TRRS jacks to connect to two halves. 
-
-### Required Hardware
-
-Apart from diodes and key switches for the keyboard matrix in each half, you will need 2x TRRS sockets and 1x TRRS cable.
-
-Alternatively, you can use any sort of cable and socket that has at least 3 wires. 
-
-If you want to use I<sup>2</sup>C to communicate between halves, you will need a cable with at least 4 wires and 2x 4.7kΩ pull-up resistors.
-
-#### Considerations 
-
-The most commonly used connection is a TRRS cable and jacks.  These provide 4 wires, making them very useful for split keyboards, and are easy to find. 
-
-However, since one of the wires carries VCC, this means that the boards are not hot pluggable. You should always disconnect the board from USB before unplugging and plugging in TRRS cables, or you can short the controller, or worse. 
-
-Another option is to use phone cables (as in, old school RJ-11/RJ-14 cables). Make sure that you use one that actually supports 4 wires/lanes.  
-
-However, USB cables, SATA cables, and even just 4 wires have been known to be used for communication between the controllers. 
-
-!> Using USB cables for communication between the controllers works just fine, but the connector could be mistaken for a normal USB connection and potentially short out the keyboard, depending on how it's wired.  For this reason, they are not recommended for connecting split keyboards.  
-
-### Serial Wiring
-
-The 3 wires of the TRS/TRRS cable need to connect GND, VCC, and D0 (aka PDO or pin 3) between the two Pro Micros. 
-
-?> Note that the pin used here is actually set by `SOFT_SERIAL_PIN` below.
-
-![serial wiring](https://i.imgur.com/C3D1GAQ.png)
-
-### I<sup>2</sup>C Wiring
-
-The 4 wires of the TRRS cable need to connect GND, VCC, and SCL and SDA (aka PD0/pin 3 and PD1/pin 2, respectively) between the two Pro Micros. 
-
-The pull-up resistors may be placed on either half. It is also possible to use 4 resistors and have the pull-ups in both halves, but this is unnecessary in simple use cases.
-
-![I2C wiring](https://i.imgur.com/Hbzhc6E.png)
-
-## Firmware Configuration
-
-To enable the split keyboard feature, add the following to your `rules.mk`: 
-
-```make
-SPLIT_KEYBOARD = yes
-```
-
-If you're using a custom transport (communication method), then you will also need to add: 
-
-```make
-SPLIT_TRANSPORT = custom
-```
-
-### Setting Handedness
-
-By default, the firmware does not know which side is which; it needs some help to determine that. There are several ways to do this, listed in order of precedence.
-
-#### Handedness by Pin
-
-You can configure the firmware to read a pin on the controller to determine handedness.  To do this, add the following to your `config.h` file:
-
-```c
-#define SPLIT_HAND_PIN B7
-```
-
-This will read the specified pin. If it's high, then the controller assumes it is the left hand, and if it's low, it's assumed to be the right side. 
-
-#### Handedness by EEPROM
-
-This method sets the keyboard's handedness by setting a flag in the persistent storage (`EEPROM`).  This is checked when the controller first starts up, and determines what half the keyboard is, and how to orient the keyboard layout. 
-
-
-To enable this method, add the following to your `config.h` file: 
-
-```c
-#define EE_HANDS
-```
-
-However, you'll have to flash the EEPROM files for the correct hand to each controller.  You can do this manually, or there are targets for avrdude and dfu to do this, while flashing the firmware: 
-
-* `:avrdude-split-left`
-* `:avrdude-split-right`
-* `:dfu-split-left`
-* `:dfu-split-right`
-
-This setting is not changed when re-initializing the EEPROM using the `EEP_RST` key, or using the `eeconfig_init()` function.  However, if you reset the EEPROM outside of the firmware's built in options (such as flashing a file that overwrites the `EEPROM`, like how the [QMK Toolbox]()'s "Reset EEPROM" button works), you'll need to re-flash the controller with the `EEPROM` files. 
-
-You can find the `EEPROM` files in the QMK firmware repo, [here](https://github.com/qmk/qmk_firmware/tree/master/quantum/split_common). 
-
-#### Handedness by `#define`
-
-You can set the handedness at compile time.  This is done by adding the following to your `config.h` file:
-
-```c
-#define MASTER_RIGHT
-```
-
-or 
-
-```c
-#define MASTER_LEFT
-```
-
-If neither are defined, the handedness defaults to `MASTER_LEFT`.
-
-
-### Communication Options
-
-Because not every split keyboard is identical, there are a number of additional options that can be configured in your `config.h` file.
-
-```c
-#define USE_I2C
-```
-
-This enables I<sup>2</sup>C support for split keyboards. This isn't strictly for communication, but can be used for OLED or other I<sup>2</sup>C-based devices. 
-
-```c
-#define SOFT_SERIAL_PIN D0
-```
-
-This sets the pin to be used for serial communication. If you're not using serial, you shouldn't need to define this.  
-
-However, if you are using serial and I<sup>2</sup>C on the board, you will need to set this, and to something other than D0 and D1 (as these are used for I<sup>2</sup>C communication).
-
-```c
-#define SELECT_SOFT_SERIAL_SPEED {#}`
-```
-
-If you're having issues with serial communication, you can change this value, as it controls the communication speed for serial.  The default is 1, and the possible values are:
-
-* **`0`**: about 189kbps (Experimental only)
-* **`1`**: about 137kbps (default)
-* **`2`**: about 75kbps
-* **`3`**: about 39kbps
-* **`4`**: about 26kbps
-* **`5`**: about 20kbps
-
-###  Hardware Configuration Options
-
-There are some settings that you may need to configure, based on how the hardware is set up. 
-
-```c
-#define MATRIX_ROW_PINS_RIGHT { <row pins> }
-#define MATRIX_COL_PINS_RIGHT { <col pins> }
-```
-
-This allows you to specify a different set of pins for the matrix on the right side.  This is useful if you have a board with differently-shaped halves that requires a different configuration (such as Keebio's Quefrency).
-
-```c
-#define DIRECT_PINS_RIGHT { { F1, F0, B0, C7 }, { F4, F5, F6, F7 } }
-```
-
-This allows you to specify a different set of direct pins for the right side.
-
-```c
-#define ENCODERS_PAD_A_RIGHT { encoder1a, encoder2a }
-#define ENCODERS_PAD_B_RIGHT { encoder1b, encoder2b }
-```
-
-This allows you to specify a different set of encoder pins for the right side.
-
-```c
-#define RGBLIGHT_SPLIT
-```
-
-This option enables synchronization of the RGB Light modes between the controllers of the split keyboard.  This is for keyboards that have RGB LEDs that are directly wired to the controller (that is, they are not using the "extra data" option on the TRRS cable).
-
-```c
-#define RGBLED_SPLIT { 6, 6 }
-```
-
-This sets how many LEDs are directly connected to each controller.  The first number is the left side, and the second number is the right side.  
-
-?> This setting implies that `RGBLIGHT_SPLIT` is enabled, and will forcibly enable it, if it's not.
-
-
-## Additional Resources
-
-Nicinabox has a [very nice and detailed guide](https://github.com/nicinabox/lets-split-guide) for the Let's Split keyboard, that covers most everything you need to know, including troubleshooting information. 
-
-However, the RGB Light section is out of date, as it was written long before the RGB Split code was added to QMK Firmware. Instead, wire each strip up directly to the controller.
-
-<!-- I may port this information later, but for now ... it's very nice, and covers everything -->

docs/feature_tap_dance.md

@@ -1,58 +1,40 @@
 # Tap Dance: A Single Key Can Do 3, 5, or 100 Different Things
 
-## Introduction
+<!-- 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.
 
-## Explanatory Comparison with `ACTION_FUNCTION_TAP`
-`ACTION_FUNCTION_TAP` can offer similar functionality to Tap Dance, but it's worth noting some important differences. To do this, let's explore a certain setup! We want one key to send `Space` on single-tap, but `Enter` on double-tap.
+To make it clear how this is different from `ACTION_FUNCTION_TAP`, let's explore a certain setup! We want one key to send `Space` on single tap, but `Enter` on double-tap.
 
-With `ACTION_FUNCTION_TAP`, it is quite a rain-dance to set this up, and has the problem that when the sequence is interrupted, the interrupting key will be sent first. Thus, `SPC a` will result in `a SPC` being sent, if `SPC` and `a` are both typed within `TAPPING_TERM`. With the Tap Dance feature, that'll come out correctly as `SPC a` (even if both `SPC` and `a` are typed within the `TAPPING_TERM`.
+With `ACTION_FUNCTION_TAP`, it is quite a rain-dance to set this up, and has the problem that when the sequence is interrupted, the interrupting key will be sent first. Thus, `SPC a` will result in `a SPC` being sent, if they are typed within `TAPPING_TERM`. With the tap dance feature, that'll come out as `SPC a`, correctly.
 
-To achieve this correct handling of interrupts, the implementation of Tap Dance hooks into two parts of the system: `process_record_quantum()`, and the matrix scan. These two parts are explained below, but for now the point to note is that we need the latter to be able to time out a tap sequence even when a key is not being pressed. That way, `SPC` alone will time out and register after `TAPPING_TERM` time.
+The implementation hooks into two parts of the system, to achieve this: into `process_record_quantum()`, and the matrix scan. We need the latter to be able to time out a tap sequence even when a key is not being pressed, so `SPC` alone will time out and register after `TAPPING_TERM` time.
 
-## How to Use Tap Dance
-But enough of the generalities; lets look at how to actually use Tap Dance!
+But lets start with how to use it, first!
 
-First, you will need `TAP_DANCE_ENABLE=yes` in your `rules.mk`, because the feature is disabled by default. This adds a little less than 1k to the firmware size. 
+First, you will need `TAP_DANCE_ENABLE=yes` in your `rules.mk`, because the feature is disabled by default. This adds a little less than 1k to the firmware size. Next, you will want to define some tap-dance keys, which is easiest to do with the `TD()` macro, that - similar to `F()`, takes a number, which will later be used as an index into the `tap_dance_actions` array.
 
-Optionally, you might want to set a custom `TAPPING_TERM` time by adding something like this in you `config.h`:
-
-```
-#define TAPPING_TERM 175
-```
-
-The `TAPPING_TERM` time is the maximum time allowed between taps of your Tap Dance key, and is measured in milliseconds. For example, if you used the above `#define` statement and set up a Tap Dance key that sends `Space` on single-tap and `Enter` on double-tap, then this key will send `ENT` only if you tap this key twice in less than 175ms. If you tap the key, wait more than 175ms, and tap the key again you'll end up sending `SPC SPC` instead. 
-
-Next, you will want to define some tap-dance keys, which is easiest to do with the `TD()` macro, that - similar to `F()` - takes a number, which will later be used as an index into the `tap_dance_actions` array. 
-
-After this, you'll want to use the `tap_dance_actions` array to specify what actions shall be taken when a tap-dance key is in action. Currently, there are five possible options:
+This array specifies what actions shall be taken when a tap-dance key is in action. Currently, there are five possible options:
 
 * `ACTION_TAP_DANCE_DOUBLE(kc1, kc2)`: Sends the `kc1` keycode when tapped once, `kc2` otherwise. When the key is held, the appropriate keycode is registered: `kc1` when pressed and held, `kc2` when tapped once, then pressed and held.
-* `ACTION_TAP_DANCE_LAYER_MOVE(kc, layer)`: Sends the `kc` keycode when tapped once, or moves to `layer`. (this functions like the `TO` layer keycode).
-    * This is the same as `ACTION_TAP_DANCE_DUAL_ROLE`, but renamed to something that is clearer about its functionality.  Both names will work.
-* `ACTION_TAP_DANCE_LAYER_TOGGLE(kc, layer)`: Sends the `kc` keycode when tapped once, or toggles the state of `layer`. (this functions like the `TG` layer keycode).
+* `ACTION_TAP_DANCE_DUAL_ROLE(kc, layer)`: Sends the `kc` keycode when tapped once, or moves to `layer`. (this functions like the `TO` layer keycode).
 * `ACTION_TAP_DANCE_FN(fn)`: Calls the specified function - defined in the user keymap - with the final tap count of the tap dance action.
 * `ACTION_TAP_DANCE_FN_ADVANCED(on_each_tap_fn, on_dance_finished_fn, on_dance_reset_fn)`: Calls the first specified function - defined in the user keymap - on every tap, the second function when the dance action finishes (like the previous option), and the last function when the tap dance action resets.
 * `ACTION_TAP_DANCE_FN_ADVANCED_TIME(on_each_tap_fn, on_dance_finished_fn, on_dance_reset_fn, tap_specific_tapping_term)`: This functions identically to the `ACTION_TAP_DANCE_FN_ADVANCED` function, but uses a custom tapping term for it, instead of the predefined `TAPPING_TERM`.
 
-The first option is enough for a lot of cases, that just want dual roles. For example, `ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT)` will result in `Space` being sent on single-tap, `Enter` otherwise. 
+The first option is enough for a lot of cases, that just want dual roles. For example, `ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT)` will result in `Space` being sent on single-tap, `Enter` otherwise.
 
 !> Keep in mind that only [basic keycodes](keycodes_basic.md) are supported here. Custom keycodes are not supported.
 
-Similar to the first option, the second option is good for simple layer-switching cases.
+And that's the bulk of it!
 
-For more complicated cases, use the third or fourth options (examples of each are listed below). 
+And now, on to the explanation of how it works!
 
-Finally, the fifth option is particularly useful if your non-Tap-Dance keys start behaving weirdly after adding the code for your Tap Dance keys. The likely problem is that you changed the `TAPPING_TERM` time to make your Tap Dance keys easier for you to use, and that this has changed the way your other keys handle interrupts.
+The main entry point is `process_tap_dance()`, called from `process_record_quantum()`, which is run for every keypress, and our handler gets to run early. This function checks whether the key pressed is a tap-dance key. If it is not, and a tap-dance was in action, we handle that first, and enqueue the newly pressed key. If it is a tap-dance key, then we check if it is the same as the already active one (if there's one active, that is). If it is not, we fire off the old one first, then register the new one. If it was the same, we increment the counter and the timer.
 
-## Implementation Details
-Well, that's the bulk of it! You should now be able to work through the examples below, and to develop your own Tap Dance functionality. But if you want a deeper understanding of what's going on behind the scenes, then read on for the explanation of how it all works!
-
-The main entry point is `process_tap_dance()`, called from `process_record_quantum()`, which is run for every keypress, and our handler gets to run early. This function checks whether the key pressed is a tap-dance key. If it is not, and a tap-dance was in action, we handle that first, and enqueue the newly pressed key. If it is a tap-dance key, then we check if it is the same as the already active one (if there's one active, that is). If it is not, we fire off the old one first, then register the new one. If it was the same, we increment the counter and reset the timer.
-
-This means that you have `TAPPING_TERM` time to tap the key again; you do not have to input all the taps within a single `TAPPING_TERM` timeframe. This allows for longer tap counts, with minimal impact on responsiveness.
+This means that you have `TAPPING_TERM` time to tap the key again, you do not have to input all the taps within that timeframe. This allows for longer tap counts, with minimal impact on responsiveness.
 
 Our next stop is `matrix_scan_tap_dance()`. This handles the timeout of tap-dance keys.
 
@@ -203,11 +185,29 @@ Below is a specific example:
 
 ## Setup
 
-You will need a few things that can be used for 'Quad Function Tap-Dance'. 
+You will need a few things that can be used for 'Quad Function Tap-Dance'. The suggested setup is to create a user directory for yourself. This directory will contain rules.mk `<your_name>.c` and `<your_name>.h`. This directory should be called `<your_name>`, and located in the top level `users` directory. There should already be a few examples to look at there.
 
-You'll need to add these to the top of your `keymap.c` file, before your keymap. 
+### In `/qmk_firmware/users/<your_name>/rules.mk`
+
+Put the following:
+```c
+TAP_DANCE_ENABLE = yes
+SRC += your_name.c
+```
+
+Pretty simple. It is a nice way to keep some rules common on all your keymaps.
+
+
+### In `/qmk_firmware/users/<your_name>/<your_name>.h`
+
+You will need a few things in this file:
 
 ```c
+#pragma once
+
+#include "quantum.h"
+#include "process_keycode/process_tap_dance.h"
+
 typedef struct {
   bool is_press_action;
   int state;
@@ -234,12 +234,18 @@ int cur_dance (qk_tap_dance_state_t *state);
 //for the x tap dance. Put it here so it can be used in any keymap
 void x_finished (qk_tap_dance_state_t *state, void *user_data);
 void x_reset (qk_tap_dance_state_t *state, void *user_data);
-
 ```
 
-Now, at the bottom of your `keymap.c` file, you'll need to add the following: 
+### In `/qmk_firmware/users/<your_name>/<your_name>.c`
+
+And then in your user's `.c` file you implement the functions above:
 
 ```c
+#include "<your_name>.h"
+#include "quantum.h"
+#include "action.h"
+#include "process_keycode/process_tap_dance.h"
+
 /* Return an integer that corresponds to what kind of tap dance should be executed.
  *
  * How to figure out tap dance state: interrupted and pressed.
@@ -329,197 +335,4 @@ qk_tap_dance_action_t tap_dance_actions[] = {
 };
 ```
 
-And then simply use `TD(X_CTL)` anywhere in your keymap.
-
-If you want to implement this in your userspace, then you may want to check out how [DanielGGordon](https://github.com/qmk/qmk_firmware/tree/master/users/gordon) has implemented this in their userspace.
-
-### Example 5: Using tap dance for advanced mod-tap and layer-tap keys
-
-Tap dance can be used to emulate `MT()` and `LT()` behavior when the tapped code is not a basic keycode. This is useful to send tapped keycodes that normally require `Shift`, such as parentheses or curly braces—or other modified keycodes, such as `Control + X`.
-
-Below your layers and custom keycodes, add the following:
-
-```c
-// tapdance keycodes
-enum td_keycodes {
-  ALT_LP // Our example key: `LALT` when held, `(` when tapped. Add additional keycodes for each tapdance.
-};
-
-// define a type containing as many tapdance states as you need
-typedef enum {
-  SINGLE_TAP,
-  SINGLE_HOLD,
-  DOUBLE_SINGLE_TAP
-} td_state_t;
-
-// create a global instance of the tapdance state type
-static td_state_t td_state;
-
-// declare your tapdance functions:
-
-// function to determine the current tapdance state
-int cur_dance (qk_tap_dance_state_t *state);
-
-// `finished` and `reset` functions for each tapdance keycode
-void altlp_finished (qk_tap_dance_state_t *state, void *user_data);
-void altlp_reset (qk_tap_dance_state_t *state, void *user_data);
-```
-
-Below your `LAYOUT`, define each of the tapdance functions:
-
-```c
-// determine the tapdance state to return
-int cur_dance (qk_tap_dance_state_t *state) {
-  if (state->count == 1) {
-    if (state->interrupted || !state->pressed) { return SINGLE_TAP; }
-    else { return SINGLE_HOLD; }
-  }
-  if (state->count == 2) { return DOUBLE_SINGLE_TAP; }
-  else { return 3; } // any number higher than the maximum state value you return above
-}
- 
-// handle the possible states for each tapdance keycode you define:
-
-void altlp_finished (qk_tap_dance_state_t *state, void *user_data) {
-  td_state = cur_dance(state);
-  switch (td_state) {
-    case SINGLE_TAP:
-      register_code16(KC_LPRN);
-      break;
-    case SINGLE_HOLD:
-      register_mods(MOD_BIT(KC_LALT)); // for a layer-tap key, use `layer_on(_MY_LAYER)` here
-      break;
-    case DOUBLE_SINGLE_TAP: // allow nesting of 2 parens `((` within tapping term
-      tap_code16(KC_LPRN);
-      register_code16(KC_LPRN);
-  }
-}
-
-void altlp_reset (qk_tap_dance_state_t *state, void *user_data) {
-  switch (td_state) {
-    case SINGLE_TAP:
-      unregister_code16(KC_LPRN);
-      break;
-    case SINGLE_HOLD:
-      unregister_mods(MOD_BIT(KC_LALT)); // for a layer-tap key, use `layer_off(_MY_LAYER)` here
-      break;
-    case DOUBLE_SINGLE_TAP:
-      unregister_code16(KC_LPRN);
-  }
-}
-
-// define `ACTION_TAP_DANCE_FN_ADVANCED()` for each tapdance keycode, passing in `finished` and `reset` functions
-qk_tap_dance_action_t tap_dance_actions[] = {
-  [ALT_LP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, altlp_finished, altlp_reset)
-};
-```
-
-Wrap each tapdance keycode in `TD()` when including it in your keymap, e.g. `TD(ALT_LP)`.
-
-### Example 6: Using tap dance for momentary-layer-switch and layer-toggle keys
-
-Tap Dance can be used to mimic MO(layer) and TG(layer) functionality. For this example, we will set up a key to function as `KC_QUOT` on single-tap, as `MO(_MY_LAYER)` on single-hold, and `TG(_MY_LAYER)` on double-tap.
-
-The first step is to include the following code towards the beginning of your `keymap.c`:
-
-```
-typedef struct {
-  bool is_press_action;
-  int state;
-} tap;
-
-//Define a type for as many tap dance states as you need
-enum {
-  SINGLE_TAP = 1,
-  SINGLE_HOLD = 2,
-  DOUBLE_TAP = 3
-};
-
-enum {
-  QUOT_LAYR = 0     //Our custom tap dance key; add any other tap dance keys to this enum 
-};
-
-//Declare the functions to be used with your tap dance key(s)
-
-//Function associated with all tap dances
-int cur_dance (qk_tap_dance_state_t *state);
-
-//Functions associated with individual tap dances
-void ql_finished (qk_tap_dance_state_t *state, void *user_data);
-void ql_reset (qk_tap_dance_state_t *state, void *user_data);
-
-//Declare variable to track which layer is active
-int active_layer;
-```
-
-The above code is similar to that used in previous examples. The one point to note is that you need to declare a variable to keep track of what layer is currently the active layer. We'll see why shortly.
-
-Towards the bottom of your `keymap.c`, include the following code:
-
-```
-//Update active_layer
-uint32_t layer_state_set_user(uint32_t state) {
-  switch (biton32(state)) {
-    case 1:
-      active_layer = 1;
-      break;
-    case 2:
-      active_layer = 2;
-      break;
-    case 3:
-      active_layer = 3;
-      break;
-    default:
-      active_layer = 0;
-      break;
-  }
-  return state;
-}
-
-//Determine the current tap dance state
-int cur_dance (qk_tap_dance_state_t *state) {
-  if (state->count == 1) {
-    if (!state->pressed) {return SINGLE_TAP;}
-    else return SINGLE_HOLD;
-  } else if (state->count == 2) {return DOUBLE_TAP;}
-  else return 8;
-}
-
-//Initialize tap structure associated with example tap dance key
-static tap ql_tap_state = {
-  .is_press_action = true,
-  .state = 0
-};
-
-//Functions that control what our tap dance key does
-void ql_finished (qk_tap_dance_state_t *state, void *user_data) {
-  ql_tap_state.state = cur_dance(state);
-  switch (ql_tap_state.state) {
-    case SINGLE_TAP: tap_code(KC_QUOT); break;
-    case SINGLE_HOLD: layer_on(_MY_LAYER); break;
-    case DOUBLE_TAP: 
-      if (active_layer==_MY_LAYER) {layer_off(_MY_LAYER);}
-      else layer_on(_MY_LAYER);
-  }
-}
-
-void ql_reset (qk_tap_dance_state_t *state, void *user_data) {
-  if (ql_tap_state.state==SINGLE_HOLD) {layer_off(_MY_LAYER);}
-  ql_tap_state.state = 0;
-}
-
-//Associate our tap dance key with its functionality
-qk_tap_dance_action_t tap_dance_actions[] = {
-  [QUOT_LAYR] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, ql_finished, ql_reset, 275)
-};
-```
-
-The is where the real logic of our tap dance key gets worked out. Since `layer_state_set_user()` is called on any layer switch, we use it to update `active_layer`. Our example is assuming that your `keymap.c` includes 4 layers, so adjust the switch statement here to fit your actual number of layers.
-
-The use of `cur_dance()` and `ql_tap_state` mirrors the above examples.
-
-The `case:SINGLE_TAP` in `ql_finished` is similar to the above examples. The `case:SINGLE_HOLD` works in conjunction with `ql_reset()` to switch to `_MY_LAYER` while the tap dance key is held, and to switch away from `_MY_LAYER` when the key is released. This mirrors the use of `MO(_MY_LAYER)`. The `case:DOUBLE_TAP` works by checking whether `_MY_LAYER` is the active layer, and toggling it on or off accordingly. This mirrors the use of `TG(_MY_LAYER)`.
-
-`tap_dance_actions[]` works similar to the above examples. Note that I used `ACTION_TAP_DANCE_FN_ADVANCED_TIME()` instead of `ACTION_TAP_DANCE_FN_ADVANCED()`. This is because I like my `TAPPING_TERM` to be short (~175ms) for my non-tap-dance keys but find that this is too quick for me to reliably complete tap dance actions - thus the increased time of 275ms here.
-
-Finally, to get this tap dance key working, be sure to include `TD(QUOT_LAYR)` in your `keymaps[]`.
+And then simply use `TD(X_CTL)` anywhere in your keymap after including `<your_name>.h`.

docs/feature_unicode.md

@@ -1,197 +1,94 @@
 # Unicode Support
 
-Unicode characters can be input straight from your keyboard! There are some limitations, however.
+There are three Unicode keymap definition method available in QMK:
 
-QMK has three different methods for enabling Unicode input and defining keycodes:
+## UNICODE_ENABLE
 
-## Basic Unicode
+Supports Unicode input up to 0xFFFF. The keycode function is `UC(n)` in keymap file, where *n* is a 4 digit hexadecimal.
 
-This method supports Unicode code points up to `0x7FFF`. This covers characters for most modern languages, as well as symbols, but it doesn't cover emoji.
+## UNICODEMAP_ENABLE
 
-Add the following to your `rules.mk`:
+Supports Unicode up to 0xFFFFFFFF. You need to maintain a separate mapping table `const uint32_t PROGMEM unicode_map[] = {...}` in your keymap file. The keycode function is `X(n)` where *n* is the array index of the mapping table.
 
-```make
-UNICODE_ENABLE = yes
-```
-
-Then add `UC(c)` keycodes to your keymap, where _c_ is the code point (preferably in hexadecimal, up to 4 digits long). For example: `UC(0x45B)`, `UC(0x30C4)`.
-
-## Unicode Map
-
-This method supports all possible code points (up to `0x10FFFF`); however, you need to maintain a separate mapping table in your keymap file, which may contain at most 16384 entries.
-
-Add the following to your `rules.mk`:
-
-```make
-UNICODEMAP_ENABLE = yes
-```
-
-Then add `X(i)` keycodes to your keymap, where _i_ is an array index into the mapping table:
+And you may want to have an enum to make reference easier.  So you'd want to add something like this to your keymap:
 
 ```c
-enum unicode_names {
-    BANG,
-    IRONY,
-    SNEK
+enum unicode_name {
+  BANG, // ‽
+  IRONY, // ⸮
+  SNEK // snke 🐍
 };
 
 const uint32_t PROGMEM unicode_map[] = {
-    [BANG]  = 0x203D,  // ‽
-    [IRONY] = 0x2E2E,  // ⸮
-    [SNEK]  = 0x1F40D, // 🐍
-};
+  [BANG]      = 0x0203D, // ‽
+  [IRONY]     = 0x02E2E, // ⸮
+  [SNEK]      = 0x1F40D // snke 🐍
+}:
 ```
 
-Then you can use `X(BANG)`, `X(SNEK)` etc. in your keymap.
+Make sure that the order for both matches.
 
-### Lower and Upper Case
+## UCIS_ENABLE
 
-Characters often come in lower and upper case pairs, such as å and Å. To make inputting these characters easier, you can use `XP(i, j)` in your keymap, where _i_ and _j_ are the mapping table indices of the lower and upper case character, respectively. If you're holding down Shift or have Caps Lock turned on when you press the key, the second (upper case) character will be inserted; otherwise, the first (lower case) version will appear.
+Supports Unicode up to 0xFFFFFFFF. As with `UNICODE_MAP`, you may want to main a mapping table in your keymap file.  However, there is no keycodes for this feature, you will have to add a keycode or function to call `qk_ucis_start()`. Once you've run that, you can just type the text for your unicode, and then hit space or enter to complete it, or ESC to cancel it. And if it matches an entry in your table, it will automatically "backspace" the trigger word (from your table) and then will input the unicode sequence.
 
-This is most useful when creating a keymap for an international layout with special characters. Instead of having to put the lower and upper case versions of a character on separate keys, you can have them both on the same key by using `XP()`. This helps blend Unicode keys in with regular alphas.
-
-Due to keycode size constraints, _i_ and _j_ can each only refer to one of the first 128 characters in your `unicode_map`. In other words, 0 ≤ _i_ ≤ 127 and 0 ≤ _j_ ≤ 127. This is enough for most use cases, but if you'd like to customize the index calculation, you can override the [`unicodemap_index()`](https://github.com/qmk/qmk_firmware/blob/71f640d47ee12c862c798e1f56392853c7b1c1a8/quantum/process_keycode/process_unicodemap.c#L40) function. This also allows you to, say, check Ctrl instead of Shift/Caps.
-
-## UCIS
-
-This method also supports all possible code points. As with the Unicode Map method, you need to maintain a mapping table in your keymap file. However, there are no built-in keycodes for this feature — you have to create a custom keycode or function that invokes this functionality.
-
-Add the following to your `rules.mk`:
-
-```make
-UCIS_ENABLE = yes
-```
-
-Then define a table like this in your keymap file:
+For instance, you would need to have a table like this in your keymap:
 
 ```c
-const qk_ucis_symbol_t ucis_symbol_table[] = UCIS_TABLE(
-    UCIS_SYM("poop", 0x1F4A9), // 💩
-    UCIS_SYM("rofl", 0x1F923), // 🤣
-    UCIS_SYM("kiss", 0x1F619)  // 😙
+const qk_ucis_symbol_t ucis_symbol_table[] = UCIS_TABLE
+(
+ UCIS_SYM("poop", 0x1f4a9),
+ UCIS_SYM("rofl", 0x1f923),
+ UCIS_SYM("kiss", 0x1f619)
 );
 ```
 
-To use it, call `qk_ucis_start()`. Then, type the mnemonic for the character (such as "rofl"), and hit Space or Enter. QMK should erase the "rofl" text and insert the laughing emoji.
+You run the function, and then type "rofl" and hit enter, it should backspace remove "rofl" and input the `0x1f923` unicode.
 
 ### Customization
 
-There are several functions that you can define in your keymap to customize the functionality of this feature.
+There are several functions that you can add to your keymap to customize the functionality of this feature.
 
-* `void qk_ucis_start_user(void)` – This runs when you call the "start" function, and can be used to provide feedback. By default, it types out a keyboard emoji.
-* `void qk_ucis_success(uint8_t symbol_index)` – This runs when the input has matched something and has completed. By default, it doesn't do anything.
-* `void qk_ucis_symbol_fallback (void)` – This runs when the input doesn't match anything. By default, it falls back to trying that input as a Unicode code.
+* `void qk_ucis_start_user(void)` - This runs when you run the "start" function, and can be used to provide feedback. By default, it types out a keyboard emoji.
+* `void qk_ucis_success(uint8_t symbol_index)` - This runs when the unicode input has matched something, and has completed. Default doesn't do anything.
+* `void qk_ucis_symbol_fallback (void)` - This runs if the input text doesn't match anything.  The default function falls back to trying that input as a unicode code.
 
-You can find the default implementations of these functions in [`process_ucis.c`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_ucis.c).
-
-## Input Modes
-
-Unicode input in QMK works by inputting a sequence of characters to the OS, sort of like a macro. Unfortunately, the way this is done differs for each platform. Specifically, each platform requires a different combination of keys to trigger Unicode input. Therefore, a corresponding input mode has to be set in QMK.
-
-The following input modes are available:
-
-* **`UC_OSX`**: macOS built-in Unicode hex input. Supports code points up to `0xFFFF` (`0x10FFFF` with Unicode Map).
-
-  To enable, go to _System Preferences > Keyboard > Input Sources_, add _Unicode Hex Input_ to the list (it's under _Other_), then activate it from the input dropdown in the Menu Bar.
-  By default, this mode uses the left Option key (`KC_LALT`) for Unicode input, but this can be changed by defining [`UNICODE_KEY_OSX`](#input-key-configuration) with another keycode.
-
-  !> Using the _Unicode Hex Input_ input source may disable some Option based shortcuts, such as Option + Left Arrow and Option + Right Arrow.
-
-* **`UC_LNX`**: Linux built-in IBus Unicode input. Supports code points up to `0x10FFFF` (all possible code points).
-
-  Enabled by default and works almost anywhere on IBus-enabled distros. Without IBus, this mode works under GTK apps, but rarely anywhere else.
-  By default, this mode uses Ctrl+Shift+U (`LCTL(LSFT(KC_U))`) to start Unicode input, but this can be changed by defining [`UNICODE_KEY_LNX`](#input-key-configuration) with another keycode. This might be required for IBus versions ≥1.5.15, where Ctrl+Shift+U behavior is consolidated into Ctrl+Shift+E.
-
-* **`UC_WIN`**: _(not recommended)_ Windows built-in hex numpad Unicode input. Supports code points up to `0xFFFF`.
-
-  To enable, create a registry key under `HKEY_CURRENT_USER\Control Panel\Input Method\EnableHexNumpad` of type `REG_SZ` called `EnableHexNumpad` and set its value to `1`. This can be done from the Command Prompt by running `reg add "HKCU\Control Panel\Input Method" -v EnableHexNumpad -t REG_SZ -d 1` with administrator privileges. Reboot afterwards.
-  This mode is not recommended because of reliability and compatibility issues; use the `UC_WINC` mode instead.
-
-* **`UC_BSD`**: _(non implemented)_ Unicode input under BSD. Not implemented at this time. If you're a BSD user and want to help add support for it, please [open an issue on GitHub](https://github.com/qmk/qmk_firmware/issues).
-
-* **`UC_WINC`**: Windows Unicode input using [WinCompose](https://github.com/samhocevar/wincompose). As of v0.9.0, supports code points up to `0x10FFFF` (all possible code points).
-
-  To enable, install the [latest release](https://github.com/samhocevar/wincompose/releases/latest). Once installed, WinCompose will automatically run on startup. Works reliably under all version of Windows supported by the app.
-  By default, this mode uses right Alt (`KC_RALT`) as the Compose key, but this can be changed in the WinCompose settings and by defining [`UNICODE_KEY_WINC`](#input-key-configuration) with another keycode.
-
-### Switching Input Modes
-
-There are two ways to set the input mode for Unicode: by keycode or by function. Keep in mind that both methods write to persistent storage (EEPROM), and are loaded each time the keyboard starts. So once you've set it the first time, you don't need to set it again unless you want to change it, or you've reset the EEPROM settings.
-
-You can switch the input mode at any time by using one of the following keycodes. The easiest way is to add the ones you use to your keymap.
-
-|Keycode               |Alias    |Input Mode  |Description                                                   |
-|----------------------|---------|------------|--------------------------------------------------------------|
-|`UNICODE_MODE_FORWARD`|`UC_MOD` |Next in list|[Cycle](#input-mode-cycling) through selected modes           |
-|`UNICODE_MODE_REVERSE`|`UC_RMOD`|Prev in list|[Cycle](#input-mode-cycling) through selected modes in reverse|
-|`UNICODE_MODE_OSX`    |`UC_M_OS`|`UC_OSX`    |Switch to macOS input                                         |
-|`UNICODE_MODE_LNX`    |`UC_M_LN`|`UC_LNX`    |Switch to Linux input                                         |
-|`UNICODE_MODE_WIN`    |`UC_M_WI`|`UC_WIN`    |Switch to Windows input                                       |
-|`UNICODE_MODE_BSD`    |`UC_M_BS`|`UC_BSD`    |Switch to BSD input (not implemented)                         |
-|`UNICODE_MODE_WINC`   |`UC_M_WC`|`UC_WINC`   |Switch to Windows input using WinCompose                      |
-
-You can also switch the input mode by calling `set_unicode_input_mode(x)` in your code, where _x_ is one of the above input mode constants (e.g. `UC_LNX`). Since the function only needs to be called once, it's recommended that you do it in `eeconfig_init_user()` (or a similar function). For example:
+The default code for these are:
 
 ```c
-void eeconfig_init_user(void) {
-    set_unicode_input_mode(UC_LNX);
+void qk_ucis_start_user(void) { // outputs keyboard emoji
+  unicode_input_start();
+  register_hex(0x2328);
+  unicode_input_finish();
+}
+
+void qk_ucis_success(uint8_t symbol_index) {
+}
+
+void qk_ucis_symbol_fallback (void) { // falls back to manual unicode entry
+  for (uint8_t i = 0; i < qk_ucis_state.count - 1; i++) {
+    uint8_t code = qk_ucis_state.codes[i];
+    register_code(code);
+    unregister_code(code);
+    wait_ms(UNICODE_TYPE_DELAY);
+  }
 }
 ```
 
-### Audio Feedback
+## Unicode Input methods
 
-If you have the [Audio feature](feature_audio.md) enabled on the board, you can set melodies to be played when you press the above keys. That way you can have some audio feedback when switching input modes.
+Unicode input in QMK works by inputting a sequence of characters to the OS,
+sort of like macro. Unfortunately, each OS has different ideas on how Unicode is input.
 
-For instance, you can add these definitions to your `config.h` file:
+This is the current list of Unicode input method in QMK:
 
-```c
-#define UNICODE_SONG_OSX  COIN_SOUND
-#define UNICODE_SONG_LNX  UNICODE_LINUX
-#define UNICODE_SONG_BSD  MARIO_GAMEOVER
-#define UNICODE_SONG_WIN  UNICODE_WINDOWS
-#define UNICODE_SONG_WINC UNICODE_WINDOWS
-```
+* __UC_OSX__: MacOS Unicode Hex Input support. Works only up to 0xFFFF. Disabled by default. To enable: go to System Preferences -> Keyboard -> Input Sources, and enable Unicode Hex.
+* __UC_OSX_RALT__: Same as UC_OSX, but sends the Right Alt key for unicode input
+* __UC_LNX__: Unicode input method under Linux. Works up to 0xFFFFF. Should work almost anywhere on ibus enabled distros. Without ibus, this works under GTK apps, but rarely anywhere else.
+* __UC_WIN__: (not recommended) Windows built-in Unicode input. To enable: create registry key under `HKEY_CURRENT_USER\Control Panel\Input Method\EnableHexNumpad` of type `REG_SZ` called `EnableHexNumpad`, set its value to 1, and reboot. This method is not recommended because of reliability and compatibility issue, use WinCompose method below instead.
+* __UC_WINC__: Windows Unicode input using WinCompose. Requires [WinCompose](https://github.com/samhocevar/wincompose). Works reliably under many (all?) variations of Windows.
 
-### Additional Customization
-
-Because Unicode is a large and versatile feature, there are a number of options you can customize to make it work better on your system.
-
-#### Start and Finish Input Functions
-
-The functions for starting and finishing Unicode input on your platform can be overridden locally. Possible uses include customizing input mode behavior if you don't use the default keys, or adding extra visual/audio feedback to Unicode input.
-
-* `void unicode_input_start(void)` – This sends the initial sequence that tells your platform to enter Unicode input mode. For example, it presses Ctrl+Shift+U on Linux and holds the Option key on macOS.
-* `void unicode_input_finish(void)` – This is called to exit Unicode input mode, for example by pressing Space or releasing the Option key.
-
-You can find the default implementations of these functions in [`process_unicode_common.c`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_unicode_common.c).
-
-#### Input Key Configuration
-
-You can customize the keys used to trigger Unicode input for macOS, Linux and WinCompose by adding corresponding defines to your `config.h`. The default values match the platforms' default settings, so you shouldn't need to change this unless Unicode input isn't working, or you want to use a different key (e.g. in order to free up left or right Alt).
-
-|Define            |Type      |Default           |Example                                    |
-|------------------|----------|------------------|-------------------------------------------|
-|`UNICODE_KEY_OSX` |`uint8_t` |`KC_LALT`         |`#define UNICODE_KEY_OSX  KC_RALT`         |
-|`UNICODE_KEY_LNX` |`uint16_t`|`LCTL(LSFT(KC_U))`|`#define UNICODE_KEY_LNX  LCTL(LSFT(KC_E))`|
-|`UNICODE_KEY_WINC`|`uint8_t` |`KC_RALT`         |`#define UNICODE_KEY_WINC KC_RGUI`         |
-
-#### Input Mode Cycling
-
-You can choose which input modes are available for cycling through. By default, this is disabled. If you want to enable it, limiting it to just the modes you use makes sense. Note that the values in the list are comma-delimited.
-
-```c
-#define UNICODE_SELECTED_MODES UC_OSX, UC_LNX, UC_WIN, UC_WINC
-```
-
-You can cycle through the selected modes by using the `UC_MOD`/`UC_RMOD` keycodes, or by calling `cycle_unicode_input_mode(offset)` in your code (`offset` is how many modes to move forward by, so +1 corresponds to `UC_MOD`).
-
-By default, when the keyboard boots, it will initialize the input mode to the last one you used. You can disable this and make it start with the first mode in the list every time by adding the following to your `config.h`:
-
-```c
-#define UNICODE_CYCLE_PERSIST false
-```
-
-!> Using `UNICODE_SELECTED_MODES` means you don't have to initially set the input mode in `matrix_init_user()` (or a similar function); the Unicode system will do that for you on startup. This has the added benefit of avoiding unnecessary writes to EEPROM.
+At some point, you need to call `set_unicode_input_mode(x)` to set the correct unicode method.  This sets the method that is used to send the unicode, and stores it in EEPROM, so you only need to call this once.
 
 ## `send_unicode_hex_string`
 
@@ -226,7 +123,7 @@ AutoHotkey inserts the Text right of `Send, ` when this combination is pressed.
 
 ### US International
 
-If you enable the US International layout on the system, it will use punctuation to accent the characters.
+If you enable the US International layout on the system, it will use punctuation to accent the characters. 
 
 For instance, typing "`a" will result in à.
 

docs/feature_userspace.md

@@ -110,16 +110,16 @@ QMK has a bunch of [functions](custom_quantum_functions.md) that have [`_quantum
 However, you can actually add support for keymap version, so that you can use it in both your userspace and your keymap! 
 
 
-For instance, let's look at the `layer_state_set_user()` function.  You can enable the [Tri Layer State](ref_functions.md#olkb-tri-layers) functionality on all of your boards, while also retaining the Tri Layer functionality in your `keymap.c` files. 
+For instance, lets looks at the `layer_state_set_user` function.  Lets enable the [Tri Layer State](ref_functions.md#olkb-tri-layers) functionalitly to all of our boards, and then still have your `keymap.c` still able to use this functionality. 
 
 In your `<name.c>` file, you'd want to add this: 
 ```c
 __attribute__ ((weak))
-layer_state_t layer_state_set_keymap (layer_state_t state) {
+uint32_t layer_state_set_keymap (uint32_t state) {
   return state;
 }
 
-layer_state_t layer_state_set_user (layer_state_t state) {
+uint32_t layer_state_set_user (uint32_t state) {
   state = update_tri_layer_state(state, 2, 3, 5);
   return layer_state_set_keymap (state);
 }
@@ -201,51 +201,27 @@ bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
-    case KC_MAKE:  // Compiles the firmware, and adds the flash command based on keyboard bootloader
-            if (!record->event.pressed) {
-            uint8_t temp_mod = get_mods();
-            uint8_t temp_osm = get_oneshot_mods();
-            clear_mods(); clear_oneshot_mods();
-            SEND_STRING("make " QMK_KEYBOARD ":" QMK_KEYMAP);
-    #ifndef FLASH_BOOTLOADER
-            if ( (temp_mod | temp_osm) & MOD_MASK_SHIFT ) 
-    #endif
-            { // 
-                #if defined(__arm__)  // only run for ARM boards
-                    SEND_STRING(":dfu-util");
-                #elif defined(BOOTLOADER_DFU) // only run for DFU boards
-                    SEND_STRING(":dfu");
-                #elif defined(BOOTLOADER_HALFKAY) // only run for teensy boards
-                    SEND_STRING(":teensy");
-                #elif defined(BOOTLOADER_CATERINA) // only run for Pro Micros
-                    SEND_STRING(":avrdude");
-                #endif // bootloader options
-            }
-            if ( (temp_mod | temp_osm) & MOD_MASK_CTRL) { 
-                SEND_STRING(" -j8 --output-sync"); 
-            }
-            SEND_STRING(SS_TAP(X_ENTER));
-            set_mods(temp_mod);
-        }
-        break;
-
+  case KC_MAKE:
+    if (!record->event.pressed) {
+      SEND_STRING("make " QMK_KEYBOARD ":" QMK_KEYMAP
+#if  (defined(BOOTLOADER_DFU) || defined(BOOTLOADER_LUFA_DFU) || defined(BOOTLOADER_QMK_DFU))
+       ":dfu "
+#elif defined(BOOTLOADER_HALFKAY)
+      ":teensy "
+#elif defined(BOOTLOADER_CATERINA)
+       ":avrdude "
+#endif
+        SS_TAP(X_ENTER));
+    }
+    return false;
+    break;
   }
   return process_record_keymap(keycode, record);
 }
 ```
 
-For boards that may not have a shift button (such as on a macro pad), we need a way to always include the bootloader option.  To do that, add the following to the `rules.mk` in your userspace folder: 
-
-```make 
-ifeq ($(strip $(FLASH_BOOTLOADER)), yes)
-    OPT_DEFS += -DFLASH_BOOTLOADER
-endif
-```
-
 This will add a new `KC_MAKE` keycode that can be used in any of your keymaps.  And this keycode will output `make <keyboard>:<keymap>`, making frequent compiling easier.  And this will work with any keyboard and any keymap as it will output the current boards info, so that you don't have to type this out every time.
 
-Also, holding `shift` will add the appropriate flashing command (`:dfu`, `:teensy`, `:avrdude`, `:dfu-util`) for a majority of keyboards.  Holding `control` will add some commands that will speed up compiling time by processing multiple files at once. 
+Additionally, this should flash the newly compiled firmware automatically, using the correct utility, based on the bootloader settings (or default to just generating the HEX file). However, it should be noted that this may not work on all systems. AVRDUDE doesn't work on WSL, namely (and will dump the HEX in the ".build" folder instead).
 
-And for the boards that lack a shift key, or that you want to always attempt the flashing part, you can add `FLASH_BOOTLOADER = yes` to the `rules.mk` of that keymap.
 
-?> This should flash the newly compiled firmware automatically, using the correct utility, based on the bootloader settings (or default to just generating the HEX file). However, it should be noted that this may not work on all systems. AVRDUDE doesn't work on WSL, namely. And this doesn't support BootloadHID or mdloader. 

docs/feature_velocikey.md

@@ -1,30 +0,0 @@
-# Velocikey
-
-Velocikey is a feature that lets you control the speed of lighting effects (like the Rainbow Swirl effect) with the speed of your typing. The faster you type, the faster the lights will go!
-
-## Usage
-For Velocikey to take effect, there are two steps. First, when compiling your keyboard, you'll need to set `VELOCIKEY_ENABLE=yes` in `rules.mk`, e.g.:
-
-```
-BOOTMAGIC_ENABLE = no
-MOUSEKEY_ENABLE = no
-STENO_ENABLE = no
-EXTRAKEY_ENABLE = yes
-VELOCIKEY_ENABLE = yes
-```
-
-Then, while using your keyboard, you need to also turn it on with the VLK_TOG keycode, which toggles the feature on and off.
-
-The following light effects will all be controlled by Velocikey when it is enabled:
- - RGB Breathing
- - RGB Rainbow Mood
- - RGB Rainbow Swirl
- - RGB Snake
- - RGB Knight
-
-Support for LED breathing effects is planned but not available yet.
-
- As long as Velocikey is enabled, it will control the speed regardless of any other speed setting that your RGB lights are currently on.
-
- ## Configuration
- Velocikey doesn't currently support any configuration via keyboard settings. If you want to adjust something like the speed increase or decay rate, you would need to edit `velocikey.c` and adjust the values there to achieve the kinds of speeds that you like.

docs/features.md

@@ -7,31 +7,23 @@ QMK has a staggering number of features for building your keyboard. It can take
 * [Audio](feature_audio.md) - Connect a speaker to your keyboard for audio feedback, midi support, and music mode.
 * [Auto Shift](feature_auto_shift.md) - Tap for the normal key, hold slightly longer for its shifted state.
 * [Backlight](feature_backlight.md) - LED lighting support for your keyboard.
-* [Bluetooth](feature_bluetooth.md) - BlueTooth support for your keyboard.
 * [Bootmagic](feature_bootmagic.md) - Adjust the behavior of your keyboard using hotkeys.
 * [Combos](feature_combo.md) - Custom actions for multiple key holds.
 * [Command](feature_command.md) - Runtime version of bootmagic (Formerly known as "Magic").
-* [Debounce API](feature_debounce_type.md) - Customization of debouncing algorithms, and the ability to add more/custom debouncing. 
-* [DIP Switch](feature_dip_switch.md) - Toggle switches for customizing board function.
 * [Dynamic Macros](feature_dynamic_macros.md) - Record and playback macros from the keyboard itself.
-* [Encoders](feature_encoders.md) - Rotary encoders! 
 * [Grave Escape](feature_grave_esc.md) - Lets you use a single key for Esc and Grave. 
-* [Haptic Feedback](feature_haptic_feedback.md) - Add haptic feedback drivers to your board.
 * [HD44780 LCD Display](feature_hd44780.md) - Support for LCD character displays using the HD44780 standard.
 * [Key Lock](feature_key_lock.md) - Lock a key in the "down" state.
 * [Layouts](feature_layouts.md) - Use one keymap with any keyboard that supports your layout.
 * [Leader Key](feature_leader_key.md) - Tap the leader key followed by a sequence to trigger custom behavior.
-* [LED Matrix](feature_led_matrix.md) - LED Matrix single color lights for per key lighting (Single Color, not RGB).
 * [Macros](feature_macros.md) - Send multiple key presses when pressing only one physical key.
 * [Mouse keys](feature_mouse_keys.md) - Control your mouse pointer from your keyboard.
-* [OLED Driver](feature_oled_driver.md) - Add OLED screens to your keyboard.
-* [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys) - Sticky Keys, lets you hit a key rather than holding it.
+* [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys) - Sticky Keys, lets hit a key rather than holding it.
 * [Pointing Device](feature_pointing_device.md) - Framework for connecting your custom pointing device to your keyboard.
 * [PS2 Mouse](feature_ps2_mouse.md) - Driver for connecting a PS/2 mouse directly to your keyboard.
 * [RGB Light](feature_rgblight.md) - RGB lighting for your keyboard.
 * [RGB Matrix](feature_rgb_matrix.md) - RGB Matrix lights for per key lighting.
-* [Space Cadet](feature_space_cadet.md) - Use your left/right shift keys to type parenthesis and brackets.
-* [Split Keyboard](feature_split_keyboard.md) 
+* [Space Cadet](feature_space_cadet_shift.md) - Use your left/right shift keys to type parenthesis and brackets.
 * [Stenography](feature_stenography.md) - Put your keyboard into Plover mode for stenography use.
 * [Swap Hands](feature_swap_hands.md) - Mirror your keyboard for one handed usage.
 * [Tap Dance](feature_tap_dance.md) - Make a single key do as many things as you want.
@@ -39,4 +31,3 @@ QMK has a staggering number of features for building your keyboard. It can take
 * [Thermal Printer](feature_thermal_printer.md) - Connect a thermal printer to your keyboard to be able to toggle on a printed log of everything you type.
 * [Unicode](feature_unicode.md) - Unicode input support.
 * [Userspace](feature_userspace.md) - Share code between different keymaps and keyboards.
-* [Velocikey](feature_velocikey.md) - Allows changes in RGB animation speed based on WPM/Typing speed.

docs/flashing.md

@@ -10,17 +10,11 @@ Atmel's DFU bootloader comes on all atmega32u4 chips by default, and is used by
 
 To ensure compatibility with the DFU bootloader, make sure this block is present your `rules.mk` (optionally with `lufa-dfu` or `qmk-dfu` instead):
 
-```make
-# Bootloader selection
-#   Teensy       halfkay
-#   Pro Micro    caterina
-#   Atmel DFU    atmel-dfu
-#   LUFA DFU     lufa-dfu
-#   QMK DFU      qmk-dfu
-#   ATmega32A    bootloadHID
-#   ATmega328P   USBasp
-BOOTLOADER = atmel-dfu
-```
+    # Bootloader
+    #     This definition is optional, and if your keyboard supports multiple bootloaders of
+    #     different sizes, comment this out, and the correct address will be loaded
+    #     automatically (+60). See bootloader.mk for all options.
+    BOOTLOADER = atmel-dfu
 
 Compatible flashers:
 
@@ -55,32 +49,17 @@ To generate this bootloader, use the `bootloader` target, eg `make planck/rev4:d
 
 To generate a production-ready .hex file (containing the application and the bootloader), use the `production` target, eg `make planck/rev4:default:production`.
 
-### DFU commands
-
-There are a number of DFU commands that you can use to flash firmware to a DFU device:
-
-* `:dfu` - This is the normal option and waits until a DFU device is available, and then flashes the firmware. This will check every 5 seconds, to see if a DFU device has appeared.
-* `:dfu-ee` - This flashes an `eep` file instead of the normal hex.  This is uncommon. 
-* `:dfu-split-left` - This flashes the normal firmware, just like the default option (`:dfu`). However, this also flashes the "Left Side" EEPROM file for split keyboards. _This is ideal for Elite C based split keyboards._
-* `:dfu-split-right` - This flashes the normal firmware, just like the default option (`:dfu`). However, this also flashes the "Right Side" EEPROM file for split keyboards. _This is ideal for Elite C based split keyboards._
-
 ## Caterina
 
-Arduino boards and their clones use the [Caterina bootloader](https://github.com/arduino/ArduinoCore-avr/tree/master/bootloaders/caterina) (any keyboard built with a Pro Micro, or clone), and uses the avr109 protocol to communicate through virtual serial. Bootloaders like [A-Star](https://www.pololu.com/docs/0J61/9) are based on Caterina.
+Arduino boards and their clones use the [Caterina bootloader](https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/bootloaders/caterina) (any keyboard built with a Pro Micro, or clone), and uses the avr109 protocol to communicate through virtual serial. Bootloaders like [A-Star](https://www.pololu.com/docs/0J61/9) are based on Caterina.
 
 To ensure compatibility with the Caterina bootloader, make sure this block is present your `rules.mk`:
 
-```make
-# Bootloader selection
-#   Teensy       halfkay
-#   Pro Micro    caterina
-#   Atmel DFU    atmel-dfu
-#   LUFA DFU     lufa-dfu
-#   QMK DFU      qmk-dfu
-#   ATmega32A    bootloadHID
-#   ATmega328P   USBasp
-BOOTLOADER = caterina
-```
+    # Bootloader
+    #     This definition is optional, and if your keyboard supports multiple bootloaders of
+    #     different sizes, comment this out, and the correct address will be loaded
+    #     automatically (+60). See bootloader.mk for all options.
+    BOOTLOADER = caterina
 
 Compatible flashers:
 
@@ -105,24 +84,17 @@ or if you want to flash multiple boards, use the following command
 
 When you're done flashing boards, you'll need to hit Ctrl + C or whatever the correct keystroke is for your operating system to break the loop.
 
-
 ## Halfkay
 
 Halfkay is a super-slim protocol developed by PJRC that uses HID, and come on all Teensys (namely the 2.0).
 
 To ensure compatibility with the Halfkay bootloader, make sure this block is present your `rules.mk`:
 
-```make
-# Bootloader selection
-#   Teensy       halfkay
-#   Pro Micro    caterina
-#   Atmel DFU    atmel-dfu
-#   LUFA DFU     lufa-dfu
-#   QMK DFU      qmk-dfu
-#   ATmega32A    bootloadHID
-#   ATmega328P   USBasp
-BOOTLOADER = halfkay
-```
+    # Bootloader
+    #     This definition is optional, and if your keyboard supports multiple bootloaders of
+    #     different sizes, comment this out, and the correct address will be loaded
+    #     automatically (+60). See bootloader.mk for all options.
+    BOOTLOADER = halfkay
 
 Compatible flashers:
 
@@ -137,73 +109,6 @@ Flashing sequence:
 3. Flash a .hex file
 4. Reset the device into application mode (may be done automatically)
 
-## USBasploader
-
-USBasploader is a bootloader developed by matrixstorm. It is used in some non-USB AVR chips such as the ATmega328P, which run V-USB.
-
-To ensure compatibility with the USBasploader bootloader, make sure this block is present in your `rules.mk`:
-
-```make
-# Bootloader selection
-#   Teensy       halfkay
-#   Pro Micro    caterina
-#   Atmel DFU    atmel-dfu
-#   LUFA DFU     lufa-dfu
-#   QMK DFU      qmk-dfu
-#   ATmega32A    bootloadHID
-#   ATmega328P   USBasp
-BOOTLOADER = USBasp
-```
-
-Compatible flashers:
-
-* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
-* [avrdude](http://www.nongnu.org/avrdude/) with the `usbasp` programmer
-* [AVRDUDESS](https://github.com/zkemble/AVRDUDESS)
-
-Flashing sequence:
-
-1. Press the `RESET` keycode, or keep the boot pin shorted to GND while quickly shorting RST to GND
-2. Wait for the OS to detect the device
-3. Flash a .hex file
-4. Reset the device into application mode (may be done automatically)
-
-## BootloadHID
-
-BootloadHID is a USB bootloader for AVR microcontrollers. The uploader tool requires no kernel level driver on Windows and can therefore be run without installing any DLLs.
-
-To ensure compatibility with the bootloadHID bootloader, make sure this block is present your `rules.mk`:
-
-```make
-# Bootloader selection
-#   Teensy       halfkay
-#   Pro Micro    caterina
-#   Atmel DFU    atmel-dfu
-#   LUFA DFU     lufa-dfu
-#   QMK DFU      qmk-dfu
-#   ATmega32A    bootloadHID
-#   ATmega328P   USBasp
-BOOTLOADER = bootloadHID
-```
-
-Compatible flashers:
-
-* [HIDBootFlash](http://vusb.wikidot.com/project:hidbootflash) (recommended Windows GUI)
-* [bootloadhid Command Line](https://www.obdev.at/products/vusb/bootloadhid.html) / `:BootloadHID` in QMK (recommended command line)
-
-Flashing sequence:
-
-1. Enter the bootloader using any of the following methods:
-    * Tap the `RESET` keycode (may not work on all devices)
-    * Hold the salt key while plugging the keyboard in (usually documented within keyboard readme) 
-2. Wait for the OS to detect the device
-3. Flash a .hex file
-4. Reset the device into application mode (may be done automatically)
-
-or:
-
-    make <keyboard>:<keymap>:bootloadHID
-
 ## STM32
 
 All STM32 chips come preloaded with a factory bootloader that cannot be modified nor deleted. Some STM32 chips have bootloaders that do not come with USB programming (e.g. STM32F103) but the process is still the same.
@@ -226,10 +131,3 @@ Flashing sequence:
     * You will receive a warning about the DFU signature; Just ignore it
 4. Reset the device into application mode (may be done automatically)
     * If you are building from command line (e.g. `make planck/rev6:default:dfu-util`), make sure that `:leave` is passed to the `DFU_ARGS` variable inside your `rules.mk` (e.g. `DFU_ARGS = -d 0483:df11 -a 0 -s 0x08000000:leave`) so that your device resets after flashing
-
-### STM32 Commands
-
-There are a number of DFU commands that you can use to flash firmware to a STM32 device:
-
-* `:dfu-util` - The default command for flashing to STM32 devices.
-* `:st-link-cli` - This allows you to flash the firmware via ST-LINK's CLI utility, rather than dfu-util.

docs/flashing_bootloadhid.md

@@ -1,70 +0,0 @@
-# BootloadHID Flashing Instructions and Bootloader Information
-
-ps2avr(GB) boards use an ATmega32A microcontroller and a different bootloader. It is not flashable using the regular QMK methods.
-
-General flashing sequence:
-
-1. Enter the bootloader using any of the following methods:
-    * Tap the `RESET` keycode (may not work on all devices)
-    * Hold the salt key while plugging the keyboard in (usually documented within keyboard readme) 
-2. Wait for the OS to detect the device
-3. Flash a .hex file
-4. Reset the device into application mode (may be done automatically)
-
-## bootloadHID Flashing Target
-
-Using the QMK installation script, detailed [here](newbs_getting_started.md), the required bootloadHID tools should be automatically installed.
-
-To flash via the command line, use the target `:bootloadHID` by executing the following command:
-
-    make <keyboard>:<keymap>:bootloadHID
-
-## GUI Flashing
-
-### Windows
-1. Download [HIDBootFlash](http://vusb.wikidot.com/project:hidbootflash).
-2. Place your keyboard into reset. 
-3. Ensure the configured VendorID is `16c0` and ProductID is `05df`
-4. Press the `Find Device` button and ensure that your keyboard is found.
-5. Press the `Open .hex File` button and locate the `.hex` file you created.
-6. Press the `Flash Device` button and wait for the process to complete.
-
-## Command Line Flashing
-
-1. Place your keyboard into reset. 
-2. Flash the board by typing `bootloadHID -r` followed by the path to your `.hex` file.
-
-### Windows Manual Installation
-For MSYS2:
-1. Download the BootloadHID firmware package from https://www.obdev.at/downloads/vusb/bootloadHID.2012-12-08.tar.gz.
-2. Extract contents using a compatible tool, for example 7-Zip.
-3. Add to the MSYS path by copying `commandline/bootloadHID.exe` from the extracted archive to your MSYS2 installation, typically `C:\msys64\usr\bin`.
-
-For native Windows flashing, the `bootloadHID.exe` can be used outside of the MSYS2 environment.
-
-### Linux Manual Installation
-1. Install libusb development dependency:
-    ```bash
-    # This depends on OS - for Debian the following works
-    sudo apt-get install libusb-dev
-    ```
-2. Download the BootloadHID firmware package:
-    ```
-    wget https://www.obdev.at/downloads/vusb/bootloadHID.2012-12-08.tar.gz -O - | tar -xz -C /tmp
-    ```
-3. Build the bootloadHID executable:
-    ```
-    cd /tmp/bootloadHID.2012-12-08/commandline/
-    make
-    sudo cp bootloadHID /usr/local/bin
-    ```
-
-### MacOS Manual Installation
-1. Install Homebrew by typing the following:
-    ```
-    /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
-    ```
-2. Install the following packages:
-    ```
-    brew install --HEAD https://raw.githubusercontent.com/robertgzr/homebrew-tap/master/bootloadhid.rb
-    ```

docs/getting_started_build_tools.md

@@ -4,9 +4,7 @@ This page describes setting up the build environment for QMK. These instructions
 
 <!-- FIXME: We should have ARM instructions somewhere. -->
 
-**Note:** If this is your first time here, check out the [Complete Newbs Guide](newbs.md) page.
-
-Before continuing, double check that your submodules (third-party libraries) are up to date by running `make git-submodule`.
+Note: If it is your first time here, Check out the "Complete Newbs guide" instead
 
 ## Linux
 
@@ -43,10 +41,6 @@ Debian / Ubuntu example:
 Fedora / Red Hat example:
 
     sudo dnf install gcc unzip wget zip dfu-util dfu-programmer avr-gcc avr-libc binutils-avr32-linux-gnu arm-none-eabi-gcc-cs arm-none-eabi-binutils-cs arm-none-eabi-newlib
-    
-Arch / Manjaro example:
-
-    pacman -S base-devel gcc unzip wget zip avr-gcc avr-binutils avr-libc dfu-util arm-none-eabi-gcc arm-none-eabi-binutils arm-none-eabi-newlib git dfu-programmer dfu-util
 
 ## Nix
 
@@ -62,14 +56,14 @@ If you're using [homebrew,](http://brew.sh/) you can use the following commands:
     brew tap osx-cross/avr
     brew tap PX4/homebrew-px4
     brew update
-    brew install avr-gcc@8
-    brew link --force avr-gcc@8
+    brew install avr-gcc@7
+    brew link --force avr-gcc@7
     brew install dfu-programmer
     brew install dfu-util
     brew install gcc-arm-none-eabi
     brew install avrdude
 
-This is the recommended method. If you don't have homebrew, [install it!](http://brew.sh/) It's very much worth it for anyone who works in the command line. Note that the `make` and `make install` portion during the homebrew installation of `avr-gcc@8` can take over 20 minutes and exhibit high CPU usage.
+This is the recommended method. If you don't have homebrew, [install it!](http://brew.sh/) It's very much worth it for anyone who works in the command line. Note that the `make` and `make install` portion during the homebrew installation of `avr-gcc@7` can take over 20 minutes and exhibit high CPU usage.
 
 ## Windows with msys2 (recommended)
 
@@ -129,27 +123,24 @@ If you have trouble and want to ask for help, it is useful to generate a *Win_Ch
 
 ## Docker
 
-If this is a bit complex for you, Docker might be the turnkey solution you need. After installing [Docker CE](https://docs.docker.com/install/#supported-platforms), run the following command from the `qmk_firmware` directory to build a keyboard/keymap:
-```bash
-util/docker_build.sh keyboard:keymap
-# For example: util/docker_build.sh ergodox_ez:steno
-```
-This will compile the desired keyboard/keymap and leave the resulting `.hex` or `.bin` file in the QMK directory for you to flash. If `:keymap` is omitted, the `default` keymap is used. Note that the parameter format is the same as when building with `make`.
+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:
 
-You can also start the script without any parameters, in which case it will ask you to input the build parameters one by one, which you may find easier to use:
 ```bash
-util/docker_build.sh
-# Reads parameters as input (leave blank for defaults)
+# You'll run this every time you want to build a keymap
+# modify the keymap and keyboard assignment to compile what you want
+# defaults are ergodox/default
+
+docker run -e keymap=gwen -e keyboard=ergodox_ez --rm -v $('pwd'):/qmk:rw edasque/qmk_firmware
 ```
 
-There is also support for building _and_ flashing the keyboard straight from Docker by specifying the `target` as well:
-```bash
-util/docker_build.sh keyboard:keymap:target
-# For example: util/docker_build.sh planck/rev6:default:dfu-util
-```
-If you're on Linux, this should work out of the box. On Windows and macOS, it requires [Docker Machine](http://gw.tnode.com/docker/docker-machine-with-usb-support-on-windows-macos/) to be running. This is tedious to set up, so it's not recommended; use [QMK Toolbox](https://github.com/qmk/qmk_toolbox) instead.
+On Windows Docker seems to have issues with the VOLUME tag in Dockerfile, and `$('pwd')` won't print a Windows compliant path; use full path instead, like this:
 
-!> Docker for Windows requires [Hyper-V](https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/quick-start/enable-hyper-v) to be enabled. This means that it cannot work on versions of Windows which don't have Hyper-V, such as Windows 7, Windows 8 and **Windows 10 Home**.
+```bash
+docker run -e keymap=default -e keyboard=ergodox_ez --rm -v D:/Users/Sacapuces/Documents/Repositories/qmk:/qmk:rw edasque/qmk_firmware
+
+```
+
+This will compile the targeted keyboard/keymap and leave it in your QMK directory for you to flash.
 
 ## Vagrant
 If you have any problems building the firmware, you can try using a tool called Vagrant. It will set up a virtual computer with a known configuration that's ready-to-go for firmware building. OLKB does NOT host the files for this virtual computer. Details on how to set up Vagrant are in the [vagrant guide](getting_started_vagrant.md).

docs/getting_started_introduction.md

@@ -12,17 +12,11 @@ Within the folder `users` is a directory for each user. This is a place for user
 
 ### Keyboard Project Structure
 
-Within the folder `keyboards`, its subfolder `handwired` and its vendor and manufacture subdirectories e.g. `clueboard` is a directory for each keyboard project, for example `qmk_firmware/keyboards/clueboard/2x1800`. Within it, you'll find the following structure:
+Within the folder `keyboards` and its subfolder `handwired` is a directory for each keyboard project, for example `qmk_firmware/keyboards/clueboard`. Within it you'll find the following structure:
 
 * `keymaps/`: Different keymaps that can be built
 * `rules.mk`: The file that sets the default "make" options. Do not edit this file directly, instead use a keymap specific `rules.mk`.
 * `config.h`: The file that sets the default compile time options. Do not edit this file directly, instead use a keymap specific `config.h`.
-* `info.json`: The file used for setting layout for QMK Configurator. See [Configurator Support](reference_configurator_support.md) for more information.
-* `readme.md`: A brief overview of the keyboard.
-* `<keyboardName>.h`: This file is where the keyboard layout is defined against the keyboard's switch matrix.
-* `<keyboardName>.c`: This file is where you can find custom code for the keyboard.  
-
-For more information on project structure, see [QMK Keyboard Guidelines](hardware_keyboard_guidelines.md).
 
 ### Keymap Structure
 

docs/getting_started_make_guide.md

@@ -14,7 +14,7 @@ The full syntax of the `make` command is `<keyboard_folder>:<keymap>:<target>`,
 The `<target>` means the following
 * If no target is given, then it's the same as `all` below
 * `all` compiles as many keyboard/revision/keymap combinations as specified. For example, `make planck/rev4:default` will generate a single .hex, while `make planck/rev4:all` will generate a hex for every keymap available to the planck.
-* `dfu`, `teensy`, `avrdude`, `dfu-util` or `bootloadHID`, compile and upload the firmware to the keyboard. If the compilation fails, then nothing will be uploaded. The programmer to use depends on the keyboard. For most keyboards it's `dfu`, but for ChibiOS keyboards you should use `dfu-util`, and `teensy` for standard Teensys. To find out which command you should use for your keyboard, check the keyboard specific readme.
+* `dfu`, `teensy`, `avrdude` or `dfu-util`, compile and upload the firmware to the keyboard. If the compilation fails, then nothing will be uploaded. The programmer to use depends on the keyboard. For most keyboards it's `dfu`, but for ChibiOS keyboards you should use `dfu-util`, and `teensy` for standard Teensys. To find out which command you should use for your keyboard, check the keyboard specific readme.
  * **Note**: some operating systems need root access for these commands to work, so in that case you need to run for example `sudo make planck/rev4:default:dfu`.
 * `clean`, cleans the build output folders to make sure that everything is built from scratch. Run this before normal compilation if you have some unexplainable problems.
 
@@ -83,7 +83,7 @@ This allows the keyboard to tell the host OS that up to 248 keys are held down a
 
 `BACKLIGHT_ENABLE`
 
-This enables the in-switch LED backlighting. You can specify the backlight pin by putting this in your `config.h`:
+This enables your backlight on Timer1 and ports B5, B6, or B7 (for now). You can specify your port by putting this in your `config.h`:
 
     #define BACKLIGHT_PIN B7
 
@@ -93,17 +93,19 @@ This enables MIDI sending and receiving with your keyboard. To enter MIDI send m
 
 `UNICODE_ENABLE`
 
-This allows you to send Unicode characters using `UC(<code point>)` in your keymap. Code points up to `0x7FFF` are supported. This covers characters for most modern languages, as well as symbols, but it doesn't cover emoji.
+This allows you to send unicode symbols via `UC(<unicode>)` in your keymap. Only codes up to 0x7FFF are currently supported.
 
 `UNICODEMAP_ENABLE`
 
-This allows you to send Unicode characters using `X(<map index>)` in your keymap. You will need to maintain a mapping table in your keymap file. All possible code points (up to `0x10FFFF`) are supported.
+This allows sending unicode symbols using `X(<unicode>)` in your keymap. Codes
+up to 0xFFFFFFFF are supported, including emojis. You will need to maintain
+a separate mapping table in your keymap file.
 
-`UCIS_ENABLE`
+Known limitations:
+- Under Mac OS, only codes up to 0xFFFF are supported.
+- Under Linux ibus, only codes up to 0xFFFFF are supported (but anything important is still under this limit for now).
 
-This allows you to send Unicode characters by inputting a mnemonic corresponding to the character you want to send. You will need to maintain a mapping table in your keymap file. All possible code points (up to `0x10FFFF`) are supported.
-
-For further details, as well as limitations, see the [Unicode page](feature_unicode.md).
+Characters out of range supported by the OS will be ignored.
 
 `BLUETOOTH_ENABLE`
 
@@ -115,7 +117,7 @@ This allows you output audio on the C6 pin (needs abstracting). See the [audio p
 
 `FAUXCLICKY_ENABLE`
 
-Uses buzzer to emulate clicky switches. A cheap imitation of the Cherry blue switches. By default, uses the C6 pin, same as `AUDIO_ENABLE`.
+Uses buzzer to emulate clicky switches. A cheap imitation of the Cherry blue switches. By default, uses the C6 pin, same as AUDIO_ENABLE.
 
 `VARIABLE_TRACE`
 
@@ -135,18 +137,6 @@ This enables [key lock](feature_key_lock.md). This consumes an additional 260 by
 
 This enables split keyboard support (dual MCU like the let's split and bakingpy's boards) and includes all necessary files located at quantum/split_common
 
-`SPLIT_TRANSPORT`
-
-As there is no standard split communication driver for ARM-based split keyboards yet, `SPLIT_TRANSPORT = custom` must be used for these. It will prevent the standard split keyboard communication code (which is AVR-specific) from being included, allowing a custom implementation to be used.
-
-`CUSTOM_MATRIX`
-
-Lets you replace the default matrix scanning routine with your own code. You will need to provide your own implementations of matrix_init() and matrix_scan().
-
-`DEBOUNCE_TYPE`
-
-Lets you replace the default key debouncing routine with an alternative one. If `custom` you will need to provide your own implementation.
-
 ## Customizing Makefile Options on a Per-Keymap Basis
 
 If your keymap directory has a file called `rules.mk` any options you set in that file will take precedence over other `rules.mk` options for your particular keyboard.

docs/getting_started_vagrant.md

@@ -1,20 +1,16 @@
 # Vagrant Quick Start
 
-This project includes a `Vagrantfile` that will allow you to build a new firmware for your keyboard very easily without major changes to your primary operating system. This also ensures that when you clone the project and perform a build, you have the exact same environment as anyone else using the Vagrantfile to build. This makes it much easier for people to help you troubleshoot any issues you encounter.
+This project includes a Vagrantfile that will allow you to build a new firmware for your keyboard very easily without major changes to your primary operating system. This also ensures that when you clone the project and perform a build, you have the exact same environment as anyone else using the Vagrantfile to build. This makes it much easier for people to help you troubleshoot any issues you encounter.
 
 ## Requirements
 
-Using the `Vagrantfile` in this repository requires you have [Vagrant](http://www.vagrantup.com/) as well as a supported provider installed:
+Using the `/Vagrantfile` in this repository requires you have [Vagrant](http://www.vagrantup.com/) as well as [VirtualBox](https://www.virtualbox.org/) (or [VMware Workstation](https://www.vmware.com/products/workstation) and [Vagrant VMware plugin](http://www.vagrantup.com/vmware) but the (paid) VMware plugin requires a licensed copy of VMware Workstation/Fusion).
 
-* [VirtualBox](https://www.virtualbox.org/) (Version at least 5.0.12)
-  * Sold as 'the most accessible platform to use Vagrant'
-* [VMware Workstation](https://www.vmware.com/products/workstation) and [Vagrant VMware plugin](http://www.vagrantup.com/vmware)
-  * The (paid) VMware plugin requires a licensed copy of VMware Workstation/Fusion
-* [Docker](https://www.docker.com/)
+*COMPATIBILITY NOTICE* Certain versions of Virtualbox 5 appear to have an incompatibility with the Virtualbox extensions installed in the boxes in this Vagrantfile. If you encounter any issues with the /vagrant mount not succeeding, please upgrade your version of Virtualbox to at least 5.0.12. **Alternately, you can try running the following command:** `vagrant plugin install vagrant-vbguest`
 
-Other than having Vagrant, a suitable provider installed and possibly a restart of your computer afterwards, you can simple run a 'vagrant up' anywhere inside the folder where you checked out this project and it will start an environment (either a virtual machine or container) that contains all the tools required to build this project. There is a post Vagrant startup hint that will get you off on the right foot, otherwise you can also reference the build documentation below.
+Other than having Vagrant and Virtualbox installed and possibly a restart of your computer afterwards, you can simple run a 'vagrant up' anywhere inside the folder where you checked out this project and it will start a Linux virtual machine that contains all the tools required to build this project. There is a post Vagrant startup hint that will get you off on the right foot, otherwise you can also reference the build documentation below.
 
-## Flashing the Firmware
+# Flashing the Firmware
 
 The "easy" way to flash the firmware is using a tool from your host OS:
 
@@ -23,35 +19,3 @@ The "easy" way to flash the firmware is using a tool from your host OS:
 * [Atmel FLIP](http://www.atmel.com/tools/flip.aspx)
 
 If you want to program via the command line you can uncomment the ['modifyvm'] lines in the Vagrantfile to enable the USB passthrough into Linux and then program using the command line tools like dfu-util/dfu-programmer or you can install the Teensy CLI version.
-
-## Vagrantfile Overview
-The development environment is configured to run the QMK Docker image, `qmkfm/base_container`. This not only ensures predictability between systems, it also mirrors the CI environment.
-
-## FAQ
-
-### Why am I seeing issues under Virtualbox?
-Certain versions of Virtualbox 5 appear to have an incompatibility with the Virtualbox extensions installed in the boxes in this Vagrantfile. If you encounter any issues with the /vagrant mount not succeeding, please upgrade your version of Virtualbox to at least 5.0.12. **Alternately, you can try running the following command:**
-
-```console
-vagrant plugin install vagrant-vbguest
-```
-
-### How do I remove an existing environment?
-Finished with your environment? From anywhere inside the folder where you checked out this project, Execute:
-
-```console
-vagrant destory
-```
-
-### What if I want to use Docker directly?
-Want to benefit from the Vagrant workflow without a virtual machine? The Vagrantfile is configured to bypass running a virtual machine, and run the container directly. Execute the following when bringing up the environment to force the use of Docker:
-```console
-vagrant up --provider=docker
-```
-
-### How do I access the virtual machine instead of the Docker container?
-Execute the following to bypass the `vagrant` user booting directly to the official qmk builder image:
-
-```console
-vagrant ssh -c 'sudo -i'
-```

docs/hand_wire.md

@@ -185,30 +185,21 @@ When you're done with the columns, start with the rows in the same process, from
 
 As you move along, be sure that the Teensy is staying in place - recutting and soldering the wires is a pain!
 
-## Additional guides
-
-If you're more of a visual learner, or want some additional tips and something more to follow along, these two visual step by step guides may be helpful:
-
-- [BrownFox's step by step guide](https://deskthority.net/viewtopic.php?f=7&t=6050)
-- [Cribbit's modern hand wiring guide](https://geekhack.org/index.php?topic=87689.0)
-
 # Getting Some Basic Firmware Set Up
 
 From here, you should have a working keyboard once you program a firmware. Before we attach the Teensy permanently to the keyboard, let's quickly get some firmware loaded onto the Teensy so we can test each keyswitch.
 
-To start out, download [the firmware](https://github.com/qmk/qmk_firmware/) - we'll be using my (Jack's) fork of TMK called QMK/Quantum. We'll be doing a lot from the Terminal/command prompt, so get that open, along with a decent text editor like [Sublime Text](http://www.sublimetext.com/) (paid) or [Visual Studio Code](https://code.visualstudio.com) (free).
+To start out, download [the firmware](https://github.com/qmk/qmk_firmware/) - we'll be using my (Jack's) fork of TMK called QMK/Quantum. We'll be doing a lot from the Terminal/command prompt, so get that open, along with a decent text editor like [Sublime Text](http://www.sublimetext.com/).
 
-The first thing we're going to do is create a new keyboard. In your terminal, run this command, which will ask you some questions and generate a basic keyboard project:
+The first thing we're going to do is create a new project using the script in the root directory of the firmware. In your terminal, run this command with `<project_name>` replaced by the name of your project - it'll need to be different from any other project in the `keyboards/` folder:
 
 ```
-./util/new_keyboard.sh
+    util/new_project.sh <project_name>
 ```
 
 You'll want to navigate to the `keyboards/<project_name>/` folder by typing, like the print-out from the script specifies:
 
-```
-cd keyboards/<project_name>
-```
+    cd keyboards/<project_name>
 
 ### `config.h`
 
@@ -218,7 +209,7 @@ Farther down are `MATRIX_ROW_PINS` and `MATRIX_COL_PINS`. Change their definitio
 
 ### `<project_name>.h`
 
-The next file you'll want to look at is `<project_name>.h`. You're going to want to rewrite the `LAYOUT` definition - the format and syntax here is extremely important, so pay attention to how things are setup. The first half of the definition are considered the arguments - this is the format that you'll be following in your keymap later on, so you'll want to have as many k*xy* variables here as you do keys. The second half is the part that the firmware actually looks at, and will contain gaps depending on how you wired your matrix.
+The next file you'll want to look at is `<project_name>.h`. You're going to want to rewrite the `KEYMAP` definition - the format and syntax here is extremely important, so pay attention to how things are setup. The first half of the definition are considered the arguments - this is the format that you'll be following in your keymap later on, so you'll want to have as many k*xy* variables here as you do keys. The second half is the part that the firmware actually looks at, and will contain gaps depending on how you wired your matrix.
 
 We'll dive into how this will work with the following example. Say we have a keyboard like this:
 
@@ -240,10 +231,10 @@ This can be described by saying the top row is 3 1u keys, and the bottom row is
     └─────┴─────┘
 ```
 
-The middle column is unused on the bottom row in this example. Our `LAYOUT` definition would look like this:
+The middle column is unused on the bottom row in this example. Our `KEYMAP` definition would look like this:
 
 ```
-    #define LAYOUT( \
+    #define KEYMAP( \
         k00, k01, k02, \
           k10,  k11,   \
     ) \
@@ -265,10 +256,10 @@ Let's say that instead, we wired our keyboard like this (a fair thing to do):
     └─────┴─────┘
 ```
 
-This would require our `LAYOUT` definition to look like this:
+This would require our `KEYMAP` definition to look like this:
 
 ```
-    #define LAYOUT( \
+    #define KEYMAP( \
         k00, k01, k02, \
           k10,  k11,   \
     ) \
@@ -278,7 +269,7 @@ This would require our `LAYOUT` definition to look like this:
     }
 ```
 
-Notice how the `k11` and `KC_NO` switched places to represent the wiring, and the unused final column on the bottom row. Sometimes it'll make more sense to put a keyswitch on a particular column, but in the end, it won't matter, as long as all of them are accounted for. You can use this process to write out the `LAYOUT` for your entire keyboard - be sure to remember that your keyboard is actually backwards when looking at the underside of it.
+Notice how the `k11` and `KC_NO` switched places to represent the wiring, and the unused final column on the bottom row. Sometimes it'll make more sense to put a keyswitch on a particular column, but in the end, it won't matter, as long as all of them are accounted for. You can use this process to write out the `KEYMAP` for your entire keyboard - be sure to remember that your keyboard is actually backwards when looking at the underside of it.
 
 ### `keymaps/<variant>/default.c`
 
@@ -300,7 +291,7 @@ This can be accomplished by using the following `keymaps` definition:
 
 ```
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [0] = LAYOUT( /* Base */
+    [0] = KEYMAP( /* Base */
       KC_A,  KC_1,  KC_H, \
         KC_TAB,  KC_SPC   \
     ),
@@ -309,7 +300,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 Note that the layout of the keycodes is similar to the physical layout of our keyboard - this make it much easier to see what's going on. A lot of the keycodes should be fairly obvious, but for a full list of them, check out [Keycodes](keycodes.md) - there are also a lot of aliases to condense your keymap file.
 
-It's also important to use the `LAYOUT` function we defined earlier - this is what allows the firmware to associate our intended readable keymap with the actual wiring.
+It's also important to use the `KEYMAP` function we defined earlier - this is what allows the firmware to associate our intended readable keymap with the actual wiring.
 
 ## Compiling Your Firmware
 
@@ -328,7 +319,7 @@ Carefully flip your keyboard over, open up a new text document, and try typing -
 2. Check the solder joints on the diode - if the diode is loose, part of your row may register, while the other may not.
 3. Check the solder joints on the columns - if your column wiring is loose, part or all of the column may not work.
 4. Check the solder joints on both sides of the wires going to/from the Teensy - the wires need to be fully soldered and connect to both sides.
-5. Check the `<project_name>.h` file for errors and incorrectly placed `KC_NO`s - if you're unsure where they should be, instead duplicate a k*xy* variable.
+5. Check the <project_name>.h file for errors and incorrectly placed `KC_NO`s - if you're unsure where they should be, instead duplicate a k*xy* variable.
 6. Check to make sure you actually compiled the firmware and flashed the Teensy correctly. Unless you got error messages in the terminal, or a pop-up during flashing, you probably did everything correctly.
 
 If you've done all of these things, keep in mind that sometimes you might have had multiple things affecting the keyswitch, so it doesn't hurt to test the keyswitch by shorting it out at the end.
@@ -337,4 +328,4 @@ If you've done all of these things, keep in mind that sometimes you might have h
 
 Now that you have a working board, it's time to get things in their permanent positions. I've often used liberal amounts of hot glue to secure and insulate things, so if that's your style, start spreading that stuff like butter. Otherwise, double-sided tape is always an elegant solution, and electrical tape is a distant second. Due to the nature of these builds, a lot of this part is up to you and how you planned (or didn't plan) things out.
 
-There are a lot of possibilities inside the firmware - explore [docs.qmk.fm](http://docs.qmk.fm) for a full feature list, and dive into the different keyboards (Planck, Clueboard, Ergodox EZ, etc) to see how people use all of them. You can always stop by [the OLKB subreddit for help!](http://reddit.com/r/olkb)
+There are a lot of possibilities inside the firmware - explore [docs.qmk.fm](http://docs.qmk.fm) for a full feature list, and dive into the different project (Planck, Clueboard, Ergodox EZ, etc) to see how people use all of them. You can always stop by [the OLKB subreddit for help!](http://reddit.com/r/olkb)

docs/hardware_avr.md

@@ -6,26 +6,14 @@ If you have not yet you should read the [Keyboard Guidelines](hardware_keyboard_
 
 ## Adding Your AVR Keyboard to QMK
 
-QMK has a number of features to simplify working with AVR keyboards. For most keyboards you don't have to write a single line of code. To get started, run the `util/new_keyboard.sh` script:
+QMK has a number of features to simplify working with AVR keyboards. For most keyboards you don't have to write a single line of code. To get started run the `util/new_project.sh` script:
 
-```
-$ ./util/new_keyboard.sh
-Generating a new QMK keyboard directory
-
-Keyboard Name: mycoolkb
-Keyboard Type [avr]: 
-Your Name [John Smith]: 
-
-Copying base template files... done
-Copying avr template files... done
-Renaming keyboard files... done
-Replacing %KEYBOARD% with mycoolkb... done
-Replacing %YOUR_NAME% with John Smith... done
-
-Created a new keyboard called mycoolkb.
-
-To start working on things, cd into keyboards/mycoolkb,
-or open the directory in your favourite text editor.
+```bash
+$ util/new_project.sh my_awesome_keyboard
+######################################################
+# /keyboards/my_awesome_keyboard project created. To start
+# working on things, cd into keyboards/my_awesome_keyboard
+######################################################
 ```
 
 This will create all the files needed to support your new keyboard, and populate the settings with default values. Now you just need to customize it for your keyboard.
@@ -78,7 +66,7 @@ Do change the `MANUFACTURER`, `PRODUCT`, and `DESCRIPTION` lines to accurately r
 #define DESCRIPTION     A custom keyboard
 ```
 
-?> Windows and macOS will display the `MANUFACTURER` and `PRODUCT` in the list of USB devices. `lsusb` on Linux instead takes these from the list maintained by the [USB ID Repository](http://www.linux-usb.org/usb-ids.html) by default. `lsusb -v` will show the values reported by the device, and they are also present in kernel logs after plugging it in.
+?> Note: On Windows and macOS the `MANUFACTURER`, `PRODUCT`, and `DESCRIPTION` fields will be displayed in the list of USB devices. ?> On Linux these values will not be visible in lsusb by default, since Linux takes the information from the list maintained by [USB ID Repository](http://www.linux-usb.org/usb-ids.html) by default. lsusb will show the information reported by the device when executed with -v option. It is also present in kernel logs after plugging in the device.
 
 ### Keyboard Matrix Configuration
 
@@ -99,33 +87,15 @@ Once you've defined the size of your matrix you need to define which pins on you
 
 The number of `MATRIX_ROW_PINS` entries must be the same as the number you assigned to `MATRIX_ROWS`, and likewise for `MATRIX_COL_PINS` and `MATRIX_COLS`. You do not have to specify `UNUSED_PINS`, but you can if you want to document what pins are open.
 
-Finally, you can specify the direction your diodes point. This can be `COL2ROW` or `ROW2COL`.
+Finally, you can specify the direction your diodes point. This can be `COL2ROW`, `ROW2COL`, or `CUSTOM_MATRIX`.
 
 ```c
 #define DIODE_DIRECTION COL2ROW
 ```
 
-#### Direct Pin Matrix
-To configure a keyboard where each switch is connected to a separate pin and ground instead of sharing row and column pins, use `DIRECT_PINS`. The mapping defines the pins of each switch in rows and columns, from left to right. Must conform to the sizes within `MATRIX_ROWS` and `MATRIX_COLS`, use `NO_PIN` to fill in blank spaces. Overrides the behaviour of `DIODE_DIRECTION`, `MATRIX_ROW_PINS` and `MATRIX_COL_PINS`.
-
-```c
-// #define MATRIX_ROW_PINS { D0, D5 }
-// #define MATRIX_COL_PINS { F1, F0, B0 }
-#define DIRECT_PINS { \
-    { F1, E6, B0, B2, B3 }, \
-    { F5, F0, B1, B7, D2 }, \
-    { F6, F7, C7, D5, D3 }, \
-    { B5, C6, B6, NO_PIN, NO_PIN } \
-}
-#define UNUSED_PINS
-
-/* COL2ROW, ROW2COL */
-//#define DIODE_DIRECTION
-```
-
 ### Backlight Configuration
 
-QMK supports backlighting on most GPIO pins. A select few of these can be driven by the MCU in hardware. For more details see the [Backlight Documentation](feature_backlight.md).
+By default QMK supports backlighting on pins `B5`, `B6`, and `B7`. If you are using one of those you can simply enable it here. For more details see the [Backlight Documentation](feature_backlight.md).
 
 ```c
 #define BACKLIGHT_PIN B7
@@ -134,6 +104,8 @@ QMK supports backlighting on most GPIO pins. A select few of these can be driven
 #define BREATHING_PERIOD 6
 ```
 
+?> You can use backlighting on any pin you like, but you will have to do more work to support that. See the [Backlight Documentation](feature_backlight.md) for more details.
+
 ### Other Configuration Options
 
 There are a lot of features that can be configured or tuned in `config.h`. You should see the [Config Options](config_options.md) page for more details.

docs/hardware_drivers.md

@@ -14,9 +14,9 @@ QMK is used on a lot of different hardware. While support for the most common MC
 
 Support for addressing pins on the ProMicro by their Arduino name rather than their AVR name. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 
-## SSD1306 OLED Driver
+## SSD1306 (AVR Only)
 
-Support for SSD1306 based OLED displays. For more information see the [OLED Driver Feature](feature_oled_driver.md) page.
+Support for SSD1306 based OLED displays. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 
 ## uGFX
 
@@ -32,4 +32,4 @@ Support for up to 2 drivers. Each driver impliments 2 charlieplex matrices to in
 
 ## IS31FL3733
 
-Support for up to a single driver with room for expansion. Each driver can control 192 individual LEDs or 64 RGB LEDs. For more information on how to setup the driver see the [RGB Matrix](feature_rgb_matrix.md) page.
+Support for up to a single driver with room for expansion. Each driver can control 192 individual LEDs or 64 RGB LEDs. For more information on how to setup the driver see the [RGB Matrix](feature_rgb_matrix.md) page.

docs/hardware_keyboard_guidelines.md

@@ -1,104 +1,20 @@
 # QMK Keyboard Guidelines
 
-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.
-
+We welcome all keyboard projects into QMK, but ask that you try to stick to a couple guidelines that help us keep things organised and consistent.
 
 ## Naming Your Keyboard/Project
 
-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.
+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.
 
-The names `test`, `keyboard`, and `all` are reserved for make commands and may not be used as a keyboard or subfolder name.
+## `readme.md`
 
-Valid Examples:
-
-* `412_64`
-* `chimera_ortho`
-* `clueboard/66/rev3`
-* `planck`
-* `v60_type_r`
-
-## Sub-folders
-
-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:
-
-    qmk_firmware/keyboards/top_folder/sub_1/sub_2/sub_3/sub_4
-
-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.
-
-Example:
-
-Clueboard uses sub-folders for both purposes, organization and keyboard revisions.
-
-* [`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)  ← This is the organization folder, there's no `rules.mk` file
-      * [`60`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/60)  ← This is a compilable keyboard, it has a `rules.mk` file
-      * [`66`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/66) ← 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) ← compilable: `make clueboard/66/rev1`
-        * [`rev2`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/66/rev2) ← compilable: `make clueboard/66/rev2`
-        * [`rev3`](https://github.com/qmk/qmk_firmware/tree/master/keyboards/clueboard/66/rev3) ← compilable: `make clueboard/66/rev3` or `make clueboard/66`
-
-## Keyboard Folder Structure
-
-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:
-
-* `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.
-
-### `rules.mk`
-
-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.
-
-### `<keyboard_name.c>`
-
-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 following functions are typically defined in this file:
-
-* `void matrix_init_kb(void)`
-* `void matrix_scan_kb(void)`
-* `bool process_record_kb(uint16_t keycode, keyrecord_t *record)`
-* `void led_set_kb(uint8_t usb_led)`
-
-### `<keyboard_name.h>`
-
-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.
-
-If you have only a single layout you should call this macro `LAYOUT`.
-
-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.
-
-Layout macro names are entirely lowercase, except for the word `LAYOUT` at the front.
-
-As an example, if you have a 60% PCB that supports ANSI and ISO you might define the following layouts and keymaps:
-
-| Layout Name | Keymap Name | Description |
-|-------------|-------------|-------------|
-| LAYOUT_all | default | A layout that supports both ISO and ANSI |
-| LAYOUT_ansi | default_ansi | An ANSI layout |
-| LAYOUT_iso | default_iso | An ISO layout |
+All projects need to have a `readme.md` file that explains what the keyboard is, who made it, where it is available, and links to more information. Please follow the [published template](documentation_templates.md#keyboard-readmemd-template).
 
 ## Image/Hardware Files
 
-In an effort to keep the repo size down we're no longer accepting 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.
+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.
 
-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.
+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.
 
 ## Keyboard Defaults
 
@@ -116,6 +32,77 @@ If your keyboard does not have 2 shift keys you should provide a working default
 
 As documented on [Customizing Functionality](custom_quantum_functions.md) you can define custom functions for your keyboard. Please keep in mind that your users may want to customize that behavior as well, and make it possible for them to do that. If you are providing a custom function, for example `process_record_kb()`, make sure that your function calls the `_user()` version of the call too. You should also take into account the return value of the `_user()` version, and only run your custom code if the user returns `true`.
 
+## Keyboard Metadata
+
+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.
+
+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] ]`
+
+### 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.compile.qmk.fm/api_docs.html) docs for more information on using the JSON API.
+
 ## Non-Production/Handwired Projects
 
 We're happy to accept any project that uses QMK, including prototypes and handwired ones, but we have a separate `/keyboards/handwired/` folder for them, so the main `/keyboards/` folder doesn't get overcrowded. If a prototype project becomes a production project at some point in the future, we'd be happy to move it to the main `/keyboards/` folder!

docs/how_keyboards_work.md

@@ -12,7 +12,7 @@ place:
 ``` text
 +------+         +-----+       +----------+      +----------+     +----+
 | User |-------->| Key |------>| Firmware |----->| USB wire |---->| OS |
-+------+         +-----+       +----------+      +----------+     +----+
++------+         +-----+       +----------+      +----------+     |----+
 ```
 
 This scheme is a very simple view of what's going on, and more details follow
@@ -33,11 +33,7 @@ The firmware does not send actual letters or characters, but only scancodes.
 Thus, by modifying the firmware, you can only modify what scancode is sent over
 USB for a given key.
 
-## 3. What the Event Input/Kernel Does
-
-The *scancode* is mapped to a *keycode* dependent on the keyboard [60-keyboard.hwdb at Master](https://github.com/systemd/systemd/blob/master/hwdb/60-keyboard.hwdb). Without this mapping, the operating system will not receive a valid keycode and will be unable to do anything useful with that key press.
-
-## 4. What the Operating System Does
+## 3. What the Operating System Does
 
 Once the keycode reaches the operating system, a piece of software has to have
 it match an actual character thanks to a keyboard layout. For example, if your
@@ -67,10 +63,10 @@ You may wonder why a keyboard layout containing all of Unicode is not devised th
 
 ## How to (Maybe) Enter Unicode Characters
 
-You can have the firmware send *sequences of keys* to use the [software Unicode Input Method](https://en.wikipedia.org/wiki/Unicode_input#Hexadecimal_input) of the target operating system, thus effectively entering characters independently of the layout defined in the OS.
+You can have the firmware send *sequences of keys* to use the [software Unicode Input Method](https://en.wikipedia.org/wiki/Unicode_input#Hexadecimal_code_input) of the target operating system, thus effectively entering characters independently of the layout defined in the OS.
 
 Yet, it does come with multiple disadvantages:
 
- - Tied to a specific OS at a time (need recompilation when changing OS);
+ - Tied to a specific OS a a time (need recompilation when changing OS);
  - Within a given OS, does not work in all software;
  - Limited to a subset of Unicode on some systems.

docs/i2c_driver.md

@@ -7,12 +7,12 @@ The I2C Master drivers used in QMK have a set of common functions to allow porta
 |Function                                                                                                          |Description                                                                                                                                                                  |
 |------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 |`void i2c_init(void);`                                                                                            |Initializes the I2C driver. This function should be called once before any transaction is initiated.                                                                         |
-|`uint8_t i2c_start(uint8_t address, uint16_t timeout);`                                                                             |Starts an I2C transaction. Address is the 7-bit slave address without the direction bit.                                                                                     |
+|`uint8_t i2c_start(uint8_t address);`                                                                             |Starts an I2C transaction. Address is the 7-bit slave address without the direction bit.                                                                                     |
 |`uint8_t i2c_transmit(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);`                        |Transmit data over I2C. Address is the 7-bit slave address without the direction. Returns status of transaction.                                                             |
 |`uint8_t i2c_receive(uint8_t address, uint8_t* data, uint16_t length, uint16_t timeout);`                         |Receive data over I2C. Address is the 7-bit slave address without the direction. Saves number of bytes specified by `length` in `data` array. Returns status of transaction. |
 |`uint8_t i2c_writeReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);`       |Same as the `i2c_transmit` function but `regaddr` sets where in the slave the data will be written.                                                                          |
 |`uint8_t i2c_readReg(uint8_t devaddr, uint8_t regaddr, uint8_t* data, uint16_t length, uint16_t timeout);`        |Same as the `i2c_receive` function but `regaddr` sets from where in the slave the data will be read.                                                                         |
-|`uint8_t i2c_stop(void);`                                                                                         |Ends an I2C transaction.                                                                                                                                                     |
+|`uint8_t i2c_stop(uint16_t timeout);`                                                                             |Stops the I2C driver.                                                                                                                                                        |
 
 ### Function Return
 
@@ -33,7 +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      |
 
 AVRs usually have set GPIO which turn into I2C pins, therefore no further configuration is required.
 
@@ -62,59 +63,20 @@ 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. You can use these defines to set your i2c pins:
+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.
 
-| Variable                 | Description                                                                                  | Default |
-|--------------------------|----------------------------------------------------------------------------------------------|---------|
-| `I2C1_SCL_BANK`          | The bank of pins (`GPIOA`, `GPIOB`, `GPIOC`) to use for SCL                                  | `GPIOB` |
-| `I2C1_SDA_BANK`          | The bank of pins (`GPIOA`, `GPIOB`, `GPIOC`) to use for SDA                                  | `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`     |
-| `I2C1_BANK` (deprecated) | The bank of pins (`GPIOA`, `GPIOB`, `GPIOC`), superceded by `I2C1_SCL_BANK`, `I2C1_SDA_BANK` | `GPIOB` |
-
-The ChibiOS I2C driver configuration depends on STM32 MCU:
-
-    STM32F1xx, STM32F2xx, STM32F4xx, STM32L0xx and STM32L1xx use I2Cv1;
-    STM32F0xx, STM32F3xx, STM32F7xx and STM32L4xx use I2Cv2;
-
-#### I2Cv1
-STM32 MCUs allow for different clock and duty parameters when configuring I2Cv1. These can be modified using the following parameters, using <https://www.playembedded.org/blog/stm32-i2c-chibios/#I2Cv1_configuration_structure> as a reference:
-
-| Variable           | Default          |
-|--------------------|------------------|
-| `I2C1_OPMODE`      | `OPMODE_I2C`     |
-| `I2C1_CLOCK_SPEED` | `100000`         |
-| `I2C1_DUTY_CYCLE`  | `STD_DUTY_CYCLE` |
-
-#### I2Cv2
-STM32 MCUs allow for different timing parameters when configuring I2Cv2. These can be modified using the following parameters, using <https://www.st.com/en/embedded-software/stsw-stm32126.html> as a reference:
-
-| Variable              | Default |
-|-----------------------|---------|
-| `I2C1_TIMINGR_PRESC`  | `15U`   |
-| `I2C1_TIMINGR_SCLDEL` | `4U`    |
-| `I2C1_TIMINGR_SDADEL` | `2U`    |
-| `I2C1_TIMINGR_SCLH`   | `15U`   |
-| `I2C1_TIMINGR_SCLL`   | `21U`   |
-
-STM32 MCUs allow for different "alternate function" modes when configuring GPIO pins. These are required to switch the pins used to I2Cv2 mode. See the respective datasheet for the appropriate values for your MCU.
-
-| Variable            | Default |
-|---------------------|---------|
-| `I2C1_SCL_PAL_MODE` | `4`     |
-| `I2C1_SDA_PAL_MODE` | `4`     |
-
-#### Other
-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:
+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:
 
 ```C
 void i2c_init(void)
 {
   setPinInput(B6); // Try releasing special pins for a short time
   setPinInput(B7);
-  wait_ms(10); // Wait for the release to happen
+  chThdSleepMilliseconds(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
 }
 ```
+
+

docs/index.html

@@ -5,13 +5,7 @@
   <title>QMK Firmware</title>
   <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
   <meta name="description" content="Description">
-  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">  
-  <meta property="og:title" content="QMK Firmware Docs">
-  <meta property="og:type" content="website">
-  <meta property="og:description" content="The full documentation of the open-source firmware">
-  <meta property="og:image" content="https://i.imgur.com/svjvIrw.jpg">
-  <meta property="og:url" content="https://docs.qmk.fm">
-  <meta name="twitter:card" content="summary_large_image">
+  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
   <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/vue.css" title="light">
   <link rel="stylesheet" href="qmk.css" title="dark" disabled>
   <link rel="stylesheet" href="sidebar.css" />
@@ -23,7 +17,7 @@
       name: 'QMK Firmware',
       nameLink: 'https://qmk.fm/',
       repo: 'qmk/qmk_firmware',
-      loadSidebar: '_summary.md',
+      loadSidebar: true,
       auto2top: true,
       formatUpdated: '{YYYY}/{MM}/{DD} {HH}:{mm}',
       search: {
@@ -31,8 +25,7 @@
         placeholder: 'Search Documentation...',
         noData: 'We could not find any documents matching your search.',
         depth: 6
-      },
-      fallbackLanguages: ['zh']
+      }
     }
   </script>
   <script src="//unpkg.com/docsify/lib/docsify.min.js"></script>

docs/internals_gpio_control.md

@@ -1,6 +1,6 @@
 # GPIO Control
 
-QMK has a GPIO control abstraction layer which is microcontroller agnostic. This is done to allow easy access to pin control across different platforms.
+QMK has a GPIO control abstraction layer which is micro-controller agnostic. This is done to allow easy access to pin control across different platforms.
 
 ## Functions
 
@@ -17,7 +17,7 @@ The following functions can provide basic control of GPIOs and are found in `qua
 |`writePin(pin, level)`|Set pin level, assuming it is an output                           |
 |`readPin(pin)`        |Returns the level of the pin                                      |
 
-## Advanced Settings
+## Advance settings
 
-Each microcontroller can have multiple advanced settings regarding its GPIO. This abstraction layer does not limit the use of architecture-specific functions. Advanced users should consult the datasheet of their desired device and include any needed libraries. For AVR, the standard avr/io.h library is used; for STM32, the ChibiOS [PAL library](http://chibios.sourceforge.net/docs3/hal/group___p_a_l.html) is used.
+Each micro-controller can have multiple advance settings regarding its GPIO. This abstraction layer does not limit the use of architecture specific functions. Advance users should consult the datasheet of there desired device and include any needed libraries. For AVR the standard avr/io.h library is used and for STM32 the Chibios [PAL library](http://chibios.sourceforge.net/docs3/hal/group___p_a_l.html) is used.
 

docs/isp_flashing_guide.md

@@ -53,7 +53,7 @@ This is pretty straight-forward - we'll be connecting like-things to like-things
 The only difference between the .hex files below is which pin is connected to RESET. You can use them on other boards as well, as long as you're aware of the pins being used. If for some reason neither of these pins are available, [create an issue](https://github.com/qmk/qmk_firmware/issues/new), and we can generate one for you!
 
 * Teensy 2.0: [`util/teensy_2.0_ISP_B0.hex`](https://github.com/qmk/qmk_firmware/blob/master/util/teensy_2.0_ISP_B0.hex) (`B0`)
-* Pro Micro: [`util/pro_micro_ISP_B6_10.hex`](https://github.com/qmk/qmk_firmware/blob/master/util/pro_micro_ISP_B6_10.hex) (`B6/10`)
+* Pro Micro: [`util/pro_micro_ISP_B6_10.hex`](https://github.com/qmk/qmk_firmware/blob/master/util/pro_mico_ISP_B6_10.hex) (`B6/10`)
 
 **Flash your Teenys/Pro Micro with one of these and continue - you won't need the file after flashing your ISP device.**
 
@@ -63,7 +63,6 @@ If you just want to get things back to normal, you can flash only a bootloader f
 
 * [`atmega32u4`](https://github.com/qmk/qmk_firmware/blob/master/util/bootloader_atmega32u4_1_0_0.hex) - Most keyboards, Planck Rev 1-5, Preonic Rev 1-2
 * [`at90usb1286`](https://github.com/qmk/qmk_firmware/blob/master/util/bootloader_at90usb128x_1_0_1.hex) - Planck Light Rev 1
-* [`atmega32a`](https://github.com/qmk/qmk_firmware/blob/master/util/bootloader_atmega32a_1_0_0.hex) - jj40
 
 If you're not sure what your board uses, look in the `rules.mk` file for the keyboard in QMK. The `MCU =` line will have the value you need. It may differ between different versions of the board.
 
@@ -114,10 +113,6 @@ Since our keyboard uses an `atmega32u4` (common), that is the chip we'll specify
 
     avrdude -c avrisp -P COM3 -p atmega32u4 -U flash:w:main.hex:i
 
-If your board uses an `atmega32a` (e.g. on a jj40), the command is this (the extra code at the end sets the fuses correctly):
-
-	avrdude -c avrisp -P COM3 -p atmega32 -U flash:w:main.hex:i -U hfuse:w:0xD0:m -U lfuse:w:0x0F:m
-
 You should see a couple of progress bars, then you should see:
 
     avrdude: verifying ...

docs/keycode.txt

@@ -0,0 +1,261 @@
+Keycode Symbol Table
+====================
+Keycodes are defined in `common/keycode.h`.
+Range of 00-A4 and E0-E7 are identical with HID Usage:
+<http://www.usb.org/developers/hidpage/Hut1_12v2.pdf>
+Virtual keycodes are defined out of above range to support special actions.
+
+
+Keycode Symbol      Short name      Description
+--------------------------------------------------------------------------------
+KC_NO                               00 Reserved (no event indicated)
+KC_ROLL_OVER                        01 Keyboard ErrorRollOver
+KC_POST_FAIL                        02 Keyboard POSTFail
+KC_UNDEFINED                        03 Keyboard ErrorUndefined
+KC_A                                04 Keyboard a and A
+KC_B                                05 Keyboard b and B
+KC_C                                06 Keyboard c and C
+KC_D                                07 Keyboard d and D
+KC_E                                08 Keyboard e and E
+KC_F                                09 Keyboard f and F
+KC_G                                0A Keyboard g and G
+KC_H                                0B Keyboard h and H
+KC_I                                0C Keyboard i and I
+KC_J                                0D Keyboard j and J
+KC_K                                0E Keyboard k and K
+KC_L                                0F Keyboard l and L
+KC_M                                10 Keyboard m and M
+KC_N                                11 Keyboard n and N
+KC_O                                12 Keyboard o and O
+KC_P                                13 Keyboard p and P
+KC_Q                                14 Keyboard q and Q
+KC_R                                15 Keyboard r and R
+KC_S                                16 Keyboard s and S
+KC_T                                17 Keyboard t and T
+KC_U                                18 Keyboard u and U
+KC_V                                19 Keyboard v and V
+KC_W                                1A Keyboard w and W
+KC_X                                1B Keyboard x and X
+KC_Y                                1C Keyboard y and Y
+KC_Z                                1D Keyboard z and Z
+KC_1                                1E Keyboard 1 and !
+KC_2                                1F Keyboard 2 and @
+KC_3                                20 Keyboard 3 and #
+KC_4                                21 Keyboard 4 and $
+KC_5                                22 Keyboard 5 and %
+KC_6                                23 Keyboard 6 and ^
+KC_7                                24 Keyboard 7 and &
+KC_8                                25 Keyboard 8 and *
+KC_9                                26 Keyboard 9 and (
+KC_0                                27 Keyboard 0 and )
+KC_ENTER            KC_ENT          28 Keyboard Return (ENTER)
+KC_ESCAPE           KC_ESC          29 Keyboard ESCAPE
+KC_BSPACE           KC_BSPC         2A Keyboard DELETE (Backspace)
+KC_TAB                              2B Keyboard Tab
+KC_SPACE            KC_SPC          2C Keyboard Spacebar
+KC_MINUS            KC_MINS         2D Keyboard - and (underscore)
+KC_EQUAL            KC_EQL          2E Keyboard = and +
+KC_LBRACKET         KC_LBRC         2F Keyboard [ and {
+KC_RBRACKET         KC_RBRC         30 Keyboard ] and }
+KC_BSLASH           KC_BSLS         31 Keyboard \ and |
+KC_NONUS_HASH       KC_NUHS         32 Keyboard Non-US # and ~
+KC_SCOLON           KC_SCLN         33 Keyboard ; and :
+KC_QUOTE            KC_QUOT         34 Keyboard ‘ and “
+KC_GRAVE            KC_GRV          35 Keyboard Grave Accent and Tilde
+KC_COMMA            KC_COMM         36 Keyboard , and <
+KC_DOT                              37 Keyboard . and >
+KC_SLASH            KC_SLSH         38 Keyboard / and ?
+KC_CAPSLOCK         KC_CAPS         39 Keyboard Caps Lock
+KC_F1                               3A Keyboard F1
+KC_F2                               3B Keyboard F2
+KC_F3                               3C Keyboard F3
+KC_F4                               3D Keyboard F4
+KC_F5                               3E Keyboard F5
+KC_F6                               3F Keyboard F6
+KC_F7                               40 Keyboard F7
+KC_F8                               41 Keyboard F8
+KC_F9                               42 Keyboard F9
+KC_F10                              43 Keyboard F10
+KC_F11                              44 Keyboard F11
+KC_F12                              45 Keyboard F12
+KC_PSCREEN          KC_PSCR         46 Keyboard PrintScreen
+KC_SCROLLLOCK       KC_SLCK         47 Keyboard Scroll Lock
+KC_PAUSE            KC_PAUS         48 Keyboard Pause
+KC_INSERT           KC_INS          49 Keyboard Insert
+KC_HOME                             4A Keyboard Home
+KC_PGUP                             4B Keyboard PageUp
+KC_DELETE           KC_DEL          4C Keyboard Delete Forward
+KC_END                              4D Keyboard End
+KC_PGDOWN           KC_PGDN         4E Keyboard PageDown
+KC_RIGHT            KC_RGHT         4F Keyboard RightArrow
+KC_LEFT                             50 Keyboard LeftArrow
+KC_DOWN                             51 Keyboard DownArrow
+KC_UP                               52 Keyboard UpArrow
+KC_NUMLOCK          KC_NLCK         53 Keypad Num Lock and Clear
+KC_KP_SLASH         KC_PSLS         54 Keypad /
+KC_KP_ASTERISK      KC_PAST         55 Keypad *
+KC_KP_MINUS         KC_PMNS         56 Keypad -
+KC_KP_PLUS          KC_PPLS         57 Keypad +
+KC_KP_ENTER         KC_PENT         58 Keypad ENTER
+KC_KP_1             KC_P1           59 Keypad 1 and End
+KC_KP_2             KC_P2           5A Keypad 2 and Down Arrow
+KC_KP_3             KC_P3           5B Keypad 3 and PageDn
+KC_KP_4             KC_P4           5C Keypad 4 and Left Arrow
+KC_KP_5             KC_P5           5D Keypad 5
+KC_KP_6             KC_P6           5E Keypad 6 and Right Arrow
+KC_KP_7             KC_P7           5F Keypad 7 and Home
+KC_KP_8             KC_P8           60 Keypad 8 and Up Arrow
+KC_KP_9             KC_P9           61 Keypad 9 and PageUp
+KC_KP_0             KC_P0           62 Keypad 0 and Insert
+KC_KP_DOT           KC_PDOT         63 Keypad . and Delete
+KC_NONUS_BSLASH     KC_NUBS         64 Keyboard Non-US \ and |
+KC_APPLICATION      KC_APP          65 Keyboard Application
+KC_POWER                            66 Keyboard Power
+KC_KP_EQUAL         KC_PEQL         67 Keypad =
+KC_F13                              68 Keyboard F13
+KC_F14                              69 Keyboard F14
+KC_F15                              6A Keyboard F15
+KC_F16                              6B Keyboard F16
+KC_F17                              6C Keyboard F17
+KC_F18                              6D Keyboard F18
+KC_F19                              6E Keyboard F19
+KC_F20                              6F Keyboard F20
+KC_F21                              70 Keyboard F21
+KC_F22                              71 Keyboard F22
+KC_F23                              72 Keyboard F23
+KC_F24                              73 Keyboard F24
+KC_EXECUTE                          74 Keyboard Execute
+KC_HELP                             75 Keyboard Help
+KC_MENU                             76 Keyboard Menu
+KC_SELECT                           77 Keyboard Select
+KC_STOP                             78 Keyboard Stop
+KC_AGAIN                            79 Keyboard Again
+KC_UNDO                             7A Keyboard Undo
+KC_CUT                              7B Keyboard Cut
+KC_COPY                             7C Keyboard Copy
+KC_PASTE                            7D Keyboard Paste
+KC_FIND                             7E Keyboard Find
+KC__MUTE                            7F Keyboard Mute
+KC__VOLUP                           80 Keyboard Volume Up
+KC__VOLDOWN                         81 Keyboard Volume Down
+KC_LOCKING_CAPS                     82 Keyboard Locking Caps Lock
+KC_LOCKING_NUM                      83 Keyboard Locking Num Lock
+KC_LOCKING_SCROLL                   84 Keyboard Locking Scroll Lock
+KC_KP_COMMA         KC_PCMM         85 Keypad Comma
+KC_KP_EQUAL_AS400                   86 Keypad Equal Sign
+KC_INT1             KC_RO           87 Keyboard International115
+KC_INT2             KC_KANA         88 Keyboard International216
+KC_INT3             KC_JYEN         89 Keyboard International317
+KC_INT4             KC_HENK         8A Keyboard International418
+KC_INT5             KC_MHEN         8B Keyboard International519
+KC_INT6                             8C Keyboard International620
+KC_INT7                             8D Keyboard International721
+KC_INT8                             8E Keyboard International822
+KC_INT9                             8F Keyboard International922
+KC_LANG1                            90 Keyboard LANG125
+KC_LANG2                            91 Keyboard LANG226
+KC_LANG3                            92 Keyboard LANG330
+KC_LANG4                            93 Keyboard LANG431
+KC_LANG5                            94 Keyboard LANG532
+KC_LANG6                            95 Keyboard LANG68
+KC_LANG7                            96 Keyboard LANG78
+KC_LANG8                            97 Keyboard LANG88
+KC_LANG9                            98 Keyboard LANG98
+KC_ALT_ERASE                        99 Keyboard Alternate Erase
+KC_SYSREQ                           9A Keyboard SysReq/Attention
+KC_CANCEL                           9B Keyboard Cancel
+KC_CLEAR                            9C Keyboard Clear
+KC_PRIOR                            9D Keyboard Prior
+KC_RETURN                           9E Keyboard Return
+KC_SEPARATOR                        9F Keyboard Separator
+KC_OUT                              A0 Keyboard Out
+KC_OPER                             A1 Keyboard Oper
+KC_CLEAR_AGAIN                      A2 Keyboard Clear/Again
+KC_CRSEL                            A3 Keyboard CrSel/Props
+KC_EXSEL                            A4 Keyboard ExSel
+/* Modifiers */
+KC_LCTRL            KC_LCTL         E0 Keyboard LeftControl
+KC_LSHIFT           KC_LSFT         E1 Keyboard LeftShift
+KC_LALT                             E2 Keyboard LeftAlt
+KC_LGUI                             E3 Keyboard Left GUI(Windows/Apple/Meta key)
+KC_RCTRL            KC_RCTL         E4 Keyboard RightControl
+KC_RSHIFT           KC_RSFT         E5 Keyboard RightShift
+KC_RALT                             E6 Keyboard RightAlt
+KC_RGUI                             E7 Keyboard Right GUI(Windows/Apple/Meta key)
+
+/*
+ * Virtual keycodes
+ */
+/* System Control */
+KC_SYSTEM_POWER     KC_PWR          System Power Down
+KC_SYSTEM_SLEEP     KC_SLEP         System Sleep
+KC_SYSTEM_WAKE      KC_WAKE         System Wake
+/* Consumer Page */
+KC_AUDIO_MUTE       KC_MUTE
+KC_AUDIO_VOL_UP     KC_VOLU
+KC_AUDIO_VOL_DOWN   KC_VOLD
+KC_MEDIA_NEXT_TRACK KC_MNXT
+KC_MEDIA_PREV_TRACK KC_MPRV
+KC_MEDIA_STOP       KC_MSTP
+KC_MEDIA_PLAY_PAUSE KC_MPLY
+KC_MEDIA_SELECT     KC_MSEL
+KC_MAIL             KC_MAIL
+KC_CALCULATOR       KC_CALC
+KC_MY_COMPUTER      KC_MYCM
+KC_WWW_SEARCH       KC_WSCH
+KC_WWW_HOME         KC_WHOM
+KC_WWW_BACK         KC_WBAK
+KC_WWW_FORWARD      KC_WFWD
+KC_WWW_STOP         KC_WSTP
+KC_WWW_REFRESH      KC_WREF
+KC_WWW_FAVORITES    KC_WFAV
+/* Mousekey */
+KC_MS_UP            KC_MS_U         Mouse Cursor Up
+KC_MS_DOWN          KC_MS_D         Mouse Cursor Down
+KC_MS_LEFT          KC_MS_L         Mouse Cursor Left
+KC_MS_RIGHT         KC_MS_R         Mouse Cursor Right
+KC_MS_BTN1          KC_BTN1         Mouse Button 1
+KC_MS_BTN2          KC_BTN2         Mouse Button 2
+KC_MS_BTN3          KC_BTN3         Mouse Button 3
+KC_MS_BTN4          KC_BTN4         Mouse Button 4
+KC_MS_BTN5          KC_BTN5         Mouse Button 5
+KC_MS_WH_UP         KC_WH_U         Mouse Wheel Up
+KC_MS_WH_DOWN       KC_WH_D         Mouse Wheel Down
+KC_MS_WH_LEFT       KC_WH_L         Mouse Wheel Left
+KC_MS_WH_RIGHT      KC_WH_R         Mouse Wheel Right
+KC_MS_ACCEL0        KC_ACL0         Mouse Acceleration 0
+KC_MS_ACCEL1        KC_ACL1         Mouse Acceleration 1
+KC_MS_ACCEL2        KC_ACL2         Mouse Acceleration 2
+/* Fn key */
+KC_FN0
+KC_FN1
+KC_FN2
+KC_FN3
+KC_FN4
+KC_FN5
+KC_FN6
+KC_FN7
+KC_FN8
+KC_FN9
+KC_FN10
+KC_FN11
+KC_FN12
+KC_FN13
+KC_FN14
+KC_FN15
+KC_FN16
+KC_FN17
+KC_FN18
+KC_FN19
+KC_FN20
+KC_FN21
+KC_FN22
+KC_FN23
+KC_FN24
+KC_FN25
+KC_FN26
+KC_FN27
+KC_FN28
+KC_FN29
+KC_FN30
+KC_FN31

docs/keycodes.md

@@ -6,234 +6,226 @@ This is a reference only. Each group of keys links to the page documenting their
 
 ## [Basic Keycodes](keycodes_basic.md)
 
-|Key                    |Aliases                       |Description                                    |
-|-----------------------|------------------------------|-----------------------------------------------|
-|`KC_NO`                |`XXXXXXX`                     |Ignore this key (NOOP)                         |
-|`KC_TRANSPARENT`       |`KC_TRNS`, `_______`          |Use the next lowest non-transparent key        |
-|`KC_A`                 |                              |`a` and `A`                                    |
-|`KC_B`                 |                              |`b` and `B`                                    |
-|`KC_C`                 |                              |`c` and `C`                                    |
-|`KC_D`                 |                              |`d` and `D`                                    |
-|`KC_E`                 |                              |`e` and `E`                                    |
-|`KC_F`                 |                              |`f` and `F`                                    |
-|`KC_G`                 |                              |`g` and `G`                                    |
-|`KC_H`                 |                              |`h` and `H`                                    |
-|`KC_I`                 |                              |`i` and `I`                                    |
-|`KC_J`                 |                              |`j` and `J`                                    |
-|`KC_K`                 |                              |`k` and `K`                                    |
-|`KC_L`                 |                              |`l` and `L`                                    |
-|`KC_M`                 |                              |`m` and `M`                                    |
-|`KC_N`                 |                              |`n` and `N`                                    |
-|`KC_O`                 |                              |`o` and `O`                                    |
-|`KC_P`                 |                              |`p` and `P`                                    |
-|`KC_Q`                 |                              |`q` and `Q`                                    |
-|`KC_R`                 |                              |`r` and `R`                                    |
-|`KC_S`                 |                              |`s` and `S`                                    |
-|`KC_T`                 |                              |`t` and `T`                                    |
-|`KC_U`                 |                              |`u` and `U`                                    |
-|`KC_V`                 |                              |`v` and `V`                                    |
-|`KC_W`                 |                              |`w` and `W`                                    |
-|`KC_X`                 |                              |`x` and `X`                                    |
-|`KC_Y`                 |                              |`y` and `Y`                                    |
-|`KC_Z`                 |                              |`z` and `Z`                                    |
-|`KC_1`                 |                              |`1` and `!`                                    |
-|`KC_2`                 |                              |`2` and `@`                                    |
-|`KC_3`                 |                              |`3` and `#`                                    |
-|`KC_4`                 |                              |`4` and `$`                                    |
-|`KC_5`                 |                              |`5` and `%`                                    |
-|`KC_6`                 |                              |`6` and `^`                                    |
-|`KC_7`                 |                              |`7` and `&`                                    |
-|`KC_8`                 |                              |`8` and `*`                                    |
-|`KC_9`                 |                              |`9` and `(`                                    |
-|`KC_0`                 |                              |`0` and `)`                                    |
-|`KC_ENTER`             |`KC_ENT`                      |Return (Enter)                                 |
-|`KC_ESCAPE`            |`KC_ESC`                      |Escape                                         |
-|`KC_BSPACE`            |`KC_BSPC`                     |Delete (Backspace)                             |
-|`KC_TAB`               |                              |Tab                                            |
-|`KC_SPACE`             |`KC_SPC`                      |Spacebar                                       |
-|`KC_MINUS`             |`KC_MINS`                     |`-` and `_`                                    |
-|`KC_EQUAL`             |`KC_EQL`                      |`=` and `+`                                    |
-|`KC_LBRACKET`          |`KC_LBRC`                     |`[` and `{`                                    |
-|`KC_RBRACKET`          |`KC_RBRC`                     |`]` and `}`                                    |
-|`KC_BSLASH`            |`KC_BSLS`                     |`\` and <code>&#124;</code>                    |
-|`KC_NONUS_HASH`        |`KC_NUHS`                     |Non-US `#` and `~`                             |
-|`KC_SCOLON`            |`KC_SCLN`                     |`;` and `:`                                    |
-|`KC_QUOTE`             |`KC_QUOT`                     |`'` and `"`                                    |
-|`KC_GRAVE`             |`KC_GRV`, `KC_ZKHK`           |<code>&#96;</code> and `~`, JIS Zenkaku/Hankaku|
-|`KC_COMMA`             |`KC_COMM`                     |`,` and `<`                                    |
-|`KC_DOT`               |                              |`.` and `>`                                    |
-|`KC_SLASH`             |`KC_SLSH`                     |`/` and `?`                                    |
-|`KC_CAPSLOCK`          |`KC_CLCK`, `KC_CAPS`          |Caps Lock                                      |
-|`KC_F1`                |                              |F1                                             |
-|`KC_F2`                |                              |F2                                             |
-|`KC_F3`                |                              |F3                                             |
-|`KC_F4`                |                              |F4                                             |
-|`KC_F5`                |                              |F5                                             |
-|`KC_F6`                |                              |F6                                             |
-|`KC_F7`                |                              |F7                                             |
-|`KC_F8`                |                              |F8                                             |
-|`KC_F9`                |                              |F9                                             |
-|`KC_F10`               |                              |F10                                            |
-|`KC_F11`               |                              |F11                                            |
-|`KC_F12`               |                              |F12                                            |
-|`KC_PSCREEN`           |`KC_PSCR`                     |Print Screen                                   |
-|`KC_SCROLLLOCK`        |`KC_SLCK`, `KC_BRMD`          |Scroll Lock, Brightness Down (macOS)           |
-|`KC_PAUSE`             |`KC_PAUS`, `KC_BRK`, `KC_BRMU`|Pause, Brightness Up (macOS)                   |
-|`KC_INSERT`            |`KC_INS`                      |Insert                                         |
-|`KC_HOME`              |                              |Home                                           |
-|`KC_PGUP`              |                              |Page Up                                        |
-|`KC_DELETE`            |`KC_DEL`                      |Forward Delete                                 |
-|`KC_END`               |                              |End                                            |
-|`KC_PGDOWN`            |`KC_PGDN`                     |Page Down                                      |
-|`KC_RIGHT`             |`KC_RGHT`                     |Right Arrow                                    |
-|`KC_LEFT`              |                              |Left Arrow                                     |
-|`KC_DOWN`              |                              |Down Arrow                                     |
-|`KC_UP`                |                              |Up Arrow                                       |
-|`KC_NUMLOCK`           |`KC_NLCK`                     |Keypad Num Lock and Clear                      |
-|`KC_KP_SLASH`          |`KC_PSLS`                     |Keypad `/`                                     |
-|`KC_KP_ASTERISK`       |`KC_PAST`                     |Keypad `*`                                     |
-|`KC_KP_MINUS`          |`KC_PMNS`                     |Keypad `-`                                     |
-|`KC_KP_PLUS`           |`KC_PPLS`                     |Keypad `+`                                     |
-|`KC_KP_ENTER`          |`KC_PENT`                     |Keypad Enter                                   |
-|`KC_KP_1`              |`KC_P1`                       |Keypad `1` and End                             |
-|`KC_KP_2`              |`KC_P2`                       |Keypad `2` and Down Arrow                      |
-|`KC_KP_3`              |`KC_P3`                       |Keypad `3` and Page Down                       |
-|`KC_KP_4`              |`KC_P4`                       |Keypad `4` and Left Arrow                      |
-|`KC_KP_5`              |`KC_P5`                       |Keypad `5`                                     |
-|`KC_KP_6`              |`KC_P6`                       |Keypad `6` and Right Arrow                     |
-|`KC_KP_7`              |`KC_P7`                       |Keypad `7` and Home                            |
-|`KC_KP_8`              |`KC_P8`                       |Keypad `8` and Up Arrow                        |
-|`KC_KP_9`              |`KC_P9`                       |Keypad `9` and Page Up                         |
-|`KC_KP_0`              |`KC_P0`                       |Keypad `0` and Insert                          |
-|`KC_KP_DOT`            |`KC_PDOT`                     |Keypad `.` and Delete                          |
-|`KC_NONUS_BSLASH`      |`KC_NUBS`                     |Non-US `\` and <code>&#124;</code>             |
-|`KC_APPLICATION`       |`KC_APP`                      |Application (Windows Menu Key)                 |
-|`KC_POWER`             |                              |System Power (macOS)                           |
-|`KC_KP_EQUAL`          |`KC_PEQL`                     |Keypad `=`                                     |
-|`KC_F13`               |                              |F13                                            |
-|`KC_F14`               |                              |F14                                            |
-|`KC_F15`               |                              |F15                                            |
-|`KC_F16`               |                              |F16                                            |
-|`KC_F17`               |                              |F17                                            |
-|`KC_F18`               |                              |F18                                            |
-|`KC_F19`               |                              |F19                                            |
-|`KC_F20`               |                              |F20                                            |
-|`KC_F21`               |                              |F21                                            |
-|`KC_F22`               |                              |F22                                            |
-|`KC_F23`               |                              |F23                                            |
-|`KC_F24`               |                              |F24                                            |
-|`KC_EXECUTE`           |`KC_EXEC`                     |Execute                                        |
-|`KC_HELP`              |                              |Help                                           |
-|`KC_MENU`              |                              |Menu                                           |
-|`KC_SELECT`            |`KC_SLCT`                     |Select                                         |
-|`KC_STOP`              |                              |Stop                                           |
-|`KC_AGAIN`             |`KC_AGIN`                     |Again                                          |
-|`KC_UNDO`              |                              |Undo                                           |
-|`KC_CUT`               |                              |Cut                                            |
-|`KC_COPY`              |                              |Copy                                           |
-|`KC_PASTE`             |`KC_PSTE`                     |Paste                                          |
-|`KC_FIND`              |                              |Find                                           |
-|`KC__MUTE`             |                              |Mute (macOS)                                   |
-|`KC__VOLUP`            |                              |Volume Up (macOS)                              |
-|`KC__VOLDOWN`          |                              |Volume Down (macOS)                            |
-|`KC_LOCKING_CAPS`      |`KC_LCAP`                     |Locking Caps Lock                              |
-|`KC_LOCKING_NUM`       |`KC_LNUM`                     |Locking Num Lock                               |
-|`KC_LOCKING_SCROLL`    |`KC_LSCR`                     |Locking Scroll Lock                            |
-|`KC_KP_COMMA`          |`KC_PCMM`                     |Keypad `,`                                     |
-|`KC_KP_EQUAL_AS400`    |                              |Keypad `=` on AS/400 keyboards                 |
-|`KC_INT1`              |`KC_RO`                       |JIS `\` and `_`                                |
-|`KC_INT2`              |`KC_KANA`                     |JIS Katakana/Hiragana                          |
-|`KC_INT3`              |`KC_JYEN`                     |JIS `¥` and <code>&#124;</code>                |
-|`KC_INT4`              |`KC_HENK`                     |JIS Henkan                                     |
-|`KC_INT5`              |`KC_MHEN`                     |JIS Muhenkan                                   |
-|`KC_INT6`              |                              |JIS Numpad `,`                                 |
-|`KC_INT7`              |                              |International 7                                |
-|`KC_INT8`              |                              |International 8                                |
-|`KC_INT9`              |                              |International 9                                |
-|`KC_LANG1`             |`KC_HAEN`                     |Hangul/English                                 |
-|`KC_LANG2`             |`KC_HANJ`                     |Hanja                                          |
-|`KC_LANG3`             |                              |JIS Katakana                                   |
-|`KC_LANG4`             |                              |JIS Hiragana                                   |
-|`KC_LANG5`             |                              |JIS Zenkaku/Hankaku                            |
-|`KC_LANG6`             |                              |Language 6                                     |
-|`KC_LANG7`             |                              |Language 7                                     |
-|`KC_LANG8`             |                              |Language 8                                     |
-|`KC_LANG9`             |                              |Language 9                                     |
-|`KC_ALT_ERASE`         |`KC_ERAS`                     |Alternate Erase                                |
-|`KC_SYSREQ`            |                              |SysReq/Attention                               |
-|`KC_CANCEL`            |                              |Cancel                                         |
-|`KC_CLEAR`             |`KC_CLR`                      |Clear                                          |
-|`KC_PRIOR`             |                              |Prior                                          |
-|`KC_RETURN`            |                              |Return                                         |
-|`KC_SEPARATOR`         |                              |Separator                                      |
-|`KC_OUT`               |                              |Out                                            |
-|`KC_OPER`              |                              |Oper                                           |
-|`KC_CLEAR_AGAIN`       |                              |Clear/Again                                    |
-|`KC_CRSEL`             |                              |CrSel/Props                                    |
-|`KC_EXSEL`             |                              |ExSel                                          |
-|`KC_LCTRL`             |`KC_LCTL`                     |Left Control                                   |
-|`KC_LSHIFT`            |`KC_LSFT`                     |Left Shift                                     |
-|`KC_LALT`              |                              |Left Alt                                       |
-|`KC_LGUI`              |`KC_LCMD`, `KC_LWIN`          |Left GUI (Windows/Command/Meta key)            |
-|`KC_RCTRL`             |`KC_RCTL`                     |Right Control                                  |
-|`KC_RSHIFT`            |`KC_RSFT`                     |Right Shift                                    |
-|`KC_RALT`              |`KC_ALGR`                     |Right Alt (AltGr)                              |
-|`KC_RGUI`              |`KC_RCMD`, `KC_RWIN`          |Right GUI (Windows/Command/Meta key)           |
-|`KC_SYSTEM_POWER`      |`KC_PWR`                      |System Power Down                              |
-|`KC_SYSTEM_SLEEP`      |`KC_SLEP`                     |System Sleep                                   |
-|`KC_SYSTEM_WAKE`       |`KC_WAKE`                     |System Wake                                    |
-|`KC_AUDIO_MUTE`        |`KC_MUTE`                     |Mute                                           |
-|`KC_AUDIO_VOL_UP`      |`KC_VOLU`                     |Volume Up                                      |
-|`KC_AUDIO_VOL_DOWN`    |`KC_VOLD`                     |Volume Down                                    |
-|`KC_MEDIA_NEXT_TRACK`  |`KC_MNXT`                     |Next Track (Windows)                           |
-|`KC_MEDIA_PREV_TRACK`  |`KC_MPRV`                     |Previous Track (Windows)                       |
-|`KC_MEDIA_STOP`        |`KC_MSTP`                     |Stop Track (Windows)                           |
-|`KC_MEDIA_PLAY_PAUSE`  |`KC_MPLY`                     |Play/Pause Track                               |
-|`KC_MEDIA_SELECT`      |`KC_MSEL`                     |Launch Media Player (Windows)                  |
-|`KC_MEDIA_EJECT`       |`KC_EJCT`                     |Eject (macOS)                                  |
-|`KC_MAIL`              |                              |Launch Mail (Windows)                          |
-|`KC_CALCULATOR`        |`KC_CALC`                     |Launch Calculator (Windows)                    |
-|`KC_MY_COMPUTER`       |`KC_MYCM`                     |Launch My Computer (Windows)                   |
-|`KC_WWW_SEARCH`        |`KC_WSCH`                     |Browser Search (Windows)                       |
-|`KC_WWW_HOME`          |`KC_WHOM`                     |Browser Home (Windows)                         |
-|`KC_WWW_BACK`          |`KC_WBAK`                     |Browser Back (Windows)                         |
-|`KC_WWW_FORWARD`       |`KC_WFWD`                     |Browser Forward (Windows)                      |
-|`KC_WWW_STOP`          |`KC_WSTP`                     |Browser Stop (Windows)                         |
-|`KC_WWW_REFRESH`       |`KC_WREF`                     |Browser Refresh (Windows)                      |
-|`KC_WWW_FAVORITES`     |`KC_WFAV`                     |Browser Favorites (Windows)                    |
-|`KC_MEDIA_FAST_FORWARD`|`KC_MFFD`                     |Next Track (macOS)                             |
-|`KC_MEDIA_REWIND`      |`KC_MRWD`                     |Previous Track (macOS)                         |
-|`KC_BRIGHTNESS_UP`     |`KC_BRIU`                     |Brightness Up                                  |
-|`KC_BRIGHTNESS_DOWN`   |`KC_BRID`                     |Brightness Down                                |
+|Key                    |Aliases             |Description                                    |
+|-----------------------|--------------------|-----------------------------------------------|
+|`KC_NO`                |`XXXXXXX`           |Ignore this key (NOOP)                         |
+|`KC_TRANSPARENT`       |`KC_TRNS`, `_______`|Use the next lowest non-transparent key        |
+|`KC_A`                 |                    |`a` and `A`                                    |
+|`KC_B`                 |                    |`b` and `B`                                    |
+|`KC_C`                 |                    |`c` and `C`                                    |
+|`KC_D`                 |                    |`d` and `D`                                    |
+|`KC_E`                 |                    |`e` and `E`                                    |
+|`KC_F`                 |                    |`f` and `F`                                    |
+|`KC_G`                 |                    |`g` and `G`                                    |
+|`KC_H`                 |                    |`h` and `H`                                    |
+|`KC_I`                 |                    |`i` and `I`                                    |
+|`KC_J`                 |                    |`j` and `J`                                    |
+|`KC_K`                 |                    |`k` and `K`                                    |
+|`KC_L`                 |                    |`l` and `L`                                    |
+|`KC_M`                 |                    |`m` and `M`                                    |
+|`KC_N`                 |                    |`n` and `N`                                    |
+|`KC_O`                 |                    |`o` and `O`                                    |
+|`KC_P`                 |                    |`p` and `P`                                    |
+|`KC_Q`                 |                    |`q` and `Q`                                    |
+|`KC_R`                 |                    |`r` and `R`                                    |
+|`KC_S`                 |                    |`s` and `S`                                    |
+|`KC_T`                 |                    |`t` and `T`                                    |
+|`KC_U`                 |                    |`u` and `U`                                    |
+|`KC_V`                 |                    |`v` and `V`                                    |
+|`KC_W`                 |                    |`w` and `W`                                    |
+|`KC_X`                 |                    |`x` and `X`                                    |
+|`KC_Y`                 |                    |`y` and `Y`                                    |
+|`KC_Z`                 |                    |`z` and `Z`                                    |
+|`KC_1`                 |                    |`1` and `!`                                    |
+|`KC_2`                 |                    |`2` and `@`                                    |
+|`KC_3`                 |                    |`3` and `#`                                    |
+|`KC_4`                 |                    |`4` and `$`                                    |
+|`KC_5`                 |                    |`5` and `%`                                    |
+|`KC_6`                 |                    |`6` and `^`                                    |
+|`KC_7`                 |                    |`7` and `&`                                    |
+|`KC_8`                 |                    |`8` and `*`                                    |
+|`KC_9`                 |                    |`9` and `(`                                    |
+|`KC_0`                 |                    |`0` and `)`                                    |
+|`KC_ENTER`             |`KC_ENT`            |Return (Enter)                                 |
+|`KC_ESCAPE`            |`KC_ESC`            |Escape                                         |
+|`KC_BSPACE`            |`KC_BSPC`           |Delete (Backspace)                             |
+|`KC_TAB`               |                    |Tab                                            |
+|`KC_SPACE`             |`KC_SPC`            |Spacebar                                       |
+|`KC_MINUS`             |`KC_MINS`           |`-` and `_`                                    |
+|`KC_EQUAL`             |`KC_EQL`            |`=` and `+`                                    |
+|`KC_LBRACKET`          |`KC_LBRC`           |`[` and `{`                                    |
+|`KC_RBRACKET`          |`KC_RBRC`           |`]` and `}`                                    |
+|`KC_BSLASH`            |`KC_BSLS`           |`\` and <code>&#124;</code>                    |
+|`KC_NONUS_HASH`        |`KC_NUHS`           |Non-US `#` and `~`                             |
+|`KC_SCOLON`            |`KC_SCLN`           |`;` and `:`                                    |
+|`KC_QUOTE`             |`KC_QUOT`           |`'` and `"`                                    |
+|`KC_GRAVE`             |`KC_GRV`, `KC_ZKHK` |<code>&#96;</code> and `~`, JIS Zenkaku/Hankaku|
+|`KC_COMMA`             |`KC_COMM`           |`,` and `<`                                    |
+|`KC_DOT`               |                    |`.` and `>`                                    |
+|`KC_SLASH`             |`KC_SLSH`           |`/` and `?`                                    |
+|`KC_CAPSLOCK`          |`KC_CLCK`, `KC_CAPS`|Caps Lock                                      |
+|`KC_F1`                |                    |F1                                             |
+|`KC_F2`                |                    |F2                                             |
+|`KC_F3`                |                    |F3                                             |
+|`KC_F4`                |                    |F4                                             |
+|`KC_F5`                |                    |F5                                             |
+|`KC_F6`                |                    |F6                                             |
+|`KC_F7`                |                    |F7                                             |
+|`KC_F8`                |                    |F8                                             |
+|`KC_F9`                |                    |F9                                             |
+|`KC_F10`               |                    |F10                                            |
+|`KC_F11`               |                    |F11                                            |
+|`KC_F12`               |                    |F12                                            |
+|`KC_PSCREEN`           |`KC_PSCR`           |Print Screen                                   |
+|`KC_SCROLLLOCK`        |`KC_SLCK`           |Scroll Lock                                    |
+|`KC_PAUSE`             |`KC_PAUS`, `KC_BRK` |Pause                                          |
+|`KC_INSERT`            |`KC_INS`            |Insert                                         |
+|`KC_HOME`              |                    |Home                                           |
+|`KC_PGUP`              |                    |Page Up                                        |
+|`KC_DELETE`            |`KC_DEL`            |Forward Delete                                 |
+|`KC_END`               |                    |End                                            |
+|`KC_PGDOWN`            |`KC_PGDN`           |Page Down                                      |
+|`KC_RIGHT`             |`KC_RGHT`           |Right Arrow                                    |
+|`KC_LEFT`              |                    |Left Arrow                                     |
+|`KC_DOWN`              |                    |Down Arrow                                     |
+|`KC_UP`                |                    |Up Arrow                                       |
+|`KC_NUMLOCK`           |`KC_NLCK`           |Keypad Num Lock and Clear                      |
+|`KC_KP_SLASH`          |`KC_PSLS`           |Keypad `/`                                     |
+|`KC_KP_ASTERISK`       |`KC_PAST`           |Keypad `*`                                     |
+|`KC_KP_MINUS`          |`KC_PMNS`           |Keypad `-`                                     |
+|`KC_KP_PLUS`           |`KC_PPLS`           |Keypad `+`                                     |
+|`KC_KP_ENTER`          |`KC_PENT`           |Keypad Enter                                   |
+|`KC_KP_1`              |`KC_P1`             |Keypad `1` and End                             |
+|`KC_KP_2`              |`KC_P2`             |Keypad `2` and Down Arrow                      |
+|`KC_KP_3`              |`KC_P3`             |Keypad `3` and Page Down                       |
+|`KC_KP_4`              |`KC_P4`             |Keypad `4` and Left Arrow                      |
+|`KC_KP_5`              |`KC_P5`             |Keypad `5`                                     |
+|`KC_KP_6`              |`KC_P6`             |Keypad `6` and Right Arrow                     |
+|`KC_KP_7`              |`KC_P7`             |Keypad `7` and Home                            |
+|`KC_KP_8`              |`KC_P8`             |Keypad `8` and Up Arrow                        |
+|`KC_KP_9`              |`KC_P9`             |Keypad `9` and Page Up                         |
+|`KC_KP_0`              |`KC_P0`             |Keypad `0` and Insert                          |
+|`KC_KP_DOT`            |`KC_PDOT`           |Keypad `.` and Delete                          |
+|`KC_NONUS_BSLASH`      |`KC_NUBS`           |Non-US `\` and <code>&#124;</code>             |
+|`KC_APPLICATION`       |`KC_APP`            |Application (Windows Menu Key)                 |
+|`KC_POWER`             |                    |System Power (macOS)                           |
+|`KC_KP_EQUAL`          |`KC_PEQL`           |Keypad `=`                                     |
+|`KC_F13`               |                    |F13                                            |
+|`KC_F14`               |                    |F14                                            |
+|`KC_F15`               |                    |F15                                            |
+|`KC_F16`               |                    |F16                                            |
+|`KC_F17`               |                    |F17                                            |
+|`KC_F18`               |                    |F18                                            |
+|`KC_F19`               |                    |F19                                            |
+|`KC_F20`               |                    |F20                                            |
+|`KC_F21`               |                    |F21                                            |
+|`KC_F22`               |                    |F22                                            |
+|`KC_F23`               |                    |F23                                            |
+|`KC_F24`               |                    |F24                                            |
+|`KC_EXECUTE`           |`KC_EXEC`           |Execute                                        |
+|`KC_HELP`              |                    |Help                                           |
+|`KC_MENU`              |                    |Menu                                           |
+|`KC_SELECT`            |`KC_SLCT`           |Select                                         |
+|`KC_STOP`              |                    |Stop                                           |
+|`KC_AGAIN`             |`KC_AGIN`           |Again                                          |
+|`KC_UNDO`              |                    |Undo                                           |
+|`KC_CUT`               |                    |Cut                                            |
+|`KC_COPY`              |                    |Copy                                           |
+|`KC_PASTE`             |`KC_PSTE`           |Paste                                          |
+|`KC_FIND`              |                    |Find                                           |
+|`KC__MUTE`             |                    |Mute (macOS)                                   |
+|`KC__VOLUP`            |                    |Volume Up (macOS)                              |
+|`KC__VOLDOWN`          |                    |Volume Down (macOS)                            |
+|`KC_LOCKING_CAPS`      |`KC_LCAP`           |Locking Caps Lock                              |
+|`KC_LOCKING_NUM`       |`KC_LNUM`           |Locking Num Lock                               |
+|`KC_LOCKING_SCROLL`    |`KC_LSCR`           |Locking Scroll Lock                            |
+|`KC_KP_COMMA`          |`KC_PCMM`           |Keypad `,`                                     |
+|`KC_KP_EQUAL_AS400`    |                    |Keypad `=` on AS/400 keyboards                 |
+|`KC_INT1`              |`KC_RO`             |JIS `\` and `_`                                |
+|`KC_INT2`              |`KC_KANA`           |JIS Katakana/Hiragana                          |
+|`KC_INT3`              |`KC_JYEN`           |JIS `¥` and <code>&#124;</code>                |
+|`KC_INT4`              |`KC_HENK`           |JIS Henkan                                     |
+|`KC_INT5`              |`KC_MHEN`           |JIS Muhenkan                                   |
+|`KC_INT6`              |                    |JIS Numpad `,`                                 |
+|`KC_INT7`              |                    |International 7                                |
+|`KC_INT8`              |                    |International 8                                |
+|`KC_INT9`              |                    |International 9                                |
+|`KC_LANG1`             |`KC_HAEN`           |Hangul/English                                 |
+|`KC_LANG2`             |`KC_HANJ`           |Hanja                                          |
+|`KC_LANG3`             |                    |JIS Katakana                                   |
+|`KC_LANG4`             |                    |JIS Hiragana                                   |
+|`KC_LANG5`             |                    |JIS Zenkaku/Hankaku                            |
+|`KC_LANG6`             |                    |Language 6                                     |
+|`KC_LANG7`             |                    |Language 7                                     |
+|`KC_LANG8`             |                    |Language 8                                     |
+|`KC_LANG9`             |                    |Language 9                                     |
+|`KC_ALT_ERASE`         |`KC_ERAS`           |Alternate Erase                                |
+|`KC_SYSREQ`            |                    |SysReq/Attention                               |
+|`KC_CANCEL`            |                    |Cancel                                         |
+|`KC_CLEAR`             |`KC_CLR`            |Clear                                          |
+|`KC_PRIOR`             |                    |Prior                                          |
+|`KC_RETURN`            |                    |Return                                         |
+|`KC_SEPARATOR`         |                    |Separator                                      |
+|`KC_OUT`               |                    |Out                                            |
+|`KC_OPER`              |                    |Oper                                           |
+|`KC_CLEAR_AGAIN`       |                    |Clear/Again                                    |
+|`KC_CRSEL`             |                    |CrSel/Props                                    |
+|`KC_EXSEL`             |                    |ExSel                                          |
+|`KC_LCTRL`             |`KC_LCTL`           |Left Control                                   |
+|`KC_LSHIFT`            |`KC_LSFT`           |Left Shift                                     |
+|`KC_LALT`              |                    |Left Alt                                       |
+|`KC_LGUI`              |`KC_LCMD`, `KC_LWIN`|Left GUI (Windows/Command/Meta key)            |
+|`KC_RCTRL`             |`KC_RCTL`           |Right Control                                  |
+|`KC_RSHIFT`            |`KC_RSFT`           |Right Shift                                    |
+|`KC_RALT`              |                    |Right Alt                                      |
+|`KC_RGUI`              |`KC_RCMD`, `KC_RWIN`|Right GUI (Windows/Command/Meta key)           |
+|`KC_SYSTEM_POWER`      |`KC_PWR`            |System Power Down                              |
+|`KC_SYSTEM_SLEEP`      |`KC_SLEP`           |System Sleep                                   |
+|`KC_SYSTEM_WAKE`       |`KC_WAKE`           |System Wake                                    |
+|`KC_AUDIO_MUTE`        |`KC_MUTE`           |Mute                                           |
+|`KC_AUDIO_VOL_UP`      |`KC_VOLU`           |Volume Up                                      |
+|`KC_AUDIO_VOL_DOWN`    |`KC_VOLD`           |Volume Down                                    |
+|`KC_MEDIA_NEXT_TRACK`  |`KC_MNXT`           |Next Track (Windows)                           |
+|`KC_MEDIA_PREV_TRACK`  |`KC_MPRV`           |Previous Track (Windows)                       |
+|`KC_MEDIA_STOP`        |`KC_MSTP`           |Stop Track (Windows)                           |
+|`KC_MEDIA_PLAY_PAUSE`  |`KC_MPLY`           |Play/Pause Track                               |
+|`KC_MEDIA_SELECT`      |`KC_MSEL`           |Launch Media Player (Windows)                  |
+|`KC_MEDIA_EJECT`       |`KC_EJCT`           |Eject (macOS)                                  |
+|`KC_MAIL`              |                    |Launch Mail (Windows)                          |
+|`KC_CALCULATOR`        |`KC_CALC`           |Launch Calculator (Windows)                    |
+|`KC_MY_COMPUTER`       |`KC_MYCM`           |Launch My Computer (Windows)                   |
+|`KC_WWW_SEARCH`        |`KC_WSCH`           |Browser Search (Windows)                       |
+|`KC_WWW_HOME`          |`KC_WHOM`           |Browser Home (Windows)                         |
+|`KC_WWW_BACK`          |`KC_WBAK`           |Browser Back (Windows)                         |
+|`KC_WWW_FORWARD`       |`KC_WFWD`           |Browser Forward (Windows)                      |
+|`KC_WWW_STOP`          |`KC_WSTP`           |Browser Stop (Windows)                         |
+|`KC_WWW_REFRESH`       |`KC_WREF`           |Browser Refresh (Windows)                      |
+|`KC_WWW_FAVORITES`     |`KC_WFAV`           |Browser Favorites (Windows)                    |
+|`KC_MEDIA_FAST_FORWARD`|`KC_MFFD`           |Next Track (macOS)                             |
+|`KC_MEDIA_REWIND`      |`KC_MRWD`           |Previous Track (macOS)                         |
 
 ## [Quantum Keycodes](quantum_keycodes.md#qmk-keycodes)
 
-|Key            |Aliases    |Description                                                          |
-|---------------|-----------|---------------------------------------------------------------------|
-|`RESET`        |           |Put the keyboard into DFU mode for flashing                          |
-|`DEBUG`        |           |Toggle debug mode                                                    |
-|`EEPROM_RESET` |`EEP_RST`  |Resets EEPROM state by reinitializing it                             |
-|`KC_GESC`      |`GRAVE_ESC`|Escape when tapped, <code>&#96;</code> when pressed with Shift or GUI|
-|`KC_LSPO`      |           |Left Shift when held, `(` when tapped                                |
-|`KC_RSPC`      |           |Right Shift when held, `)` when tapped                               |
-|`KC_LCPO`      |           |Left Control when held, `(` when tapped                              |
-|`KC_RCPC`      |           |Right Control when held, `)` when tapped                             |
-|`KC_LAPO`      |           |Left Alt when held, `(` when tapped                                  |
-|`KC_RAPC`      |           |Right Alt when held, `)` when tapped                                 |
-|`KC_SFTENT`    |           |Right Shift when held, Enter when tapped                             |
-|`KC_LEAD`      |           |The [Leader key](feature_leader_key.md)                              |
-|`KC_LOCK`      |           |The [Lock key](feature_key_lock.md)                                  |
-|`FUNC(n)`      |`F(n)`     |Call `fn_action(n)` (deprecated)                                     |
-|`M(n)`         |           |Call macro `n`                                                       |
-|`MACROTAP(n)`  |           |Macro-tap `n` idk FIXME                                              |
+|Key          |Aliases    |Description                                                          |
+|-------------|-----------|---------------------------------------------------------------------|
+|`RESET`      |           |Put the keyboard into DFU mode for flashing                          |
+|`DEBUG`      |           |Toggle debug mode                                                    |
+|`KC_GESC`    |`GRAVE_ESC`|Escape when tapped, <code>&#96;</code> when pressed with Shift or GUI|
+|`KC_LSPO`    |           |Left Shift when held, `(` when tapped                                |
+|`KC_RSPC`    |           |Right Shift when held, `)` when tapped                               |
+|`KC_LEAD`    |           |The [Leader key](feature_leader_key.md)                              |
+|`KC_LOCK`    |           |The [Lock key](feature_key_lock.md)                                  |
+|`FUNC(n)`    |`F(n)`     |Call `fn_action(n)` (deprecated)                                     |
+|`M(n)`       |           |Call macro `n`                                                       |
+|`MACROTAP(n)`|           |Macro-tap `n` idk FIXME                                              |
 
 ## [Audio Keys](feature_audio.md)
 
 |Key             |Aliases  |Description                       |
 |----------------|---------|----------------------------------|
-|`AU_ON`         |         |Turns on Audio Feature            |
-|`AU_OFF`        |         |Turns off Audio Feature           |
-|`AU_TOG`        |         |Toggles Audio state               |
+|`AU_ON`         |         |Audio mode on                     |
+|`AU_OFF`        |         |Audio mode off                    |
+|`AU_TOG`        |         |Toggles Audio mode                |
 |`CLICKY_TOGGLE` |`CK_TOGG`|Toggles Audio clicky mode         |
 |`CLICKY_UP`     |`CK_UP`  |Increases frequency of the clicks |
 |`CLICKY_DOWN`   |`CK_DOWN`|Decreases frequency of the clicks |
@@ -243,6 +235,8 @@ This is a reference only. Each group of keys links to the page documenting their
 |`MU_TOG`        |         |Toggles Music Mode                |
 |`MU_MOD`        |         |Cycles through the music modes    |
 
+
+
 ## [Backlighting](feature_backlight.md)
 
 |Key      |Description                               |
@@ -261,8 +255,6 @@ This is a reference only. Each group of keys links to the page documenting their
 |----------------------------------|---------|------------------------------------|
 |`MAGIC_SWAP_CONTROL_CAPSLOCK`     |         |Swap Caps Lock and Left Control     |
 |`MAGIC_CAPSLOCK_TO_CONTROL`       |         |Treat Caps Lock as Control          |
-|`MAGIC_SWAP_LCTL_LGUI`            |         |Swap Left Control and GUI           |
-|`MAGIC_SWAP_RCTL_RGUI`            |         |Swap Right Control and GUI          |
 |`MAGIC_SWAP_LALT_LGUI`            |         |Swap Left Alt and GUI               |
 |`MAGIC_SWAP_RALT_RGUI`            |         |Swap Right Alt and GUI              |
 |`MAGIC_NO_GUI`                    |         |Disable the GUI key                 |
@@ -270,11 +262,8 @@ This is a reference only. Each group of keys links to the page documenting their
 |`MAGIC_SWAP_BACKSLASH_BACKSPACE`  |         |Swap `\` and Backspace              |
 |`MAGIC_HOST_NKRO`                 |         |Force NKRO on                       |
 |`MAGIC_SWAP_ALT_GUI`              |`AG_SWAP`|Swap Alt and GUI on both sides      |
-|`MAGIC_SWAP_CTL_GUI`              |`CG_SWAP`|Swap Ctrl and GUI on both sides (for macOS)|
 |`MAGIC_UNSWAP_CONTROL_CAPSLOCK`   |         |Unswap Caps Lock and Left Control   |
 |`MAGIC_UNCAPSLOCK_TO_CONTROL`     |         |Stop treating Caps Lock as Control  |
-|`MAGIC_UNSWAP_LCTL_LGUI`          |         |Unswap Left Control and GUI         |
-|`MAGIC_UNSWAP_RCTL_RGUI`          |         |Unswap Right Control and GUI        |
 |`MAGIC_UNSWAP_LALT_LGUI`          |         |Unswap Left Alt and GUI             |
 |`MAGIC_UNSWAP_RALT_RGUI`          |         |Unswap Right Alt and GUI            |
 |`MAGIC_UNNO_GUI`                  |         |Enable the GUI key                  |
@@ -282,10 +271,8 @@ This is a reference only. Each group of keys links to the page documenting their
 |`MAGIC_UNSWAP_BACKSLASH_BACKSPACE`|         |Unswap `\` and Backspace            |
 |`MAGIC_UNHOST_NKRO`               |         |Force NKRO off                      |
 |`MAGIC_UNSWAP_ALT_GUI`            |`AG_NORM`|Unswap Alt and GUI on both sides    |
-|`MAGIC_UNSWAP_CTL_GUI`            |`CG_NORM`|Unswap Ctrl and GUI on both sides      |
-|`MAGIC_TOGGLE_ALT_GUI`            |`AG_TOGG`|Toggle Alt and GUI swap on both sides  |
-|`MAGIC_TOGGLE_CTL_GUI`            |`CG_TOGG`|Toggle Ctrl and GUI swap on both sides |
-|`MAGIC_TOGGLE_NKRO`               |         |Turn NKRO on or off                    |
+|`MAGIC_TOGGLE_ALT_GUI`            |`AG_TOGG`|Toggle Alt and GUI swap on both sides|
+|`MAGIC_TOGGLE_NKRO`               |         |Turn NKRO on or off                 |
 
 ## [Bluetooth](feature_bluetooth.md)
 
@@ -295,18 +282,18 @@ This is a reference only. Each group of keys links to the page documenting their
 |`OUT_USB` |USB only                                      |
 |`OUT_BT`  |Bluetooth only                                |
 
+
 ## [Layer Switching](feature_advanced_keycodes.md#switching-and-toggling-layers)
 
-|Key             |Description                                                                       |
-|----------------|----------------------------------------------------------------------------------|
-|`DF(layer)`     |Set the base (default) layer                                                      |
-|`MO(layer)`     |Momentarily turn on `layer` when pressed (requires `KC_TRNS` on destination layer)|
-|`OSL(layer)`    |Momentarily activates `layer` until a key is pressed. See [One Shot Keys](https://docs.qmk.fm/#/feature_advanced_keycodes?id=one-shot-keys) for details. |
-|`LM(layer, mod)`|Momentarily turn on `layer` (like MO) with `mod` active as well.  Where `mod` is a mods_bit.  Mods can be viewed [here](https://docs.qmk.fm/#/feature_advanced_keycodes?id=mod-tap).  Example Implementation: `LM(LAYER_1, MOD_LALT)`|
-|`LT(layer, kc)` |Turn on `layer` when held, `kc` when tapped                                       |
-|`TG(layer)`     |Toggle `layer` on or off                                                          |
-|`TO(layer)`     |Turns on `layer` and turns off all other layers, except the default layer |
-|`TT(layer)`     |Normally acts like MO unless it's tapped multiple times, which toggles `layer` on |
+|Key         |Description                                                               |
+|-----------------|---------------------------------------------------------------------|
+|`DF(layer)`      |Switches the default layer                                           |
+|`MO(layer)`      |Momentarily activates layer, switches off when you let go            |
+|`LM(layer, mod)` |As `MO(layer)` but with `mod` active                                 |
+|`LT(layer, kc)`  |Momentarily activates layer if held, sends kc if tapped              |
+|`TG(layer)`      |Toggles the layer (enables it if no active, and vise versa)          |
+|`TO(layer)`      |Activates layer and deactivates all other layers                     |
+|`TT(layer)`      |Momentarily activates layer if held, toggles it if tapped repeatedly |
 
 ## [Mouse Keys](feature_mouse_keys.md)
 
@@ -331,44 +318,43 @@ This is a reference only. Each group of keys links to the page documenting their
 
 ## [Modifiers](feature_advanced_keycodes.md#modifier-keys)
 
-|Key       |Aliases                        |Description                                         |
-|----------|-------------------------------|----------------------------------------------------|
-|`LCTL(kc)`|`C(kc)`                        |Hold Left Control and press `kc`                    |
-|`LSFT(kc)`|`S(kc)`                        |Hold Left Shift and press `kc`                      |
-|`LALT(kc)`|`A(kc)`                        |Hold Left Alt and press `kc`                        |
-|`LGUI(kc)`|`G(kc)`, `LCMD(kc)`, `LWIN(kc)`|Hold Left GUI and press `kc`                        |
-|`RCTL(kc)`|                               |Hold Right Control and press `kc`                   |
-|`RSFT(kc)`|                               |Hold Right Shift and press `kc`                     |
-|`RALT(kc)`|`ALGR(kc)`                     |Hold Right Alt and press `kc`                       |
-|`RGUI(kc)`|`RCMD(kc)`, `LWIN(kc)`         |Hold Right GUI and press `kc`                       |
-|`SGUI(kc)`|`SCMD(kc)`, `SWIN(kc)`         |Hold Left Shift and GUI and press `kc`              |
-|`LCA(kc)` |                               |Hold Left Control and Alt and press `kc`            |
-|`LCAG(kc)`|                               |Hold Left Control, Alt and GUI and press `kc`       |
-|`MEH(kc)` |                               |Hold Left Control, Shift and Alt and press `kc`     |
-|`HYPR(kc)`|                               |Hold Left Control, Shift, Alt and GUI and press `kc`|
-|`KC_MEH`  |                               |Left Control, Shift and Alt                         |
-|`KC_HYPR` |                               |Left Control, Shift, Alt and GUI                    |
+|Key       |Aliases               |Description                                         |
+|----------|----------------------|----------------------------------------------------|
+|`KC_HYPR` |                      |Hold Left Control, Shift, Alt and GUI               |
+|`KC_MEH`  |                      |Hold Left Control, Shift and Alt                    |
+|`LCTL(kc)`|                      |Hold Left Control and press `kc`                    |
+|`LSFT(kc)`|`S(kc)`               |Hold Left Shift and press `kc`                      |
+|`LALT(kc)`|                      |Hold Left Alt and press `kc`                        |
+|`LGUI(kc)`|`LCMD(kc)`, `LWIN(kc)`|Hold Left GUI and press `kc`                        |
+|`RCTL(kc)`|                      |Hold Right Control and press `kc`                   |
+|`RSFT(kc)`|                      |Hold Right Shift and press `kc`                     |
+|`RALT(kc)`|                      |Hold Right Alt and press `kc`                       |
+|`RGUI(kc)`|`RCMD(kc)`, `LWIN(kc)`|Hold Right GUI and press `kc`                       |
+|`HYPR(kc)`|                      |Hold Left Control, Shift, Alt and GUI and press `kc`|
+|`MEH(kc)` |                      |Hold Left Control, Shift and Alt and press `kc`     |
+|`LCAG(kc)`|                      |Hold Left Control, Alt and GUI and press `kc`       |
+|`SGUI(kc)`|`SCMD(kc)`, `SWIN(kc)`|Hold Left Shift and GUI and press `kc`              |
+|`LCA(kc)` |                      |Hold Left Control and Alt and press `kc`            |
 
 ## [Mod-Tap Keys](feature_advanced_keycodes.md#mod-tap)
 
-|Key          |Aliases                                                          |Description                                            |
-|-------------|-----------------------------------------------------------------|-------------------------------------------------------|
-|`MT(mod, kc)`|                                                                 |`mod` when held, `kc` when tapped                      |
-|`LCTL_T(kc)` |`CTL_T(kc)`                                                      |Left Control when held, `kc` when tapped               |
-|`LSFT_T(kc)` |`SFT_T(kc)`                                                      |Left Shift when held, `kc` when tapped                 |
-|`LALT_T(kc)` |`ALT_T(kc)`                                                      |Left Alt when held, `kc` when tapped                   |
-|`LGUI_T(kc)` |`LCMD_T(kc)`, `LWIN_T(kc)`, `GUI_T(kc)`, `CMD_T(kc)`, `WIN_T(kc)`|Left GUI when held, `kc` when tapped                   |
-|`RCTL_T(kc)` |                                                                 |Right Control when held, `kc` when tapped              |
-|`RSFT_T(kc)` |                                                                 |Right Shift when held, `kc` when tapped                |
-|`RALT_T(kc)` |`ALGR_T(kc)`                                                     |Right Alt when held, `kc` when tapped                  |
-|`RGUI_T(kc)` |`RCMD_T(kc)`, `RWIN_T(kc)`                                       |Right GUI when held, `kc` when tapped                  |
-|`SGUI_T(kc)` |`SCMD_T(kc)`, `SWIN_T(kc)`                                       |Left Shift and GUI when held, `kc` when tapped         |
-|`LCA_T(kc)`  |                                                                 |Left Control and Alt when held, `kc` when tapped       |
-|`LCAG_T(kc)` |                                                                 |Left Control, Alt and GUI when held, `kc` when tapped  |
-|`RCAG_T(kc)` |                                                                 |Right Control, Alt and GUI when held, `kc` when tapped |
-|`C_S_T(kc)`  |                                                                 |Left Control and Shift when held, `kc` when tapped     |
-|`MEH_T(kc)`  |                                                                 |Left Control, Shift and Alt when held, `kc` when tapped|
-|`HYPR_T(kc)` |`ALL_T(kc)`                                                      |Left Control, Shift, Alt and GUI when held, `kc` when tapped - more info [here](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)|
+|Key         |Aliases                                |Description                                            |
+|------------|---------------------------------------|-------------------------------------------------------|
+|`LCTL_T(kc)`|`CTL_T(kc)`                            |Left Control when held, `kc` when tapped               |
+|`RCTL_T(kc)`|                                       |Right Control when held, `kc` when tapped              |
+|`LSFT_T(kc)`|`SFT_T(kc)`                            |Left Shift when held, `kc` when tapped                 |
+|`RSFT_T(kc)`|                                       |Right Shift when held, `kc` when tapped                |
+|`LALT_T(kc)`|`ALT_T(kc)`                            |Left Alt when held, `kc` when tapped                   |
+|`RALT_T(kc)`|`ALGR_T(kc)`                           |Right Alt when held, `kc` when tapped                  |
+|`LGUI_T(kc)`|`LCMD_T(kc)`, `RWIN_T(kc)`, `GUI_T(kc)`|Left GUI when held, `kc` when tapped                   |
+|`RGUI_T(kc)`|`RCMD_T(kc)`, `RWIN_T(kc)`             |Right GUI when held, `kc` when tapped                  |
+|`C_S_T(kc)` |                                       |Left Control and Shift when held, `kc` when tapped     |
+|`MEH_T(kc)` |                                       |Left Control, Shift and Alt when held, `kc` when tapped|
+|`LCAG_T(kc)`|                                       |Left Control, Alt and GUI when held, `kc` when tapped  |
+|`RCAG_T(kc)`|                                       |Right Control, Alt and GUI when held, `kc` when tapped |
+|`ALL_T(kc)` |                                       |Left Control, Shift, Alt and GUI when held, `kc` when tapped - more info [here](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)|
+|`SGUI_T(kc)`|`SCMD_T(kc)`, `SWIN_T(kc)`             |Left Shift and GUI when held, `kc` when tapped         |
+|`LCA_T(kc)` |                                       |Left Control and Alt when held, `kc` when tapped       |
 
 ## [RGB Lighting](feature_rgblight.md)
 
@@ -442,6 +428,18 @@ This is a reference only. Each group of keys links to the page documenting their
 |`KC_RIGHT_ANGLE_BRACKET`|`KC_RABK`, `KC_GT` |`>`                |
 |`KC_QUESTION`           |`KC_QUES`          |`?`                |
 
+## [Switching and Toggling Layers](feature_advanced_keycodes.md#switching-and-toggling-layers)
+
+|Key             |Description                                                                       |
+|----------------|----------------------------------------------------------------------------------|
+|`LT(layer, kc)` |Turn on `layer` when held, `kc` when tapped                                       |
+|`TO(layer)`     |Turn on `layer` when pressed                                                      |
+|`MO(layer)`     |Momentarily turn on `layer` when pressed (requires `KC_TRNS` on destination layer)|
+|`DF(layer)`     |Set the base (default) layer                                                      |
+|`TG(layer)`     |Toggle `layer` on or off                                                          |
+|`TT(layer)`     |Normally acts like MO unless it's tapped multiple times, which toggles `layer` on |
+|`LM(layer, mod)`|Momentarily turn on `layer` (like MO) with `mod` active as well.                  |
+
 ## [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
 
 |Key         |Description                       |
@@ -449,6 +447,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`OSM(mod)`  |Hold `mod` for one keypress       |
 |`OSL(layer)`|Switch to `layer` for one keypress|
 
+
 ## [Swap Hands](feature_swap_hands.md)
 
 |Key        |Description                                                              |
@@ -463,15 +462,7 @@ This is a reference only. Each group of keys links to the page documenting their
 
 ## [Unicode Support](feature_unicode.md)
 
-|Key                   |Aliases  |Description                                                     |
-|----------------------|---------|----------------------------------------------------------------|
-|`UC(c)`               |         |Send Unicode code point `c`                                     |
-|`X(i)`                |         |Send Unicode code point at index `i` in `unicode_map`           |
-|`XP(i, j)`            |         |Send Unicode code point at index `i`, or `j` if Shift/Caps is on|
-|`UNICODE_MODE_FORWARD`|`UC_MOD` |Cycle through selected input modes                              |
-|`UNICODE_MODE_REVERSE`|`UC_RMOD`|Cycle through selected input modes in reverse                   |
-|`UNICODE_MODE_OSX`    |`UC_M_OS`|Switch to macOS input                                           |
-|`UNICODE_MODE_LNX`    |`UC_M_LN`|Switch to Linux input                                           |
-|`UNICODE_MODE_WIN`    |`UC_M_WI`|Switch to Windows input                                         |
-|`UNICODE_MODE_BSD`    |`UC_M_BS`|Switch to BSD input (not implemented)                           |
-|`UNICODE_MODE_WINC`   |`UC_M_WC`|Switch to Windows input using WinCompose                        |
+|Key         |Aliases|                                                 |
+|------------|-------|-------------------------------------------------|
+|`UNICODE(n)`|`UC(n)`|Send Unicode character `n`                       |
+|`X(n)`      |       |Send Unicode character `n` via a different method|

docs/keycodes_basic.md

@@ -97,14 +97,14 @@ The basic set of keycodes are based on the [HID Keyboard/Keypad Usage Page (0x07
 
 ## Lock Keys
 
-|Key                |Aliases             |Description                         |
-|-------------------|--------------------|------------------------------------|
-|`KC_CAPSLOCK`      |`KC_CLCK`, `KC_CAPS`|Caps Lock                           |
-|`KC_SCROLLLOCK`    |`KC_SLCK`, `KC_BRMD`|Scroll Lock, Brightness Down (macOS)|
-|`KC_NUMLOCK`       |`KC_NLCK`           |Keypad Num Lock and Clear           |
-|`KC_LOCKING_CAPS`  |`KC_LCAP`           |Locking Caps Lock                   |
-|`KC_LOCKING_NUM`   |`KC_LNUM`           |Locking Num Lock                    |
-|`KC_LOCKING_SCROLL`|`KC_LSCR`           |Locking Scroll Lock                 |
+|Key                |Aliases             |Description              |
+|-------------------|--------------------|-------------------------|
+|`KC_CAPSLOCK`      |`KC_CLCK`, `KC_CAPS`|Caps Lock                |
+|`KC_SCROLLLOCK`    |`KC_SLCK`           |Scroll Lock              |
+|`KC_NUMLOCK`       |`KC_NLCK`           |Keypad Num Lock and Clear|
+|`KC_LOCKING_CAPS`  |`KC_LCAP`           |Locking Caps Lock        |
+|`KC_LOCKING_NUM`   |`KC_LNUM`           |Locking Num Lock         |
+|`KC_LOCKING_SCROLL`|`KC_LSCR`           |Locking Scroll Lock      |
 
 ## Modifiers
 
@@ -116,7 +116,7 @@ The basic set of keycodes are based on the [HID Keyboard/Keypad Usage Page (0x07
 |`KC_LGUI`  |`KC_LCMD`, `KC_LWIN`|Left GUI (Windows/Command/Meta key) |
 |`KC_RCTRL` |`KC_RCTL`           |Right Control                       |
 |`KC_RSHIFT`|`KC_RSFT`           |Right Shift                         |
-|`KC_RALT`  |`KC_ALGR`           |Right Alt (AltGr)                   |
+|`KC_RALT`  |                    |Right Alt                           |
 |`KC_RGUI`  |`KC_RCMD`, `KC_RWIN`|Right GUI (Windows/Command/Meta key)|
 
 ## International
@@ -144,48 +144,48 @@ The basic set of keycodes are based on the [HID Keyboard/Keypad Usage Page (0x07
 
 ## Commands
 
-|Key               |Aliases                       |Description                   |
-|------------------|------------------------------|------------------------------|
-|`KC_PSCREEN`      |`KC_PSCR`                     |Print Screen                  |
-|`KC_PAUSE`        |`KC_PAUS`, `KC_BRK`, `KC_BRMU`|Pause, Brightness Up (macOS)  |
-|`KC_INSERT`       |`KC_INS`                      |Insert                        |
-|`KC_HOME`         |                              |Home                          |
-|`KC_PGUP`         |                              |Page Up                       |
-|`KC_DELETE`       |`KC_DEL`                      |Forward Delete                |
-|`KC_END`          |                              |End                           |
-|`KC_PGDOWN`       |`KC_PGDN`                     |Page Down                     |
-|`KC_RIGHT`        |`KC_RGHT`                     |Right Arrow                   |
-|`KC_LEFT`         |                              |Left Arrow                    |
-|`KC_DOWN`         |                              |Down Arrow                    |
-|`KC_UP`           |                              |Up Arrow                      |
-|`KC_APPLICATION`  |`KC_APP`                      |Application (Windows Menu Key)|
-|`KC_POWER`        |                              |System Power (macOS/Linux)    |
-|`KC_EXECUTE`      |`KC_EXEC`                     |Execute                       |
-|`KC_HELP`         |                              |Help                          |
-|`KC_MENU`         |                              |Menu                          |
-|`KC_SELECT`       |`KC_SLCT`                     |Select                        |
-|`KC_STOP`         |                              |Stop                          |
-|`KC_AGAIN`        |`KC_AGIN`                     |Again                         |
-|`KC_UNDO`         |                              |Undo                          |
-|`KC_CUT`          |                              |Cut                           |
-|`KC_COPY`         |                              |Copy                          |
-|`KC_PASTE`        |`KC_PSTE`                     |Paste                         |
-|`KC_FIND`         |                              |Find                          |
-|`KC__MUTE`        |                              |Mute (macOS)                  |
-|`KC__VOLUP`       |                              |Volume Up (macOS)             |
-|`KC__VOLDOWN`     |                              |Volume Down (macOS)           |
-|`KC_ALT_ERASE`    |`KC_ERAS`                     |Alternate Erase               |
-|`KC_SYSREQ`       |                              |SysReq/Attention              |
-|`KC_CANCEL`       |                              |Cancel                        |
-|`KC_CLEAR`        |`KC_CLR`                      |Clear                         |
-|`KC_PRIOR`        |                              |Prior                         |
-|`KC_RETURN`       |                              |Return                        |
-|`KC_SEPARATOR`    |                              |Separator                     |
-|`KC_OUT`          |                              |Out                           |
-|`KC_OPER`         |                              |Oper                          |
-|`KC_CLEAR_AGAIN`  |                              |Clear/Again                   |
-|`KC_CRSEL`        |                              |CrSel/Props                   |
-|`KC_EXSEL`        |                              |ExSel                         |
+|Key               |Aliases            |Description                   |
+|------------------|-------------------|------------------------------|
+|`KC_PSCREEN`      |`KC_PSCR`          |Print Screen                  |
+|`KC_PAUSE`        |`KC_PAUS`, `KC_BRK`|Pause                         |
+|`KC_INSERT`       |`KC_INS`           |Insert                        |
+|`KC_HOME`         |                   |Home                          |
+|`KC_PGUP`         |                   |Page Up                       |
+|`KC_DELETE`       |`KC_DEL`           |Forward Delete                |
+|`KC_END`          |                   |End                           |
+|`KC_PGDOWN`       |`KC_PGDN`          |Page Down                     |
+|`KC_RIGHT`        |`KC_RGHT`          |Right Arrow                   |
+|`KC_LEFT`         |                   |Left Arrow                    |
+|`KC_DOWN`         |                   |Down Arrow                    |
+|`KC_UP`           |                   |Up Arrow                      |
+|`KC_APPLICATION`  |`KC_APP`           |Application (Windows Menu Key)|
+|`KC_POWER`        |                   |System Power (macOS/Linux)    |
+|`KC_EXECUTE`      |`KC_EXEC`          |Execute                       |
+|`KC_HELP`         |                   |Help                          |
+|`KC_MENU`         |                   |Menu                          |
+|`KC_SELECT`       |`KC_SLCT`          |Select                        |
+|`KC_STOP`         |                   |Stop                          |
+|`KC_AGAIN`        |`KC_AGIN`          |Again                         |
+|`KC_UNDO`         |                   |Undo                          |
+|`KC_CUT`          |                   |Cut                           |
+|`KC_COPY`         |                   |Copy                          |
+|`KC_PASTE`        |`KC_PSTE`          |Paste                         |
+|`KC_FIND`         |                   |Find                          |
+|`KC__MUTE`        |                   |Mute (macOS)                  |
+|`KC__VOLUP`       |                   |Volume Up (macOS)             |
+|`KC__VOLDOWN`     |                   |Volume Down (macOS)           |
+|`KC_ALT_ERASE`    |`KC_ERAS`          |Alternate Erase               |
+|`KC_SYSREQ`       |                   |SysReq/Attention              |
+|`KC_CANCEL`       |                   |Cancel                        |
+|`KC_CLEAR`        |`KC_CLR`           |Clear                         |
+|`KC_PRIOR`        |                   |Prior                         |
+|`KC_RETURN`       |                   |Return                        |
+|`KC_SEPARATOR`    |                   |Separator                     |
+|`KC_OUT`          |                   |Out                           |
+|`KC_OPER`         |                   |Oper                          |
+|`KC_CLEAR_AGAIN`  |                   |Clear/Again                   |
+|`KC_CRSEL`        |                   |CrSel/Props                   |
+|`KC_EXSEL`        |                   |ExSel                         |
 
 ## Media Keys
 
@@ -219,8 +219,6 @@ Windows and macOS use different keycodes for "next track" and "previous track".
 |`KC_WWW_FAVORITES`     |`KC_WFAV`|Browser Favorites (Windows)  |
 |`KC_MEDIA_FAST_FORWARD`|`KC_MFFD`|Next Track (macOS)           |
 |`KC_MEDIA_REWIND`      |`KC_MRWD`|Previous Track (macOS)       |
-|`KC_BRIGHTNESS_UP`     |`KC_BRIU`|Brightness Up                |
-|`KC_BRIGHTNESS_DOWN`   |`KC_BRID`|Brightness Down              |
 
 ## Number Pad
 

docs/keymap.md

@@ -1,6 +1,6 @@
 # Keymap Overview
 
-QMK keymaps are defined inside a C source file. The data structure is an array of arrays. The outer array is a list of layer arrays while the inner layer array is a list of keys. Most keyboards define a `LAYOUT()` macro to help you create this array of arrays.
+QMK keymaps are defined inside a C source file. The data structure is an array of arrays. The outer array is a list of layer arrays while the inner layer array is a list of keys. Most keyboards define a `KEYMAP()` macro to help you create this array of arrays.
 
 
 ## Keymap and Layers
@@ -119,7 +119,7 @@ The main part of this file is the `keymaps[]` definition. This is where you list
 
     const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
-After this you'll find a list of LAYOUT() macros. A LAYOUT() is simply a list of keys to define a single layer. Typically you'll have one or more "base layers" (such as QWERTY, Dvorak, or Colemak) and then you'll layer on top of that one or more "function" layers. Due to the way layers are processed you can't overlay a "lower" layer on top of a "higher" layer.
+After this you'll find a list of KEYMAP() macros. A KEYMAP() is simply a list of keys to define a single layer. Typically you'll have one or more "base layers" (such as QWERTY, Dvorak, or Colemak) and then you'll layer on top of that one or more "function" layers. Due to the way layers are processed you can't overlay a "lower" layer on top of a "higher" layer.
 
 `keymaps[][MATRIX_ROWS][MATRIX_COLS]` in QMK holds the 16 bit action code (sometimes referred as the quantum keycode) in it.  For the keycode representing typical keys, its high byte is 0 and its low byte is the USB HID usage ID for keyboard.
 
@@ -131,7 +131,7 @@ Here is an example of the Clueboard's base layer:
 
       /* Keymap _BL: Base Layer (Default Layer)
        */
-    [_BL] = LAYOUT(
+    [_BL] = KEYMAP(
       F(0),    KC_1,    KC_2,   KC_3,   KC_4,   KC_5,   KC_6,   KC_7,   KC_8,   KC_9,    KC_0,     KC_MINS,  KC_EQL,   KC_GRV,  KC_BSPC,          KC_PGUP, \
       KC_TAB,  KC_Q,    KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,   KC_O,    KC_P,     KC_LBRC,  KC_RBRC,  KC_BSLS,                   KC_PGDN, \
       KC_CAPS, KC_A,    KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,    KC_SCLN,  KC_QUOT,  KC_NUHS,  KC_ENT,                             \
@@ -149,7 +149,7 @@ Some interesting things to note about this:
 
 Our function layer is, from a code point of view, no different from the base layer. Conceptually, however, you will build that layer as an overlay, not a replacement. For many people this distinction does not matter, but as you build more complicated layering setups it matters more and more.
 
-    [_FL] = LAYOUT(
+    [_FL] = KEYMAP(
       KC_GRV,  KC_F1,   KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_F6,  KC_F7,  KC_F8,  KC_F9,   KC_F10,   KC_F11,   KC_F12,   _______, KC_DEL,           BL_STEP, \
       _______, _______, _______,_______,_______,_______,_______,_______,KC_PSCR,KC_SLCK, KC_PAUS,  _______,  _______,  _______,                   _______, \
       _______, _______, MO(_CL),_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  _______,                           \
@@ -161,6 +161,62 @@ Some interesting things to note:
 * We have used our `_______` definition to turn `KC_TRNS` into `_______`. This makes it easier to spot the keys that have changed on this layer.
 * While in this layer if you press one of the `_______` keys it will activate the key in the next lowest active layer.
 
+### Custom Functions
+
+At the bottom of the file we've defined a single custom function. This function defines a key that sends `KC_ESC` when pressed without modifiers and `KC_GRAVE` when modifiers are held. There are a couple pieces that need to be in place for this to work, and we will go over both of them.
+
+#### `fn_actions[]`
+
+We define the `fn_actions[]` array to point to custom functions. `F(N)` in a keymap will call element N of that array. For the Clueboard's that looks like this:
+
+    const uint16_t PROGMEM fn_actions[] = {
+      [0] = ACTION_FUNCTION(0),  // Calls action_function()
+    };
+
+In this case we've instructed QMK to call the `ACTION_FUNCTION` callback, which we will define in the next section.
+
+> This `fn_actions[]` interface is mostly for backward compatibility.  In QMK, you don't need to use `fn_actions[]`.  You can directly use `ACTION_FUNCTION(N)` or any other action code value itself normally generated by the macro in `keymaps[][MATRIX_ROWS][MATRIX_COLS]`.  N in `F(N)` can only be 0 to 31.  Use of the action code directly in `keymaps` unlocks this limitation.
+
+You can get a full list of Action Functions in [action_code.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action_code.h). 
+
+#### `action_function()`
+
+To actually handle the keypress event we define an `action_function()`. This function will be called when the key is pressed, and then again when the key is released. We have to handle both situations within our code, as well as determining whether to send/release `KC_ESC` or `KC_GRAVE`.
+
+    void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
+      static uint8_t mods_pressed;
+
+      switch (id) {
+        case 0:
+          /* Handle the combined Grave/Esc key
+           */
+          mods_pressed = get_mods()&GRAVE_MODS; // Check to see what mods are pressed
+
+          if (record->event.pressed) {
+            /* The key is being pressed.
+             */
+            if (mods_pressed) {
+              add_key(KC_GRV);
+              send_keyboard_report();
+            } else {
+              add_key(KC_ESC);
+              send_keyboard_report();
+            }
+          } else {
+            /* The key is being released.
+             */
+            if (mods_pressed) {
+              del_key(KC_GRV);
+              send_keyboard_report();
+            } else {
+              del_key(KC_ESC);
+              send_keyboard_report();
+            }
+          }
+          break;
+      }
+    }
+
 # Nitty Gritty Details
 
 This should have given you a basic overview for creating your own keymap. For more details see the following resources:

docs/newbs.md

@@ -6,18 +6,13 @@ Not sure if your keyboard can run QMK? If it's a mechanical keyboard you built y
 
 ## Overview
 
-There are 7 main sections to this guide:
+There are 5 main sections to this guide:
 
 * [Getting Started](newbs_getting_started.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)
+* [Building Your First Firmware](newbs_building_firmware.md)
 * [Flashing Firmware](newbs_flashing.md)
 * [Testing and Debugging](newbs_testing_debugging.md)
-* [Git Best Practices](newbs_best_practices.md)
+* [Best Practices](newbs_best_practices.md)
 * [Learn More with these Resources](newbs_learn_more_resources.md)
 
 This guide is focused on helping someone who has never compiled software before. It makes choices and recommendations based on that viewpoint. There are alternative methods for many of these procedures, and we support most of those alternatives. If you have any doubt about how to accomplish a task you can [ask us for guidance](getting_started_getting_help.md).
-
-## Additional Resources
-
-* [Thomas Baart's QMK Basics Blog](https://thomasbaart.nl/category/mechanical-keyboards/firmware/qmk/qmk-basics/) – A user-created blog covering the basics of how to use QMK Firmware, as seen from a new user's perspective.

docs/newbs_building_firmware_configurator.md

@@ -1,105 +0,0 @@
-# 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/tx54jkRC9ZY)
-
-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)

docs/newbs_flashing.md

@@ -86,7 +86,7 @@ If you know what bootloader that you're using, then when compiling the firmware,
 
 ### DFU
 
-For the DFU bootloader, when you're ready to compile and flash your firmware, open up your terminal window and run the build command: 
+For the DFU bootloader, when you're ready to compile and flash your firmware, open up your terminal window and run the built command: 
 
     make <my_keyboard>:<my_keymap>:dfu
 
@@ -127,21 +127,13 @@ Once it does this, you'll want to reset the controller.  It should then show out
 >>> dfu-programmer atmega32u4 reset
 ```
 
-?> If you have any issues with this - such as `dfu-programmer: no device present` - please see the [Frequently Asked Build Questions](faq_build.md).
-
-#### DFU commands
-
-There are a number of DFU commands that you can use to flash firmware to a DFU device:
-
-* `:dfu` - This is the normal option and waits until a DFU device is available, and then flashes the firmware. This will check every 5 seconds, to see if a DFU device has appeared.
-* `:dfu-ee` - This flashes an `eep` file instead of the normal hex.  This is uncommon. 
-* `:dfu-split-left` - This flashes the normal firmware, just like the default option (`:dfu`). However, this also flashes the "Left Side" EEPROM file for split keyboards. _This is ideal for Elite C based split keyboards._
-* `:dfu-split-right` - This flashes the normal firmware, just like the default option (`:dfu`). However, this also flashes the "Right Side" EEPROM file for split keyboards. _This is ideal for Elite C based split keyboards._
+If you have any issues with this, you may need to this: 
 
+    sudo make <my_keyboard>:<my_keymap>:dfu
 
 ### Caterina 
 
-For Arduino boards and their clones (such as the SparkFun ProMicro), when you're ready to compile and flash your firmware, open up your terminal window and run the build command: 
+For Arduino boards and their close (such as the SparkFun ProMicro), when you're ready to compile and flash your firmware, open up your terminal window and run the built command: 
 
     make <my_keyboard>:<my_keymap>:avrdude
 
@@ -207,23 +199,15 @@ If you have any issues with this, you may need to this:
 
     sudo make <my_keyboard>:<my_keymap>:avrdude
 
-
-Additionally, if you want to flash multiple boards, use the following command:
-
-    make <keyboard>:<keymap>:avrdude-loop
-
-When you're done flashing boards, you'll need to hit Ctrl + C or whatever the correct keystroke is for your operating system to break the loop.
-
-
 ## HalfKay
 
-For the PJRC devices (Teensy's), when you're ready to compile and flash your firmware, open up your terminal window and run the build command: 
+For the PJRC devices (Teensy's), when you're ready to compile and flash your firmware, open up your terminal window and run the built command: 
 
     make <my_keyboard>:<my_keymap>:teensy
 
 For example, if your keymap is named "xyverz" and you're building a keymap for an Ergodox or Ergodox EZ, you'll use this command:
 
-    make ergodox_ez:xyverz:teensy
+    make erdogox_ez:xyverz:teensy
 
 Once the firmware finishes compiling, it will output something like this: 
 
@@ -242,97 +226,12 @@ Waiting for Teensy device...
 
  ```
  Found HalfKay Bootloader
-Read "./.build/ergodox_ez_xyverz.hex": 28532 bytes, 88.5% usage
+Read "./.build/ergodox_ez_drashna.hex": 28532 bytes, 88.5% usage
 Programming............................................................................................................................................................................
 ...................................................
 Booting
 ```
 
-## BootloadHID
-
-For Bootmapper Client(BMC)/bootloadHID/ATmega32A based boards, when you're ready to compile and flash your firmware, open up your terminal window and run the build command: 
-
-    make <my_keyboard>:<my_keymap>:bootloaderHID
-
-For example, if your keymap is named "xyverz" and you're building a keymap for a jj40, you'll use this command:
-
-    make jj40:xyverz:bootloaderHID
-
-Once the firmware finishes compiling, it will output something like this: 
-
-```
-Linking: .build/jj40_default.elf                                                                   [OK]
-Creating load file for flashing: .build/jj40_default.hex                                           [OK]
-Copying jj40_default.hex to qmk_firmware folder                                                    [OK]
-Checking file size of jj40_default.hex                                                             [OK]
- * The firmware size is fine - 21920/28672 (6752 bytes free)
-```
-
-After it gets to this point, the build script will look for the DFU bootloader every 5 seconds.  It will repeat the following until the device is found or you cancel it. 
-
-```
-Error opening HIDBoot device: The specified device was not found
-Trying again in 5s.
-```
-
-Once it does this, you'll want to reset the controller.  It should then show output similar to this: 
-
-```
-Page size   = 128 (0x80)
-Device size = 32768 (0x8000); 30720 bytes remaining
-Uploading 22016 (0x5600) bytes starting at 0 (0x0)
-0x05580 ... 0x05600
-```
-
-## STM32 (ARM)
-
-For a majority of ARM boards (including the Proton C, Planck Rev 6, and Preonic Rev 3), when you're ready to compile and flash your firmware, open up your terminal window and run the build command: 
-
-    make <my_keyboard>:<my_keymap>:dfu-util
-
-For example, if your keymap is named "xyverz" and you're building a keymap for the Planck Revision 6 keyboard, you'll use this command and then reboot the keyboard to the bootloader (before it finishes compiling):
-
-    make planck/rev6:xyverz:dfu-util
-
-Once the firmware finishes compiling, it will output something like this: 
-
-```
-Linking: .build/planck_rev6_xyverz.elf                                                             [OK]
-Creating binary load file for flashing: .build/planck_rev6_xyverz.bin                               [OK]
-Creating load file for flashing: .build/planck_rev6_xyverz.hex                                     [OK]
-
-Size after:
-   text    data     bss     dec     hex filename
-      0   41820       0   41820    a35c .build/planck_rev6_xyverz.hex
-
-Copying planck_rev6_xyverz.bin to qmk_firmware folder                                              [OK]
-dfu-util 0.9
-
-Copyright 2005-2009 Weston Schmidt, Harald Welte and OpenMoko Inc.
-Copyright 2010-2016 Tormod Volden and Stefan Schmidt
-This program is Free Software and has ABSOLUTELY NO WARRANTY
-Please report bugs to http://sourceforge.net/p/dfu-util/tickets/
-
-Invalid DFU suffix signature
-A valid DFU suffix will be required in a future dfu-util release!!!
-Opening DFU capable USB device...
-ID 0483:df11
-Run-time device DFU version 011a
-Claiming USB DFU Interface...
-Setting Alternate Setting #0 ...
-Determining device status: state = dfuERROR, status = 10
-dfuERROR, clearing status
-Determining device status: state = dfuIDLE, status = 0
-dfuIDLE, continuing
-DFU mode device DFU version 011a
-Device returned transfer size 2048
-DfuSe interface name: "Internal Flash  "
-Downloading to address = 0x08000000, size = 41824
-Download        [=========================] 100%        41824 bytes
-Download done.
-File downloaded successfully
-Transitioning to dfuMANIFEST state
-```
 
 ## Test It Out!
 

docs/newbs_getting_started.md

@@ -6,10 +6,7 @@ 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. 
-
-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). 
-
+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.
 
 ## Download Software
 
@@ -66,10 +63,8 @@ You will need to install Git. It's very likely that you already have it, but if
 
 Once you have set up your Linux/Unix environment, you are ready to download QMK. We will do this by using Git to "clone" the QMK repository. Open a Terminal or MSYS2 MinGW window and leave it open for the remainder of this guide. Inside that window run these two commands:
 
-```shell
-git clone --recurse-submodules https://github.com/qmk/qmk_firmware.git
-cd qmk_firmware
-```
+    git clone https://github.com/qmk/qmk_firmware.git
+    cd qmk_firmware
 
 ?> If you already know [how to use GitHub](getting_started_github.md), we recommend that you create and clone your own fork instead. If you don't know what that means, you can safely ignore this message.
 

docs/newbs_testing_debugging.md

@@ -13,27 +13,9 @@ Note: These programs are not provided by or endorsed by QMK.
 * [Keyboard Tester](http://www.keyboardtester.com) (Web Based)
 * [Keyboard Checker](http://keyboardchecker.com) (Web Based)
 
-## Debugging
+## Debugging With QMK Toolbox
 
-Your keyboard will output debug information if you have `CONSOLE_ENABLE = yes` in your `rules.mk`. By default the output is very limited, but you can turn on debug mode to increase the amount of debug output. Use the `DEBUG` keycode in your keymap, use the [Command](feature_command.md) feature to enable debug mode, or add the following code to your keymap.
-
-```c
-void keyboard_post_init_user(void) {
-  // Customise these values to desired behaviour
-  debug_enable=true;
-  debug_matrix=true;
-  //debug_keyboard=true;
-  //debug_mouse=true;
-}
-```
-
-### Debugging With QMK Toolbox
-
-For compatible platforms, [QMK Toolbox](https://github.com/qmk/qmk_toolbox) can be used to display debug messages from your keyboard.
-
-### Debugging With hid_listen
-
-Prefer a terminal based solution? [hid_listen](https://www.pjrc.com/teensy/hid_listen.html), provided by PJRC, can also be used to display debug messages. Prebuilt binaries for Windows,Linux,and MacOS are available.
+[QMK Toolbox](https://github.com/qmk/qmk_toolbox) will show messages from your keyboard if you have `CONSOLE_ENABLE = yes` in your `rules.mk`. By default the output is very limited, but you can turn on debug mode to increase the amount of debug output. Use the `DEBUG` keycode in your keymap, or use the [Command](feature_command.md) feature to enable debug mode.
 
 <!-- FIXME: Describe the debugging messages here. -->
 
@@ -46,54 +28,6 @@ Sometimes it's useful to print debug messages from within your [custom code](cus
 After that you can use a few different print functions:
 
 * `print("string")`: Print a simple string.
-* `uprintf("%s string", var)`: Print a formatted string
+* `sprintf("%s string", var)`: Print a formatted string
 * `dprint("string")` Print a simple string, but only when debug mode is enabled
 * `dprintf("%s string", var)`: Print a formatted string, but only when debug mode is enabled
-
-## Debug Examples
-
-Below is a collection of real world debugging examples. For additional information, refer to [Debugging/Troubleshooting QMK](faq_debug.md).
-
-### Which matrix position is this keypress?
-
-When porting, or when attempting to diagnose pcb issues, it can be useful to know if a keypress is scanned correctly. To enable logging for this scenario, add the following code to your keymaps `keymap.c`
-
-```c
-bool process_record_user(uint16_t keycode, keyrecord_t *record) {
-  // If console is enabled, it will print the matrix position and status of each key pressed
-#ifdef CONSOLE_ENABLE
-    uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
-#endif 
-  return true;
-}
-```
-
-Example output
-```text
-Waiting for device:.......
-Listening:
-KL: kc: 169, col: 0, row: 0, pressed: 1
-KL: kc: 169, col: 0, row: 0, pressed: 0
-KL: kc: 174, col: 1, row: 0, pressed: 1
-KL: kc: 174, col: 1, row: 0, pressed: 0
-KL: kc: 172, col: 2, row: 0, pressed: 1
-KL: kc: 172, col: 2, row: 0, pressed: 0
-```
-
-### How long did it take to scan for a keypress?
-
-When testing performance issues, it can be useful to know the frequency at which the switch matrix is being scanned. To enable logging for this scenario, add the following code to your keymaps `config.h`
-
-```c
-#define DEBUG_MATRIX_SCAN_RATE
-```
-
-Example output
-```text
-  > matrix scan frequency: 315
-  > matrix scan frequency: 313
-  > matrix scan frequency: 316
-  > matrix scan frequency: 316
-  > matrix scan frequency: 316
-  > matrix scan frequency: 316
-```

docs/other_vscode.md

@@ -1,117 +0,0 @@
-# Setting up Visual Studio Code for QMK Development
-
-[Visual Studio Code](https://code.visualstudio.com/) (VS Code) is an open-source code editor that supports many different programming languages. 
-
-Using a full-featured editor such as VS Code provides many advantages over a plain text editor, such as:
-* intelligent code completion
-* convenient navigation in the code
-* refactoring tools
-* build automation (no need for the command-line)
-* a graphical front end for GIT
-* many other tools such as debugging, code formatting, showing call hierarchies etc.
-
-The purpose of this page is to document how to set up VS Code for developing QMK Firmware.
-
-This guide covers how to configure everything needed on Windows and Ubuntu 18.04
-
-# Set up VS Code
-Before starting, you will want to make sure that you have all of the build tools set up, and QMK Firmware cloned. Head to the the [Newbs Getting Started Guide](newbs_getting_started.md) to get things set up, if you haven't already.
-
-## Windows
-
-### Prerequisites
-
-* [Git for Windows](https://git-scm.com/download/win) (This link will prompt to save/run the installer)
-  
-  1. Disable all of the options but `Git LFS (Large File Support)` and `Check daily for Git for Windows updates`. 
-  2. Set the default editor to `Use Visual Studio Code as Git's default editor`
-  3. Select the `Use Git from Git Bash only` option, since that's the option that you should use here.
-  4. For the `Choosing HTTPS transport backend`, either option should be fine.
-  5. Select the `Checkout as-is, commit Unix-style line endings` option. QMK Firmware uses Unix style commits.
-  6. For the extra options, leave the default options as is. 
-
-  This software is needed for Git support in VS Code. It may be possible to not include this, but it is much simpler to just use this. 
-
-* [Git Credential Manager for Windows](https://github.com/Microsoft/Git-Credential-Manager-for-Windows/releases) (Optional) 
-
-  This software provides better support for Git by providing secure storage for git credentials, MFA and personal access token generation. 
-  
-  This isn't strictly needed, but we would recommend it. 
-
-
-### Installing VS Code
-
-1. Head to [VS Code](https://code.visualstudio.com/) and download the installer
-2. Run the installer
-
-This part is super simple.  However, there is some configuration that we need to do to ensure things are configured correctly.
-
-### Configuring VS Code
-
-First, we need to set up IntelliSense. This isn't strictly required, but it will make your life a LOT easier. To do this, we need to create the `.vscode/c_cpp_properies.json` file in the QMK Firmware folder, You can do this all manually, but I've done most of the work already. 
-
-Grab [this file](https://gist.github.com/drashna/48e2c49ce877be592a1650f91f8473e8) and save it.  You may need to edit this file, if you didn't install MSYS2 to the default location, or are using WSL/LxSS.  
-
-Once you have saved this file, you will need to reload VS Code, if it was already running. 
-
-?> You should see an `extensions.json` and `settings.json` file in the `.vscode` folder, as well.
-
-
-Now, we will set up the MSYS2 window to show up in VSCode as the integrated terminal.  This has a number of advantages. Mostly, you can control+click on errors and jump to those files.  This makes debugging much easier.  It's also nice, in that you don't have to jump to another window. 
-
-1. Click <kbd><kbd>File</kbd> > <kbd>Preferences ></kbd> > <kbd>Settings</kbd> </kbd>
-2. Click on the <kbd>{}</kbd> button, in the top right to open the `settings.json` file. 
-3. Set the file's content to: 
-
-   ```json
-   {
-        "terminal.integrated.shell.windows": "C:\\msys64\\usr\\bin\\bash.exe",
-        "terminal.integrated.env.windows": {
-            "MSYSTEM": "MINGW64",
-            "CHERE_INVOKING": "1"
-        },
-        "terminal.integrated.shellArgs.windows": [
-            "--login"
-        ],
-        "terminal.integrated.cursorStyle": "line"
-    }
-    ```
-
-   If there are settings here already, then just add everything between the first and last curly brackets.  
-
-?> If you installed MSYS2 to a different folder, then you'll need to change the path for `terminal.integrated.shell.windows` to the correct path for your system. 
-
-4. Hit Ctrl-` (grave) to bring up the terminal.  
-
-   This should start the terminal in the workspace's folder (so the `qmk_firmware` folder), and then you can compile your keyboard. 
-
-
-## Every other Operating System
-
-1. Head to [VS Code](https://code.visualstudio.com/) and download the installer
-2. Run the installer
-3. That's it
-
-No, really, that's it.  The paths needed are already included when installing the packages, and it is much better about detecting the current workspace files and parsing them for IntelliSense. 
-
-## Plugins
-
-There are a number of extensions that you may want to install:
-
-* [Git Extension Pack](https://marketplace.visualstudio.com/items?itemName=donjayamanne.git-extension-pack) - 
-This installs a bunch of Git related tools that may make using Git with QMK Firmware easier.
-* [EditorConfig for VS Code](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) - _[Optional]_ -  Helps to keep the code to the QMK Coding Conventions.
-* [Bracket Pair Colorizer 2](https://marketplace.visualstudio.com/items?itemName=CoenraadS.bracket-pair-colorizer-2) - _[Optional]_ - This color codes the brackets in your code, to make it easier to reference nested code.
-* [Github Markdown Preview](https://marketplace.visualstudio.com/items?itemName=bierner.github-markdown-preview) - _[Optional]_ - Makes the markdown preview in VS Code more like GitHub's.
-* [VS Live Share Extension Pack](https://marketplace.visualstudio.com/items?itemName=MS-vsliveshare.vsliveshare-pack) - _[Optional]_ - This extension allows somebody else to access your workspace (or you to access somebody else's workspace) and help out.  This is great if you're having issues and need some help from somebody.
-* [VIM Keymap](https://marketplace.visualstudio.com/items?itemName=GiuseppeCesarano.vim-keymap) - _[Optional]_ - For those that prefer VIM style keybindings. There are other options for this, too. 
-* [Travis CI Status](https://marketplace.visualstudio.com/items?itemName=felixrieseberg.vsc-travis-ci-status) - _[Optional]_ - This shows the current Travis CI status, if you have it set up.
-
-Restart once you've installed any extensions
-
-# Configure VS Code for QMK
-1. Click <kbd><kbd>File</kbd> > <kbd>Open Folder</kbd></kbd>
-2. Open the QMK Firmware folder that you cloned from GitHub. 
-3. Click <kbd><kbd>File</kbd> > <kbd>Save Workspace As...</kbd></kbd>
-
-And now you're ready to code QMK Firmware in VS Code

docs/porting_your_keyboard_to_qmk_(arm_and_other_chibios_cpus).md

@@ -1,25 +1,15 @@
-Setting up your ARM based PCB is a little more involved than an Atmel MCU, but is easy enough. Start by running `util/new_keyboard.sh`:
+Setting up your ARM based PCB is a little more involved than an Atmel MCU, but is easy enough. Start by using `util/new_project.sh <keyboard>` to create a new project:
 
 ```
-$ ./util/new_keyboard.sh
-Generating a new QMK keyboard directory
-
-Keyboard Name: mycoolkb
-Keyboard Type [avr]: 
-Your Name [John Smith]: 
-
-Copying base template files... done
-Copying avr template files... done
-Renaming keyboard files... done
-Replacing %KEYBOARD% with mycoolkb... done
-Replacing %YOUR_NAME% with John Smith... done
-
-Created a new keyboard called mycoolkb.
-
-To start working on things, cd into keyboards/mycoolkb,
-or open the directory in your favourite text editor.
+$ util/new_project.sh simontester
+######################################################
+# /keyboards/simontester project created. To start
+# working on things, cd into keyboards/simontester
+######################################################
 ```
 
+
+
 # END OF NEW ARM DOC, OLD ATMEL DOC FOLLOWS
 
 ## `/keyboards/<keyboard>/config.h`
@@ -32,9 +22,7 @@ The `MATRIX_ROW_PINS` and `MATRIX_COL_PINS` are the pins your MCU uses on each r
 
 For the `DIODE_DIRECTION`, most hand-wiring guides will instruct you to wire the diodes in the `COL2ROW` position, but it's possible that they are in the other - people coming from EasyAVR often use `ROW2COL`. Nothing will function if this is incorrect.
 
-To configure a keyboard where each switch is connected to a separate pin and ground instead of sharing row and column pins, use `DIRECT_PINS`. The mapping defines the pins of each switch in rows and columns, from left to right. Must conform to the sizes within `MATRIX_ROWS` and `MATRIX_COLS`, use `NO_PIN` to fill in blank spaces. Overrides the behaviour of `DIODE_DIRECTION`, `MATRIX_ROW_PINS` and `MATRIX_COL_PINS`.
-
-`BACKLIGHT_PIN` is the pin that your PWM-controlled backlight (if one exists) is hooked-up to.
+`BACKLIGHT_PIN` is the pin that your PWM-controlled backlight (if one exists) is hooked-up to. Currently only B5, B6, and B7 are supported.
 
 `BACKLIGHT_BREATHING` is a fancier backlight feature that adds breathing/pulsing/fading effects to the backlight. It uses the same timer as the normal backlight. These breathing effects must be called by code in your keymap.
 
@@ -66,10 +54,10 @@ This is where all of the custom logic for your keyboard goes - you may not need
 
 ## `/keyboards/<keyboard>/<keyboard>.h`
 
-Here is where you can (optionally) define your `LAYOUT` function to remap your matrix into a more readable format. With ortholinear boards, this isn't always necessary, but it can help to accommodate the dead spots on your matrix, where there are keys that take up more than one space (2u, staggering, 6.25u, etc). The example shows the difference between the physical keys, and the matrix design:
+Here is where you can (optionally) define your `KEYMAP` function to remap your matrix into a more readable format. With ortholinear boards, this isn't always necessary, but it can help to accommodate the dead spots on your matrix, where there are keys that take up more than one space (2u, staggering, 6.25u, etc). The example shows the difference between the physical keys, and the matrix design:
 
 ```
-#define LAYOUT( \
+#define KEYMAP( \
     k00, k01, k02, \
       k10,  k11   \
 ) \

docs/proton_c_conversion.md

@@ -1,21 +0,0 @@
-# Converting a board to use the Proton C
-
-If a board currently supported in QMK uses a Pro Micro (or compatible board) and you want to use the Proton C, you can generate the firmware by appending `CONVERT_TO_PROTON_C=yes` (or `CTPC=yes`) to your make argument, like this:
-
-    make 40percentclub/mf68:default CTPC=yes
-
-You can add the same argument to your keymap's `rules.mk`, which will accomplish the same thing.
-
-This exposes the `CONVERT_TO_PROTON_C` flag that you can use in your code with `#ifdef`s, like this:
-
-    #ifdef CONVERT_TO_PROTON_C
-        // Proton C code
-    #else
-        // Pro Micro code
-    #endif
-
-Before being able to compile, you may get some errors about `PORTB/DDRB`, etc not being defined, so you'll need to convert the keyboard's code to use the [GPIO Controls](internals_gpio_control.md) that will work for both ARM and AVR. This shouldn't affect the AVR builds at all.
-
-The Proton C only has one on-board LED (C13), and by default, the TXLED (D5) is mapped to it. If you want the RXLED (B0) mapped to it instead, add this like to your `config.h`:
-
-    #define CONVERT_TO_PROTON_C_RXLED

docs/python_development.md

@@ -1,45 +0,0 @@
-# Python Development in QMK
-
-This document gives an overview of how QMK has structured its python code. You should read this before working on any of the python code.
-
-## Script directories
-
-There are two places scripts live in QMK: `qmk_firmware/bin` and `qmk_firmware/util`. You should use `bin` for any python scripts that utilize the `qmk` wrapper. Scripts that are standalone and not run very often live in `util`.
-
-We discourage putting anything into `bin` that does not utilize the `qmk` wrapper. If you think you have a good reason for doing so please talk to us about your use case.
-
-## Python Modules
-
-Most of the QMK python modules can be found in `qmk_firmware/lib/python`. This is the path that we append to `sys.path`.
-
-We have a module hierarchy under that path:
-
-* `qmk_firmware/lib/python`
-    * `milc.py` - The CLI library we use. Will be pulled out into its own module in the future.
-    * `qmk` - Code associated with QMK
-        * `cli` - Modules that will be imported for CLI commands.
-        * `errors.py` - Errors that can be raised within QMK apps
-        * `keymap.py` - Functions for working with keymaps
-
-## CLI Scripts
-
-We have a CLI wrapper that you should utilize for any user facing scripts. We think it's pretty easy to use and it gives you a lot of nice things for free.
-
-To use the wrapper simply place a module into `qmk_firmware/lib/python/qmk/cli`, and create a symlink to `bin/qmk` named after your module. Dashes in command names will be converted into dots so you can use hierarchy to manage commands.
-
-When `qmk` is run it checks to see how it was invoked. If it was invoked as `qmk` the module name is take from `sys.argv[1]`. If it was invoked as `qmk-<module-name>` then everything after the first dash is taken as the module name. Dashes and underscores are converted to dots, and then `qmk.cli` is prepended before the module is imported.
-
-The module uses `@cli.entrypoint()` and `@cli.argument()` decorators to define an entrypoint, which is where execution starts.
-
-## Example CLI Script
-
-We have provided a QMK Hello World script you can use as an example. To run it simply run `qmk hello` or `qmk-hello`. The source code is listed below.
-
-```
-from milc import cli
-
-@cli.argument('-n', '--name', default='World', help='Name to greet.')
-@cli.entrypoint('QMK Python Hello World.')
-def main(cli):
-    cli.echo('Hello, %s!', cli.config.general.name)
-```

docs/quantum_keycodes.md

@@ -1,6 +1,6 @@
 # Quantum Keycodes
 
-Quantum keycodes allow for easier customization of your keymap than the basic ones provide, without having to define custom actions.
+Quantum keycodes allow for easier customisation of your keymap than the basic ones provide, without having to define custom actions.
 
 All keycodes within quantum are numbers between `0x0000` and `0xFFFF`. Within your `keymap.c` it may look like you have functions and other special cases, but ultimately the C preprocessor will translate those into a single 4 byte integer. QMK has reserved `0x0000` through `0x00FF` for standard keycodes. These are keycodes such as `KC_A`, `KC_1`, and `KC_LCTL`, which are basic keys defined in the USB HID specification.
 
@@ -16,11 +16,6 @@ On this page we have documented keycodes between `0x00FF` and `0xFFFF` which are
 |`KC_GESC`      |`GRAVE_ESC`|Escape when tapped, <code>&#96;</code> when pressed with Shift or GUI|
 |`KC_LSPO`      |           |Left Shift when held, `(` when tapped                                |
 |`KC_RSPC`      |           |Right Shift when held, `)` when tapped                               |
-|`KC_LCPO`      |           |Left Control when held, `(` when tapped                              |
-|`KC_RCPC`      |           |Right Control when held, `)` when tapped                             |
-|`KC_LAPO`      |           |Left Alt when held, `(` when tapped                                  |
-|`KC_RAPC`      |           |Right Alt when held, `)` when tapped                                 |
-|`KC_SFTENT`    |           |Right Shift when held, Enter when tapped                             |
 |`KC_LEAD`      |           |The [Leader key](feature_leader_key.md)                              |
 |`KC_LOCK`      |           |The [Lock key](feature_key_lock.md)                                  |
 |`FUNC(n)`      |`F(n)`     |Call `fn_action(n)` (deprecated)                                     |