Fix avrdude message to not mention any specific device model.

* Added BLE support to USB-USB converter

* Added readme

* Removed images and Makefile

.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:

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 %/rules.mk,%,$(wildcard $(ROOT_DIR)/keyboards/*/rules.mk)))
+#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 %/rules.mk,%,$$(wildcard $(ROOT_DIR)/keyboards/$$(CURRENT_KB)/*/rules.mk)))
-    # 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,86 +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=
-        ifneq ("$(wildcard $(ROOT_DIR)/keyboards/$$(CURRENT_KB)/subproject.mk)","")
-            $$(eval include $(ROOT_DIR)/keyboards/$$(CURRENT_KB)/subproject.mk)
-        endif
-        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
@@ -380,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
@@ -455,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
@@ -504,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 %/rules.mk,%,$(wildcard ./*/rules.mk)))
-.PHONY: $(SUBPROJECTS)
-$(SUBPROJECTS): %: %-allkm
-
 # Let's match everything, we handle all the rule parsing ourselves
 .PHONY: %
 %:
@@ -539,22 +542,24 @@ 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 $?

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)/rules.mk
-    KEYMAP_C := $(SUBPROJ_KEYMAP_C)
-    KEYMAP_PATH := $(SUBPROJ_KEYMAP_PATH)
-else ifneq ("$(wildcard $(MAIN_KEYMAP_C))","")
-    -include $(MAIN_KEYMAP_PATH)/rules.mk
-    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

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
@@ -167,6 +171,10 @@ ifeq ($(strip $(TERMINAL_ENABLE)), yes)
     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)
@@ -51,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_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_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/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

@@ -121,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,22 +1,21 @@
 # More detailed make instruction
 
-The full syntax of the `make` command is `<keyboard>-<subproject>-<keymap>-<target>`, where:
+The full syntax of the `make` command is `<keyboard_folder>:<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.
 
 The `<target>` means the following
 * If no target is given, then it's the same as `all` below
-* `all` compiles as many keyboard/revision/keymap combinations as specified. For example, `make planck-rev4-default-all` will generate a single .hex, while `make planck-rev-all` will generate a hex for every keymap available to the planck.
+* `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`.
+ * **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.
 
 You can also add extra options at the end of the make command line, after the target
@@ -30,9 +29,9 @@ 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 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.
+* `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.
 
 ## `rules.mk` options
 

docs/hand_wire.md

@@ -273,7 +273,7 @@ Notice how the `k11` and `KC_NO` switched places to represent the wiring, and th
 
 ### 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 handwired-<keyboard>-<variant>`, which will pull `keymaps/<variant>/keymap.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/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/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/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
 

keyboards/9key/readme.md

@@ -12,6 +12,6 @@ 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/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/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/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/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/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/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

@@ -7,7 +7,7 @@ How to build and flash
 ----------------------
 
 to build;
-make atreus-dvorak_42_key
+make atreus:dvorak_42_key
 
 to flash:
 avrdude -p atmega32u4 -c avr109 -U flash:w:atreus_dvorak_42_key.hex  -P COM7

keyboards/atreus/keymaps/dvorak_42_key/keymap.c

@@ -15,7 +15,7 @@
 static bool mouse_lock = false;
 
 // building instructions:
-// make atreus-dvorak_42_key
+// make atreus:dvorak_42_key
 
 // flashing instructions:
 // avrdude -p atmega32u4 -c avr109 -U flash:w:atreus_dvorak_42_key.hex  -P COM7

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

@@ -5,12 +5,12 @@ 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, (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.
 
-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-avrdude
+    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/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/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/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/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/subproject.mk

@@ -1 +0,0 @@
-SUBPROJECT_DEFAULT = stm32_f072_onekey

keyboards/clueboard_17/Makefile

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

keyboards/clueboard_17/readme.md

@@ -10,6 +10,6 @@ A basic 17 key numpad PCB.
 
 Make example for this keyboard (after setting up your build environment):
 
-    make cluepad-default
+    make clueboard_17: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/clueboard_60/boards/GENERIC_STM32_F303XC/board.mk

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

keyboards/clueboard_60/readme.md

@@ -9,6 +9,6 @@ A fully customizable 60% keyboard.
 
 Make example for this keyboard (after setting up your build environment):
 
-    make clueboard_60-default-dfu-util
+    make clueboard_60:default:dfu-util
 
 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/clueboard_66/Makefile

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

keyboards/clueboard_66/clueboard_66.h

@@ -1,16 +1,16 @@
 #ifndef CLUEBOARD_H
 #define CLUEBOARD_H
 
-#ifdef SUBPROJECT_rev1
+#include "quantum.h"
+
+#ifdef KEYBOARD_clueboard_66_rev1
     #include "rev1.h"
 #endif
-#ifdef SUBPROJECT_rev2
+#ifdef KEYBOARD_clueboard_66_rev2
     #include "rev2.h"
 #endif
-#ifdef SUBPROJECT_rev3
+#ifdef KEYBOARD_clueboard_66_rev3
     #include "rev3.h"
 #endif
 
-#include "quantum.h"
-
 #endif

keyboards/clueboard_66/config.h

@@ -60,15 +60,4 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //#define NO_ACTION_MACRO
 //#define NO_ACTION_FUNCTION
 
-
-#ifdef SUBPROJECT_rev1
-    #include "rev1/config.h"
-#endif
-#ifdef SUBPROJECT_rev2
-    #include "rev2/config.h"
-#endif
-#ifdef SUBPROJECT_rev3
-    #include "rev3/config.h"
-#endif
-
 #endif

keyboards/clueboard_66/readme.md

@@ -13,6 +13,6 @@ A fully customizable 66% keyboard.
 
 Make example for this keyboard (after setting up your build environment):
 
-    make clueboard-rev3-default
+    make clueboard/rev3: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/clueboard_66/rev1/Makefile

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

keyboards/clueboard_66/rev1/config.h

@@ -1,7 +1,7 @@
 #ifndef REV2_CONFIG_H
 #define REV2_CONFIG_H
 
-#include "../config.h"
+#include "config_common.h"
 
 #define PRODUCT_ID      0x2301
 #define DEVICE_VER      0x0003

keyboards/clueboard_66/rev2/Makefile

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

keyboards/clueboard_66/rev2/config.h

@@ -1,7 +1,7 @@
 #ifndef REV2_CONFIG_H
 #define REV2_CONFIG_H
 
-#include "../config.h"
+#include "config_common.h"
 
 #define PRODUCT_ID      0x2320
 #define DEVICE_VER      0x0001

keyboards/clueboard_66/rev2/rev2.h

@@ -1,7 +1,7 @@
 #ifndef REV2_H
 #define REV2_H
 
-#include "../clueboard_66.h"
+#include "clueboard_66.h"
 
 /* Clueboard matrix layout
  * ,-----------------------------------------------------------.  ,---.

keyboards/clueboard_66/rev3/config.h

@@ -1,7 +1,7 @@
 #ifndef REV3_CONFIG_H
 #define REV3_CONFIG_H
 
-#include "../config.h"
+#include "config_common.h"
 
 #define PRODUCT_ID      0x2370
 #define DEVICE_VER      0x0001

keyboards/clueboard_66/rev3/rev3.h

@@ -1,7 +1,7 @@
 #ifndef REV3_H
 #define REV3_H
 
-#include "../clueboard_66.h"
+#include "clueboard_66.h"
 
 /* Clueboard matrix layout
  * ,-----------------------------------------------------------.  ,---.

keyboards/clueboard_66/rules.mk

@@ -19,3 +19,5 @@ RGBLIGHT_ENABLE = yes  # Enable keyboard underlight functionality
 MIDI_ENABLE = no 		# MIDI controls
 UNICODE_ENABLE = no 		# Unicode
 BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
+
+DEFAULT_FOLDER = clueboard_66/rev2

keyboards/clueboard_66/subproject.mk

@@ -1 +0,0 @@
-SUBPROJECT_DEFAULT = rev2

keyboards/cluecard/readme.md

@@ -8,6 +8,6 @@ A simple QMK dev kit.
 
 Make example for this keyboard (after setting up your build environment):
 
-    make cluecard-default
+    make cluecard: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/converter/converter.c

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

keyboards/converter/converter.h

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

keyboards/converter/usb_usb/README.md

@@ -9,7 +9,7 @@ Hardware Availability: [GH thread](https://geekhack.org/index.php?topic=72052.0)
 
 Make example for this keyboard (after setting up your build environment):
 
-    make converter-usb_usb-default
+    make converter/usb_usb: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/converter/usb_usb/keymaps/ble/README.md

@@ -0,0 +1,30 @@
+QMK BLE Adapter
+===============
+A small device that reads USB keyboard input and passes it on over Bluetooth LE HID.
+
+![Picture of Adapter](https://i.imgur.com/O3VwBBJ.png)
+
+Hardware
+--------
+The hardware is relatively easy to assemble. Just follow the schematic and don't forget to [cut the VBUS jumper](https://www.pjrc.com/teensy/td_libs_USBHostShield_4a.jpg).
+
+Schematic:
+![Schematic](https://i.imgur.com/s1Ia9We.png)
+
+Part list:
+* [Adafruit Feather 32u4 Bluefruit LE](https://www.adafruit.com/product/2829)
+* [USB Host Mini](https://www.circuitsathome.com/arduino_usb_host_shield_projects/)
+* [Pololu 5V Step-Up Voltage Regulator U3V12F5](https://www.pololu.com/product/2115)
+* [Lithium Ion Battery - 3.7v 2000mAh](https://www.adafruit.com/product/2011)
+* Some sort of switch to be able to turn it off
+
+Building and Flashing
+---------------------
+
+```
+make converter-usb_usb-ble
+```
+
+```
+make converter-usb_usb-ble-avrdude
+```

keyboards/converter/usb_usb/keymaps/ble/config.h

@@ -0,0 +1,15 @@
+#ifndef CONFIG_USER_H
+#define CONFIG_USER_H
+
+#include "../../config.h"
+
+#undef PRODUCT
+#define PRODUCT         QMK BLE Adapter
+#undef DESCRIPTION
+#define DESCRIPTION  
+
+// Turn off the mode leds on the BLE module
+#define ADAFRUIT_BLE_ENABLE_MODE_LEDS 0
+#define ADAFRUIT_BLE_ENABLE_POWER_LED 0
+
+#endif

keyboards/converter/usb_usb/keymaps/ble/keymap.c

@@ -0,0 +1,76 @@
+/*
+Copyright 2017 Balz Guenat <balz.guenat@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/>.
+*/
+
+#include "usb_usb.h"
+
+const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] PROGMEM = {
+    /* 0: plain Qwerty without layer switching
+     *         ,---------------. ,---------------. ,---------------.
+     *         |F13|F14|F15|F16| |F17|F18|F19|F20| |F21|F22|F23|F24|
+     * ,---.   |---------------| |---------------| |---------------| ,-----------. ,---------------. ,-------.
+     * |Esc|   |F1 |F2 |F3 |F4 | |F5 |F6 |F7 |F8 | |F9 |F10|F11|F12| |PrS|ScL|Pau| |VDn|VUp|Mut|Pwr| | Help  |
+     * `---'   `---------------' `---------------' `---------------' `-----------' `---------------' `-------'
+     * ,-----------------------------------------------------------. ,-----------. ,---------------. ,-------.
+     * |  `|  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|JPY|Bsp| |Ins|Hom|PgU| |NmL|  /|  *|  -| |Stp|Agn|
+     * |-----------------------------------------------------------| |-----------| |---------------| |-------|
+     * |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|  \  | |Del|End|PgD| |  7|  8|  9|  +| |Mnu|Und|
+     * |-----------------------------------------------------------| `-----------' |---------------| |-------|
+     * |CapsL |  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  :|  #|Retn|               |  4|  5|  6|KP,| |Sel|Cpy|
+     * |-----------------------------------------------------------|     ,---.     |---------------| |-------|
+     * |Shft|  <|  Z|  X|  C|  V|  B|  N|  M|  ,|  ,|  /| RO|Shift |     |Up |     |  1|  2|  3|KP=| |Exe|Pst|
+     * |-----------------------------------------------------------| ,-----------. |---------------| |-------|
+     * |Ctl|Gui|Alt|MHEN|HNJ| Space  |H/E|HENK|KANA|Alt|Gui|App|Ctl| |Lef|Dow|Rig| |  0    |  .|Ent| |Fnd|Cut|
+     * `-----------------------------------------------------------' `-----------' `---------------' `-------'
+     */
+    [0] = KEYMAP_ALL(
+                      KC_F13,  KC_F14,  KC_F15,  KC_F16, KC_F17, KC_F18, KC_F19,  KC_F20,  KC_F21,  KC_F22,  KC_F23,  KC_F24,
+    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_SLCK, KC_PAUS,    KC_VOLD, KC_VOLU, KC_MUTE, KC_PWR,     KC_HELP, 
+    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_JYEN, KC_BSPC,     KC_INS,  KC_HOME, KC_PGUP,    KC_NLCK, KC_PSLS, KC_PAST, KC_PMNS,    KC_STOP, KC_AGIN,
+    KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,   KC_Y,   KC_U,   KC_I,    KC_O,    KC_P,    KC_LBRC, KC_RBRC,          KC_BSLS,     KC_DEL,  KC_END,  KC_PGDN,    KC_P7,   KC_P8,   KC_P9,   KC_PPLS,    KC_MENU, KC_UNDO,
+    KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,   KC_H,   KC_J,   KC_K,    KC_L,    KC_SCLN, KC_QUOT,          KC_NUHS, KC_ENT,                                    KC_P4,   KC_P5,   KC_P6,   KC_PCMM,    KC_SLCT, KC_COPY,
+    KC_LSFT, KC_NUBS, KC_Z,    KC_X,    KC_C,    KC_V,   KC_B,   KC_N,   KC_M,    KC_COMM, KC_DOT,  KC_SLSH,          KC_RO,   KC_RSFT,              KC_UP,               KC_P1,   KC_P2,   KC_P3,   KC_PEQL,    KC_EXEC, KC_PSTE,
+    KC_LCTL, KC_LGUI, KC_LALT, KC_MHEN, KC_HANJ,         KC_SPC,         KC_HAEN, KC_HENK, KC_KANA, KC_RALT, KC_RGUI, KC_APP,  KC_RCTL,     KC_LEFT, KC_DOWN, KC_RGHT,    KC_P0,            KC_PDOT, KC_PENT,    KC_FIND, KC_CUT
+    ),
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+  switch(id) {
+    default:
+      return MACRO_NONE;
+  }
+};
+
+
+void matrix_init_user(void) {
+
+}
+
+void matrix_scan_user(void) {
+
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
+}
+
+void led_set_user(uint8_t usb_led) {
+
+}

