Added BLE support for USB-USB converter. (#1824)

* Added BLE support to USB-USB converter

* Added readme

* Removed images and Makefile

.gitignore

@@ -24,6 +24,9 @@ CMakeLists.txt
 .DS_STORE
 /util/wsl_downloaded
 /util/win_downloaded
+/keyboards/*/Makefile
+/keyboards/*/*/Makefile
+/keyboards/*/keymaps/Makefile
 
 # Eclipse/PyCharm/Other IDE Settings
 .cproject
@@ -36,6 +39,8 @@ util/Win_Check_Output.txt
 # Let these ones be user specific, since we have so many different configurations
 .vscode/launch.json
 .vscode/tasks.json
+.vscode/last.sql
+.vscode/temp.sql
 .stfolder
 
 # ignore image files
@@ -44,8 +49,9 @@ util/Win_Check_Output.txt
 *.gif
 
 # Do not ignore MiniDox left/right hand eeprom files
-!keyboards/minidox/*.eep 
+!keyboards/minidox/*.eep
 
 # things travis sees
 secrets.tar
-id_rsa_*
+id_rsa_*
+/.vs

.travis.yml

@@ -11,14 +11,14 @@ env:
   global:
   - secure: vBTSL34BDPxDilKUuTXqU4CJ26Pv5hogD2nghatkxSQkI1/jbdnLj/DQdPUrMJFDIY6TK3AltsBx72MaMsLQ1JO/Ou24IeHINHXzUC1FlS9yQa48cpxnhX5kzXNyGs3oa0qaFbvnr7RgYRWtmD52n4bIZuSuW+xpBv05x2OCizdT2ZonH33nATaHGFasxROm4qYZ241VfzcUv766V6RVHgL4x9V08warugs+RENVkfzxxwhk3NmkrISabze0gSVJLHBPHxroZC6EUcf/ocobcuDrCwFqtEt90i7pNIAFUE7gZsN2uE75LmpzAWin21G7lLPcPL2k4FJVd8an1HiP2WmscJU6U89fOfMb2viObnKcCzebozBCmKGtHEuXZo9FcReOx49AnQSpmESJGs+q2dL/FApkTjQiyT4J6O5dJpoww0/r57Wx0cmmqjETKBb5rSgXM51Etk3wO09mvcPHsEwrT7qH8r9XWdyCDoEn7FCLX3/LYnf/D4SmZ633YPl5gv3v9XEwxR5+04akjgnvWDSNIaDbWBdxHNb7l4pMc+WR1bwCyMyA7KXj0RrftEGOrm9ZRLe6BkbT4cycA+j77nbPOMcyZChliV9pPQos+4TOJoTzcK2L8yWVoY409aDNVuAjdP6Yum0R2maBGl/etLmIMpJC35C5/lZ+dUNjJAM=
 before_install:
-  - wget http://www.atmel.com/images/avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz
+  - wget http://www.atmel.com/images/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"
 before_script:
   - avr-gcc --version
 script:
-- make test AUTOGEN=false
+- make test:all AUTOGEN=false
 - bash util/travis_build.sh
 addons:
   apt:

.vscode/settings.json

@@ -1,5 +1,7 @@
 // Place your settings in this file to overwrite default and user settings.
 {
+    // Unofficially, QMK uses spaces for indentation
+    "editor.insertSpaces": true,
     // Configure glob patterns for excluding files and folders.
     "files.exclude": {
         "**/.build": true,

Makefile

@@ -21,7 +21,7 @@ override SILENT := false
 
 QMK_VERSION := $(shell git describe --abbrev=0 --tags 2>/dev/null)
 ifneq ($(QMK_VERSION),)
-$(info QMK Firmware v$(QMK_VERSION))
+$(info QMK Firmware $(QMK_VERSION))
 endif
 
 ON_ERROR := error_occurred=1
@@ -65,80 +65,86 @@ $(eval $(call NEXT_PATH_ELEMENT))
 # It's really a very simple if else chain, if you squint enough,
 # but the makefile syntax makes it very verbose.
 # If we are in a subfolder of keyboards
-ifeq ($(CURRENT_PATH_ELEMENT),keyboards)
-    $(eval $(call NEXT_PATH_ELEMENT))
-    KEYBOARD := $(CURRENT_PATH_ELEMENT)
-    $(eval $(call NEXT_PATH_ELEMENT))
-    # If we are in a subfolder of keymaps, or in other words in a keymap
-    # folder
-    ifeq ($(CURRENT_PATH_ELEMENT),keymaps)
-        $(eval $(call NEXT_PATH_ELEMENT))
-        KEYMAP := $(CURRENT_PATH_ELEMENT)
-     # else if we are not in the keyboard folder itself
-    else ifneq ($(CURRENT_PATH_ELEMENT),)
-        # the we can assume it's a subproject, as no other folders
-        # should have make files in them
-        SUBPROJECT := $(CURRENT_PATH_ELEMENT)
-        $(eval $(call NEXT_PATH_ELEMENT))
-        # if we are inside a keymap folder of a subproject
-        ifeq ($(CURRENT_PATH_ELEMENT),keymaps)
-            $(eval $(call NEXT_PATH_ELEMENT))
-            KEYMAP := $(CURRENT_PATH_ELEMENT)
-        endif
-    endif
-endif
+# 
+# *** No longer needed **
+#
+# ifeq ($(CURRENT_PATH_ELEMENT),keyboards)
+#     $(eval $(call NEXT_PATH_ELEMENT))
+#     KEYBOARD := $(CURRENT_PATH_ELEMENT)
+#     $(eval $(call NEXT_PATH_ELEMENT))
+#     # If we are in a subfolder of keymaps, or in other words in a keymap
+#     # folder
+#     ifeq ($(CURRENT_PATH_ELEMENT),keymaps)
+#         $(eval $(call NEXT_PATH_ELEMENT))
+#         KEYMAP := $(CURRENT_PATH_ELEMENT)
+#      # else if we are not in the keyboard folder itself
+#     else ifneq ($(CURRENT_PATH_ELEMENT),)
+#         # the we can assume it's a subproject, as no other folders
+#         # should have make files in them
+#         SUBPROJECT := $(CURRENT_PATH_ELEMENT)
+#         $(eval $(call NEXT_PATH_ELEMENT))
+#         # if we are inside a keymap folder of a subproject
+#         ifeq ($(CURRENT_PATH_ELEMENT),keymaps)
+#             $(eval $(call NEXT_PATH_ELEMENT))
+#             KEYMAP := $(CURRENT_PATH_ELEMENT)
+#         endif
+#     endif
+# endif
+
+define 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))
+    All_RULES_MK += $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/*/*/*/rules.mk))
+
+    KEYMAPS_MK := $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/keymaps/*/rules.mk))
+    KEYMAPS_MK += $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/*/keymaps/*/rules.mk))
+    KEYMAPS_MK += $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/*/*/keymaps/*/rules.mk))
+    KEYMAPS_MK += $$(patsubst $(ROOT_DIR)/keyboards/%/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/*/*/*/*/keymaps/*/rules.mk))
+
+    KEYBOARDS := $$(sort $$(filter-out $$(KEYMAPS_MK), $$(All_RULES_MK)))
+endef
+
+$(eval $(call GET_KEYBOARDS))
 
 # Only consider folders with makefiles, to prevent errors in case there are extra folders
-KEYBOARDS := $(notdir $(patsubst %/Makefile,%,$(wildcard $(ROOT_DIR)/keyboards/*/Makefile)))
+#KEYBOARDS += $(patsubst $(ROOD_DIR)/keyboards/%/rules.mk,%,$(wildcard $(ROOT_DIR)/keyboards/*/*/rules.mk))
+
+list-keyboards:
+	echo $(KEYBOARDS)
+	exit 0
 
 #Compatibility with the old make variables, anything you specify directly on the command line
 # always overrides the detected folders
 ifdef keyboard
     KEYBOARD := $(keyboard)
 endif
-ifdef sub
-    SUBPROJECT := $(sub)
-endif
-ifdef subproject
-    SUBPROJECT := $(subproject)
-endif
 ifdef keymap
     KEYMAP := $(keymap)
 endif
 
 # Uncomment these for debugging
-#$(info Keyboard: $(KEYBOARD))
-#$(info Keymap: $(KEYMAP))
-#$(info Subproject: $(SUBPROJECT))
-#$(info Keyboards: $(KEYBOARDS))
+# $(info Keyboard: $(KEYBOARD))
+# $(info Keymap: $(KEYMAP))
+# $(info Subproject: $(SUBPROJECT))
+# $(info Keyboards: $(KEYBOARDS))
 
 
 # Set the default goal depending on where we are running make from
 # this handles the case where you run make without any arguments
-.DEFAULT_GOAL := all
+.DEFAULT_GOAL := all:all
 ifneq ($(KEYMAP),)
-    ifeq ($(SUBPROJECT),)
-         # Inside a keymap folder, just build the keymap, with the
-         # default subproject
-        .DEFAULT_GOAL := $(KEYBOARD)-$(KEYMAP)
-    else
-         # Inside a subproject keyamp folder, build the keymap
-         # for that subproject
-        .DEFAULT_GOAL := $(KEYBOARD)-$(SUBPROJECT)-$(KEYMAP)
-    endif
-else ifneq ($(SUBPROJECT),)
-     # Inside a subproject folder, build all keymaps for that subproject
-    .DEFAULT_GOAL := $(KEYBOARD)-$(SUBPROJECT)-allkm
+    .DEFAULT_GOAL := $(KEYBOARD):$(KEYMAP)
 else ifneq ($(KEYBOARD),)
      # Inside a keyboard folder, build all keymaps for all subprojects
      # Note that this is different from the old behaviour, which would
      # build only the default keymap of the default keyboard
-    .DEFAULT_GOAL := $(KEYBOARD)-allsp-allkm
+    .DEFAULT_GOAL := $(KEYBOARD):all
 endif
 
 
 # Compare the start of the RULE variable with the first argument($1)
-# If the rules equals $1 or starts with $1-, RULE_FOUND is set to true
+# If the rules equals $1 or starts with $1:, RULE_FOUND is set to true
 #     and $1 is removed from the RULE variable
 # Otherwise the RULE_FOUND variable is set to false, and RULE left as it was
 # The function is a bit tricky, since there's no built in $(startswith) function
@@ -147,10 +153,10 @@ define COMPARE_AND_REMOVE_FROM_RULE_HELPER
         RULE:=
         RULE_FOUND := true
     else
-        STARTDASH_REMOVED=$$(subst START$1-,,START$$(RULE))
-        ifneq ($$(STARTDASH_REMOVED),START$$(RULE))
+        STARTCOLON_REMOVED=$$(subst START$1:,,START$$(RULE))
+        ifneq ($$(STARTCOLON_REMOVED),START$$(RULE))
             RULE_FOUND := true
-            RULE := $$(STARTDASH_REMOVED)
+            RULE := $$(STARTCOLON_REMOVED)
         else
             RULE_FOUND := false
         endif
@@ -229,14 +235,14 @@ define PARSE_ALL_IN_LIST
 endef
 
 # The entry point for rule parsing
-# parses a rule in the format <keyboard>-<subproject>-<keymap>-<target>
+# parses a rule in the format <keyboard>:<keymap>:<target>
 # but this particular function only deals with the first <keyboard> part
 define PARSE_RULE
     RULE := $1
     COMMANDS :=
-    # If the rule starts with allkb, then continue the parsing from
+    # If the rule starts with all, then continue the parsing from
     # PARSE_ALL_KEYBOARDS
-    ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,allkb),true)
+    ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,all),true)
         $$(eval $$(call PARSE_ALL_KEYBOARDS))
     else ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,test),true)
         $$(eval $$(call PARSE_TEST))
@@ -250,35 +256,107 @@ define PARSE_RULE
         $$(eval $$(call PARSE_KEYBOARD,$$(KEYBOARD)))
     else
         $$(info make: *** No rule to make target '$1'. Stop.)
-        # Notice the tab instead of spaces below!
-		exit 1
+        $$(info |)
+        $$(info |  QMK's make format recently changed to use folder locations and colons:)
+        $$(info |     make project_folder:keymap[:target])
+        $$(info |  Examples:)
+        $$(info |     make planck/rev4:default:dfu)
+        $$(info |     make planck:default)
+        $$(info |)
     endif
 endef
 
 # $1 = Keyboard
-# Parses a rule in the format <subproject>-<keymap>-<target>
+# Parses a rule in the format <keymap>:<target>
 # the keyboard is already known when entering this function
 define PARSE_KEYBOARD
+    # If we want to compile the default subproject, then we need to
+    # include the correct makefile to determine the actual name of it
     CURRENT_KB := $1
-    # A subproject is any keyboard subfolder with a makefile
-    SUBPROJECTS := $$(notdir $$(patsubst %/Makefile,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(CURRENT_KB)/*/Makefile)))
-    # if the rule starts with allsp, then continue with looping over all subprojects
-    ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,allsp),true)
-        $$(eval $$(call PARSE_ALL_SUBPROJECTS))
-    # A special case for matching the defaultsp (default subproject)
-    else ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,defaultsp),true)
-        $$(eval $$(call PARSE_SUBPROJECT,defaultsp))
-    # If the rule starts with the name of a known subproject
-    else ifeq ($$(call TRY_TO_MATCH_RULE_FROM_LIST,$$(SUBPROJECTS)),true)
-        $$(eval $$(call PARSE_SUBPROJECT,$$(MATCHED_ITEM)))
-    # Try to use the SUBPROJECT variable, which is either determined by the
-    # directory which invoked make, or passed as an argument to make
-    else ifneq ($$(SUBPROJECT),)
-        $$(eval $$(call PARSE_SUBPROJECT,$$(SUBPROJECT)))
-	# If there's no matching subproject, we assume it's the default
-	# This will allow you to leave the subproject part of the target out
+
+    # KEYBOARD_FOLDERS := $$(subst /, , $(CURRENT_KB))
+
+    DEFAULT_FOLDER := $$(CURRENT_KB)
+
+    # We assume that every rules.mk will contain the full default value
+    $$(eval include $(ROOT_DIR)/keyboards/$$(CURRENT_KB)/rules.mk)
+    ifneq ($$(DEFAULT_FOLDER),$$(CURRENT_KB))
+        $$(eval include $(ROOT_DIR)/keyboards/$$(DEFAULT_FOLDER)/rules.mk)
+    endif
+    CURRENT_KB := $$(DEFAULT_FOLDER)
+
+    # 5/4/3/2/1
+    KEYBOARD_FOLDER_PATH_1 := $$(CURRENT_KB)
+    KEYBOARD_FOLDER_PATH_2 := $$(patsubst %/,%,$$(dir $$(KEYBOARD_FOLDER_PATH_1)))
+    KEYBOARD_FOLDER_PATH_3 := $$(patsubst %/,%,$$(dir $$(KEYBOARD_FOLDER_PATH_2)))
+    KEYBOARD_FOLDER_PATH_4 := $$(patsubst %/,%,$$(dir $$(KEYBOARD_FOLDER_PATH_3)))
+    KEYBOARD_FOLDER_PATH_5 := $$(patsubst %/,%,$$(dir $$(KEYBOARD_FOLDER_PATH_4)))
+    KEYBOARD_FOLDER_1 := $$(notdir $$(KEYBOARD_FOLDER_PATH_1))
+    KEYBOARD_FOLDER_2 := $$(notdir $$(KEYBOARD_FOLDER_PATH_2))
+    KEYBOARD_FOLDER_3 := $$(notdir $$(KEYBOARD_FOLDER_PATH_3))
+    KEYBOARD_FOLDER_4 := $$(notdir $$(KEYBOARD_FOLDER_PATH_4))
+    KEYBOARD_FOLDER_5 := $$(notdir $$(KEYBOARD_FOLDER_PATH_5))
+
+    KEYMAPS :=
+    # get a list of all keymaps
+    KEYMAPS += $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_1)/keymaps/*/.)))
+    KEYMAPS += $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_2)/keymaps/*/.)))
+    KEYMAPS += $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_3)/keymaps/*/.)))
+    KEYMAPS += $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_4)/keymaps/*/.)))
+    KEYMAPS += $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_PATH_5)/keymaps/*/.)))
+    # this might be needed, but in a different form
+    #KEYMAPS := $$(sort $$(filter-out $$(KEYBOARD_FOLDER_1) $$(KEYBOARD_FOLDER_2) \
+        $$(KEYBOARD_FOLDER_3) $$(KEYBOARD_FOLDER_4) $$(KEYBOARD_FOLDER_5), $$(KEYMAPS)))
+
+    KEYBOARD_LAYOUTS :=
+    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_5)/rules.mk)","")
+      LAYOUTS :=
+      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_5)/rules.mk)
+      KEYBOARD_LAYOUTS := $$(sort $$(LAYOUTS) $$(KEYBOARD_LAYOUTS))
+    endif
+    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_4)/rules.mk)","")
+      LAYOUTS :=
+      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_4)/rules.mk)
+      KEYBOARD_LAYOUTS := $$(sort $$(LAYOUTS) $$(KEYBOARD_LAYOUTS))
+    endif
+    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_3)/rules.mk)","")
+      LAYOUTS :=
+      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_3)/rules.mk)
+      KEYBOARD_LAYOUTS := $$(sort $$(LAYOUTS) $$(KEYBOARD_LAYOUTS))
+    endif
+    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_2)/rules.mk)","")
+      LAYOUTS :=
+      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_2)/rules.mk)
+      KEYBOARD_LAYOUTS := $$(sort $$(LAYOUTS) $$(KEYBOARD_LAYOUTS))
+    endif
+    ifneq ("$$(wildcard $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_1)/rules.mk)","")
+      LAYOUTS :=
+      $$(eval include $(ROOT_DIR)/keyboards/$$(KEYBOARD_FOLDER_1)/rules.mk)
+      KEYBOARD_LAYOUTS := $$(sort $$(LAYOUTS) $$(KEYBOARD_LAYOUTS))
+    endif
+
+    LAYOUT_KEYMAPS :=
+    $$(foreach LAYOUT,$$(KEYBOARD_LAYOUTS),$$(eval LAYOUT_KEYMAPS += $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/layouts/*/$$(LAYOUT)/*/.)))))
+    
+    KEYMAPS := $$(sort $$(KEYMAPS) $$(LAYOUT_KEYMAPS))
+
+    # if the rule after removing the start of it is empty (we haven't specified a kemap or target)
+    # compile all the keymaps
+    ifeq ($$(RULE),)
+        $$(eval $$(call PARSE_ALL_KEYMAPS))
+    # The same if all was specified
+    else ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,all),true)
+        $$(eval $$(call PARSE_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)))
+    # Otherwise try to match the keymap from the current folder, or arguments to the make command
+    else ifneq ($$(KEYMAP),)
+        $$(eval $$(call PARSE_KEYMAP,$$(KEYMAP)))
+    # Otherwise, make all keymaps, again this is consistent with how it works without
+    # any arguments
     else
-        $$(eval $$(call PARSE_SUBPROJECT,))
+        $$(eval $$(call PARSE_ALL_KEYMAPS))
     endif
 endef
 
@@ -291,84 +369,19 @@ endef
 # $1 Subproject
 # When entering this, the keyboard and subproject are known, so now we need
 # to determine which keymaps are going to get compiled
-define PARSE_SUBPROJECT
-    # If we want to compile the default subproject, then we need to
-    # include the correct makefile to determine the actual name of it
-    CURRENT_SP := $1
-    ifeq ($$(CURRENT_SP),)
-        CURRENT_SP := defaultsp
-    endif
-    ifeq ($$(CURRENT_SP),defaultsp)
-        SUBPROJECT_DEFAULT=
-        $$(eval include $(ROOT_DIR)/keyboards/$$(CURRENT_KB)/Makefile)
-        CURRENT_SP := $$(SUBPROJECT_DEFAULT)
-    endif
-    # If current subproject is empty (the default was not defined), and we have a list of subproject
-    # then make all of them
-    ifeq ($$(CURRENT_SP),)
-        ifneq ($$(SUBPROJECTS),)
-            CURRENT_SP := allsp
-         endif
-    endif
-    # The special allsp is handled later
-    ifneq ($$(CURRENT_SP),allsp)
-        # get a list of all keymaps
-        KEYMAPS := $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(CURRENT_KB)/keymaps/*/.)))
-        LAYOUTS :=
-        $$(eval -include $(ROOT_DIR)/keyboards/$$(CURRENT_KB)/rules.mk)
-        KEYBOARD_LAYOUTS := $$(LAYOUTS)
-        ifneq ($$(CURRENT_SP),)
-            # if the subproject is defined, then also look for keymaps inside the subproject folder
-            SP_KEYMAPS := $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(CURRENT_KB)/$$(CURRENT_SP)/keymaps/*/.)))
-            KEYMAPS := $$(sort $$(KEYMAPS) $$(SP_KEYMAPS))
-	        # $$(eval -include $(ROOT_DIR)/keyboards/$$(CURRENT_KB)/$$(CURRENT_SP)/rules.mk)
-        	# KEYBOARD_LAYOUTS := $$(sort $$(KEYBOARD_LAYOUTS) $$(LAYOUTS))
-        endif
+# define PARSE_SUBPROJECT
 
-        LAYOUT_KEYMAPS :=
-        $$(foreach LAYOUT,$$(KEYBOARD_LAYOUTS),$$(eval LAYOUT_KEYMAPS += $$(notdir $$(patsubst %/.,%,$$(wildcard $(ROOT_DIR)/layouts/*/$$(LAYOUT)/*/.)))))
-        
-        KEYMAPS := $$(sort $$(KEYMAPS) $$(LAYOUT_KEYMAPS))
-        # if the rule after removing the start of it is empty (we haven't specified a kemap or target)
-        # compile all the keymaps
-        ifeq ($$(RULE),)
-            $$(eval $$(call PARSE_ALL_KEYMAPS))
-        # The same if allkm was specified
-        else ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,allkm),true)
-            $$(eval $$(call PARSE_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)))
-        # Otherwise try to match the keymap from the current folder, or arguments to the make command
-        else ifneq ($$(KEYMAP),)
-            $$(eval $$(call PARSE_KEYMAP,$$(KEYMAP)))
-        # No matching keymap found, so we assume that the rest of the rule is the target
-        # If we haven't been able to parse out a subproject, then make all of them
-        # This is consistent with running make without any arguments from the keyboard
-        # folder
-        else ifeq ($1,)
-            $$(eval $$(call PARSE_ALL_SUBPROJECTS))
-        # Otherwise, make all keymaps, again this is consistent with how it works without
-        # any arguments
-        else
-            $$(eval $$(call PARSE_ALL_KEYMAPS))
-        endif
-    else
-        # As earlier mentioned when allsb is specified, we call our self recursively
-        # for all of the subprojects
-        $$(eval $$(call PARSE_ALL_IN_LIST,PARSE_SUBPROJECT,$(SUBPROJECTS)))
-    endif
-endef
+# endef
 
 # If we want to parse all subprojects, but the keyboard doesn't have any,
 # then use defaultsp instead
-define PARSE_ALL_SUBPROJECTS
-    ifeq ($$(SUBPROJECTS),)
-        $$(eval $$(call PARSE_SUBPROJECT,defaultsp))
-    else
-        $$(eval $$(call PARSE_ALL_IN_LIST,PARSE_SUBPROJECT,$$(SUBPROJECTS)))
-    endif
-endef
+# define PARSE_ALL_SUBPROJECTS
+#     ifeq ($$(SUBPROJECTS),)
+#         $$(eval $$(call PARSE_SUBPROJECT,defaultsp))
+#     else
+#         $$(eval $$(call PARSE_ALL_IN_LIST,PARSE_SUBPROJECT,$$(SUBPROJECTS)))
+#     endif
+# endef
 
 # $1 Keymap
 # This is the meat of compiling a keyboard, when entering this, everything is known
@@ -378,21 +391,18 @@ endef
 define PARSE_KEYMAP
     CURRENT_KM = $1
     # The rest of the rule is the target
-    # Remove the leading "-" from the target, as it acts as a separator
-    MAKE_TARGET := $$(patsubst -%,%,$$(RULE))
+    # Remove the leading ":" from the target, as it acts as a separator
+    MAKE_TARGET := $$(patsubst :%,%,$$(RULE))
     # We need to generate an unique indentifer to append to the COMMANDS list
-    COMMAND := COMMAND_KEYBOARD_$$(CURRENT_KB)_SUBPROJECT_$(CURRENT_SP)_KEYMAP_$$(CURRENT_KM)
+    CURRENT_KB_UNDER := $$(subst /,_,$$(CURRENT_KB))
+    COMMAND := COMMAND_KEYBOARD_$$(CURRENT_KB_UNDER)_KEYMAP_$$(CURRENT_KM)
     # If we are compiling a keyboard without a subproject, we want to display just the name
     # of the keyboard, otherwise keyboard/subproject
-    ifeq ($$(CURRENT_SP),)
-        KB_SP := $(CURRENT_KB)
-    else
-        KB_SP := $(CURRENT_KB)/$$(CURRENT_SP)
-    endif
+    KB_SP := $$(CURRENT_KB)
     # Format it in bold
     KB_SP := $(BOLD)$$(KB_SP)$(NO_COLOR)
     # Specify the variables that we are passing forward to submake
-    MAKE_VARS := KEYBOARD=$$(CURRENT_KB) SUBPROJECT=$$(CURRENT_SP) KEYMAP=$$(CURRENT_KM)
+    MAKE_VARS := KEYBOARD=$$(CURRENT_KB) KEYMAP=$$(CURRENT_KM)
     # And the first part of the make command
     MAKE_CMD := $$(MAKE) -r -R -C $(ROOT_DIR) -f build_keyboard.mk $$(MAKE_TARGET)
     # The message to display
@@ -453,8 +463,8 @@ endef
 
 define PARSE_TEST
     TESTS :=
-    TEST_NAME := $$(firstword $$(subst -, ,$$(RULE)))
-    TEST_TARGET := $$(subst $$(TEST_NAME),,$$(subst $$(TEST_NAME)-,,$$(RULE)))
+    TEST_NAME := $$(firstword $$(subst :, ,$$(RULE)))
+    TEST_TARGET := $$(subst $$(TEST_NAME),,$$(subst $$(TEST_NAME):,,$$(RULE)))
     ifeq ($$(TEST_NAME),all)
         MATCHED_TESTS := $$(TEST_LIST)
     else
@@ -502,11 +512,6 @@ if [ $$error_occurred -gt 0 ]; then $(HANDLE_ERROR); fi;
 
 endef
 