keyboards/converter/usb_usb/keymaps/ble/rules.mk

@@ -0,0 +1,3 @@
+BLUETOOTH = AdafruitBLE
+ADAFRUIT_BLE_ENABLE = yes
+OPT_DEFS +=  -DCATERINA_BOOTLOADER

keyboards/converter/usb_usb/rules.mk

@@ -1,5 +1,5 @@
 # MCU name
-MCU ?= atmega32u4
+MCU = atmega32u4
 
 
 # Processor frequency.
@@ -13,14 +13,14 @@ MCU ?= atmega32u4
 #     does not *change* the processor frequency - it should merely be updated to
 #     reflect the processor speed set externally so that the code can use accurate
 #     software delays.
-F_CPU ?= 8000000
+F_CPU = 8000000
 
 
 #
 # LUFA specific
 #
 # Target architecture (see library "Board Types" documentation).
-ARCH ?= AVR8
+ARCH = AVR8
 
 # Input clock frequency.
 #     This will define a symbol, F_USB, in all source code files equal to the
@@ -33,7 +33,7 @@ ARCH ?= AVR8
 #
 #     If no clock division is performed on the input clock inside the AVR (via the
 #     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
-F_USB ?= $(F_CPU)
+F_USB = $(F_CPU)
 
 # Interrupt driven control endpoint task
 OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
@@ -51,16 +51,15 @@ OPT_DEFS += -DBOOTLOADER_SIZE=4096
 # Build Options
 #   comment out to disable the options.
 #
-# BOOTMAGIC_ENABLE	?= yes	# Virtual DIP switch configuration(+1000)
-# MOUSEKEY_ENABLE		?= yes	# Mouse keys(+4700)
-EXTRAKEY_ENABLE		?= yes	# Audio control and System control(+450)
-# CONSOLE_ENABLE		?= yes	# Console for debug(+400)
-# COMMAND_ENABLE		?= yes  # Commands for debug and configuration
-# SLEEP_LED_ENABLE ?= yes  # Breathing sleep LED during USB suspend
-# NKRO_ENABLE ?= yes	# USB Nkey Rollover - not yet supported in LUFA
-# BACKLIGHT_ENABLE ?= yes
-
+# BOOTMAGIC_ENABLE	= yes	# Virtual DIP switch configuration(+1000)
+# MOUSEKEY_ENABLE		= yes	# Mouse keys(+4700)
+EXTRAKEY_ENABLE		= yes	# Audio control and System control(+450)
+# CONSOLE_ENABLE		= yes	# Console for debug(+400)
+# COMMAND_ENABLE		= yes  # Commands for debug and configuration
+# SLEEP_LED_ENABLE = yes  # Breathing sleep LED during USB suspend
+# NKRO_ENABLE = yes	# USB Nkey Rollover - not yet supported in LUFA
+# BACKLIGHT_ENABLE = yes
+USB_HID_ENABLE = yes
 
 CUSTOM_MATRIX = yes
-SRC = custom_matrix.cpp
-include $(TMK_DIR)/protocol/usb_hid.mk
+SRC = custom_matrix.cpp

keyboards/deltasplit75/config.h

@@ -20,10 +20,4 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "config_common.h"
 
-#ifdef SUBPROJECT_protosplit
-    #include "protosplit/config.h"
-#endif
-#ifdef SUBPROJECT_v2
-    #include "v2/config.h"
-#endif
 #endif

keyboards/deltasplit75/deltasplit75.h

@@ -1,12 +1,7 @@
 #ifndef DELTASPLIT75_H
 #define DELTASPLIT75_H
 
-#ifdef SUBPROJECT_v2
-    #include "v2.h"
-#endif
-#ifdef SUBPROJECT_protosplit
-    #include "protosplit.h"
-#endif
+#include "v2.h"
 
 #include "quantum.h"
 

keyboards/deltasplit75/readme.md

@@ -9,7 +9,7 @@ Hardware Availability: Group Buy
 
 Make example for this keyboard (after setting up your build environment):
 
-    make deltasplit75-v2-default
+    make deltasplit75/v2: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/deltasplit75/rules.mk

@@ -55,21 +55,23 @@ OPT_DEFS += -DBOOTLOADER_SIZE=4096
 #   change to "no" to disable the options, or define them in the Makefile in
 #   the appropriate keymap folder that will get included automatically
 #
-BOOTMAGIC_ENABLE ?= no       # Virtual DIP switch configuration(+1000)
-MOUSEKEY_ENABLE ?= yes       # Mouse keys(+4700)
-EXTRAKEY_ENABLE ?= yes       # Audio control and System control(+450)
-CONSOLE_ENABLE ?= no         # Console for debug(+400)
-COMMAND_ENABLE ?= yes        # Commands for debug and configuration
-NKRO_ENABLE ?= no            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
-BACKLIGHT_ENABLE ?= no      # Enable keyboard backlight functionality
-MIDI_ENABLE ?= no            # MIDI controls
-AUDIO_ENABLE ?= no           # Audio output on port C6
-UNICODE_ENABLE ?= no         # 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.
-SUBPROJECT_rev1 ?= yes
-USE_I2C ?= yes
+BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+CONSOLE_ENABLE = no         # Console for debug(+400)
+COMMAND_ENABLE = yes        # Commands for debug and configuration
+NKRO_ENABLE = no            # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE = no      # Enable keyboard backlight functionality
+MIDI_ENABLE = no            # MIDI controls
+AUDIO_ENABLE = no           # Audio output on port C6
+UNICODE_ENABLE = no         # 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.
+SUBPROJECT_rev1 = yes
+USE_I2C = yes
 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
-SLEEP_LED_ENABLE ?= no    # Breathing sleep LED during USB suspend
+SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
 
 CUSTOM_MATRIX = yes
+
+DEFAULT_FOLDER = deltasplit75/v2

keyboards/deltasplit75/subproject.mk

@@ -1 +0,0 @@
-SUBPROJECT_DEFAULT = v2

keyboards/deltasplit75/v2/config.h

@@ -15,8 +15,8 @@ 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_V2_H
+#define CONFIG_V2_H
 
 #include "config_common.h"
 

keyboards/deltasplit75/v2/rules.mk

@@ -1,5 +1 @@
-BACKLIGHT_ENABLE = no
-
-ifndef QUANTUM_DIR
-	include ../../../Makefile
-endif
+BACKLIGHT_ENABLE = no

keyboards/dichotemy/config.h

@@ -0,0 +1,87 @@
+/*
+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"
+
+/* USB Device descriptor parameter */
+
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0xACC7
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    unknown
+#define PRODUCT         Dichotemy
+#define DESCRIPTION     q.m.k. keyboard firmware for Dichotemy
+
+/* key matrix size */
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 12
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+//#define BACKLIGHT_LEVELS 3
+
+#define ONESHOT_TIMEOUT 500
+
+
+/* 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.
+ */
+
+#define PREVENT_STUCK_MODIFIERS
+
+/* 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
+
+//UART settings for communication with the RF microcontroller
+#define SERIAL_UART_BAUD 1000000
+#define SERIAL_UART_DATA UDR1
+#define SERIAL_UART_UBRR (F_CPU / (16UL * SERIAL_UART_BAUD) - 1)
+#define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1))
+#define SERIAL_UART_RXD_PRESENT (UCSR1A & _BV(RXC1))
+#define SERIAL_UART_INIT() do { \
+    	/* baud rate */ \
+    	UBRR1L = SERIAL_UART_UBRR; \
+    	/* baud rate */ \
+    	UBRR1H = SERIAL_UART_UBRR >> 8; \
+    	/* enable TX and RX */ \
+    	UCSR1B = _BV(TXEN1) | _BV(RXEN1); \
+    	/* 8-bit data */ \
+    	UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
+  	} while(0)
+
+#endif