-# Allow specifying just the subproject, in the keyboard directory, which will compile all keymaps
-SUBPROJECTS := $(notdir $(patsubst %/Makefile,%,$(wildcard ./*/Makefile)))
-.PHONY: $(SUBPROJECTS)
-$(SUBPROJECTS): %: %-allkm
-
 # Let's match everything, we handle all the rule parsing ourselves
 .PHONY: %
 %:
@@ -514,6 +519,9 @@ $(SUBPROJECTS): %: %-allkm
 	cmp $(ROOT_DIR)/Makefile $(ROOT_DIR)/Makefile >/dev/null 2>&1; if [ $$? -gt 0 ]; then printf "$(MSG_NO_CMP)"; exit 1; 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 --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 \
@@ -534,22 +542,32 @@ endif
 	$(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
+
 # All should compile everything
-.PHONY: all
-all: all-keyboards test-all
+# .PHONY: all
+# all: all-keyboards test-all
 
 # Define some shortcuts, mostly for compatibility with the old syntax
-.PHONY: all-keyboards
-all-keyboards: allkb-allsp-allkm
+# .PHONY: all-keyboards
+# all-keyboards: all\:all\:all
 
-.PHONY: all-keyboards-defaults
-all-keyboards-defaults: allkb-allsp-default
+# .PHONY: all-keyboards-defaults
+# all-keyboards-defaults: all\:default
 
-.PHONY: test
-test: test-all
+# .PHONY: test
+# test: test-all
 
-.PHONY: test-clean
-test-clean: test-all-clean
+# .PHONY: test-clean
+# test-clean: test-all-clean
+
+lib/%:
+	git submodule sync $?
+	git submodule update --init $?
+
+git-submodule:
+	git submodule sync --recursive
+	git submodule update --init --recursive
 
 ifdef SKIP_VERSION
 SKIP_GIT := yes

build_keyboard.mk

@@ -6,18 +6,26 @@ endif
 
 include common.mk
 
-ifneq ($(SUBPROJECT),)
-    TARGET ?= $(KEYBOARD)_$(SUBPROJECT)_$(KEYMAP)
-    KEYBOARD_OUTPUT := $(BUILD_DIR)/obj_$(KEYBOARD)_$(SUBPROJECT)
-else
-    TARGET ?= $(KEYBOARD)_$(KEYMAP)
-    KEYBOARD_OUTPUT := $(BUILD_DIR)/obj_$(KEYBOARD)
-endif
+# 5/4/3/2/1
+KEYBOARD_FOLDER_PATH_1 := $(KEYBOARD)
+KEYBOARD_FOLDER_PATH_2 := $(patsubst %/,%,$(dir $(KEYBOARD_FOLDER_PATH_1)))
+KEYBOARD_FOLDER_PATH_3 := $(patsubst %/,%,$(dir $(KEYBOARD_FOLDER_PATH_2)))
+KEYBOARD_FOLDER_PATH_4 := $(patsubst %/,%,$(dir $(KEYBOARD_FOLDER_PATH_3)))
+KEYBOARD_FOLDER_PATH_5 := $(patsubst %/,%,$(dir $(KEYBOARD_FOLDER_PATH_4)))
+KEYBOARD_FOLDER_1 := $(notdir $(KEYBOARD_FOLDER_PATH_1))
+KEYBOARD_FOLDER_2 := $(notdir $(KEYBOARD_FOLDER_PATH_2))
+KEYBOARD_FOLDER_3 := $(notdir $(KEYBOARD_FOLDER_PATH_3))
+KEYBOARD_FOLDER_4 := $(notdir $(KEYBOARD_FOLDER_PATH_4))
+KEYBOARD_FOLDER_5 := $(notdir $(KEYBOARD_FOLDER_PATH_5))
+
+KEYBOARD_FILESAFE := $(subst /,_,$(KEYBOARD))
+
+TARGET ?= $(KEYBOARD_FILESAFE)_$(KEYMAP)
+KEYBOARD_OUTPUT := $(BUILD_DIR)/obj_$(KEYBOARD_FILESAFE)
 
 # Force expansion
 TARGET := $(TARGET)
 
-
 MASTER ?= left
 ifdef master
     MASTER = $(master)
@@ -31,28 +39,62 @@ $(error MASTER does not have a valid value(left/right))
     endif
 endif
 
-KEYBOARD_PATH := keyboards/$(KEYBOARD)
-KEYBOARD_C := $(KEYBOARD_PATH)/$(KEYBOARD).c
+KEYBOARD_PATHS :=
 
-ifneq ("$(wildcard $(KEYBOARD_C))","")
-    include $(KEYBOARD_PATH)/rules.mk
-else
-    $(error "$(KEYBOARD_C)" does not exist)
+KEYBOARD_PATH_1 := keyboards/$(KEYBOARD_FOLDER_PATH_1)
+KEYBOARD_PATH_2 := keyboards/$(KEYBOARD_FOLDER_PATH_2)
+KEYBOARD_PATH_3 := keyboards/$(KEYBOARD_FOLDER_PATH_3)
+KEYBOARD_PATH_4 := keyboards/$(KEYBOARD_FOLDER_PATH_4)
+KEYBOARD_PATH_5 := keyboards/$(KEYBOARD_FOLDER_PATH_5)
+
+ifneq ("$(wildcard $(KEYBOARD_PATH_5)/rules.mk)","")
+    KEYBOARD_PATHS += $(KEYBOARD_PATH_5)
+    include $(KEYBOARD_PATH_5)/rules.mk
 endif
-OPT_DEFS += -DKEYBOARD_$(KEYBOARD)
-
-ifneq ($(SUBPROJECT),)
-    SUBPROJECT_PATH := keyboards/$(KEYBOARD)/$(SUBPROJECT)
-    SUBPROJECT_C := $(SUBPROJECT_PATH)/$(SUBPROJECT).c
-    ifneq ("$(wildcard $(SUBPROJECT_C))","")
-        OPT_DEFS += -DSUBPROJECT_$(SUBPROJECT)
-        include $(SUBPROJECT_PATH)/rules.mk
-    else
-        $(error "$(SUBPROJECT_PATH)/$(SUBPROJECT).c" does not exist)
-    endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_4)/rules.mk)","")
+    KEYBOARD_PATHS += $(KEYBOARD_PATH_4)
+    include $(KEYBOARD_PATH_4)/rules.mk
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_3)/rules.mk)","")
+    KEYBOARD_PATHS += $(KEYBOARD_PATH_3)
+    include $(KEYBOARD_PATH_3)/rules.mk
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_2)/rules.mk)","")
+    KEYBOARD_PATHS += $(KEYBOARD_PATH_2)
+    include $(KEYBOARD_PATH_2)/rules.mk
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_1)/rules.mk)","")
+    KEYBOARD_PATHS += $(KEYBOARD_PATH_1)
+    include $(KEYBOARD_PATH_1)/rules.mk
 endif
 
-# We can assume a ChibiOS target When MCU_FAMILY is defined, since it's not used for LUFA
+KEYBOARD_SRC :=
+
+KEYBOARD_C_1 := $(KEYBOARD_PATH_1)/$(KEYBOARD_FOLDER_1).c
+KEYBOARD_C_2 := $(KEYBOARD_PATH_2)/$(KEYBOARD_FOLDER_2).c
+KEYBOARD_C_3 := $(KEYBOARD_PATH_3)/$(KEYBOARD_FOLDER_3).c
+KEYBOARD_C_4 := $(KEYBOARD_PATH_4)/$(KEYBOARD_FOLDER_4).c
+KEYBOARD_C_5 := $(KEYBOARD_PATH_5)/$(KEYBOARD_FOLDER_5).c
+
+ifneq ("$(wildcard $(KEYBOARD_C_5))","")
+    KEYBOARD_SRC += $(KEYBOARD_C_5)
+endif
+ifneq ("$(wildcard $(KEYBOARD_C_4))","")
+    KEYBOARD_SRC += $(KEYBOARD_C_4)
+endif
+ifneq ("$(wildcard $(KEYBOARD_C_3))","")
+    KEYBOARD_SRC += $(KEYBOARD_C_3)
+endif
+ifneq ("$(wildcard $(KEYBOARD_C_2))","")
+    KEYBOARD_SRC += $(KEYBOARD_C_2)
+endif
+ifneq ("$(wildcard $(KEYBOARD_C_1))","")
+    KEYBOARD_SRC += $(KEYBOARD_C_1)
+endif
+
+OPT_DEFS += -DKEYBOARD_$(KEYBOARD_FILESAFE)
+
+# We can assume a ChibiOS target When MCU_FAMILY is defined , since it's not used for LUFA
 ifdef MCU_FAMILY
     PLATFORM=CHIBIOS
 else
@@ -63,44 +105,80 @@ ifeq ($(PLATFORM),CHIBIOS)
     include $(TMK_PATH)/protocol/chibios.mk
     include $(TMK_PATH)/chibios.mk
     OPT_OS = chibios
-    ifneq ("$(wildcard $(SUBPROJECT_PATH)/bootloader_defs.h)","")
-        OPT_DEFS += -include $(SUBPROJECT_PATH)/bootloader_defs.h
-    else ifneq ("$(wildcard $(SUBPROJECT_PATH)/boards/$(BOARD)/bootloader_defs.h)","")
-        OPT_DEFS += -include $(SUBPROJECT_PATH)/boards/$(BOARD)/bootloader_defs.h
-    else ifneq ("$(wildcard $(KEYBOARD_PATH)/bootloader_defs.h)","")
-        OPT_DEFS += -include $(KEYBOARD_PATH)/bootloader_defs.h
-    else ifneq ("$(wildcard $(KEYBOARD_PATH)/boards/$(BOARD)/bootloader_defs.h)","")
-        OPT_DEFS += -include $(KEYBOARD_PATH)/boards/$(BOARD)/bootloader_defs.h
+    ifneq ("$(wildcard $(KEYBOARD_PATH_5)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_5)/bootloader_defs.h
+     else ifneq ("$(wildcard $(KEYBOARD_PATH_5)/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_5)/boards/$(BOARD)/bootloader_defs.h
+    else ifneq ("$(wildcard $(KEYBOARD_PATH_4)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_4)/bootloader_defs.h
+     else ifneq ("$(wildcard $(KEYBOARD_PATH_4)/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_4)/boards/$(BOARD)/bootloader_defs.h
+    else ifneq ("$(wildcard $(KEYBOARD_PATH_3)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_3)/bootloader_defs.h
+     else ifneq ("$(wildcard $(KEYBOARD_PATH_3)/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_3)/boards/$(BOARD)/bootloader_defs.h
+    else ifneq ("$(wildcard $(KEYBOARD_PATH_2)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_2)/bootloader_defs.h
+     else ifneq ("$(wildcard $(KEYBOARD_PATH_2)/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_2)/boards/$(BOARD)/bootloader_defs.h
+    else ifneq ("$(wildcard $(KEYBOARD_PATH_1)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_1)/bootloader_defs.h
+     else ifneq ("$(wildcard $(KEYBOARD_PATH_1)/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(KEYBOARD_PATH_1)/boards/$(BOARD)/bootloader_defs.h
     endif
 endif
 
-CONFIG_H = $(KEYBOARD_PATH)/config.h
-ifneq ($(SUBPROJECT),)
-    ifneq ("$(wildcard $(SUBPROJECT_C))","")
-        CONFIG_H = $(SUBPROJECT_PATH)/config.h
-    endif
+CONFIG_H :=
+ifneq ("$(wildcard $(KEYBOARD_PATH_5)/config.h)","")
+    CONFIG_H += $(KEYBOARD_PATH_5)/config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_4)/config.h)","")
+    CONFIG_H += $(KEYBOARD_PATH_4)/config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_3)/config.h)","")
+    CONFIG_H += $(KEYBOARD_PATH_3)/config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_2)/config.h)","")
+    CONFIG_H += $(KEYBOARD_PATH_2)/config.h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_1)/config.h)","")
+    CONFIG_H += $(KEYBOARD_PATH_1)/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) $(SUBPROJECT_PATH) $(KEYBOARD_PATH)
+PROJECT_INC := $(VPATH) $(EXTRAINCDIRS) $(KEYBOARD_PATHS)
 PROJECT_CONFIG := $(CONFIG_H)
 
-MAIN_KEYMAP_PATH := $(KEYBOARD_PATH)/keymaps/$(KEYMAP)
-MAIN_KEYMAP_C := $(MAIN_KEYMAP_PATH)/keymap.c
-SUBPROJ_KEYMAP_PATH := $(SUBPROJECT_PATH)/keymaps/$(KEYMAP)
-SUBPROJ_KEYMAP_C := $(SUBPROJ_KEYMAP_PATH)/keymap.c
-ifneq ("$(wildcard $(SUBPROJ_KEYMAP_C))","")
-    -include $(SUBPROJ_KEYMAP_PATH)/Makefile
-    KEYMAP_C := $(SUBPROJ_KEYMAP_C)
-    KEYMAP_PATH := $(SUBPROJ_KEYMAP_PATH)
-else ifneq ("$(wildcard $(MAIN_KEYMAP_C))","")
-    -include $(MAIN_KEYMAP_PATH)/Makefile
-    KEYMAP_C := $(MAIN_KEYMAP_C)
-    KEYMAP_PATH := $(MAIN_KEYMAP_PATH)
+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
+else 
     $(error Could not find keymap)
     # this state should never be reached
 endif
@@ -110,29 +188,21 @@ endif
 #     this an empty or blank macro!
 KEYMAP_OUTPUT := $(BUILD_DIR)/obj_$(TARGET)
 
-
 ifneq ("$(wildcard $(KEYMAP_PATH)/config.h)","")
-    CONFIG_H = $(KEYMAP_PATH)/config.h
+    CONFIG_H += $(KEYMAP_PATH)/config.h
 endif
 
 # # project specific files
-SRC += $(KEYBOARD_C) \
+SRC += $(KEYBOARD_SRC) \
     $(KEYMAP_C) \
     $(QUANTUM_SRC)
 
-ifneq ($(SUBPROJECT),)
-    SRC += $(SUBPROJECT_C)
-endif
-
 # Optimize size but this may cause error "relocation truncated to fit"
 #EXTRALDFLAGS = -Wl,--relax
 
 # Search Path
 VPATH += $(KEYMAP_PATH)
-ifneq ($(SUBPROJECT),)
-    VPATH += $(SUBPROJECT_PATH)
-endif
-VPATH += $(KEYBOARD_PATH)
+VPATH += $(KEYBOARD_PATHS)
 VPATH += $(COMMON_VPATH)
 
 include common_features.mk
@@ -161,15 +231,15 @@ endif
 OUTPUTS := $(KEYMAP_OUTPUT) $(KEYBOARD_OUTPUT)
 $(KEYMAP_OUTPUT)_SRC := $(SRC)
 $(KEYMAP_OUTPUT)_DEFS := $(OPT_DEFS) $(GFXDEFS) \
--DQMK_KEYBOARD=\"$(KEYBOARD)\" -DQMK_KEYBOARD_H=\"$(KEYBOARD).h\" -DQMK_KEYBOARD_CONFIG_H=\"$(KEYBOARD_PATH)/config.h\" \
+-DQMK_KEYBOARD=\"$(KEYBOARD)\" -DQMK_KEYBOARD_H=\"$(KEYBOARD_FOLDER_1).h\" -DQMK_KEYBOARD_CONFIG_H=\"$(KEYBOARD_PATH_1)/config.h\" \
 -DQMK_KEYMAP=\"$(KEYMAP)\" -DQMK_KEYMAP_H=\"$(KEYMAP).h\" -DQMK_KEYMAP_CONFIG_H=\"$(KEYMAP_PATH)/config.h\" \
--DQMK_SUBPROJECT=\"$(SUBPROJECT)\" -DQMK_SUBPROJECT_H=\"$(SUBPROJECT).h\" -DQMK_SUBPROJECT_CONFIG_H=\"$(SUBPROJECT_PATH)/config.h\"
+-DQMK_SUBPROJECT -DQMK_SUBPROJECT_H -DQMK_SUBPROJECT_CONFIG_H
 $(KEYMAP_OUTPUT)_INC :=  $(VPATH) $(EXTRAINCDIRS)
 $(KEYMAP_OUTPUT)_CONFIG := $(CONFIG_H)
 $(KEYBOARD_OUTPUT)_SRC := $(CHIBISRC) $(GFXSRC)
 $(KEYBOARD_OUTPUT)_DEFS := $(PROJECT_DEFS) $(GFXDEFS)
 $(KEYBOARD_OUTPUT)_INC := $(PROJECT_INC) $(GFXINC)
-$(KEYBOARD_OUTPUT)_CONFIG  := $(PROJECT_CONFIG)
+$(KEYBOARD_OUTPUT)_CONFIG := $(PROJECT_CONFIG)
 
 # Default target.
 all: build sizeafter
@@ -181,4 +251,3 @@ build: elf hex
 
 
 include $(TMK_PATH)/rules.mk
-

common_features.mk

@@ -69,6 +69,10 @@ ifeq ($(strip $(FAUXCLICKY_ENABLE)), yes)
     SRC += $(QUANTUM_DIR)/fauxclicky.c
 endif
 
+ifeq ($(strip $(POINTING_DEVICE_ENABLE)), yes)
+	SRC += $(QUANTUM_DIR)/pointing_device.c
+endif
+
 ifeq ($(strip $(UCIS_ENABLE)), yes)
     OPT_DEFS += -DUCIS_ENABLE
     UNICODE_COMMON = yes
@@ -93,10 +97,14 @@ endif
 
 ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
     OPT_DEFS += -DRGBLIGHT_ENABLE
-    SRC += ws2812.c
     SRC += $(QUANTUM_DIR)/rgblight.c
     CIE1931_CURVE = yes
     LED_BREATHING_TABLE = yes
+    ifeq ($(strip $(RGBLIGHT_CUSTOM_DRIVER)), yes)
+        OPT_DEFS += -DRGBLIGHT_CUSTOM_DRIVER
+    else
+	    SRC += ws2812.c
+    endif
 endif
 
 ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
@@ -115,6 +123,11 @@ ifeq ($(strip $(PRINTING_ENABLE)), yes)
     SRC += $(TMK_DIR)/protocol/serial_uart.c
 endif
 
+ifeq ($(strip $(AUTO_SHIFT_ENABLE)), yes)
+    OPT_DEFS += -DAUTO_SHIFT_ENABLE
+    SRC += $(QUANTUM_DIR)/process_keycode/process_auto_shift.c
+endif
+
 ifeq ($(strip $(SERIAL_LINK_ENABLE)), yes)
     SRC += $(patsubst $(QUANTUM_PATH)/%,%,$(SERIAL_SRC))
     OPT_DEFS += $(SERIAL_DEFS)
@@ -153,6 +166,15 @@ ifeq ($(strip $(LED_TABLES)), yes)
     SRC += $(QUANTUM_DIR)/led_tables.c
 endif
 
+ifeq ($(strip $(TERMINAL_ENABLE)), yes)
+    SRC += $(QUANTUM_DIR)/process_keycode/process_terminal.c
+    OPT_DEFS += -DTERMINAL_ENABLE
+endif
+
+ifeq ($(strip $(USB_HID_ENABLE)), yes)
+    include $(TMK_DIR)/protocol/usb_hid.mk
+endif
+
 QUANTUM_SRC:= \
     $(QUANTUM_DIR)/quantum.c \
     $(QUANTUM_DIR)/keymap_common.c \

docs/README.md

@@ -14,11 +14,11 @@ Otherwise, you can either download it directly ([zip](https://github.com/qmk/qmk
 
 Before you are able to compile, you'll need to [install an environment](getting_started_build_tools.md) for AVR or/and ARM development. Once that is complete, you'll use the `make` command to build a keyboard and keymap with the following notation:
 
-    make planck-rev4-default
+    make planck/rev4:default
 
-This would build the `rev4` revision of the `planck` with the `default` keymap. Not all keyboards have revisions (also called subprojects), in which case, it can be omitted:
+This would build the `rev4` revision of the `planck` with the `default` keymap. Not all keyboards have revisions (also called subprojects or folders), in which case, it can be omitted:
 
-    make preonic-default
+    make preonic:default
 
 ## How to customize {#how-to-customize}
 

docs/_summary.md

@@ -3,6 +3,7 @@
   * [Install Build Tools](getting_started_build_tools.md)
     * Alternative: [Vagrant Guide](getting_started_vagrant_guide.md)
   * [Build/Compile instructions](getting_started_make_guide.md)
+  * [Contributing to QMK](contributing.md)
   * [How to Use Github](getting_started_github.md)
 
 * [FAQ](faq.md)
@@ -21,6 +22,7 @@
   * [Leader Key](feature_leader_key.md)
   * [Macros](macros.md)
   * [Mouse keys](mouse_keys.md)
+  * [Pointing Device](feature_pointing_device.md)
   * [PS2 Mouse](feature_ps2_mouse.md)
   * [Space Cadet](space_cadet_shift.md)
   * [Tap Dance](tap_dance.md)
@@ -28,6 +30,7 @@
   * [Thermal Printer](feature_thermal_printer.md)
   * [Stenography](stenography.md)
   * [Unicode](unicode.md)
+  * [Terminal](feature_terminal.md)
 
 * Reference
   * [Glossary](glossary.md)
@@ -50,11 +53,11 @@
   * [The `config.h` File](config_options.md)
   * [Customizing Functionality](custom_quantum_functions.md)
   * [Documentation Best Practices](documentation_best_practices.md)
+  * [Documentation Templates](documentation_templates.md)
   * [Unit Testing](unit_testing.md)
 
 * For Makers and Modders
   * [Adding a keyboard to QMK](adding_a_keyboard_to_qmk.md)
-  * [Adding features to QMK](adding_features_to_qmk.md)
   * [Hand Wiring Guide](hand_wiring.md)
   * [ISP flashing guide](isp_flashing_guide.md)
   * [Modding your keyboard](modding_your_keyboard.md)

docs/adding_a_keyboard_to_qmk.md

@@ -4,7 +4,7 @@ We welcome all keyboard projects into QMK, but ask that you try to stick to a co
 
 ## Naming your directory/project
 
-All names should be lowercase alphanumeric, and separated by an underscore (`_`), but not begin with one. Dashes (`-`) aren't allow by our build system, and will confuse it with keymaps/subprojects. Your directory and your `.h` and `.c` files should have exactly the same name. Subprojects/revision should follow the same format. 
+All names should be lowercase alphanumeric, and separated by an underscore (`_`), but not begin with one. Your directory and your `.h` and `.c` files should have exactly the same name. All folders should follow the same format. 
 
 ## `readme.md`
 
@@ -26,7 +26,7 @@ When developing your keyboard, keep in mind that all warnings will be treated as
 
 ## Licenses
 
-If you're adapting your keyboard's setup from another project, but not using the same code, but sure to update the copyright header at the top of the files to show your name, it this format:
+If you're adapting your keyboard's setup from another project, but not using the same code, but sure to update the copyright header at the top of the files to show your name, in this format:
 
     Copyright 2017 Your Name <your@email.com>
     

docs/adding_features_to_qmk.md

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

docs/config_options.md

@@ -12,29 +12,25 @@ This is a c header file that is one of the first things included, and will persi
 
 // config options
 
-#ifdef SUBPROJECT_<subproject>
-    #include "<subproject>/config.h"
-#endif
-
 #endif
 ```
 
-This file contains config options that should apply to the whole keyboard, and won't change in subprojects, or most keymaps. The suproject block here only applies to keyboards with subprojects.
+This file contains config options that should apply to the whole keyboard, and won't change in revisions, or most keymaps. The revision block here only applies to keyboards with revisions.
 
-## Subproject
+## Revisions
 
 ```c
-#ifndef <subproject>_CONFIG_H
-#define <subproject>_CONFIG_H
+#ifndef <revision>_CONFIG_H
+#define <revision>_CONFIG_H
 
-#include "../config.h"
+#include "config_common.h"
 
 // config options
 
 #endif
 ```
 
-For keyboards that have subprojects, this file contains config options that should apply to only that subproject, and won't change in most keymaps.
+For keyboards that have revisions, this file contains config options that should apply to only that revisions, and won't change in most keymaps.
 
 ## Keymap
 
@@ -42,7 +38,7 @@ For keyboards that have subprojects, this file contains config options that shou
 #ifndef CONFIG_USER_H
 #define CONFIG_USER_H
 
-#include "../../config.h"
+#include "config_common.h"
 
 // config options
 

docs/contributing.md

@@ -0,0 +1,147 @@
+# How To Contribute
+
+👍🎉 First off, thanks for taking the time to read this and contribute! 🎉👍
+
+Third-party contributions help us grow and improve QMK. We want to make the pull request and contribution process useful and easy for both contributors and maintainers. To this end we've put together some guidelines for contributors to help your pull request be accepted without major changes.
+
+* [Project Overview](#project-overview)
+* [Coding Conventions](#coding-conventions)
+* [General Guidelines](#general-guidelines)
+* [What does the Code of Conduct mean for me?](#what-does-the-code-of-conduct-mean-for-me)
+
+## I Don't Want To Read This Whole Thing I Just Have a Question!
+
+If you'd like to ask questions about QMK you can do so on the [OLKB Subreddit](https://reddit.com/r/olkb) or on [Gitter](https://gitter.im/qmk/qmk_firmware).
+
+Please keep these things in mind:
+
+* It may take several hours for someone to respond to your question. Please be patient!
+* Everyone involved with QMK is donating their time and energy. We don't get paid to work on or answer questions about QMK.
+* Try to ask your question so it's as easy to answer as possible. If you're not sure how to do that these are some good guides:
+  * https://opensource.com/life/16/10/how-ask-technical-questions
+  * http://www.catb.org/esr/faqs/smart-questions.html
+
+# Project Overview
+
+QMK is largely written in C, with specific features and parts written in C++. It targets embedded processors found in keyboards, particularly AVR ([LUFA](http://www.fourwalledcubicle.com/LUFA.php)) and ARM ([ChibiOS](http://www.chibios.com)). If you are already well versed in Arduino programming you'll find a lot of the concepts and limitations familiar. Prior experience with Arduino is not required to successfully contribute to QMK.
+
+<!-- FIXME: We should include a list of resources for learning C here. -->
+
+# Where can I go for help?
+
+If you need help you can [open an issue](https://github.com/qmk/qmk_firmware/issues) or [chat on gitter](http://gitter.im/QMK/qmk_firmware).
+
+# How Do I Make a Contribution?
+
+Never made an open source contribution before? Wondering how contributions work in QMK? Here's a quick rundown!
+
+0. Sign up for a [GitHub](https://github.com) account.
+1. Put together a keymap to contribute, [find an issue](https://github.com/qmk/qmk_firmware/issues) you are interested in addressing, or [a feature](https://github.com/qmk/qmk_firmware/issues?q=is%3Aopen+is%3Aissue+label%3Afeature) you would like to add.
+2. Fork the repository associated with the issue to your GitHub account. This means that you will have a copy of the repository under `your-GitHub-username/qmk_firmware`.
+3. Clone the repository to your local machine using `git clone https://github.com/github-username/repository-name.git`.
+4. If you're working on a new feature consider opening an issue to talk with us about the work you're about to undertake.
+5. Create a new branch for your fix using `git checkout -b branch-name-here`.
+6. Make the appropriate changes for the issue you are trying to address or the feature that you want to add.
+7. Use `git add insert-paths-of-changed-files-here` to add the file contents of the changed files to the "snapshot" git uses to manage the state of the project, also known as the index.
+8. Use `git commit -m "Insert a short message of the changes made here"` to store the contents of the index with a descriptive message.
+9. Push the changes to your repository on GitHub using `git push origin branch-name-here`.
+10. Submit a pull request to [QMK Firmware](https://github.com/qmk/qmk_firmware/pull/new/master).
+11. Title the pull request with a short description of the changes made and the issue or bug number associated with your change. For example, you can title an issue like so "Added more log outputting to resolve #4352".
+12. In the description of the pull request explain the changes that you made, any issues you think exist with the pull request you made, and any questions you have for the maintainer. It's OK if your pull request is not perfect (no pull request is), the reviewer will be able to help you fix any problems and improve it!
+13. Wait for the pull request to be reviewed by a maintainer.
+14. Make changes to the pull request if the reviewing maintainer recommends them.
+15. Celebrate your success after your pull request is merged!
+
+# Coding conventions
+
+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 two spaces (soft tabs)
+* We use 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 use 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.
+
+# General Guidelines
+
+We have a few different types of changes in QMK, each requiring a different level of rigor. We'd like you to keep the following guidelines in mind no matter what type of change you're making.
+
+* Separate PR's into logical units. For example, do not submit one PR covering two separate features, instead submit a separate PR for each feature. 
+* Check for unnecessary whitespace with `git diff --check` before committing.
+* Make sure your code change actually compiles.
+  * Keymaps: Make sure that `make keyboard:your_new_keymap` does not return an error
+  * Keyboards: Make sure that `make keyboard:all` does not return any errors
+  * Core: Make sure that `make allkb` does not return any errors.
+* Make sure commit messages are understandable on their own. You should put a short description (no more than 70 characters) on the first line, the second line should be empty, and on the 3rd and later lines you should describe your commit in detail, if required. Example:
+
+```
+Adjust the fronzlebop for the kerpleplork
+
+The kerpleplork was intermittently failing with error code 23. The root cause was the fronzlebop setting, which causes the kerpleplork to activate every N iterations.
+
+Limited experimentation on the devices I have available shows that 7 is high enough to avoid confusing the kerpleplork, but I'd like to get some feedback from people with ARM devices to be sure.
+```
+
+## Documentation
+
+Documentation is one of the easiest ways to get started contributing to QMK. Finding places where the documentation is wrong or incomplete and fixing those is easy! We also very badly need someone to edit our documentation, so if you have editing skills but aren't sure where or how to jump in please [reach out for help](#where-can-i-go-for-help)!
+
+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/.
+
+## 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.
+
+* Write a `readme.md` using [the template](https://docs.qmk.fm/documentation_templates.html#).
+* 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.
+
+## Keyboards
+
+Keyboards are the raison d'être for QMK. Some keyboards are community maintained, while others are maintained by the people responsible for making a particular keyboard. The `readme.md` should tell you who maintains a particular keyboard. If you have questions relating to a particular keyboard you can [Open An Issue](https://github.com/qmk/qmk_firmware/issues) and tag the maintainer in your question.
+
+We also ask that you follow these guidelines: 
+
+* Write a `readme.md` using [the template](https://docs.qmk.fm/documentation_templates.html#).
+* Keep the number of commits reasonable or we will squash your PR
+* Do not lump core features in with new keyboards. Submit the feature first and then submit a separate PR for the keyboard.
+
+## Quantum/TMK Core
+
+Before you put a lot of work into building your new feature you should make sure you are implementing it in the best way. You can get a basic understanding of QMK by reading [Understaning QMK](understanding_qmk.html), which will take you on a tour of the QMK program flow. From here you should talk to us to get a sense of the best way to implement your idea. There are two main ways to do this:
+
+* [Chat on Gitter](https://gitter.im/qmk/qmk_firmware)
+* [Open an Issue](https://github.com/qmk/qmk_firmware/issues/new)
+
+Feature and Bug Fix PR's affect all keyboards. We are also in the process of restructuring QMK. For this reason it is especially important for significant changes to be discussed before implementation has happened. If you open a PR without talking to us first please be prepared to do some significant rework if your choices do not mesh well with our planned direction.
+
+Here are some things to keep in mind when working on your feature or bug fix.
+
+* **Disabled by default** - memory is a pretty limited on most chips QMK supports, and it's important that current keymaps aren't broken, so please allow your feature to be turned **on**, rather than being turned off. If you think it should be on by default, or reduces the size of the code, please talk with us about it.
+* **Compile locally before submitting** - hopefully this one is obvious, but things need to compile! Our Travis system will catch any issues, but it's generally faster for you to compile a few keyboards locally instead of waiting for the results to come back.
+* **Consider revisions and different chip-bases** - there are several keyboards that have revisions that allow for slightly different configurations, and even different chip-bases. Try to make a feature supported in ARM and AVR, or automatically disabled on platforms it doesn't work on.
+* **Explain your feature** - Document it in `docs/`, either as a new file or as part of an existing file. If you don't document it other people won't be able to benefit from your hard work.
+
+We also ask that you follow these guidelines: 
+
+* Keep the number of commits reasonable or we will squash your PR
+* Do not lump keyboards or keymaps in with core changes. Submit your core changes first.
+* Write [Unit Tests](http://docs.qmk.fm/unit_testing.html) for your feature
+* Follow the style of the file you are editing. If the style is unclear or there are mixed styles you should conform to the [coding conventions](#coding-conventions) above.
+
+## Refactoring
+
+To maintain a clear vision of how things are laid out in QMK we try to plan out refactors in-depth and have a collaborator make the changes. If you have an idea for refactoring, or suggestions, [open an issue](https://github.com/qmk/qmk_firmware/issues), we'd love to talk about how QMK can be improved.
+
+# What does the Code of Conduct mean for me?
+
+Our Code of Conduct means that you are responsible for treating everyone on the project with respect and courtesy regardless of their identity. If you are the victim of any inappropriate behavior or comments as described in our Code of Conduct, we are here for you and will do the best to ensure that the abuser is reprimanded appropriately, per our code.

docs/documentation_templates.md

@@ -0,0 +1,42 @@
+# Documentation Templates
+
+This page documents the templates you should use when submitting new Keymaps and Keyboards to QMK.
+
+## Keymap `readme.md` Template
+
+Most keymaps have an image depicting the layout. You can use [Keyboard Layout Editor](http://keyboard-layout-editor.com) to create an image. Upload it to [Imgur](http://imgur.com) or another hosting service, please do not include images in your Pull Request.
+
+Below the image you should write a short description to help people understand your keymap.
+
+```
+![Clueboard Layout Image](http://i.imgur.com/7Capi8W.png)
+
+# Default Clueboard Layout
+
+This is the default layout that comes flashed on every Clueboard. For the most
+part it's a straightforward and easy to follow layout. The only unusual key is
+the key in the upper left, which sends Escape normally, but Grave when any of
+the Ctrl, Alt, or GUI modifiers are held down.
+```
+
+## Keyboard `readme.md` Template
+
+```
+# Planck
+
+![Planck](http://i.imgur.com/q2M3uEU.jpg)
+
+A compact 40% (12x4) ortholinear keyboard kit made and sold by OLKB and Massdrop. [More info on qmk.fm](http://qmk.fm/planck/)
+
+Keyboard Maintainer: [Jack Humbert](https://github.com/jackhumbert)  
+Hardware Supported: Planck PCB rev1, rev2, rev3, rev4, Teensy 2.0  
+Hardware Availability: [OLKB.com](https://olkb.com), [Massdrop](https://www.massdrop.com/buy/planck-mechanical-keyboard?mode=guest_open)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make planck/rev4:default
+
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
+```
+
+There needs to be two spaces at the end of the `Keyboard Maintainer` and `Hardware Supported` lines for it to render correctly with Markdown.

docs/faq_build.md

@@ -13,7 +13,7 @@ In short when your controller is ATMega32u4,
 
 or just
 
-    $ sudo make <keyboard>-<keymap>-dfu
+    $ sudo make <keyboard>:<keymap>:dfu
 
 But to run `make` with root privilege is not good idea. Use former method if possible.
 

docs/faq_debug.md

@@ -92,7 +92,7 @@ First you have to compile frimware with this build option `NKRO_ENABLE` in **Mak
 
 Try `Magic` **N** command(`LShift+RShift+N` by default) when **NKRO** still doesn't work. You can use this command to toggle between **NKRO** and **6KRO** mode temporarily. In some situations **NKRO** doesn't work you need to switch to **6KRO** mode, in particular when you are in BIOS.
 
-If your firmeare built with `BOOTMAGIC_ENABLE` you need to turn its switch on by `BootMagic` **N** command(`Space+N` by default). This setting is stored in EEPROM and keeped over power cycles.
+If your firmware built with `BOOTMAGIC_ENABLE` you need to turn its switch on by `BootMagic` **N** command(`Space+N` by default). This setting is stored in EEPROM and keeped over power cycles.
 
 https://github.com/tmk/tmk_keyboard#boot-magic-configuration---virtual-dip-switch
 

docs/feature_auto_shift.md

@@ -0,0 +1,160 @@
+# Auto Shift: Why do we need a shift key?
+
+Tap a key and you get its character. Tap a key, but hold it *slightly* longer
+and you get its shifted state. Viola! No shift key needed!
+
+## Why Auto Shift?
+
+Many people suffer from various forms of RSI. A common cause is stretching your
+fingers repetitively long distances. For us on the keyboard, the pinky does that
+all too often when reaching for the shift key. Auto Shift looks to alleviate that
+problem.
+
+## How does it work?
+
+When you tap a key, it stays depressed for a short period of time before it is
+then released. This depressed time is a different length for everyone. Auto Shift
+defines a constant `AUTO_SHIFT_TIMEOUT` which is typically set to twice your
+normal pressed state time. When you press a key, a timer starts and then stops
+when you release the key. If the time depressed is greater than or equal to the
+`AUTO_SHIFT_TIMEOUT`, then a shifted version of the key is emitted. If the time
+is less than the `AUTO_SHIFT_TIMEOUT` time, then the normal state is emitted.
+
+## Are there limitations to Auto Shift?
+
+Yes, unfortunately.
+
+1. Key repeat will cease to work. For example, before if you wanted 20 'a'
+   characters, you could press and hold the 'a' key for a second or two. This no
+   longer works with Auto Shift because it is timing your depressed time instead
+   of emitting a depressed key state to your operating system.
+2. Auto Shift is disabled for any key press that is accompanied by one or more
+   modifiers. Thus, Ctrl+A that you hold for a really long time is not the same
+   as Ctrl+Shift+A.
+3. You will have characters that are shifted when you did not intend on shifting, and
+   other characters you wanted shifted, but were not. This simply comes down to
+   practice. As we get in a hurry, we think we have hit the key long enough
+   for a shifted version, but we did not. On the other hand, we may think we are
+   tapping the keys, but really we have held it for a little longer than
+   anticipated.
+
+## How do I enable Auto Shift?
+
+Add to your `rules.mk` in the keymap folder:
+
+    AUTO_SHIFT_ENABLE = YES
+
+If no `rules.mk` exists, you can create one.
+
+Then compile and install your new firmware with Auto Key enabled! That's it!
+
+## Configuring Auto Shift
+
+If desired, there is some configuration that can be done to change the
+behavior of Auto Shift. This is done by setting various variables the
+`config.h` file located in your keymap folder. If no `config.h` file exists, you can create one.
+
+A sample is
+
+    #ifndef CONFIG_USER_H
+    #define CONFIG_USER_H
+
+    #include "../../config.h"
+
+    #define AUTO_SHIFT_TIMEOUT 150
+    #define NO_AUTO_SHIFT_SPECIAL
+
+    #endif
+
+### AUTO_SHIFT_TIMEOUT (value in ms)
+
+This controls how long you have to hold a key before you get the shifted state.
+Obviously, this is different for everyone. For the common person, a setting of
+135 to 150 works great. However, one should start with a value of at least 175, which
+is the default value. Then work down from there. The idea is to have the shortest time required to get the shifted state without having false positives.
+
+Play with this value until things are perfect. Many find that all will work well
+at a given value, but one or two keys will still emit the shifted state on
+occassion. This is simply due to habit and holding some keys a little longer
+than others. Once you find this value, work on tapping your problem keys a little
+quicker than normal and you will be set.
+
+{% hint style='info' %}
+Auto Shift has three special keys that can help you get this value right very
+quick. See "Auto Shift Setup" for more details!
+{% endhint %}
+
+### NO_AUTO_SHIFT_SPECIAL (simple define)
+
+Do not Auto Shift special keys, which include -_, =+, [{, ]}, ;:, '", ,<, .>,
+and /?
+
+### NO_AUTO_SHIFT_NUMERIC (simple define)
+
+Do not Auto Shift numeric keys, zero through nine.
+
+### NO_AUTO_SHIFT_ALPHA (simple define)
+
+Do not Auto Shift alpha characters, which include A through Z.
+
+## Using Auto Shift Setup
+
+This will enable you to define three keys temporailiy to increase, decrease and report your `AUTO_SHIFT_TIMEOUT`.
+
+### Setup
+
+Map three keys temporarily in your keymap:
+
+| Key Name | Description                                         |
+|----------|-----------------------------------------------------|
+| KC_ASDN  | Lower the Auto Shift timeout variable (down)        |
+| KC_ASUP  | Raise the Auto Shift timeout variable (up)          |
+| KC_ASRP  | Report your current Auto Shift timeout value        |
+
+Compile and upload your new firmware.
+
+### Use
+
+It is important to note that during these tests, you should be typing
+completely normal and with no intention of shifted keys.
+
+1. Type multiple sentences of alphabetical letters.
+2. Observe any upper case letters.
+3. If there are none, press the key you have mapped to `KC_ASDN` to decrease
+   time Auto Shift timeout value and go back to step 1.
+4. If there are some upper case letters, decide if you need to work on tapping
+   those keys with less down time, or if you need to increase the timeout.
+5. If you decide to increase the timeout, press the key you have mapped to
+   `KC_ASUP` and go back to step 1.
+6. Once you are happy with your results, press the key you have mapped to
+   `KC_ASRP`. The keyboard will type by itself the value of your
+   `AUTO_SHIFT_TIMEOUT`.
+7. Update `AUTO_SHIFT_TIMEOUT` in your `config.h` with the value reported.
+8. Remove `AUTO_SHIFT_SETUP` from your `config.h`.
+9. Remove the key bindings `KC_ASDN`, `KC_ASUP` and `KC_ASRP`.
+10. Compile and upload your new firmware.
+
+#### An example run
+
+'''
+hello world. my name is john doe. i am a computer programmer playing with
+keyboards right now.
+
+[PRESS KC_ASDN quite a few times]
+
+heLLo woRLd. mY nAMe is JOHn dOE. i AM A compUTeR proGRaMMER PlAYiNG witH
+KEYboArDS RiGHT NOw.
+
+[PRESS KC_ASUP a few times]
+
+hello world. my name is john Doe. i am a computer programmer playing with
+keyboarDs right now.
+
+[PRESS KC_ASRP]
+
+115
+'''
+
+The keyboard typed `115` which represents your current `AUTO_SHIFT_TIMEOUT`
+value. You are now set! Practice on the *D* key a little bit that showed up
+in the testing and you'll be golden.

docs/feature_bootmagic.md

@@ -14,7 +14,7 @@ Shortcuts for bootmagic options. You can use these even when bootmagic is off.
 |`MAGIC_SWAP_RALT_RGUI`|Swap the right Alt and GUI keys|
 |`MAGIC_NO_GUI`|Disable the GUI key|
 |`MAGIC_SWAP_GRAVE_ESC`|Swap the Grave and Esc key.|
-|`MAGIC_SWAP_BACKSLASH_BACKSPACE`|Swap backslack and backspace|
+|`MAGIC_SWAP_BACKSLASH_BACKSPACE`|Swap backslash and backspace|
 |`MAGIC_HOST_NKRO`|Force NKRO on|
 |`MAGIC_SWAP_ALT_GUI`/`AG_SWAP`|Swap Alt and Gui on both sides|
 |`MAGIC_UNSWAP_CONTROL_CAPSLOCK`|Disable the Control/Capslock swap|

docs/feature_common_shortcuts.md

@@ -39,7 +39,7 @@ If you are just getting started with QMK you will want to keep everything simple
 
 ### Intermediate Users
 
-Sometimes you need more than one base layer. For example, if you want to switch between QWERTY and Dvorak, switch between layouts for different countries, or switch your layout for different videogames. Your base layers should always be the lowest numbered layers. When you have multiple base layers you should always treat them as multually exclusive. When one base layer is on the others are off. 
+Sometimes you need more than one base layer. For example, if you want to switch between QWERTY and Dvorak, switch between layouts for different countries, or switch your layout for different videogames. Your base layers should always be the lowest numbered layers. When you have multiple base layers you should always treat them as mutually exclusive. When one base layer is on the others are off. 
 
 ### Advanced Users
 
@@ -92,7 +92,7 @@ The following shortcuts automatically add `LSFT()` to keycodes to get commonly u
 | KC_RCBR | } |
 | KC_LABK | < |
 | KC_RABK | > |
-| KC_PIPE | | |
+| KC_PIPE | &#x7C; |
 | KC_COLN | : |
 
 ## Mod Tap

docs/feature_layouts.md

@@ -43,15 +43,15 @@ The folder name must be added to the keyboard's `rules.mk`:
 
     LAYOUTS = 60_ansi
 
-`LAYOUTS` can be appended in the subproject's `rules.mk`:
+`LAYOUTS` can be set in any keyboard folder level's `rules.mk`:
 
-    LAYOUTS += 60_iso
+    LAYOUTS = 60_iso
 
-but the `LAYOUT_<layout>` variable must be defined in `<subproject>.h` as well.
+but the `LAYOUT_<layout>` variable must be defined in `<folder>.h` as well.
 
 ## Tips for making layouts keyboard-agnostic
 
-Instead of using `#include "planck.h"`, you can use this line to include whatever `<keyboard>.h` (`<subproject>.h` should not be included here) file that is being compiled:
+Instead of using `#include "planck.h"`, you can use this line to include whatever `<keyboard>.h` (`<folder>.h` should not be included here) file that is being compiled:
 
     #include QMK_KEYBOARD_H
 
@@ -61,17 +61,16 @@ In your config.h, you can also use this variable to include the keyboard's `conf
 
 If you want to keep some keyboard-specific code, you can use these variables to escape it with an `#ifdef` statement:
 
-* `KEYBOARD_<keyboard>`
-* `SUBPROJECT_<subproject>`
+* `KEYBOARD_<folder1>_<folder2>`
 
 For example:
 
 ```c
 #ifdef KEYBOARD_planck
-    #ifdef SUBPROJECT_rev4
+    #ifdef KEYBOARD_planck_rev4
         planck_rev4_function();
     #endif
 #endif
 ```
 
-Note that the names are lowercase and match the folder/file names for the keyboard/subproject exactly.
+Note that the names are lowercase and match the folder/file names for the keyboard/revision exactly.

docs/feature_pointing_device.md

@@ -0,0 +1,47 @@
+## Pointing Device
+
+Pointing Device is a generic name for a feature intended to be generic: moving the system pointer arround.  There are certainly other options for it - like mousekeys - but this aims to be easily modifiable and lightweight.  You can implement custom keys to control functionality, or you can gather information from other peripherals and insert it directly here - let QMK handle the processing for you.
+
+To enable Pointing Device, uncomment the following line in your rules.mk:
+
+```
+POINTING_DEVICE_ENABLE = yes
+```
+
+To manipulate the mouse report, you can use the following functions:
+
+* `pointing_device_get_report()` - Returns the current report_mouse_t that represents the information sent to the host computer
+* `pointing_device_set_report(report_mouse_t newMouseReport)` - Overrides and saves the report_mouse_t to be sent to the host computer
+
+Keep in mind that a report_mouse_t (here "mouseReport") has the following properties:
+
+* `mouseReport.x` - this is a signed int from -127 to 127 (not 128, this is defined in USB HID spec) representing movement (+ to the right, - to the left) on the x axis.
+* `mouseReport.y` - this is a signed int from -127 to 127 (not 128, this is defined in USB HID spec) representing movement (+ upward, - downward) on the y axis.
+* `mouseReport.v` - this is a signed int from -127 to 127 (not 128, this is defined in USB HID spec) representing vertical scrolling (+ upward, - downward).
+* `mouseReport.h` - this is a signed int from -127 to 127 (not 128, this is defined in USB HID spec) representing horizontal scrolling (+ right, - left).
+* `mouseReport.buttons` - this is a uint8_t in which the last 5 bits are used.  These bits represent the mouse button state - bit 3 is mouse button 5, and bit 7 is mouse button 1.
+
+When the mouse report is sent, the x, y, v, and h values are set to 0 (this is done in "pointing_device_send()", which can be overridden to avoid this behavior).  This way, button states persist, but movement will only occur once.  For further customization, both `pointing_device_init` and `pointing_device_task` can be overridden.
+
+In the following example, a custom key is used to click the mouse and scroll 127 units vertically and horizontally, then undo all of that when released - because that's a totally useful function.  Listen, this is an example:
+
+```
+case MS_SPECIAL:
+	report_mouse_t currentReport = pointing_device_get_report();
+    if (record->event.pressed)
+    {
+        currentReport.v = 127;
+		currentReport.h = 127;
+		currentReport.buttons |= MOUSE_BTN1; //this is defined in report.h
+    }
+    else
+    {
+        currentReport.v = -127;
+        currentReport.h = -127;
+        currentReport.buttons &= ~MOUSE_BTN1;
+    }
+	pointing_device_set_report(currentReport);
+    break;
+```
+
+Recall that the mouse report is set to zero (except the buttons) whenever it is sent, so the scrolling would only occur once in each case.

docs/feature_ps2_mouse.md

@@ -227,6 +227,26 @@ Fine control over the scrolling is supported with the following defines:
 #define PS2_MOUSE_SCROLL_DIVISOR_V 2
 ```
 
+#### Invert mouse and scroll axes
+
+To invert the X and Y axes you can put:
+
+```
+#define PS2_MOUSE_INVERT_X
+#define PS2_MOUSE_INVERT_Y
+```
+
+into config.h.
+
+To reverse the scroll axes you can put:
+
+```
+#define PS2_MOUSE_INVERT_H
+#define PS2_MOUSE_INVERT_V
+```
+
+into config.h.
+
 #### Debug settings
 
 To debug the mouse, add `debug_mouse = true` or enable via bootmagic.

docs/feature_rgblight.md

@@ -1,8 +1,107 @@
 # RGB Lighting
 
-<!-- FIXME: Describe how to use RGB Lighting here. -->
+If you've installed addressable RGB lights on your keyboard you can control them with QMK. Currently we support the following addressable LEDs on Atmel AVR processors:
 
-## RGB Under Glow Mod
+* WS2811 and variants (WS2812, WS2812B, WS2812C, etc)
+* SK6812RGBW
+
+Some keyboards come with RGB LEDs pre-installed. Others have to have LEDs installed after the fact. See below for information on modifying your keyboard.
+
+## Selecting Colors
+
+QMK uses Hue, Saturation, and Value to set color rather than using RGB. You can use the color wheel below to see how this works. Changing the Hue will cycle around the circle. Saturation will affect the intensity of the color, which you can see as you move from the inner part to the outer part of the wheel. Value sets the overall brightness.
+
+<img src="gitbook/images/color-wheel.svg" alt="HSV Color Wheel" width="250">
+
+If you would like to learn more about HSV you can start with the [Wikipedia article](https://en.wikipedia.org/wiki/HSL_and_HSV).
+
+## Configuration
+
+Before RGB Lighting can be used you have to enable it in `rules.mk`:
+
+    RGBLIGHT_ENABLE = yes
+
+You can configure the behavior of the RGB lighting by defining values inside `config.h`.
+
+### Required Configuration
+
+At minimum you have to define the pin your LED strip is connected to and the number of LEDs connected.
+
+```c
+#define RGB_DI_PIN D7     // The pin the LED strip is connected to
+#define RGBLED_NUM 14     // Number of LEDs in your strip
+```
+
+### Optional Configuration
+
+You can change the behavior of the RGB Lighting by setting these configuration values. Use `#define <Option> <Value>` in a `config.h` at the keyboard, revision, or keymap level.
+
+| Option | Default Value | Description |
+|--------|---------------|-------------|
+| `RGBLIGHT_HUE_STEP` | 10 | How many hues you want to have available. |
+| `RGBLIGHT_SAT_STEP` | 17 | How many steps of saturation you'd like. |
+| `RGBLIGHT_VAL_STEP` | 17 | The number of levels of brightness you want. |
+
+### Animations
+
+If you have `#define RGBLIGHT_ANIMATIONS` in your `config.h` you will have a number of animation modes you can cycle through using the `RGB_MOD` key. You can also `#define` other options to tweak certain animations.
+
+| Option | Default Value | Description |
+|--------|---------------|-------------|
+| `RGBLIGHT_ANIMATIONS` | | `#define` this to enable animation modes. |
+| `RGBLIGHT_EFFECT_SNAKE_LENGTH` | 4 | The number of LEDs to light up for the "snake" mode. |
+| `RGBLIGHT_EFFECT_KNIGHT_LENGTH` | 3 | The number of LEDs to light up for the "knight" mode. |
+| `RGBLIGHT_EFFECT_KNIGHT_OFFSET` | 0 | Start the knight animation this many LEDs from the start of the strip. |
+| `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. Specified in ms. |
+| `RGBLIGHT_EFFECT_CHRISTMAS_STEP` | 2 | How many LED's to group the red/green colors by for the christmas mode. |
+
+You can also tweak the behavior of the animations by defining these consts in your `keymap.c`. These mostly affect the speed different modes animate at.
+
+```c
+// How long (in ms) to wait between animation steps for the breathing mode
+const uint8_t RGBLED_BREATHING_INTERVALS[] PROGMEM = {30, 20, 10, 5};
+
+// How long (in ms) to wait between animation steps for the rainbow mode
+const uint8_t RGBLED_RAINBOW_MOOD_INTERVALS[] PROGMEM = {120, 60, 30};
+
+// How long (in ms) to wait between animation steps for the swirl mode
+const uint8_t RGBLED_RAINBOW_SWIRL_INTERVALS[] PROGMEM = {100, 50, 20};
+
+// How long (in ms) to wait between animation steps for the snake mode
+const uint8_t RGBLED_SNAKE_INTERVALS[] PROGMEM = {100, 50, 20};
+
+// How long (in ms) to wait between animation steps for the knight modes
+const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {127, 63, 31};
+
+// These control which colors are selected for the gradient mode
+const uint16_t RGBLED_GRADIENT_RANGES[] PROGMEM = {360, 240, 180, 120, 90};
+```
+
+## RGB Lighting Keycodes
+
+These control the RGB Lighting functionality.
+
+| Long Name | Short Name | Description |
+|-----------|------------|-------------|
+||`RGB_TOG`|toggle on/off|
+||`RGB_MOD`|cycle through modes|
+||`RGB_HUI`|hue increase|
+||`RGB_HUD`|hue decrease|
+||`RGB_SAI`|saturation increase|
+||`RGB_SAD`|saturation decrease|
+||`RGB_VAI`|value (brightness) increase|
+||`RGB_VAD`|value (brightness) decrease|
+|`RGB_MODE_PLAIN`|`RGB_M_P `| Switch to the static no animation mode |
+|`RGB_MODE_BREATHE`|`RGB_M_B`| Switch to the breathing mode |
+|`RGB_MODE_RAINBOW`|`RGB_M_R`| Switch to the rainbow mode ||
+|`RGB_MODE_SWIRL`|`RGB_M_SW`| Switch to the swirl mode |
+|`RGB_MODE_SNAKE`|`RGB_M_SN`| Switch to the snake mode |
+|`RGB_MODE_KNIGHT`|`RGB_M_K`| Switch to the knight animation |
+|`RGB_MODE_XMAS`|`RGB_M_X`| Switch to the Christmas animation |
+|`RGB_MODE_GRADIENT`|`RGB_M_G`| Switch to the static gradient mode |
+
+## Hardware Modification
 
 ![Planck with RGB Underglow](https://raw.githubusercontent.com/qmk/qmk_firmware/master/keyboards/planck/keymaps/yang/planck-with-rgb-underglow.jpg)
 
@@ -17,33 +116,6 @@ In order to use the underglow animation functions, you need to have `#define RGB
 Please add the following options into your config.h, and set them up according your hardware configuration. These settings are for the `F4` pin by default:
 
     #define RGB_DI_PIN F4     // The pin your RGB strip is wired to
-    #define RGBLIGHT_ANIMATIONS    // Require for fancier stuff (not compatible with audio)
     #define RGBLED_NUM 14     // Number of LEDs
-    #define RGBLIGHT_HUE_STEP 10
-    #define RGBLIGHT_SAT_STEP 17
-    #define RGBLIGHT_VAL_STEP 17
 
 You'll need to edit `RGB_DI_PIN` to the pin you have your `DI` on your RGB strip wired to.
-
-The firmware supports 5 different light effects, and the color (hue, saturation, brightness) can be customized in most effects. To control the underglow, you need to modify your keymap file to assign those functions to some keys/key combinations. For details, please check this keymap. `keyboards/planck/keymaps/yang/keymap.c`
-
-### WS2812 Wiring
-
-![WS2812 Wiring](https://raw.githubusercontent.com/qmk/qmk_firmware/master/keyboards/planck/keymaps/yang/WS2812-wiring.jpg)
-
-Please note the USB port can only supply a limited amount of power to the keyboard (500mA by standard, however, modern computer and most usb hubs can provide 700+mA.). According to the data of NeoPixel from Adafruit, 30 WS2812 LEDs require a 5V 1A power supply, LEDs used in this mod should not more than 20.
-
-## RGB Lighting Keycodes
-
-This controls the RGB Lighting functionality. Most keyboards use WS2812 (and compatible) LEDs for underlight or case lighting.
-
-|Name|Description|
-|----|-----------|
-|`RGB_TOG`|toggle on/off|
-|`RGB_MOD`|cycle through modes|
-|`RGB_HUI`|hue increase|
-|`RGB_HUD`|hue decrease|
-|`RGB_SAI`|saturation increase|
-|`RGB_SAD`|saturation decrease|
-|`RGB_VAI`|value increase|
-|`RGB_VAD`|value decrease|

docs/feature_terminal.md

@@ -0,0 +1,80 @@
+# Terminal
+
+> This feature is currently *huge* at 4400 bytes, and should probably only be put on boards with a lot of memory, or for fun.
+
+The terminal feature is a command-line-like interface designed to communicate through a text editor with keystrokes. It's beneficial to turn off auto-indent features in your editor.
+
+To enable, stick this in your `rules.mk` or `Makefile`:
+
+    TERMINAL_ENABLE = yes
+
+And use the `TERM_ON` and `TERM_OFF` keycodes to turn it on or off.
+
+When enabled, a `> ` prompt will appear, where you'll be able to type, backspace (a bell will ding if you reach the beginning and audio is enabled), and hit enter to send the command. Arrow keys are currently disabled so it doesn't get confused. Moving your cursor around with the mouse is discouraged.
+
+`#define TERMINAL_HELP` enables some other output helpers that aren't really needed with this page.
+
+## Future ideas
+
+* Keyboard/user-extendable commands
+* Smaller footprint
+* Arrow key support
+* Command history
+* SD card support
+* LCD support for buffer display
+* Keycode -> name string LUT
+* Layer status
+* *Analog/digital port read/write*
+* RGB mode stuff
+* Macro definitions
+* EEPROM read/write
+* Audio control
+
+## Current commands
+
+### `about`
+
+Prints out the current version of QMK with a build date:
+
+```
+> about
+QMK Firmware
+  v0.5.115-7-g80ed73-dirty
+  Built: 2017-08-29-20:24:44
+```
+
+### `help`
+
+Prints out the available commands:
+
+```
+> help
+commands available:
+  about help keycode keymap exit
+```
+
+### `keycode <layer> <row> <col>`
+
+Prints out the keycode value of a certain layer, row, and column:
+
+```
+> keycode 0 1 0
+0x29 (41)
+```
+
+### `keymap <layer>`
+
+Prints out the entire keymap for a certain layer
+
+```
+> keymap 0
+0x002b, 0x0014, 0x001a, 0x0008, 0x0015, 0x0017, 0x001c, 0x0018, 0x000c, 0x0012, 0x0013, 0x002a, 
+0x0029, 0x0004, 0x0016, 0x0007, 0x0009, 0x000a, 0x000b, 0x000d, 0x000e, 0x000f, 0x0033, 0x0034, 
+0x00e1, 0x001d, 0x001b, 0x0006, 0x0019, 0x0005, 0x0011, 0x0010, 0x0036, 0x0037, 0x0038, 0x0028, 
+0x5cd6, 0x00e0, 0x00e2, 0x00e3, 0x5cd4, 0x002c, 0x002c, 0x5cd5, 0x0050, 0x0051, 0x0052, 0x004f,
+> 
+```
+
+### `exit`
+
+Exits the terminal - same as `TERM_OFF`.

docs/features.md

@@ -102,4 +102,4 @@ case MACRO_RAISED:
     update_tri_layer(LAYER_LOWER, LAYER_RAISED, LAYER_ADJUST);
   }
   break;
-```
+```

docs/getting_started_build_tools.md

@@ -36,12 +36,23 @@ Debian/Ubuntu example:
     sudo apt-get update
     sudo apt-get install gcc unzip wget zip gcc-avr binutils-avr avr-libc dfu-programmer dfu-util gcc-arm-none-eabi binutils-arm-none-eabi libnewlib-arm-none-eabi
 
-# Mac
+## Nix
+
+If you're on [NixOS](https://nixos.org/), or have Nix installed on Linux or macOS, run `nix-shell` from the repository root to get a build environment.
+
+By default, this will download compilers for both AVR and ARM. If you don't need both, disable the `avr` or `arm` arguments, e.g.:
+
+    nix-shell --arg arm false
+
+## Mac
 If you're using [homebrew,](http://brew.sh/) you can use the following commands:
 
     brew tap osx-cross/avr
-    brew install avr-libc
+    brew tap PX4/homebrew-px4
+    brew update
+    brew install avr-gcc
     brew install dfu-programmer
+    brew install gcc-arm-none-eabi
 
 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-libc can take over 20 minutes and exhibit high CPU usage.
 
@@ -110,10 +121,10 @@ If this is a bit complex for you, Docker might be the turn-key solution you need
 # modify the keymap and keyboard assigment to compile what you want
 # defaults are ergodox/default
 
-docker run -e keymap=gwen -e subproject=ez -e keyboard=ergodox --rm -v $('pwd'):/qmk:rw edasque/qmk_firmware
+docker run -e keymap=gwen -e keyboard=ergodox_ez --rm -v $('pwd'):/qmk:rw edasque/qmk_firmware
 
 # On windows docker seems to have issue with VOLUME tag in Dockerfile, and $('pwd') won't print a windows compliant path, use full path instead like this
-docker run -e keymap=default -e subproject=ez -e keyboard=ergobox --rm -v D:/Users/Sacapuces/Documents/Repositories/qmk:/qmk:rw edasque/qmk_firmware
+docker run -e keymap=default -e keyboard=ergobox_ez --rm -v D:/Users/Sacapuces/Documents/Repositories/qmk:/qmk:rw edasque/qmk_firmware
 
 ```
 

docs/getting_started_make_guide.md

@@ -1,37 +1,23 @@
 # More detailed make instruction
 
-The full syntax of the `make` command is the following, but parts of the command can be left out if you run it from other directories than the `root` (as you might already have noticed by reading the simple instructions).
+The full syntax of the `make` command is `<keyboard_folder>:<keymap>:<target>`, where:
 
-`<keyboard>-<subproject>-<keymap>-<target>`, where:
-
-* `<keyboard>` is the name of the keyboard, for example `planck`
-  * Use `allkb` to compile all keyboards
-* `<subproject>` is the name of the subproject (revision or sub-model of the keyboard). For example, for Ergodox it can be `ez` or `infinity`, and for Planck `rev3` or `rev4`.
-  * If the keyboard doesn't have any subprojects, it can be left out
-  * To compile the default subproject, you can leave it out, or specify `defaultsp`
-  * Use `allsp` to compile all subprojects
+* `<keyboard_folder>` is the path of the keyboard, for example `planck`
+  * Use `all` to compile all keyboards
+  * Specify the path to compile a revision, for example `planck/rev4` or `planck/rev3` 
+  * If the keyboard doesn't have any folders, it can be left out
+  * To compile the default folder, you can leave it out
 * `<keymap>` is the name of the keymap, for example `algernon`
-  * Use `allkm` to compile all keymaps
+  * Use `all` to compile all keymaps
 * `<target>` will be explained in more detail below.
 
-**Note:** When you leave some parts of the command out, you should also remove the dash (`-`).
-
-As mentioned above, there are some shortcuts, when you are in a:
-
-* `keyboard` folder, the command will automatically fill the `<keyboard>` part. So you only need to type `<subproject>-<keymap>-<target>`
-* `subproject` folder, it will fill in both `<keyboard>` and `<subproject>`
-* `keymap` folder, then `<keyboard>` and `<keymap>` will be filled in. If you need to specify the `<subproject>` use the following syntax `<subproject>-<target>`
-  * Note in order to support this shortcut, the keymap needs its own Makefile
-* `keymap` folder of a `subproject`, then everything except the `<target>` will be filled in
-
 The `<target>` means the following
 * If no target is given, then it's the same as `all` below
-* `all` compiles the keyboard and generates a `<keyboard>_<keymap>.hex` file in whichever folder you run `make` from. These files are ignored by git, so don't worry about deleting them when committing/creating pull requests.
-* `dfu`, `teensy` or `dfu-util`, compile and upload the firmware to the keyboard. If the compilation fails, then nothing will be uploaded. The programmer to use depends on the keyboard. For most keyboards it's `dfu`, but for Infinity 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** that some operating systems needs root access for these commands to work, so in that case you need to run for example `sudo make dfu`.
+* `all` compiles as many keyboard/revision/keymap combinations as specified. For example, `make planck/rev4:default:all` will generate a single .hex, while `make planck/rev4:all` will generate a hex for every keymap available to the planck.
+* `dfu`, `teensy` or `dfu-util`, compile and upload the firmware to the keyboard. If the compilation fails, then nothing will be uploaded. The programmer to use depends on the keyboard. For most keyboards it's `dfu`, but for ChibiOS keyboards you should use `dfu-util`, and `teensy` for standard Teensys. To find out which command you should use for your keyboard, check the keyboard specific readme. 
+ * **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.
 
-Some other targets are supported but, but not important enough to be documented here. Check the source code of the make files for more information.
-
 You can also add extra options at the end of the make command line, after the target
 
 * `make COLOR=false` - turns off color output
@@ -43,26 +29,11 @@ The make command itself also has some additional options, type `make --help` for
 
 Here are some examples commands
 
-* `make allkb-allsp-allkm` builds everything (all keyboards, all subprojects, all keymaps). Running just `make` from the `root` will also run this.
-* `make` from within a `keyboard` directory, is the same as `make keyboard-allsp-allkm`, which compiles all subprojects and keymaps of the keyboard. **NOTE** that this behaviour has changed. Previously it compiled just the default keymap.
-* `make ergodox-infinity-algernon-clean` will clean the build output of the Ergodox Infinity keyboard. This example uses the full syntax and can be run from any folder with a `Makefile`
-* `make dfu COLOR=false` from within a keymap folder, builds and uploads the keymap, but without color output.
+* `make all:all` builds everything (all keyboard folders, all keymaps). Running just `make` from the `root` will also run this.
+* `make ergodox_infinity:algernon:clean` will clean the build output of the Ergodox Infinity keyboard. 
+* `make planck/rev4:default:dfu COLOR=false` builds and uploads the keymap without color output.
 
-# The `Makefile`
-
-There are 5 different `make` and `Makefile` locations:
-
-* root (`/`)
-* keyboard (`/keyboards/<keyboard>/`)
-* keymap (`/keyboards/<keyboard>/keymaps/<keymap>/`)
-* subproject (`/keyboards/<keyboard>/<subproject>`)
-* subproject keymap (`/keyboards/<keyboard>/<subproject>/keymaps/<keymap>`)
-
-The root contains the code used to automatically figure out which keymap or keymaps to compile based on your current directory and commandline arguments. It's considered stable, and shouldn't be modified. The keyboard one will contain the MCU set-up and default settings for your keyboard, and shouldn't be modified unless you are the producer of that keyboard. The keymap Makefile can be modified by users, and is optional. It is included automatically if it exists. You can see an example [here](https://github.com/qmk/qmk_firmware/blob/master/doc/keymap_makefile_example.mk) - the last few lines are the most important. The settings you set here will override any defaults set in the keyboard Makefile. **The file is required if you want to run `make` in the keymap folder.**
-
-For keyboards and subprojects, the make files are split in two parts `Makefile` and `rules.mk`. All settings can be found in the `rules.mk` file, while the `Makefile` is just there for support and including the root `Makefile`. Keymaps contain just one `Makefile` for simplicity.
-
-## Makefile options
+## `rules.mk` options
 
 Set these variables to `no` to disable them, and `yes` to enable them.
 
@@ -164,8 +135,6 @@ This enables [key lock](key_lock.md). This consumes an additional 260 bytes.
 
 ## Customizing Makefile options on a per-keymap basis
 
-If your keymap directory has a file called `Makefile` (note the filename), any Makefile options you set in that file will take precedence over other Makefile options for your particular keyboard.
+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.
 
-So let's say your keyboard's makefile has `BACKLIGHT_ENABLE = yes` (or maybe doesn't even list the `BACKLIGHT_ENABLE` option, which would cause it to be off). You want your particular keymap to not have the debug console, so you make a file called `Makefile` and specify `BACKLIGHT_ENABLE = no`.
-
-You can use the `docs/keymap_makefile_example.md` as a template/starting point.
+So let's say your keyboard's `rules.mk` has `BACKLIGHT_ENABLE = yes`. You want your particular keyboard to not have the backlight, so you make a file called `rules.mk` and specify `BACKLIGHT_ENABLE = no`.

docs/gitbook/images/color-wheel.svg

@@ -0,0 +1,441 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Generator: Adobe Illustrator 15.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg
+    xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    xmlns="http://www.w3.org/2000/svg"
+    xmlns:dc="http://purl.org/dc/elements/1.1/"
+    xmlns:ns1="http://sozi.baierouge.fr"
+    xmlns:cc="http://web.resource.org/cc/"
+    xmlns:xlink="http://www.w3.org/1999/xlink"
+    xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+    id="Layer_1"
+    enable-background="new 0 0 360 360"
+    xml:space="preserve"
+    viewBox="0 0 360 360"
+    version="1.1"
+    y="0px"
+    x="0px"
+  >
+<g
+    >
+</g
+  >
+<g
+    >
+	<g
+      >
+		<path
+          d="m193.8 167.46l113.52-113.89c-23.457-23.36-50.2-38.727-82.193-47.23l-41.313 155.45c3.15 0.84 7.66 3.37 9.98 5.67z"
+          fill="#E0C3D3"
+      />
+		<path
+          d="m209.95 151.26l97.367-97.688c-23.457-23.36-50.2-38.727-82.193-47.23l-35.43 133.29c7.71 1.86 14.76 5.91 20.25 11.63z"
+          fill="#E0A0C3"
+      />
+		<path
+          d="m225.94 135.21l81.375-81.643c-23.457-23.36-50.2-38.727-82.193-47.23l-29.61 111.4c11.55 2.89 22.11 8.95 30.42 17.47z"
+          fill="#E080B5"
+      />
+		<path
+          d="m241.95 119.15l65.369-65.585c-23.457-23.36-50.2-38.727-82.193-47.23l-23.784 89.491c15.38 3.919 29.46 12.004 40.6 23.324z"
+          fill="#E061A7"
+      />
+		<path
+          d="m257.95 103.1l49.371-49.533c-23.457-23.36-50.2-38.727-82.193-47.23l-17.962 67.589c19.22 4.944 36.82 15.052 50.78 29.174z"
+          fill="#E04198"
+      />
+		<path
+          d="m273.95 87.05l33.373-33.482c-23.457-23.36-50.2-38.727-82.193-47.23l-12.142 45.687c23.07 5.968 44.18 18.099 60.96 35.025z"
+          fill="#E0228B"
+      />
+		<path
+          d="m289.94 70.999l17.375-17.431c-23.457-23.36-50.2-38.728-82.193-47.231l-6.321 23.784c26.91 6.994 51.54 21.148 71.13 40.878z"
+          fill="#E10071"
+      />
+	</g
+    >
+	<g
+      >
+		<path
+          d="m174.73 162.13c2.934-0.792 6.094-0.876 8.876-0.292l41-155.36c-31.994-8.502-61.625-8.332-93.483 0.274l42.101 155.85c-0.01-0.02 1.13-0.37 1.5-0.47z"
+          fill="#FFD9D9"
+      />
+		<path
+          d="m168.93 139.99c6.926-1.871 14.036-1.906 20.556-0.349l35.12-133.16c-31.994-8.502-61.625-8.332-93.483 0.274l36.127 133.73c0.95-0.27 1.19-0.36 1.67-0.49z"
+          fill="#FFB6B6"
+      />
+		<path
+          d="m163.03 118.12c10.904-2.946 22.03-2.917 32.267-0.373l29.31-111.27c-31.994-8.502-61.625-8.332-93.483 0.274l30.218 111.86c0.96-0.27 1.19-0.36 1.68-0.49z"
+          fill="#FF8F8F"
+      />
+		<path
+          d="m157.12 96.243c14.884-4.021 30.029-3.944 43.982-0.413l23.51-89.354c-31.994-8.502-61.625-8.332-93.483 0.274l24.304 89.968c0.96-0.268 1.2-0.344 1.69-0.475z"
+          fill="#FF6E6E"
+      />
+		<path
+          d="m151.21 74.369c18.863-5.096 38.024-4.964 55.695-0.446l17.71-67.447c-31.994-8.502-61.625-8.332-93.483 0.274l18.395 68.094c0.96-0.267 1.2-0.344 1.69-0.475z"
+          fill="#FF4848"
+      />
+		<path
+          d="m145.06 52.56c22.919-6.191 46.298-6.016 67.745-0.456l11.81-45.628c-31.994-8.502-61.625-8.332-93.483 0.274l12.484 46.214c0.97-0.263 1.13-0.317 1.45-0.404z"
+          fill="#FF2424"
+      />
+		<path
+          d="m139.15 30.685c26.906-7.269 54.312-7.036 79.48-0.483l5.978-23.726c-31.994-8.502-61.625-8.332-93.483 0.274l6.575 24.34c0.97-0.262 1.13-0.318 1.45-0.405z"
+          fill="#FF0000"
+      />
+	</g
+    >
+	<g
+      >
+		<path
+          d="m173.23 162.6l-42.1-155.85c-31.858 8.606-56.824 23.185-80.185 46.64l114.57 114.36c2.08-2.33 4.86-4.17 7.71-5.15z"
+          fill="#FFEBD9"
+      />
+		<path
+          d="m167.25 140.48l-36.12-133.73c-31.858 8.606-56.824 23.185-80.185 46.64l98.442 98.288c4.77-5.09 11.17-9.11 17.86-11.2z"
+          fill="#FFD7B3"
+      />
+		<path
+          d="m161.34 118.61l-30.21-111.86c-31.858 8.606-56.824 23.185-80.185 46.64l82.386 82.283c7.49-7.82 17.47-13.93 28.01-17.06z"
+          fill="#FFC48F"
+      />
+		<path
+          d="m155.43 96.719l-24.3-89.969c-31.858 8.606-56.824 23.185-80.185 46.64l66.336 66.282c10.2-10.55 23.74-18.78 38.15-22.951z"
+          fill="#FFB26C"
+      />
+		<path
+          d="m149.52 74.845l-18.39-68.095c-31.858 8.606-56.824 23.185-80.185 46.64l50.287 50.283c12.91-13.273 30.02-23.612 48.29-28.825z"
+          fill="#FF9F48"
+      />
+		<path
+          d="m143.61 52.964l-12.48-46.214c-31.858 8.606-56.824 23.185-80.185 46.64l34.05 34.204c15.705-16.028 35.495-28.198 58.615-34.63z"
+          fill="#FF8C24"
+      />
+		<path
+          d="m137.7 31.091l-6.575-24.34c-31.858 8.606-56.824 23.185-80.185 46.64l17.99 18.216c18.435-18.762 41.795-33.041 68.775-40.516z"
+          fill="#FF8000"
+      />
+	</g
+    >
+	<g
+      >
+		<path
+          d="m166.24 167.56l-114.82-114.3c-23.36 23.457-36.884 48.514-45.386 80.507l155.98 41.453c0.85-3.15 1.92-5.35 4.23-7.66z"
+          fill="#FFFED9"
+      />
+		<path
+          d="m149.96 151.35l-98.535-98.09c-23.36 23.457-36.884 48.514-45.386 80.507l133.85 35.573c1.8-6.74 5.26-12.94 10.07-17.99z"
+          fill="#FFFDB3"
+      />
+		<path
+          d="m133.9 135.37l-82.475-82.11c-23.36 23.457-36.884 48.514-45.386 80.507l111.95 29.753c2.82-10.58 8.31-20.29 15.91-28.15z"
+          fill="#FFFC8F"
+      />
+		<path
+          d="m117.84 119.37l-66.415-66.11c-23.36 23.457-36.884 48.514-45.386 80.507l90.037 23.929c3.845-14.42 11.364-27.64 21.764-38.33z"
+          fill="#FFFB6C"
+      />
+		<path
+          d="m101.78 103.39l-50.355-50.13c-23.36 23.457-36.884 48.514-45.386 80.507l68.136 18.108c4.869-18.26 14.403-34.99 27.605-48.49z"
+          fill="#FFFA48"
+      />
+		<path
+          d="m85.716 87.398l-34.291-34.138c-23.36 23.457-36.884 48.514-45.386 80.507l46.235 12.288c5.893-22.09 17.445-42.34 33.442-58.662z"
+          fill="#FFF924"
+      />
+		<path
+          d="m69.657 71.411l-18.232-18.151c-23.36 23.457-36.884 48.514-45.386 80.507l24.334 6.468c6.917-25.93 20.488-49.694 39.284-68.829z"
+          fill="#FFFF00"
+      />
+	</g
+    >
+	<g
+      >
+		<path
+          d="m162.13 185.27c-0.792-2.934-0.647-7.06-0.061-9.842l-155.89-41.15c-8.503 31.994-8.034 62.733 0.572 94.591l155.85-42.1c-0.02 0.01-0.37-1.13-0.47-1.5z"
+          fill="#EBFFD9"
+      />
+		<path
+          d="m139.99 191.07c-1.963-7.268-1.891-14.725-0.095-21.517l-133.72-35.27c-8.503 31.994-8.034 62.733 0.572 94.591l133.73-36.127c-0.27-0.96-0.36-1.19-0.49-1.67z"
+          fill="#D8FFB6"
+      />
+		<path
+          d="m118.12 196.98c-3.039-11.249-2.905-22.722-0.121-33.231l-111.82-29.47c-8.503 31.994-8.034 62.733 0.572 94.591l111.86-30.218c-0.27-0.96-0.36-1.19-0.49-1.67z"
+          fill="#C5FF92"
+      />
+		<path
+          d="m96.244 202.89c-4.114-15.228-3.942-30.725-0.169-44.949l-89.897-23.66c-8.503 31.994-8.034 62.733 0.572 94.591l89.968-24.304c-0.268-0.97-0.343-1.2-0.474-1.68z"
+          fill="#B1FF6C"
+      />
+		<path
+          d="m74.371 208.8c-5.189-19.208-4.962-38.724-0.201-56.666l-67.992-17.85c-8.503 31.994-8.034 62.733 0.572 94.591l68.094-18.395c-0.267-0.96-0.343-1.2-0.473-1.68z"
+          fill="#9DFF48"
+      />
+		<path
+          d="m52.563 214.95c-6.285-23.265-6.011-46.996-0.205-68.714l-46.18-11.96c-8.503 31.994-8.034 62.733 0.572 94.591l46.214-12.484c-0.263-0.97-0.315-1.12-0.401-1.44z"
+          fill="#8AFF24"
+      />
+		<path
+          d="m30.688 220.86c-7.362-27.251-7.029-55.011-0.229-80.452l-24.28-6.125c-8.503 31.994-8.034 62.733 0.572 94.591l24.34-6.575c-0.264-0.97-0.317-1.12-0.403-1.44z"
+          fill="#71FF00"
+      />
+	</g
+    >
+	<g
+      >
+		<path
+          d="m162.6 186.77l-155.85 42.1c8.606 31.857 23.185 56.824 46.641 80.185l114.36-114.57c-2.33-2.09-4.17-4.87-5.15-7.72z"
+          fill="#DCFFDC"
+      />
+		<path
+          d="m140.48 192.75l-133.73 36.12c8.606 31.857 23.185 56.824 46.641 80.185l98.286-98.442c-5.1-4.78-9.11-11.18-11.2-17.87z"
+          fill="#B6FFB6"
+      />
+		<path
+          d="m118.61 198.66l-111.86 30.21c8.606 31.857 23.185 56.824 46.641 80.185l82.281-82.387c-7.82-7.49-13.93-17.47-17.06-28.01z"
+          fill="#92FF92"
+      />
+		<path
+          d="m96.719 204.57l-89.969 24.3c8.606 31.857 23.185 56.824 46.641 80.185l66.28-66.336c-10.55-10.2-18.78-23.74-22.951-38.15z"
+          fill="#6EFF6E"
+      />
+		<path
+          d="m74.845 210.48l-68.095 18.39c8.606 31.857 23.185 56.824 46.641 80.185l50.281-50.287c-13.274-12.92-23.614-30.02-28.825-48.29z"
+          fill="#4AFF4A"
+      />
+		<path
+          d="m52.964 216.39l-46.214 12.48c8.606 31.857 23.185 56.824 46.641 80.185l34.202-34.049c-16.028-15.71-28.198-35.5-34.629-58.62z"
+          fill="#27FF27"
+      />
+		<path
+          d="m31.091 222.3l-24.34 6.575c8.606 31.857 23.185 56.824 46.641 80.185l18.214-17.989c-18.763-18.43-33.043-41.79-40.515-68.77z"
+          fill="#00FF00"
+      />
+	</g
+    >
+	<g
+      >
+		<path
+          d="m167.59 193.87l-114.31 114.78c23.455 23.359 47.388 37.112 79.381 45.616l41.606-156.55c-3.16-0.85-4.37-1.55-6.68-3.85z"
+          fill="#DCFFED"
+      />
+		<path
+          d="m151.42 210.11l-98.14 98.54c23.455 23.359 47.388 37.112 79.381 45.616l35.721-134.41c-6.34-1.86-12.17-5.21-16.96-9.75z"
+          fill="#B6FFD9"
+      />
+		<path
+          d="m135.43 226.16l-82.15 82.49c23.455 23.359 47.388 37.112 79.381 45.616l29.9-112.51c-10.18-2.89-19.52-8.26-27.13-15.6z"
+          fill="#92FFC6"
+      />
+		<path
+          d="m119.43 242.22l-66.15 66.43c23.456 23.359 47.388 37.112 79.381 45.616l24.079-90.603c-14.02-3.92-26.87-11.31-37.31-21.45z"
+          fill="#6EFFB3"
+      />
+		<path
+          d="m103.44 258.28l-50.16 50.37c23.455 23.359 47.388 37.112 79.381 45.616l18.258-68.701c-17.86-4.95-34.22-14.35-47.48-27.29z"
+          fill="#4AFFA0"
+      />
+		<path
+          d="m87.451 274.34l-34.17 34.31c23.455 23.359 47.388 37.112 79.381 45.616l12.438-46.801c-21.69-5.97-41.58-17.4-57.649-33.13z"
+          fill="#27FF8D"
+      />
+		<path
+          d="m71.459 290.39l-18.179 18.26c23.455 23.359 47.388 37.112 79.381 45.616l6.618-24.9c-25.53-6.99-48.93-20.44-67.821-38.98z"
+          fill="#00FF80"
+      />
+	</g
+    >
+	<g
+      >
+		<path
+          d="m173.85 197.82l-41.812 156.61c31.993 8.501 61.11 8.47 92.969-0.136l-42.101-155.85c-2.95 0.59-6.08 0.35-9.06-0.62z"
+          fill="#DCFFFE"
+      />
+		<path
+          d="m167.98 219.87l-35.941 134.56c31.993 8.501 61.11 8.47 92.969-0.136l-36.127-133.73c-6.82 1.57-14.22 1.29-20.9-0.69z"
+          fill="#B6FFFD"
+      />
+		<path
+          d="m162.15 241.77l-30.107 112.65c31.993 8.501 61.11 8.47 92.969-0.136l-30.219-111.86c-10.69 2.62-22.24 2.33-32.64-0.65z"
+          fill="#92FFFC"
+      />
+		<path
+          d="m156.32 263.68l-24.276 90.754c31.993 8.501 61.11 8.47 92.969-0.136l-24.305-89.969c-14.54 3.66-30.26 3.33-44.38-0.64z"
+          fill="#6EFFFB"
+      />
+		<path
+          d="m150.49 285.57l-18.446 68.856c31.993 8.501 61.11 8.47 92.969-0.136l-18.396-68.095c-18.41 4.7-38.28 4.34-56.12-0.63z"
+          fill="#4AFFFA"
+      />
+		<path
+          d="m144.7 307.61l-12.655 46.815c31.993 8.501 61.11 8.47 92.969-0.136l-12.484-46.215c-23.22 6.1-46.19 5.49-67.83-0.45z"
+          fill="#27FFF9"
+      />
+		<path
+          d="m138.88 329.52l-6.839 24.913c31.994 8.501 61.11 8.47 92.969-0.136l-6.575-24.341c-27.08 7.13-54.2 6.49-79.56-0.43z"
+          fill="#00FFFF"
+      />
+	</g
+    >
+	<g
+      >
+		<path
+          d="m192.47 193.82c-2.109 1.906-5.088 3.48-8.022 4.273-0.373 0.101-1.527 0.377-1.533 0.354l42.101 155.85c31.857-8.606 57.647-23.407 81.009-46.862l-113.56-113.61z"
+          fill="#DCEFFF"
+      />
+		<path
+          d="m208.69 210.01c-4.857 4.652-11.156 8.255-18.107 10.133-0.485 0.131-0.729 0.176-1.699 0.42l36.127 133.73c31.857-8.606 57.647-23.407 81.009-46.862l-97.33-97.42z"
+          fill="#B6DEFF"
+      />
+		<path
+          d="m224.73 226.01c-7.572 7.374-17.307 13.052-28.233 16.004-0.486 0.131-0.732 0.17-1.701 0.42l30.219 111.86c31.857-8.606 57.647-23.407 81.009-46.862l-81.3-81.42z"
+          fill="#92CEFF"
+      />
+		<path
+          d="m240.78 242.02c-10.285 10.097-23.467 17.838-38.372 21.864-0.484 0.131-0.729 0.186-1.696 0.438l24.305 89.969c31.857-8.606 57.647-23.407 81.009-46.862l-65.25-65.41z"
+          fill="#6EBEFF"
+      />
+		<path
+          d="m208.31 285.76c-0.485 0.132-0.731 0.185-1.698 0.439l18.396 68.095c31.857-8.606 57.647-23.407 81.009-46.862l-49.444-49.336c-13 12.81-29.38 22.56-48.27 27.66z"
+          fill="#4AADFF"
+      />
+		<path
+          d="m213.98 307.7c-0.324 0.088-0.49 0.122-1.456 0.38l12.484 46.215c31.857-8.606 57.647-23.407 81.009-46.862l-33.533-33.371c-15.72 15.59-35.58 27.44-58.5 33.63z"
+          fill="#279EFF"
+      />
+		<path
+          d="m219.89 329.57c-0.325 0.088-0.491 0.121-1.457 0.38l6.575 24.341c31.857-8.606 57.647-23.407 81.009-46.862l-17.47-17.385c-18.43 18.34-41.75 32.27-68.65 39.53z"
+          fill="#0080FF"
+      />
+	</g
+    >
+	<g
+      >
+		<path
+          d="m197.71 185.73c-0.843 3.153-2.941 5.768-5.242 8.083l113.97 113.5c23.359-23.456 39.325-47.987 47.829-79.98l-156.56-41.6z"
+          fill="#DCDCFF"
+      />
+		<path
+          d="m219.85 191.62c-2.041 6.976-5.889 13.329-11.148 18.372l97.727 97.328c23.359-23.456 39.325-47.987 47.829-79.98l-134.41-35.72z"
+          fill="#B6B6FF"
+      />
+		<path
+          d="m241.75 197.44c-3.064 10.814-8.936 20.677-16.995 28.538l81.675 81.342c23.359-23.456 39.325-47.987 47.829-79.98l-112.52-29.9z"
+          fill="#9292FF"
+      />
+		<path
+          d="m263.66 203.26c-4.089 14.652-11.976 28.037-22.837 38.716l65.61 65.343c23.359-23.456 39.325-47.987 47.829-79.98l-90.6-24.08z"
+          fill="#6E6EFF"
+      />
+		<path
+          d="m285.56 209.08c-5.112 18.491-15.019 35.392-28.682 48.887l49.554 49.352c23.359-23.456 39.325-47.987 47.829-79.98l-68.7-18.26z"
+          fill="#4A4AFF"
+      />
+		<path
+          d="m307.46 214.9c-6.137 22.329-18.063 42.745-34.525 59.06l33.496 33.358c23.359-23.456 39.325-47.987 47.829-79.98l-46.81-12.44z"
+          fill="#2727FF"
+      />
+		<path
+          d="m329.36 220.72c-7.161 26.167-21.104 50.1-40.368 69.23l17.438 17.366c23.359-23.456 39.325-47.987 47.829-79.98l-24.9-6.62z"
+          fill="#0000FF"
+      />
+	</g
+    >
+	<g
+      >
+		<path
+          d="m198.44 177.09c0.588 2.949 0.342 6.08-0.624 9.056l156.61 41.813c8.501-31.994 8.47-61.111-0.136-92.969l-155.85 42.1z"
+          fill="#ECDCFF"
+      />
+		<path
+          d="m220.56 171.12c1.57 6.827 1.293 14.228-0.688 20.901l134.56 35.941c8.501-31.994 8.47-61.111-0.136-92.969l-133.73 36.13z"
+          fill="#D8B6FF"
+      />
+		<path
+          d="m242.43 165.21c2.612 10.689 2.32 22.245-0.657 32.643l112.65 30.108c8.501-31.994 8.47-61.111-0.136-92.969l-111.85 30.22z"
+          fill="#C492FF"
+      />
+		<path
+          d="m264.32 159.29c3.655 14.55 3.324 30.265-0.649 44.388l90.754 24.277c8.501-31.994 8.47-61.111-0.136-92.969l-89.96 24.3z"
+          fill="#B16EFF"
+      />
+		<path
+          d="m286.2 153.38c4.699 18.412 4.345 38.281-0.625 56.128l68.855 18.446c8.501-31.994 8.47-61.111-0.136-92.969l-68.1 18.39z"
+          fill="#9E4AFF"
+      />
+		<path
+          d="m308.08 147.47c6.088 23.216 5.471 46.185-0.464 67.83l46.814 12.655c8.501-31.994 8.47-61.111-0.136-92.969l-46.21 12.48z"
+          fill="#8B27FF"
+      />
+		<path
+          d="m329.95 141.56c7.131 27.078 6.49 54.192-0.435 79.554l24.911 6.84c8.501-31.994 8.47-61.111-0.136-92.969l-24.34 6.58z"
+          fill="#8000FF"
+      />
+	</g
+    >
+	<g
+      >
+		<path
+          d="m198.09 175.56c0.101 0.374 0.377 1.528 0.354 1.534l155.85-42.101c-8.606-31.858-23.408-57.649-46.862-81.009l-113.63 113.48c1.9 2.11 3.5 5.16 4.29 8.1z"
+          fill="#FEDCFF"
+      />
+		<path
+          d="m220.14 169.42c0.131 0.486 0.176 0.729 0.42 1.699l133.73-36.126c-8.606-31.858-23.407-57.648-46.862-81.009l-97.479 97.275c4.61 4.84 8.32 11.25 10.19 18.16z"
+          fill="#FDB6FF"
+      />
+		<path
+          d="m242.01 163.51c0.131 0.484 0.169 0.729 0.419 1.697l111.86-30.218c-8.606-31.858-23.408-57.649-46.862-81.009l-81.486 81.231c7.34 7.56 13.13 17.41 16.07 28.3z"
+          fill="#FC92FF"
+      />
+		<path
+          d="m263.89 157.6c0.13 0.484 0.185 0.725 0.438 1.692l89.969-24.304c-8.606-31.858-23.408-57.649-46.862-81.009l-65.48 65.173c10.06 10.28 17.91 23.57 21.93 38.45z"
+          fill="#FB6EFF"
+      />
+		<path
+          d="m285.76 151.69c0.131 0.483 0.183 0.724 0.438 1.69l68.095-18.395c-8.606-31.858-23.408-57.649-46.862-81.009l-49.482 49.121c12.79 13 22.71 29.74 27.8 48.6z"
+          fill="#FA4AFF"
+      />
+		<path
+          d="m307.7 146.03c0.087 0.321 0.12 0.48 0.378 1.447l46.215-12.484c-8.606-31.858-23.408-57.649-46.862-81.009l-33.484 33.07c15.59 15.719 27.55 36.039 33.74 58.969z"
+          fill="#F927FF"
+      />
+		<path
+          d="m329.58 140.12c0.086 0.321 0.118 0.48 0.377 1.446l24.341-6.575c-8.606-31.858-23.52-58.061-46.974-81.421l-17.375 17.432c18.32 18.435 32.35 42.199 39.62 69.109z"
+          fill="#FF00FF"
+      />
+	</g
+    >
+</g
+  >
+<metadata
+    ><rdf:RDF
+      ><cc:Work
+        ><dc:format
+          >image/svg+xml</dc:format
+        ><dc:type
+            rdf:resource="http://purl.org/dc/dcmitype/StillImage"
+        /><cc:license
+            rdf:resource="http://creativecommons.org/licenses/publicdomain/"
+        /><dc:publisher
+          ><cc:Agent
+              rdf:about="http://openclipart.org/"
+            ><dc:title
+              >Openclipart</dc:title
+            ></cc:Agent
+          ></dc:publisher
+        ></cc:Work
+      ><cc:License
+          rdf:about="http://creativecommons.org/licenses/publicdomain/"
+        ><cc:permits
+            rdf:resource="http://creativecommons.org/ns#Reproduction"
+        /><cc:permits
+            rdf:resource="http://creativecommons.org/ns#Distribution"
+        /><cc:permits
+            rdf:resource="http://creativecommons.org/ns#DerivativeWorks"
+        /></cc:License
+      ></rdf:RDF
+    ></metadata
+  ></svg
+>

docs/hand_wire.md

@@ -271,9 +271,9 @@ This would require our `KEYMAP` 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 `KEYMAP` for your entire keyboard - be sure to remember that your keyboard is actually backwards when looking at the underside of it.
 
-### keymaps/default.c
+### keymaps/<variant>/default.c
 
-This is the actual keymap for your keyboard, and the main place you'll make changes as you perfect your layout. `default.c` is the file that gets pull by default when typing `make`, but you can make other files as well, and specify them by typing `make KEYMAP=<variant>`, which will pull `keymaps/<variant>.c`.
+This is the actual keymap for your keyboard, and the main place you'll make changes as you perfect your layout. `default.c` is the file that gets pull by default when typing `make`, but you can make other files as well, and specify them by typing `make handwired/<keyboard>:<variant>`, which will pull `keymaps/<variant>/keymap.c`.
 
 The basis of a keymap is its layers - by default, layer 0 is active. You can activate other layers, the highest of which will be referenced first. Let's start with our base layer.
 

docs/keycodes.md

@@ -152,12 +152,12 @@ When defining a [keymap](keymap.md) each key needs a valid key definition. This
 |`KC_WWW_REFRESH`|`KC_WREF`||
 |`KC_WWW_FAVORITES`|`KC_WFAV`||
 |`KC_STOP`||Stop|
-|`KC__MUTE`||Mute|
-|`KC__VOLUP`||Volume Up|
-|`KC__VOLDOWN`||Volume Down|
-|`KC_AUDIO_MUTE`|`KC_MUTE`||
-|`KC_AUDIO_VOL_UP`|`KC_VOLU`||
-|`KC_AUDIO_VOL_DOWN`|`KC_VOLD`||
+|`KC__MUTE`||Mute (macOS)|
+|`KC__VOLUP`||Volume Up (macOS)|
+|`KC__VOLDOWN`||Volume Down (macOS)|
+|`KC_AUDIO_MUTE`|`KC_MUTE`|Mute (Windows/macOS/Linux)|
+|`KC_AUDIO_VOL_UP`|`KC_VOLU`|Volume Up (Windows/macOS/Linux)|
+|`KC_AUDIO_VOL_DOWN`|`KC_VOLD`|Volume Down (Windows/macOS/Linux)|
 |`KC_MEDIA_NEXT_TRACK`|`KC_MNXT`|Next Track (Windows)|
 |`KC_MEDIA_PREV_TRACK`|`KC_MPRV`|Previous Track (Windows)|
 |`KC_MEDIA_FAST_FORWARD`|`KC_MFFD`|Next Track (macOS)|

docs/keycodes_basic.md

@@ -125,12 +125,12 @@ Windows and Mac use different key codes for next track and previous track. Make
 |Long Name|Short Name|Description|
 |---------|----------|-----------|
 |KC_STOP||Stop|
-|KC__MUTE||Mute|
-|KC__VOLUP||Volume Up|
-|KC__VOLDOWN||Volume Down|
-|KC_AUDIO_MUTE|KC_MUTE||
-|KC_AUDIO_VOL_UP|KC_VOLU||
-|KC_AUDIO_VOL_DOWN|KC_VOLD||
+|KC__MUTE||Mute (macOS)|
+|KC__VOLUP||Volume Up (macOS)|
+|KC__VOLDOWN||Volume Down (macOS)|
+|KC_AUDIO_MUTE|KC_MUTE|Mute (Windows/macOS/Linux)|
+|KC_AUDIO_VOL_UP|KC_VOLU|Volume Up (Windows/macOS/Linux)|
+|KC_AUDIO_VOL_DOWN|KC_VOLD|Volume Down (Windows/macOS/Linux)|
 |KC_MEDIA_NEXT_TRACK|KC_MNXT|Next Track (Windows)|
 |KC_MEDIA_PREV_TRACK|KC_MPRV|Previous Track (Windows)|
 |KC_MEDIA_FAST_FORWARD|KC_MFFD|Next Track (macOS)|

docs/keymap.md

@@ -79,7 +79,7 @@ Key with `KC_TRANS` (`KC_TRNS` and `_______` are the alias) doesn't has its own
 
 ## Anatomy Of A `keymap.c`
 
-For this example we will walk through the [default Clueboard keymap](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/keymaps/default/keymap.c). You'll find it helpful to open that file in another browser window so you can look at everything in context.
+For this example we will walk through the [default Clueboard 66% keymap](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard_66/keymaps/default/keymap.c). You'll find it helpful to open that file in another browser window so you can look at everything in context.
 
 There are 3 main sections of a `keymap.c` file you'll want to concern yourself with:
 

docs/macros.md

@@ -1,12 +1,93 @@
 # Macros
 
-Macros allow you to send multiple keystrokes when pressing just one key. QMK has a number of ways to define and use macros. These can do anything you want- type common phrases for you, copypasta, repetitive game movements, or even help you code. 
+Macros allow you to send multiple keystrokes when pressing just one key. QMK has a number of ways to define and use macros. These can do anything you want: type common phrases for you, copypasta, repetitive game movements, or even help you code. 
 
 {% hint style='danger' %}
 **Security Note**: While it is possible to use macros to send passwords, credit card numbers, and other sensitive information it is a supremely bad idea to do so. Anyone who gets ahold of your keyboard will be able to access that information by opening a text editor.
 {% endhint %}
 
-# Macro Definitions
+## The new way: `SEND_STRING()` & `process_record_user`
+
+Sometimes you just want a key to type out words or phrases. For the most common situations we've provided `SEND_STRING()`, which will type out your string for you. All ascii that is easily translated to a keycode is supported (eg `\n\t`).
+
+For example:
+
+```c
+enum custom_keycodes {
+	PRINT_TRUTH = SAFE_RANGE
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	if (record->event.pressed) {
+		switch(keycode) {
+			case PRINT_TRUTH:
+				SEND_STRING("QMK is the best thing ever!");
+				return false; break;
+		}
+	}
+	return true;
+};
+```
+
+### Tap/down/up
+
+You can send arbitary keycodes by wrapping them in:
+
+* `SS_TAP()`
+* `SS_DOWN()`
+* `SS_UP()`
+
+For example:
+
+    SEND_STRING(SS_TAP(X_HOME));
+
+Would tap `KC_HOME` - note how the prefix is now `X_`, and not `KC_`. You can also combine this with other strings, like this:
+
+    SEND_STRING("VE"SS_TAP(X_HOME)"LO");
+
+Which would send "VE" followed by a `KC_HOME` tap, and "LO" (spelling "LOVE" if on a newline).
+
+There's also a couple of mod shortcuts you can use:
+
+* `SS_LCTRL(string)`
+* `SS_LGUI(string)`
+* `SS_LALT(string)`
+
+That can be used like this:
+
+    SEND_STRING(SS_LCTRL("a"));
+
+Which would send LCTRL+a (LTRL down, a, LTRL up) - notice that they take strings (eg `"k"`), and not the `X_K` keycodes.
+
+### Alternative keymaps
+
+By default, it assumes a US keymap with a QWERTY layout; if you want to change that (e.g. if your OS uses software Colemak), include this somewhere in your keymap:
+
+    #include <sendstring_colemak.h>
+
+### Strings in memory
+
+If for some reason you're manipulating strings and need to print out something you just generated (instead of being a literal, constant string), you can use `send_string()`, like this:
+
+```c
+char my_str[4] = "ok.";
+send_string(my_str);
+```
+
+The shortcuts defined above won't work with `send_string()`, but you can separate things out to different lines if needed:
+
+```c
+char my_str[4] = "ok.";
+SEND_STRING("I said: ");
+send_string(my_str);
+SEND_STRING(".."SS_TAP(X_END));
+```
+
+## The old way: `MACRO()` & `action_get_macro`
+
+{% hint style='info' %}
+This is inherited from TMK, and hasn't been updated - it's recommend that you use `SEND_STRING` and `process_record_user` instead.
+{% endhint %}
 
 By default QMK assumes you don't have any macros. To define your macros you create an `action_get_macro()` function. For example:
 
@@ -26,11 +107,9 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 
 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:
 
-```c
 	if (!record->event.pressed) {
-```
 
-## Macro Commands
+### Macro Commands
 
 A macro can include the following commands:
 
@@ -41,32 +120,7 @@ A macro can include the following commands:
 * W() wait (milliseconds).
 * END end mark.
 
-## Sending strings
-
-Sometimes you just want a key to type out words or phrases. For the most common situations we've provided `SEND_STRING()`, which will type out your string for you instead of having to build a `MACRO()`.
-
-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:
-				SEND_STRING("QMK is the best thing ever!");
-				return false;
-		}
-	}
-	return MACRO_NONE;
-};
-```
-
-By default, it assumes a US keymap with a QWERTY layout; if you want to change that (e.g. if your OS uses software Colemak), include this somewhere in your keymap:
-
-```
-#include <sendstring_colemak.h>
-```
-
-## Mapping a Macro to a key
+### 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:
 
@@ -92,7 +146,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 
 When you press the key on the left it will type "Hi!" and when you press the key on the right it will type "Bye!".
 
-## Naming your macros
+### Naming your macros
 
 If you have a bunch of macros you want to refer to from your keymap while keeping the keymap easily readable you can name them using `#define` at the top of your file.
 
@@ -107,11 +161,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 ```
 
-# Advanced macro functions
+## Advanced macro functions
 
-While working within the `action_get_macro()` function block there are some functions you may find useful. 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.
+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`
+### `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
 
@@ -123,27 +177,27 @@ This is a boolean value that can be tested to see if the switch is being pressed
 	}
 ```
 
-#### `register_code(<kc>);`
+### `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>);`
+### `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.
 
-#### `clear_keyboard();`
+### `clear_keyboard();`
 
 This will clear all mods and keys currently pressed.
 
-#### `clear_mods();`
+### `clear_mods();`
 
 This will clear all mods currently pressed.
 
-#### `clear_keyboard_but_mods();`
+### `clear_keyboard_but_mods();`
 
 This will clear all keys besides the mods currently pressed.
 
-# Advanced Example: Single-key copy/paste
+## Advanced Example: Single-key copy/paste
 
 This example defines a macro which sends `Ctrl-C` when pressed down, and `Ctrl-V` when released. 
 

docs/tap_dance.md

@@ -14,7 +14,7 @@ The implementation hooks into two parts of the system, to achieve this: into `pr
 
 But lets start with how to use it, first!
 
-First, you will need `TAP_DANCE_ENABLE=yes` in your `Makefile`, 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.
+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.
 
 This array specifies what actions shall be taken when a tap-dance key is in action. Currently, there are three possible options:
 
@@ -42,7 +42,7 @@ For the sake of flexibility, tap-dance actions can be either a pair of keycodes,
 
 Here's a simple example for a single definition:
 
-1. In your `makefile`, add `TAP_DANCE_ENABLE = yes`
+1. In your `rules.mk`, add `TAP_DANCE_ENABLE = yes`
 2. In your `config.h` (which you can copy from `qmk_firmware/keyboards/planck/config.h` to your keymap directory), add `#define TAPPING_TERM 200`
 3. In your `keymap.c` file, define the variables and definitions, then add to your keymap:
 

docs/understanding_qmk.md

@@ -147,6 +147,7 @@ The `process_record()` function itself is deceptively simple, but hidden within
     * [`bool process_unicode(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_unicode.c#L22)
     * [`bool process_ucis(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_ucis.c#L91)
     * [`bool process_printer(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_printer.c#L77)
+    * [`bool process_auto_shift(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_auto_shift.c#L47)
     * [`bool process_unicode_map(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_unicodemap.c#L47)
     * [Identify and process quantum specific keycodes](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L211)
   

docs/unicode.md

@@ -24,6 +24,7 @@ sort of like macro. Unfortunately, each OS has different ideas on how Unicode is
 This is the current list of Unicode input method in QMK:
 
 * 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 Rigt 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.

docs/unit_testing.md

@@ -36,7 +36,7 @@ Note how there's several different tests, each mocking out a separate part. Also
 
 ## Running the tests
 
-To run all the tests in the codebase, type `make test`. You can also run test matching a substring by typing `make test-matchingsubstring` Note that the tests are always compiled with the native compiler of your platform, so they are also run like any other program on your computer.
+To run all the tests in the codebase, type `make test`. You can also run test matching a substring by typing `make test:matchingsubstring` Note that the tests are always compiled with the native compiler of your platform, so they are also run like any other program on your computer.
 
 ## Debugging the tests
 

drivers/avr/ws2812.h

@@ -28,23 +28,7 @@
 //#include "ws2812_config.h"
 //#include "i2cmaster.h"
 
-#ifdef RGBW
-  #define LED_TYPE struct cRGBW
-#else
-  #define LED_TYPE struct cRGB
-#endif
-
-
-/*
- *  Structure of the LED array
- *
- * cRGB:     RGB  for WS2812S/B/C/D, SK6812, SK6812Mini, SK6812WWA, APA104, APA106
- * cRGBW:    RGBW for SK6812RGBW
- */
-
-struct cRGB  { uint8_t g; uint8_t r; uint8_t b; };
-struct cRGBW { uint8_t g; uint8_t r; uint8_t b; uint8_t w;};
-
+#include "rgblight_types.h"
 
 
 /* User Interface

keyboards/9key/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/9key/config.h

@@ -47,6 +47,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* COL2ROW or ROW2COL */
 #define DIODE_DIRECTION COL2ROW
 
-#define TAPPING_TERM 150
+#define TAPPING_TERM 200
 
 #endif

keyboards/9key/keymaps/default/keymap.c

@@ -2,45 +2,63 @@
 
 // Tap Dance Declarations
 enum {
-  ENT_5 = 0
+  ENT_5 = 0,
+  ZERO_7
+};
+
+// Macro Declarations
+enum {
+  DBL_0 = 0
 };
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 /* LAYER 0
- * ,-----------------.
- * |  1  |  2  |  3  |
- * |-----+-----+-----|
- * |  4  |5/ENT|  6  | Dbl Tap 5 for Enter
- * |-----+-----+-----|
- * |  7  |  8  | FN  | 
- * `-----------------'
+ * ,-----------------------.
+ * |   1   |   2   |   3   |
+ * |-------+-------+-------|
+ * |   4   | 5/ENT |   6   | Dbl Tap 5 for Enter
+ * |-------+-------+-------|
+ * |  7/0  |   8   | 9/FN  | 7/0 = Dbl Tap 7 for 0  -  9/FN = Hold 9 for FN
+ * `-----------------------'
  */
 [0] = KEYMAP( \
-  KC_1, KC_2, KC_3, \
-  KC_4, TD(ENT_5), KC_6, \
-  KC_7, KC_8, MO(1) \
+  KC_1,       KC_2,      KC_3,       \
+  KC_4,       TD(ENT_5), KC_6,       \
+  TD(ZERO_7), KC_8,      LT(1, KC_9) \
 ),
 
 /* LAYER 1
- * ,-----------------.
- * |  9  |  0  |  -  |
- * |-----+-----+-----|
- * |  +  |  *  |  /  |
- * |-----+-----+-----|
- * | F1  | F2  |     |
- * `-----------------'
+ * ,-----------------------.
+ * |  ESC  |   +   |   -   |
+ * |-------+-------+-------|
+ * |  BSPC |   *   |   /   |
+ * |-------+-------+-------|
+ * |  00   |   .   |       |
+ * `-----------------------'
  */
 [1] = KEYMAP( \
-  KC_9,    KC_0,    KC_MINS, \
-  KC_PLUS, KC_ASTR, KC_SLSH, \
-  KC_F1,   KC_F2,   KC_TRNS  \
+  KC_ESC,   KC_PLUS, KC_MINS, \
+  KC_BSPC,  KC_ASTR, KC_SLSH, \
+  M(DBL_0), KC_DOT,  KC_TRNS  \
 )
 
 };
 
 qk_tap_dance_action_t tap_dance_actions[] = {
-  [ENT_5] = ACTION_TAP_DANCE_DOUBLE(KC_5, KC_ENT)
+  [ENT_5] = ACTION_TAP_DANCE_DOUBLE(KC_5, KC_ENT),
+  [ZERO_7] = ACTION_TAP_DANCE_DOUBLE(KC_7, KC_0)
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+  if (record->event.pressed) {
+      switch(id) {
+          case DBL_0:
+              SEND_STRING("00");
+              return false;
+      }
+  }
+  return MACRO_NONE;
 };
 
 void matrix_init_user(void) {

keyboards/9key/readme.md

@@ -8,10 +8,10 @@ A compact minipad (3x3) keyboard made and sold by Bishop Keyboards.
 
 Keyboard Maintainer: QMK Community  
 Hardware Supported: 9key PCB, Pro Micro ATmega32U4  
-Hardware Availability: [BishopKeyboards.com](https://www.reddit.com/user/se7en9057) (BishopKeyboards.com under renovation)  
+Hardware Availability: [BishopKeyboards.com](http://bishopkeyboards.com/)
 
 Make example for this keyboard (after setting up your build environment):
 
-    make 9key-default
+    make 9key:default
 
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/alps64/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/alps64/readme.md

@@ -3,12 +3,12 @@ Alps64
 
 An Alps-only 60% board designed by Hasu.
 
-Keyboard Maintainer: QMK Community
-Hardware Supported: Alps64 PCB
+Keyboard Maintainer: QMK Community  
+Hardware Supported: Alps64 PCB  
 Hardware Availability: https://geekhack.org/index.php?topic=69666.0
 
 Make example for this keyboard (after setting up your build environment):
 
-    make alps64-default
+    make alps64:default
 
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/amj40/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/amj40/keymaps/default/keymap.c

@@ -1,7 +1,5 @@
 
 
-// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
-// this is the style you want to emulate.
 
 #include "amj40.h"
 

keyboards/amj40/keymaps/fabian/keymap.c

@@ -1,3 +1,18 @@
+/* Copyright 2015-2017 Jack Humbert
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 #include "amj40.h"
 
 // Set the custom keymap
@@ -14,23 +29,16 @@
     {k30, k31, k32, k33, k34, k35, XXX, XXX, XXX, k39, k3a, k3b} \
 }
 
-// Fillers to make layering more clear
-#define _______ KC_TRNS
-#define XXXXXXX KC_NO
+extern keymap_config_t keymap_config;
 
-// Custom
-#define CTL_ESC CTL_T(KC_ESC)  // Tap for Escape, hold for Control
-#define SFT_ENT SFT_T(KC_ENT)  // Tap for Enter, hold for Shift
-#define SFT_BSP SFT_T(KC_BSPC) // Tap for Backspace, hold for Shift
-#define HPR_TAB ALL_T(KC_TAB)  // Tap for Tab, hold for Hyper (Super+Ctrl+Alt+Shift)
-// #define MEH_GRV MEH_T(KC_GRV)  // Tap for Backtick, hold for Meh (Ctrl+Alt+Shift)
-
-#define _QWERTY 0
-#define _COLEMAK 1
-#define _DVORAK 2
-#define _LOWER 3
-#define _RAISE 4
-#define _ADJUST 16
+enum custom_layers {
+  _QWERTY,
+  _COLEMAK,
+  _DVORAK,
+  _LOWER,
+  _RAISE,
+  _ADJUST
+};
 
 enum custom_keycodes {
   QWERTY = SAFE_RANGE,
@@ -38,9 +46,21 @@ enum custom_keycodes {
   DVORAK,
   LOWER,
   RAISE,
-  ADJUST,
+  BACKLIT,
+  EXT_PLV
 };
 
+#define XXXXXXX KC_NO
+#define _______ KC_TRNS
+
+#define CTL_ESC CTL_T(KC_ESC)  // Tap for Escape, hold for Control
+#define HPR_TAB ALL_T(KC_TAB)  // Tap for Tab, hold for Hyper (Super+Ctrl+Alt+Shift)
+#define MEH_GRV MEH_T(KC_GRV)  // Tap for Backtick, hold for Meh (Ctrl+Alt+Shift)
+#define SFT_BSP SFT_T(KC_BSPC) // Tap for Backspace, hold for Shift
+#define SFT_ENT SFT_T(KC_ENT)  // Tap for Enter, hold for Shift
+#define SFT_SPC SFT_T(KC_SPC)  // Tap for Space, hold for Shift
+#define UMLAUT  RALT(KC_U)     // Combine Alt and U
+
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 /* Qwerty
  * ,-----------------------------------------------------------------------------------.
@@ -50,14 +70,14 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |------+------+------+------+------+------|------+------+------+------+------+------|
  * | Shift|   Z  |   X  |   C  |   V  |   B  |   N  |   M  |   ,  |   .  |   /  |Enter |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
- * |Adjust| Ctrl | Alt  | GUI  | Lower and Space | Raise and Bksp | GUI  |AltGr | Ctrl |
+ * | Ctrl | Meh  | Alt  | GUI  | Lower and Space | Raise          | GUI  |AltGr | Ctrl |
  * `-----------------------------------------------------------------------------------'
  */
 [_QWERTY] = KEYMAP( \
   HPR_TAB, KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC, \
   CTL_ESC, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, \
-  SFT_BSP, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, SFT_ENT , \
-  F(2),    KC_LCTL, KC_LALT, KC_LGUI,          F(0),             F(1),             KC_RGUI, KC_RALT, KC_RCTL \
+  SFT_BSP, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, SFT_ENT, \
+  KC_LCTL, MEH_GRV, KC_LALT, KC_LGUI,          F(0),             RAISE,            KC_RGUI, KC_RALT, KC_RCTL \
 ),
 
 /* Colemak
@@ -68,14 +88,14 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |------+------+------+------+------+------|------+------+------+------+------+------|
  * | Shift|   Z  |   X  |   C  |   V  |   B  |   K  |   M  |   ,  |   .  |   /  |Enter |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
- * |Adjust| Ctrl | Alt  | GUI  | Lower and Space | Raise and Bksp | GUI  |AltGr | Ctrl |
+ * | Ctrl | Meh  | Alt  | GUI  | Lower and Space | Raise          | GUI  |AltGr | Ctrl |
  * `-----------------------------------------------------------------------------------'
  */
 [_COLEMAK] = KEYMAP( \
   HPR_TAB, KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_BSPC, \
   CTL_ESC, KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,    KC_QUOT, \
-  SFT_BSP, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, SFT_ENT , \
-  F(2),    KC_LCTL, KC_LALT, KC_LGUI,          F(0),             F(1),             KC_RGUI, KC_RALT, KC_RCTL \
+  SFT_BSP, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, SFT_ENT, \
+  KC_LCTL, MEH_GRV, KC_LALT, KC_LGUI,          F(0),             RAISE,            KC_RGUI, KC_RALT, KC_RCTL \
 ),
 
 /* Dvorak
@@ -86,14 +106,14 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |------+------+------+------+------+------|------+------+------+------+------+------|
  * | Shift|   ;  |   Q  |   J  |   K  |   X  |   B  |   M  |   W  |   V  |   Z  |Enter |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
- * |Adjust| Ctrl | Alt  | GUI  | Lower and Space | Raise and Bksp | GUI  |AltGr | Ctrl |
+ * | Ctrl | Meh  | Alt  | GUI  | Lower and Space | Raise          | GUI  |AltGr | Ctrl |
  * `-----------------------------------------------------------------------------------'
  */
 [_DVORAK] = KEYMAP( \
   HPR_TAB, KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_BSPC, \
   CTL_ESC, KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_SLSH, \
-  SFT_BSP, KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    SFT_ENT , \
-  F(2),    KC_LCTL, KC_LALT, KC_LGUI,          F(0),             F(1),             KC_RGUI, KC_RALT, KC_RCTL \
+  SFT_BSP, KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    SFT_ENT, \
+  KC_LCTL, MEH_GRV, KC_LALT, KC_LGUI,          F(0),             RAISE,            KC_RGUI, KC_RALT, KC_RCTL \
 ),
 
 /* Lower
@@ -104,7 +124,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |------+------+------+------+------+------|------+------+------+------+------+------|
  * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 | MS L | MS D |MS U  | MS R |MS Btn|
  * |------+------+------+------+------+------+------+------+------+------+------+------|
- * |      |      |      |      |      |      |      |      | Next | Vol- | Vol+ | Play |
+ * |      |      |      |      |                 |      Next      | Vol- | Vol+ | Play |
  * `-----------------------------------------------------------------------------------'
  */
 [_LOWER] = KEYMAP( \
@@ -122,7 +142,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |------+------+------+------+------+------|------+------+------+------+------+------|
  * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 | Left | Down |  Up  | Rght |MS_BN2|
  * |------+------+------+------+------+------+------+------+------+------+------+------|
- * |      |      |      |      |      |      |      |      | Next | Vol- | Vol+ | Play |
+ * |      |      |      |      |                 |      Next      | Vol- | Vol+ | Play |
  * `-----------------------------------------------------------------------------------'
  */
 [_RAISE] = KEYMAP( \
@@ -134,72 +154,44 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
 /* Adjust (Lower + Raise)
  * ,-----------------------------------------------------------------------------------.
- * |Reset |Colemk|Qwerty|Dvorak|      |      |      |      |  MU  |      |      |Reset |
+ * |      | Reset|      |      |      |      |      |      |      |      | Reset|  Del |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * |      |      |      |Aud on|Audoff|AGnorm|AGswap|Qwerty|Colemk|Dvorak|      |      |
  * |------+------+------+------+------+------|------+------+------+------+------+------|
- * |      |AGNorm|AGSwap|      |      |      |      |  ML  |  MD  |  MR  |      |      |
+ * |      |Voice-|Voice+|Mus on|Musoff|MIDIon|MIDIof|      |      |      |      |      |
  * |------+------+------+------+------+------+------+------+------+------+------+------|
- * |      |AudOn |AudOff|      |      |      |      |MBtn1 |MBtn2 |MBtn3 |      |      |
- * |------+------+------+------+------+------+------+------+------+------+------+------|
- * |      |      |      |      |      |      |      |      |      |      |      |      |
+ * |      |      |      |      |                 |                |      |      |      |
  * `-----------------------------------------------------------------------------------'
  */
 [_ADJUST] = KEYMAP( \
-  RESET,   COLEMAK, QWERTY,  DVORAK,  _______, _______, _______, _______, KC_MS_U, _______, _______, RESET, \
-  _______, AG_NORM, AG_SWAP, _______, _______, _______, _______, KC_MS_L, KC_MS_D, KC_MS_R, _______, _______, \
-  _______, AU_ON,   AU_OFF,  _______, _______, _______, _______, KC_BTN1, KC_BTN2, KC_BTN3, _______, _______, \
+  _______, RESET,   _______, _______, _______, _______, _______, _______, _______, _______, RESET,   KC_DEL, \
+  _______, _______, MU_MOD,  AU_ON,   AU_OFF,  AG_NORM, AG_SWAP, QWERTY,  COLEMAK, DVORAK,  _______, _______, \
+  _______, MUV_DE,  MUV_IN,  MU_ON,   MU_OFF,  MI_ON,   MI_OFF,  _______, _______, _______, _______, _______, \
   _______, _______, _______, _______,          _______,          _______,          _______, _______, _______ \
 )
-
 };
 
-#ifdef AUDIO_ENABLE
-float tone_qwerty[][2]     = SONG(QWERTY_SOUND);
-float tone_dvorak[][2]     = SONG(DVORAK_SOUND);
-float tone_colemak[][2]    = SONG(COLEMAK_SOUND);
-#endif
-
-void persistent_default_layer_set(uint16_t default_layer) {
-  eeconfig_update_default_layer(default_layer);
-  default_layer_set(default_layer);
-}
-
 const uint16_t PROGMEM fn_actions[] = {
-        [0]  = ACTION_LAYER_TAP_KEY(_LOWER, KC_SPC),
-        [1]  = ACTION_LAYER_TAP_KEY(_RAISE, KC_BSPC),
-        [2]  = ACTION_LAYER_TAP_KEY(_ADJUST, KC_LGUI),
-};
-
-const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
-{
-    return MACRO_NONE;
+    [0]  = ACTION_LAYER_TAP_KEY(_LOWER, KC_SPC),
 };
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case QWERTY:
       if (record->event.pressed) {
-        #ifdef AUDIO_ENABLE
-          PLAY_SONG(tone_qwerty);
-        #endif
-        persistent_default_layer_set(1UL<<_QWERTY);
+        set_single_persistent_default_layer(_QWERTY);
       }
       return false;
       break;
     case COLEMAK:
       if (record->event.pressed) {
-        #ifdef AUDIO_ENABLE
-          PLAY_SONG(tone_colemak);
-        #endif
-        persistent_default_layer_set(1UL<<_COLEMAK);
+        set_single_persistent_default_layer(_COLEMAK);
       }
       return false;
       break;
     case DVORAK:
       if (record->event.pressed) {
-        #ifdef AUDIO_ENABLE
-          PLAY_SONG(tone_dvorak);
-        #endif
-        persistent_default_layer_set(1UL<<_DVORAK);
+        set_single_persistent_default_layer(_DVORAK);
       }
       return false;
       break;
@@ -223,11 +215,14 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
       }
       return false;
       break;
-    case ADJUST:
+    case BACKLIT:
       if (record->event.pressed) {
-        layer_on(_ADJUST);
+        register_code(KC_RSFT);
+        #ifdef BACKLIGHT_ENABLE
+          backlight_step();
+        #endif
       } else {
-        layer_off(_ADJUST);
+        unregister_code(KC_RSFT);
       }
       return false;
       break;

keyboards/amj40/readme.md

@@ -1,35 +1,14 @@
-AMJ40 keyboard firmware
-======================
+AMJ40
+===
+
 DIY/Assembled compact 40% keyboard.
 
-Ported by N.Hou from the original TMK firmware.
+Keyboard Maintainer: QMK Community  
+Hardware Supported: AMJ40 PCB  
+Hardware Availability: https://geekhack.org/index.php?topic=87961.0
 
-*Supports both backlight LEDs as well as RGB underglow. 
-
-*For reference, the AMJ40 uses pin D3 for underglow lighting.
-
-## Quantum MK Firmware
-
-For the full Quantum feature list, see [the parent readme.md](/readme.md).
-
-## Building
-
-Download or clone the whole firmware and navigate to the keyboards/amj40
-folder. Once your dev env is setup, you'll be able to type `make` to generate
-your .hex - you can then use `make dfu` to program your PCB once you hit the
-reset button. 
-
-Depending on which keymap you would like to use, you will have to compile
-slightly differently.
-
-### Default
-To build with the default keymap, simply run `sudo make all`.
-The .hex file will appear in the root of the qmk firmware folder.
-
-
-
-
-### Original tmk firmware
-The original firmware that was used to port to qmk can be found [here](https://github.com/AMJKeyboard/AMJ40).
+Make example for this keyboard (after setting up your build environment):
 
+    make amj40:default
 
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/amj60/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/amj60/keymaps/default/keymap.c

@@ -0,0 +1,59 @@
+
+#include "amj60.h"
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _DEF 0
+#define _SPC 1
+
+// dual-role shortcuts
+#define SPACEDUAL LT(_SPC, KC_SPACE)
+
+
+// increase readability 
+#define _______ KC_TRNS
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    /* Keymap _DEF: Default Layer
+     * ,-----------------------------------------------------------.
+     * |Esc|  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =| \ | ~ |
+     * |-----------------------------------------------------------|
+     * |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]| bspc|
+     * |-----------------------------------------------------------|
+     * |Caps   | A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '| Return |
+     * |-----------------------------------------------------------|
+     * |Sft | Fn0|  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /| Sft |Fn2|
+     * |-----------------------------------------------------------|
+     * |Ctrl|Win |Alt |      Space/Fn0         |Alt |Win |Menu|RCtl|
+     * `-----------------------------------------------------------'
+     */
+    [_DEF] = KEYMAP_MAX(
+        KC_ESC,   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_BSLS, KC_GRV, \
+        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_BSPC,  \
+        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_ENT,   \
+        KC_LSFT,  F(0),    KC_Z,    KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT,    F(1),     \
+        KC_LCTL,  KC_LALT, KC_LGUI,             SPACEDUAL,                       KC_RGUI, KC_RALT, KC_RCTL,    F(2)),
+
+    /* Keymap 1: F-and-vim Layer, modified with Space (by holding space)
+     * ,-----------------------------------------------------------.
+     * |PrSc| F1| F2| F3| F4| F5| F6| F7| F8| F9|F10|F11|F12|   |  |
+     * |-----------------------------------------------------------|
+     * |    |Paus| Up| [ | ] |   |   |   | ( | ) |   |   |   | Del |
+     * |-----------------------------------------------------------|
+     * |      |Lft|Dwn|Rgt|   |   |Left|Down|Right|Up|  |   | PLAY |
+     * |-----------------------------------------------------------|
+     * |    |   |   |   | < | > |   |M0 |   |   |   |   | Vol+ |   |
+     * |-----------------------------------------------------------|
+     * |    |    |    |                        |Alt |Prev|Vol-|Next|
+     * `-----------------------------------------------------------'
+     */
+    [_SPC] = KEYMAP_MAX(
+        KC_PSCR, 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_PAUS, KC_UP,   _______,  _______, _______, _______,  _______, _______, _______, _______, _______, _______, KC_DEL, \
+        _______, KC_LEFT, KC_DOWN, KC_RIGHT, _______, _______, KC_LEFT,  KC_DOWN,   KC_UP,     KC_RGHT, _______, _______, KC_MPLY, \
+        _______, _______, _______, _______,  _______, _______, KC_SPACE, M(0),      _______,   _______, _______, _______, KC_VOLU, _______, \
+        _______, _______, _______,                                  _______,                                 _______, KC_MPRV, KC_VOLD, KC_MNXT),
+
+};

keyboards/amj60/keymaps/iso_split_rshift/keymap.c

@@ -1,5 +1,3 @@
-// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
-// this is the style you want to emulate.
 
 #include "amj60.h"
 

keyboards/amj60/keymaps/maximized/keymap.c

@@ -1,5 +1,3 @@
-// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
-// this is the style you want to emulate.
 
 #include "amj60.h"
 

keyboards/amj60/readme.md

@@ -9,6 +9,6 @@ Hardware Availability: https://geekhack.org/index.php?topic=77636.0
 
 Make example for this keyboard (after setting up your build environment):
 
-    make amj60-maximized
+    make amj60:maximized
 
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/amjpad/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/amjpad/readme.md

@@ -9,6 +9,6 @@ Hardware Availability: https://geekhack.org/index.php?topic=83546.0
 
 Make example for this keyboard (after setting up your build environment):
 
-    make amjpad-default
+    make amjpad:default
 
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/atomic/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/atomic/keymaps/pvc/config.h

@@ -15,37 +15,19 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef CONFIG_H
-#define CONFIG_H
+#ifndef CONFIG_USER_H
+#define CONFIG_USER_H
 
 #include "config_common.h"
 
 /* USB Device descriptor parameter */
-#define VENDOR_ID       0xFEED
+#undef PRODUCT_ID
 #define PRODUCT_ID      0x0419
-#define DEVICE_VER      0x0001
-#define MANUFACTURER    Ortholinear Keyboards
-#define PRODUCT         The Atomic Keyboard
-#define DESCRIPTION     A compact ortholinear keyboard
 
 /* key matrix size */
 #define MATRIX_ROWS 5
 #define MATRIX_COLS 15
 
-/*
- * Keyboard Matrix Assignments
- *
- * Change this to how you wired your keyboard
- * COLS: AVR pins used for columns, left to right
- * ROWS: AVR pins used for rows, top to bottom
- * DIODE_DIRECTION: COL2ROW = COL = Anode (+), ROW = Cathode (-, marked on diode)
- *                  ROW2COL = ROW = Anode (+), COL = Cathode (-, marked on diode)
- *
-*/
-#define MATRIX_ROW_PINS { D0, D5, B5, B6, B3 }
-#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7, D3, D2, D1 }
-#define UNUSED_PINS
-
 #define BACKLIGHT_PIN B7
 #define BACKLIGHT_BREATHING
 

keyboards/atomic/readme.md

@@ -5,12 +5,12 @@ Atomic
 
 A compact 60% (15x5) ortholinear keyboard kit made and sold by OLKB. [More info on qmk.fm](http://qmk.fm/atomic/)
 
-Keyboard Maintainer: [Jack Humbert](https://github.com/jackhumbert)
-Hardware Supported: Atomic PCB rev1, Teensy 2.0
+Keyboard Maintainer: [Jack Humbert](https://github.com/jackhumbert)  
+Hardware Supported: Atomic PCB rev1, Teensy 2.0  
 Hardware Availability: no longer available
 
 Make example for this keyboard (after setting up your build environment):
 
-    make atomic-default
+    make atomic:default
 
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/atreus/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/atreus/config.h

@@ -22,9 +22,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 /* USB Device descriptor parameter */
 
-#define VENDOR_ID       0xFEED
-#define PRODUCT_ID      0x6060
-#define DEVICE_VER      0x0001
+#define VENDOR_ID       0x1209
+#define PRODUCT_ID      0xA1E5
+#define DEVICE_VER      0x0008
 #define MANUFACTURER    Technomancy
 #define PRODUCT         Atreus
 #define DESCRIPTION     q.m.k. keyboard firmware for Atreus

keyboards/atreus/keymaps/classic/keymap.c

@@ -9,24 +9,24 @@
 #define _LW 2
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-[_QW] = { /* Qwerty */
-  {KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,   KC_TRNS,  KC_Y,    KC_U,    KC_I,    KC_O,    KC_P    },
-  {KC_A,    KC_S,    KC_D,    KC_F,    KC_G,   KC_TRNS,  KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN },
-  {KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,   KC_LALT,  KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH },
-  {KC_ESC, KC_TAB, KC_LGUI,  KC_LSFT, KC_BSPC,  KC_LCTL, KC_SPC,  MO(_RS), KC_MINS, KC_QUOT, KC_ENT  }
-},
-[_RS] = { /* [> RAISE <] */
-  {KC_EXLM, KC_AT,   KC_LCBR, KC_RCBR, KC_PIPE, KC_TRNS, KC_PGUP, KC_7,    KC_8,   KC_9, KC_ASTR},
-  {KC_HASH, KC_DLR,  KC_LPRN, KC_RPRN, KC_GRV,  KC_TRNS, KC_PGDN, KC_4,    KC_5,   KC_6, KC_PLUS},
-  {KC_PERC, KC_CIRC, KC_LBRC, KC_RBRC, KC_TILD, KC_LALT, KC_AMPR, KC_1,    KC_2,   KC_3, KC_BSLS},
-  {TG(_LW), KC_INS,  KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_SPC,  KC_TRNS, KC_DOT, KC_0, KC_EQL}
-},
-[_LW] = { /* [> LOWER <] */
-  {KC_INS,  KC_HOME, KC_UP,   KC_END,  KC_PGUP, KC_TRNS, KC_UP,   KC_F7,   KC_F8,   KC_F9,   KC_F10},
-  {KC_DELT, KC_LEFT, KC_DOWN, KC_RGHT, KC_DOWN, KC_TRNS, KC_DOWN, KC_F4,   KC_F5,   KC_F6,   KC_F11},
-  {KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_LALT, KC_TRNS, KC_F1,   KC_F2,   KC_F3,   KC_F12},
-  {KC_TRNS, KC_TRNS, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_SPC,  DF(_QW), KC_TRNS, KC_TRNS, RESET}
-}};
+  [_QW] = KEYMAP( /* Qwerty */
+  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,                      KC_Y,    KC_U,    KC_I,    KC_O,    KC_P    ,
+  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,                      KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN ,
+  KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,                      KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH ,
+  KC_ESC,  KC_TAB, KC_LGUI,  KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC,  MO(_RS), KC_MINS, KC_QUOT, KC_ENT  ),
+
+  [_RS] = KEYMAP( /* [> RAISE <] */
+  KC_EXLM, KC_AT,   KC_LCBR, KC_RCBR, KC_PIPE,                   KC_PGUP, KC_7,    KC_8,   KC_9, KC_ASTR ,
+  KC_HASH, KC_DLR,  KC_LPRN, KC_RPRN, KC_GRV,                    KC_PGDN, KC_4,    KC_5,   KC_6, KC_PLUS ,
+  KC_PERC, KC_CIRC, KC_LBRC, KC_RBRC, KC_TILD,                   KC_AMPR, KC_1,    KC_2,   KC_3, KC_BSLS ,
+  TG(_LW), KC_INS,  KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC,  KC_TRNS, KC_DOT, KC_0, KC_EQL  ),
+
+  [_LW] = KEYMAP( /* [> LOWER <] */
+  KC_INS,  KC_HOME, KC_UP,   KC_END,  KC_PGUP,                   KC_UP,   KC_F7,   KC_F8,   KC_F9,   KC_F10 ,
+  KC_DELT, KC_LEFT, KC_DOWN, KC_RGHT, KC_DOWN,                   KC_DOWN, KC_F4,   KC_F5,   KC_F6,   KC_F11 ,
+  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,                   KC_TRNS, KC_F1,   KC_F2,   KC_F3,   KC_F12 ,
+  KC_TRNS, KC_TRNS, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC,  DF(_QW), KC_TRNS, KC_TRNS, RESET  )
+};
 
 const uint16_t PROGMEM fn_actions[] = {
 

keyboards/atreus/keymaps/default/keymap.c

@@ -12,36 +12,34 @@
 #define _LW 2
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-[_QW] = { /* Qwerty */
-  {KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,   KC_TRNS,  KC_Y,    KC_U,    KC_I,    KC_O,    KC_P    },
-  {KC_A,    KC_S,    KC_D,    KC_F,    KC_G,   KC_TRNS,  KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN },
-  {KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,   KC_LCTL,  KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH },
-  {KC_ESC, KC_TAB, KC_LGUI,  KC_LSFT, KC_BSPC,  KC_LALT, KC_SPC,  MO(_RS), KC_MINS, KC_QUOT, KC_ENT  }
-},
+[_QW] = KEYMAP( /* Qwerty */
+  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,                      KC_Y,    KC_U,    KC_I,    KC_O,    KC_P    ,
+  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,                      KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN ,
+  KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,                      KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH ,
+  KC_ESC, KC_TAB, KC_LGUI,  KC_LSFT, KC_BSPC,  KC_LCTL, KC_LALT, KC_SPC,  MO(_RS), KC_MINS, KC_QUOT, KC_ENT  ),
 /*
  *  !       @     up     {    }        ||     pgup    7     8     9    *
  *  #     left   down  right  $        ||     pgdn    4     5     6    +
  *  [       ]      (     )    &        ||       `     1     2     3    \
  * lower  insert super shift bksp ctrl || alt space   fn    .     0    =
  */
-[_RS] = { /* [> RAISE <] */
-  {KC_EXLM, KC_AT,   KC_UP,   KC_LCBR, KC_RCBR, KC_TRNS, KC_PGUP, KC_7,    KC_8,   KC_9, KC_ASTR},
-  {KC_HASH, KC_LEFT, KC_DOWN, KC_RGHT, KC_DLR,  KC_TRNS, KC_PGDN, KC_4,    KC_5,   KC_6, KC_PLUS},
-  {KC_LBRC, KC_RBRC, KC_LPRN, KC_RPRN, KC_AMPR, KC_LCTL, KC_GRV,  KC_1,    KC_2,   KC_3, KC_BSLS},
-  {TG(_LW), KC_INS,  KC_LGUI, KC_LSFT, KC_BSPC, KC_LALT, KC_SPC,  KC_TRNS, KC_DOT, KC_0, KC_EQL}
-},
+[_RS] = KEYMAP( /* [> RAISE <] */
+  KC_EXLM, KC_AT,   KC_UP,   KC_LCBR, KC_RCBR,                   KC_PGUP, KC_7,    KC_8,   KC_9, KC_ASTR ,
+  KC_HASH, KC_LEFT, KC_DOWN, KC_RGHT, KC_DLR,                    KC_PGDN, KC_4,    KC_5,   KC_6, KC_PLUS ,
+  KC_LBRC, KC_RBRC, KC_LPRN, KC_RPRN, KC_AMPR,                   KC_GRV,  KC_1,    KC_2,   KC_3, KC_BSLS ,
+  TG(_LW), KC_INS,  KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC,  KC_TRNS, KC_DOT, KC_0, KC_EQL  ),
 /*
  * insert home   up  end   pgup       ||      up     F7    F8    F9   F10
  *  del   left  down right pgdn       ||     down    F4    F5    F6   F11
  *       volup             reset      ||             F1    F2    F3   F12
  *       voldn  super shift bksp ctrl || alt space   L0  prtsc scroll pause
  */
-[_LW] = { /* [> LOWER <] */
-  {KC_INS,  KC_HOME, KC_UP,   KC_END,  KC_PGUP, KC_TRNS, KC_UP,   KC_F7,   KC_F8,   KC_F9,   KC_F10},
-  {KC_DELT, KC_LEFT, KC_DOWN, KC_RGHT, KC_DOWN, KC_TRNS, KC_DOWN, KC_F4,   KC_F5,   KC_F6,   KC_F11},
-  {KC_NO,   KC_VOLU, KC_NO,   KC_NO,   RESET,   KC_LCTL, KC_NO,   KC_F1,   KC_F2,   KC_F3,   KC_F12},
-  {KC_NO,   KC_VOLD, KC_LGUI, KC_LSFT, KC_BSPC, KC_LALT, KC_SPC,  TO(_QW), KC_PSCR, KC_SLCK, KC_PAUS}
-}};
+[_LW] = KEYMAP( /* [> LOWER <] */
+  KC_INS,  KC_HOME, KC_UP,   KC_END,  KC_PGUP,                   KC_UP,   KC_F7,   KC_F8,   KC_F9,   KC_F10  ,
+  KC_DELT, KC_LEFT, KC_DOWN, KC_RGHT, KC_DOWN,                   KC_DOWN, KC_F4,   KC_F5,   KC_F6,   KC_F11  ,
+  KC_NO,   KC_VOLU, KC_NO,   KC_NO,   RESET,                     KC_NO,   KC_F1,   KC_F2,   KC_F3,   KC_F12  ,
+  KC_NO,   KC_VOLD, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC,  TO(_QW), KC_PSCR, KC_SLCK, KC_PAUS )
+};
 
 const uint16_t PROGMEM fn_actions[] = {
 

keyboards/atreus/keymaps/dvorak_42_key/README.md

@@ -0,0 +1,21 @@
+Overview
+========
+
+This is a dvorak based layout for the Atreus. Its basic key layout is similar to the ergodox_ez "dvorak_42_key" layout. In fact this layout was created for seamless switching between the Ergodox EZ and Atreus. 
+
+How to build and flash
+----------------------
+
+to build;
+make atreus:dvorak_42_key
+
+to flash:
+avrdude -p atmega32u4 -c avr109 -U flash:w:atreus_dvorak_42_key.hex  -P COM7
+
+Layers
+------
+* BASE: basic dvorak layout
+* KEYNAV: arrow-key navigation. Momentary toggle held by thumb allows the right hand to navigate through text as well as copy/paste/cut, page up/page down
+* KEYSEL: similar to KEYNAV, except for shift-selection
+* COMBINED: this is a layer that combines numbers, brackets and special characters. !@#$%^&*( can be type by shift+COMBINED+1/2/3/etc..
+* MOUSE: mouse navigation, as well as browser tab-left/tab-right shortcuts

keyboards/atreus/keymaps/dvorak_42_key/config.h

@@ -0,0 +1,106 @@
+/*
+Copyright 2012 Jun Wako <wakojun@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+
+#include "config_common.h"
+
+
+// mouse speed
+
+#define MOUSEKEY_INTERVAL       15
+#define MOUSEKEY_DELAY          100
+#define MOUSEKEY_TIME_TO_MAX    100
+#define MOUSEKEY_MAX_SPEED      3
+
+#define MOUSEKEY_WHEEL_DELAY    500
+#define MOUSEKEY_WHEEL_DELTA    1
+#define MOUSEKEY_WHEEL_MAX_SPEED 1
+#define MOUSEKEY_WHEEL_TIME_TO_MAX 100
+
+/* USB Device descriptor parameter */
+
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6060
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    Technomancy
+#define PRODUCT         Atreus
+#define DESCRIPTION     q.m.k. keyboard firmware for Atreus
+
+/* key matrix size */
+#define MATRIX_ROWS 4
+#define MATRIX_COLS 11
+
+// Change this to how you wired your keyboard
+// COLS: Left to right, ROWS: Top to bottom
+#if defined(ATREUS_ASTAR)
+#   define MATRIX_ROW_PINS { D0, D1, D3, D2 }
+#if defined(PCBDOWN)
+#   define MATRIX_COL_PINS { B7, D6, F7, F6, B6, D4, E6, B4, B5, C6, D7 }
+#else
+#   define MATRIX_COL_PINS { D7, C6, B5, B4, E6, D4, B6, F6, F7, D6, B7 }
+#endif
+#   define UNUSED_PINS
+#elif defined(ATREUS_TEENSY2)
+#   define MATRIX_ROW_PINS { D0, D1, D2, D3 }
+#   define MATRIX_COL_PINS { F6, F5, F4, B7, B6, B5, B4, B3, B2, B1, B0 }
+#   define UNUSED_PINS
+#endif
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+//#define BACKLIGHT_LEVELS 3
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCING_DELAY 5
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/* key combination for command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION
+
+#endif

keyboards/atreus/keymaps/dvorak_42_key/keymap.c

@@ -0,0 +1,93 @@
+
+#include "atreus.h"
+
+// layers
+#define BASE      0
+#define KEYNAV    1
+#define KEYSEL    2
+#define MOUSE     3
+#define COMBINED  4
+
+// macros
+#define MOUSE_TOGGLE 1
+#define MOUSE_LOCK 2
+
+static bool mouse_lock = false;
+
+// building instructions:
+// make atreus:dvorak_42_key
+
+// flashing instructions:
+// avrdude -p atmega32u4 -c avr109 -U flash:w:atreus_dvorak_42_key.hex  -P COM7
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	
+[BASE] = { 
+  {KC_QUOTE,      KC_COMMA,      KC_DOT,    KC_P,       KC_Y,         KC_TRNS,    KC_F,  KC_G,  KC_C,   KC_R,   KC_L, },
+  {KC_A,          KC_O,          KC_E,      KC_U,       KC_I,         KC_TRNS,    KC_D,  KC_H,  KC_T,   KC_N,   KC_S, },
+  {KC_SCOLON,     KC_Q,          KC_J,      KC_K,       KC_X,         MO(KEYNAV), KC_B,  KC_M,  KC_W,   KC_V,   KC_Z, },
+  {OSM(MOD_LSFT), OSM(MOD_LCTL), M(MOUSE_TOGGLE), MO(KEYSEL), MO(COMBINED), KC_ENTER,   KC_SPACE,  KC_BSPC, RCTL(KC_BSPC), KC_CAPSLOCK, OSM(MOD_LSFT), }
+},	
+
+[KEYNAV] = { 
+  {KC_ESC,    MEH(KC_A), RCTL(KC_Z),   RCTL(KC_S), MEH(KC_B), KC_TRNS,    KC_TRNS,       KC_HOME,    KC_UP,           KC_END,     KC_PGUP, },
+  {MEH(KC_C), MEH(KC_D), RSFT(KC_TAB), KC_TAB,     MEH(KC_E), KC_TRNS,    LCTL(KC_LEFT), KC_LEFT,    KC_DOWN,         KC_RIGHT,   LCTL(KC_RIGHT), },
+  {MEH(KC_F), MEH(KC_G), MEH(KC_H),    MEH(KC_I),  MEH(KC_J), KC_TRNS,    KC_TRNS,       RCTL(KC_C), RCTL(KC_X),      RCTL(KC_V), KC_PGDOWN, },
+  {KC_TRNS, KC_TRNS,   KC_TRNS,      KC_TRNS,    KC_TRNS,   KC_ENTER,   KC_SPACE,      KC_BSPC,   RCTL(KC_BSPC),    KC_DELETE,  LCTL(KC_DELETE), }
+},	
+
+[KEYSEL] = { 
+  {KC_TRNS, KC_TRNS, RCTL(KC_Z),   RCTL(KC_S), KC_TRNS, KC_TRNS,    KC_TRNS,             RSFT(KC_HOME), RSFT(KC_UP),  RSFT(KC_END), RSFT(KC_PGUP), },
+  {KC_TRNS, KC_TRNS, RSFT(KC_TAB), KC_TAB,     KC_TRNS, KC_TRNS,    RSFT(RCTL(KC_LEFT)), RSFT(KC_LEFT), RSFT(KC_DOWN), RSFT(KC_RIGHT), RSFT(RCTL(KC_RIGHT)), },
+  {KC_TRNS, KC_TRNS, KC_TRNS,      KC_TRNS,    KC_TRNS, KC_TRNS,    KC_TRNS,             RCTL(KC_C),RCTL(KC_X),     RCTL(KC_V), RSFT(KC_PGDN), },
+  {RESET,   KC_TRNS, KC_TRNS,      KC_TRNS,    KC_TRNS, KC_ENTER,   KC_SPACE,            KC_BSPC,   RCTL(KC_BSPC),  KC_DELETE,  LCTL(KC_DELETE), }
+},	
+
+[COMBINED] = { 
+  {KC_ESC,  KC_LABK, KC_RABK,     KC_DQUO,     KC_GRAVE, KC_TRNS,    KC_PLUS,     KC_7,    KC_8,    KC_9,    KC_ASTR, },
+  {KC_LPRN, KC_RPRN, KC_LBRACKET, KC_RBRACKET, KC_UNDS,  KC_TRNS,    KC_MINS,     KC_4,    KC_5,    KC_6,    KC_SLSH, },
+  {KC_LCBR, KC_RCBR, KC_BSLS,     KC_PIPE,     KC_TILD,  KC_TRNS,    KC_EQUAL,    KC_1,    KC_2,    KC_3,    KC_QUES, },
+  {KC_TRNS, KC_TRNS, KC_TRNS,     KC_TRNS,     KC_TRNS,  KC_TRNS,    KC_TRNS,     KC_0,  KC_DOT,  KC_TRNS, KC_TRNS, }
+},	
+
+[MOUSE] = { 
+  {KC_TRNS,      KC_PGUP, KC_MS_WH_UP,   KC_UP,        KC_TRNS, KC_TRNS, KC_UP,     KC_HOME,   KC_MS_U,   KC_END,  KC_MS_WH_UP,  },
+  {KC_MS_ACCEL0, KC_PGDN, KC_MS_WH_DOWN, KC_DOWN,      KC_TRNS, KC_TRNS, KC_DOWN,   KC_MS_L,   KC_MS_D,   KC_MS_R, KC_MS_WH_DOWN, },
+  {KC_TRNS,      KC_TRNS, KC_TRNS,       KC_TRNS,      KC_TRNS, KC_BTN3, MEH(KC_X), MEH(KC_Y), MEH(KC_Z), KC_F5,   RCTL(KC_W), },
+  {KC_TRNS, M(MOUSE_LOCK), KC_TRNS, KC_MS_ACCEL0, KC_TRNS, KC_BTN1, KC_BTN2, RSFT(RCTL(KC_TAB)), RCTL(KC_TAB), RCTL(KC_T), LALT(KC_LEFT), }
+},	
+
+
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  // MACRODOWN only works in this function
+      switch(id) {
+		case MOUSE_TOGGLE:
+            if (record->event.pressed) {
+				layer_on(MOUSE);
+            } else {
+				if(!mouse_lock)
+					layer_off(MOUSE);
+			}
+			break;
+		case MOUSE_LOCK:
+			if (record->event.pressed)
+			{
+				if(mouse_lock)
+				{
+					mouse_lock = false;
+					layer_off(MOUSE);
+				}
+				else
+					mouse_lock = true;
+			}
+			break;		  
+      }
+    return MACRO_NONE;
+};

keyboards/atreus/keymaps/henxing/Readme.md

@@ -0,0 +1,6 @@
+# Hugh's Atreus Keymap
+
+This keymap is the same as the [default](../default) layout for the Atreus, but
+uses the programming style found in the Let's
+Split [default](../../../lets_split/keymaps/default) keymap. See
+[`keymap.c`](keymap.c) for the layout.

keyboards/atreus/keymaps/henxing/keymap.c

@@ -0,0 +1,105 @@
+#include "atreus.h"
+#include "action_layer.h"
+#include "eeconfig.h"
+
+extern keymap_config_t keymap_config;
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _QWERTY 0
+#define _LOWER  1
+#define _RAISE  2
+
+enum custom_keycodes {
+    QWERTY = SAFE_RANGE,
+    LOWER,
+    RAISE
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+    /*
+     *  q   w   e    r    t        ||       y     u    i  o   p
+     *  a   s   d    f    g        ||       h     j    k  l   ;
+     *  z   x   c    v    b        ||       n     m    ,  .   /
+     * esc tab gui shift bksp ctrl || alt space lower  -  ' enter
+     */
+    [_QWERTY] = KEYMAP( \
+            KC_Q,   KC_W,   KC_E,    KC_R,    KC_T,                      KC_Y,   KC_U,  KC_I,    KC_O,    KC_P,    \
+            KC_A,   KC_S,   KC_D,    KC_F,    KC_G,                      KC_H,   KC_J,  KC_K,    KC_L,    KC_SCLN, \
+            KC_Z,   KC_X,   KC_C,    KC_V,    KC_B,                      KC_N,   KC_M,  KC_COMM, KC_DOT,  KC_SLSH, \
+            KC_ESC, KC_TAB, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC, LOWER, KC_MINS, KC_QUOT, KC_ENT   \
+            ),
+
+    /*
+     *  !       @     up     {    }        ||     pgup    7     8     9    *
+     *  #     left   down  right  $        ||     pgdn    4     5     6    +
+     *  [       ]      (     )    &        ||       `     1     2     3    \
+     * raise  insert  gui  shift bksp ctrl || alt space  ____   .     0    =
+     */
+    [_LOWER] = KEYMAP( \
+            KC_EXLM, KC_AT,   KC_UP,   KC_LCBR, KC_RCBR,                   KC_PGUP, KC_7,    KC_8,   KC_9, KC_ASTR, \
+            KC_HASH, KC_LEFT, KC_DOWN, KC_RGHT, KC_DEL,                    KC_PGDN, KC_4,    KC_5,   KC_6, KC_PLUS, \
+            KC_LBRC, KC_RBRC, KC_LPRN, KC_RPRN, KC_AMPR,                   KC_GRV,  KC_1,    KC_2,   KC_3, KC_BSLS, \
+            RAISE,   KC_INS,  KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC,  KC_TRNS, KC_DOT, KC_0, KC_EQL   \
+            ),
+
+    /*
+     * insert home   up   end  pgup       ||      up      F7    F8     F9    F10
+     *  del   left  down right pgdn       ||     down     F4    F5     F6    F11
+     *       volup             reset      ||              F1    F2     F3    F12
+     *       voldn super shift bksp  ctrl || alt space QWERTY  prtsc scroll pause
+     */
+    [_RAISE] = KEYMAP( \
+            KC_INS,  KC_HOME, KC_UP,   KC_END,  KC_PGUP,                   KC_UP,   KC_F7,  KC_F8,   KC_F9,   KC_F10, \
+            KC_DEL,  KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN,                   KC_DOWN, KC_F4,  KC_F5,   KC_F6,   KC_F11, \
+            KC_TRNS, KC_VOLU, KC_TRNS, KC_TRNS, RESET,                     KC_TRNS, KC_F1,  KC_F2,   KC_F3,   KC_F12, \
+            KC_NO,   KC_VOLD, KC_LGUI, KC_LSFT, KC_BSPC, KC_LCTL, KC_LALT, KC_SPC,  QWERTY, KC_PSCR, KC_SLCK, KC_PAUS \
+            )
+
+};
+
+void persistent_default_layer_set(uint16_t default_layer) {
+    eeconfig_update_default_layer(default_layer);
+    default_layer_set(default_layer);
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+
+    // The value to return
+    bool return_value = false;
+
+    switch (keycode) {
+        case QWERTY:
+            if (record->event.pressed) {
+                persistent_default_layer_set(1UL<<_QWERTY);
+            }
+            break;
+
+        case LOWER:
+            // Toggle LOWER layer on when key pressed and off when released
+            if (record->event.pressed) {
+                layer_on(_LOWER);
+            } else {
+                layer_off(_LOWER);
+            }
+            break;
+
+        case RAISE:
+            if (record->event.pressed) {
+                persistent_default_layer_set(1UL<<_RAISE);
+            }
+            break;
+
+        default:
+
+            // If the keycode is not handled by any of the other cases, the
+            // function should return true
+            return_value = true;
+            break;
+    }
+
+    return return_value;
+}

keyboards/atreus/keymaps/xk/config.h

@@ -0,0 +1,37 @@
+/*
+This is the c configuration file for the keymap
+
+Copyright 2012 Jun Wako <wakojun@gmail.com>
+Copyright 2015 Jack Humbert
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+*/
+
+#ifndef CONFIG_USER_H
+#define CONFIG_USER_H
+
+#include "../../config.h"
+
+#define TAPPING_TOGGLE 1
+#define TAPPING_TERM 300
+#define ONESHOT_TAP_TOGGLE 3
+#define ONESHOT_LAYER_TOGGLE 3
+#define ONESHOT_TIMEOUT 800
+
+#define MOUSEKEY_INTERVAL 50
+#define MOUSEKEY_DELAY 0
+#define MOUSEKEY_TIME_TO_MAX 60
+#define MOUSEKEY_MAX_SPEED 7
+
+#define MOUSEKEY_WHEEL_DELAY 0
+#define MOUSEKEY_WHEEL_MAX_SPEED   8
+#define MOUSEKEY_WHEEL_TIME_TO_MAX 40
+
+#define PREVENT_STUCK_MODIFIERS
+#define IGNORE_MOD_TAP_INTERRUPT
+#define PERMISSIVE_HOLD
+
+#endif

keyboards/atreus/keymaps/xk/keymap.c

@@ -0,0 +1,313 @@
+// this is the style you want to emulate.
+// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
+
+#include "atreus.h"
+
+#define _COLEMAK  0
+#define _KAMELOC  1
+#define _IKAPILA  2
+#define _IKASHFT  3
+#define _FNCTION  5
+#define _NINEKEY  6
+#define _GAMEQWERTY   7
+#define _MLAYER   8
+#define _GRVTABL  9
+
+enum custom_keycodes {
+  COLEMAK = SAFE_RANGE,
+  KAMELOC,
+  IKAPILA,
+  IKASHFT,
+  FNCTION,
+  NINEKEY,
+  GAMEQWERTY,
+  MLAYER,
+  GRVTABL,
+};
+
+//TD Declarations
+enum {
+VOM = 0,
+PRN,
+EGT,
+HRD,
+XRD,
+DSH,
+ESC,
+EQE,
+PGN,
+HND,
+COD,
+UND,
+MND,
+F11,
+F12,
+F13,
+F14,
+F15,
+F16,
+F17,
+F18,
+F19,
+F20,
+//unicode_inputctl
+LINUX,
+WIN,
+WINSH,
+OSX,
+};
+
+#define _______     KC_TRNS
+#define XXXXXXX     KC_NO
+
+// action-TAP for key/mod behavior LT(layer, KC)
+#define XK_TAB      LT(_KAMELOC, KC_TAB)
+#define XK_BSP      LT(_KAMELOC, KC_BSPC)
+
+#define XK_SPC      LT(_IKAPILA, KC_SPC)
+#define XK_ENT      LT(_IKAPILA, KC_ENT)
+#define XK_PGDN     LT(_IKASHFT, KC_PGDN)
+#define XK_APO      LT(_IKASHFT, KC_QUOT)
+#define XK_PGUP     LT(_IKASHFT, KC_PGUP)
+#define PIPBOY      LT(_FNCTION, KC_BSLS)
+
+#define XK_DEL      LT(_IKASHFT, KC_DEL)
+#define XK_ESC      LT(_GRVTABL, KC_ESC)
+
+// mod-TAP for mod/key behavior MT(modkey, KC)
+#define ALT_IT      MT(MOD_RALT, KC_SCLN)
+#define SFT_IT      MT(MOD_RSFT, KC_DOT)
+#define CTL_IT      MT(MOD_RCTL, KC_SLSH)
+#define SFT_ENT	    MT(MOD_RSFT, KC_ENT)
+
+//sticky modifiers
+#define KYCTL       OSM(MOD_LCTL)
+#define KYSFT       OSM(MOD_LSFT)
+#define KYALT       OSM(MOD_LALT)
+#define CAKY        OSM(MOD_LCTL | MOD_LALT)
+
+//shortcuts
+#define CADEL       LALT(LCTL(KC_DEL))
+#define CAINS       LALT(LCTL(KC_INS))
+#define TGNKRO      MAGIC_TOGGLE_NKRO
+
+#define NAVCH       LCTL(KC_HOME)
+#define NAVCPD      LCTL(KC_PGDN)
+#define NAVCPU      LCTL(KC_PGUP)
+#define NAVCE       LCTL(KC_END)
+#define NAVCU       LCTL(KC_UP)
+#define NAVCD       LCTL(KC_DOWN)
+#define NAVCL       LCTL(KC_LEFT)
+#define NAVCR       LCTL(KC_RGHT)
+#define NAVGU       LGUI(KC_UP)
+#define NAVGD       LGUI(KC_DOWN)
+#define NAVGL       LGUI(KC_LEFT)
+#define NAVGR       LGUI(KC_RGHT)
+
+#define KC_NDSH     LCTL(KC_PMNS)
+#define KC_MDSH     LALT(LCTL(KC_PMNS))
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+/*
+  TAP
+  ┌────┬────┬────┬────┬────┐              ┌────┬────┬────┬────┬────┐
+  │ Q  │ W  │ F  │ P  │ B  │              │ J  │ L  │ U  │ Y  │ ;  │
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │ A  │ R  │ S  │ T  │ G  │              │ M  │ N  │ E  │ I  │ O  │
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │ X  │ C  │ D  │ V  │ Z  ├────┐    ┌────┤ K  │ H  │ ,  │ .  │ /  │
+  ├────┼────┼────┼────┼────┤    │    │    ├────┼────┼────┼────┼────┤
+  │SFTn│CTLn│ALTn│ROUS│SPC │BKSP│    │TAB │ENT │PGDN│ '  │ \  │ESC │
+  └────┴────┴────┴────┴────┴────┘    └────┴────┴────┴────┴────┴────┘
+   HOLD
+  ┌────┬────┬────┬────┬────┐              ┌────┬────┬────┬────┬────┐
+  │    │    │    │    │    │              │    │    │    │    │ALT │
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │    │    │    │    │    │              │    │    │    │    │    │
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │    │    │    │    │    ├────┐    ┌────┤    │    │    │    │CTL │
+  ├────┼────┼────┼────┼────┤    │    │    ├────┼────┼────┼────┼────┤
+  │SFT │CTL │ALT │ROUS│L123│L OH│    │L OH│L123│L!@#│    │L FN│LESC│
+  └────┴────┴────┴────┴────┴────┘    └────┴────┴────┴────┴────┴────┘
+   DOUBLETAP
+  ┌────┬────┬────┬────┬────┐              ┌────┬────┬────┬────┬────┐
+  │    │    │    │    │    │              │    │    │    │    │    │
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │    │    │    │    │    │              │    │    │    │    │    │
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │    │    │    │    │    ├────┐    ┌────┤    │    │    │    │    │
+  ├────┼────┼────┼────┼────┤    │    │    ├────┼────┼────┼────┼────┤
+  │OSML│OSML│OSML│NADA│    │    │    │    │    │    │    │    │    │
+  └────┴────┴────┴────┴────┴────┘    └────┴────┴────┴────┴────┴────┘
+*/
+
+// Colemak PB&J (Mod-DH)
+[_COLEMAK] = KEYMAP( \
+     KC_Q,   KC_W,   KC_F,    KC_P,    KC_B,                      KC_J,     KC_L,        KC_U,    KC_Y,  ALT_IT,  \
+     KC_A,   KC_R,   KC_S,    KC_T,    KC_G,                      KC_M,     KC_N,        KC_E,    KC_I,    KC_O,  \
+     KC_X,   KC_C,   KC_D,    KC_V,    KC_Z,                      KC_K,     KC_H,     KC_COMM,  SFT_IT,  CTL_IT,  \
+    KYCTL,  KYSFT,  KYALT,  TT(_MLAYER),  XK_SPC,  XK_TAB,  XK_BSP,  XK_ENT,  XK_PGDN, XK_APO,  PIPBOY,  XK_ESC  \
+),
+
+// useful for one-handed typing
+[_KAMELOC] = KEYMAP( \
+  KC_SCLN,    KC_Y,        KC_U,         KC_L,   KC_J,                       KC_B,         KC_P,    KC_F,    KC_W,    KC_Q,  \
+     KC_O,    KC_I,        KC_E,         KC_N,   KC_M,                       KC_G,         KC_T,    KC_S,    KC_R,    KC_A,  \
+  KC_SLSH,  KC_DOT,     KC_COMM,         KC_H,   KC_K,                       KC_Z,         KC_V,    KC_D,    KC_C,    KC_X,  \
+   XK_ESC,  PIPBOY, TT(_MLAYER),     KC_PGDN, KC_ENT,  _______, _______,  XK_SPC,       KC_PGUP,   KYALT,   KYCTL,   KYSFT  \
+),
+
+/*
+  ┌────┬────┬────┬────┬────┐              ┌────┬────┬────┬────┬────┐
+  │ 1  │ 2  │ 3  │ 4  │ 5  │              │ 6  │ 7  │ 8  │ 9  │ 0  │
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │ M  │ V- │ V+ │NEXT│PLAY│              │ ←  │ ↓  │ ↑  │ →  │DASH│
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │ -  │ =  │ `  │GUI │UNDO├────┐    ┌────┤HOME│END │HOME│INS │ \  │
+  ├────┼────┼────┼────┼────┤    │    │    ├────┼────┼────┼────┼────┤
+  │    │    │    │    │    │    │    │    │    │GUI │    │    │    │
+  └────┴────┴────┴────┴────┴────┘    └────┴────┴────┴────┴────┴────┘
+*/
+
+[_IKAPILA] = KEYMAP( \
+     KC_1,    KC_2,    KC_3,    KC_4,       KC_5,                        KC_6,    KC_7,    KC_8,    KC_9,    KC_0,  \
+  KC_MUTE, KC_VOLD, KC_VOLU, TD(MND),    KC_MPLY,                     KC_LEFT, KC_DOWN,   KC_UP, KC_RGHT, TD(DSH),  \
+  KC_MINS,  KC_EQL,  KC_GRV, KC_LGUI, LCTL(KC_Z),                     TD(HND), KC_HOME, TD(HND),  KC_INS, KC_BSLS,  \
+  _______, _______, _______, _______,    _______,  _______, _______,  _______, KC_LGUI, _______, _______,   KYSFT  \
+),
+
+/*
+  ┌────┬────┬────┬────┬────┐              ┌────┬────┬────┬────┬────┐
+  │ !  │ @  │ #  │ $  │ %  │              │ ^  │ &  │ *  │ (  │ )  │
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │PSCR│ ←  │ ↓  │ ↑  │ →  │              │NEXT│PGUP│ V+ │ V- │DASH│
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │ _  │ +  │ ~  │HOME│END ├────┐    ┌────┤ {} │ () │ <> │ [  │ ]  │
+  ├────┼────┼────┼────┼────┤    │    │    ├────┼────┼────┼────┼────┤
+  │    │    │    │    │    │DEL │    │BKSP│    │    │    │    │    │
+  └────┴────┴────┴────┴────┴────┘    └────┴────┴────┴────┴────┴────┘
+*/
+
+[_IKASHFT] =  KEYMAP( \
+  KC_EXLM,   KC_AT, KC_HASH,  KC_DLR, KC_PERC,                  KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN,  \
+  KC_PSCR, KC_LEFT, KC_DOWN,   KC_UP, KC_RGHT,                  TD(MND), KC_PGUP, KC_VOLU, TD(VOM), KC_MDSH,  \
+  KC_UNDS, KC_PLUS, KC_TILD, KC_HOME,  KC_END,                     M(1),    M(0),    M(5), KC_LBRC, KC_RBRC,  \
+  _______, _______, _______, _______, _______, KC_BSPC, KC_DEL, _______, _______, _______, _______, _______  \
+),
+
+/*
+  ┌────┬────┬────┬────┬────┐              ┌────┬────┬────┬────┬────┐
+  │ F1 │ F2 │ F3 │ F4 │ F5 │              │ F6 │ F7 │ F8 │ F9 │ F10│
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │ F21│ F22│ F23│ F24│PAUS│              │    │SCLK│BOOT│    │NKRO│
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │    │    │    │    │    ├────┐    ┌────┤    │    │    │    │CAPS│
+  ├────┼────┼────┼────┼────┤    │    │    ├────┼────┼────┼────┼────┤
+  │    │    │    │    │    │    │    │    │    │    │    │    │    │
+  └────┴────┴────┴────┴────┴────┘    └────┴────┴────┴────┴────┴────┘
+*/
+
+[_FNCTION] =  KEYMAP( \
+  TD(F11), TD(F12), TD(F13), TD(F14), TD(F15),                     TD(F16), TD(F17), TD(F18), TD(F19), TD(F20),  \
+   KC_F21,  KC_F22,  KC_F23,  KC_F24, XXXXXXX,                     XXXXXXX, KC_SLCK, XXXXXXX, XXXXXXX,  TGNKRO,  \
+  XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                     XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_CAPS,  \
+  _______, _______, _______, _______, _______,  _______, _______,  _______, _______, _______, _______, _______  \
+),
+
+[_GAMEQWERTY] = KEYMAP( \
+     KC_P,    KC_Q,    KC_W,    KC_E,    KC_R,                        KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,  \
+  KC_SCLN,    KC_A,    KC_S,    KC_D,    KC_F,                        KC_G,    KC_H,    KC_J,    KC_K,    KC_L,  \
+  KC_SLSH,    KC_Z,    KC_X,    KC_C,    KC_V,                        KC_B,    KC_N,    KC_M, KC_COMM, TD(COD),  \
+  _______, _______, _______, _______, _______,  _______, _______,  _______, _______, _______, _______, _______  \
+),
+
+/*
+  ┌────┬────┬────┬────┬────┐              ┌────┬────┬────┬────┬────┐
+  │^HOM│^PGD│^UP │^PGU│^PGU│              │    │MW_L│ MU │MW_R│ AC2│
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │^END│^LFT│^DWN│^RGT│^PGD│              │    │ ML │ MD │ MR │ AC1│
+  ├────┼────┼────┼────┼────┤              ├────┼────┼────┼────┼────┤
+  │ M5 │ M2 │ M4 │ M3 │ M1 ├────┐    ┌────┤    │MW_D│MW_U│    │ AC0│
+  ├────┼────┼────┼────┼────┤    │    │    ├────┼────┼────┼────┼────┤
+  │    │    │    │    │    │    │    │    │    │    │    │    │    │
+  └────┴────┴────┴────┴────┴────┘    └────┴────┴────┴────┴────┴────┘ 
+*/
+
+[_MLAYER] =  KEYMAP( \
+  LALT(KC_ESC), KC_9,    KC_8,    KC_7,    KC_6,                  M(1),    M(0), KC_MS_U,    M(0),    M(2),  \
+     KC_0,    KC_2,    KC_3,    KC_4,    KC_5,                        M(5), KC_MS_L, KC_MS_D, KC_MS_R, KC_ACL2,  \
+     KC_1,    KC_0, XXXXXXX, XXXXXXX, KC_BTN5,                     KC_WH_L, KC_WH_D, KC_WH_U, KC_WH_R,    M(5),  \
+  _______, _______, _______, _______, KC_BTN1,  KC_BTN2, KC_BTN2,  KC_BTN1, KC_BTN2, _______, KC_ACL0, _______ \
+),
+
+//one_ring=2__rule__them-all
+[_GRVTABL] =  KEYMAP( \
+    LALT(KC_PSCR),         M(4),      KC_PWR,     KC_POWER,        RESET,                            RESET,         KC_R,    KC_E,     KC_I,       LALT(KC_PSCR),  \
+     TG(_NINEKEY), TG(_FNCTION), TG(_MLAYER), TG(_IKASHFT), TG(_IKAPILA),                     TG(_IKAPILA),         KC_S,    KC_U,     KC_B,        TG(_NINEKEY),  \
+             M(3), TG(_GAMEQWERTY),  XXXXXXX,      XXXXXXX,      XXXXXXX,                          KC_MYCM,      KC_CALC, XXXXXXX, TG(_GAMEQWERTY),         M(3),  \
+     TT(_GRVTABL), TG(_FNCTION), TG(_MLAYER), TG(_IKASHFT), TG(_IKAPILA),  _______, _______,  TG(_IKAPILA), TG(_IKASHFT), TG(_MLAYER), TG(_MLAYER), TG(_NINEKEY)  \
+)};
+
+qk_tap_dance_action_t tap_dance_actions[] = {
+ [VOM] = ACTION_TAP_DANCE_DOUBLE(KC_VOLD, KC_MUTE),
+ [PRN] = ACTION_TAP_DANCE_DOUBLE(KC_LPRN, KC_RPRN),
+ [EGT] = ACTION_TAP_DANCE_DOUBLE(KC_LCBR, KC_RCBR),
+ [HRD] = ACTION_TAP_DANCE_DOUBLE(KC_LBRC, KC_RBRC),
+ [DSH] = ACTION_TAP_DANCE_DOUBLE(KC_NDSH, KC_MDSH),
+ [ESC] = ACTION_TAP_DANCE_DOUBLE(KC_ESC,  LALT(KC_F4)),
+ [EQE] = ACTION_TAP_DANCE_DOUBLE(KC_EQL,  KC_ENT),
+ [UND] = ACTION_TAP_DANCE_DOUBLE(KC_Z,    LCTL(KC_Z)),
+ [PGN] = ACTION_TAP_DANCE_DOUBLE(KC_PGDN, KC_PGUP),
+ [HND] = ACTION_TAP_DANCE_DOUBLE(KC_HOME, KC_END),
+ [COD] = ACTION_TAP_DANCE_DOUBLE(KC_COMM, KC_DOT),
+ [MND] = ACTION_TAP_DANCE_DOUBLE(KC_MNXT, KC_MPRV),
+ [F11] = ACTION_TAP_DANCE_DOUBLE(KC_F1,   KC_F11),
+ [F12] = ACTION_TAP_DANCE_DOUBLE(KC_F2,   KC_F12),
+ [F13] = ACTION_TAP_DANCE_DOUBLE(KC_F3,   KC_F13),
+ [F14] = ACTION_TAP_DANCE_DOUBLE(KC_F4,   KC_F14),
+ [F15] = ACTION_TAP_DANCE_DOUBLE(KC_F5,   KC_F15),
+ [F16] = ACTION_TAP_DANCE_DOUBLE(KC_F6,   KC_F16),
+ [F17] = ACTION_TAP_DANCE_DOUBLE(KC_F7,   KC_F17),
+ [F18] = ACTION_TAP_DANCE_DOUBLE(KC_F8,   KC_F18),
+ [F19] = ACTION_TAP_DANCE_DOUBLE(KC_F9,   KC_F19),
+ [F20] = ACTION_TAP_DANCE_DOUBLE(KC_F10,  KC_F20),
+};
+
+void matrix_init_user(){
+  set_unicode_input_mode(UC_LNX);
+}
+
+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(9), U(LSFT), D(LSFT), T(0), U(LSFT), T(LEFT), END );
+  case 1:
+    return MACRO( D(LSFT), T(LBRC), U(LSFT), D(LSFT), T(RBRC), U(LSFT), T(LEFT), END );
+  case 2:
+    return MACRO( T(LBRC), T(RBRC), T(LEFT), END);
+  case 5:
+    return MACRO( D(LSFT), T(COMMA), U(LSFT), D(LSFT), T(DOT), U(LSFT), END );
+  case 3:
+    clear_keyboard();
+    return false;
+    break;
+  case 4:
+    return MACRO( D(LSFT), T(SCOLON), U(LSFT), D(LSFT), T(9), U(LSFT), D(LSFT), T(0), U(LSFT), D(LSFT), T(LBRACKET), U(LSFT), D(LSFT), T(9), U(LSFT), D(LSFT), T(SCOLON), U(LSFT), D(LSFT), T(0), U(LSFT), D(LSFT), T(BSLASH), U(LSFT), D(LSFT), T(SCOLON), U(LSFT), D(LSFT), T(7), U(LSFT), D(LSFT), T(RBRACKET), U(LSFT), T(SCOLON), D(LSFT), T(SCOLON), U(LSFT), END );
+  case WINSH:
+    set_unicode_input_mode(UC_WIN);
+    return false;
+    break;
+  case WIN:
+    set_unicode_input_mode(UC_WINC);
+    return false;
+    break;
+  case OSX:
+    set_unicode_input_mode(UC_OSX);
+    return false;
+    break;
+   }
+  }
+ return MACRO_NONE;
+};