keyboards/dichotemy/dichotemy.c

@@ -0,0 +1,86 @@
+#include "dichotemy.h"
+#include "pointing_device.h"
+#include "report.h"
+
+void uart_init(void) {
+	SERIAL_UART_INIT();
+}
+
+void pointing_device_task(void){
+	report_mouse_t currentReport = {};
+    SERIAL_UART_INIT();
+    uint32_t timeout = 0;
+
+    //the m character requests the RF slave to send the mouse report
+    SERIAL_UART_DATA = 'm';
+
+    //trust the external inputs completely, erase old data
+    uint8_t uart_data[5] = {0};
+
+    //there are 10 bytes corresponding to 10 columns, and an end byte
+    for (uint8_t i = 0; i < 5; i++) {
+        //wait for the serial data, timeout if it's been too long
+        //this only happened in testing with a loose wire, but does no
+        //harm to leave it in here
+        while(!SERIAL_UART_RXD_PRESENT){
+            timeout++;
+            if (timeout > 10000){
+                break;
+            }
+        } 
+        uart_data[i] = SERIAL_UART_DATA;
+    }
+
+    //check for the end packet, bits 1-4 are movement and scroll
+    //but bit 5 has bits 0-3 for the scroll button state
+	//(1000 if pressed, 0000 if not) and bits 4-7 are always 1
+	//We can use this to verify the report sent properly.
+    if (uart_data[4] == 0x0F || uart_data[4] == 0x8F)
+    {
+		currentReport = pointing_device_get_report();
+        //shifting and transferring the info to the mouse report varaible
+        //mouseReport.x = 127 max -127 min
+		currentReport.x = uart_data[0];
+        //mouseReport.y = 127 max -127 min
+		currentReport.y = uart_data[1];
+        //mouseReport.v = 127 max -127 min (scroll vertical)
+		currentReport.v = uart_data[2];
+        //mouseReport.h = 127 max -127 min (scroll horizontal)
+		currentReport.h = uart_data[3];
+        //mouseReport.buttons = 0x31 max (bitmask for mouse buttons 1-5) 0x00 min
+		//mouse buttons 1 and 2 are handled by the keymap, but not 3
+		if (uart_data[4] == 0x0F) { //then 3 is not pressed
+			currentReport.buttons &= ~MOUSE_BTN3; //MOUSE_BTN3 is def in report.h
+		} else { //3 must be pressed
+			currentReport.buttons |= MOUSE_BTN3;
+		}
+		pointing_device_set_report(currentReport);
+    }
+    pointing_device_send();
+}
+
+void led_init(void) {
+	DDRD  |= (1<<1);
+	PORTD |= (1<<1);
+	DDRF  |= (1<<4) | (1<<5);
+	PORTF |= (1<<4) | (1<<5);
+}
+
+
+void matrix_init_kb(void) {
+	// put your keyboard start-up code here
+	// runs once when the firmware starts up
+	matrix_init_user();
+	uart_init();
+	led_init();
+}
+
+void matrix_scan_kb(void) {
+	// put your looping keyboard code here
+	// runs every cycle (a lot)
+	matrix_scan_user();
+}
+
+void led_set_kb(uint8_t usb_led) {
+
+}

keyboards/dichotemy/dichotemy.h

@@ -0,0 +1,67 @@
+#ifndef DICHOTEMY_H
+#define DICHOTEMY_H
+
+#include "quantum.h"
+#include "matrix.h"
+#include "backlight.h"
+#include <stddef.h>
+
+#define red_led_off   PORTF |= (1<<5)
+#define red_led_on    PORTF &= ~(1<<5)
+#define blu_led_off   PORTF |= (1<<4)
+#define blu_led_on    PORTF &= ~(1<<4)
+#define grn_led_off   PORTD |= (1<<1)
+#define grn_led_on    PORTD &= ~(1<<1)
+
+#define set_led_off     red_led_off; grn_led_off; blu_led_off
+#define set_led_red     red_led_on;  grn_led_off; blu_led_off
+#define set_led_blue    red_led_off; grn_led_off; blu_led_on
+#define set_led_green   red_led_off; grn_led_on;  blu_led_off
+#define set_led_yellow  red_led_on;  grn_led_on;  blu_led_off
+#define set_led_magenta red_led_on;  grn_led_off; blu_led_on
+#define set_led_cyan    red_led_off; grn_led_on;  blu_led_on
+#define set_led_white   red_led_on;  grn_led_on;  blu_led_on
+
+/*
+#define LED_B 5
+#define LED_R 6
+#define LED_G 7
+
+#define all_leds_off PORTF &= ~(1<<LED_B) & ~(1<<LED_R) & ~(1<<LED_G)
+
+#define red_led_on   PORTF |= (1<<LED_R)
+#define red_led_off  PORTF &= ~(1<<LED_R)
+#define grn_led_on   PORTF |= (1<<LED_G)
+#define grn_led_off  PORTF &= ~(1<<LED_G)
+#define blu_led_on   PORTF |= (1<<LED_B)
+#define blu_led_off  PORTF &= ~(1<<LED_B)
+
+#define set_led_off     PORTF &= ~(1<<LED_B) & ~(1<<LED_R) & ~(1<<LED_G)
+#define set_led_red     PORTF = PORTF & ~(1<<LED_B) & ~(1<<LED_G) | (1<<LED_R)
+#define set_led_blue    PORTF = PORTF & ~(1<<LED_G) & ~(1<<LED_R) | (1<<LED_B)
+#define set_led_green   PORTF = PORTF & ~(1<<LED_B) & ~(1<<LED_R) | (1<<LED_G)
+#define set_led_yellow  PORTF = PORTF & ~(1<<LED_B) | (1<<LED_R) | (1<<LED_G)
+#define set_led_magenta PORTF = PORTF & ~(1<<LED_G) | (1<<LED_R) | (1<<LED_B)
+#define set_led_cyan    PORTF = PORTF & ~(1<<LED_R) | (1<<LED_B) | (1<<LED_G)
+#define set_led_white   PORTF |= (1<<LED_B) | (1<<LED_R) | (1<<LED_G)
+*/
+
+// This a shortcut to help you visually see your layout.
+// The first section contains all of the arguements
+// The second converts the arguments into a two-dimensional array
+#define KEYMAP( \
+  k00, k01, k02, k03, k04, k05,      k06, k07, k08, k09, k0A, k0B, \
+  k10, k11, k12, k13, k14, k15,      k16, k17, k18, k19, k1A, k1B, \
+  k20, k21, k22, k23, k24, k25,      k26, k27, k28, k29, k2A, k2B, \
+                 k33, k34, k35,      k36, k37, k38,      \
+                 k43, k44, k45,      k46, k47, k48       \
+) \
+{ \
+	{ k00,   k01,   k02,   k03,   k04,   k05,      k06,   k07,   k08,   k09,   k0A,   k0B   }, \
+	{ k10,   k11,   k12,   k13,   k14,   k15,      k16,   k17,   k18,   k19,   k1A,   k1B   }, \
+	{ k20,   k21,   k22,   k23,   k24,   k25,      k26,   k27,   k28,   k29,   k2A,   k2B   }, \
+	{ KC_NO, KC_NO, KC_NO, k33,   k34,   k35,      k36,   k37,   k38,   KC_NO, KC_NO, KC_NO }, \
+	{ KC_NO, KC_NO, KC_NO, k43,   k44,   k45,      k46,   k47,   k48,   KC_NO, KC_NO, KC_NO }  \
+}
+
+#endif

keyboards/dichotemy/keymaps/default/keymap.c

@@ -0,0 +1,394 @@
+// 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 "dichotemy.h"
+#include "report.h"
+#include "pointing_device.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.
+enum dichotemy_layers
+{
+	_BS,
+	_SF,
+	_NM,
+	_NS,
+	_MS
+};
+
+#define LONGPRESS_COUNT 4
+
+enum dichotemy_keycodes 
+{
+  CK_1G = SAFE_RANGE,
+  CK_BSPE,
+  CK_QE,
+  CK_TE, //these 4 CK_XXXX keys are special "alternate long-press" keys controlled with unique timers.  Make sure you understand them before you mess with them.
+  NS_HYPH,
+  NS_EQU,
+  NUMKEY,
+  SFTKEY,
+  MOUSE,
+  MS_BTN1,
+  MS_BTN2
+  //MS_BTN3
+};
+
+// Macro definitions for readability
+enum dichotemy_macros
+{
+	VOLU,
+	VOLD,
+	ESCM
+};
+
+#define LONGPRESS_DELAY 150
+#define MAX_TOGGLE_LENGTH 300
+#define TAPPING_TOGGLE 1
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+[_BS] = { /* Base layout, nearly qwerty but with modifications because it's not a full keyboard. Obviously. */
+  {CK_TE,   KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,           KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC },
+  {NUMKEY,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,           KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, CK_QE   },
+  {SFTKEY,  KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,           KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, MOUSE   },
+  {XXXXXXX, XXXXXXX, XXXXXXX, KC_LCTL, KC_LALT, KC_LGUI,        KC_RGUI, KC_RALT, KC_RCTL, XXXXXXX, XXXXXXX, XXXXXXX },
+  {XXXXXXX, XXXXXXX, XXXXXXX, KC_LBRC, KC_LPRN, KC_QUOT,        KC_SPC,  KC_RPRN, KC_RBRC, XXXXXXX, XXXXXXX, XXXXXXX }
+},
+
+[_SF] = { /* Shifted layout, small changes (because angle brackets have been moved to thumb cluster buttons) */
+  {_______, _______, _______, _______, _______, _______,        _______, _______, _______, _______, _______, _______ },
+  {_______, _______, _______, _______, _______, _______,        _______, _______, _______, _______, _______, _______ },
+  {_______, _______, _______, _______, _______, _______,        _______, _______, NS_HYPH, KC_UNDS, _______, _______ },
+  {XXXXXXX, XXXXXXX, XXXXXXX, _______, _______, _______,        _______, _______, _______, XXXXXXX, XXXXXXX, XXXXXXX },
+  {XXXXXXX, XXXXXXX, XXXXXXX, _______, KC_LABK, _______,        _______, KC_RABK, _______, XXXXXXX, XXXXXXX, XXXXXXX }
+},
+
+[_NM] = { /* Number layout, basically the main function layer */
+  {_______, KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,          KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  _______ },
+  {_______, CK_1G,   KC_2,    KC_3,    KC_4,    KC_5,           KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    CK_BSPE },
+  {_______, KC_F11,  KC_F12,  KC_F13,  KC_F14,  KC_F15,         KC_F16,  KC_F17,  KC_F18,  KC_F19,  KC_F20,  _______ },
+  {XXXXXXX, XXXXXXX, XXXXXXX, _______, _______, _______,        _______, _______, _______, XXXXXXX, XXXXXXX, XXXXXXX },
+  {XXXXXXX, XXXXXXX, XXXXXXX, _______, _______, _______,        _______, _______, _______, XXXXXXX, XXXXXXX, XXXXXXX }
+},
+
+[_NS] = { /* Shifted number/function layout, for per-key control.  Only active when shift is held, and number is toggled or held */
+  {_______, _______, _______, _______, _______, _______,        _______, _______, _______, _______, _______, _______ },
+  {_______, _______, _______, _______, _______, _______,        _______, _______, _______, KC_PLUS, NS_EQU,  _______ },
+  {_______, _______, _______, _______, _______, _______,        _______, _______, _______, _______, _______, _______ },
+  {XXXXXXX, XXXXXXX, XXXXXXX, _______, _______, _______,        _______, _______, _______, XXXXXXX, XXXXXXX, XXXXXXX },
+  {XXXXXXX, XXXXXXX, XXXXXXX, _______, _______, _______,        _______, _______, _______, XXXXXXX, XXXXXXX, XXXXXXX }
+},
+
+[_MS] = { /* Mouse layer, including buttons for clicking. */
+  {_______, _______, _______, _______, _______, _______,        KC_VOLU, KC_HOME, KC_PGUP, _______, _______, _______ },
+  {_______, _______, _______, _______, _______, _______,        _______, MS_BTN1, MS_BTN2, _______, _______, _______ },
+  {_______, _______, _______, _______, _______, _______,        KC_VOLD, KC_END,  KC_PGDN, _______, _______, _______ },
+  {XXXXXXX, XXXXXXX, XXXXXXX, _______, _______, _______,        _______, KC_UP,   _______, XXXXXXX, XXXXXXX, XXXXXXX },
+  {XXXXXXX, XXXXXXX, XXXXXXX, _______, _______, _______,        KC_LEFT, KC_DOWN, KC_RGHT, XXXXXXX, XXXXXXX, XXXXXXX }
+}
+
+};
+
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+static uint16_t special_timers[LONGPRESS_COUNT] = {0xFFFF,0xFFFF,0xFFFF,0xFFFF};
+static bool special_key_states[LONGPRESS_COUNT] = {0,0,0,0};
+
+static uint16_t shift_timer;
+static uint16_t num_timer;
+static uint16_t mouse_timer;
+
+static bool shift_singular_key = false;
+static bool number_singular_key = false;
+static bool mouse_singular_key = false;
+
+static bool shift_held = false;
+static bool shift_suspended = false;
+report_mouse_t currentReport = {};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+
+	//uint8_t layer;
+	//layer = biton32(layer_state);  // get the current layer  //Or don't, I didn't use it.
+
+	 //custom layer handling for tri_layer,
+	switch (keycode) {
+		case NUMKEY:
+			if (record->event.pressed) {
+				num_timer = timer_read();
+				number_singular_key = true;
+				layer_invert(_NM);
+			} else {
+				if (timer_elapsed(num_timer) < MAX_TOGGLE_LENGTH && number_singular_key) {
+					//do nothing, the layer has already been inverted
+				} else {
+					layer_invert(_NM);
+				}
+			}
+			update_tri_layer(_NM, _SF, _NS);
+			return false;
+		break;
+		//SHIFT is handled as LSHIFT in the general case - 'toggle' shoudl activate caps, while the layer is only active when shift is held.
+		case SFTKEY:
+			if (record->event.pressed) {
+				shift_held = true;
+				shift_suspended = false;
+				shift_timer = timer_read();
+				shift_singular_key = true;
+				layer_on(_SF);
+				register_code(KC_LSFT);
+			} else {
+				shift_held = false;
+				if (timer_elapsed(shift_timer) < MAX_TOGGLE_LENGTH && shift_singular_key) {
+					//this was basically a toggle, so activate/deactivate caps lock.
+					SEND_STRING(SS_TAP(X_CAPSLOCK));
+				}
+				layer_off(_SF);
+				unregister_code(KC_LSFT);
+			}
+			update_tri_layer(_NM, _SF, _NS);
+			return false;
+		break;
+		//MOUSE layer needs to be handled the same way as NUMKEY, but differently from shift
+		case MOUSE:
+			if (record->event.pressed) {
+				mouse_timer = timer_read();
+				mouse_singular_key = true;
+				layer_invert(_MS);
+			} else {
+				if (timer_elapsed(mouse_timer) < MAX_TOGGLE_LENGTH && number_singular_key){
+					//do nothing, it was a toggle (and it's already been toggled)
+				} else {
+					layer_invert(_MS);
+				}
+			}
+			return false;
+		break;
+		//Custom macros for strange keys with different long-tap behavior
+		case CK_1G:
+			if (shift_held && shift_suspended){
+				register_code(KC_LSFT);
+				shift_suspended = false;
+			}
+			shift_singular_key = false;
+			number_singular_key = false;
+			mouse_singular_key = false;
+			if (record->event.pressed) {
+				special_timers[CK_1G-SAFE_RANGE] = timer_read();
+			} else {
+				if (special_key_states[CK_1G-SAFE_RANGE]){
+					//key was activated after longpress_delay, need to close those keycodes
+					special_key_states[CK_1G-SAFE_RANGE] = 0;
+					unregister_code(KC_GRAVE);
+				} else {
+					//key was not activated, return macro activating proper, pre-long-tap key
+					SEND_STRING(SS_TAP(X_1));
+				}
+				special_timers[CK_1G-SAFE_RANGE] = 0xFFFF;
+			}
+		break;
+		case CK_BSPE:
+			if (shift_held && shift_suspended){
+				register_code(KC_LSFT);
+				shift_suspended = false;
+			}
+			shift_singular_key = false;
+			number_singular_key = false;
+			mouse_singular_key = false;
+			if (record->event.pressed) {
+				special_timers[CK_BSPE-SAFE_RANGE] = timer_read();
+			} else {
+				if (special_key_states[CK_BSPE-SAFE_RANGE]){
+					//key was activated after longpress_delay, need to close those keycodes
+					special_key_states[CK_BSPE-SAFE_RANGE] = 0;
+					unregister_code(KC_ENTER);
+				} else {
+					//key was not activated, return macro activating proper, pre-long-tap key
+					SEND_STRING(SS_TAP(X_BSLASH));
+				}
+				special_timers[CK_BSPE-SAFE_RANGE] = 0xFFFF;
+			}
+		break;
+		case CK_QE:
+			if (shift_held && shift_suspended){
+				register_code(KC_LSFT);
+				shift_suspended = false;
+			}
+			shift_singular_key = false;
+			number_singular_key = false;
+			mouse_singular_key = false;
+			if (record->event.pressed) {
+				special_timers[CK_QE-SAFE_RANGE] = timer_read();
+			} else {
+				if (special_key_states[CK_QE-SAFE_RANGE]){
+					//key was activated after longpress_delay, need to close those keycodes
+					special_key_states[CK_QE-SAFE_RANGE] = 0;
+					unregister_code(KC_ENTER);
+				} else {
+					//key was not activated, return macro activating proper, pre-long-tap key
+					SEND_STRING(SS_TAP(X_QUOTE));
+				}
+				special_timers[CK_QE-SAFE_RANGE] = 0xFFFF;
+			}
+		break;
+		case CK_TE:
+			if (shift_held && shift_suspended){
+				register_code(KC_LSFT);
+				shift_suspended = false;
+			}
+			if (record->event.pressed) {
+				special_timers[CK_TE-SAFE_RANGE] = timer_read();
+			} else {
+				if (special_key_states[CK_TE-SAFE_RANGE]){
+					//key was activated after longpress_delay, need to close those keycodes
+					special_key_states[CK_TE-SAFE_RANGE] = 0;
+					unregister_code(KC_ENTER);
+				} else {
+					//key was not activated, return macro activating proper, pre-long-tap key
+					SEND_STRING(SS_TAP(X_TAB));
+				}
+				special_timers[CK_TE-SAFE_RANGE] = 0xFFFF;
+			}
+		break;
+		//No-shift keys, they unregister the KC_LSFT code so they can send 
+		//unshifted values - but they don't change the bool. if any other 
+		//key is pressed and the bool is set, KC_LSFT is registered again.
+		case NS_HYPH:
+			if (record->event.pressed) {
+				shift_suspended = true;
+				unregister_code(KC_LSFT);
+				register_code(KC_MINS);
+			} else {
+				unregister_code(KC_MINS);
+				if (shift_held && shift_suspended){
+					register_code(KC_LSFT);
+					shift_suspended = false;
+				}
+			}
+		break;
+		case NS_EQU:
+			if (record->event.pressed) {
+				shift_suspended = true;
+				unregister_code(KC_LSFT);
+				register_code(KC_EQUAL);
+			} else {
+				unregister_code(KC_EQUAL);
+				if (shift_held && shift_suspended){
+					register_code(KC_LSFT);
+					shift_suspended = false;
+				}
+			}
+		break;
+		
+		//mouse buttons, for 1-3, to update the mouse report:
+		case MS_BTN1:
+			currentReport = pointing_device_get_report();
+			if (record->event.pressed) {
+				if (shift_held && shift_suspended){
+					register_code(KC_LSFT);
+					shift_suspended = false;
+				}
+				//update mouse report here
+				currentReport.buttons |= MOUSE_BTN1; //MOUSE_BTN1 is a const defined in report.h
+			} else {
+				//update mouse report here
+				currentReport.buttons &= ~MOUSE_BTN1;
+			}
+			pointing_device_set_report(currentReport);
+		break;
+		case MS_BTN2:
+			currentReport = pointing_device_get_report();
+			if (record->event.pressed) {
+				if (shift_held && shift_suspended){
+					register_code(KC_LSFT);
+					shift_suspended = false;
+				}
+				//update mouse report here
+				currentReport.buttons |= MOUSE_BTN2; //MOUSE_BTN2 is a const defined in report.h
+			} else {
+				//update mouse report here
+			}
+			pointing_device_set_report(currentReport);
+		break;
+		//there is a case for button 3, but that's handled in dichotemy.c, and this is being
+		//disabled to avoid any conflict.
+		/*case MS_BTN3:
+			currentReport = pointing_device_get_report();
+			if (record->event.pressed) {
+				if (shift_held && shift_suspended){
+					register_code(KC_LSFT);
+					shift_suspended = false;
+				}
+				//update mouse report here
+				currentReport.buttons |= MOUSE_BTN3; //MOUSE_BTN2 is a const defined in report.h
+			} else {
+				//update mouse report here
+			}
+			pointing_device_set_report(currentReport);
+		break;*/
+		
+		//If any other key was pressed during the layer mod hold period,
+		//then the layer mod was used momentarily, and should block latching
+		//Additionally, if NS_ keys are in use, then shift may be held (but is
+		//disabled for the unshifted keycodes to be send.  Check the bool and
+		//register shift as necessary.
+		default:
+			if (shift_held){
+				register_code(KC_LSFT);
+			}
+			shift_singular_key = false;
+			number_singular_key = false;
+			mouse_singular_key = false;
+		break;
+	}
+	return true;
+};
+
+void matrix_scan_user(void) {
+    uint8_t layer = biton32(layer_state);
+    for (uint8_t i = 0; i<LONGPRESS_COUNT; i++){
+		if (timer_elapsed(special_timers[i]) >= LONGPRESS_DELAY && !special_key_states[i]){
+			switch (i + SAFE_RANGE){
+				case CK_1G:
+					register_code(KC_GRAVE);
+				break;
+				case CK_BSPE:
+					register_code(KC_ENTER);
+				break;
+				case CK_QE:
+					register_code(KC_ENTER);
+				break;
+				case CK_TE:
+					register_code(KC_ESCAPE);
+				break;
+			}
+			special_key_states[i] = 1;
+		}
+	}
+    switch (layer) {
+    	case _BS:
+    		set_led_off;
+    		break;
+        case _NM:
+            set_led_blue;
+            break;
+        case _SF:
+            set_led_red;
+            break;
+        case _NS:
+        	set_led_green;
+        	break;
+        default:
+            break;
+    }
+};
+