keyboards/atreus/keymaps/xk/rules.mk

@@ -0,0 +1,18 @@
+MOUSEKEY_ENABLE = yes       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+NKRO_ENABLE = no            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work 
+TAP_DANCE_ENABLE = yes
+
+CONSOLE_ENABLE = no         # Console for debug(+400)
+COMMAND_ENABLE = no         # Commands for debug and configuration
+BACKLIGHT_ENABLE = no       # Enable keyboard backlight functionality
+MIDI_ENABLE = no            # MIDI controls
+AUDIO_ENABLE = no           # Audio output on port C6
+UNICODE_ENABLE = yes        # Unicode
+BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
+RGBLIGHT_ENABLE = no        # Enable WS2812 RGB underlight.  Do not enable this with audio at the same time.
+BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
+
+ifndef QUANTUM_DIR
+	include ../../../../Makefile
+endif

keyboards/atreus/readme.md

@@ -3,16 +3,14 @@ Atreus
 
 A small mechanical keyboard that is based around the shape of the human hand.
 
-These configuration files are specifically for the Atreus keyboards created by Phil Hagelberg (@technomancy). This keyboard is available in two variants: one powered by a Teensy 2, one powered by an A-Star. This repository currently assumes that you have an A-Star powered Atreus. If you are using a Teensy2, specify that by adding `TEENSY2=yes` to your `make` commands.
+These configuration files are specifically for the Atreus keyboards created by Phil Hagelberg (@technomancy). This keyboard is available in two variants: one powered by a Teensy 2, (usually hand-wired) one powered by an A-Star. (usually using a PCB) This repository currently assumes that you have an A-Star powered Atreus. If you are using a Teensy2, specify that by adding `TEENSY2=yes` to your `make` commands.
 