keyboards/dichotemy/matrix.c

@@ -0,0 +1,178 @@
+/*
+Copyright 2012 Jun Wako
+Copyright 2014 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 <stdint.h>
+#include <stdbool.h>
+#if defined(__AVR__)
+#include <avr/io.h>
+#endif
+#include "wait.h"
+#include "print.h"
+#include "debug.h"
+#include "util.h"
+#include "matrix.h"
+#include "timer.h"
+
+#if (MATRIX_COLS <= 8)
+#    define print_matrix_header()  print("\nr/c 01234567\n")
+#    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop(matrix[i])
+#    define ROW_SHIFTER ((uint8_t)1)
+#elif (MATRIX_COLS <= 16)
+#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF\n")
+#    define print_matrix_row(row)  print_bin_reverse16(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop16(matrix[i])
+#    define ROW_SHIFTER ((uint16_t)1)
+#elif (MATRIX_COLS <= 32)
+#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
+#    define print_matrix_row(row)  print_bin_reverse32(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop32(matrix[i])
+#    define ROW_SHIFTER  ((uint32_t)1)
+#endif
+
+#define MAIN_ROWMASK 0xFFF0;
+#define LOWER_ROWMASK 0x1F80;
+
+/* matrix state(1:on, 0:off) */
+static matrix_row_t matrix[MATRIX_ROWS];
+
+__attribute__ ((weak))
+void matrix_init_quantum(void) {
+    matrix_init_kb();
+}
+
+__attribute__ ((weak))
+void matrix_scan_quantum(void) {
+    matrix_scan_kb();
+}
+
+__attribute__ ((weak))
+void matrix_init_kb(void) {
+    matrix_init_user();
+}
+
+__attribute__ ((weak))
+void matrix_scan_kb(void) {
+    matrix_scan_user();
+}
+
+__attribute__ ((weak))
+void matrix_init_user(void) {
+}
+
+__attribute__ ((weak))
+void matrix_scan_user(void) {
+}
+
+inline
+uint8_t matrix_rows(void) {
+    return MATRIX_ROWS;
+}
+
+inline
+uint8_t matrix_cols(void) {
+    return MATRIX_COLS;
+}
+
+void matrix_init(void) {
+
+    matrix_init_quantum();
+}
+
+uint8_t matrix_scan(void)
+{
+    SERIAL_UART_INIT();
+
+    uint32_t timeout = 0;
+
+    //the s character requests the RF slave to send the matrix
+    SERIAL_UART_DATA = 's';
+
+    //trust the external keystates entirely, erase the last data
+    uint8_t uart_data[7] = {0};
+
+    //there are 10 bytes corresponding to 10 columns, and an end byte
+    for (uint8_t i = 0; i < 7; i++) {
+        //wait for the serial data, timeout if it's been too long
+        //this only happened in testing with a loose wire, but does no
+        //harm to leave it in here
+        while(!SERIAL_UART_RXD_PRESENT){
+            timeout++;
+            if (timeout > 10000){
+                break;
+            }
+        } 
+        uart_data[i] = SERIAL_UART_DATA;
+    }
+
+    //check for the end packet, the key state bytes use the LSBs, so 0xE0
+    //will only show up here if the correct bytes were recieved
+    if (uart_data[6] == 0x96) { //this is an arbitrary binary checksum (10010110)
+        //shifting and transferring the keystates to the QMK matrix variable
+		//bits 1-12 are row 1, 13-24 are row 2, 25-36 are row 3,
+		//bits 37-42 are row 4 (only 6 wide, 1-3 are 0, and 10-12 are 0)
+		//bits 43-48 are row 5 (same as row 4)
+		/* ASSUMING MSB FIRST */
+		matrix[0] = (((uint16_t) uart_data[0] << 8) | ((uint16_t) uart_data[1])) & MAIN_ROWMASK;
+		matrix[1] = ((uint16_t) uart_data[1] << 12) | ((uint16_t) uart_data[2] << 4);
+		matrix[2] = (((uint16_t) uart_data[3] << 8) | ((uint16_t) uart_data[4])) & MAIN_ROWMASK;
+		matrix[3] = (((uint16_t) uart_data[4] << 9) | ((uint16_t) uart_data[5] << 1)) & LOWER_ROWMASK;
+		matrix[4] = ((uint16_t) uart_data[5] << 7) & LOWER_ROWMASK;
+		/* OK, TURNS OUT THAT WAS A BAD ASSUMPTION */
+        for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+			//I've unpacked these into the mirror image of what QMK expects them to be, so...
+			matrix[i] = ((matrix[i] * 0x0802LU & 0x22110LU) | (matrix[i] * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16;
+			//bithack mirror!  Doesn't make any sense, but works - and efficiently.
+        }
+    }
+
+
+    matrix_scan_quantum();
+    return 1;
+}
+
+inline
+bool matrix_is_on(uint8_t row, uint8_t col)
+{
+    return (matrix[row] & ((matrix_row_t)1<col));
+}
+
+inline
+matrix_row_t matrix_get_row(uint8_t row)
+{
+    return matrix[row];
+}
+
+void matrix_print(void)
+{
+    print_matrix_header();
+
+    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+        phex(row); print(": ");
+        print_matrix_row(row);
+        print("\n");
+    }
+}
+
+uint8_t matrix_key_count(void)
+{
+    uint8_t count = 0;
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+        count += matrix_bitpop(i);
+    }
+    return count;
+}

keyboards/dichotemy/readme.md

@@ -0,0 +1,33 @@
+Dichotemy Keyboard Firmware
+======================
+
+These configuration files were based off the Mitosis keyboard. This keyboard uses a completely different 'matrix scan' system to other keyboards, it relies on an external nRF51822 microcontroller maintaining a matrix of keystates received from the keyboard halves - it also receives mouse pointer information from the keyboard halves, which is implemented through a new feature, "Pointing Device". The matrix.c file contains the code to poll the external microcontroller for the key matrix, and the keymap.c file contains similar code to obtain the mouse report. As long as the relavant functions in these files are not changed, all other QMK features are supported.
+
+Build log of the keyboard can be found [here](http://google.com)
+
+Hardware design files can be found [here](http://google.com)
+
+Firmware for the nordic MCUs can be found [here](http://google.com)
+
+## Quantum MK Firmware
+
+For the full Quantum feature list, see [the parent readme](/).
+
+## Building
+
+Download or clone the whole firmware and navigate to the keyboards/atreus 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 `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 file named `<name>.c` and see keymap document (you can find in top readme.md) and existent 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/dichotemy/rules.mk

@@ -0,0 +1,82 @@
+
+OPT_DEFS += -DDICHOTEMY_PROMICRO
+OPT_DEFS += -DCATERINA_BOOTLOADER
+DICHOTEMY_UPLOAD_COMMAND = while [ ! -r $(USB) ]; do sleep 1; done; \
+                         avrdude -p $(MCU) -c avr109 -U flash:w:$(TARGET).hex -P $(USB)
+
+# # project specific files
+SRC = matrix.c
+
+
+# MCU name
+#MCU = at90usb1287
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Boot Section Size in *bytes*
+#   Teensy halfKay   512
+#   Teensy++ halfKay 1024
+#   Atmel DFU loader 4096
+#   LUFA bootloader  4096
+#   USBaspLoader     2048
+OPT_DEFS += -DBOOTLOADER_SIZE=4096
+
+
+# Build Options
+#   comment out to disable the options.
+#
+#BOOTMAGIC_ENABLE = yes	# Virtual DIP switch configuration(+1000)
+#MOUSEKEY_ENABLE = yes	# Mouse keys(+4700)
+POINTING_DEVICE_ENABLE = yes # Generic Pointer, not as big as mouse keys hopefully.
+EXTRAKEY_ENABLE = yes	# Audio control and System control(+450)
+CONSOLE_ENABLE = yes	# Console for debug(+400)
+COMMAND_ENABLE = yes   # Commands for debug and configuration
+CUSTOM_MATRIX = yes    # Remote matrix from the wireless bridge
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+# SLEEP_LED_ENABLE = yes  # Breathing sleep LED during USB suspend
+NKRO_ENABLE = yes		# USB Nkey Rollover - not yet supported in LUFA
+# BACKLIGHT_ENABLE = yes  # Enable keyboard backlight functionality
+# MIDI_ENABLE = YES 		# MIDI controls
+UNICODE_ENABLE = YES 		# Unicode
+# BLUETOOTH_ENABLE = yes # Enable Bluetooth with the Adafruit EZ-Key HID
+
+USB = /dev/ttyACM0
+
+#upload: build
+#	$(DICHOTEMY_UPLOAD_COMMAND)

keyboards/dk60/readme.md

@@ -10,7 +10,7 @@ Another 60% keyboard with different HHKB layout made and sold by dbroqua. [More
 
 Make example for this keyboard (after setting up your build environment):
 
-    make dk60-default
+    make dk60: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/dz60/dz60.h

@@ -23,13 +23,13 @@
 	K100,       K102, K103, K104, K105, K106, K107, K108, K109, K110, K111, K112, K113, K114, \
 	K200,       K202, K203, K204, K205, K206, K207, K208, K209, K210, K211, K212, K213,       \
 	K300, K301, K302, K303, K304, K305, K306, K307, K308, K309, K310, K311,       K313, K314, \
-	      K401,       K403,             K406,                   K410, K411  \
+	      K401,       K403,             K406,                         K411,       K413  \
 ) { \
 	{ K000,  K001,  K002,  K003,  K004,  K005,  K006,  K007,  K008,  K009,  K010,  K011,  K012,  K013,  K014 }, \
 	{ K100,  KC_NO, K102,  K103,  K104,  K105,  K106,  K107,  K108,  K109,  K110,  K111,  K112,  K113,  K114 }, \
 	{ K200,  KC_NO, K202,  K203,  K204,  K205,  K206,  K207,  K208,  K209,  K210,  K211,  K212,  K213,  KC_NO }, \
 	{ K300,  K301,  K302,  K303,  K304,  K305,  K306,  K307,  K308,  K309,  K310,  K311,  KC_NO, K313,  K314 }, \
-	{ KC_NO, K401,  KC_NO, K403,  KC_NO, KC_NO, K406,  KC_NO, KC_NO, KC_NO, K410,  K411,  KC_NO, KC_NO, KC_NO }  \
+	{ KC_NO, K401,  KC_NO, K403,  KC_NO, KC_NO, K406,  KC_NO, KC_NO, KC_NO, KC_NO, K411,  KC_NO, K413,  KC_NO }  \
 }
 
 #define KEYMAP_2_SHIFTS( \

keyboards/dz60/keymaps/itsaferbie/keymap.c

@@ -0,0 +1,43 @@
+#include "dz60.h"
+#include "action_layer.h"
+
+// My layout is practically the default HHKB layout.
+#define _DEFAULT 0
+#define _FN 1
+#define _LIGHTS 2
+
+#define ______ KC_TRNS
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+	[_DEFAULT] = KEYMAP_HHKB(
+		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_LCTL,          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_NO,   KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH,           KC_RSFT, MO(_FN), 
+		         KC_LGUI,          KC_LALT,                   KC_SPC,                                      KC_RALT,           MO(_LIGHTS)),
+
+	[_FN] = KEYMAP_HHKB(
+		______,  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_INS,  KC_DEL, 
+		KC_CAPS,          ______,  ______,  ______,  ______,  ______,  ______,  ______,  KC_PSCR, KC_SLCK, KC_PAUS,  KC_UP,   ______,  RESET, 
+		______,           KC_VOLD, KC_VOLU, KC_MUTE, ______,  ______,  KC_PAST, KC_PSLS, KC_HOME, KC_PGUP, KC_LEFT,  KC_RGHT, ______, 
+		______,  ______,  KC_MPRV, KC_MPLY, KC_MNXT, ______,  ______,  KC_PPLS, KC_PMNS, KC_END,  KC_PGDN, KC_DOWN,           ______,  ______, 
+		         ______,           ______,                    ______,                                      ______,            ______),
+
+	[_LIGHTS] = KEYMAP_HHKB(
+		RGB_TOG, RGB_M_P, RGB_M_B, RGB_M_R, RGB_M_SW, RGB_M_SN, RGB_M_K, RGB_M_X, RGB_M_G, ______, ______, ______, ______, ______, ______, 
+		RGB_MOD,          RGB_HUI, RGB_SAI, RGB_VAI,  ______,   ______,  ______,  ______,  ______, ______, ______, ______, ______, ______, 
+		______,           RGB_HUD, RGB_SAD, RGB_VAD,  ______,   ______,  ______,  ______,  ______, ______, ______, ______, ______, 
+		______,  ______,  ______,  ______,  BL_DEC,   BL_TOGG,  BL_INC,  ______,  ______,  ______, ______, ______,         ______, ______, 
+		         ______,           ______,                      ______,                                    ______,         ______),
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+
+
+	switch (id) {
+
+	}
+	return MACRO_NONE;
+}

keyboards/dz60/readme.md

@@ -10,6 +10,6 @@ Hardware Availability: [kbdfans](https://kbdfans.myshopify.com/collections/pcb/p
 
 Make example for this keyboard (after setting up your build environment):
 
-    make dz60-default
+    make dz60: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/eco/eco.h

@@ -1,10 +1,10 @@
 #ifndef ECO_H
 #define ECO_H
 
-#ifdef SUBPROJECT_rev1
+#ifdef KEYBOARD_eco_rev1
     #include "rev1.h"
 #endif
-#ifdef SUBPROJECT_rev2
+#ifdef KEYBOARD_eco_rev2
     #include "rev2.h"
 #endif
 

keyboards/eco/keymaps/default/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.
 
 // Default ECO Layout
 // KLE here : http://www.keyboard-layout-editor.com/#/gists/0733eca6b4cb88ff9d7de746803f4039

keyboards/eco/keymaps/that_canadian/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.
 
 // Below layout is based upon /u/That-Canadian's planck layout
 

keyboards/eco/readme.md

@@ -10,6 +10,6 @@ Hardware Supported: ECO PCB rev1 Pro Micro
 
 Make example for this keyboard (after setting up your build environment):
 
-    make eco-rev2-that_canadian
+    make eco/rev2:that_canadian
 
 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.