-If you are coming from the [atreus-firmware](https://github.com/technomancy/atreus-firmware), we've also brought forward the `make upload` command for you to use.
-
-Keyboard Maintainer: QMK Community
-Hardware Supported: Atreus PCB
+Keyboard Maintainer: QMK Community  
+Hardware Supported: Atreus PCB  
 Hardware Availability: https://atreus.technomancy.us
 
 Make example for this keyboard (after setting up your build environment):
 
-    make atreus-default
+    make atreus:default:avrdude
 
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/atreus/rules.mk

@@ -77,6 +77,3 @@ UNICODE_ENABLE = YES 		# Unicode
 # BLUETOOTH_ENABLE = yes # Enable Bluetooth with the Adafruit EZ-Key HID
 
 USB = /dev/cu.usbmodem1411
-
-# upload: build
-# 	$(ATREUS_UPLOAD_COMMAND)

keyboards/atreus62/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/atreus62/readme.md

@@ -5,12 +5,12 @@ A 62 key variant of the Atreus keyboard.
 
 https://github.com/profet23/atreus62
 
-Keyboard Maintainer: QMK Community
-Hardware Supported: Atreus62 PCB
+Keyboard Maintainer: QMK Community  
+Hardware Supported: Atreus62 PCB  
 Hardware Availability: http://shop.profetkeyboards.com/product/atreus62-keyboard
 
 Make example for this keyboard (after setting up your build environment):
 
-    make atreus62-default
+    make atreus62:default
 
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/bananasplit/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/bananasplit/README.md

@@ -1,29 +1,15 @@
-# BananaSplit60 keyboard firmware
+BananaSplit60
+===
 
-Ported from evangs/tmk_keyboard
+A 60% PCB featuring a split spacebar.
 
-## Quantum MK Firmware
+Keyboard Maintainer: QMK Community  
+Hardware Supported: BananaSplit60 PCB  
+Hardware Availability: https://thevankeyboards.com/products/gb-bananasplit-60-keyboard-kit?variant=42149104910
 
-For the full Quantum feature list, see [the parent readme](/).
+Make example for this keyboard (after setting up your build environment):
 
-## Building
+    make bananasplit:default
 
-Download or clone the whole firmware and navigate to the keyboards/bananasplit folder. Once your dev env is setup, you'll be able to type `make` to generate your .hex - you can then use the Teensy Loader to program your .hex file.
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
 
-Depending on which keymap you would like to use, you will have to compile slightly differently.
-
-### Default
-
-To build with the default keymap, simply run `make default`.
-
-### Other Keymaps
-
-Several version of keymap are available in advance but you are recommended to define your favorite layout yourself. To define your own keymap create a folder with the name of your keymap in the keymaps folder, and see keymap documentation (you can find in top readme.md) and existant keymap files.
-
-To build the firmware binary hex file with a keymap just do `make` with a keymap like this:
-
-```
-$ make [default|jack|<name>]
-```
-
-Keymaps follow the format **__\<name\>.c__** and are stored in the `keymaps` folder.

keyboards/bananasplit/keymaps/rask/README.md

@@ -0,0 +1,53 @@
+# rask's BananaSplit60
+
+![BS60 layout](http://i.imgur.com/Q7so1py.png)
+
+## Notes
+
+### Layers
+
+Base layer is a regular HHKBish ANSI layer. Toggling the
+alternate base layer (Fn3) makes it simpler to play games with
+the left space being set to be an actual Space.
+
+Layer 1 (Fn1) contains usual 60% functionalities such as the
+F-row, while Layer 2 (Fn2) contains media controls.
+
+The final layer (Fn4) is a special layer that acts as a lock
+layer, meaning the keyboard is locked while the layer
+is active. This firmware assumes a lock switch (read below).
+
+### Lock switches
+
+1.25u between the split space halves and the 1u key right
+left of LeftArrow are to be operated with a lock switch.
+If you don't have lock switches you should swap the `MO()`
+calls with `TG()` calls to make the layer toggles work
+with regular non/locking switches.
+
+## How to make and flash
+
+(These instructions are for Linux-based operating systems
+with `dfu-programmer` available.)
+
+`cd` into the `bananasplit` keyboard's directory and run
+
+    make rask
+
+which should result in a file called `bananasplit_rask.hex` appearing
+in your QMK root directory.
+
+Now plug in your BananaSplit60 keyboard via USB. Verify
+with `lsusb` that it appears. At least my PCB did not have
+anything preflashed so you should see `atmega32u4` or similar
+in the `lsusb` output.
+
+Now you can flash the firmware by
+
+    $ sudo dfu-programmer atmega32u4 erase
+    $ cd /qmk_firmware/root/directory
+    $ sudo dfu-programmer atmega32u4 flash bananasplit_rask.hex
+
+_If_ you happen to have some other `atmega32u4` based device
+I suggest you plug it out before flashing your BS60 just to
+prevent accidentally flashing your old device.

keyboards/bananasplit/keymaps/rask/keymap.c

@@ -0,0 +1,72 @@
+#include "bananasplit.h"
+
+// rask's BananaSplit60 layout
+
+#define L_BASE      0
+#define L_BASE_ALT  1
+#define L_ONE       2
+#define L_TWO       3
+#define L_LOCK      4
+
+#define ______  KC_TRNS
+#define XXXXXX  KC_NO
+
+// L_BASE
+// Initial layer with default keymap
+//
+// L_BASE_ALT
+// Layer with some standardisation e.g. make
+// space key "full" to make gaming less of a
+// chore
+//
+// L_ONE
+// General things like F-row and navigation
+//
+// L_TWO
+// Media controls and more exotic keybinds
+//
+// L_LOCK
+// Lock the keyboard, release to unlock
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    [L_BASE] = KEYMAP_HHKB_ARROW( \
+        KC_GRV,     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_BSLS,    KC_DEL,     \
+        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_BSPC,    \
+        MO(L_ONE),  KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,       KC_L,       KC_SCLN,    KC_QUOT,                            KC_ENT,     \
+        KC_LSFT,            KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,       KC_COMM,    KC_DOT,     MT(MOD_RSFT, KC_SLSH),  KC_UP,      MO(L_TWO),  \
+        KC_LCTRL,   KC_LGUI,    KC_LALT,    KC_BSPC,        MO(L_BASE_ALT), KC_SPACE,   KC_RALT,    MO(L_LOCK),             KC_LEFT,    KC_DOWN,    KC_RIGHT    \
+    ),
+
+    [L_BASE_ALT] = KEYMAP_HHKB_ARROW( \
+        ______,     ______, ______, ______, ______, ______, ______, ______, ______,     ______,     ______,     ______,     ______,     ______,     ______,     \
+        ______,     ______, ______, ______, ______, ______, ______, ______, ______,     ______,     ______,     ______,     ______,                 ______,     \
+        ______,     ______, ______, ______, ______, ______, ______, ______, ______,     ______,     ______,     ______,                             ______,     \
+        ______,             ______, ______, ______, ______, ______, ______, ______,     ______,     ______,     ______,                 ______,     ______,     \
+        ______,     ______,     ______,     KC_SPACE,       ______,         ______,     ______,     ______,                 ______,     ______,     ______      \
+    ),
+
+    [L_ONE] = KEYMAP_HHKB_ARROW( \
+        KC_ESC,     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_PSCR,    KC_INS,     \
+        ______,     ______, ______, ______, ______, ______, ______, ______, ______,     ______,     ______,     ______,     ______,                 ______,     \
+        ______,     ______, ______, ______, ______, ______, ______, ______, ______,     ______,     ______,     ______,                             ______,     \
+        ______,             ______, ______, ______, ______, ______, ______, ______,     ______,     ______,     ______,                 KC_PGUP,    ______,     \
+        ______,     ______,     ______,     ______,         ______,         ______,     ______,     ______,                 KC_HOME,    KC_PGDN,    KC_END      \
+
+    ),
+
+    [L_TWO] = KEYMAP_HHKB_ARROW( \
+        ______,     ______, ______, ______, ______, ______, ______, ______, ______,     ______,     ______,     ______,     ______,     ______,     ______,     \
+        ______,     ______, ______, ______, ______, ______, ______, ______, ______,     KC_MPRV,    KC_MPLY,    KC_MNXT,    ______,                 ______,     \
+        KC_CAPS,    ______, ______, ______, ______, ______, ______, ______, ______,     KC_VOLD,    KC_VOLU,    KC_MUTE,                            ______,     \
+        ______,             ______, ______, ______, ______, ______, ______, ______,     KC_MSTP,    ______,     ______,                 ______,     ______,     \
+        ______,     KC_APP,     ______,     ______,         ______,         ______,     ______,     ______,                 ______,     ______,     ______      \
+    ),
+
+    [L_LOCK] = KEYMAP_HHKB_ARROW( \
+        XXXXXX,     XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX,     XXXXXX,     XXXXXX,     XXXXXX,     XXXXXX,     XXXXXX,     XXXXXX,     \
+        XXXXXX,     XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX,     XXXXXX,     XXXXXX,     XXXXXX,     XXXXXX,                 XXXXXX,     \
+        XXXXXX,     XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX,     XXXXXX,     XXXXXX,     XXXXXX,                             XXXXXX,     \
+        XXXXXX,             XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX, XXXXXX,     XXXXXX,     XXXXXX,     XXXXXX,                 XXXXXX,     XXXXXX,     \
+        XXXXXX,     XXXXXX,     XXXXXX,     XXXXXX,         XXXXXX,         XXXXXX,     XXXXXX,     ______,                 XXXXXX,     XXXXXX,     XXXXXX      \
+    ),
+};

keyboards/bantam44/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/bantam44/readme.md

@@ -3,12 +3,12 @@ Bantam-44
 
 A small mechanical keyboard.
 
-Keyboard Maintainer: QMK Community
-Hardware Supported: Bantam-44 PCB
+Keyboard Maintainer: QMK Community  
+Hardware Supported: Bantam-44 PCB  
 Hardware Availability: http://www.bantamkeyboards.com
 
 Make example for this keyboard (after setting up your build environment):
 
-    make bantam44-default
+    make bantam44:default
 
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/chibios_test/Makefile

@@ -1,5 +0,0 @@
-SUBPROJECT_DEFAULT = stm32_f072_onekey
-
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/chibios_test/boards/GENERIC_STM32_F103/board.mk

@@ -1,5 +1,5 @@
 # List of all the board related files.
-BOARDSRC = $(KEYBOARD_PATH)/boards/GENERIC_STM32_F103/board.c
+BOARDSRC = $(BOARD_PATH)/boards/GENERIC_STM32_F103/board.c
 
 # Required include directories
-BOARDINC = $(KEYBOARD_PATH)/boards/GENERIC_STM32_F103
+BOARDINC = $(BOARD_PATH)/boards/GENERIC_STM32_F103

keyboards/chibios_test/rules.mk

@@ -5,4 +5,6 @@ CONSOLE_ENABLE = yes	# Console for debug
 COMMAND_ENABLE = yes    # Commands for debug and configuration
 SLEEP_LED_ENABLE = yes  # Breathing sleep LED during USB suspend
 NKRO_ENABLE = yes	    # USB Nkey Rollover
-CUSTOM_MATRIX = yes # Custom matrix file
+CUSTOM_MATRIX = yes # Custom matrix file
+
+DEFAULT_FOLDER = chibios_test/stm32_f072_onekey

keyboards/chibios_test/stm32_f072_onekey/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../../Makefile
-endif

keyboards/chibios_test/stm32_f103_onekey/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../../Makefile
-endif

keyboards/chibios_test/teensy_lc_onekey/Makefile

@@ -1,3 +0,0 @@
-ifndef MAKEFILE_INCLUDED
-	include ../../../Makefile
-endif

keyboards/chibios_test/teensy_lc_onekey/instructions.md

@@ -2,9 +2,24 @@
 
 These ARM Teensies are now supported through [ChibiOS](http://chibios.org).
 
-You'll need to install an ARM toolchain, for instance from [gcc ARM embedded](https://launchpad.net/gcc-arm-embedded) website, or using your favourite package manager. After installing, you should be able to run `arm-none-eabi-gcc -v` in the command prompt and get sensible output. This toolchain is used instead of `avr-gcc`, which is only for AVR chips. Naturally you'll also need the usual development tools (e.g. `make`), just as in the AVR setting.
+## Installing the ARM toolchain
 
-Next, you'll need ChibiOS. For Teensies, you'll need code from two repositories: [chibios-main](https://github.com/ChibiOS/ChibiOS) and [chibios-contrib](https://github.com/ChibiOS/ChibiOS). If you're not using git, you can just download a [zip of chibios from here](https://github.com/ChibiOS/ChibiOS/archive/a7df9a891067621e8e1a5c2a2c0ceada82403afe.zip), unpack the zip, and rename/move the unpacked directory (named `ChibiOS-<long_hash_here>`) to `tmk_core/tool/chibios/chibios` (so that the file `tmk_core/tool/chibios/chibios/license.txt` exists). Now the same procedure with a [zip of chibios-contrib from here](https://github.com/ChibiOS/ChibiOS-Contrib/archive/e1311c4db6cd366cf760673f769e925741ac0ad3.zip): unpack and move `ChibiOS-Contrib-<long_hash_here>` to `tmk_core/tool/chibios/chibios-contrib`.
+You'll need to install an ARM toolchain, there is now a nice documentation about the two AVR/ARM toolchain : https://docs.qmk.fm/getting_started_build_tools.html and you can just run `sudo util/install_dependencies.sh`.
+This toolchain is used instead of `avr-gcc`, which is only for AVR chips. Naturally you'll also need the usual development tools (e.g. `make`), just as in the AVR setting.
+
+You can find others way with the [gcc ARM embedded](https://launchpad.net/gcc-arm-embedded) website, or using your favourite package manager. After installing, you should be able to run `arm-none-eabi-gcc -v` in the command prompt and get sensible output.
+
+## Installing ChibiOS
+
+Next, you'll need ChibiOS. For Teensies, you'll need code from two repositories: [chibios-main](https://github.com/ChibiOS/ChibiOS) and [chibios-contrib](https://github.com/ChibiOS/ChibiOS).
+
+### If you’re using git
+
+Run `git submodule sync —recursive && git submodule update --init —recursive`. This will install ChibiOS and ChibiOS-Contrib in the `/lib/` directory.
+
+### If you’re not using Git
+
+If you're not using git, you can just download a [zip of chibios from here](https://github.com/ChibiOS/ChibiOS/archive/a7df9a891067621e8e1a5c2a2c0ceada82403afe.zip), unpack the zip, and rename/move the unpacked directory (named `ChibiOS-<long_hash_here>`) to `lib/chibios/chibios` (so that the file `lib/chibios/chibios/license.txt` exists). Now the same procedure with a [zip of chibios-contrib from here](https://github.com/ChibiOS/ChibiOS-Contrib/archive/e1311c4db6cd366cf760673f769e925741ac0ad3.zip): unpack and move `ChibiOS-Contrib-<long_hash_here>` to `lib/chibios/chibios-contrib`.
 
 (If you're using git, you can just clone the two repos: [chibios](https://github.com/ChibiOS/ChibiOS) and [chibios-contrib](https://github.com/ChibiOS/ChibiOS-Contrib). However - be warned that things may be somewhat out-of-sync (updates at different rates), so you may need to hunt a bit for the right commits.)
 

keyboards/clueboard/Makefile

@@ -1,5 +0,0 @@
-SUBPROJECT_DEFAULT = rev2
-
-ifndef MAKEFILE_INCLUDED
-	include ../../Makefile
-endif

keyboards/clueboard/clueboard.c

@@ -1 +0,0 @@
-#include "clueboard.h"

keyboards/clueboard/clueboard.h

@@ -1,13 +0,0 @@
-#ifndef CLUEBOARD_H
-#define CLUEBOARD_H
-
-#ifdef SUBPROJECT_rev1
-    #include "rev1.h"
-#endif
-#ifdef SUBPROJECT_rev2
-    #include "rev2.h"
-#endif
-
-#include "quantum.h"
-
-#endif