media next/prev track buttons

the original macros have every possible switch position for the board,
but there are a handful of switch positions that I'm not using. It's not
actually possible to use them all at once, since some of them would
cause keys to collide. I removed the uneeded positions to fit my layout.

.clang_complete

@@ -0,0 +1,24 @@
+
+-I.
+-I./drivers
+-I./drivers/avr
+-I./keyboards/ergodox_ez
+-I./keyboards/ergodox_ez/keymaps/vim
+-I./lib
+-I./lib/lufa
+-I./quantum
+-I./quantum/api
+-I./quantum/audio
+-I./quantum/keymap_extras
+-I./quantum/process_keycode
+-I./quantum/serial_link
+-I./quantum/template
+-I./quantum/tools
+-I./quantum/visualizer
+-I./tmk_core
+-I./tmk_core/common
+-I./tmk_core/common/debug.h
+-I./tmk_core/protocol
+-I./tmk_core/protocol/lufa
+-I./util
+-DQMK_KEYBOARD=\"$(KEYBOARD)\" -DQMK_KEYMAP=\"$(KEYMAP)\"

.editorconfig

@@ -8,7 +8,6 @@ indent_style = space
 indent_size = 2
 
 # We recommend you to keep these unchanged
-end_of_line = lf
 charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true
@@ -16,3 +15,22 @@ insert_final_newline = true
 [*.md]
 trim_trailing_whitespace = false
 indent_size = 4
+
+# Make these match what we have in .gitattributes
+[*.mk]
+end_of_line = lf
+
+[Makefile]
+end_of_line = lf
+
+[*.sh]
+end_of_line = lf
+
+# The gitattributes file will handle the line endings conversion properly according to the operating system settings for other files
+
+
+# We don't have gitattributes properly for these
+# So if the user have for example core.autocrlf set to true
+# the line endings would be wrong.
+[lib/**]
+end_of_line = unset

.gitignore

@@ -23,6 +23,7 @@ quantum/version.h
 .idea/
 CMakeLists.txt
 cmake-build-debug
+doxygen/
 .DS_STORE
 /util/wsl_downloaded
 /util/win_downloaded
@@ -42,6 +43,7 @@ cmake-build-debug
 .project
 .settings/
 .idea
+*.iml
 .browse.VC.db*
 *.stackdump
 util/Win_Check_Output.txt
@@ -52,6 +54,7 @@ util/Win_Check_Output.txt
 .vscode/last.sql
 .vscode/temp.sql
 .stfolder
+.tags
 
 # ignore image files
 *.png

.gitmodules

@@ -4,6 +4,7 @@
 [submodule "lib/chibios-contrib"]
 	path = lib/chibios-contrib
 	url = https://github.com/qmk/ChibiOS-Contrib
+	branch = k-type-fix
 [submodule "lib/ugfx"]
 	path = lib/ugfx
 	url = https://github.com/qmk/uGFX

.travis.yml

@@ -11,15 +11,17 @@ 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://qmk.fm/avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz
+  - wget http://ww1.microchip.com/downloads/en/DeviceDoc/avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz || wget http://qmk.fm/avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz
 install:
   - tar -zxf avr8-gnu-toolchain-3.5.4.1709-linux.any.x86_64.tar.gz
   - export PATH="$PATH:$TRAVIS_BUILD_DIR/avr8-gnu-toolchain-linux_x86_64/bin"
+  - npm install -g moxygen
 before_script:
   - avr-gcc --version
 script:
 - make test:all AUTOGEN=false
 - bash util/travis_build.sh
+- bash util/travis_docs.sh
 addons:
   apt:
     packages:
@@ -30,6 +32,7 @@ addons:
     - libnewlib-arm-none-eabi
     - diffutils
     - dos2unix
+    - doxygen
 after_success: 
   bash util/travis_compiled_push.sh
 notifications:
@@ -38,4 +41,4 @@ notifications:
       - https://webhooks.gitter.im/e/afce403d65f143dfac09
     on_success: always  # options: [always|never|change] default: always
     on_failure: always  # options: [always|never|change] default: always
-    on_start: never     # options: [always|never|change] default: always
+    on_start: never     # options: [always|never|change] default: always

Doxyfile

@@ -0,0 +1,266 @@
+# Doxyfile 1.8.14
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for qmk_firmware (github.com/qmk/qmk_firmware)
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+DOXYFILE_ENCODING      = UTF-8
+PROJECT_NAME           = "QMK Firmware"
+PROJECT_NUMBER         = https://github.com/qmk/qmk_firmware
+PROJECT_BRIEF          = "Keyboard controller firmware for Atmel AVR and ARM USB families"
+OUTPUT_DIRECTORY       = doxygen
+ALLOW_UNICODE_NAMES    = NO
+OUTPUT_LANGUAGE        = English
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = YES
+STRIP_FROM_PATH        = 
+STRIP_FROM_INC_PATH    = 
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = NO
+QT_AUTOBRIEF           = NO
+MULTILINE_CPP_IS_BRIEF = NO
+INHERIT_DOCS           = YES
+SEPARATE_MEMBER_PAGES  = NO
+TAB_SIZE               = 4
+ALIASES                = 
+TCL_SUBST              = 
+OPTIMIZE_OUTPUT_FOR_C  = YES
+OPTIMIZE_OUTPUT_JAVA   = NO
+OPTIMIZE_FOR_FORTRAN   = NO
+OPTIMIZE_OUTPUT_VHDL   = NO
+EXTENSION_MAPPING      = 
+MARKDOWN_SUPPORT       = YES
+TOC_INCLUDE_HEADINGS   = 2
+AUTOLINK_SUPPORT       = YES
+BUILTIN_STL_SUPPORT    = NO
+CPP_CLI_SUPPORT        = NO
+SIP_SUPPORT            = NO
+IDL_PROPERTY_SUPPORT   = YES
+DISTRIBUTE_GROUP_DOC   = NO
+GROUP_NESTED_COMPOUNDS = NO
+SUBGROUPING            = YES
+INLINE_GROUPED_CLASSES = NO
+INLINE_SIMPLE_STRUCTS  = NO
+TYPEDEF_HIDES_STRUCT   = NO
+LOOKUP_CACHE_SIZE      = 0
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+EXTRACT_ALL            = NO
+EXTRACT_PRIVATE        = NO
+EXTRACT_PACKAGE        = NO
+EXTRACT_STATIC         = NO
+EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_LOCAL_METHODS  = NO
+EXTRACT_ANON_NSPACES   = NO
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = NO
+CASE_SENSE_NAMES       = NO
+HIDE_SCOPE_NAMES       = YES
+HIDE_COMPOUND_REFERENCE= NO
+SHOW_INCLUDE_FILES     = YES
+SHOW_GROUPED_MEMB_INC  = NO
+FORCE_LOCAL_INCLUDES   = NO
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+SORT_BRIEF_DOCS        = NO
+SORT_MEMBERS_CTORS_1ST = NO
+SORT_GROUP_NAMES       = NO
+SORT_BY_SCOPE_NAME     = NO
+STRICT_PROTO_MATCHING  = NO
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = YES
+SHOW_FILES             = YES
+SHOW_NAMESPACES        = YES
+FILE_VERSION_FILTER    = 
+LAYOUT_FILE            = 
+CITE_BIB_FILES         = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_NO_PARAMDOC       = NO
+WARN_AS_ERROR          = NO
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+INPUT                  = tmk_core quantum drivers
+INPUT_ENCODING         = UTF-8
+FILE_PATTERNS          = *.c \
+                         *.cc \
+                         *.cxx \
+                         *.cpp \
+                         *.c++ \
+                         *.h \
+                         *.hh \
+                         *.hxx \
+                         *.hpp \
+                         *.h++
+RECURSIVE              = YES
+EXCLUDE                = 
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXCLUDE_SYMBOLS        = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = *
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_PATTERNS        = 
+FILTER_SOURCE_FILES    = NO
+FILTER_SOURCE_PATTERNS = 
+USE_MDFILE_AS_MAINPAGE = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+SOURCE_BROWSER         = YES
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION    = NO
+REFERENCES_LINK_SOURCE = YES
+SOURCE_TOOLTIPS        = YES
+USE_HTAGS              = NO
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          = 
+
+#---------------------------------------------------------------------------
+# Configuration options related to disabled outputs
+#---------------------------------------------------------------------------
+
+GENERATE_HTML          = NO
+GENERATE_LATEX         = NO
+GENERATE_RTF           = NO
+GENERATE_MAN           = NO
+GENERATE_DOCBOOK       = NO
+GENERATE_AUTOGEN_DEF   = NO
+GENERATE_PERLMOD       = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+GENERATE_XML           = YES
+XML_OUTPUT             = xml
+XML_PROGRAMLISTING     = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = 
+INCLUDE_FILE_PATTERNS  = 
+PREDEFINED             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+TAGFILES               = 
+GENERATE_TAGFILE       = 
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+EXTERNAL_PAGES         = YES
+PERL_PATH              = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+CLASS_DIAGRAMS         = YES
+MSCGEN_PATH            = 
+DIA_PATH               = 
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = NO
+DOT_NUM_THREADS        = 0
+DOT_FONTNAME           = Helvetica
+DOT_FONTSIZE           = 10
+DOT_FONTPATH           = 
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+GROUP_GRAPHS           = YES
+UML_LOOK               = NO
+UML_LIMIT_NUM_FIELDS   = 10
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = NO
+CALLER_GRAPH           = NO
+GRAPHICAL_HIERARCHY    = YES
+DIRECTORY_GRAPH        = YES
+DOT_IMAGE_FORMAT       = png
+INTERACTIVE_SVG        = NO
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MSCFILE_DIRS           = 
+DIAFILE_DIRS           = 
+PLANTUML_JAR_PATH      = 
+PLANTUML_CFG_FILE      = 
+PLANTUML_INCLUDE_PATH  = 
+DOT_GRAPH_MAX_NODES    = 50
+MAX_DOT_GRAPH_DEPTH    = 0
+DOT_TRANSPARENT        = NO
+DOT_MULTI_TARGETS      = NO
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES

LICENSE

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

Makefile

@@ -19,10 +19,12 @@ endif
 # Otherwise the [OK], [ERROR] and [WARN] messages won't be displayed correctly
 override SILENT := false
 
+ifndef SUB_IS_SILENT
 QMK_VERSION := $(shell git describe --abbrev=0 --tags 2>/dev/null)
 ifneq ($(QMK_VERSION),)
 $(info QMK Firmware $(QMK_VERSION))
 endif
+endif
 
 ON_ERROR := error_occurred=1
 
@@ -114,6 +116,20 @@ list-keyboards:
 	echo $(KEYBOARDS)
 	exit 0
 
+define PRINT_KEYBOARD
+	$(info $(PRINTING_KEYBOARD))
+endef
+
+generate-keyboards-file:
+	$(foreach PRINTING_KEYBOARD,$(KEYBOARDS),$(eval $(call PRINT_KEYBOARD)))
+	exit 0
+
+clean:
+	echo -n 'Deleting .build ... '
+	rm -rf $(BUILD_DIR)
+	echo 'done'
+	exit 0
+
 #Compatibility with the old make variables, anything you specify directly on the command line
 # always overrides the detected folders
 ifdef keyboard

bootloader.mk

@@ -0,0 +1,62 @@
+# Copyright 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/>.
+
+# If it's possible that multiple bootloaders can be used for one project,
+# you can leave this unset, and the correct size will be selected
+# automatically.
+#
+# Sets the bootloader defined in the keyboard's/keymap's rules.mk
+# Current options:
+#   atmel-dfu
+#   lufa-dfu
+#   qmk-dfu
+#   halfkay
+#   caterina
+#   bootloadHID
+#
+# BOOTLOADER_SIZE can still be defined manually, but it's recommended
+# you add any possible configuration to this list
+
+ifeq ($(strip $(BOOTLOADER)), atmel-dfu)
+    OPT_DEFS += -DBOOTLOADER_ATMEL_DFU
+    OPT_DEFS += -DBOOTLOADER_DFU
+    BOOTLOADER_SIZE = 4096
+endif
+ifeq ($(strip $(BOOTLOADER)), lufa-dfu)
+    OPT_DEFS += -DBOOTLOADER_LUFA_DFU
+    OPT_DEFS += -DBOOTLOADER_DFU
+    BOOTLOADER_SIZE = 4096
+endif
+ifeq ($(strip $(BOOTLOADER)), qmk-dfu)
+    OPT_DEFS += -DBOOTLOADER_QMK_DFU
+    OPT_DEFS += -DBOOTLOADER_DFU
+    BOOTLOADER_SIZE = 4096
+endif
+ifeq ($(strip $(BOOTLOADER)), halfkay)
+    OPT_DEFS += -DBOOTLOADER_HALFKAY
+    BOOTLOADER_SIZE = 512
+endif
+ifeq ($(strip $(BOOTLOADER)), caterina)
+    OPT_DEFS += -DBOOTLOADER_CATERINA
+    BOOTLOADER_SIZE = 4096
+endif
+ifeq ($(strip $(BOOTLOADER)), bootloadHID)
+    OPT_DEFS += -DBOOTLOADER_BOOTLOADHID
+    BOOTLOADER_SIZE = 4096
+endif
+
+ifdef BOOTLOADER_SIZE
+    OPT_DEFS += -DBOOTLOADER_SIZE=$(strip $(BOOTLOADER_SIZE))
+endif

build_keyboard.mk

@@ -94,15 +94,33 @@ endif
 
 OPT_DEFS += -DKEYBOARD_$(KEYBOARD_FILESAFE)
 
+
+ifneq ("$(wildcard $(KEYBOARD_PATH_1)/$(KEYBOARD_FOLDER_1).h)","")
+    QMK_KEYBOARD_H = $(KEYBOARD_FOLDER_1).h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_2)/$(KEYBOARD_FOLDER_2).h)","")
+    QMK_KEYBOARD_H = $(KEYBOARD_FOLDER_2).h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_3)/$(KEYBOARD_FOLDER_3).h)","")
+    QMK_KEYBOARD_H = $(KEYBOARD_FOLDER_3).h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_4)/$(KEYBOARD_FOLDER_4).h)","")
+    QMK_KEYBOARD_H = $(KEYBOARD_FOLDER_4).h
+endif
+ifneq ("$(wildcard $(KEYBOARD_PATH_5)/$(KEYBOARD_FOLDER_5).h)","")
+    QMK_KEYBOARD_H = $(KEYBOARD_FOLDER_5).h
+endif
+
 # We can assume a ChibiOS target When MCU_FAMILY is defined , since it's not used for LUFA
 ifdef MCU_FAMILY
+    FIRMWARE_FORMAT=bin
     PLATFORM=CHIBIOS
 else
     PLATFORM=AVR
+    FIRMWARE_FORMAT=hex
 endif
 
 ifeq ($(PLATFORM),CHIBIOS)
-    include $(TMK_PATH)/protocol/chibios.mk
     include $(TMK_PATH)/chibios.mk
     OPT_OS = chibios
     ifneq ("$(wildcard $(KEYBOARD_PATH_5)/bootloader_defs.h)","")
@@ -125,6 +143,8 @@ ifeq ($(PLATFORM),CHIBIOS)
         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
+    else ifneq ("$(wildcard $(TOP_DIR)/drivers/boards/$(BOARD)/bootloader_defs.h)","")
+        OPT_DEFS += -include $(TOP_DIR)/drivers/boards/$(BOARD)/bootloader_defs.h
     endif
 endif
 
@@ -178,14 +198,22 @@ else ifneq ("$(wildcard $(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
 
 # User space stuff
-USER_PATH := users/$(KEYMAP)
+ifeq ("$(USER_NAME)","")
+    USER_NAME := $(KEYMAP)
+endif
+USER_PATH := users/$(USER_NAME)
+
 -include $(USER_PATH)/rules.mk
+ifneq ("$(wildcard users/$(KEYMAP)/config.h)","")
+    CONFIG_H += users/$(KEYMAP)/config.h
+endif
+
 
 # Object files directory
 #     To put object files in current directory, use a dot (.), do NOT make
@@ -213,6 +241,7 @@ VPATH += $(USER_PATH)
 include common_features.mk
 include $(TMK_PATH)/protocol.mk
 include $(TMK_PATH)/common.mk
+include bootloader.mk
 
 SRC += $(TMK_COMMON_SRC)
 OPT_DEFS += $(TMK_COMMON_DEFS)
@@ -227,16 +256,22 @@ endif
     include $(TMK_PATH)/avr.mk
 endif
 
+ifeq ($(PLATFORM),CHIBIOS)
+    include $(TMK_PATH)/protocol/chibios.mk
+endif
+
 ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
     VISUALIZER_DIR = $(QUANTUM_DIR)/visualizer
     VISUALIZER_PATH = $(QUANTUM_PATH)/visualizer
     include $(VISUALIZER_PATH)/visualizer.mk
 endif
 
+ALL_CONFIGS := $(PROJECT_CONFIG) $(CONFIG_H)
+
 OUTPUTS := $(KEYMAP_OUTPUT) $(KEYBOARD_OUTPUT)
 $(KEYMAP_OUTPUT)_SRC := $(SRC)
 $(KEYMAP_OUTPUT)_DEFS := $(OPT_DEFS) $(GFXDEFS) \
--DQMK_KEYBOARD=\"$(KEYBOARD)\" -DQMK_KEYBOARD_H=\"$(KEYBOARD_FOLDER_1).h\" -DQMK_KEYBOARD_CONFIG_H=\"$(KEYBOARD_PATH_1)/config.h\" \
+-DQMK_KEYBOARD=\"$(KEYBOARD)\" -DQMK_KEYBOARD_H=\"$(QMK_KEYBOARD_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 -DQMK_SUBPROJECT_H -DQMK_SUBPROJECT_CONFIG_H
 $(KEYMAP_OUTPUT)_INC :=  $(VPATH) $(EXTRAINCDIRS)
@@ -247,10 +282,10 @@ $(KEYBOARD_OUTPUT)_INC := $(PROJECT_INC) $(GFXINC)
 $(KEYBOARD_OUTPUT)_CONFIG := $(PROJECT_CONFIG)
 
 # Default target.
-all: build sizeafter
+all: build check-size
 
 # Change the build target to build a HEX file or a library.
-build: elf hex
+build: elf cpfirmware
 #build: elf hex eep lss sym
 #build: lib
 

common_features.mk

@@ -34,7 +34,12 @@ ifeq ($(strip $(AUDIO_ENABLE)), yes)
     OPT_DEFS += -DAUDIO_ENABLE
     MUSIC_ENABLE := 1
     SRC += $(QUANTUM_DIR)/process_keycode/process_audio.c
-    SRC += $(QUANTUM_DIR)/audio/audio.c
+    SRC += $(QUANTUM_DIR)/process_keycode/process_clicky.c
+    ifeq ($(PLATFORM),AVR)
+        SRC += $(QUANTUM_DIR)/audio/audio.c
+    else
+        SRC += $(QUANTUM_DIR)/audio/audio_arm.c
+    endif
     SRC += $(QUANTUM_DIR)/audio/voices.c
     SRC += $(QUANTUM_DIR)/audio/luts.c
 endif
@@ -128,6 +133,9 @@ endif
 ifeq ($(strip $(AUTO_SHIFT_ENABLE)), yes)
     OPT_DEFS += -DAUTO_SHIFT_ENABLE
     SRC += $(QUANTUM_DIR)/process_keycode/process_auto_shift.c
+    ifeq ($(strip $(AUTO_SHIFT_MODIFIERS)), yes)
+        OPT_DEFS += -DAUTO_SHIFT_MODIFIERS
+    endif
 endif
 
 ifeq ($(strip $(SERIAL_LINK_ENABLE)), yes)
@@ -151,6 +159,9 @@ endif
 ifeq ($(strip $(BACKLIGHT_ENABLE)), yes)
     ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
         CIE1931_CURVE = yes
+    endif
+		ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes)
+        OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER
     endif
 endif
 

docs/README.md

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

docs/_summary.md

@@ -1,11 +1,18 @@
-* [Getting started](README.md)
+* [Getting Started](README.md)
   * [QMK Introduction](getting_started_introduction.md)
   * [Install Build Tools](getting_started_build_tools.md)
-    * Alternative: [Vagrant Guide](getting_started_vagrant_guide.md)
-  * [Build/Compile instructions](getting_started_make_guide.md)
-  * [Flashing instructions](flashing.md)
+    * Alternative: [Vagrant Guide](getting_started_vagrant.md)
+  * [Build/Compile Instructions](getting_started_make_guide.md)
+  * [Flashing Firmware](flashing.md)
   * [Contributing to QMK](contributing.md)
   * [How to Use Github](getting_started_github.md)
+  * [Getting Help](getting_started_getting_help.md)
+
+* [Complete Newbs Guide](newbs.md)
+  * [Getting Started](newbs_getting_started.md)
+  * [Building Your First Firmware](newbs_building_firmware.md)
+  * [Flashing Firmware](newbs_flashing.md)
+  * [Testing and Debugging](newbs_testing_debugging.md)
 
 * [FAQ](faq.md)
   * [General FAQ](faq_general.md)
@@ -25,17 +32,20 @@
   * [Auto Shift](feature_auto_shift.md)
   * [Backlight](feature_backlight.md)
   * [Bootmagic](feature_bootmagic.md)
+  * [Command](feature_command.md)
   * [Dynamic Macros](feature_dynamic_macros.md)
+  * [Grave Escape](feature_grave_esc.md)
   * [Key Lock](feature_key_lock.md)
   * [Layouts](feature_layouts.md)
   * [Leader Key](feature_leader_key.md)
   * [Macros](feature_macros.md)
-  * [Mouse keys](feature_mouse_keys.md)
+  * [Mouse Keys](feature_mouse_keys.md)
   * [Pointing Device](feature_pointing_device.md)
-  * [PS2 Mouse](feature_ps2_mouse.md)
+  * [PS/2 Mouse](feature_ps2_mouse.md)
   * [RGB Lighting](feature_rgblight.md)
   * [Space Cadet](feature_space_cadet.md)
   * [Stenography](feature_stenography.md)
+  * [Swap Hands](feature_swap_hands.md)
   * [Tap Dance](feature_tap_dance.md)
   * [Terminal](feature_terminal.md)
   * [Thermal Printer](feature_thermal_printer.md)
@@ -63,14 +73,13 @@
   * [Customizing Functionality](custom_quantum_functions.md)
   * [Documentation Best Practices](documentation_best_practices.md)
   * [Documentation Templates](documentation_templates.md)
-  * [Glossary](glossary.md)
-  * [Keymap overview](keymap.md)
+  * [Glossary](reference_glossary.md)
+  * [Keymap Overview](keymap.md)
   * [Unit Testing](unit_testing.md)
 
 * For Makers and Modders
   * [Hand Wiring Guide](hand_wire.md)
-  * [ISP flashing guide](isp_flashing_guide.md)
-  * [Modding your keyboard](modding_your_keyboard.md)
+  * [ISP Flashing Guide](isp_flashing_guide.md)
 
 * For a Deeper Understanding
   * [How Keyboards Work](how_keyboards_work.md)
@@ -78,3 +87,12 @@
 
 * Other Topics
   * [Using Eclipse with QMK](eclipse.md)
+
+* QMK Internals (In Progress)
+  * [Defines](internals_defines.md)
+  * [Input Callback Reg](internals_input_callback_reg.md)
+  * [Midi Device](internals_midi_device.md)
+  * [Midi Device Setup Process](internals_midi_device_setup_process.md)
+  * [Midi Util](internals_midi_util.md)
+  * [Send Functions](internals_send_functions.md)
+  * [Sysex Tools](internals_sysex_tools.md)

docs/becoming_a_qmk_collaborator.md

@@ -4,4 +4,4 @@ A QMK collaborator is a keyboard maker/designer that is interested in helping QM
 * **Maintain the your keyboard's directory** - this may just require an initial setup to get your keyboard working, but it could also include accommodating changes made to QMK's core.
 * **Approve and merge your keyboard's keymap pull requests** - we like to encourage users to contribute their keymaps for others to see and work from when creating their own.
 
-If you feel you meet these requirements, shoot us an email at hello@qmk.fm with an introduction and some links to your keyboard!
+If you feel you meet these requirements, shoot us an email at hello@qmk.fm with an introduction and some links to your keyboard!

docs/compatible_microcontrollers.md

@@ -22,4 +22,4 @@ You can also use any ARM processor that [ChibiOS](http://www.chibios.org) suppor
 * [Kinetis MKL26Z64](http://www.nxp.com/products/microcontrollers-and-processors/arm-processors/kinetis-cortex-m-mcus/l-series-ultra-low-power-m0-plus/kinetis-kl2x-48-mhz-usb-ultra-low-power-microcontrollers-mcus-based-on-arm-cortex-m0-plus-core:KL2x)
 * [Kinetis MK20DX128](http://www.nxp.com/assets/documents/data/en/data-sheets/K20P64M50SF0.pdf)
 * [Kinetis MK20DX128](http://www.nxp.com/assets/documents/data/en/data-sheets/K20P64M50SF0.pdf)
-* [Kinetis MK20DX256](http://www.nxp.com/products/microcontrollers-and-processors/arm-processors/kinetis-cortex-m-mcus/k-series-performance-m4/k2x-usb/kinetis-k20-72-mhz-full-speed-usb-mixed-signal-integration-microcontrollers-mcus-based-on-arm-cortex-m4-core:K20_72)
+* [Kinetis MK20DX256](http://www.nxp.com/products/microcontrollers-and-processors/arm-processors/kinetis-cortex-m-mcus/k-series-performance-m4/k2x-usb/kinetis-k20-72-mhz-full-speed-usb-mixed-signal-integration-microcontrollers-mcus-based-on-arm-cortex-m4-core:K20_72)

docs/config_options.md

@@ -25,13 +25,14 @@ Some keyboards have folders and sub-folders to allow for different hardware conf
 
 This level contains all of the options for that particular keymap. If you wish to override a previous declaration, you can use `#undef <variable>` to undefine it, where you can then redefine it without an error.
 
-# The `config.h` file
+# The `config.h` File
 
-This is a C header file that is one of the first things included, and will persist over the whole project (if included). Lots of variables can be set here and accessed elsewhere.
+This is a C header file that is one of the first things included, and will persist over the whole project (if included). Lots of variables can be set here and accessed elsewhere. The `config.h` file shouldn't be including other `config.h` files, or anything besides this:
 
-## `config.h` Options
+    #include "config_common.h"
 
-### Hardware Options
+
+## Hardware Options
 * `#define VENDOR_ID 0x1234`
   * defines your VID, and for most DIY projects, can be whatever you want
 * `#define PRODUCT_ID 0x5678`
@@ -60,14 +61,26 @@ This is a C header file that is one of the first things included, and will persi
   * COL2ROW or ROW2COL - how your matrix is configured. COL2ROW means the black mark on your diode is facing to the rows, and between the switch and the rows.
 * `#define AUDIO_VOICES`
   * turns on the alternate audio voices (to cycle through)
+* `#define C4_AUDIO`
+  * enables audio on pin C4
+* `#define C5_AUDIO`
+  * enables audio on pin C5
 * `#define C6_AUDIO`
   * enables audio on pin C6
 * `#define B5_AUDIO`
-  * enables audio on pin B5 (duophony is enable if both are enabled)
+  * enables audio on pin B5 (duophony is enables if one of B[5-7]_AUDIO is enabled along with one of C[4-6]_AUDIO)
+* `#define B6_AUDIO`
+  * enables audio on pin B6 (duophony is enables if one of B[5-7]_AUDIO is enabled along with one of C[4-6]_AUDIO)
+* `#define B7_AUDIO`
+  * enables audio on pin B7 (duophony is enables if one of B[5-7]_AUDIO is enabled along with one of C[4-6]_AUDIO)
 * `#define BACKLIGHT_PIN B7`
   * pin of the backlight - B5, B6, B7 use PWM, others use softPWM
 * `#define BACKLIGHT_LEVELS 3`
-  * number of levels your backlight will have (not including off)
+  * number of levels your backlight will have (maximum 15 excluding off)
+* `#define BACKLIGHT_BREATHING`
+  * enables backlight breathing (only works with backlight pins B5, B6 and B7)
+* `#define BREATHING_PERIOD 6`
+  * the length of one backlight "breath" in seconds
 * `#define DEBOUNCING_DELAY 5`
   * the delay when reading the value of the pin (5 is default)
 * `#define LOCKING_SUPPORT_ENABLE`
@@ -77,12 +90,12 @@ This is a C header file that is one of the first things included, and will persi
 * `#define IS_COMMAND() ( keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) )`
   * key combination that allows the use of magic commands (useful for debugging)
 
-### Features That Can Be Disabled
+## Features That Can Be Disabled
 
 If you define these options you will disable the associated feature, which can save on code size.
 
 * `#define NO_DEBUG`
-  * disable debuging
+  * disable debugging
 * `#define NO_PRINT`
   * disable printing/debugging using hid_listen
 * `#define NO_ACTION_LAYER`
@@ -96,16 +109,16 @@ If you define these options you will disable the associated feature, which can s
 * `#define NO_ACTION_FUNCTION`
   * disable the action function (deprecated)
 
-### Features That Can Be Enabled
+## Features That Can Be Enabled
 
 If you define these options you will enable the associated feature, which may increase your code size.
 
 * `#define FORCE_NKRO`
-  * NKRO by default requires to be turned on, this forces it on during keyboard startup regardless of eeprom setting. NKRO can still be turned off but will be turned on again if the keyboard reboots.
+  * NKRO by default requires to be turned on, this forces it on during keyboard startup regardless of EEPROM setting. NKRO can still be turned off but will be turned on again if the keyboard reboots.
 * `#define PREVENT_STUCK_MODIFIERS`
-  * when switching layers, this will release all mods
+  * stores the layer a key press came from so the same layer is used when the key is released, regardless of which layers are enabled
 
-### Behaviors That Can Be Configured
+## Behaviors That Can Be Configured
 
 * `#define TAPPING_TERM 200`
   * how long before a tap becomes a hold
@@ -123,8 +136,17 @@ If you define these options you will enable the associated feature, which may in
   * how many taps before oneshot toggle is triggered
 * `#define IGNORE_MOD_TAP_INTERRUPT`
   * makes it possible to do rolling combos (zx) with keys that convert to other keys on hold
-
-### RGB Light Configuration
+* `#define QMK_KEYS_PER_SCAN 4`
+  * Allows sending more than one key per scan. By default, only one key event gets
+    sent via `process_record()` per scan. This has little impact on most typing, but
+    if you're doing a lot of chords, or your scan rate is slow to begin with, you can
+    have some delay in processing key events. Each press and release is a separate
+    event. For a keyboard with 1ms or so scan times, even a very fast typist isn't
+    going to produce the 500 keystrokes a second needed to actually get more than a
+    few ms of delay from this. But if you're doing chording on something with 3-4ms
+    scan times? You probably want this.
+
+## RGB Light Configuration
 
 * `#define RGB_DI_PIN D7`
   * pin the DI on the ws2812 is hooked-up to
@@ -135,13 +157,13 @@ If you define these options you will enable the associated feature, which may in
 * `#define RGBLIGHT_HUE_STEP 12`
   * units to step when in/decreasing hue
 * `#define RGBLIGHT_SAT_STEP 25`
-  * units to step when in/decresing saturation
+  * units to step when in/decreasing saturation
 * `#define RGBLIGHT_VAL_STEP 12`
   * units to step when in/decreasing value (brightness)
 * `#define RGBW_BB_TWI`
-  * bit-bangs twi to EZ RGBW LEDs (only required for Ergodox EZ)
+  * bit-bangs TWI to EZ RGBW LEDs (only required for Ergodox EZ)
 
-### Mouse Key Options
+## Mouse Key Options
 
 * `#define MOUSEKEY_INTERVAL 20`
 * `#define MOUSEKEY_DELAY 0`
@@ -153,9 +175,7 @@ If you define these options you will enable the associated feature, which may in
 
 This is a [make](https://www.gnu.org/software/make/manual/make.html) file that is included by the top-level `Makefile`. It is used to set some information about the MCU that we will be compiling for as well as enabling and disabling certain features.
 
-## `rules.mk` options
-
-### Build Options
+## Build Options
 
 * `DEFAULT_FOLDER`
   * Used to specify a default folder when a keyboard has more than one sub-folder.
@@ -164,15 +184,21 @@ This is a [make](https://www.gnu.org/software/make/manual/make.html) file that i
 * `LAYOUTS`
   * A list of [layouts](feature_layouts.md) this keyboard supports.
 
-### AVR MCU Options
+## AVR MCU Options
 * `MCU = atmega32u4`
 * `F_CPU = 16000000`
 * `ARCH = AVR8`
 * `F_USB = $(F_CPU)`
 * `OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT`
-* `OPT_DEFS += -DBOOTLOADER_SIZE=4096`
+* `BOOTLOADER = atmel-dfu` with the following options:
+  * `atmel-dfu`
+  * `lufa-dfu`
+  * `qmk-dfu`
+  * `halfkay`
+  * `caterina`
+  * `bootloadHID`
 
-### Feature Options
+## Feature Options
 
 Use these to enable or disable building certain features. The more you have enabled the bigger your firmware will be, and you run the risk of building a firmware too large for your MCU.
 
@@ -187,7 +213,7 @@ Use these to enable or disable building certain features. The more you have enab
 * `COMMAND_ENABLE`
   * Commands for debug and configuration
 * `NKRO_ENABLE`
-  * USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+  * USB N-Key Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
 * `AUDIO_ENABLE`
   * Enable the audio subsystem.
 * `RGBLIGHT_ENABLE`

docs/contributing.md

@@ -1,4 +1,4 @@
-# How To Contribute
+# How to Contribute
 
 👍🎉 First off, thanks for taking the time to read this and contribute! 🎉👍
 
@@ -9,7 +9,7 @@ Third-party contributions help us grow and improve QMK. We want to make the pull
 * [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!
+## 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).
 
@@ -27,7 +27,7 @@ QMK is largely written in C, with specific features and parts written in C++. It
 
 <!-- FIXME: We should include a list of resources for learning C here. -->
 
-# Where can I go for help?
+# 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).
 
@@ -52,7 +52,7 @@ Never made an open source contribution before? Wondering how contributions work
 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
+# 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:
 
@@ -64,7 +64,7 @@ Most of our style is pretty easy to pick up on, but right now it's not entirely
   * Optional Braces: Always include optional braces.
     * Good: if (condition) { return false; }
     * Bad: if (condition) return false;
-* We use C style comments: /* */
+* 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
@@ -75,7 +75,7 @@ Most of our style is pretty easy to pick up on, but right now it's not entirely
 
 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. 
+* 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
@@ -111,7 +111,7 @@ Most first-time QMK contributors start with their personal keymaps. We try to ke
 
 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: 
+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
@@ -122,7 +122,7 @@ We also ask that you follow these guidelines:
 
 ## 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:
+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 [Understanding QMK](understanding_qmk.md), 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)
@@ -136,7 +136,7 @@ Here are some things to keep in mind when working on your feature or bug fix.
 * **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: 
+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.
@@ -147,6 +147,6 @@ We also ask that you follow these guidelines:
 
 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?
+# What Does the Code of Conduct Mean for Me?
 
 Our [Code of Conduct](https://github.com/qmk/qmk_firmware/blob/master/CODE_OF_CONDUCT.md) 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/custom_quantum_functions.md

@@ -1,8 +1,8 @@
-# How To Customize Your Keyboard's Behavior
+# How to Customize Your Keyboard's Behavior
 
-For a lot of people a custom keyboard is about more than sending button presses to your computer. You want to be able to do things that are more complex than simple button presses and macros. QMK has hooks that allow you to inject code, override functionality, and otherwise customize how your keyboard behaves in different situations. 
+For a lot of people a custom keyboard is about more than sending button presses to your computer. You want to be able to do things that are more complex than simple button presses and macros. QMK has hooks that allow you to inject code, override functionality, and otherwise customize how your keyboard behaves in different situations.
 
-This page does not assume any special knowledge about QMK, but reading [Understanding QMK](understanding_qmk.html) will help you understand what is going on at a more fundamental level.
+This page does not assume any special knowledge about QMK, but reading [Understanding QMK](understanding_qmk.md) will help you understand what is going on at a more fundamental level.
 
 ## A Word on Core vs Keyboards vs Keymap
 
@@ -34,13 +34,13 @@ enum my_keycodes {
 };
 ```
 
-## Programming The Behavior Of Any Keycode
+## Programming the Behavior of Any Keycode
 
-When you want to override the behavior of an existing key, or define the behavior for a new key, you should use the `process_record_kb()` and `process_record_user()` functions. These are called by QMK during key processing before the actual key event is handled. If these functions return `true` QMK will process the keycodes as usual. That can be handy for extending the functionality of a key rather than replacing it. If these functions return `false` QMK will skip the normal key handling, and it will be up you to send any key up or down events that are required.
+When you want to override the behavior of an existing key, or define the behavior for a new key, you should use the `process_record_kb()` and `process_record_user()` functions. These are called by QMK during key processing before the actual key event is handled. If these functions return `true` QMK will process the keycodes as usual. That can be handy for extending the functionality of a key rather than replacing it. If these functions return `false` QMK will skip the normal key handling, and it will be up to you to send any key up or down events that are required.
 
 These function are called every time a key is pressed or released.
 
-### Example `process_record_user()` implementation
+### Example `process_record_user()` Implementation
 
 This example does two things. It defines the behavior for a custom keycode called `FOO`, and it supplements our Enter key by playing a tone whenever it is pressed.
 
@@ -60,18 +60,20 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         PLAY_NOTE_ARRAY(tone_qwerty);
       }
       return true; // Let QMK send the enter press/release events
+    default:
+      return true; // Process all other keycodes normally
   }
 }
 ```
 
-### `process_record_*` Function documentation
+### `process_record_*` Function Documentation
 
-* Keyboard/Revision: `bool process_record_kb(uint16_t keycode, keyrecord_t *record)` 
+* Keyboard/Revision: `bool process_record_kb(uint16_t keycode, keyrecord_t *record)`
 * Keymap: `bool process_record_user(uint16_t keycode, keyrecord_t *record)`
 
 The `keycode` argument is whatever is defined in your keymap, eg `MO(1)`, `KC_L`, etc. You should use a `switch...case` block to handle these events.
 
-The `record` argument contains infomation about the actual press:
+The `record` argument contains information about the actual press:
 
 ```
 keyrecord_t record {
@@ -96,10 +98,10 @@ This allows you to control the 5 LED's defined as part of the USB Keyboard spec.
 * `USB_LED_COMPOSE`
 * `USB_LED_KANA`
 
-### Example `led_set_kb()` implementation
+### Example `led_set_user()` Implementation
 
 ```
-void led_set_kb(uint8_t usb_led) {
+void led_set_user(uint8_t usb_led) {
     if (usb_led & (1<<USB_LED_NUM_LOCK)) {
         PORTB |= (1<<0);
     } else {
@@ -128,23 +130,22 @@ void led_set_kb(uint8_t usb_led) {
 }
 ```
 
-### `led_set_*` Function documentation
+### `led_set_*` Function Documentation
 
-* Keyboard/Revision: `void led_set_kb(uint8_t usb_led)` 
+* Keyboard/Revision: `void led_set_kb(uint8_t usb_led)`
 * Keymap: `void led_set_user(uint8_t usb_led)`
 
 # Matrix Initialization Code
 
 Before a keyboard can be used the hardware must be initialized. QMK handles initialization of the keyboard matrix itself, but if you have other hardware like LED's or i&#xb2;c controllers you will need to set up that hardware before it can be used.
 
-### Example `matrix_init_kb()` implementation
+### Example `matrix_init_user()` Implementation
 
 This example, at the keyboard level, sets up B1, B2, and B3 as LED pins.
 
 ```
-void matrix_init_kb(void) {
+void matrix_init_user(void) {
   // Call the keymap level matrix init.
-  matrix_init_user();
 
   // Set our LED pins as output
   DDRB |= (1<<1);
@@ -153,20 +154,20 @@ void matrix_init_kb(void) {
 }
 ```
 
-### `matrix_init_*` Function documentation
+### `matrix_init_*` Function Documentation
 
-* Keyboard/Revision: `void matrix_init_kb(void)` 
+* Keyboard/Revision: `void matrix_init_kb(void)`
 * Keymap: `void matrix_init_user(void)`
 
 # Matrix Scanning Code
 
 Whenever possible you should customize your keyboard by using `process_record_*()` and hooking into events that way, to ensure that your code does not have a negative performance impact on your keyboard. However, in rare cases it is necessary to hook into the matrix scanning. Be extremely careful with the performance of code in these functions, as it will be called at least 10 times per second.
 
-### Example `matrix_scan_*` implementation
+### Example `matrix_scan_*` Implementation
 
 This example has been deliberately omitted. You should understand enough about QMK internals to write this without an example before hooking into such a performance sensitive area. If you need help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) or [chat with us on gitter](https://gitter.im/qmk/qmk_firmware).
 
-### `matrix_scan_*` Function documentation
+### `matrix_scan_*` Function Documentation
 
 * Keyboard/Revision: `void matrix_scan_kb(void)`
 * Keymap: `void matrix_scan_user(void)`
@@ -174,3 +175,41 @@ This example has been deliberately omitted. You should understand enough about Q
 This function gets called at every matrix scan, which is basically as often as the MCU can handle. Be careful what you put here, as it will get run a lot.
 
 You should use this function if you need custom matrix scanning code. It can also be used for custom status output (such as LED's or a display) or other functionality that you want to trigger regularly even when the user isn't typing.
+
+
+# Layer Change Code
+
+Thir runs code every time that the layers get changed.  This can be useful for layer indication, or custom layer handling. 
+
+### Example `layer_state_set_*` Implementation
+
+This example shows how to set the [RGB Underglow](feature_rgblight.md) lights based on the layer, using the Planck as an example
+
+```
+uint32_t layer_state_set_user(uint32_t state) {
+    switch (biton32(state)) {
+    case _RAISE:
+        rgblight_setrgb (0x00,  0x00, 0xFF);
+        break;
+    case _LOWER:
+        rgblight_setrgb (0xFF,  0x00, 0x00);
+        break;
+    case _PLOVER:
+        rgblight_setrgb (0x00,  0xFF, 0x00);
+        break;
+    case _ADJUST:
+        rgblight_setrgb (0x7A,  0x00, 0xFF);
+        break;
+    default: //  for any other layers, or the default layer
+        rgblight_setrgb (0x00,  0xFF, 0xFF);
+        break;
+    }
+  return state;
+}
+```
+### `layer_state_set_*` Function Documentation
+
+* Keyboard/Revision: `void uint32_t layer_state_set_kb(uint32_t state)`
+* Keymap: `uint32_t layer_state_set_user(uint32_t state)`
+
+The `state` is the bitmask of the active layers, as explained in the [Keymap Overview](keymap.md#keymap-layer-status)

docs/documentation_best_practices.md

@@ -4,7 +4,7 @@ This page exists to document best practices when writing documentation for QMK.
 
 # Page Opening
 
-Your documentation page should generally start with an H1 heading, followed by a 1 paragrah description of what the user will find on this page. Keep in mind that this heading and paragraph will sit next to the Table of Contents, so keep the heading short and avoid long strings with no whitespace.
+Your documentation page should generally start with an H1 heading, followed by a 1 paragraph description of what the user will find on this page. Keep in mind that this heading and paragraph will sit next to the Table of Contents, so keep the heading short and avoid long strings with no whitespace.
 
 Example:
 
@@ -78,7 +78,7 @@ What about an error message?
 
 # Documenting Features
 
-If you create a new feature for QMK, create a documentation page for it. It doesn't have to be very long, a few sentances describing your feature and a table listing any relevant keycodes is enough. Here is a basic template:
+If you create a new feature for QMK, create a documentation page for it. It doesn't have to be very long, a few sentences describing your feature and a table listing any relevant keycodes is enough. Here is a basic template:
 
 ```markdown
 # My Cool Feature

docs/eclipse.md

@@ -1,6 +1,6 @@
-# Setting Up Eclipse for QMK Development
+# Setting up Eclipse for QMK Development
 
-[Eclipse](https://en.wikipedia.org/wiki/Eclipse_(software)) is an open-source [Integrated Development Environment](https://en.wikipedia.org/wiki/Integrated_development_environment) (IDE) widely used for Java development, but with an extensible plugin system that allows to customize it for other languages and usages.
+[Eclipse][1] is an open-source [Integrated Development Environment](https://en.wikipedia.org/wiki/Integrated_development_environment) (IDE) widely used for Java development, but with an extensible plugin system that allows to customize it for other languages and usages.
 
 Using an IDE such as Eclipse provides many advantages over a plain text editor, such as:
 * intelligent code completion
@@ -16,16 +16,16 @@ The purpose of the is page is to document how to set-up Eclipse for developing A
 Note that this set-up has been tested on Ubuntu 16.04 only for the moment.
 
 # Prerequisites
-## Build environment
-Before starting, you must have followed the [Getting Started](home.md#getting-started) section corresponding to your system. In particular, you must have been able to build the firmware with [the `make` command](../#the-make-command).
+## Build Environment
+Before starting, you must have followed the [Getting Started](README.md#getting-started) section corresponding to your system. In particular, you must have been able to build the firmware with [the `make` command](../#the-make-command).
 
 ## Java
 Eclipse is a Java application, so you will need to install Java 8 or more recent to be able to run it. You may choose between the JRE or the JDK, the latter being useful if you intend to do Java development.
 
-# Install Eclipse and its plugins
+# Install Eclipse and Its Plugins
 Eclipse comes in [several flavours](http://www.eclipse.org/downloads/eclipse-packages/) depending on the target usage that you will have. There is no package comprising the AVR stack, so we will need to start from Eclipse CDT (C/C++ Development Tooling) and install the necessary plugins.
 
-## Download and install Eclipse CDT
+## Download and Install Eclipse CDT
 If you already have Eclipse CDT on your system, you can skip this step. However it is advised to keep it up-to-date for better support.
 
 If you have another Eclipse package installed, it is normally possible to [install the CDT plugin over it](https://eclipse.org/cdt/downloads.php). However it is probably better to reinstall it from scratch to keep it light and avoid the clutter of tools that you don't need for the projects you will be working on.
@@ -41,10 +41,10 @@ When you are prompted with the Workspace Selector, select a directory that will
 
 Once started, click the <kbd>Workbench</kbd> button at the top right to switch to the workbench view (there is a also checkbox at the bottom to skip the welcome screen at startup).
 
-## Install the necessary plugins
+## Install the Necessary Plugins
 Note: you do not need to restart Eclipse after installing each plugin. Simply restart once all plugins are installed.
 
-### [The AVR plugin](http://avr-eclipse.sourceforge.net/)
+### [The AVR Plugin](http://avr-eclipse.sourceforge.net/)
 This is the most important plugin as it will allow Eclipse to _understand_ AVR C code. Follow [the instructions for using the update site](http://avr-eclipse.sourceforge.net/wiki/index.php/Plugin_Download#Update_Site), and agree with the security warning for unsigned content.
 
 ### [ANSI Escape in Console](https://marketplace.eclipse.org/content/ansi-escape-console)
@@ -58,7 +58,7 @@ This plugin is necessary to properly display the colored build output generated
 Once both plugins are installed, restart Eclipse as prompted.
 
 # Configure Eclipse for QMK
-## Importing the project
+## Importing the Project
 1. Click <kbd><kbd>File</kbd> > <kbd>New</kbd> > <kbd>Makefile Project with Existing Code</kbd></kbd>
 2. On the next screen:
   * Select the directory where you cloned the repository as _Existing Code Location_;
@@ -72,7 +72,7 @@ Once both plugins are installed, restart Eclipse as prompted.
 
 ¹ There might be issues for importing the project with a custom name. If it does not work properly, try leaving the default project name (i.e. the name of the directory, probably `qmk_firmware`).
 
-## Build your keyboard
+## Build Your Keyboard
 We will now configure a make target that cleans the project and builds the keymap of your choice.
 
 1. On the right side of the screen, select the <kbd>Make Target</kbd> tab
@@ -84,3 +84,5 @@ We will now configure a make target that cleans the project and builds the keyma
 7. (Optional) Toggle the <kbd>Hide Empty Folders</kbd> icon button above the targets tree to only show your build target.
 8. Double-click the build target you created to trigger a build.
 9. Select the <kbd>Console</kbd> view at the bottom to view the running build.
+
+  [1]: https://en.wikipedia.org/wiki/Eclipse_(software)

docs/faq_build.md

@@ -1,40 +1,25 @@
 # Frequently Asked Build Questions
 
-This page covers questions about building QMK. If you have not yet you should read the [Build Environment Setup](getting_started_build_tools.md) and [Make Instructions](make_instructions.md) guides.
+This page covers questions about building QMK. If you haven't yet done so, you should read the [Build Environment Setup](getting_started_build_tools.md) and [Make Instructions](getting_started_make_guide.md) guides.
 
-## Can't program on Linux
-You will need proper permission to operate a device. For Linux users see udev rules below. Easy way is to use `sudo` command, if you are not familiar with this command check its manual with `man sudo` or this page on line.
+## Can't Program on Linux
+You will need proper permissions to operate a device. For Linux users, see the instructions regarding `udev` rules, below. If you have issues with `udev`, a work-around is to use the `sudo` command. If you are not familiar with this command, check its manual with `man sudo` or [see this webpage](https://linux.die.net/man/8/sudo).
+
+An example of using `sudo`, when your controller is ATMega32u4:
 
-In short when your controller is ATMega32u4,
-    
     $ sudo dfu-programmer atmega32u4 erase --force
     $ sudo dfu-programmer atmega32u4 flash your.hex
     $ sudo dfu-programmer atmega32u4 reset
 
-or just
+or just:
 
     $ sudo make <keyboard>:<keymap>:dfu
 
-But to run `make` with root privilege is not good idea. Use former method if possible.
-
-## WINAVR is obsolete
-It is no longer recommended and may cause some problem.
-See [TMK Issue #99](https://github.com/tmk/tmk_keyboard/issues/99).
-
-## USB VID and PID
-You can use any ID you want with editing `config.h`. Using any presumably unused ID will be no problem in fact except for very low chance of collision with other product.
-
-Most boards in QMK use `0xFEED` as the vendor ID. You should look through other keyboards to make sure you pick a unique Product ID.
-
-Also see this.
-https://github.com/tmk/tmk_keyboard/issues/150
+Note that running `make` with `sudo` is generally *not* a good idea, and you should use one of the former methods, if possible.
 
-You can buy a really unique VID:PID here. I don't think you need this for personal use.
-- http://www.obdev.at/products/vusb/license.html
-- http://www.mcselec.com/index.php?page=shop.product_details&flypage=shop.flypage&product_id=92&option=com_phpshop&Itemid=1
-
-## Linux udev rules
-On Linux you need proper privilege to access device file of MCU, you'll have to use `sudo` when flashing firmware. You can circumvent this with placing these files in `/etc/udev/rules.d/`.
+## Linux `udev` Rules
+On Linux, you'll need proper privileges to access the MCU. You can either use
+`sudo` when flashing firmware, or place these files in `/etc/udev/rules.d/`.
 
 **/etc/udev/rules.d/50-atmel-dfu.rules:**
 ```
@@ -52,8 +37,23 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2ff0", MODE:="066
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
 ```
 
+## WINAVR is Obsolete
+It is no longer recommended and may cause some problem.
+See [TMK Issue #99](https://github.com/tmk/tmk_keyboard/issues/99).
+
+## USB VID and PID
+You can use any ID you want with editing `config.h`. Using any presumably unused ID will be no problem in fact except for very low chance of collision with other product.
+
+Most boards in QMK use `0xFEED` as the vendor ID. You should look through other keyboards to make sure you pick a unique Product ID.
+
+Also see this.
+https://github.com/tmk/tmk_keyboard/issues/150
+
+You can buy a really unique VID:PID here. I don't think you need this for personal use.
+- http://www.obdev.at/products/vusb/license.html
+- http://www.mcselec.com/index.php?page=shop.product_details&flypage=shop.flypage&product_id=92&option=com_phpshop&Itemid=1
 
-## Cortex: cstddef: No such file or directory
+## Cortex: `cstddef: No such file or directory`
 GCC 4.8 of Ubuntu 14.04 had this problem and had to update to 4.9 with this PPA.
 https://launchpad.net/~terry.guo/+archive/ubuntu/gcc-arm-embedded
 
@@ -61,8 +61,7 @@ https://github.com/tmk/tmk_keyboard/issues/212
 https://github.com/tmk/tmk_keyboard/wiki/mbed-cortex-porting#compile-error-cstddef
 https://developer.mbed.org/forum/mbed/topic/5205/
 
-
-## `clock_prescale_set` and `clock_div_1` not available
+## `clock_prescale_set` and `clock_div_1` Not Available
 Your toolchain is too old to support the MCU. For example WinAVR 20100110 doesn't support ATMega32u2.
 
 ```
@@ -81,11 +80,27 @@ make: *** [obj_alps64/protocol/lufa/lufa.o] Error 1
 Note that Teensy2.0++ bootloader size is 2048byte. Some Makefiles may have wrong comment.
 
 ```
-# Boot Section Size in *bytes*    
-#   Teensy halfKay   512          
-#   Teensy++ halfKay 2048         
+# Boot Section Size in *bytes*
+#   Teensy halfKay   512
+#   Teensy++ halfKay 2048
 #   Atmel DFU loader 4096       (TMK Alt Controller)
-#   LUFA bootloader  4096         
-#   USBaspLoader     2048         
+#   LUFA bootloader  4096
+#   USBaspLoader     2048
 OPT_DEFS += -DBOOTLOADER_SIZE=2048
 ```
+
+## `avr-gcc: internal compiler error: Abort trap: 6 (program cc1)` on MacOS
+This is an issue with updating on brew, causing symlinks that avr-gcc depend on getting mangled. 
+
+The solution is to remove and reinstall all affected modules. 
+
+```
+brew rm avr-gcc
+brew rm dfu-programmer
+brew rm gcc-arm-none-eabi
+brew rm avrdude
+brew install avr-gcc
+brew install dfu-programmer
+brew install gcc-arm-none-eabi
+brew install avrdude
+```

docs/faq_debug.md

@@ -4,14 +4,14 @@ This page details various common questions people have about troubleshooting the
 
 # Debug Console
 
-## hid_listen can't recognize device
+## `hid_listen` Can't Recognize Device
 When debug console of your device is not ready you will see like this:
 
 ```
 Waiting for device:.........
 ```
 
-once the device is pluged in then *hid_listen* finds it you will get this message:
+once the device is plugged in then *hid_listen* finds it you will get this message:
 
 ```
 Waiting for new device:.........................
@@ -23,7 +23,7 @@ If you can't get this 'Listening:' message try building with `CONSOLE_ENABLE=yes
 You may need privilege to access the device on OS like Linux.
 - try `sudo hid_listen`
 
-## Can't get message on console
+## Can't Get Message on Console
 Check:
 - *hid_listen* finds your device. See above.
 - Enable debug with pressing **Magic**+d. See [Magic Commands](https://github.com/tmk/tmk_keyboard#magic-commands).
@@ -31,7 +31,7 @@ Check:
 - try using 'print' function instead of debug print. See **common/print.h**.
 - disconnect other devices with console function. See [Issue #97](https://github.com/tmk/tmk_keyboard/issues/97).
 
-## Linux or UNIX like system requires Super User privilege
+## Linux or UNIX Like System Requires Super User Privilege
 Just use 'sudo' to execute *hid_listen* with privilege.
 ```
 $ sudo hid_listen
@@ -82,46 +82,46 @@ Size after:
     consume extra memory; watch out for BOOTMAGIC_ENABLE,
     MOUSEKEY_ENABLE, EXTRAKEY_ENABLE, CONSOLE_ENABLE, API_SYSEX_ENABLE
 - DFU tools do /not/ allow you to write into the bootloader (unless
-  you throw in extra fruitsalad of options), so there is little risk
+  you throw in extra fruit salad of options), so there is little risk
   there.
 - EEPROM has around a 100000 write cycle.  You shouldn't rewrite the
   firmware repeatedly and continually; that'll burn the EEPROM
   eventually.
 ## NKRO Doesn't work
-First you have to compile frimware with this build option `NKRO_ENABLE` in **Makefile**.
+First you have to compile firmware with this build option `NKRO_ENABLE` in **Makefile**.
 
 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 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.
+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 kept over power cycles.
 
 https://github.com/tmk/tmk_keyboard#boot-magic-configuration---virtual-dip-switch
 
 
-## TrackPoint needs reset circuit(PS/2 mouse support)
-Without reset circuit you will have inconsistent reuslt due to improper initialize of the hardware. See circuit schematic of TPM754.
+## TrackPoint Needs Reset Circuit (PS/2 Mouse Support)
+Without reset circuit you will have inconsistent result due to improper initialize of the hardware. See circuit schematic of TPM754.
 
 - http://geekhack.org/index.php?topic=50176.msg1127447#msg1127447
 - http://www.mikrocontroller.net/attachment/52583/tpm754.pdf
 
 
-## Can't read column of matrix beyond 16 
+## Can't Read Column of Matrix Beyond 16
 Use `1UL<<16` instead of `1<<16` in `read_cols()` in [matrix.h] when your columns goes beyond 16.
 
-In C `1` means one of [int] type which is [16bit] in case of AVR so you can't shift left more than 15. You will get unexpected zero when you say `1<<16`. You have to use [unsigned long] type with `1UL`.
+In C `1` means one of [int] type which is [16 bit] in case of AVR so you can't shift left more than 15. You will get unexpected zero when you say `1<<16`. You have to use [unsigned long] type with `1UL`.
 
 http://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
 
 
-## Bootloader jump doesn't work
+## Bootloader Jump Doesn't Work
 Properly configure bootloader size in **Makefile**. With wrong section size bootloader won't probably start with **Magic command** and **Boot Magic**.
 ```
 # Size of Bootloaders in bytes:
-#   Atmel DFU loader(ATmega32U4)   4096    
-#   Atmel DFU loader(AT90USB128)   8192    
-#   LUFA bootloader(ATmega32U4)    4096             
-#   Arduino Caterina(ATmega32U4)   4096             
-#   USBaspLoader(ATmega***)        2048             
-#   Teensy   halfKay(ATmega32U4)   512              
+#   Atmel DFU loader(ATmega32U4)   4096
+#   Atmel DFU loader(AT90USB128)   8192
+#   LUFA bootloader(ATmega32U4)    4096
+#   Arduino Caterina(ATmega32U4)   4096
+#   USBaspLoader(ATmega***)        2048
+#   Teensy   halfKay(ATmega32U4)   512
 #   Teensy++ halfKay(AT90USB128)   2048
 OPT_DEFS += -DBOOTLOADER_SIZE=4096
 ```
@@ -135,14 +135,14 @@ byte     Atmel/LUFA(ATMega32u4)          byte     Atmel(AT90SUB1286)
          |               |                        |               |
          |               |                        |               |
          |  Application  |                        |  Application  |
-         |               |                        |               | 
+         |               |                        |               |
          =               =                        =               =
          |               | 32KB-4KB               |               | 128KB-8KB
 0x6000   +---------------+               0x1E000  +---------------+
          |  Bootloader   | 4KB                    |  Bootloader   | 8KB
 0x7FFF   +---------------+               0x1FFFF  +---------------+
 
- 
+
 byte     Teensy(ATMega32u4)              byte     Teensy++(AT90SUB1286)
 0x0000   +---------------+               0x00000  +---------------+
          |               |                        |               |
@@ -161,14 +161,14 @@ https://github.com/tmk/tmk_keyboard/issues/179
 
 If you are using a TeensyUSB, there is a [known bug](https://github.com/qmk/qmk_firmware/issues/164) in which the hardware reset button prevents the RESET key from working. Unplugging the keyboard and plugging it back in should resolve the problem.
 
-## Special Extra key doesn't work(System, Audio control keys)
+## Special Extra Key Doesn't Work (System, Audio Control Keys)
 You need to define `EXTRAKEY_ENABLE` in `rules.mk` to use them in QMK.
 
 ```
 EXTRAKEY_ENABLE = yes          # Audio control and System control
 ```
 
-## Wakeup from sleep doesn't work
+## Wakeup from Sleep Doesn't Work
 
 In Windows check `Allow this device to wake the computer` setting in Power **Management property** tab of **Device Manager**. Also check BIOS setting.
 
@@ -181,11 +181,11 @@ Pressing any key during sleep should wake host.
 - http://arduino.cc/en/uploads/Main/arduino-leonardo-schematic_3b.pdf
 - http://arduino.cc/en/uploads/Main/arduino-micro-schematic.pdf
 
-Arduino leonardo and micro have **ATMega32U4** and can be used for TMK, though Arduino bootloader may be a problem.
+Arduino Leonardo and micro have **ATMega32U4** and can be used for TMK, though Arduino bootloader may be a problem.
 
 
-## Using PF4-7 pins of USB AVR?
-You need to set JTD bit of MCUCR yourself to use PF4-7 as GPIO. Those pins are configured to serve JTAG function by default. MCUs like ATMega*U* or AT90USB* are affeteced with this.
+## Using PF4-7 Pins of USB AVR?
+You need to set JTD bit of MCUCR yourself to use PF4-7 as GPIO. Those pins are configured to serve JTAG function by default. MCUs like ATMega*U* or AT90USB* are affected with this.
 
 If you are using Teensy this isn't needed. Teensy is shipped with JTAGEN fuse bit unprogrammed to disable the function.
 
@@ -200,7 +200,7 @@ https://github.com/tmk/tmk_keyboard/blob/master/keyboard/hbkb/matrix.c#L67
 And read **26.5.1 MCU Control Register – MCUCR** of ATMega32U4 datasheet.
 
 
-## Adding LED indicators of Lock keys
+## Adding LED Indicators of Lock Keys
 You need your own LED indicators for CapsLock, ScrollLock and NumLock? See this post.
 
 http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-120.html#p191560
@@ -218,26 +218,26 @@ http://arduino.cc/en/Main/ArduinoBoardMicro
 https://geekhack.org/index.php?topic=14290.msg1563867#msg1563867
 
 
-## USB 3 compatibility
+## USB 3 Compatibility
 I heard some people have a problem with USB 3 port, try USB 2 port.
 
 
-## Mac compatibility
+## Mac Compatibility
 ### OS X 10.11 and Hub
 https://geekhack.org/index.php?topic=14290.msg1884034#msg1884034
 
 
-## Problem on BIOS(UEFI)/Resume(Sleep&Wake)/Power cycles
+## Problem on BIOS (UEFI)/Resume (Sleep & Wake)/Power Cycles
 Some people reported their keyboard stops working on BIOS and/or after resume(power cycles).
 
-As of now root of its cause is not clear but some build options seem to be related. In Makefile try to disable those options like `CONSOLE_ENABLE`, `NKRO_ENABLE`, `SLEEP_LED_ENABLE` and/or others. 
+As of now root of its cause is not clear but some build options seem to be related. In Makefile try to disable those options like `CONSOLE_ENABLE`, `NKRO_ENABLE`, `SLEEP_LED_ENABLE` and/or others.
 
 https://github.com/tmk/tmk_keyboard/issues/266
 https://geekhack.org/index.php?topic=41989.msg1967778#msg1967778
 
 
 
-## FLIP doesn't work
-### AtLibUsbDfu.dll not found
+## FLIP Doesn't Work
+### `AtLibUsbDfu.dll` Not Found
 Remove current driver and reinstall one FLIP provides from DeviceManager.
 http://imgur.com/a/bnwzy

docs/faq_general.md

@@ -4,7 +4,7 @@
 
 [QMK](https://github.com/qmk), short for Quantum Mechanical Keyboard, is a group of people building tools for custom keyboards. We started with the [QMK firmware](https://github.com/qmk/qmk_firmware), a heavily modified fork of [TMK](https://github.com/tmk/tmk_keyboard).
 
-### Why the name Quantum?
+### Why the Name Quantum?
 
 <!-- FIXME -->
 
@@ -17,4 +17,3 @@ From a technical standpoint QMK builds upon TMK by adding several new features.
 From a project and community management standpoint TMK maintains all the officially supported keyboards by himself, with a bit of community support. Separate community maintained forks exist or can be created for other keyboards. Only a few keymaps are provided by default, so users typically don't share keymaps with each other. QMK encourages sharing of both keyboards and keymaps through a centrally managed repository, accepting all pull requests that follow the quality standards. These are mostly community maintained, but the QMK team also helps when necessary.
 
 Both approaches have their merits and their drawbacks, and code flows freely between TMK and QMK when it makes sense.
-

docs/faq_keymap.md

@@ -7,48 +7,57 @@ See [Keycodes](keycodes.md) for an index of keycodes available to you. These lin
 
 Keycodes are actually defined in [common/keycode.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keycode.h).
 
-## What Are The Default Keycodes?
+## What Are the Default Keycodes?
 
 There are 3 standard keyboard layouts in use around the world- ANSI, ISO, and JIS. North America primarily uses ANSI, Europe and Africa primarily use ISO, and Japan uses JIS. Regions not mentioned typically use either ANSI or ISO. The keycodes corresponding to these layouts are shown here:
 
 <!-- Source for this image: http://www.keyboard-layout-editor.com/#/gists/9ce023dc6caadc0cf11c88c782350a8c -->
 ![Keyboard Layout Image](https://i.imgur.com/45m4mRf.png)
 
+## Some Of My Keys Are Swapped Or Not Working
+
+QMK has two features, Bootmagic and Command, which allow you to change the behavior of your keyboard on the fly. This includes, but is not limited to, swapping Ctrl/Caps, disabling Gui, swapping Alt/Gui, swapping Backspace/Backslash, disabling all keys, and other behavioral modifications. 
+
+As a quick fix try holding down `Space`+`Backspace` while you plug in your keyboard. This will reset the stored settings on your keyboard, returning those keys to normal operation. If that doesn't work look here:
+
+* [Bootmagic](feature_bootmagic.md)
+* [Command](feature_command.md) 
+
 ## The Menu Key Isn't Working
 
 The key found on most modern keyboards that is located between `KC_RGUI` and `KC_RCTL` is actually called `KC_APP`. This is because when that key was invented there was already a key named `MENU` in the relevant standards, so MS chose to call that the `APP` key.
 
-## `KC_SYSREQ` isn't working
+## `KC_SYSREQ` Isn't Working
 Use keycode for Print Screen(`KC_PSCREEN` or `KC_PSCR`) instead of `KC_SYSREQ`. Key combination of 'Alt + Print Screen' is recognized as 'System request'.
 
 See [issue #168](https://github.com/tmk/tmk_keyboard/issues/168) and
-- http://en.wikipedia.org/wiki/Magic_SysRq_key
-- http://en.wikipedia.org/wiki/System_request
+* http://en.wikipedia.org/wiki/Magic_SysRq_key
+* http://en.wikipedia.org/wiki/System_request
 
-## Power key doesn't work
+## Power Key Doesn't Work
 Use `KC_PWR` instead of `KC_POWER` or vice versa.
-- `KC_PWR` works with Windows and Linux, not with OSX.
-- `KC_POWER` works with OSX and Linux, not with Windows.
+* `KC_PWR` works with Windows and Linux, not with OSX.
+* `KC_POWER` works with OSX and Linux, not with Windows.
 
 More info: http://geekhack.org/index.php?topic=14290.msg1327264#msg1327264
 
-## Oneshot modifier
-Solves my personal 'the' problem. I often got 'the' or 'THe' wrongly instead of 'The'.  Oneshot Shift mitgates this for me.
+## One Shot Modifier
+Solves my personal 'the' problem. I often got 'the' or 'THe' wrongly instead of 'The'.  One Shot Shift mitigates this for me.
 https://github.com/tmk/tmk_keyboard/issues/67
 
-## Modifier/Layer stuck
+## Modifier/Layer Stuck
 Modifier keys or layers can be stuck unless layer switching is configured properly.
 For Modifier keys and layer actions you have to place `KC_TRANS` on same position of destination layer to  unregister the modifier key or return to previous layer on release event.
 
-- https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#31-momentary-switching
-- http://geekhack.org/index.php?topic=57008.msg1492604#msg1492604
-- https://github.com/tmk/tmk_keyboard/issues/248
+* https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#31-momentary-switching
+* http://geekhack.org/index.php?topic=57008.msg1492604#msg1492604
+* https://github.com/tmk/tmk_keyboard/issues/248
 
 
 ## Mechanical Lock Switch Support
 
 This feature is for *mechanical lock switch* like [this Alps one](http://deskthority.net/wiki/Alps_SKCL_Lock). You can enable it by adding this to your `config.h`:
- 
+
 ```
 #define LOCKING_SUPPORT_ENABLE
 #define LOCKING_RESYNC_ENABLE
@@ -58,7 +67,7 @@ After enabling this feature use keycodes `KC_LCAP`, `KC_LNUM` and `KC_LSCR` in y
 
 Old vintage mechanical keyboards occasionally have lock switches but modern ones don't have. ***You don't need this feature in most case and just use keycodes `KC_CAPS`, `KC_NLCK` and `KC_SLCK`.***
 
-## Input special charactors other than ASCII like Cédille 'Ç'
+## Input Special Characters Other Than ASCII like Cédille 'Ç'
 NO UNIVERSAL METHOD TO INPUT THOSE WORKS OVER ALL SYSTEMS. You have to define **MACRO** in way specific to your OS or layout.
 
 See this post for example **MACRO** code.
@@ -66,20 +75,20 @@ See this post for example **MACRO** code.
 http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-120.html#p195620
 
 On **Windows** you can use `AltGr` key or **Alt code**.
-- http://en.wikipedia.org/wiki/AltGr_key
-- http://en.wikipedia.org/wiki/Alt_code
+* http://en.wikipedia.org/wiki/AltGr_key
+* http://en.wikipedia.org/wiki/Alt_code
 
 On **Mac** OS defines `Option` key combinations.
-- http://en.wikipedia.org/wiki/Option_key#Alternative_keyboard_input
+* http://en.wikipedia.org/wiki/Option_key#Alternative_keyboard_input
 
 On **Xorg** you can use `compose` key, instead.
-- http://en.wikipedia.org/wiki/Compose_key
+* http://en.wikipedia.org/wiki/Compose_key
 
 And see this for **Unicode** input.
-- http://en.wikipedia.org/wiki/Unicode_input
+* http://en.wikipedia.org/wiki/Unicode_input
 
 
-## Apple/Mac keyboard Fn
+## Apple/Mac Keyboard `Fn`
 Not supported.
 
 Apple/Mac keyboard sends keycode for Fn unlike most of other keyboards.
@@ -88,13 +97,13 @@ I think you can send Apple Fn key using Apple venter specific Page 0xff01 and us
 https://opensource.apple.com/source/IOHIDFamily/IOHIDFamily-606.1.7/IOHIDFamily/AppleHIDUsageTables.h
 
 
-## Media control keys in Mac OSX
-#### KC_MNXT and KC_MPRV does not work on Mac
+## Media Control Keys in Mac OSX
+#### KC_MNXT and KC_MPRV Does Not Work on Mac
 Use `KC_MFFD`(`KC_MEDIA_FAST_FORWARD`) and `KC_MRWD`(`KC_MEDIA_REWIND`) instead of `KC_MNXT` and `KC_MPRV`.
 See https://github.com/tmk/tmk_keyboard/issues/195
 
 
-## Keys supported in Mac OSX?
+## Keys Supported in Mac OSX?
 You can know which keycodes are supported in OSX from this source code.
 
 `usb_2_adb_keymap` array maps Keyboard/Keypad Page usages to ADB scancodes(OSX internal keycodes).
@@ -106,7 +115,7 @@ And `IOHIDConsumer::dispatchConsumerEvent` handles Consumer page usages.
 https://opensource.apple.com/source/IOHIDFamily/IOHIDFamily-606.1.7/IOHIDFamily/IOHIDConsumer.cpp
 
 
-## JIS keys in Mac OSX
+## JIS Keys in Mac OSX
 Japanese JIS keyboard specific keys like `無変換(Muhenkan)`, `変換(Henkan)`, `ひらがな(hiragana)` are not recognized on OSX. You can use **Seil** to enable those keys, try following options.
 
 * Enable NFER Key on PC keyboard
@@ -116,23 +125,21 @@ Japanese JIS keyboard specific keys like `無変換(Muhenkan)`, `変換(Henkan)`
 https://pqrs.org/osx/karabiner/seil.html
 
 
-## RN-42 Bluetooth doesn't work with Karabiner
+## RN-42 Bluetooth Doesn't Work with Karabiner
 Karabiner - Keymapping tool on Mac OSX - ignores inputs from RN-42 module by default. You have to enable this option to make Karabiner working with your keyboard.
 https://github.com/tekezo/Karabiner/issues/403#issuecomment-102559237
 
-See these for the deail of this problem.
+See these for the detail of this problem.
 https://github.com/tmk/tmk_keyboard/issues/213
 https://github.com/tekezo/Karabiner/issues/403
 
 
-## Esc and `~ on a key
-
-Use `GRAVE_ESC` or `KC_GESC` in your keymap. `GUI`+`GRAVE_ESC` results in `` ` `` and `SHIFT`+`GRAVE_ESC` results in `~`.
+## Esc and <code>&#96;</code> on a Single Key
 
-Note that this will break the CTRL+SHIFT+ESC shortcut to the Windows task manager. Use `#define GRAVE_ESC_CTRL_OVERRIDE` in your `config.h` to get the shortcut back. With this option, `ESC_GRAVE` results in `ESC` if `CTRL` is held, even if `SHIFT` or `GUI` are also held.
+See the [Grave Escape](feature_grave_esc.md) feature.
 
-## Arrow on Right Modifier keys with Dual-Role
-This turns right modifer keys into arrow keys when the keys are tapped while still modifiers when the keys are hold. In TMK the dual-role function is dubbed **TAP**.
+## Arrow on Right Modifier Keys with Dual-Role
+This turns right modifier keys into arrow keys when the keys are tapped while still modifiers when the keys are hold. In TMK the dual-role function is dubbed **TAP**.
 ```
 
 #include "keymap_common.h"
@@ -183,18 +190,18 @@ It seems Windows 10 ignores the code and Linux/Xorg recognizes but has no mappin
 Not sure what keycode Eject is on genuine Apple keyboard actually. HHKB uses `F20` for Eject key(`Fn+f`) on Mac mode but this is not same as Apple Eject keycode probably.
 
 
-## What's weak_mods and real_mods in action_util.c
+## What's `weak_mods` and `real_mods` in `action_util.c`
 ___TO BE IMPROVED___
 
 real_mods is intended to retains state of real/physical modifier key state, while
-weak_mods retains state of virtual or temprary modifiers which should not affect state real modifier key.
+weak_mods retains state of virtual or temporary modifiers which should not affect state real modifier key.
 
-Let's say you hold down physical left shift key and type ACTION_MODS_KEY(LSHIFT, KC_A), 
+Let's say you hold down physical left shift key and type ACTION_MODS_KEY(LSHIFT, KC_A),
 
 with weak_mods,
 * (1) hold down left shift: real_mods |= MOD_BIT(LSHIFT)
 * (2) press ACTION_MODS_KEY(LSHIFT, KC_A): weak_mods |= MOD_BIT(LSHIFT)
-* (3) release ACTION_MODS_KEY(LSHIFT, KC_A): waek_mods &= ~MOD_BIT(LSHIFT)
+* (3) release ACTION_MODS_KEY(LSHIFT, KC_A): weak_mods &= ~MOD_BIT(LSHIFT)
 real_mods still keeps modifier state.
 
 without weak mods,
@@ -206,7 +213,7 @@ here real_mods lost state for 'physical left shift'.
 weak_mods is ORed with real_mods when keyboard report is sent.
 https://github.com/tmk/tmk_core/blob/master/common/action_util.c#L57
 
-## Timer functionality
+## Timer Functionality
 
 It's possible to start timers and read values for time-specific events - here's an example:
 

docs/feature_advanced_keycodes.md

@@ -13,21 +13,23 @@ People often define custom names using `#define`. For example:
 
 This will allow you to use `FN_CAPS` and `ALT_TAB` in your `KEYMAP()`, keeping it more readable.
 
-### Limits of these aliases
+### Limits of These Aliases
 
-Currently, the keycodes able to used with these functions are limited to the [Basic Keycodes](keycodes_basic.html), meaning you can't use keycodes like `KC_TILD`, or anything greater than 0xFF. For a full list of the keycodes able to be used see [Basic Keycodes](keycodes_basic.html).
+Currently, the keycodes able to used with these functions are limited to the [Basic Keycodes](keycodes_basic.md), meaning you can't use keycodes like `KC_TILD`, or anything greater than 0xFF. For a full list of the keycodes able to be used see [Basic Keycodes](keycodes_basic.md).
 
-# Switching and toggling layers
+# Switching and Toggling Layers
 
-These functions allow you to activate layers in various ways.
+These functions allow you to activate layers in various ways. Note that layers are not generally independent layouts -- multiple layers can be activated at once, and it's typical for layers to use `KC_TRNS` to allow keypresses to pass through to lower layers. For a detailed explanation of layers, see [Keymap Overview](keymap.md#keymap-and-layers)
 
-* `MO(layer)` - momentary switch to *layer*. As soon as you let go of the key, the layer is deactivated and you pop back out to the previous layer.
-* `LT(layer, kc)` - momentary switch to *layer* when held, and *kc* when tapped.
-* `TG(layer)` - toggles a layer on or off.
-* `TO(layer)` - Goes to a layer. This code is special, because it lets you go either up or down the stack -- just goes directly to the layer you want. So while other codes only let you go _up_ the stack (from layer 0 to layer 3, for example), `TO(2)` is going to get you to layer 2, no matter where you activate it from -- even if you're currently on layer 5. This gets activated on keydown (as soon as the key is pressed).
-* `TT(layer)` - Layer Tap-Toggle. If you hold the key down, the layer becomes active, and then deactivates when you let go. And if you tap it, the layer simply becomes active (toggles on). It needs 5 taps by default, but you can set it by defining `TAPPING_TOGGLE`, for example, `#define TAPPING_TOGGLE 2` for just two taps.
+* `DF(layer)` - switches the default layer. The default layer is the always-active base layer that other layers stack on top of. See below for more about the default layer. This might be used to switch from QWERTY to Dvorak layout. (Note that this is a temporary switch that only persists until the keyboard loses power. To modify the default layer in a persistent way requires deeper customization, such as calling the `set_single_persistent_default_layer` function inside of [process_record_user](custom_quantum_functions.md#programming-the-behavior-of-any-keycode).)
+* `MO(layer)` - momentarily activates *layer*. As soon as you let go of the key, the layer is deactivated. 
+* `LM(layer, mod)` - Momentarily activates *layer* (like `MO`), but with modifier(s) *mod* active. Only supports layers 0-15 and the left modifiers.
+* `LT(layer, kc)` - momentarily activates *layer* when held, and sends *kc* when tapped.
+* `TG(layer)` - toggles *layer*, activating it if it's inactive and vice versa
+* `TO(layer)` - activates *layer* and de-activates all other layers (except your default layer). This function is special, because instead of just adding/removing one layer to your active layer stack, it will completely replace your current active layers, uniquely allowing you to replace higher layers with a lower one. This is activated on keydown (as soon as the key is pressed).
+* `TT(layer)` - Layer Tap-Toggle. If you hold the key down, *layer* is activated, and then is de-activated when you let go (like `MO`). If you repeatedly tap it, the layer will be toggled on or off (like `TG`). It needs 5 taps by default, but you can change this by defining `TAPPING_TOGGLE` -- for example, `#define TAPPING_TOGGLE 2` to toggle on just two taps.
 
-# Working With Layers
+# Working with Layers
 
 Care must be taken when switching layers, it's possible to lock yourself into a layer with no way to deactivate that layer (without unplugging your keyboard.) We've created some guidelines to help users avoid the most common problems.
 
@@ -35,13 +37,13 @@ Care must be taken when switching layers, it's possible to lock yourself into a
 
 If you are just getting started with QMK you will want to keep everything simple. Follow these guidelines when setting up your layers:
 
-* Setup layer 0 as your "base" layer. This is your normal typing layer, and could be whatever layout you want (qwerty, dvorak, colemak, etc.)
+* Setup layer 0 as your default, "base" layer. This is your normal typing layer, and could be whatever layout you want (qwerty, dvorak, colemak, etc.). It's important to set this as the lowest layer since it will typically have most or all of the keyboard's keys defined, so would block other layers from having any effect if it were above them (i.e., had a higher layer number). 
 * Arrange your layers in a "tree" layout, with layer 0 as the root. Do not try to enter the same layer from more than one other layer.
-* Never try to stack a higher numbered layer on top of a lower numbered layer. Doing so is tricky and error prone.
+* In a layer's keymap, only reference higher-numbered layers. Because layers are processed from the highest-numbered (topmost) active layer down, modifying the state of lower layers can be tricky and error-prone.
 
 ### Intermediate Users
 
-Sometimes you need more than one base layer. For example, if you want to switch between QWERTY and Dvorak, switch between layouts for different countries, or switch your layout for different videogames. Your base layers should always be the lowest numbered layers. When you have multiple base layers you should always treat them as mutually exclusive. When one base layer is on the others are off. 
+Sometimes you need more than one base layer. For example, if you want to switch between QWERTY and Dvorak, switch between layouts for different countries, or switch your layout for different videogames. Your base layers should always be the lowest numbered layers. When you have multiple base layers you should always treat them as mutually exclusive. When one base layer is on the others are off.
 
 ### Advanced Users
 
@@ -49,9 +51,9 @@ Once you have a good feel for how layers work and what you can do, you can get m
 
 Layers stack on top of each other in numerical order. When determining what a keypress does, QMK scans the layers from the top down, stopping when it reaches the first active layer that is not set to `KC_TRNS`. As a result if you activate a layer that is numerically lower than your current layer, and your current layer (or another layer that is active and higher than your target layer) has something other than `KC_TRNS`, that is the key that will be sent, not the key on the layer you just activated. This is the cause of most people's "why doesn't my layer get switched" problem.
 
-Sometimes, you might want to switch between layers in a macro or as part of a tap dance routine. `layer_on` activates a layer, and `layer_off` deactivates it. More layer-related functions can be found in [action_layer.h](../tmk_core/common/action_layer.h).
+Sometimes, you might want to switch between layers in a macro or as part of a tap dance routine. `layer_on` activates a layer, and `layer_off` deactivates it. More layer-related functions can be found in [action_layer.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action_layer.h).
 
-# Modifier keys
+# Modifier Keys
 
 These functions allow you to combine a mod with a keycode. When pressed the keydown for the mod will be sent first, and then *kc* will be sent. When released the keyup for *kc* will be sent and then the mod will be sent.
 
@@ -75,29 +77,29 @@ You can also chain these, like this:
 
 The following shortcuts automatically add `LSFT()` to keycodes to get commonly used symbols.
 
-|Name|Description|
-|----|-----------|
-| KC_TILD | ~ |
-| KC_EXLM | ! |
-| KC_QUES | ? |
-| KC_AT | @ |
-| KC_HASH | # |
-| KC_DLR  | $ |
-| KC_PERC | % |
-| KC_CIRC | ^ |
-| KC_AMPR | & |
-| KC_ASTR | * |
-| KC_LPRN | ( |
-| KC_RPRN | ) |
-| KC_UNDS | _ |
-| KC_PLUS | + |
-| KC_DQUO | " |
-| KC_LCBR | { |
-| KC_RCBR | } |
-| KC_LABK | < |
-| KC_RABK | > |
-| KC_PIPE | &#x7C; |
-| KC_COLN | : |
+|Key                     |Aliases           |Description        |
+|------------------------|------------------|-------------------|
+|`KC_TILDE`              |`KC_TILD`         |`~`                |
+|`KC_EXCLAIM`            |`KC_EXLM`         |`!`                |
+|`KC_AT`                 |                  |`@`                |
+|`KC_HASH`               |                  |`#`                |
+|`KC_DOLLAR`             |`KC_DLR`          |`$`                |
+|`KC_PERCENT`            |`KC_PERC`         |`%`                |
+|`KC_CIRCUMFLEX`         |`KC_CIRC`         |`^`                |
+|`KC_AMPERSAND`          |`KC_AMPR`         |`&`                |
+|`KC_ASTERISK`           |`KC_ASTR`         |`*`                |
+|`KC_LEFT_PAREN`         |`KC_LPRN`         |`(`                |
+|`KC_RIGHT_PAREN`        |`KC_RPRN`         |`)`                |
+|`KC_UNDERSCORE`         |`KC_UNDS`         |`_`                |
+|`KC_PLUS`               |                  |`+`                |
+|`KC_LEFT_CURLY_BRACE`   |`KC_LCBR`         |`{`                |
+|`KC_RIGHT_CURLY_BRACE`  |`KC_RCBR`         |`}`                |
+|`KC_PIPE`               |                  |<code>&#124;</code>|
+|`KC_COLON`              |`KC_COLN`         |`:`                |
+|`KC_DOUBLE_QUOTE`       |`KC_DQT`/`KC_DQUO`|`"`                |
+|`KC_LEFT_ANGLE_BRACKET` |`KC_LT`/`KC_LABK` |`<`                |
+|`KC_RIGHT_ANGLE_BRACKET`|`KC_GT`/`KC_RABK` |`>`                |
+|`KC_QUESTION`           |`KC_QUES`         |`?`                |
 
 # Mod Tap
 
@@ -116,7 +118,7 @@ These are the values you can use for the `mod` in `MT()` and `OSM()`:
   * MOD_HYPR
   * MOD_MEH
 
-These can also be combined like `MOD_LCTL | MOD_LSFT` e.g. `MT(MOD_LCTL | MOD_LSFT, KC_ESC)` which would activate Control and Shift when held, and send Escape when tapped. Note however, that you cannot mix right and left side modifiers.
+These can also be combined like `MOD_LCTL | MOD_LSFT` e.g. `MT(MOD_LCTL | MOD_LSFT, KC_ESC)` which would activate Control and Shift when held, and send Escape when tapped.
 
 We've added shortcuts to make common modifier/tap (mod-tap) mappings more compact:
 
@@ -129,9 +131,15 @@ We've added shortcuts to make common modifier/tap (mod-tap) mappings more compac
   * `LCAG_T(kc)` - is CtrlAltGui when held and *kc* when tapped
   * `MEH_T(kc)` - is like Hyper, but not as cool -- does not include the Cmd/Win key, so just sends Alt+Ctrl+Shift.
 
+{% hint style='info' %}
+Due to the way that keycodes are structured, any modifiers specified as part of `kc`, such as `LCTL()` or `KC_LPRN`, will only activate when held instead of tapped.
+
+Additionally, if there is at least one right modifier, any other modifiers will turn into their right equivalents, so it is not possible to "mix and match" the two.
+{% endhint %}
+
 # One Shot Keys
 
-One shot keys are keys that remain active until the next key is pressed, and then are releasd. This allows you to type keyboard combinations without pressing more than one key at a time.
+One shot keys are keys that remain active until the next key is pressed, and then are released. This allows you to type keyboard combinations without pressing more than one key at a time. These keys are usually called "Sticky keys" or "Dead keys".
 
 For example, if you define a key as `OSM(MOD_LSFT)`, you can type a capital A character by first pressing and releasing shift, and then pressing and releasing A. Your computer will see the shift key being held the moment shift is pressed, and it will see the shift key being released immediately after A is released.
 
@@ -147,9 +155,11 @@ You can control the behavior of one shot keys by defining these in `config.h`:
 * `OSM(mod)` - Momentarily hold down *mod*. You must use the `MOD_*` keycodes as shown in [Mod Tap](#mod-tap), not the `KC_*` codes.
 * `OSL(layer)` - momentary switch to *layer*.
 
-Sometimes, you want to activate a one-shot layer as part of a macro or tap dance routine. To do this, you need to call `set_oneshot_layer(LAYER, ONESHOT_START)` on key down, and `set_oneshot_layer(ONESHOT_PRESSED)` on key up. If you want to cancel the oneshot, call `reset_oneshot_layer()`. For more complicated actions, take a look at the oneshot implementation in [`process_record`](../tmk_core/common/action.c#L429).
+Sometimes, you want to activate a one-shot layer as part of a macro or tap dance routine. To do this, you need to call `set_oneshot_layer(LAYER, ONESHOT_START)` on key down, and `set_oneshot_layer(ONESHOT_PRESSED)` on key up. If you want to cancel the oneshot, call `reset_oneshot_layer()`. For more complicated actions, take a look at the oneshot implementation in [`process_record`](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action.c#L429).
+
+If you're having issues with OSM translating over Remote Desktop Connection, this can be fixed by opening the settings, going to the "Local Resources" tap, and in the keyboard section, change the drop down to "On this Computer".  This will fix the issue and allow OSM to function properly over Remote Desktop.
 
-## Permissive Hold
+# Permissive Hold
 
 As of [PR#1359](https://github.com/qmk/qmk_firmware/pull/1359/), there is a new `config.h` option:
 

docs/feature_audio.md

@@ -1,6 +1,17 @@
 # Audio
 
-Your keyboard can make sounds! If you've got a Planck, Preonic, or basically any AVR keyboard that allows access to the C6 or B5 port (`#define C6_AUDIO` and/or `#define B5_AUDIO`), you can hook up a simple speaker and make it beep. You can use those beeps to indicate layer transitions, modifiers, special keys, or just to play some funky 8bit tunes.
+Your keyboard can make sounds! If you've got a Planck, Preonic, or basically any AVR keyboard that allows access to certain PWM-capable pins, you can hook up a simple speaker and make it beep. You can use those beeps to indicate layer transitions, modifiers, special keys, or just to play some funky 8bit tunes.
+
+Up to two simultaneous audio voices are supported, one driven by timer 1 and another driven by timer 3.  The following pins can be defined as audio outputs in config.h:
+Timer 1:
+`#define B5_AUDIO`
+`#define B6_AUDIO`
+`#define B7_AUDIO`
+
+Timer 3:
+`#define C4_AUDIO`
+`#define C5_AUDIO`
+`#define C6_AUDIO`
 
 If you add `AUDIO_ENABLE = yes` to your `rules.mk`, there's a couple different sounds that will automatically be enabled without any other configuration:
 
@@ -47,9 +58,9 @@ PLAY_LOOP(my_song);
 
 It's advised that you wrap all audio features in `#ifdef AUDIO_ENABLE` / `#endif` to avoid causing problems when audio isn't built into the keyboard.
 
-## Music mode
+## Music Mode
 
-The music mode maps your columns to a chromatic scale, and your rows to octaves. This works best with ortholinear keyboards, but can be made to work with others. All keycodes less than `0xFF` get blocked, so you won't type while playing notes - if you have special keys/mods, those will still work. A work-around for this is to jump to a different layer with KC_NOs before (or after) enabling music mode.  
+The music mode maps your columns to a chromatic scale, and your rows to octaves. This works best with ortholinear keyboards, but can be made to work with others. All keycodes less than `0xFF` get blocked, so you won't type while playing notes - if you have special keys/mods, those will still work. A work-around for this is to jump to a different layer with KC_NOs before (or after) enabling music mode.
 
 Recording is experimental due to some memory issues - if you experience some weird behavior, unplugging/replugging your keyboard will fix things.
 
@@ -82,7 +93,41 @@ The pitch standard (`PITCH_STANDARD_A`) is 440.0f by default - to change this, a
 
     #define PITCH_STANDARD_A 432.0f
 
-## MIDI functionalty
+You can completely disable Music Mode as well. This is useful, if you're pressed for space on your controller.  To disable it, add this to your `config.h`:
+
+    #define NO_MUSIC_MODE
+
+## Faux Click
+
+This adds a click sound each time you hit a button, to simulate click sounds from the keyboard. And the sounds are slightly different for each keypress, so it doesn't sound like a single long note, if you type rapidly. 
+
+* `CK_TOGG` - Toggles the status (will play sound if enabled)
+* `CK_RST` - Resets the frequency to the default state 
+* `CK_UP` - Increases the frequency of the clicks
+* `CK_DOWN` - Decreases the frequency of the clicks
+
+The feature is disabled by default, to save space.  To enable it, add this to your `config.h`:
+
+    #define AUDIO_CLICKY
+
+Additionally, even when enabled, the feature is not enabled by default, so you would need to turn it on first.  And since we don't use EEPROM to store the setting (yet), you can default this to on by adding this to your `config.h`:
+
+    #define AUDIO_CLICKY_ON
+
+You can configure the default, min and max frequencies, the stepping and built in randomness by defining these values: 
+
+| Option | Default Value | Description |
+|--------|---------------|-------------|
+| `AUDIO_CLICKY_FREQ_DEFAULT` | 440.0f | Sets the default/starting audio frequency for the clicky sounds. |
+| `AUDIO_CLICKY_FREQ_MIN` | 65.0f | Sets the lowest frequency (under 60f are a bit buggy). |
+| `AUDIO_CLICKY_FREQ_MAX` | 1500.0f | Sets the the highest frequency. Too high may result in coworkers attacking you. |
+| `AUDIO_CLICKY_FREQ_FACTOR` | 1.18921f| Sets the stepping of UP/DOWN key codes. |
+| `AUDIO_CLICKY_FREQ_RANDOMNESS`     |  0.05f |  Sets a factor of randomness for the clicks, Setting this to `0f` will make each click identical. | 
+
+
+
+
+## MIDI Functionality
 
 This is still a WIP, but check out `quantum/keymap_midi.c` to see what's happening. Enable from the Makefile.
 

docs/feature_auto_shift.md

@@ -1,7 +1,7 @@
-# Auto Shift: Why do we need a shift key?
+# Auto Shift: Why Do We Need a Shift Key?
 
 Tap a key and you get its character. Tap a key, but hold it *slightly* longer
-and you get its shifted state. Viola! No shift key needed!
+and you get its shifted state. Voilà! No shift key needed!
 
 ## Why Auto Shift?
 
@@ -10,7 +10,7 @@ fingers repetitively long distances. For us on the keyboard, the pinky does that
 all too often when reaching for the shift key. Auto Shift looks to alleviate that
 problem.
 
-## How does it work?
+## How Does It Work?
 
 When you tap a key, it stays depressed for a short period of time before it is
 then released. This depressed time is a different length for everyone. Auto Shift
@@ -20,7 +20,7 @@ when you release the key. If the time depressed is greater than or equal to the
 `AUTO_SHIFT_TIMEOUT`, then a shifted version of the key is emitted. If the time
 is less than the `AUTO_SHIFT_TIMEOUT` time, then the normal state is emitted.
 
-## Are there limitations to Auto Shift?
+## Are There Limitations to Auto Shift?
 
 Yes, unfortunately.
 
@@ -28,17 +28,14 @@ Yes, unfortunately.
    characters, you could press and hold the 'a' key for a second or two. This no
    longer works with Auto Shift because it is timing your depressed time instead
    of emitting a depressed key state to your operating system.
-2. Auto Shift is disabled for any key press that is accompanied by one or more
-   modifiers. Thus, Ctrl+A that you hold for a really long time is not the same
-   as Ctrl+Shift+A.
-3. You will have characters that are shifted when you did not intend on shifting, and
+2. You will have characters that are shifted when you did not intend on shifting, and
    other characters you wanted shifted, but were not. This simply comes down to
    practice. As we get in a hurry, we think we have hit the key long enough
    for a shifted version, but we did not. On the other hand, we may think we are
    tapping the keys, but really we have held it for a little longer than
    anticipated.
 
-## How do I enable Auto Shift?
+## How Do I Enable Auto Shift?
 
 Add to your `rules.mk` in the keymap folder:
 
@@ -48,6 +45,18 @@ If no `rules.mk` exists, you can create one.
 
 Then compile and install your new firmware with Auto Key enabled! That's it!
 
+## Modifiers
+
+By default, Auto Shift is disabled for any key press that is accompanied by one or more
+modifiers. Thus, Ctrl+A that you hold for a really long time is not the same
+as Ctrl+Shift+A.
+
+You can re-enable Auto Shift for modifiers by adding another rule to your `rules.mk`
+
+    AUTO_SHIFT_MODIFIERS = yes
+
+In which case, Ctrl+A held past the `AUTO_SHIFT_TIMEOUT` will be sent as Ctrl+Shift+A
+
 ## Configuring Auto Shift
 
 If desired, there is some configuration that can be done to change the
@@ -66,7 +75,7 @@ A sample is
 
     #endif
 
-### AUTO_SHIFT_TIMEOUT (value in ms)
+### AUTO_SHIFT_TIMEOUT (Value in ms)
 
 This controls how long you have to hold a key before you get the shifted state.
 Obviously, this is different for everyone. For the common person, a setting of
@@ -75,7 +84,7 @@ is the default value. Then work down from there. The idea is to have the shortes
 
 Play with this value until things are perfect. Many find that all will work well
 at a given value, but one or two keys will still emit the shifted state on
-occassion. This is simply due to habit and holding some keys a little longer
+occasion. This is simply due to habit and holding some keys a little longer
 than others. Once you find this value, work on tapping your problem keys a little
 quicker than normal and you will be set.
 
@@ -86,7 +95,7 @@ quick. See "Auto Shift Setup" for more details!
 
 ### NO_AUTO_SHIFT_SPECIAL (simple define)
 
-Do not Auto Shift special keys, which include -_, =+, [{, ]}, ;:, '", ,<, .>,
+Do not Auto Shift special keys, which include -\_, =+, [{, ]}, ;:, '", ,<, .>,
 and /?
 
 ### NO_AUTO_SHIFT_NUMERIC (simple define)
@@ -99,7 +108,7 @@ Do not Auto Shift alpha characters, which include A through Z.
 
 ## Using Auto Shift Setup
 
-This will enable you to define three keys temporailiy to increase, decrease and report your `AUTO_SHIFT_TIMEOUT`.
+This will enable you to define three keys temporarily to increase, decrease and report your `AUTO_SHIFT_TIMEOUT`.
 
 ### Setup
 
@@ -110,6 +119,9 @@ Map three keys temporarily in your keymap:
 | KC_ASDN  | Lower the Auto Shift timeout variable (down)        |
 | KC_ASUP  | Raise the Auto Shift timeout variable (up)          |
 | KC_ASRP  | Report your current Auto Shift timeout value        |
+| KC_ASON  | Turns on the Auto Shift Function                    |
+| KC_ASOFF | Turns off the Auto Shift Function                   |
+| KC_ASTG  | Toggles the state of the Auto Shift feature         |
 
 Compile and upload your new firmware.
 
@@ -134,7 +146,7 @@ completely normal and with no intention of shifted keys.
 9. Remove the key bindings `KC_ASDN`, `KC_ASUP` and `KC_ASRP`.
 10. Compile and upload your new firmware.
 
-#### An example run
+#### An Example Run
 
     hello world. my name is john doe. i am a computer programmer playing with
     keyboards right now.
@@ -155,4 +167,4 @@ completely normal and with no intention of shifted keys.
 
 The keyboard typed `115` which represents your current `AUTO_SHIFT_TIMEOUT`
 value. You are now set! Practice on the *D* key a little bit that showed up
-in the testing and you'll be golden.
+in the testing and you'll be golden.

docs/feature_backlight.md

@@ -6,12 +6,34 @@
 
 These keycodes control the backlight. Most keyboards use this for single color in-switch lighting.
 
-|Name|Description|
-|----|-----------|
-|`BL_x`|Set a specific backlight level between 0-9|
-|`BL_ON`|An alias for `BL_9`|
-|`BL_OFF`|An alias for `BL_0`|
-|`BL_DEC`|Turn the backlight level down by 1|
-|`BL_INC`|Turn the backlight level up by 1|
-|`BL_TOGG`|Toggle the backlight on or off|
-|`BL_STEP`|Step through backlight levels, wrapping around to 0 when you reach the top.|
+|Key      |Description                               |
+|---------|------------------------------------------|
+|`BL_TOGG`|Turn the backlight on or off              |
+|`BL_STEP`|Cycle through backlight levels            |
+|`BL_ON`  |Set the backlight to max brightness       |
+|`BL_OFF` |Turn the backlight off                    |
+|`BL_INC` |Increase the backlight level              |
+|`BL_DEC` |Decrease the backlight level              |
+|`BL_BRTG`|Toggle backlight breathing                |
+
+Note that for backlight breathing, you need to have `#define BACKLIGHT_BREATHING` in your config.h.
+
+## Configuration Options in `config.h`
+
+* `BACKLIGHT_PIN B7` defines the pin that controlls the LEDs. Unless you design your own keyboard, you don't need to set this.
+* `BACKLIGHT_LEVELS 3` defines the number of brightness levels (maximum 15 excluding off).
+* `BACKLIGHT_BREATHING` if defined, enables backlight breathing. Note that this is only available if `BACKLIGHT_PIN` is B5, B6 or B7.
+* `BREATHING_PERIOD 6` defines the length of one backlight "breath" in seconds.
+
+## Notes on Implementation
+
+To change the brightness when using pins B5, B6 or B7, the PWM (Pulse Width Modulation) functionality of the on-chip timer is used.
+The timer is a counter that counts up to a certain TOP value (`0xFFFF` set in ICR1) before resetting to 0.
+We also set an OCR1x register.
+When the counter reaches the value stored in that register, the PWM pin drops to low.
+The PWM pin is pulled high again when the counter resets to 0.
+Therefore, OCR1x basically sets the duty cycle of the LEDs and as such the brightness where `0` is the darkest and `0xFFFF` the brightest setting.
+
+To enable the breathing effect, we register an interrupt handler to be called whenever the counter resets (with `ISR(TIMER1_OVF_vect)`).
+In this handler, which gets called roughly 244 times per second, we compute the desired brightness using a precomputed brightness curve.
+To disable breathing, we can just disable the respective interrupt vector and reset the brightness to the desired level.

docs/feature_bluetooth.md

@@ -1,6 +1,6 @@
 # Bluetooth
 
-## Bluetooth functionality
+## Bluetooth Functionality
 
 This requires [some hardware changes](https://www.reddit.com/r/MechanicalKeyboards/comments/3psx0q/the_planck_keyboard_with_bluetooth_guide_and/?ref=search_posts), but can be enabled via the Makefile. The firmware will still output characters via USB, so be aware of this when charging via a computer. It would make sense to have a switch on the Bluefruit to turn it off at will.
 
@@ -10,8 +10,8 @@ This requires [some hardware changes](https://www.reddit.com/r/MechanicalKeyboar
 
 This is used when multiple keyboard outputs can be selected. Currently this only allows for switching between USB and Bluetooth on keyboards that support both.
 
-|Name|Description|
-|----|-----------|
-|`OUT_AUTO`|auto mode|
-|`OUT_USB`|usb only|
-|`OUT_BT`|bluetooth|
+|Name      |Description                                   |
+|----------|----------------------------------------------|
+|`OUT_AUTO`|Automatically switch between USB and Bluetooth|
+|`OUT_USB` |USB only                                      |
+|`OUT_BT`  |Bluetooth only                                |

docs/feature_bootmagic.md

@@ -1,29 +1,89 @@
-# Bootmagic
-
-<!-- FIXME: Describe the bootmagic feature here. -->
-
-## Bootmagic Keycodes
-
-Shortcuts for bootmagic options. You can use these even when bootmagic is off.
-
-|Name|Description|
-|----|-----------|
-|`MAGIC_SWAP_CONTROL_CAPSLOCK`|Swap Capslock and Left Control|
-|`MAGIC_CAPSLOCK_TO_CONTROL`|Treat Capslock like a Control Key|
-|`MAGIC_SWAP_LALT_LGUI`|Swap the left Alt and GUI keys|
-|`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 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|
-|`MAGIC_UNCAPSLOCK_TO_CONTROL`|Disable treating Capslock like Control |
-|`MAGIC_UNSWAP_LALT_LGUI`|Disable Left Alt and GUI switching|
-|`MAGIC_UNSWAP_RALT_RGUI`|Disable Right Alt and GUI switching|
-|`MAGIC_UNNO_GUI`|Enable the GUI key |
-|`MAGIC_UNSWAP_GRAVE_ESC`|Disable the Grave/Esc swap |
-|`MAGIC_UNSWAP_BACKSLASH_BACKSPACE`|Disable the backslash/backspace swap|
-|`MAGIC_UNHOST_NKRO`|Force NKRO off|
-|`MAGIC_UNSWAP_ALT_GUI`/`AG_NORM`|Disable the Alt/GUI switching|
-|`MAGIC_TOGGLE_NKRO`|Turn NKRO on or off|
+# Bootmagic and Magic Keycodes
+
+There are 3 separate but related features that allow you to change the behavior of your keyboard without reflashing. While each of them have similar functionality you access that functionality in different ways depending on how your keyboard is configured.
+
+Bootmagic is a system for configuring your keyboard while it initializes. To trigger a Bootmagic command you hold down the bootmagic key (`KC_SPACE` on most keyboards) and one or more command keys.
+
+Bootmagic Keycodes allow you to access the Bootmagic functionality after your keyboard has initialized. To use Bootmagic Keycodes you assign keycodes starting with `MAGIC_`, much in the same way you define any other key.
+
+Command is a feature that allows you to control different aspects of your keyboard. Command used to be called Magic. Command is typically accessed by holding Left and Right Shift at the same time, although that can be customized. While it shares some functionality with Bootmagic it also allows you to access functionality that Bootmagic does not. For more information see the [Command](feature_command.md) documentation page.
+
+## Enabling Bootmagic
+
+Bootmagic is disabled by default. To use Bootmagic you need to enable it in your `rules.mk` file:
+
+    BOOTMAGIC_ENABLE = yes
+
+## Bootmagic Hotkeys and Keycodes
+
+This table describes the default Hotkeys for Bootmagic and the Keycodes for Magic. These may be overriden at the Keyboard or Keymap level. Some functionality is not available in both methods.
+
+To use the Hotkey hold down `BOOTMAGIC_KEY_SALT` (`KC_SPACE` by default) and the Hotkey while plugging in your keyboard. To use the Keycode assign that keycode to a layer. For example, if you hold down Space+B while plugging in most keyboards, you will enter bootloader mode.
+
+|Hotkey     |Keycode                           |Description                                             |
+|-----------|----------------------------------|--------------------------------------------------------|
+|`ESC`      |                                  |Skip bootmagic and saved eeprom configuration           |
+|`B`        |`RESET`                           |Enter bootloader instead of firmware                    |
+|`D`        |`DEBUG`                           |Enable debugging (writes messages to serial)            |
+|`X`        |                                  |Enable matrix debugging                                 |
+|`K`        |                                  |Enable keyboard debugging                               |
+|`M`        |                                  |Enable mouse debugging                                  |
+|`BACKSPACE`|                                  |Clear the saved settings from flash                     |
+|`CAPSLOCK` |`MAGIC_CAPSLOCK_TO_CONTROL`       |Treat `Capslock` as `Control`                           |
+|           |`MAGIC_UNCAPSLOCK_TO_CONTROL`     |Stop treating CapsLock as Control                       |
+|`LCTRL`    |`MAGIC_SWAP_CONTROL_CAPSLOCK`     |Swap `Control` and `Capslock`                           |
+|           |`MAGIC_UNSWAP_CONTROL_CAPSLOCK`   |Unswap Left Control and Caps Lock                       |
+|           |`MAGIC_SWAP_ALT_GUI`              |Swap Alt and GUI on both sides                          |
+|           |`MAGIC_UNSWAP_ALT_GUI`            |Unswap Left Alt and GUI                                 |
+|`LALT`     |`MAGIC_SWAP_LALT_LGUI`            |Swap Left `Alt` and `GUI`, e.g. for OSX Opt and Cmd     |
+|           |`MAGIC_UNSWAP_LALT_LGUI`          |Unswap Left Alt and GUI                                 |
+|`RALT`     |`MAGIC_SWAP_RALT_RGUI`            |Swap Right `Alt` and `GUI`                              |
+|           |`MAGIC_UNSWAP_RALT_RGUI`          |Unswap Right Alt and GUI                                |
+|`LGUI`     |`MAGIC_NO_GUI`                    |Disable GUI key - e.g. disable Windows key during gaming|
+|           |`MAGIC_UNNO_GUI`                  |Enable the GUI key                                      |
+|`GRAVE`    |`MAGIC_SWAP_GRAVE_ESC`            |Swap `\`~` and `ESC`                                    |
+|           |`MAGIC_UNSWAP_GRAVE_ESC`          |Unswap `\`~` and Escape                                 |
+|`BACKSLASH`|`MAGIC_SWAP_BACKSLASH_BACKSPACE`  |Swap Blackslash and Backspace                           |
+|           |`MAGIC_UNSWAP_BACKSLASH_BACKSPACE`|Unswap Backslash and Backspace                          |
+|`N`        |`MAGIC_HOST_NKRO`                 |Force N-Key Rollover (NKRO) on                          |
+|           |`MAGIC_UNHOST_NKRO`               |Force NKRO off                                          |
+|           |`MAGIC_TOGGLE_NKRO`               |Toggle NKRO on or off                                   |
+|`0`        |`DF(0)`                           |Make Layer 0 the default layer at bootup                |
+|`1`        |`DF(1)`                           |Make Layer 1 the default layer at bootup                |
+|`2`        |`DF(2)`                           |Make Layer 2 the default layer at bootup                |
+|`3`        |`DF(3)`                           |Make Layer 3 the default layer at bootup                |
+|`4`        |`DF(4)`                           |Make Layer 4 the default layer at bootup                |
+|`5`        |`DF(5)`                           |Make Layer 5 the default layer at bootup                |
+|`6`        |`DF(6)`                           |Make Layer 6 the default layer at bootup                |
+|`7`        |`DF(7)`                           |Make Layer 7 the default layer at bootup                |
+
+## Bootmagic Configuration
+
+When setting up your keyboard and/or keymap there are a number of `#define`s that control the behavior of Bootmagic. To use these put them in your `config.h`, either at the keyboard or keymap level.
+
+|Define |Default|Description |
+|-------|-------|------------|
+|`BOOTMAGIC_KEY_SALT`|`KC_SPACE`|The key to hold down to trigger Bootmagic during initialization.|
+|`BOOTMAGIC_KEY_SKIP`|`KC_ESC`|The Hotkey to ignore saved eeprom configuration.|
+|`BOOTMAGIC_KEY_EEPROM_CLEAR`|`KC_BSPACE`|The hotkey to clear the saved eeprom configuration.|
+|`BOOTMAGIC_KEY_BOOTLOADER`|`KC_B`|The hotkey to enter the bootloader.|
+|`BOOTMAGIC_KEY_DEBUG_ENABLE`|`KC_D`|The hotkey to enable debug mode.|
+|`BOOTMAGIC_KEY_DEBUG_MATRIX`|`KC_X`|The hotkey to enable matrix debugging mode.|
+|`BOOTMAGIC_KEY_DEBUG_KEYBOARD`|`KC_K`|The hotkey to enable keyboard debugging mode.|
+|`BOOTMAGIC_KEY_DEBUG_MOUSE`|`KC_M`|The hotkey to enable mouse debugging mode.|
+|`BOOTMAGIC_KEY_SWAP_CONTROL_CAPSLOCK`|`KC_LCTRL`||
+|`BOOTMAGIC_KEY_CAPSLOCK_TO_CONTROL`|`KC_CAPSLOCK`||
+|`BOOTMAGIC_KEY_SWAP_LALT_LGUI`|`KC_LALT`||
+|`BOOTMAGIC_KEY_SWAP_RALT_RGUI`|`KC_RALT`||
+|`BOOTMAGIC_KEY_NO_GUI`|`KC_LGUI`||
+|`BOOTMAGIC_KEY_SWAP_GRAVE_ESC`|`KC_GRAVE`||
+|`BOOTMAGIC_KEY_SWAP_BACKSLASH_BACKSPACE`|`KC_BSLASH`||
+|`BOOTMAGIC_HOST_NKRO`|`KC_N`||
+|`BOOTMAGIC_KEY_DEFAULT_LAYER_0`|`KC_0`|Hotkey to set Layer 0 as the default layer|
+|`BOOTMAGIC_KEY_DEFAULT_LAYER_1`|`KC_1`|Hotkey to set Layer 1 as the default layer|
+|`BOOTMAGIC_KEY_DEFAULT_LAYER_2`|`KC_2`|Hotkey to set Layer 2 as the default layer|
+|`BOOTMAGIC_KEY_DEFAULT_LAYER_3`|`KC_3`|Hotkey to set Layer 3 as the default layer|
+|`BOOTMAGIC_KEY_DEFAULT_LAYER_4`|`KC_4`|Hotkey to set Layer 4 as the default layer|
+|`BOOTMAGIC_KEY_DEFAULT_LAYER_5`|`KC_5`|Hotkey to set Layer 5 as the default layer|
+|`BOOTMAGIC_KEY_DEFAULT_LAYER_6`|`KC_6`|Hotkey to set Layer 6 as the default layer|
+|`BOOTMAGIC_KEY_DEFAULT_LAYER_7`|`KC_7`|Hotkey to set Layer 7 as the default layer|

docs/feature_command.md

@@ -0,0 +1,52 @@
+# Command (Formerly known as Magic)
+
+Command is a way to change your keyboard's behavior without having to flash or unplug it to use [Bootmagic](feature_bootmagic.md). There is a lot of overlap between this functionality and the [Bootmagic Keycodes](feature_bootmagic.md). Whenever possible we encourage you to use that functionality instead of Command.
+
+## Enabling Command
+
+By default Command is disabled. You can enable it in your `rules.mk` file:
+
+    COMMAND_ENABLE = yes
+
+## Usage
+
+To use Command you hold down the key combination defined by `IS_COMMAND`. By default that combination is both shift keys. While holding the key combination press the key corresponding to the command you want.
+
+For example, to write the current QMK version to the QMK Toolbox console, you can press `Left Shift`+`Right Shift`+`V`.
+
+## Configuration
+
+The following values can be defined in `config.h` to control the behavior of Command.
+
+|Define |Default | Description |
+|-------|--------|-------------|
+|`IS_COMMAND()`                      |`(keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)))`|Key combination to activate Command|
+|`MAGIC_KEY_SWITCH_LAYER_WITH_FKEYS` |`true`                                                                |Do layer switching with Function row|
+|`MAGIC_KEY_SWITCH_LAYER_WITH_NKEYS` |`true`                                                                |Do layer switching with number keys.|
+|`MAGIC_KEY_SWITCH_LAYER_WITH_CUSTOM`|`false`                                                               |Do layer switching with custom keys (`MAGIC_KEY_LAYER0..9` below.)|
+|`MAGIC_KEY_HELP1`                   |`H`                                                                   |Show help.|
+|`MAGIC_KEY_HELP2`                   |`SLASH`                                                               |Show help.|
+|`MAGIC_KEY_DEBUG`                   |`D`                                                                   |Turn on debug mode.|
+|`MAGIC_KEY_DEBUG_MATRIX`            |`X`                                                                   |Turn on matrix debugging.|
+|`MAGIC_KEY_DEBUG_KBD`               |`K`                                                                   |Turn on keyboard debugging.|
+|`MAGIC_KEY_DEBUG_MOUSE`             |`M`                                                                   |Turn on mouse debugging.|
+|`MAGIC_KEY_VERSION`                 |`V`                                                                   |Write the QMK version to the console|
+|`MAGIC_KEY_STATUS`                  |`S`                                                                   |Show the current keyboard status|
+|`MAGIC_KEY_CONSOLE`                 |`C`                                                                   |Enable the Command Console|
+|`MAGIC_KEY_LAYER0_ALT1`             |`ESC`                                                                 |Alternate access to layer 0|
+|`MAGIC_KEY_LAYER0_ALT2`             |`GRAVE`                                                               |Alternate access to layer 0|
+|`MAGIC_KEY_LAYER0`                  |`0`                                                                   |Change default layer to 0|
+|`MAGIC_KEY_LAYER1`                  |`1`                                                                   |Change default layer to 1|
+|`MAGIC_KEY_LAYER2`                  |`2`                                                                   |Change default layer to 2|
+|`MAGIC_KEY_LAYER3`                  |`3`                                                                   |Change default layer to 3|
+|`MAGIC_KEY_LAYER4`                  |`4`                                                                   |Change default layer to 4|
+|`MAGIC_KEY_LAYER5`                  |`5`                                                                   |Change default layer to 5|
+|`MAGIC_KEY_LAYER6`                  |`6`                                                                   |Change default layer to 6|
+|`MAGIC_KEY_LAYER7`                  |`7`                                                                   |Change default layer to 7|
+|`MAGIC_KEY_LAYER8`                  |`8`                                                                   |Change default layer to 8|
+|`MAGIC_KEY_LAYER9`                  |`9`                                                                   |Change default layer to 9|
+|`MAGIC_KEY_BOOTLOADER`              |`PAUSE`                                                               |Exit keyboard and enter bootloader|
+|`MAGIC_KEY_LOCK`                    |`CAPS`                                                                |Lock the keyboard so nothing can be typed|
+|`MAGIC_KEY_EEPROM`                  |`E`                                                                   |Erase EEPROM settings|
+|`MAGIC_KEY_NKRO`                    |`N`                                                                   |Toggle NKRO on/off|
+|`MAGIC_KEY_SLEEP_LED`               |`Z`                                                                   |Toggle LED when computer is sleeping on/off|

docs/feature_dynamic_macros.md

@@ -1,4 +1,4 @@
-# Dynamic macros: record and replay macros in runtime
+# Dynamic Macros: Record and Replay Macros in Runtime
 
 QMK supports temporary macros created on the fly. We call these Dynamic Macros. They are defined by the user from the keyboard and are lost when the keyboard is unplugged or otherwise rebooted.
 
@@ -52,7 +52,7 @@ For users of the earlier versions of dynamic macros: It is still possible to fin
 
 ```c
 	uint16_t macro_kc = (keycode == MO(_DYN) ? DYN_REC_STOP : keycode);
-	
+
 	if (!process_record_dynamic_macro(macro_kc, record)) {
 		return false;
 	}

docs/feature_grave_esc.md

@@ -0,0 +1,17 @@
+# Grave Escape
+
+Grave Escape is a feature that allows you to share the grave key (<code>&#96;</code> and `~`) on the same key as Escape. When `KC_GESC` is used it will act as `KC_ESC`, unless Shift or GUI is pressed, in which case it will act as `KC_GRAVE`.
+
+
+|Key      |Aliases    |Description                                                       |
+|---------|-----------|------------------------------------------------------------------|
+|`KC_GESC`|`GRAVE_ESC`|Escape when pressed, <code>&#96;</code> when Shift or GUI are held|
+
+There are several possible key combinations this will break, among them Ctrl+Shift+Esc on Windows and Cmd+Opt+Esc on macOS. You can use these options in your `config.h` to work around this:
+
+| Option | Description |
+|--------|-------------|
+| `GRAVE_ESC_ALT_OVERRIDE` | Always send Escape if Alt is pressed. |
+| `GRAVE_ESC_CTRL_OVERRIDE` | Always send Escape if Ctrl is pressed. |
+| `GRAVE_ESC_GUI_OVERRIDE` | Always send Escape if GUI is pressed. |
+| `GRAVE_ESC_SHIFT_OVERRIDE` | Always send Escape if SHIFT is pressed. |

docs/feature_key_lock.md

@@ -1,4 +1,4 @@
-## Key Lock: Holding down keys for you
+## Key Lock: Holding Down Keys for You
 
 Sometimes, you need to hold down a specific key for a long period of time. Whether this is while typing in ALL CAPS, or playing a video game that hasn't implemented auto-run, Key Lock is here to help. Key Lock adds a new keycode, `KC_LOCK`, that will hold down the next key you hit for you. The key is released when you hit it again. Here's an example: let's say you need to type in all caps for a few sentences. You hit KC_LOCK, and then shift. Now, shift will be considered held until you hit it again. You can think of key lock as caps lock, but supercharged.
 
@@ -8,4 +8,4 @@ Here's how to use it:
 2. Enable key lock by including `KEY_LOCK_ENABLE = yes` in your Makefile.
 3. That's it!
 
-Important: switching layers does not cancel the key lock. Additionally, key lock is only able to hold standard action keys and One Shot modifier keys (for example, if you have your shift defined as `OSM(KC_LSFT)`; see [One Shot Keys](quantum_keycodes.md#one-shot-keys)). This does not include any of the QMK special functions (except One Shot modifiers), or shifted versions of keys such as KC_LPRN. If it's in the [basic_keycodes](basic_keycodes.md) list, it can be held. If it's not, then it can't be.
+Important: switching layers does not cancel the key lock. Additionally, key lock is only able to hold standard action keys and One Shot modifier keys (for example, if you have your shift defined as `OSM(KC_LSFT)`; see [One Shot Keys](quantum_keycodes.md#one-shot-keys)). This does not include any of the QMK special functions (except One Shot modifiers), or shifted versions of keys such as KC_LPRN. If it's in the [Basic Keycodes](keycodes_basic.md) list, it can be held. If it's not, then it can't be.

docs/feature_layouts.md

@@ -1,6 +1,6 @@
-# Layouts: Using a keymap with multiple keyboards
+# Layouts: Using a Keymap with Multiple Keyboards
 
-The `layouts/` folder contains different physical key layouts that can apply to different keyboards. 
+The `layouts/` folder contains different physical key layouts that can apply to different keyboards.
 
 ```
 layouts/
@@ -21,7 +21,7 @@ layouts/
 | + ...
 ```
 
-The `layouts/default/` and `layouts/community/` are two examples of layout "repositories" - currently `default` will contain all of the information concerning the layout, and one default keymap named `default_<layout>`, for users to use as a reference. `community` contains all of the community keymaps, with the eventual goal of being split-off into a separate repo for users to clone into `layouts/`. QMK searches through all folders in `layouts/`, so it's possible to have multiple reposistories here. 
+The `layouts/default/` and `layouts/community/` are two examples of layout "repositories" - currently `default` will contain all of the information concerning the layout, and one default keymap named `default_<layout>`, for users to use as a reference. `community` contains all of the community keymaps, with the eventual goal of being split-off into a separate repo for users to clone into `layouts/`. QMK searches through all folders in `layouts/`, so it's possible to have multiple repositories here.
 
 Each layout folder is named (`[a-z0-9_]`) after the physical aspects of the layout, in the most generic way possible, and contains a `readme.md` with the layout to be defined by the keyboard:
 
@@ -33,12 +33,14 @@ Each layout folder is named (`[a-z0-9_]`) after the physical aspects of the layo
 
 New names should try to stick to the standards set by existing layouts, and can be discussed in the PR/Issue.
 
-## Supporting a layout
+## Supporting a Layout
 
-For a keyboard to support a layout, the variable (`[a-z0-9_]`) must be defined in it's `<keyboard>.h`, and match the number of arguments/keys (and preferrably the physical layout):
+For a keyboard to support a layout, the variable must be defined in it's `<keyboard>.h`, and match the number of arguments/keys (and preferably the physical layout):
 
     #define LAYOUT_60_ansi KEYMAP_ANSI
 
+The name of the layout must match this regex: `[a-z0-9_]+`
+
 The folder name must be added to the keyboard's `rules.mk`:
 
     LAYOUTS = 60_ansi
@@ -49,16 +51,12 @@ The folder name must be added to the keyboard's `rules.mk`:
 
 but the `LAYOUT_<layout>` variable must be defined in `<folder>.h` as well.
 
-## Tips for making layouts keyboard-agnostic
+## Tips for Making Layouts Keyboard-Agnostic
 
 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
 
-In your config.h, you can also use this variable to include the keyboard's `config.h`:
-
-    #include QMK_KEYBOARD_CONFIG_H
-
 If you want to keep some keyboard-specific code, you can use these variables to escape it with an `#ifdef` statement:
 
 * `KEYBOARD_<folder1>_<folder2>`
@@ -73,4 +71,4 @@ For example:
 #endif
 ```
 
-Note that the names are lowercase and match the folder/file names for the keyboard/revision exactly.
+Note that the names are lowercase and match the folder/file names for the keyboard/revision exactly.

docs/feature_leader_key.md

@@ -1,4 +1,4 @@
-# The Leader key: A new kind of modifier
+# The Leader Key: A New Kind of Modifier
 
 If you've ever used Vim, you know what a Leader key is. If not, you're about to discover a wonderful concept. :) Instead of hitting Alt+Shift+W for example (holding down three keys at the same time), what if you could hit a _sequence_ of keys instead? So you'd hit our special modifier (the Leader key), followed by W and then C (just a rapid succession of keys), and something would happen.
 
@@ -34,4 +34,4 @@ void matrix_scan_user(void) {
 }
 ```
 
-As you can see, you have three function. you can use - `SEQ_ONE_KEY` for single-key sequences (Leader followed by just one key), and `SEQ_TWO_KEYS` and `SEQ_THREE_KEYS` for longer sequences. Each of these accepts one or more keycodes as arguments. This is an important point: You can use keycodes from **any layer on your keyboard**. That layer would need to be active for the leader macro to fire, obviously.
+As you can see, you have three function. you can use - `SEQ_ONE_KEY` for single-key sequences (Leader followed by just one key), and `SEQ_TWO_KEYS` and `SEQ_THREE_KEYS` for longer sequences. Each of these accepts one or more keycodes as arguments. This is an important point: You can use keycodes from **any layer on your keyboard**. That layer would need to be active for the leader macro to fire, obviously.

docs/feature_macros.md

@@ -1,41 +1,85 @@
 # Macros
 
-Macros allow you to send multiple keystrokes when pressing just one key. QMK has a number of ways to define and use macros. These can do anything you want: type common phrases for you, copypasta, repetitive game movements, or even help you code. 
+Macros allow you to send multiple keystrokes when pressing just one key. QMK has a number of ways to define and use macros. These can do anything you want: type common phrases for you, copypasta, repetitive game movements, or even help you code.
 
 {% hint style='danger' %}
-**Security Note**: While it is possible to use macros to send passwords, credit card numbers, and other sensitive information it is a supremely bad idea to do so. Anyone who gets ahold of your keyboard will be able to access that information by opening a text editor.
+**Security Note**: While it is possible to use macros to send passwords, credit card numbers, and other sensitive information it is a supremely bad idea to do so. Anyone who gets a hold of your keyboard will be able to access that information by opening a text editor.
 {% endhint %}
 
-## The new way: `SEND_STRING()` & `process_record_user`
+## The New Way: `SEND_STRING()` & `process_record_user`
 
-Sometimes you just want a key to type out words or phrases. For the most common situations we've provided `SEND_STRING()`, which will type out your string for you. All ascii that is easily translated to a keycode is supported (eg `\n\t`).
+Sometimes you just want a key to type out words or phrases. For the most common situations we've provided `SEND_STRING()`, which will type out your string (i.e. a sequence of characters) for you. All ASCII characters that are easily translated to a keycode are supported (e.g. `\n\t`).
 
-For example:
+Here is an example `keymap.c` for a two-key keyboard:
+
+```c
+enum custom_keycodes {
+	MY_CUSTOM_MACRO = SAFE_RANGE
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	if (record->event.pressed) {
+		switch(keycode) {
+			case MY_CUSTOM_MACRO:
+				SEND_STRING("QMK is the best thing ever!"); // this is our macro!
+				return false;
+		}
+	}
+	return true;
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[0] = {
+	  {MY_CUSTOM_MACRO, KC_ESC}
+	}
+};
+```
+
+What happens here is this:
+We first define a new custom keycode in the range not occupied by any other keycodes.
+Then we use the `process_record_user` function, which is called whenever a key is pressed or released, to check if our custom keycode has been activated.
+If yes, we send the string `"QMK is the best thing ever!"` to the computer via the `SEND_STRING` macro (this is a C preprocessor macro, not to be confused with QMK macros).
+We return `false` to indicate to the caller that the key press we just processed need not be processed any further.
+Finally, we define the keymap so that the first button activates our macro and the second button is just an escape button.
+
+You might want to add more than one macro.
+You can do that by adding another keycode and adding another case to the switch statement, like so:
 
 ```c
 enum custom_keycodes {
-	PRINT_TRUTH = SAFE_RANGE
+	MY_CUSTOM_MACRO = SAFE_RANGE,
+	MY_OTHER_MACRO
 };
 
 bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 	if (record->event.pressed) {
 		switch(keycode) {
-			case PRINT_TRUTH:
+			case MY_CUSTOM_MACRO:
 				SEND_STRING("QMK is the best thing ever!");
-				return false; break;
+				return false;
+			case MY_OTHER_MACRO:
+				SEND_STRING(SS_LCTRL("ac")); // selects all and copies
+				return false;
 		}
 	}
 	return true;
 };
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+	[0] = {
+	  {MY_CUSTOM_MACRO, MY_OTHER_MACRO}
+	}
+};
 ```
 
-### Tap/down/up
+### TAP, DOWN and UP
 
-You can send arbitary keycodes by wrapping them in:
+You may want to use keys in your macros that you can't write down, such as `Ctrl` or `Home`.
+You can send arbitrary keycodes by wrapping them in:
 
-* `SS_TAP()`
-* `SS_DOWN()`
-* `SS_UP()`
+* `SS_TAP()` presses and releases a key.
+* `SS_DOWN()` presses (but does not release) a key.
+* `SS_UP()` releases a key.
 
 For example:
 
@@ -52,20 +96,23 @@ There's also a couple of mod shortcuts you can use:
 * `SS_LCTRL(string)`
 * `SS_LGUI(string)`
 * `SS_LALT(string)`
+* `SS_LSFT(string)`
+* `SS_RALT(string)`
 
-That can be used like this:
+These press the respective modifier, send the supplied string and then release the modifier.
+They can be used like this:
 
     SEND_STRING(SS_LCTRL("a"));
 
-Which would send LCTRL+a (LTRL down, a, LTRL up) - notice that they take strings (eg `"k"`), and not the `X_K` keycodes.
+Which would send LCTRL+a (LCTRL down, a, LCTRL up) - notice that they take strings (eg `"k"`), and not the `X_K` keycodes.
 
-### Alternative keymaps
+### Alternative Keymaps
 
 By default, it assumes a US keymap with a QWERTY layout; if you want to change that (e.g. if your OS uses software Colemak), include this somewhere in your keymap:
 
     #include <sendstring_colemak.h>
 
-### Strings in memory
+### Strings in Memory
 
 If for some reason you're manipulating strings and need to print out something you just generated (instead of being a literal, constant string), you can use `send_string()`, like this:
 
@@ -83,7 +130,7 @@ send_string(my_str);
 SEND_STRING(".."SS_TAP(X_END));
 ```
 
-## The old way: `MACRO()` & `action_get_macro`
+## The Old Way: `MACRO()` & `action_get_macro`
 
 {% hint style='info' %}
 This is inherited from TMK, and hasn't been updated - it's recommend that you use `SEND_STRING` and `process_record_user` instead.
@@ -120,7 +167,7 @@ A macro can include the following commands:
 * W() wait (milliseconds).
 * END end mark.
 
-### Mapping a Macro to a key
+### Mapping a Macro to a Key
 
 Use the `M()` function within your `KEYMAP()` to call a macro. For example, here is the keymap for a 2-key keyboard:
 
@@ -146,7 +193,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 
 When you press the key on the left it will type "Hi!" and when you press the key on the right it will type "Bye!".
 
-### Naming your macros
+### Naming Your Macros
 
 If you have a bunch of macros you want to refer to from your keymap while keeping the keymap easily readable you can name them using `#define` at the top of your file.
 
@@ -161,7 +208,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 ```
 
-## Advanced macro functions
+## Advanced Macro Functions
 
 There are some functions you may find useful in macro-writing. Keep in mind that while you can write some fairly advanced code within a macro if your functionality gets too complex you may want to define a custom keycode instead. Macros are meant to be simple.
 
@@ -197,9 +244,9 @@ This will clear all mods currently pressed.
 
 This will clear all keys besides the mods currently pressed.
 
-## Advanced Example: Single-key copy/paste
+## Advanced Example: Single-Key Copy/Paste
 
-This example defines a macro which sends `Ctrl-C` when pressed down, and `Ctrl-V` when released. 
+This example defines a macro which sends `Ctrl-C` when pressed down, and `Ctrl-V` when released.
 
 ```c
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
@@ -216,5 +263,3 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 	return MACRO_NONE;
 };
 ```
-
-

docs/feature_mouse_keys.md

@@ -3,48 +3,48 @@
 
 Mousekeys is a feature that allows you to emulate a mouse using your keyboard. You can move the pointer around, click up to 5 buttons, and even scroll in all 4 directions. QMK uses the same algorithm as the X Window System MouseKeysAccel feature. You can read more about it [on Wikipedia](https://en.wikipedia.org/wiki/Mouse_keys).
 
-## Adding Mousekeys To a Keymap
+## Adding Mousekeys to a Keymap
 
-There are two steps to adding Mousekeys support to your keyboard. You must enable support in the Makefile and you must map mouse actions to keys on your keyboard.
+There are two steps to adding Mousekeys support to your keyboard. You must enable support in the `rules.mk` file and you must map mouse actions to keys on your keyboard.
 
-### Adding Mousekeys support in the `Makefile`
+### Adding Mousekeys Support in the `rules.mk`
 
-To add support for Mousekeys you simply need to add a single line to your keymap's `Makefile`:
+To add support for Mousekeys you simply need to add a single line to your keymap's `rules.mk`:
 
 ```
 MOUSEKEY_ENABLE = yes
 ```
 
-You can see an example here: https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/keymaps/mouse_keys/Makefile
+You can see an example here: https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/66/keymaps/mouse_keys/rules.mk
 
-### Mapping Mouse Actions To Keyboard Keys
+### Mapping Mouse Actions to Keyboard Keys
 
 You can use these keycodes within your keymap to map button presses to mouse actions:
 
-|Long Name|Short Name|Description|
-|---------|----------|-----------|
-|KC_MS_UP|KC_MS_U|Mouse Cursor Up|
-|KC_MS_DOWN|KC_MS_D|Mouse Cursor Down|
-|KC_MS_LEFT|KC_MS_L|Mouse Cursor Left|
-|KC_MS_RIGHT|KC_MS_R|Mouse Cursor Right|
-|KC_MS_BTN1|KC_BTN1|Mouse Button 1|
-|KC_MS_BTN2|KC_BTN2|Mouse Button 2|
-|KC_MS_BTN3|KC_BTN3|Mouse Button 3|
-|KC_MS_BTN4|KC_BTN4|Mouse Button 4|
-|KC_MS_BTN5|KC_BTN5|Mouse Button 5|
-|KC_MS_WH_UP|KC_WH_U|Mouse Wheel Up|
-|KC_MS_WH_DOWN|KC_WH_D|Mouse Wheel Down|
-|KC_MS_WH_LEFT|KC_WH_L|Mouse Wheel Left|
-|KC_MS_WH_RIGHT|KC_WH_R|Mouse Wheel Right|
-|KC_MS_ACCEL0|KC_ACL0|Set Mouse Acceleration Speed to 0|
-|KC_MS_ACCEL1|KC_ACL1|Set Mouse Acceleration Speed to 1|
-|KC_MS_ACCEL2|KC_ACL2|Set Mouse Acceleration Speed to 2|
-
-You can see an example in the `_ML` here: https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/keymaps/mouse_keys/keymap.c#L46
-
-## Configuring the behavior of Mousekeys
-
-The default speed for controlling the mouse with the keyboard is intentionaly slow. You can adjust these parameters by adding these settings to your keymap's `config.h` file. All times are specified in miliseconds (ms).
+|Key             |Aliases  |Description                |
+|----------------|---------|---------------------------|
+|`KC_MS_UP`      |`KC_MS_U`|Mouse Cursor Up            |
+|`KC_MS_DOWN`    |`KC_MS_D`|Mouse Cursor Down          |
+|`KC_MS_LEFT`    |`KC_MS_L`|Mouse Cursor Left          |
+|`KC_MS_RIGHT`   |`KC_MS_R`|Mouse Cursor Right         |
+|`KC_MS_BTN1`    |`KC_BTN1`|Mouse Button 1             |
+|`KC_MS_BTN2`    |`KC_BTN2`|Mouse Button 2             |
+|`KC_MS_BTN3`    |`KC_BTN3`|Mouse Button 3             |
+|`KC_MS_BTN4`    |`KC_BTN4`|Mouse Button 4             |
+|`KC_MS_BTN5`    |`KC_BTN5`|Mouse Button 5             |
+|`KC_MS_WH_UP`   |`KC_WH_U`|Mouse Wheel Up             |
+|`KC_MS_WH_DOWN` |`KC_WH_D`|Mouse Wheel Down           |
+|`KC_MS_WH_LEFT` |`KC_WH_L`|Mouse Wheel Left           |
+|`KC_MS_WH_RIGHT`|`KC_WH_R`|Mouse Wheel Right          |
+|`KC_MS_ACCEL0`  |`KC_ACL0`|Set mouse acceleration to 0|
+|`KC_MS_ACCEL1`  |`KC_ACL1`|Set mouse acceleration to 1|
+|`KC_MS_ACCEL2`  |`KC_ACL2`|Set mouse acceleration to 2|
+
+You can see an example in the `_ML` here: https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/66/keymaps/mouse_keys/keymap.c#L46
+
+## Configuring the Behavior of Mousekeys
+
+The default speed for controlling the mouse with the keyboard is intentionally slow. You can adjust these parameters by adding these settings to your keymap's `config.h` file. All times are specified in milliseconds (ms).
 
 ```
 #define MOUSEKEY_DELAY             300
@@ -78,4 +78,4 @@ The top speed for scrolling movements.
 
 ### `MOUSEKEY_WHEEL_TIME_TO_MAX`
 
-How long you want to hold down a scroll key for until `MOUSEKEY_WHEEL_MAX_SPEED` is reached. This controls how quickling your scrolling will accelerate.
+How long you want to hold down a scroll key for until `MOUSEKEY_WHEEL_MAX_SPEED` is reached. This controls how quickly your scrolling will accelerate.

docs/feature_pointing_device.md

@@ -1,6 +1,6 @@
 ## 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.
+Pointing Device is a generic name for a feature intended to be generic: moving the system pointer around.  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:
 
@@ -44,4 +44,4 @@ case MS_SPECIAL:
     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.
+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

@@ -6,7 +6,7 @@ To hook up a Trackpoint, you need to obtain a Trackpoint module (i.e. harvest fr
 
 There are three available modes for hooking up PS/2 devices: USART (best), interrupts (better) or busywait (not recommended).
 
-### Busywait version
+### Busywait Version
 
 Note: This is not recommended, you may encounter jerky movement or unsent inputs. Please use interrupt or USART version if possible.
 
@@ -32,7 +32,7 @@ In your keyboard config.h:
 #endif
 ```
 
-### Interrupt version
+### Interrupt Version
 
 The following example uses D2 for clock and D5 for data. You can use any INT or PCINT pin for clock, and any pin for data.
 
@@ -70,7 +70,7 @@ In your keyboard config.h:
 #endif
 ```
 
-### USART version
+### USART Version
 
 To use USART on the ATMega32u4, you have to use PD5 for clock and PD2 for data. If one of those are unavailable, you need to use interrupt version.
 
@@ -129,13 +129,13 @@ In your keyboard config.h:
 
 ### Additional Settings
 
-#### PS/2 mouse features
+#### PS/2 Mouse Features
 
 These enable settings supported by the PS/2 mouse protocol: http://www.computer-engineering.org/ps2mouse/
 
 ```
 /* Use remote mode instead of the default stream mode (see link) */
-#define PS2_MOUSE_USE_REMOTE_MODE  
+#define PS2_MOUSE_USE_REMOTE_MODE
 
 /* Enable the scrollwheel or scroll gesture on your mouse or touchpad */
 #define PS2_MOUSE_ENABLE_SCROLLING
@@ -170,7 +170,7 @@ void ps2_mouse_set_resolution(ps2_mouse_resolution_t resolution);
 void ps2_mouse_set_sample_rate(ps2_mouse_sample_rate_t sample_rate);
 ```
 
-#### Fine control
+#### Fine Control
 
 Use the following defines to change the sensitivity and speed of the mouse.
 Note: you can also use `ps2_mouse_set_resolution` for the same effect (not supported on most touchpads).
@@ -181,7 +181,7 @@ Note: you can also use `ps2_mouse_set_resolution` for the same effect (not suppo
 #define PS2_MOUSE_V_MULTIPLIER 1
 ```
 
-#### Scroll button
+#### Scroll Button
 
 If you're using a trackpoint, you will likely want to be able to use it for scrolling.
 Its possible to enable a "scroll button/s" that when pressed will cause the mouse to scroll instead of moving.
@@ -227,7 +227,7 @@ Fine control over the scrolling is supported with the following defines:
 #define PS2_MOUSE_SCROLL_DIVISOR_V 2
 ```
 
-#### Invert mouse and scroll axes
+#### Invert Mouse and Scroll Axes
 
 To invert the X and Y axes you can put:
 
@@ -247,7 +247,7 @@ To reverse the scroll axes you can put:
 
 into config.h.
 
-#### Debug settings
+#### Debug Settings
 
 To debug the mouse, add `debug_mouse = true` or enable via bootmagic.
 

docs/feature_rgblight.md

@@ -41,6 +41,9 @@ You can change the behavior of the RGB Lighting by setting these configuration v
 | `RGBLIGHT_HUE_STEP` | 10 | How many hues you want to have available. |
 | `RGBLIGHT_SAT_STEP` | 17 | How many steps of saturation you'd like. |
 | `RGBLIGHT_VAL_STEP` | 17 | The number of levels of brightness you want. |
+| `RGBLIGHT_LIMIT_VAL` | 255 | Limit the val of HSV to limit the maximum brightness simply. |
+| `RGBLIGHT_SLEEP`     |    |  `#define` this will shut off the lights when the host goes to sleep | 
+
 
 ### Animations
 
@@ -80,29 +83,46 @@ const uint8_t RGBLED_KNIGHT_INTERVALS[] PROGMEM = {127, 63, 31};
 const uint16_t RGBLED_GRADIENT_RANGES[] PROGMEM = {360, 240, 180, 120, 90};
 ```
 
+### LED Control
+
+Look in `rgblights.h` for all available functions, but if you want to control all or some LEDs your goto functions are:
+
+```c
+rgblight_disable();  // turn all lights off
+rgblight_enable();  // turn lights on, based on their previous state (stored in EEPROM)
+
+rgblight_setrgb(r, g, b);  // where r/g/b is a number from 0..255.  Turns all the LEDs to this color
+rgblight_sethsv(h, s, v);  // HSV color control - h is a value from 0..360 and s/v is a value from 0..255
+rgblight_setrgb_at(r,g,b, LED);  // control a single LED.  0 <= LED < RGBLED_NUM
+rgblight_sethsv_at(h,s,v, LED);  // control a single LED.  0 <= LED < RGBLED_NUM
+```
+You can find a list of predefined colors at [`quantum/rgblight_list.h`](https://github.com/qmk/qmk_firmware/blob/master/quantum/rgblight_list.h). Free to add to this list!
+
 ## RGB Lighting Keycodes
 
 These control the RGB Lighting functionality.
 
-| Long Name | Short Name | Description |
-|-----------|------------|-------------|
-||`RGB_TOG`|toggle on/off|
-||`RGB_MOD`|cycle through modes|
-||`RGB_SMOD`|cycle through modes, use reverse direction when shift is hold|
-||`RGB_HUI`|hue increase|
-||`RGB_HUD`|hue decrease|
-||`RGB_SAI`|saturation increase|
-||`RGB_SAD`|saturation decrease|
-||`RGB_VAI`|value (brightness) increase|
-||`RGB_VAD`|value (brightness) decrease|
-|`RGB_MODE_PLAIN`|`RGB_M_P `| Switch to the static no animation mode |
-|`RGB_MODE_BREATHE`|`RGB_M_B`| Switch to the breathing mode |
-|`RGB_MODE_RAINBOW`|`RGB_M_R`| Switch to the rainbow mode ||
-|`RGB_MODE_SWIRL`|`RGB_M_SW`| Switch to the swirl mode |
-|`RGB_MODE_SNAKE`|`RGB_M_SN`| Switch to the snake mode |
-|`RGB_MODE_KNIGHT`|`RGB_M_K`| Switch to the knight animation |
-|`RGB_MODE_XMAS`|`RGB_M_X`| Switch to the Christmas animation |
-|`RGB_MODE_GRADIENT`|`RGB_M_G`| Switch to the static gradient mode |
+|Key                |Aliases   |Description                                                         |
+|-------------------|----------|--------------------------------------------------------------------|
+|`RGB_TOG`          |          |Toggle RGB lighting on or off                                       |
+|`RGB_MODE_FORWARD` |`RGB_MOD` |Cycle through modes, reverse direction when Shift is held           |
+|`RGB_MODE_REVERSE` |`RGB_RMOD`|Cycle through modes in reverse, forward direction when Shift is held|
+|`RGB_HUI`          |          |Increase hue                                                        |
+|`RGB_HUD`          |          |Decrease hue                                                        |
+|`RGB_SAI`          |          |Increase saturation                                                 |
+|`RGB_SAD`          |          |Decrease saturation                                                 |
+|`RGB_VAI`          |          |Increase value (brightness)                                         |
+|`RGB_VAD`          |          |Decrease value (brightness)                                         |
+|`RGB_MODE_PLAIN`   |`RGB_M_P `|Static (no animation) mode                                          |
+|`RGB_MODE_BREATHE` |`RGB_M_B` |Breathing animation mode                                            |
+|`RGB_MODE_RAINBOW` |`RGB_M_R` |Rainbow animation mode                                              |
+|`RGB_MODE_SWIRL`   |`RGB_M_SW`|Swirl animation mode                                                |
+|`RGB_MODE_SNAKE`   |`RGB_M_SN`|Snake animation mode                                                |
+|`RGB_MODE_KNIGHT`  |`RGB_M_K` |"Knight Rider" animation mode                                       |
+|`RGB_MODE_XMAS`    |`RGB_M_X` |Christmas animation mode                                            |
+|`RGB_MODE_GRADIENT`|`RGB_M_G` |Static gradient animation mode                                      |
+
+note: for backwards compatibility, `RGB_SMOD` is an alias for `RGB_MOD`.
 
 ## Hardware Modification
 

docs/feature_space_cadet.md

@@ -1,8 +1,8 @@
-## Space Cadet Shift: The future, built in
+## Space Cadet Shift: The Future, Built In
 
 Steve Losh [described](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/) the Space Cadet Shift quite well. Essentially, you hit the left Shift on its own, and you get an opening parenthesis; hit the right Shift on its own, and you get the closing one. When hit with other keys, the Shift key keeps working as it always does. Yes, it's as cool as it sounds.
 
-To use it, use `KC_LSPO` (Left Shift, Parens Open) for your left Shift on your keymap, and `KC_RSPC` (Right Shift, Parens Close) for your right Shift.
+To use it, use `KC_LSPO` (Left Shift, Parenthesis Open) for your left Shift on your keymap, and `KC_RSPC` (Right Shift, Parenthesis Close) for your right Shift.
 
 It's defaulted to work on US keyboards, but if your layout uses different keys for parenthesis, you can define those in your `config.h` like this:
 

docs/feature_space_shift_cadet.md

@@ -0,0 +1,26 @@
+## Space Cadet Shift Enter: The future, built in
+
+Based on the Space Cadet Shift by Steve Losh [described](http://stevelosh.com/blog/2012/10/a-modern-space-cadet/) 
+Essentially, you hit the Shift on its own, and it acts as the enter key. When hit with other keys, the Shift key keeps working as it always does. Yes, it's as cool as it sounds. This solution works better than using a macro since the timers defined in quantum allow us to tell when another key is pressed, rather than just having a janky timer than results in accidental endlines. 
+
+To use it, use `KC_SFTENT` (Shift, Enter) for any Shift on your keymap.
+
+It's defaulted to work on US keyboards, but if you'd like to use a different key for Enter, you can define those in your `config.h` like this:
+
+    #define SFTENT_KEY KC_ENT
+
+
+The only other thing you're going to want to do is create a `rules.mk` in your keymap directory and set the following:
+
+```
+COMMAND_ENABLE   = no  # Commands for debug and configuration
+```
+
+This is just to keep the keyboard from going into command mode when you hold both Shift keys at the same time.
+
+
+
+
+
+PLEASE NOTE: this feature uses the same timers as the Space Cadet Shift feature, so using them in tandem may produce unwanted results. 
+

docs/feature_stenography.md

@@ -14,7 +14,7 @@ To use Plover with QMK just enable NKRO and optionally adjust your layout if you
 
 Plover also understands the language of several steno machines. QMK can speak a couple of these languages, TX Bolt and GeminiPR. An example layout can be found in `planck/keymaps/steno`.
 
-When QMK speaks to Plover over a steno protocol Plover will not use the keyboard as input. This means that you can switch back and forth between a standard keyboard and your steno keyboard, or even switch layers from Plover to standard and back without needing to activate/deactive Plover.
+When QMK speaks to Plover over a steno protocol Plover will not use the keyboard as input. This means that you can switch back and forth between a standard keyboard and your steno keyboard, or even switch layers from Plover to standard and back without needing to activate/deactivate Plover.
 
 In this mode Plover expects to speak with a steno machine over a serial port so QMK will present itself to the operating system as a virtual serial port in addition to a keyboard. By default QMK will speak the TX Bolt protocol but can be switched to GeminiPR; the last protocol used is stored in non-volatile memory so QMK will use the same protocol on restart.
 
@@ -56,6 +56,29 @@ On the display tab click 'Open stroke display'. With Plover disabled you should
 * [Steno Jig](https://joshuagrams.github.io/steno-jig/)
 * More resources at the Plover [Learning Stenography](https://github.com/openstenoproject/plover/wiki/Learning-Stenography) wiki
 
+## Interfacing with the code
+
+The steno code has three interceptible hooks. If you define these functions, they will be called at certain points in processing; if they return true, processing continues, otherwise it's assumed you handled things.
+
+```C
+bool send_steno_chord_user(steno_mode_t mode, uint8_t chord[6]);
+```
+
+This function is called when a chord is about to be sent. Mode will be one of `STENO_MODE_BOLT` or `STENO_MODE_GEMINI`. This represents the actual chord that would be sent via whichever protocol. You can modify the chord provided to alter what gets sent. Remember to return true if you want the regular sending process to happen.
+
+```C
+bool process_steno_user(uint16_t keycode, keyrecord_t *record) { return true; }
+```
+
+This function is called when a keypress has come in, before it is processed. The keycode should be one of `QK_STENO_BOLT`, `QK_STENO_GEMINI`, or one of the `STN_*` key values.
+
+```C
+bool postprocess_steno_user(uint16_t keycode, keyrecord_t *record, steno_mode_t mode, uint8_t chord[6], int8_t pressed);
+```
+
+This function is called after a key has been processed, but before any decision about whether or not to send a chord. If `IS_PRESSED(record->event)` is false, and `pressed` is 0 or 1, the chord will be sent shortly, but has not yet been sent. This is where to put hooks for things like, say, live displays of steno chords or keys.
+
+
 ## Keycode Reference
 
 As defined in `keymap_steno.h`.
@@ -106,3 +129,4 @@ As defined in `keymap_steno.h`.
 |`STN_RES1`||(GeminiPR only)|
 |`STN_RES2`||(GeminiPR only)|
 |`STN_PWR`||(GeminiPR only)|
+

docs/feature_swap_hands.md

@@ -0,0 +1,30 @@
+# Swap-Hands Action
+
+The swap-hands action allows support for one-handed typing without requiring a separate layer. Set `SWAP_HANDS_ENABLE` in the Makefile and define a `hand_swap_config` entry in your keymap. Now whenever the `ACTION_SWAP_HANDS` command key is pressed the keyboard is mirrored. For instance, to type "Hello, World" on QWERTY you would type `^Ge^s^s^w^c W^wr^sd`
+
+## Configuration
+
+The configuration table is a simple 2-dimensional array to map from column/row to new column/row. Example `hand_swap_config` for Planck:
+
+```C
+const keypos_t hand_swap_config[MATRIX_ROWS][MATRIX_COLS] = {
+  {{11, 0}, {10, 0}, {9, 0}, {8, 0}, {7, 0}, {6, 0}, {5, 0}, {4, 0}, {3, 0}, {2, 0}, {1, 0}, {0, 0}},
+  {{11, 1}, {10, 1}, {9, 1}, {8, 1}, {7, 1}, {6, 1}, {5, 1}, {4, 1}, {3, 1}, {2, 1}, {1, 1}, {0, 1}},
+  {{11, 2}, {10, 2}, {9, 2}, {8, 2}, {7, 2}, {6, 2}, {5, 2}, {4, 2}, {3, 2}, {2, 2}, {1, 2}, {0, 2}},
+  {{11, 3}, {10, 3}, {9, 3}, {8, 3}, {7, 3}, {6, 3}, {5, 3}, {4, 3}, {3, 3}, {2, 3}, {1, 3}, {0, 3}},
+};
+```
+
+Note that the array indices are reversed same as the matrix and the values are of type `keypos_t` which is `{col, row}` and all values are zero-based. In the example above, `hand_swap_config[2][4]` (third row, fifth column) would return `{7, 2}` (third row, eighth column). Yes, this is confusing.
+
+## Swap Keycodes
+
+|Key        |Description                                                              |
+|-----------|-------------------------------------------------------------------------|
+|`SH_T(key)`|Sends `key` with a tap; momentary swap when held.                        |
+|`SW_ON`    |Turns on swapping and leaves it on.                                      |
+|`SW_OFF`   |Turn off swapping and leaves it off. Good for returning to a known state.|
+|`SW_MON`   |Swaps hands when pressed, returns to normal when released (momentary).   |
+|`SW_MOFF`  |Momentarily turns off swap.                                              |
+|`SH_TG`    |Toggles swap on and off with every key press.                            |
+|`SH_TT`    |Toggles with a tap; momentary when held.                                 |

docs/feature_tap_dance.md

@@ -1,4 +1,4 @@
-# Tap Dance: A single key can do 3, 5, or 100 different things
+# Tap Dance: A Single Key Can Do 3, 5, or 100 Different Things
 
 <!-- FIXME: Break this up into multiple sections -->
 
@@ -22,7 +22,7 @@ This array specifies what actions shall be taken when a tap-dance key is in acti
 * `ACTION_TAP_DANCE_FN(fn)`: Calls the specified function - defined in the user keymap - with the final tap count of the tap dance action.
 * `ACTION_TAP_DANCE_FN_ADVANCED(on_each_tap_fn, on_dance_finished_fn, on_dance_reset_fn)`: Calls the first specified function - defined in the user keymap - on every tap, the second function on when the dance action finishes (like the previous option), and the last function when the tap dance action resets.
 
-The first option is enough for a lot of cases, that just want dual roles. For example, `ACTION_TAP_DANCE(KC_SPC, KC_ENT)` will result in `Space` being sent on single-tap, `Enter` otherwise.
+The first option is enough for a lot of cases, that just want dual roles. For example, `ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT)` will result in `Space` being sent on single-tap, `Enter` otherwise.
 
 And that's the bulk of it!
 
@@ -78,7 +78,7 @@ enum {
  X_TAP_DANCE
 };
 ```
-### Example 1: Send `:` on single tap, `;` on double tap
+### Example 1: Send `:` on Single Tap, `;` on Double Tap
 ```c
 void dance_cln_finished (qk_tap_dance_state_t *state, void *user_data) {
   if (state->count == 1) {
@@ -103,7 +103,7 @@ qk_tap_dance_action_t tap_dance_actions[] = {
  [CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finished, dance_cln_reset)
 };
 ```
-### Example 2: Send "Safety Dance!" after 100 taps
+### Example 2: Send "Safety Dance!" After 100 Taps
 ```c
 void dance_egg (qk_tap_dance_state_t *state, void *user_data) {
   if (state->count >= 100) {
@@ -117,7 +117,7 @@ qk_tap_dance_action_t tap_dance_actions[] = {
 };
 ```
 
-### Example 3: Turn LED lights on then off, one at a time
+### Example 3: Turn LED Lights On Then Off, One at a Time
 
 ```c
 // on each tap, light up one led, from right to left
@@ -150,7 +150,7 @@ void dance_flsh_finished(qk_tap_dance_state_t *state, void *user_data) {
   }
 }
 
-// if the flash state didnt happen, then turn off leds, left to right
+// if the flash state didn't happen, then turn off LEDs, left to right
 void dance_flsh_reset(qk_tap_dance_state_t *state, void *user_data) {
   ergodox_right_led_1_off();
   _delay_ms(50);
@@ -187,9 +187,9 @@ enum {
   SINGLE_TAP = 1,
   SINGLE_HOLD = 2,
   DOUBLE_TAP = 3,
-  DOUBLE_HOLD = 4, 
+  DOUBLE_HOLD = 4,
   DOUBLE_SINGLE_TAP = 5 //send SINGLE_TAP twice - NOT DOUBLE_TAP
-  // Add more enums here if you want for triple, quadruple, etc. 
+  // Add more enums here if you want for triple, quadruple, etc.
 };
 
 typedef struct {
@@ -209,14 +209,14 @@ int cur_dance (qk_tap_dance_state_t *state) {
     if (state->interrupted) return DOUBLE_SINGLE_TAP;
     else if (state->pressed) return DOUBLE_HOLD;
     else return DOUBLE_TAP;
-  } 
+  }
   else return 6; //magic number. At some point this method will expand to work for more presses
 }
 
 //**************** Definitions needed for quad function to work *********************//
 
 //instanalize an instance of 'tap' for the 'x' tap dance.
-static tap xtap_state = { 
+static tap xtap_state = {
   .is_press_action = true,
   .state = 0
 };

docs/feature_terminal.md

@@ -14,9 +14,9 @@ When enabled, a `> ` prompt will appear, where you'll be able to type, backspace
 
 `#define TERMINAL_HELP` enables some other output helpers that aren't really needed with this page.
 
-## Future ideas
+## Future Ideas
 
-* Keyboard/user-extendable commands
+* Keyboard/user-extensible commands
 * Smaller footprint
 * Arrow key support
 * Command history
@@ -30,7 +30,7 @@ When enabled, a `> ` prompt will appear, where you'll be able to type, backspace
 * EEPROM read/write
 * Audio control
 
-## Current commands
+## Current Commands
 
 ### `about`
 
@@ -68,13 +68,13 @@ Prints out the entire keymap for a certain layer
 
 ```
 > keymap 0
-0x002b, 0x0014, 0x001a, 0x0008, 0x0015, 0x0017, 0x001c, 0x0018, 0x000c, 0x0012, 0x0013, 0x002a, 
-0x0029, 0x0004, 0x0016, 0x0007, 0x0009, 0x000a, 0x000b, 0x000d, 0x000e, 0x000f, 0x0033, 0x0034, 
-0x00e1, 0x001d, 0x001b, 0x0006, 0x0019, 0x0005, 0x0011, 0x0010, 0x0036, 0x0037, 0x0038, 0x0028, 
+0x002b, 0x0014, 0x001a, 0x0008, 0x0015, 0x0017, 0x001c, 0x0018, 0x000c, 0x0012, 0x0013, 0x002a,
+0x0029, 0x0004, 0x0016, 0x0007, 0x0009, 0x000a, 0x000b, 0x000d, 0x000e, 0x000f, 0x0033, 0x0034,
+0x00e1, 0x001d, 0x001b, 0x0006, 0x0019, 0x0005, 0x0011, 0x0010, 0x0036, 0x0037, 0x0038, 0x0028,
 0x5cd6, 0x00e0, 0x00e2, 0x00e3, 0x5cd4, 0x002c, 0x002c, 0x5cd5, 0x0050, 0x0051, 0x0052, 0x004f,
-> 
+>
 ```
 
 ### `exit`
 
-Exits the terminal - same as `TERM_OFF`.
+Exits the terminal - same as `TERM_OFF`.

docs/feature_thermal_printer.md

@@ -4,7 +4,7 @@
 
 ## Thermal Printer Keycodes
 
-|Name|Description|
-|----|-----------|
-|`PRINT_ON`|Start printing everything the user types|
-|`PRINT_OFF`|Stop printing everything the user types|
+|Key        |Description                             |
+|-----------|----------------------------------------|
+|`PRINT_ON` |Start printing everything the user types|
+|`PRINT_OFF`|Stop printing everything the user types |

docs/feature_unicode.md

@@ -1,4 +1,4 @@
-# Unicode support
+# Unicode Support
 
 There are three Unicode keymap definition method available in QMK:
 
@@ -24,12 +24,12 @@ sort of like macro. Unfortunately, each OS has different ideas on how Unicode is
 This is the current list of Unicode input method in QMK:
 
 * UC_OSX: MacOS Unicode Hex Input support. Works only up to 0xFFFF. Disabled by default. To enable: go to System Preferences -> Keyboard -> Input Sources, and enable Unicode Hex.
-* UC_OSX_RALT: Same as UC_OSX, but sends the Rigt Alt key for unicode input
+* UC_OSX_RALT: Same as UC_OSX, but sends the Right Alt key for unicode input
 * UC_LNX: Unicode input method under Linux. Works up to 0xFFFFF. Should work almost anywhere on ibus enabled distros. Without ibus, this works under GTK apps, but rarely anywhere else.
 * UC_WIN: (not recommended) Windows built-in Unicode input. To enable: create registry key under `HKEY_CURRENT_USER\Control Panel\Input Method\EnableHexNumpad` of type `REG_SZ` called `EnableHexNumpad`, set its value to 1, and reboot. This method is not recommended because of reliability and compatibility issue, use WinCompose method below instead.
 * UC_WINC: Windows Unicode input using WinCompose. Requires [WinCompose](https://github.com/samhocevar/wincompose). Works reliably under many (all?) variations of Windows.
 
-# Additional language support
+# Additional Language Support
 
 In `quantum/keymap_extras/`, you'll see various language files - these work the same way as the alternative layout ones do. Most are defined by their two letter country/language code followed by an underscore and a 4-letter abbreviation of its name. `FR_UGRV` which will result in a `ù` when using a software-implemented AZERTY layout. It's currently difficult to send such characters in just the firmware.
 
@@ -52,4 +52,3 @@ In the default script of AutoHotkey you can define custom hotkeys.
 
 The hotkeys above are for the combination CtrlAltGui and CtrlAltGuiShift plus the letter a.
 AutoHotkey inserts the Text right of `Send, ` when this combination is pressed.
-

docs/feature_userspace.md

@@ -1,12 +1,13 @@
-# Userspace: sharing code between keymaps
+# Userspace: Sharing Code Between Keymaps
 
 If you use more than one keyboard with a similar keymap, you might see the benefit in being able to share code between them. Create your own folder in `users/` named the same as your keymap (ideally your github username, `<name>`) with the following structure:
 
 * `/users/<name>/` (added to the path automatically)
-  * `readme.md`
+  * `readme.md` (optional, recommended)
   * `rules.mk` (included automatically)
   * `<name>.h` (optional)
   * `<name>.c` (optional)
+  * `config.h` (optional)
 
 `<name>.c` will need to be added to the SRC in `rules.mk` like this:
 
@@ -18,16 +19,107 @@ All this only happens when you build a keymap named `<name>`, like this:
 
     make planck:<name>
 
-For example, 
+For example,
 
     make planck:jack
 
 Will include the `/users/jack/` folder in the path, along with `/users/jack/rules.mk`.
 
+Additionally, `config.h` here will be processed like the same file in your keymap folder.  This is handled separately from the `<name>.h` file.
+
+The reason for this, is that `<name>.h` won't be added in time to add settings (such as `#define TAPPING_TERM 100`), and including the `<name.h>` file in any `config.h` files will result in compile issues.
+
+So you should use the `config.h` for QMK settings, and the `<name>.h` file for user or keymap specific settings.
+
 ## Readme
 
 Please include authorship (your name, github username, email), and optionally [a license that's GPL compatible](https://www.gnu.org/licenses/license-list.html#GPLCompatibleLicenses).
 
+## `Config.h`
+
+If you do add a `config,h` file, you want to make sure that it only gets processed once.  So you may want to start off with something like this:
+
+```c
+#ifndef USERSPACE_CONFIG_H
+#define USERSPACE_CONFIG_H
+
+// Put normal config.h settings here:
+
+#endif // !USERSPACE_CONFIG_H
+```
+
+You can use any option hre that you could use in your keymap's `config.h` file. You can find a list of vales [here](config_options.md).
+
 ## Example
 
-For a brief example, checkout `/users/_example/` until we have more reasonable and useful examples.
+For a brief example, checkout `/users/_example/` , or for a more detailed examples check out [`template.h`](https://github.com/qmk/qmk_firmware/blob/master/users/drashna/template.h) and [`template.c`](https://github.com/qmk/qmk_firmware/blob/master/users/drashna/template.c) in `/users/drashna/` .
+
+### Consolidated Macros
+
+If you wanted to consolidate macros and other functions into your userspace for all of your keymaps, you can do that.  The issue is that you then cannot call any function defined in your userspace, or it gets complicated.  To better handle this, you can call the functions here and create new functions to use in individual keymaps.
+
+First, you'd want to go through all of your `keymap.c` files and replace `process_record_user` with `process_record_keymap` instead.   This way, you can still use keyboard specific codes on those boards, and use your custom "global" keycodes as well.   You'll also want to replace `SAFE_RANGE` with `NEW_SAFE_RANGE` so that you wont have any overlapping keycodes
+
+Then add `#include <name.h>` to all of your keymap.c files.  This allows you to use these new keycodes without having to redefine them in each keymap.
+
+Once you've done that, you'll want to set the keycode definitions that you need to the `<name>.h`  file. For instance:
+```
+#ifndef USERSPACE
+#define USERSPACE
+
+#include "quantum.h"
+
+// Define all of
+enum custom_keycodes {
+  KC_MAKE = SAFE_RANGE,
+  NEW_SAFE_RANGE  //use "NEW_SAFE_RANGE" for keymap specific codes
+};
+
+#endif
+```
+
+Now you want to create the `<name>.c` file, and add this content to it:
+
+```
+#include "<name>.h"
+#include "quantum.h"
+#include "action.h"
+#include "version.h"
+
+__attribute__ ((weak))
+bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
+  return true;
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+  case KC_MAKE:
+    if (!record->event.pressed) {
+      SEND_STRING("make " QMK_KEYBOARD ":" QMK_KEYMAP
+#if  (defined(BOOTLOADER_DFU) || defined(BOOTLOADER_LUFA_DFU) || defined(BOOTLOADER_QMK_DFU))
+       ":dfu "
+#elif defined(BOOTLOADER_HALFKAY)
+      ":teensy "
+#elif defined(BOOTLOADER_CATERINA)
+       ":avrdude "
+#endif
+        SS_TAP(X_ENTER));
+    }
+    return false;
+    break;
+  }
+  return process_record_keymap(keycode, record);
+}
+```
+
+This will add a new `KC_MAKE`  keycode that can be used in any of your keymaps.  And this keycode will output `make <keyboard>:<keymap">`, making frequent compiling easier.  And this will work with any keyboard and any keymap as it will output the current boards info, so that you don't have to type this out every time.
+
+Additionally, this should flash the newly compiled firmware automatically, using the correct utility, based on the bootloader settings (or default to just generating the HEX file). However, it should be noted that this may not work on all systems. AVRDUDE doesn't work on WSL, namely (and will dump the HEX in the ".build" folder instead).
+
+## Override default userspace
+
+By default the userspace used will be the same as the keymap name. In some situations this isn't desirable. For instance, if you use the [layout](feature_layouts.md) feature you can't use the same name for different keymaps (e.g. ANSI and ISO). You can name your layouts `mylayout-ansi` and `mylayout-iso` and add the following line to your layout's `rules.mk`:
+
+```
+USER_NAME := mylayout
+```

docs/features.md

@@ -1,6 +1,6 @@
 # QMK Features
 
-QMK has a staggering number of features for building your keyboard. It can take some time to understand all of them and determine which one will acheive your goal.
+QMK has a staggering number of features for building your keyboard. It can take some time to understand all of them and determine which one will achieve your goal.
 
 
 * [Advanced Keycodes](feature_advanced_keycodes.md) - Change layers, type shifted keys, and more. Go beyond typing simple characters.
@@ -15,9 +15,9 @@ QMK has a staggering number of features for building your keyboard. It can take
 * [Macros](feature_macros.md) - Send multiple key presses when pressing only one physical key.
 * [Mouse keys](feature_mouse_keys.md) - Control your mouse pointer from your keyboard.
 * [Pointing Device](feature_pointing_device.md) - Framework for connecting your custom pointing device to your keyboard.
-* [PS2 Mouse](feature_ps2_mouse.md) - Driver for connecting a ps2 mouse directly to your keyboard.
+* [PS2 Mouse](feature_ps2_mouse.md) - Driver for connecting a PS/2 mouse directly to your keyboard.
 * [RGB Light](feature_rgblight.md) - RGB lighting for your keyboard.
-* [Space Cadet](feature_space_cadet_shift.md) - Use your left/right shift keys to type parenthesis and brackets.
+* [Space Cadet](feature_space_cadet.md) - Use your left/right shift keys to type parenthesis and brackets.
 * [Stenography](feature_stenography.md) - Put your keyboard into Plover mode for stenography use.
 * [Tap Dance](feature_tap_dance.md) - Make a single key do as many things as you want.
 * [Terminal](feature_terminal.md) - CLI interface to the internals of your keyboard.

docs/flashing.md

@@ -1,18 +1,26 @@
-# Flashing Intrustructions
+# Flashing Instructions and Bootloader Information
 
 There are quite a few different types of bootloaders that keyboards use, and just about all of the use a different flashing method. Luckily, projects like the [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) aim to be compatible with all the different types without having to think about it much, but this article will describe the different types of bootloaders, and available methods for flashing them.
 
+If you have a bootloader selected with the `BOOTLOADER` variable in your `rules.mk`, QMK will automatically calculate if your .hex file is the right size to be flashed to the device, and output the total size it bytes (along with the max). To run this process manually, compile with the target `check-size`, eg `make planck/rev4:default:check-size`.
+
 ## DFU
 
 Atmel's DFU bootloader comes on all atmega32u4 chips by default, and is used by many keyboards that have their own ICs on their PCBs (Older OLKB boards, Clueboards). Some keyboards may also use LUFA's DFU bootloader (or QMK's fork) (Newer OLKB boards) that adds in additional features specific to that hardware.
 
-These bootloaders are usually 4096 bytes for the atmega32u4 chip. 
+To ensure compatibility with the DFU bootloader, make sure this block is present your `rules.mk` (optionally with `lufa-dfu` or `qmk-dfu` instead):
+
+    # Bootloader
+    #     This definition is optional, and if your keyboard supports multiple bootloaders of
+    #     different sizes, comment this out, and the correct address will be loaded
+    #     automatically (+60). See bootloader.mk for all options.
+    BOOTLOADER = atmel-dfu
 
 Compatible flashers:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
-* [dfu-programmer](https://github.com/dfu-programmer/dfu-programmer) / `:dfu` in QMK (recommended commandline)
-* [Atmel's Flip](http://www.atmel.com/tools/flip.aspx) (not recommended)
+* [dfu-programmer](https://github.com/dfu-programmer/dfu-programmer) / `:dfu` in QMK (recommended command line)
+* [Atmel's Flip](http://www.microchip.com/developmenttools/productdetails.aspx?partno=flip) (not recommended)
 
 Flashing sequence:
 
@@ -26,20 +34,37 @@ or:
 
     make <keyboard>:<keymap>:dfu
 
+### QMK DFU
+
+QMK has a fork of the LUFA DFU bootloader that allows for a simple matrix scan for exiting the bootloader and returning to the application, as well as flashing an LED/making a ticking noise with a speaker when things are happening. To enable these features, use this block in your `config.h` (The key that exits the bootloader needs to be hooked-up to the INPUT and OUTPUT defined here):
+
+    #define QMK_ESC_OUTPUT F1 // usually COL
+    #define QMK_ESC_INPUT D5 // usually ROW
+    #define QMK_LED E6
+    #define QMK_SPEAKER C6
+
+The Manufacturer and Product names are automatically pulled from your `config.h`, and "Bootloader" is added to the product.
+
+To generate this bootloader, use the `bootloader` target, eg `make planck/rev4:default:bootloader`.
+
+To generate a production-ready .hex file (containing the application and the bootloader), use the `production` target, eg `make planck/rev4:default:production`.
+
 ## Caterina
 
 Arduino boards and their clones use the [Caterina bootloader](https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/bootloaders/caterina) (any keyboard built with a Pro Micro, or clone), and uses the avr109 protocol to communicate through virtual serial. Bootloaders like [A-Star](https://www.pololu.com/docs/0J61/9) are based on Caterina.
 
-This block of code allows for Caterina compatibility in QMK:
-
-    #define CATERINA_BOOTLOADER
+To ensure compatibility with the Caterina bootloader, make sure this block is present your `rules.mk`:
 
-These bootloaders are usually 4096 bytes for the atmega32u4 chip. 
+    # Bootloader
+    #     This definition is optional, and if your keyboard supports multiple bootloaders of
+    #     different sizes, comment this out, and the correct address will be loaded
+    #     automatically (+60). See bootloader.mk for all options.
+    BOOTLOADER = caterina
 
 Compatible flashers:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
-* [avrdude](http://www.nongnu.org/avrdude/) with avr109 / `:avrdude` (recommended commandline)
+* [avrdude](http://www.nongnu.org/avrdude/) with avr109 / `:avrdude` (recommended command line)
 * [AVRDUDESS](https://github.com/zkemble/AVRDUDESS)
 
 Flashing sequence:
@@ -57,13 +82,19 @@ or
 
 Halfkay is a super-slim protocol developed by PJRC that uses HID, and come on all Teensys (namely the 2.0).
 
-This bootloader is 512 bytes.
+To ensure compatibility with the Halfkay bootloader, make sure this block is present your `rules.mk`:
+
+    # Bootloader
+    #     This definition is optional, and if your keyboard supports multiple bootloaders of
+    #     different sizes, comment this out, and the correct address will be loaded
+    #     automatically (+60). See bootloader.mk for all options.
+    BOOTLOADER = halfkay
 
 Compatible flashers:
 
 * [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (recommended GUI)
 * [Teensy Loader](https://www.pjrc.com/teensy/loader.html)
-* [Teensy Loader Command Line](https://www.pjrc.com/teensy/loader_cli.html) (recommended commandline)
+* [Teensy Loader Command Line](https://www.pjrc.com/teensy/loader_cli.html) (recommended command line)
 
 Flashing sequence:
 
@@ -71,4 +102,3 @@ Flashing sequence:
 2. Wait for the OS to detect the device
 4. Flash a .hex file
 5. Reset the device into application mode (may be done automatically)
-

docs/getting_started_build_tools.md

@@ -31,11 +31,15 @@ git
 
 Install the dependencies with your favorite package manager.
 
-Debian/Ubuntu example:
+Debian / Ubuntu example:
 
     sudo apt-get update
     sudo apt-get install gcc unzip wget zip gcc-avr binutils-avr avr-libc dfu-programmer dfu-util gcc-arm-none-eabi binutils-arm-none-eabi libnewlib-arm-none-eabi
 
+Fedora / Red Hat example:
+
+    sudo dnf install gcc unzip wget zip dfu-util dfu-programmer avr-gcc avr-libc binutils-avr32-linux-gnu arm-none-eabi-gcc-cs arm-none-eabi-binutils-cs arm-none-eabi-newlib
+
 ## Nix
 
 If you're on [NixOS](https://nixos.org/), or have Nix installed on Linux or macOS, run `nix-shell` from the repository root to get a build environment.
@@ -53,6 +57,7 @@ If you're using [homebrew,](http://brew.sh/) you can use the following commands:
     brew install avr-gcc
     brew install dfu-programmer
     brew install gcc-arm-none-eabi
+    brew install avrdude
 
 This is the recommended method. If you don't have homebrew, [install it!](http://brew.sh/) It's very much worth it for anyone who works in the command line. Note that the `make` and `make install` portion during the homebrew installation of avr-libc can take over 20 minutes and exhibit high CPU usage.
 
@@ -78,26 +83,26 @@ In addition to the Creators Update, you need Windows 10 Subystem for Linux, so i
 ### Git
 If you already have cloned the repository on your Windows file system you can ignore this section.
 
-You will need to clone the repository to your Windows file system using the normal Git for Windows and **not** the WSL Git. So if you haven't installed Git before, [download](https://git-scm.com/download/win) and install it. Then [set it up](https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup), it's important that you setup the e-mail and user name, especially if you are planning to contribute. 
+You will need to clone the repository to your Windows file system using the normal Git for Windows and **not** the WSL Git. So if you haven't installed Git before, [download](https://git-scm.com/download/win) and install it. Then [set it up](https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup), it's important that you setup the e-mail and user name, especially if you are planning to contribute.
 
 Once Git is installed, open the Git Bash command and change the directory to where you want to clone QMK; note that you have to use forward slashes, and that your c drive is accessed like this `/c/path/to/where/you/want/to/go`. Then run `git clone --recurse-submodules https://github.com/qmk/qmk_firmware`, this will create a new folder `qmk_firmware` as a subfolder of the current one.
 
-### Toolchain setup
+### Toolchain Setup
 The Toolchain setup is done through the Windows Subsystem for Linux, and the process is fully automated. If you want to do everything manually, there are no other instructions than the scripts themselves, but you can always open issues and ask for more information.
 
-1. Open "Bash On Ubuntu On Windows" from the start menu. 
-2. Go to the directory where you cloned `qmk_firmware`. Note that the paths start with `/mnt/` in the WSL, so you have to write for example `cd /mnt/c/path/to/qmk_firmware`. 
+1. Open "Bash On Ubuntu On Windows" from the start menu.
+2. Go to the directory where you cloned `qmk_firmware`. Note that the paths start with `/mnt/` in the WSL, so you have to write for example `cd /mnt/c/path/to/qmk_firmware`.
 3. Run `util/wsl_install.sh` and follow the on-screen instructions.
 4. Close the Bash command window, and re-open it.
 5. You are ready to compile and flash the firmware!
 
-### Some important things to keep in mind
+### Some Important Things to Keep in Mind
 * You can run `util/wsl_install.sh` again to get all the newest updates.
 * Your QMK repository need to be on a Windows file system path, since WSL can't run executables outside it.
 * The WSL Git is **not** compatible with the Windows Git, so use the Windows Git Bash or a windows Git GUI for all Git operations
 * You can edit files either inside WSL or normally using Windows, but note that if you edit makefiles or shell scripts, make sure you are using an editor that saves the files with Unix line endings. Otherwise the compilation might not work.
 
-## Windows (Vista and later) (Deprecated)
+## Windows (Vista and Later) (Deprecated)
 
 These are the old instructions for Windows Vista and later. We recommend you use [MSYS2 as outlined above](#windows-with-msys2-recommended).
 
@@ -118,7 +123,7 @@ If this is a bit complex for you, Docker might be the turn-key solution you need
 
 ```bash
 # You'll run this every time you want to build a keymap
-# modify the keymap and keyboard assigment to compile what you want
+# modify the keymap and keyboard assignment to compile what you want
 # defaults are ergodox/default
 
 docker run -e keymap=gwen -e keyboard=ergodox_ez --rm -v $('pwd'):/qmk:rw edasque/qmk_firmware
@@ -127,7 +132,7 @@ docker run -e keymap=gwen -e keyboard=ergodox_ez --rm -v $('pwd'):/qmk:rw edasqu
 On Windows Docker seems to have issues with the VOLUME tag in Dockerfile, and `$('pwd')` won't print a Windows compliant path; use full path instead, like this:
 
 ```bash
-docker run -e keymap=default -e keyboard=ergobox_ez --rm -v D:/Users/Sacapuces/Documents/Repositories/qmk:/qmk:rw edasque/qmk_firmware
+docker run -e keymap=default -e keyboard=ergodox_ez --rm -v D:/Users/Sacapuces/Documents/Repositories/qmk:/qmk:rw edasque/qmk_firmware
 
 ```
 

docs/getting_started_getting_help.md

@@ -0,0 +1,21 @@
+# Getting Help
+
+There are a lot of resources for getting help with QMK.
+
+## Realtime Chat
+
+You can find QMK developers and users on our main [gitter chat room](https://gitter.im/qmk/qmk_firmware). We also have other rooms for more specific discussion:
+
+* [Main Firmware Chat](https://gitter.im/qmk/qmk_firmware)
+* [QMK Toolbox](https://gitter.im/qmk/qmk_toolbox)
+* [Hardware Design Discussion](https://gitter.im/qmk/qmk_hardware)
+* [Web Configurator](https://gitter.im/qmk/qmk_configurator)
+* [Compiler API](https://gitter.im/qmk/qmk_compiler_api)
+
+## OLKB Subreddit
+
+The official QMK forum is [/r/olkb](https://reddit.com/r/olkb) on [reddit.com](https://reddit.com).
+
+## Github Issues
+
+You can open an [issue on GitHub](https://github.com/qmk/qmk_firmware/issues). This is especially handy when your issue will require long-term discussion or debugging.

docs/getting_started_github.md

@@ -1,4 +1,4 @@
-# How to use Github with QMK
+# How to Use Github with QMK
 
 Github can be a little tricky to those that aren't familiar with it - this guide will walk through each step of forking, cloning, and submitting a pull request with QMK.
 

docs/getting_started_introduction.md

@@ -2,11 +2,11 @@
 
 This page attempts to explain the basic information you need to know to work with the QMK project. It assumes that you are familiar with navigating a Unix shell, but does not assume you are familiar with C or with compiling using make.
 
-## Basic QMK structure
+## Basic QMK Structure
 
 QMK is a fork of [Jun Wako](https://github.com/tmk)'s [tmk_keyboard](https://github.com/tmk/tmk_keyboard) project. The original TMK code, with modifications, can be found in the `tmk` folder. The QMK additions to the project may be found in the `quantum` folder. Keyboard projects may be found in the `handwired` and `keyboard` folders.
 
-### Keyboard project structure
+### Keyboard Project Structure
 
 Within the folder `keyboards` and its subfolder `handwired` is a directory for each keyboard project, for example `qmk_firmware/keyboards/clueboard`. Within it you'll find the following structure:
 
@@ -14,7 +14,7 @@ Within the folder `keyboards` and its subfolder `handwired` is a directory for e
 * `rules.mk`: The file that sets the default "make" options. Do not edit this file directly, instead use a keymap specific `Makefile`
 * `config.h`: The file that sets the default compile time options. Do not edit this file directly, instead use a keymap specific `config.h`.
 
-### Keymap structure
+### Keymap Structure
 
 In every keymap folder, the following files may be found. Only `keymap.c` is required, and if the rest of the files are not found the default options will be chosen.
 
@@ -23,7 +23,7 @@ In every keymap folder, the following files may be found. Only `keymap.c` is req
 * `rules.mk`: the features of QMK that are enabled
 * `readme.md`: a description of your keymap, how others might use it, and explanations of features. Please upload images to a service like imgur.
 
-# The `config.h` file
+# The `config.h` File
 
 There are 2 `config.h` locations:
 

docs/getting_started_make_guide.md

@@ -1,10 +1,10 @@
-# More detailed make instruction
+# More Detailed `make` Instructions
 
 The full syntax of the `make` command is `<keyboard_folder>:<keymap>:<target>`, where:
 
 * `<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` 
+  * 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`
@@ -13,8 +13,8 @@ The full syntax of the `make` command is `<keyboard_folder>:<keymap>:<target>`,
 
 The `<target>` means the following
 * If no target is given, then it's the same as `all` below
-* `all` compiles as many keyboard/revision/keymap combinations as specified. For example, `make planck/rev4:default: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. 
+* `all` compiles as many keyboard/revision/keymap combinations as specified. For example, `make planck/rev4:default` will generate a single .hex, while `make planck/rev4:all` will generate a hex for every keymap available to the planck.
+* `dfu`, `teensy` or `dfu-util`, compile and upload the firmware to the keyboard. If the compilation fails, then nothing will be uploaded. The programmer to use depends on the keyboard. For most keyboards it's `dfu`, but for ChibiOS keyboards you should use `dfu-util`, and `teensy` for standard Teensys. To find out which command you should use for your keyboard, check the keyboard specific readme.
  * **Note**: some operating systems need root access for these commands to work, so in that case you need to run for example `sudo make planck/rev4:default:dfu`.
 * `clean`, cleans the build output folders to make sure that everything is built from scratch. Run this before normal compilation if you have some unexplainable problems.
 
@@ -30,10 +30,10 @@ The make command itself also has some additional options, type `make --help` for
 Here are some examples commands
 
 * `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 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
+## `rules.mk` Options
 
 Set these variables to `no` to disable them, and `yes` to enable them.
 
@@ -53,9 +53,9 @@ This allows you to use the system and audio control key codes.
 
 `CONSOLE_ENABLE`
 
-This allows you to print messages that can be read using [`hid_listen`](https://www.pjrc.com/teensy/hid_listen.html). 
+This allows you to print messages that can be read using [`hid_listen`](https://www.pjrc.com/teensy/hid_listen.html).
 
-By default, all debug (*dprint*) print (*print*, *xprintf*), and user print (*uprint*) messages will be enabled. This will eat up a significant portion of the flash and may make the keyboard .hex file too big to program. 
+By default, all debug (*dprint*) print (*print*, *xprintf*), and user print (*uprint*) messages will be enabled. This will eat up a significant portion of the flash and may make the keyboard .hex file too big to program.
 
 To disable debug messages (*dprint*) and reduce the .hex file size, include `#define NO_DEBUG` in your `config.h` file.
 
@@ -65,7 +65,7 @@ To disable print messages (*print*, *xprintf*) and **KEEP** user print messages
 
 To see the text, open `hid_listen` and enjoy looking at your printed messages.
 
-**NOTE:** Do not include *uprint* messages in anything other than your keymap code. It must not be used within the QMK system framework. Otherwise, you will bloat other people's .hex files. 
+**NOTE:** Do not include *uprint* messages in anything other than your keymap code. It must not be used within the QMK system framework. Otherwise, you will bloat other people's .hex files.
 
 Consumes about 400 bytes.
 
@@ -133,7 +133,7 @@ This consumes about 5390 bytes.
 
 This enables [key lock](feature_key_lock.md). This consumes an additional 260 bytes.
 
-## Customizing Makefile options on a per-keymap basis
+## Customizing Makefile Options on a Per-Keymap Basis
 
 If your keymap directory has a file called `rules.mk` any options you set in that file will take precedence over other `rules.mk` options for your particular keyboard.
 

docs/getting_started_vagrant.md

@@ -10,11 +10,11 @@ Using the `/Vagrantfile` in this repository requires you have [Vagrant](http://w
 
 Other than having Vagrant and Virtualbox installed and possibly a restart of your computer afterwards, you can simple run a 'vagrant up' anywhere inside the folder where you checked out this project and it will start a Linux virtual machine that contains all the tools required to build this project. There is a post Vagrant startup hint that will get you off on the right foot, otherwise you can also reference the build documentation below.
 
-# Flashing the firmware
+# Flashing the Firmware
 
 The "easy" way to flash the firmware is using a tool from your host OS:
 
-* [QMK Toolbox](https://github.com/qmk/qmk_toolbox) (reccommened)
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox) (recommended)
 * [Teensy Loader](https://www.pjrc.com/teensy/loader.html)
 * [Atmel FLIP](http://www.atmel.com/tools/flip.aspx)
 

docs/hand_wire.md

@@ -1,4 +1,4 @@
-# Quantum Hand-wiring Guide
+# Quantum Hand-Wiring Guide
 
 Parts list:
 * *x* keyswitches (MX, Matias, Gateron, etc)
@@ -6,12 +6,12 @@ Parts list:
 * Keyboard plate (metal, plastic, cardboard, etc)
 * Wire (strained for wiring to the Teensy, anything for the rows/columns)
 * Soldering iron set at 600ºF or 315ºC (if temperature-controlled)
-* Resin-cored solder (leaded or lead-free)
+* Rosin-cored solder (leaded or lead-free)
 * Adequate ventilation/a fan
 * Tweezers (optional)
 * Wire cutters/snippers
 
-## How the matrix works (why we need diodes)
+## How the Matrix Works (Why We Need Diodes)
 
 The microcontroller (in this case, the Teensy 2.0) will be setup up via the firmware to send a logical 1 to the columns, one at a time, and read from the rows, all at once - this process is called matrix scanning. The matrix is a bunch of open switches that, by default, don't allow any current to pass through - the firmware will read this as no keys being pressed. As soon as you press one key down, the logical 1 that was coming from the column the keyswitch is attached to gets passed through the switch and to the corresponding row - check out the following 2x2 example:
 
@@ -100,9 +100,9 @@ Things act as they should! Which will get us the following data:
 
 The firmware can then use this correct data to detect what it should do, and eventually, what signals it needs to send to the OS.
 
-# The actual hand-wiring
+# The Actual Hand-Wiring
 
-## Getting things in place
+## Getting Things in Place
 
 When starting this, you should have all of your stabilisers and keyswitches already installed (and optionally keycaps). If you're using a Cherry-type stabiliser (plate-mounted only, obviously), you'll need to install that before your keyswitches. If you're using Costar ones, you can installed them afterwards.
 
@@ -112,7 +112,7 @@ Get your soldering iron heated-up and collect the rest of the materials from the
 
 Before continuing, plan out where you're going to place your Teensy. If you're working with a board that has a large (6.25u) spacebar, it may be a good idea to place it in-between switches against the plate. Otherwise, you may want to trim some of the leads on the keyswitches where you plan on putting it - this will make it a little harder to solder the wire/diodes, but give you more room to place the Teensy.
 
-## Preparing the diodes
+## Preparing the Diodes
 
 It's a little easier to solder the diodes in place if you bend them at a 90º angle immediately after the black line - this will help to make sure you put them on the right way (direction matters), and in the correct position. The diodes will look like this when bent (with longer leads):
 
@@ -125,7 +125,7 @@ It's a little easier to solder the diodes in place if you bend them at a 90º an
 
 We'll be using the long lead at the bent end to connect it to the elbow (bent part) of the next diode, creating the row.
 
-## Soldering the diodes
+## Soldering the Diodes
 
 Starting at the top-left switch, place the diode (with tweezers if you have them) on the switch so that the diode itself is vertically aligned, and the black line is facing toward you. The straight end of the diode should be touching the left contact on the switch, and the bent end should be facing to the right and resting on the switch there, like this:
 
@@ -133,7 +133,7 @@ Starting at the top-left switch, place the diode (with tweezers if you have them
      │o
     ┌┴┐         o
     │ │    O
-    ├─┤      
+    ├─┤
     └┬┘
      └─────────────
 ```
@@ -142,7 +142,7 @@ Letting the diode rest, grab your solder, and touch both it and the soldering ir
 
 The smoke that the rosin releases is harmful, so be careful not to breath it or get it in your eyes/face.
 
-After soldering things in place, it may be helpful to blow on the joint to push the smoke away from your face, and cool the solder quicker. You should see the solder develop a matte (not shiney) surface as it solidifies. Keep in mind that it will still be very hot afterwards, and will take a couple minutes to be cool to touch. Blow on it will accelerate this process.
+After soldering things in place, it may be helpful to blow on the joint to push the smoke away from your face, and cool the solder quicker. You should see the solder develop a matte (not shiny) surface as it solidifies. Keep in mind that it will still be very hot afterwards, and will take a couple minutes to be cool to touch. Blow on it will accelerate this process.
 
 When the first diode is complete, the next one will need to be soldered to both the keyswitch, and the previous diode at the new elbow. That will look something like this:
 
@@ -150,7 +150,7 @@ When the first diode is complete, the next one will need to be soldered to both
      │o               │o
     ┌┴┐         o    ┌┴┐         o
     │ │    O         │ │    O
-    ├─┤              ├─┤      
+    ├─┤              ├─┤
     └┬┘              └┬┘
      └────────────────┴─────────────
 ```
@@ -159,7 +159,7 @@ After completing a row, use the wire cutters to trim the excess wire from the to
 
 When all of the diodes are completely soldered, it's a good idea to quickly inspect each one to ensure that your solder joints are solid and sturdy - repairing things after this is possible, but more difficult.
 
-## Soldering the columns
+## Soldering the Columns
 
 You'll have some options in the next process - it's a good idea to insulate the column wires (since the diodes aren't), but if you're careful enough, you can use exposed wires for the columns - it's not recommended, though. If you're using single-cored wire, stripping the plastic off of the whole wire and feeding it back on is probably the best option, but can be difficult depending on the size and materials. You'll want to leave parts of the wire exposed where you're going to be solder it onto the keyswitch.
 
@@ -169,7 +169,7 @@ Before beginning to solder, it helps to have your wire pre-bent (if using single
 
 If you're not using any insulation, you can try to keep the column wires elevated, and solder them near the tips of the keyswitch contacts - if the wires are sturdy enough, they won't short out to the row wiring an diodes.
 
-## Wiring things to the Teensy
+## Wiring Things to the Teensy
 
 Now that the matrix itself is complete, it's time to connect what you've done to the Teensy. You'll be needing the number of pins equal to your number of columns + your number of rows. There are some pins on the Teensy that are special, like D6 (the LED on the chip), or some of the UART, SPI, I2C, or PWM channels, but only avoid those if you're planning something in addition to a keyboard. If you're unsure about wanting to add something later, you should have enough pins in total to avoid a couple.
 
@@ -185,7 +185,7 @@ When you're done with the columns, start with the rows in the same process, from
 
 As you move along, be sure that the Teensy is staying in place - recutting and soldering the wires is a pain!
 
-# Getting some basic firmware set-up
+# Getting Some Basic Firmware Set Up
 
 From here, you should have a working keyboard once you program a firmware. Before we attach the Teensy permanently to the keyboard, let's quickly get some firmware loaded onto the Teensy so we can test each keyswitch.
 
@@ -201,13 +201,13 @@ You'll want to navigate to the `keyboards/<project_name>/` folder by typing, lik
 
     cd keyboards/<project_name>
 
-### config.h
+### `config.h`
 
 The first thing you're going to want to modify is the `config.h` file. Find `MATRIX_ROWS` and `MATRIX_COLS` and change their definitions to match the dimensions of your keyboard's matrix.
 
 Farther down are `MATRIX_ROW_PINS` and `MATRIX_COL_PINS`. Change their definitions to match how you wired up your matrix (looking from the top of the keyboard, the rows run top-to-bottom and the columns run left-to-right). Likewise, change the definition of `UNUSED_PINS` to match the pins you did not use (this will save power).
 
-### \<project_name\>.h
+### `<project_name>.h`
 
 The next file you'll want to look at is `<project_name>.h`. You're going to want to rewrite the `KEYMAP` definition - the format and syntax here is extremely important, so pay attention to how things are setup. The first half of the definition are considered the arguments - this is the format that you'll be following in your keymap later on, so you'll want to have as many k*xy* variables here as you do keys. The second half is the part that the firmware actually looks at, and will contain gaps depending on how you wired your matrix.
 
@@ -271,7 +271,7 @@ This would require our `KEYMAP` definition to look like this:
 
 Notice how the `k11` and `KC_NO` switched places to represent the wiring, and the unused final column on the bottom row. Sometimes it'll make more sense to put a keyswitch on a particular column, but in the end, it won't matter, as long as all of them are accounted for. You can use this process to write out the `KEYMAP` for your entire keyboard - be sure to remember that your keyboard is actually backwards when looking at the underside of it.
 
-### keymaps/<variant>/default.c
+### `keymaps/<variant>/default.c`
 
 This is the actual keymap for your keyboard, and the main place you'll make changes as you perfect your layout. `default.c` is the file that gets pull by default when typing `make`, but you can make other files as well, and specify them by typing `make handwired/<keyboard>:<variant>`, which will pull `keymaps/<variant>/keymap.c`.
 
@@ -302,7 +302,7 @@ Note that the layout of the keycodes is similar to the physical layout of our ke
 
 It's also important to use the `KEYMAP` function we defined earlier - this is what allows the firmware to associate our intended readable keymap with the actual wiring.
 
-## Compiling your firmware
+## Compiling Your Firmware
 
 After you've written out your entire keymap, you're ready to get the firmware compiled and onto your Teensy. Before compiling, you'll need to get your [development environment set-up](getting_started_build_tools.md) - you can skip the dfu-programmer instructions, but you'll need to download and install the [Teensy Loader](https://www.pjrc.com/teensy/loader.html) to get the firmware on your Teensy.
 
@@ -310,7 +310,7 @@ Once everything is installed, running `make` in the terminal should get you some
 
 Once you have your `<project_name>.hex` file, open up the Teensy loader application, and click the file icon. From here, navigate to your `QMK/keyboards/<project_name>/` folder, and select the `<project_name>.hex` file. Plug in your keyboard and press the button on the Teensy - you should see the LED on the device turn off once you do. The Teensy Loader app will change a little, and the buttons should be clickable - click the download button (down arrow), and then the reset button (right arrow), and your keyboard should be ready to go!
 
-## Testing your firmware
+## Testing Your Firmware
 
 Carefully flip your keyboard over, open up a new text document, and try typing - you should get the characters that you put into your keymap. Test each key, and note the ones that aren't working. Here's a quick trouble-shooting guide for non-working keys:
 
@@ -324,7 +324,7 @@ Carefully flip your keyboard over, open up a new text document, and try typing -
 
 If you've done all of these things, keep in mind that sometimes you might have had multiple things affecting the keyswitch, so it doesn't hurt to test the keyswitch by shorting it out at the end.
 
-# Securing the Teensy, finishing your hardware, getting fancier firmware
+# Securing the Teensy, Finishing Your Hardware, Getting Fancier Firmware
 
 Now that you have a working board, it's time to get things in their permanent positions. I've often used liberal amounts of hot glue to secure and insulate things, so if that's your style, start spreading that stuff like butter. Otherwise, double-sided tape is always an elegant solution, and electrical tape is a distant second. Due to the nature of these builds, a lot of this part is up to you and how you planned (or didn't plan) things out.
 

docs/hardware.md

@@ -1,6 +1,6 @@
 # Hardware
 
-QMK runs on a variety of hardware. If your processor can be targetted by [LUFA](http://www.fourwalledcubicle.com/LUFA.php) or [ChibiOS](http://www.chibios.com) you can probably get QMK running on it. This section explores getting QMK running on, and communicating with, hardware of all kinds.
+QMK runs on a variety of hardware. If your processor can be targeted by [LUFA](http://www.fourwalledcubicle.com/LUFA.php) or [ChibiOS](http://www.chibios.com) you can probably get QMK running on it. This section explores getting QMK running on, and communicating with, hardware of all kinds.
 
 * [Keyboard Guidelines](hardware_keyboard_guidelines.md)
 * [AVR Processors](hardware_avr.md)

docs/hardware_avr.md

@@ -1,4 +1,4 @@
-# Keyboards With AVR Processors
+# Keyboards with AVR Processors
 
 This page describes the support for for AVR processors in QMK. AVR processors include the atmega32u4, atmega32u2, at90usb1286, and other processors from Atmel Corporation. AVR processors are 8-bit MCU's that are designed to be easy to work with. The most common AVR processors in keyboards have on-board USB and plenty of GPIO for supporting large keyboard matrices. They are the most popular MCU for use in keyboards today.
 
@@ -28,7 +28,7 @@ This is where all the custom logic for your keyboard goes. Many keyboards do not
 
 ## `<keyboard>.h`
 
-This is the file you define your [Layout Macro(s)](feature_layouts.md) in. At minumum you should have a `#define LAYOUT` for your keyboard that looks something like this:
+This is the file you define your [Layout Macro(s)](feature_layouts.md) in. At minimum you should have a `#define LAYOUT` for your keyboard that looks something like this:
 
 ```
 #define LAYOUT(          \
@@ -44,7 +44,7 @@ The first half of the `LAYOUT` pre-processor macro defines the physical arrangem
 
 Each of the `k__` variables needs to be unique, and typically they follow the format `k<row><col>`.
 
-The physical matrix (the second half) must have a number of rows equalling `MATRIX_ROWS`, and each row must have exactly `MATRIX_COLS` elements in it. If you do not have this many physical keys you can use `KC_NO` to fill in the blank spots.
+The physical matrix (the second half) must have a number of rows equaling `MATRIX_ROWS`, and each row must have exactly `MATRIX_COLS` elements in it. If you do not have this many physical keys you can use `KC_NO` to fill in the blank spots.
 
 ## `config.h`
 
@@ -101,8 +101,9 @@ By default QMK supports backlighting on pins `B5`, `B6`, and `B7`. If you are us
 
 ```
 #define BACKLIGHT_PIN B7
-#define BACKLIGHT_BREATHING
 #define BACKLIGHT_LEVELS 3
+#define BACKLIGHT_BREATHING
+#define BREATHING_PERIOD 6
 ```
 
 {% hint style='info' %}
@@ -154,4 +155,3 @@ OPT_DEFS += -DBOOTLOADER_SIZE=4096
 ### Build Options
 
 There are a number of features that can be turned on or off in `rules.mk`. See the [Config Options](config_options.md#feature-options) page for a detailed list and description.
-

docs/hardware_drivers.md

@@ -10,11 +10,11 @@ QMK is used on a lot of different hardware. While support for the most common MC
 
 # Available Drivers
 
-## ProMicro (AVR only)
+## ProMicro (AVR Only)
 
 Support for addressing pins on the ProMicro by their Arduino name rather than their AVR name. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 
-## SSD1306 (AVR only)
+## SSD1306 (AVR Only)
 
 Support for SSD1306 based OLED displays. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 
@@ -22,6 +22,6 @@ Support for SSD1306 based OLED displays. This needs to be better documented, if
 
 You can make use of uGFX within QMK to drive character and graphic LCD's, LED arrays, OLED, TFT, and other display technologies. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
 
-## WS2812 (AVR only)
+## WS2812 (AVR Only)
 
 Support for WS2811/WS2812{a,b,c} LED's. For more information see the [RGB Light](feature_rgblight.md) page.

docs/hardware_keyboard_guidelines.md

@@ -2,20 +2,36 @@
 
 We welcome all keyboard projects into QMK, but ask that you try to stick to a couple guidelines that help us keep things organised and consistent.
 
-## Naming your keyboard/project
+## Naming Your Keyboard/Project
 
-All names should be lowercase alphanumeric, and separated by an underscore (`_`), but not begin with one. Your directory and your `.h` and `.c` files should have exactly the same name. All folders should follow the same format.
+All names should be lowercase alphanumeric, and separated by an underscore (`_`), but not begin with one. Your directory and your `.h` and `.c` files should have exactly the same name. All folders should follow the same format. `test`, `keyboard`, and `all` are reserved by make and are not a valid name for a keyboard.
 
 ## `readme.md`
 
 All projects need to have a `readme.md` file that explains what the keyboard is, who made it, where it is available, and links to more information. Please follow the [published template](documentation_templates.md#keyboard-readmemd-template).
 
-## Image/Hardware files
+## Image/Hardware Files
 
 In an effort to keep the repo size down, we're no longer accepting images of any format in the repo, with few exceptions. Hosting them elsewhere (imgur) and linking them in the `readme.md` is the preferred method.
 
 Any sort of hardware file (plate, case, pcb) can't be stored in qmk_firmware, but we have the [qmk.fm repo](https://github.com/qmk/qmk.fm) where such files (as well as in-depth info) can be stored and viewed on [qmk.fm](http://qmk.fm). Downloadable files are stored in `/<keyboard>/` (name follows the same format as above) which are served at `http://qmk.fm/<keyboard>/`, and pages are generated from `/_pages/<keyboard>/` which are served at the same location (.md files are generated into .html files through Jekyll). Check out the `lets_split` directory for an example.
 
+## Keyboard Defaults
+
+Given the amount of functionality that QMK exposes it's very easy to confuse new users. When putting together the default firmware for your keyboard we recommend limiting your enabled features and options to the minimal set needed to support your hardware. Recommendations for specific features follow.
+
+### Bootmagic and Command
+
+[Bootmagic](feature_bootmagic.md) and [Command](feature_command.md) are two related features that allow a user to control their keyboard in non-obvious ways. We recommend you think long and hard about if you're going to enable either feature, and how you will expose this functionality. Keep in mind that users who want this functionality can enable it in their personal keymaps without affecting all the novice users who may be using your keyboard as their first programmable board.
+
+By far the most common problem new users encounter is accidentally triggering Bootmagic while they're plugging in their keyboard. They're holding the keyboard by the bottom, unknowingly pressing in alt and spacebar, and then they find that these keys have been swapped on them. We recommend leaving this feature disabled by default, but if you do turn it on consider setting `BOOTMAGIC_KEY_SALT` to a key that is hard to press while plugging your keyboard in.
+
+If your keyboard does not have 2 shift keys you should provide a working default for `IS_COMMAND`, even when you have set `COMMAND_ENABLE = no`. This will give your users a default to conform to if they do enable Command.
+
+## Custom Keyboard Programming
+
+As documented on [Customizing Functionality](custom_quantum_functions.md) you can define custom functions for your keyboard. Please keep in mind that your users may want to customize that behavior as well, and make it possible for them to do that. If you are providing a custom function, for example `process_record_kb()`, make sure that your function calls the `_user()` version of the call too. You should also take into account the return value of the `_user()` version, and only run your custom code if the user returns `true`.
+
 ## Keyboard Metadata
 
 As QMK grows so does the ecosystem surrounding QMK. To make it easier for projects in that ecosystem to tie into QMK as we make changes we are developing a metadata system to expose information about keyboards in QMK.
@@ -29,17 +45,8 @@ The `info.json` file is a JSON formatted dictionary with the following keys avai
 * `keyboard_name`
   * A free-form text string describing the keyboard.
   * Example: `Clueboard 66%`
-* `manufacturer`
-  * A free-form text string naming the manufacturer.
-  * Example: `Clueboard`
-* `identifier`
-  * The Vendor, Product, and Revision ID's joined by a :
-  * Example: `c1ed:2370:0001`
 * `url`
   * A URL to the keyboard's product page, [QMK.fm/keyboards](https://qmk.fm/keyboards) page, or other page describing information about the keyboard.
-* `processor`
-  * The MCU or CPU this keyboard uses.
-  * Example: `atmega32u4` or `stm32f303`
 * `bootloader`
   * What bootloader this keyboard uses. Available options:
     * `atmel-dfu`
@@ -47,7 +54,9 @@ The `info.json` file is a JSON formatted dictionary with the following keys avai
     * `lufa-dfu`
     * `qmk-dfu`
     * `stm32-dfu-util`
-    * (FIXME: This list is incomplete.)
+    * `caterina`
+    * `halfkay`
+    * `bootloadHID`
 * `maintainer`
   * GitHub username of the maintainer, or `qmk` for community maintained boards
 * `width`
@@ -91,11 +100,11 @@ All key positions and rotations are specified in relation to the top-left corner
 * `RY`
   * The absolute position of the point to rotate the key around in the vertical axis. Default: `y`
 * `KS`
-  * Key Shape: define a polygon by providing a list of points, in Key Units. 
+  * Key Shape: define a polygon by providing a list of points, in Key Units.
   * **Important**: These are relative to the top-left of the key, not absolute.
   * Example ISO Enter: `[ [0,0], [1.5,0], [1.5,2], [0.25,2], [0.25,1], [0,1], [0,0] ]`
 
-### How Is The Metadata Exposed?
+### How is the Metadata Exposed?
 
 This metadata is primarily used in two ways:
 
@@ -104,11 +113,11 @@ This metadata is primarily used in two ways:
 
 Configurator authors can see the [QMK Compiler](https://docs.compile.qmk.fm/api_docs.html) docs for more information on using the JSON API.
 
-## Non-production/handwired projects
+## Non-Production/Handwired Projects
 
 We're happy to accept any project that uses QMK, including prototypes and handwired ones, but we have a separate `/keyboards/handwired/` folder for them, so the main `/keyboards/` folder doesn't get overcrowded. If a prototype project becomes a production project at some point in the future, we'd be happy to move it to the main `/keyboards/` folder!
 
-## Warnings as errors
+## Warnings as Errors
 
 When developing your keyboard, keep in mind that all warnings will be treated as errors - these small warnings can build-up and cause larger errors down the road (and keeping them is generally a bad practice).
 
@@ -132,6 +141,6 @@ The core of QMK is licensed under the [GNU General Public License](https://www.g
 
 If your keyboard makes use of the [uGFX](https://ugfx.io) features within QMK you must comply with the [uGFX License](https://ugfx.io/license.html), which requires a separate commercial license before selling a device containing uGFX.
 
-## Technical details
+## Technical Details
 
 If you're looking for more information on making your keyboard work with QMK, [check out the hardware section](hardware.md)!

docs/how_keyboards_work.md

@@ -1,10 +1,10 @@
-# How keys are registered, and interpreted by computers
+# How Keys Are Registered, and Interpreted by Computers
 
 In this file, you can will learn the concepts of how keyboards work over USB,
 and you'll be able to better understand what you can expect from changing your
 firmware directly.
 
-## Schematic view
+## Schematic View
 
 Whenever you type on 1 particular key, here is the chain of actions taking
 place:
@@ -49,7 +49,7 @@ layout is set to QWERTY, a sample of the matching table is as follow:
 | 0x1D | z/Z |
 | ... | ... |
 
-## Back to the firmware
+## Back to the Firmware
 
 As the layout is generally fixed (unless you create your own), the firmware can actually call a keycode by its layout name directly to ease things for you. This is exactly what is done here with `KC_A` actually representing `0x04` in QWERTY. The full list can be found in [keycodes](keycodes.md).
 

docs/internals_defines.md

@@ -0,0 +1,78 @@
+# group `defines` {#group__defines}
+
+## Summary
+
+ Members                        | Descriptions                                
+--------------------------------|---------------------------------------------
+`define `[`SYSEX_BEGIN`](#group__defines_1ga1a3c39bb790dda8a368c4247caabcf79)            | 
+`define `[`SYSEX_END`](#group__defines_1ga753706d1d28e6f96d7caf1973e80feed)            | 
+`define `[`MIDI_STATUSMASK`](#group__defines_1gab78a1c818a5f5dab7a8946543f126c69)            | 
+`define `[`MIDI_CHANMASK`](#group__defines_1ga239edc0a6f8405d3a8f2804f1590b909)            | 
+`define `[`MIDI_CC`](#group__defines_1ga45f116a1daab76b3c930c2cecfaef215)            | 
+`define `[`MIDI_NOTEON`](#group__defines_1gafd416f27bf3590868c0c1f55c30be4c7)            | 
+`define `[`MIDI_NOTEOFF`](#group__defines_1gabed24bea2d989fd655e2ef2ad0765adc)            | 
+`define `[`MIDI_AFTERTOUCH`](#group__defines_1ga3a322d8cfd53576a2e167c1840551b0f)            | 
+`define `[`MIDI_PITCHBEND`](#group__defines_1gabcc799504e8064679bca03f232223af4)            | 
+`define `[`MIDI_PROGCHANGE`](#group__defines_1gaefb3f1595ffbb9db66b46c2c919a3d42)            | 
+`define `[`MIDI_CHANPRESSURE`](#group__defines_1gaeb3281cc7fcd0daade8ed3d2dfc33dbe)            | 
+`define `[`MIDI_CLOCK`](#group__defines_1gafa5e4e295aafd15ab7893344599b3b89)            | 
+`define `[`MIDI_TICK`](#group__defines_1ga3b99408ff864613765d4c3c2ceb52aa7)            | 
+`define `[`MIDI_START`](#group__defines_1ga8233631c85823aa546f932ad8975caa4)            | 
+`define `[`MIDI_CONTINUE`](#group__defines_1gab24430f0081e27215b0da84dd0ee745c)            | 
+`define `[`MIDI_STOP`](#group__defines_1ga3af9271d4b1f0d22904a0b055f48cf62)            | 
+`define `[`MIDI_ACTIVESENSE`](#group__defines_1gacd88ed42dba52bb4b2052c5656362677)            | 
+`define `[`MIDI_RESET`](#group__defines_1ga02947f30ca62dc332fdeb10c5868323b)            | 
+`define `[`MIDI_TC_QUARTERFRAME`](#group__defines_1gaaa072f33590e236d1bfd8f28e833ae31)            | 
+`define `[`MIDI_SONGPOSITION`](#group__defines_1ga412f6ed33a2150051374bee334ee1705)            | 
+`define `[`MIDI_SONGSELECT`](#group__defines_1gafcab254838b028365ae0259729e72c4e)            | 
+`define `[`MIDI_TUNEREQUEST`](#group__defines_1ga8100b907b8c0a84e58b1c53dcd9bd795)            | 
+`define `[`SYSEX_EDUMANUFID`](#group__defines_1ga5ef855ed955b00a2239ca16afbeb164f)            | 
+
+## Members
+
+#### `define `[`SYSEX_BEGIN`](#group__defines_1ga1a3c39bb790dda8a368c4247caabcf79) {#group__defines_1ga1a3c39bb790dda8a368c4247caabcf79}
+
+#### `define `[`SYSEX_END`](#group__defines_1ga753706d1d28e6f96d7caf1973e80feed) {#group__defines_1ga753706d1d28e6f96d7caf1973e80feed}
+
+#### `define `[`MIDI_STATUSMASK`](#group__defines_1gab78a1c818a5f5dab7a8946543f126c69) {#group__defines_1gab78a1c818a5f5dab7a8946543f126c69}
+
+#### `define `[`MIDI_CHANMASK`](#group__defines_1ga239edc0a6f8405d3a8f2804f1590b909) {#group__defines_1ga239edc0a6f8405d3a8f2804f1590b909}
+
+#### `define `[`MIDI_CC`](#group__defines_1ga45f116a1daab76b3c930c2cecfaef215) {#group__defines_1ga45f116a1daab76b3c930c2cecfaef215}
+
+#### `define `[`MIDI_NOTEON`](#group__defines_1gafd416f27bf3590868c0c1f55c30be4c7) {#group__defines_1gafd416f27bf3590868c0c1f55c30be4c7}
+
+#### `define `[`MIDI_NOTEOFF`](#group__defines_1gabed24bea2d989fd655e2ef2ad0765adc) {#group__defines_1gabed24bea2d989fd655e2ef2ad0765adc}
+
+#### `define `[`MIDI_AFTERTOUCH`](#group__defines_1ga3a322d8cfd53576a2e167c1840551b0f) {#group__defines_1ga3a322d8cfd53576a2e167c1840551b0f}
+
+#### `define `[`MIDI_PITCHBEND`](#group__defines_1gabcc799504e8064679bca03f232223af4) {#group__defines_1gabcc799504e8064679bca03f232223af4}
+
+#### `define `[`MIDI_PROGCHANGE`](#group__defines_1gaefb3f1595ffbb9db66b46c2c919a3d42) {#group__defines_1gaefb3f1595ffbb9db66b46c2c919a3d42}
+
+#### `define `[`MIDI_CHANPRESSURE`](#group__defines_1gaeb3281cc7fcd0daade8ed3d2dfc33dbe) {#group__defines_1gaeb3281cc7fcd0daade8ed3d2dfc33dbe}
+
+#### `define `[`MIDI_CLOCK`](#group__defines_1gafa5e4e295aafd15ab7893344599b3b89) {#group__defines_1gafa5e4e295aafd15ab7893344599b3b89}
+
+#### `define `[`MIDI_TICK`](#group__defines_1ga3b99408ff864613765d4c3c2ceb52aa7) {#group__defines_1ga3b99408ff864613765d4c3c2ceb52aa7}
+
+#### `define `[`MIDI_START`](#group__defines_1ga8233631c85823aa546f932ad8975caa4) {#group__defines_1ga8233631c85823aa546f932ad8975caa4}
+
+#### `define `[`MIDI_CONTINUE`](#group__defines_1gab24430f0081e27215b0da84dd0ee745c) {#group__defines_1gab24430f0081e27215b0da84dd0ee745c}
+
+#### `define `[`MIDI_STOP`](#group__defines_1ga3af9271d4b1f0d22904a0b055f48cf62) {#group__defines_1ga3af9271d4b1f0d22904a0b055f48cf62}
+
+#### `define `[`MIDI_ACTIVESENSE`](#group__defines_1gacd88ed42dba52bb4b2052c5656362677) {#group__defines_1gacd88ed42dba52bb4b2052c5656362677}
+
+#### `define `[`MIDI_RESET`](#group__defines_1ga02947f30ca62dc332fdeb10c5868323b) {#group__defines_1ga02947f30ca62dc332fdeb10c5868323b}
+
+#### `define `[`MIDI_TC_QUARTERFRAME`](#group__defines_1gaaa072f33590e236d1bfd8f28e833ae31) {#group__defines_1gaaa072f33590e236d1bfd8f28e833ae31}
+
+#### `define `[`MIDI_SONGPOSITION`](#group__defines_1ga412f6ed33a2150051374bee334ee1705) {#group__defines_1ga412f6ed33a2150051374bee334ee1705}
+
+#### `define `[`MIDI_SONGSELECT`](#group__defines_1gafcab254838b028365ae0259729e72c4e) {#group__defines_1gafcab254838b028365ae0259729e72c4e}
+
+#### `define `[`MIDI_TUNEREQUEST`](#group__defines_1ga8100b907b8c0a84e58b1c53dcd9bd795) {#group__defines_1ga8100b907b8c0a84e58b1c53dcd9bd795}
+
+#### `define `[`SYSEX_EDUMANUFID`](#group__defines_1ga5ef855ed955b00a2239ca16afbeb164f) {#group__defines_1ga5ef855ed955b00a2239ca16afbeb164f}
+

docs/internals_input_callback_reg.md

@@ -0,0 +1,169 @@
+# group `input_callback_reg` {#group__input__callback__reg}
+
+These are the functions you use to register your input callbacks.
+
+The functions are called when the appropriate midi message is matched on the associated device's input.
+
+## Summary
+
+ Members                        | Descriptions                                
+--------------------------------|---------------------------------------------
+`public void `[`midi_register_cc_callback`](#group__input__callback__reg_1ga64ab672abbbe393c9c4a83110c8df718)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)`            | Register a control change message (cc) callback.
+`public void `[`midi_register_noteon_callback`](#group__input__callback__reg_1ga3962f276c17618923f1152779552103e)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)`            | Register a note on callback.
+`public void `[`midi_register_noteoff_callback`](#group__input__callback__reg_1gac847b66051bd6d53b762958be0ec4c6d)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)`            | Register a note off callback.
+`public void `[`midi_register_aftertouch_callback`](#group__input__callback__reg_1gaa95bc901bd9edff956a667c9a69dd01f)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)`            | Register an after touch callback.
+`public void `[`midi_register_pitchbend_callback`](#group__input__callback__reg_1ga071a28f02ba14f53de219be70ebd9a48)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)`            | Register a pitch bend callback.
+`public void `[`midi_register_songposition_callback`](#group__input__callback__reg_1gaf2adfd79637f3553d8f26deb1ca22ed6)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)`            | Register a song position callback.
+`public void `[`midi_register_progchange_callback`](#group__input__callback__reg_1gae6ba1a35a4cde9bd15dd42f87401d127)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_two_byte_func_t func)`            | Register a program change callback.
+`public void `[`midi_register_chanpressure_callback`](#group__input__callback__reg_1ga39b31f1f4fb93917ce039b958f21b4f5)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_two_byte_func_t func)`            | Register a channel pressure callback.
+`public void `[`midi_register_songselect_callback`](#group__input__callback__reg_1gaf9aafc76a2dc4b9fdbb4106cbda6ce72)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_two_byte_func_t func)`            | Register a song select callback.
+`public void `[`midi_register_tc_quarterframe_callback`](#group__input__callback__reg_1ga0a119fada2becc628cb15d753b257e6e)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_two_byte_func_t func)`            | Register a tc quarter frame callback.
+`public void `[`midi_register_realtime_callback`](#group__input__callback__reg_1ga764f440e857b89084b1a07f9da2ff93a)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_one_byte_func_t func)`            | Register a realtime callback.
+`public void `[`midi_register_tunerequest_callback`](#group__input__callback__reg_1gae40ff3ce20bda79fef87da24b8321cb1)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_one_byte_func_t func)`            | Register a tune request callback.
+`public void `[`midi_register_sysex_callback`](#group__input__callback__reg_1ga63ce9631b025785c1848d0122d4c4c48)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_sysex_func_t func)`            | Register a sysex callback.
+`public void `[`midi_register_fallthrough_callback`](#group__input__callback__reg_1ga7ed189164aa9682862b3181153afbd94)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_var_byte_func_t func)`            | Register fall through callback.
+`public void `[`midi_register_catchall_callback`](#group__input__callback__reg_1ga9dbfed568d047a6cd05708f11fe39e99)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_var_byte_func_t func)`            | Register a catch all callback.
+
+## Members
+
+#### `public void `[`midi_register_cc_callback`](#group__input__callback__reg_1ga64ab672abbbe393c9c4a83110c8df718)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)` {#group__input__callback__reg_1ga64ab672abbbe393c9c4a83110c8df718}
+
+Register a control change message (cc) callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_noteon_callback`](#group__input__callback__reg_1ga3962f276c17618923f1152779552103e)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)` {#group__input__callback__reg_1ga3962f276c17618923f1152779552103e}
+
+Register a note on callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_noteoff_callback`](#group__input__callback__reg_1gac847b66051bd6d53b762958be0ec4c6d)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)` {#group__input__callback__reg_1gac847b66051bd6d53b762958be0ec4c6d}
+
+Register a note off callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_aftertouch_callback`](#group__input__callback__reg_1gaa95bc901bd9edff956a667c9a69dd01f)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)` {#group__input__callback__reg_1gaa95bc901bd9edff956a667c9a69dd01f}
+
+Register an after touch callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_pitchbend_callback`](#group__input__callback__reg_1ga071a28f02ba14f53de219be70ebd9a48)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)` {#group__input__callback__reg_1ga071a28f02ba14f53de219be70ebd9a48}
+
+Register a pitch bend callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_songposition_callback`](#group__input__callback__reg_1gaf2adfd79637f3553d8f26deb1ca22ed6)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_three_byte_func_t func)` {#group__input__callback__reg_1gaf2adfd79637f3553d8f26deb1ca22ed6}
+
+Register a song position callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_progchange_callback`](#group__input__callback__reg_1gae6ba1a35a4cde9bd15dd42f87401d127)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_two_byte_func_t func)` {#group__input__callback__reg_1gae6ba1a35a4cde9bd15dd42f87401d127}
+
+Register a program change callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_chanpressure_callback`](#group__input__callback__reg_1ga39b31f1f4fb93917ce039b958f21b4f5)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_two_byte_func_t func)` {#group__input__callback__reg_1ga39b31f1f4fb93917ce039b958f21b4f5}
+
+Register a channel pressure callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_songselect_callback`](#group__input__callback__reg_1gaf9aafc76a2dc4b9fdbb4106cbda6ce72)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_two_byte_func_t func)` {#group__input__callback__reg_1gaf9aafc76a2dc4b9fdbb4106cbda6ce72}
+
+Register a song select callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_tc_quarterframe_callback`](#group__input__callback__reg_1ga0a119fada2becc628cb15d753b257e6e)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_two_byte_func_t func)` {#group__input__callback__reg_1ga0a119fada2becc628cb15d753b257e6e}
+
+Register a tc quarter frame callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_realtime_callback`](#group__input__callback__reg_1ga764f440e857b89084b1a07f9da2ff93a)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_one_byte_func_t func)` {#group__input__callback__reg_1ga764f440e857b89084b1a07f9da2ff93a}
+
+Register a realtime callback.
+
+The callback will be called for all of the real time message types.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_tunerequest_callback`](#group__input__callback__reg_1gae40ff3ce20bda79fef87da24b8321cb1)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_one_byte_func_t func)` {#group__input__callback__reg_1gae40ff3ce20bda79fef87da24b8321cb1}
+
+Register a tune request callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_sysex_callback`](#group__input__callback__reg_1ga63ce9631b025785c1848d0122d4c4c48)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_sysex_func_t func)` {#group__input__callback__reg_1ga63ce9631b025785c1848d0122d4c4c48}
+
+Register a sysex callback.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_fallthrough_callback`](#group__input__callback__reg_1ga7ed189164aa9682862b3181153afbd94)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_var_byte_func_t func)` {#group__input__callback__reg_1ga7ed189164aa9682862b3181153afbd94}
+
+Register fall through callback.
+
+This is only called if a more specific callback is not matched and called. For instance, if you don't register a note on callback but you get a note on message the fall through callback will be called, if it is registered.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+
+#### `public void `[`midi_register_catchall_callback`](#group__input__callback__reg_1ga9dbfed568d047a6cd05708f11fe39e99)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_var_byte_func_t func)` {#group__input__callback__reg_1ga9dbfed568d047a6cd05708f11fe39e99}
+
+Register a catch all callback.
+
+If registered, the catch all callback is called for every message that is matched, even if a more specific or the fallthrough callback is registered.
+
+#### Parameters
+* `device` the device associate with 
+
+* `func` the callback function to register
+

docs/internals_midi_device.md

@@ -0,0 +1,143 @@
+# group `midi_device` {#group__midi__device}
+
+You use the functions when you are implementing your own midi device.
+
+You set a send function to actually send bytes via your device, this method is called when you call a send function with this device, for instance midi_send_cc
+
+You use the midi_device_input to process input data from the device and pass it through the device's associated callbacks.
+
+You use the midi_device_set_pre_input_process_func if you want to have a function called at the beginning of the device's process function, generally to poll for input and pass that into midi_device_input
+
+## Summary
+
+ Members                        | Descriptions                                
+--------------------------------|---------------------------------------------
+`define `[`MIDI_INPUT_QUEUE_LENGTH`](#group__midi__device_1ga4aaa419caebdca2bbdfc1331e79781a8)            | 
+`enum `[`input_state_t`](#group__midi__device_1gac203e877d3df4275ceb8e7180a61f621)            | 
+`public void `[`midi_device_input`](#group__midi__device_1gad8d3db8eb35d9cfa51ef036a0a9d70db)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t cnt,uint8_t * input)`            | Process input bytes. This function parses bytes and calls the appropriate callbacks associated with the given device. You use this function if you are creating a custom device and you want to have midi input.
+`public void `[`midi_device_set_send_func`](#group__midi__device_1ga59f5a46bdd4452f186cc73d9e96d4673)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_var_byte_func_t send_func)`            | Set the callback function that will be used for sending output data bytes. This is only used if you're creating a custom device. You'll most likely want the callback function to disable interrupts so that you can call the various midi send functions without worrying about locking.
+`public void `[`midi_device_set_pre_input_process_func`](#group__midi__device_1ga4de0841b87c04fc23cb56b6451f33b69)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_no_byte_func_t pre_process_func)`            | Set a callback which is called at the beginning of the midi_device_process call. This can be used to poll for input data and send the data through the midi_device_input function. You'll probably only use this if you're creating a custom device.
+`struct `[`_midi_device`](docs/api_midi_device.md#struct__midi__device) | This structure represents the input and output functions and processing data for a midi device.
+
+## Members
+
+#### `define `[`MIDI_INPUT_QUEUE_LENGTH`](#group__midi__device_1ga4aaa419caebdca2bbdfc1331e79781a8) {#group__midi__device_1ga4aaa419caebdca2bbdfc1331e79781a8}
+
+#### `enum `[`input_state_t`](#group__midi__device_1gac203e877d3df4275ceb8e7180a61f621) {#group__midi__device_1gac203e877d3df4275ceb8e7180a61f621}
+
+ Values                         | Descriptions                                
+--------------------------------|---------------------------------------------
+IDLE            | 
+ONE_BYTE_MESSAGE            | 
+TWO_BYTE_MESSAGE            | 
+THREE_BYTE_MESSAGE            | 
+SYSEX_MESSAGE            | 
+
+#### `public void `[`midi_device_input`](#group__midi__device_1gad8d3db8eb35d9cfa51ef036a0a9d70db)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t cnt,uint8_t * input)` {#group__midi__device_1gad8d3db8eb35d9cfa51ef036a0a9d70db}
+
+Process input bytes. This function parses bytes and calls the appropriate callbacks associated with the given device. You use this function if you are creating a custom device and you want to have midi input.
+
+#### Parameters
+* `device` the midi device to associate the input with 
+
+* `cnt` the number of bytes you are processing 
+
+* `input` the bytes to process
+
+#### `public void `[`midi_device_set_send_func`](#group__midi__device_1ga59f5a46bdd4452f186cc73d9e96d4673)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_var_byte_func_t send_func)` {#group__midi__device_1ga59f5a46bdd4452f186cc73d9e96d4673}
+
+Set the callback function that will be used for sending output data bytes. This is only used if you're creating a custom device. You'll most likely want the callback function to disable interrupts so that you can call the various midi send functions without worrying about locking.
+
+#### Parameters
+* `device` the midi device to associate this callback with 
+
+* `send_func` the callback function that will do the sending
+
+#### `public void `[`midi_device_set_pre_input_process_func`](#group__midi__device_1ga4de0841b87c04fc23cb56b6451f33b69)`(`[`MidiDevice`](#struct__midi__device)` * device,midi_no_byte_func_t pre_process_func)` {#group__midi__device_1ga4de0841b87c04fc23cb56b6451f33b69}
+
+Set a callback which is called at the beginning of the midi_device_process call. This can be used to poll for input data and send the data through the midi_device_input function. You'll probably only use this if you're creating a custom device.
+
+#### Parameters
+* `device` the midi device to associate this callback with 
+
+* `midi_no_byte_func_t` the actual callback function
+
+# struct `_midi_device` {#struct__midi__device}
+
+This structure represents the input and output functions and processing data for a midi device.
+
+A device can represent an actual physical device [serial port, usb port] or something virtual. You should not need to modify this structure directly.
+
+## Summary
+
+ Members                        | Descriptions                                
+--------------------------------|---------------------------------------------
+`public midi_var_byte_func_t `[`send_func`](docs/api_midi_device.md#struct__midi__device_1a25d4c94b4bbccd5b98f1032b469f3ff9) | 
+`public midi_three_byte_func_t `[`input_cc_callback`](docs/api_midi_device.md#struct__midi__device_1a6da5236c1bc73877728df92d213a78d1) | 
+`public midi_three_byte_func_t `[`input_noteon_callback`](docs/api_midi_device.md#struct__midi__device_1aa10b15cf1a7fb825a5df0d2abbe34a1c) | 
+`public midi_three_byte_func_t `[`input_noteoff_callback`](docs/api_midi_device.md#struct__midi__device_1aaf290043078534d3a5a0ea4c840eba84) | 
+`public midi_three_byte_func_t `[`input_aftertouch_callback`](docs/api_midi_device.md#struct__midi__device_1acb0b4901c545cec4b28b126f2d8c315f) | 
+`public midi_three_byte_func_t `[`input_pitchbend_callback`](docs/api_midi_device.md#struct__midi__device_1a305fea672caeb996f2233bf8cd2bef18) | 
+`public midi_three_byte_func_t `[`input_songposition_callback`](docs/api_midi_device.md#struct__midi__device_1a5f3f13638b3fef3fc561ed1bf301d586) | 
+`public midi_two_byte_func_t `[`input_progchange_callback`](docs/api_midi_device.md#struct__midi__device_1adaf1da617c9a10a9dcad00ab1959d3da) | 
+`public midi_two_byte_func_t `[`input_chanpressure_callback`](docs/api_midi_device.md#struct__midi__device_1ab7ca2925c539915d43974eff604d85f7) | 
+`public midi_two_byte_func_t `[`input_songselect_callback`](docs/api_midi_device.md#struct__midi__device_1a89bed8a5a55376120cfc0a62b42f057f) | 
+`public midi_two_byte_func_t `[`input_tc_quarterframe_callback`](docs/api_midi_device.md#struct__midi__device_1ad9813e75d22e284f9f65a907d20600f0) | 
+`public midi_one_byte_func_t `[`input_realtime_callback`](docs/api_midi_device.md#struct__midi__device_1a9448eba4afb7e43650434748db3777be) | 
+`public midi_one_byte_func_t `[`input_tunerequest_callback`](docs/api_midi_device.md#struct__midi__device_1a0cb8fd53e00cf1d4202d4fa04d038e8d) | 
+`public midi_sysex_func_t `[`input_sysex_callback`](docs/api_midi_device.md#struct__midi__device_1afff9a0ce641762aaef24c1e6953ec9a2) | 
+`public midi_var_byte_func_t `[`input_fallthrough_callback`](docs/api_midi_device.md#struct__midi__device_1abb974ec6d734001b4a0e370f292be503) | 
+`public midi_var_byte_func_t `[`input_catchall_callback`](docs/api_midi_device.md#struct__midi__device_1aae0d535129d4fd650edc98eb3f7584f8) | 
+`public midi_no_byte_func_t `[`pre_input_process_callback`](docs/api_midi_device.md#struct__midi__device_1aeb0bb8923d66c23d874e177dc4265754) | 
+`public uint8_t `[`input_buffer`](docs/api_midi_device.md#struct__midi__device_1a7c5684857d6af4ebc4dc12da27bd6b2a) | 
+`public input_state_t `[`input_state`](docs/api_midi_device.md#struct__midi__device_1a69a687d2d1c449ec15a11c07a5722e39) | 
+`public uint16_t `[`input_count`](docs/api_midi_device.md#struct__midi__device_1a68dea8e7b6151e89c85c95caa612ee5d) | 
+`public uint8_t `[`input_queue_data`](docs/api_midi_device.md#struct__midi__device_1ada41de021135dc423abedcbb30f366ff) | 
+`public `[`byteQueue_t`](#structbyte_queue__t)` `[`input_queue`](#struct__midi__device_1a49c8538a8a02193c58e28a56eb695d8f) | 
+
+## Members
+
+#### `public midi_var_byte_func_t `[`send_func`](docs/api_midi_device.md#struct__midi__device_1a25d4c94b4bbccd5b98f1032b469f3ff9) {#struct__midi__device_1a25d4c94b4bbccd5b98f1032b469f3ff9}
+
+#### `public midi_three_byte_func_t `[`input_cc_callback`](docs/api_midi_device.md#struct__midi__device_1a6da5236c1bc73877728df92d213a78d1) {#struct__midi__device_1a6da5236c1bc73877728df92d213a78d1}
+
+#### `public midi_three_byte_func_t `[`input_noteon_callback`](docs/api_midi_device.md#struct__midi__device_1aa10b15cf1a7fb825a5df0d2abbe34a1c) {#struct__midi__device_1aa10b15cf1a7fb825a5df0d2abbe34a1c}
+
+#### `public midi_three_byte_func_t `[`input_noteoff_callback`](docs/api_midi_device.md#struct__midi__device_1aaf290043078534d3a5a0ea4c840eba84) {#struct__midi__device_1aaf290043078534d3a5a0ea4c840eba84}
+
+#### `public midi_three_byte_func_t `[`input_aftertouch_callback`](docs/api_midi_device.md#struct__midi__device_1acb0b4901c545cec4b28b126f2d8c315f) {#struct__midi__device_1acb0b4901c545cec4b28b126f2d8c315f}
+
+#### `public midi_three_byte_func_t `[`input_pitchbend_callback`](docs/api_midi_device.md#struct__midi__device_1a305fea672caeb996f2233bf8cd2bef18) {#struct__midi__device_1a305fea672caeb996f2233bf8cd2bef18}
+
+#### `public midi_three_byte_func_t `[`input_songposition_callback`](docs/api_midi_device.md#struct__midi__device_1a5f3f13638b3fef3fc561ed1bf301d586) {#struct__midi__device_1a5f3f13638b3fef3fc561ed1bf301d586}
+
+#### `public midi_two_byte_func_t `[`input_progchange_callback`](docs/api_midi_device.md#struct__midi__device_1adaf1da617c9a10a9dcad00ab1959d3da) {#struct__midi__device_1adaf1da617c9a10a9dcad00ab1959d3da}
+
+#### `public midi_two_byte_func_t `[`input_chanpressure_callback`](docs/api_midi_device.md#struct__midi__device_1ab7ca2925c539915d43974eff604d85f7) {#struct__midi__device_1ab7ca2925c539915d43974eff604d85f7}
+
+#### `public midi_two_byte_func_t `[`input_songselect_callback`](docs/api_midi_device.md#struct__midi__device_1a89bed8a5a55376120cfc0a62b42f057f) {#struct__midi__device_1a89bed8a5a55376120cfc0a62b42f057f}
+
+#### `public midi_two_byte_func_t `[`input_tc_quarterframe_callback`](docs/api_midi_device.md#struct__midi__device_1ad9813e75d22e284f9f65a907d20600f0) {#struct__midi__device_1ad9813e75d22e284f9f65a907d20600f0}
+
+#### `public midi_one_byte_func_t `[`input_realtime_callback`](docs/api_midi_device.md#struct__midi__device_1a9448eba4afb7e43650434748db3777be) {#struct__midi__device_1a9448eba4afb7e43650434748db3777be}
+
+#### `public midi_one_byte_func_t `[`input_tunerequest_callback`](docs/api_midi_device.md#struct__midi__device_1a0cb8fd53e00cf1d4202d4fa04d038e8d) {#struct__midi__device_1a0cb8fd53e00cf1d4202d4fa04d038e8d}
+
+#### `public midi_sysex_func_t `[`input_sysex_callback`](docs/api_midi_device.md#struct__midi__device_1afff9a0ce641762aaef24c1e6953ec9a2) {#struct__midi__device_1afff9a0ce641762aaef24c1e6953ec9a2}
+
+#### `public midi_var_byte_func_t `[`input_fallthrough_callback`](docs/api_midi_device.md#struct__midi__device_1abb974ec6d734001b4a0e370f292be503) {#struct__midi__device_1abb974ec6d734001b4a0e370f292be503}
+
+#### `public midi_var_byte_func_t `[`input_catchall_callback`](docs/api_midi_device.md#struct__midi__device_1aae0d535129d4fd650edc98eb3f7584f8) {#struct__midi__device_1aae0d535129d4fd650edc98eb3f7584f8}
+
+#### `public midi_no_byte_func_t `[`pre_input_process_callback`](docs/api_midi_device.md#struct__midi__device_1aeb0bb8923d66c23d874e177dc4265754) {#struct__midi__device_1aeb0bb8923d66c23d874e177dc4265754}
+
+#### `public uint8_t `[`input_buffer`](docs/api_midi_device.md#struct__midi__device_1a7c5684857d6af4ebc4dc12da27bd6b2a) {#struct__midi__device_1a7c5684857d6af4ebc4dc12da27bd6b2a}
+
+#### `public input_state_t `[`input_state`](docs/api_midi_device.md#struct__midi__device_1a69a687d2d1c449ec15a11c07a5722e39) {#struct__midi__device_1a69a687d2d1c449ec15a11c07a5722e39}
+
+#### `public uint16_t `[`input_count`](docs/api_midi_device.md#struct__midi__device_1a68dea8e7b6151e89c85c95caa612ee5d) {#struct__midi__device_1a68dea8e7b6151e89c85c95caa612ee5d}
+
+#### `public uint8_t `[`input_queue_data`](docs/api_midi_device.md#struct__midi__device_1ada41de021135dc423abedcbb30f366ff) {#struct__midi__device_1ada41de021135dc423abedcbb30f366ff}
+
+#### `public `[`byteQueue_t`](#structbyte_queue__t)` `[`input_queue`](#struct__midi__device_1a49c8538a8a02193c58e28a56eb695d8f) {#struct__midi__device_1a49c8538a8a02193c58e28a56eb695d8f}
+

docs/internals_midi_device_setup_process.md

@@ -0,0 +1,31 @@
+# group `midi_device_setup_process` {#group__midi__device__setup__process}
+
+These are method that you must use to initialize and run a device.
+
+## Summary
+
+ Members                        | Descriptions                                
+--------------------------------|---------------------------------------------
+`public void `[`midi_device_init`](#group__midi__device__setup__process_1gaf29deddc94ea98a59daa0bde1aefd9d9)`(`[`MidiDevice`](#struct__midi__device)` * device)`            | Initialize a device.
+`public void `[`midi_device_process`](#group__midi__device__setup__process_1gaa3d5993d0e998a1b59bbf5ab9c7b492b)`(`[`MidiDevice`](#struct__midi__device)` * device)`            | Process input data.
+
+## Members
+
+#### `public void `[`midi_device_init`](#group__midi__device__setup__process_1gaf29deddc94ea98a59daa0bde1aefd9d9)`(`[`MidiDevice`](#struct__midi__device)` * device)` {#group__midi__device__setup__process_1gaf29deddc94ea98a59daa0bde1aefd9d9}
+
+Initialize a device.
+
+You must call this before using the device in question.
+
+#### Parameters
+* `device` the device to initialize
+
+#### `public void `[`midi_device_process`](#group__midi__device__setup__process_1gaa3d5993d0e998a1b59bbf5ab9c7b492b)`(`[`MidiDevice`](#struct__midi__device)` * device)` {#group__midi__device__setup__process_1gaa3d5993d0e998a1b59bbf5ab9c7b492b}
+
+Process input data.
+
+This method drives the input processing, you must call this method frequently if you expect to have your input callbacks called.
+
+#### Parameters
+* `device` the device to process
+

docs/internals_midi_util.md

@@ -0,0 +1,54 @@
+# group `midi_util` {#group__midi__util}
+
+## Summary
+
+ Members                        | Descriptions                                
+--------------------------------|---------------------------------------------
+`enum `[`midi_packet_length_t`](#group__midi__util_1gae29ff56aee2b430ffe53933b97e5e79e)            | An enumeration of the possible packet length values.
+`public bool `[`midi_is_statusbyte`](#group__midi__util_1ga12e3b42ff9cbb4b4f2bc455fc8743ee5)`(uint8_t theByte)`            | Test to see if the byte given is a status byte.
+`public bool `[`midi_is_realtime`](#group__midi__util_1gad2f52c363e34a8000d80c983c324e2d7)`(uint8_t theByte)`            | Test to see if the byte given is a realtime message.
+`public `[`midi_packet_length_t`](#group__midi__util_1gae29ff56aee2b430ffe53933b97e5e79e)` `[`midi_packet_length`](#group__midi__util_1gaa168b43af6ae9de0debce1625e4b8175)`(uint8_t status)`            | Find the length of the packet associated with the status byte given.
+
+## Members
+
+#### `enum `[`midi_packet_length_t`](#group__midi__util_1gae29ff56aee2b430ffe53933b97e5e79e) {#group__midi__util_1gae29ff56aee2b430ffe53933b97e5e79e}
+
+ Values                         | Descriptions                                
+--------------------------------|---------------------------------------------
+UNDEFINED            | 
+ONE            | 
+TWO            | 
+THREE            | 
+
+An enumeration of the possible packet length values.
+
+#### `public bool `[`midi_is_statusbyte`](#group__midi__util_1ga12e3b42ff9cbb4b4f2bc455fc8743ee5)`(uint8_t theByte)` {#group__midi__util_1ga12e3b42ff9cbb4b4f2bc455fc8743ee5}
+
+Test to see if the byte given is a status byte.
+
+#### Parameters
+* `theByte` the byte to test 
+
+#### Returns
+true if the byte given is a midi status byte
+
+#### `public bool `[`midi_is_realtime`](#group__midi__util_1gad2f52c363e34a8000d80c983c324e2d7)`(uint8_t theByte)` {#group__midi__util_1gad2f52c363e34a8000d80c983c324e2d7}
+
+Test to see if the byte given is a realtime message.
+
+#### Parameters
+* `theByte` the byte to test 
+
+#### Returns
+true if it is a realtime message, false otherwise
+
+#### `public `[`midi_packet_length_t`](#group__midi__util_1gae29ff56aee2b430ffe53933b97e5e79e)` `[`midi_packet_length`](#group__midi__util_1gaa168b43af6ae9de0debce1625e4b8175)`(uint8_t status)` {#group__midi__util_1gaa168b43af6ae9de0debce1625e4b8175}
+
+Find the length of the packet associated with the status byte given.
+
+#### Parameters
+* `status` the status byte 
+
+#### Returns
+the length of the packet, will return UNDEFINED if the byte is not a status byte or if it is a sysex status byte
+

docs/internals_send_functions.md

@@ -0,0 +1,241 @@
+# group `send_functions` {#group__send__functions}
+
+These are the functions you use to send midi data through a device.
+
+## Summary
+
+ Members                        | Descriptions                                
+--------------------------------|---------------------------------------------
+`public void `[`midi_send_cc`](#group__send__functions_1gaaf884811c92df405ca8fe1a00082f960)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t num,uint8_t val)`            | Send a control change message (cc) via the given device.
+`public void `[`midi_send_noteon`](#group__send__functions_1ga467bcf46dbf03ec269ce565b46bc2775)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t num,uint8_t vel)`            | Send a note on message via the given device.
+`public void `[`midi_send_noteoff`](#group__send__functions_1gaedb7d8805425eef5d47d57ddcb4c7a49)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t num,uint8_t vel)`            | Send a note off message via the given device.
+`public void `[`midi_send_aftertouch`](#group__send__functions_1ga0014847571317a0e34b2ef46a6bc584f)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t note_num,uint8_t amt)`            | Send an after touch message via the given device.
+`public void `[`midi_send_pitchbend`](#group__send__functions_1gae5a4a1e71611e7534be80af9ce3d3491)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,int16_t amt)`            | Send a pitch bend message via the given device.
+`public void `[`midi_send_programchange`](#group__send__functions_1ga7b15588ef25e5e1ff09c2afc3151ce86)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t num)`            | Send a program change message via the given device.
+`public void `[`midi_send_channelpressure`](#group__send__functions_1gaf23e69fdf812e89c0036f51f88ab2e1b)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t amt)`            | Send a channel pressure message via the given device.
+`public void `[`midi_send_clock`](#group__send__functions_1ga4e1b11a7cdb0875f6e03ce7c79c581aa)`(`[`MidiDevice`](#struct__midi__device)` * device)`            | Send a clock message via the given device.
+`public void `[`midi_send_tick`](#group__send__functions_1ga2b43c7d433d940c5b907595aac947972)`(`[`MidiDevice`](#struct__midi__device)` * device)`            | Send a tick message via the given device.
+`public void `[`midi_send_start`](#group__send__functions_1ga1569749a8d58ccc56789289d7c7245cc)`(`[`MidiDevice`](#struct__midi__device)` * device)`            | Send a start message via the given device.
+`public void `[`midi_send_continue`](#group__send__functions_1gaed5dc29d754a27372e89ab8bc20ee120)`(`[`MidiDevice`](#struct__midi__device)` * device)`            | Send a continue message via the given device.
+`public void `[`midi_send_stop`](#group__send__functions_1ga026e1a620276cb653ac501aa0d12a988)`(`[`MidiDevice`](#struct__midi__device)` * device)`            | Send a stop message via the given device.
+`public void `[`midi_send_activesense`](#group__send__functions_1ga9b6e4c6ce4719d2604187b325620db37)`(`[`MidiDevice`](#struct__midi__device)` * device)`            | Send an active sense message via the given device.
+`public void `[`midi_send_reset`](#group__send__functions_1ga3671e39a6d93ca9568fc493001af1b1b)`(`[`MidiDevice`](#struct__midi__device)` * device)`            | Send a reset message via the given device.
+`public void `[`midi_send_tcquarterframe`](#group__send__functions_1ga5b85639910eec280bb744c934d0fd45a)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t time)`            | Send a tc quarter frame message via the given device.
+`public void `[`midi_send_songposition`](#group__send__functions_1gab1c9eeef3b57a8cd2e6128d18e85eb7f)`(`[`MidiDevice`](#struct__midi__device)` * device,uint16_t pos)`            | Send a song position message via the given device.
+`public void `[`midi_send_songselect`](#group__send__functions_1ga42de7838ba70d949af9a50f9facc3c50)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t song)`            | Send a song select message via the given device.
+`public void `[`midi_send_tunerequest`](#group__send__functions_1ga8db6c7e04d48e4d2266dd59118ca0656)`(`[`MidiDevice`](#struct__midi__device)` * device)`            | Send a tune request message via the given device.
+`public void `[`midi_send_byte`](#group__send__functions_1ga857e85eb90b288385642d4d991e09881)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t b)`            | Send a byte via the given device.
+`public void `[`midi_send_data`](#group__send__functions_1ga36e2f2e45369d911b76969361679054b)`(`[`MidiDevice`](#struct__midi__device)` * device,uint16_t count,uint8_t byte0,uint8_t byte1,uint8_t byte2)`            | Send up to 3 bytes of data.
+`public void `[`midi_send_array`](#group__send__functions_1ga245243cb1da18d2cea18d4b18d846ead)`(`[`MidiDevice`](#struct__midi__device)` * device,uint16_t count,uint8_t * array)`            | Send an array of formatted midi data.
+
+## Members
+
+#### `public void `[`midi_send_cc`](#group__send__functions_1gaaf884811c92df405ca8fe1a00082f960)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t num,uint8_t val)` {#group__send__functions_1gaaf884811c92df405ca8fe1a00082f960}
+
+Send a control change message (cc) via the given device.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `chan` the channel to send on, 0-15 
+
+* `num` the cc num 
+
+* `val` the value of that cc num
+
+#### `public void `[`midi_send_noteon`](#group__send__functions_1ga467bcf46dbf03ec269ce565b46bc2775)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t num,uint8_t vel)` {#group__send__functions_1ga467bcf46dbf03ec269ce565b46bc2775}
+
+Send a note on message via the given device.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `chan` the channel to send on, 0-15 
+
+* `num` the note number 
+
+* `vel` the note velocity
+
+#### `public void `[`midi_send_noteoff`](#group__send__functions_1gaedb7d8805425eef5d47d57ddcb4c7a49)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t num,uint8_t vel)` {#group__send__functions_1gaedb7d8805425eef5d47d57ddcb4c7a49}
+
+Send a note off message via the given device.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `chan` the channel to send on, 0-15 
+
+* `num` the note number 
+
+* `vel` the note velocity
+
+#### `public void `[`midi_send_aftertouch`](#group__send__functions_1ga0014847571317a0e34b2ef46a6bc584f)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t note_num,uint8_t amt)` {#group__send__functions_1ga0014847571317a0e34b2ef46a6bc584f}
+
+Send an after touch message via the given device.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `chan` the channel to send on, 0-15 
+
+* `note_num` the note number 
+
+* `amt` the after touch amount
+
+#### `public void `[`midi_send_pitchbend`](#group__send__functions_1gae5a4a1e71611e7534be80af9ce3d3491)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,int16_t amt)` {#group__send__functions_1gae5a4a1e71611e7534be80af9ce3d3491}
+
+Send a pitch bend message via the given device.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `chan` the channel to send on, 0-15 
+
+* `amt` the bend amount range: -8192..8191, 0 means no bend
+
+#### `public void `[`midi_send_programchange`](#group__send__functions_1ga7b15588ef25e5e1ff09c2afc3151ce86)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t num)` {#group__send__functions_1ga7b15588ef25e5e1ff09c2afc3151ce86}
+
+Send a program change message via the given device.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `chan` the channel to send on, 0-15 
+
+* `num` the program to change to
+
+#### `public void `[`midi_send_channelpressure`](#group__send__functions_1gaf23e69fdf812e89c0036f51f88ab2e1b)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t chan,uint8_t amt)` {#group__send__functions_1gaf23e69fdf812e89c0036f51f88ab2e1b}
+
+Send a channel pressure message via the given device.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `chan` the channel to send on, 0-15 
+
+* `amt` the amount of channel pressure
+
+#### `public void `[`midi_send_clock`](#group__send__functions_1ga4e1b11a7cdb0875f6e03ce7c79c581aa)`(`[`MidiDevice`](#struct__midi__device)` * device)` {#group__send__functions_1ga4e1b11a7cdb0875f6e03ce7c79c581aa}
+
+Send a clock message via the given device.
+
+#### Parameters
+* `device` the device to use for sending
+
+#### `public void `[`midi_send_tick`](#group__send__functions_1ga2b43c7d433d940c5b907595aac947972)`(`[`MidiDevice`](#struct__midi__device)` * device)` {#group__send__functions_1ga2b43c7d433d940c5b907595aac947972}
+
+Send a tick message via the given device.
+
+#### Parameters
+* `device` the device to use for sending
+
+#### `public void `[`midi_send_start`](#group__send__functions_1ga1569749a8d58ccc56789289d7c7245cc)`(`[`MidiDevice`](#struct__midi__device)` * device)` {#group__send__functions_1ga1569749a8d58ccc56789289d7c7245cc}
+
+Send a start message via the given device.
+
+#### Parameters
+* `device` the device to use for sending
+
+#### `public void `[`midi_send_continue`](#group__send__functions_1gaed5dc29d754a27372e89ab8bc20ee120)`(`[`MidiDevice`](#struct__midi__device)` * device)` {#group__send__functions_1gaed5dc29d754a27372e89ab8bc20ee120}
+
+Send a continue message via the given device.
+
+#### Parameters
+* `device` the device to use for sending
+
+#### `public void `[`midi_send_stop`](#group__send__functions_1ga026e1a620276cb653ac501aa0d12a988)`(`[`MidiDevice`](#struct__midi__device)` * device)` {#group__send__functions_1ga026e1a620276cb653ac501aa0d12a988}
+
+Send a stop message via the given device.
+
+#### Parameters
+* `device` the device to use for sending
+
+#### `public void `[`midi_send_activesense`](#group__send__functions_1ga9b6e4c6ce4719d2604187b325620db37)`(`[`MidiDevice`](#struct__midi__device)` * device)` {#group__send__functions_1ga9b6e4c6ce4719d2604187b325620db37}
+
+Send an active sense message via the given device.
+
+#### Parameters
+* `device` the device to use for sending
+
+#### `public void `[`midi_send_reset`](#group__send__functions_1ga3671e39a6d93ca9568fc493001af1b1b)`(`[`MidiDevice`](#struct__midi__device)` * device)` {#group__send__functions_1ga3671e39a6d93ca9568fc493001af1b1b}
+
+Send a reset message via the given device.
+
+#### Parameters
+* `device` the device to use for sending
+
+#### `public void `[`midi_send_tcquarterframe`](#group__send__functions_1ga5b85639910eec280bb744c934d0fd45a)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t time)` {#group__send__functions_1ga5b85639910eec280bb744c934d0fd45a}
+
+Send a tc quarter frame message via the given device.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `time` the time of this quarter frame, range 0..16383
+
+#### `public void `[`midi_send_songposition`](#group__send__functions_1gab1c9eeef3b57a8cd2e6128d18e85eb7f)`(`[`MidiDevice`](#struct__midi__device)` * device,uint16_t pos)` {#group__send__functions_1gab1c9eeef3b57a8cd2e6128d18e85eb7f}
+
+Send a song position message via the given device.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `pos` the song position
+
+#### `public void `[`midi_send_songselect`](#group__send__functions_1ga42de7838ba70d949af9a50f9facc3c50)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t song)` {#group__send__functions_1ga42de7838ba70d949af9a50f9facc3c50}
+
+Send a song select message via the given device.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `song` the song to select
+
+#### `public void `[`midi_send_tunerequest`](#group__send__functions_1ga8db6c7e04d48e4d2266dd59118ca0656)`(`[`MidiDevice`](#struct__midi__device)` * device)` {#group__send__functions_1ga8db6c7e04d48e4d2266dd59118ca0656}
+
+Send a tune request message via the given device.
+
+#### Parameters
+* `device` the device to use for sending
+
+#### `public void `[`midi_send_byte`](#group__send__functions_1ga857e85eb90b288385642d4d991e09881)`(`[`MidiDevice`](#struct__midi__device)` * device,uint8_t b)` {#group__send__functions_1ga857e85eb90b288385642d4d991e09881}
+
+Send a byte via the given device.
+
+This is a generic method for sending data via the given midi device. This would be useful for sending sysex data or messages that are not implemented in this API, if there are any. Please contact the author if you find some so we can add them.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `b` the byte to send
+
+#### `public void `[`midi_send_data`](#group__send__functions_1ga36e2f2e45369d911b76969361679054b)`(`[`MidiDevice`](#struct__midi__device)` * device,uint16_t count,uint8_t byte0,uint8_t byte1,uint8_t byte2)` {#group__send__functions_1ga36e2f2e45369d911b76969361679054b}
+
+Send up to 3 bytes of data.
+
+% 4 is applied to count so that you can use this to pass sysex through
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `count` the count of bytes to send, %4 is applied 
+
+* `byte0` the first byte 
+
+* `byte1` the second byte, ignored if cnt % 4 != 2 
+
+* `byte2` the third byte, ignored if cnt % 4 != 3
+
+#### `public void `[`midi_send_array`](#group__send__functions_1ga245243cb1da18d2cea18d4b18d846ead)`(`[`MidiDevice`](#struct__midi__device)` * device,uint16_t count,uint8_t * array)` {#group__send__functions_1ga245243cb1da18d2cea18d4b18d846ead}
+
+Send an array of formatted midi data.
+
+Can be used for sysex.
+
+#### Parameters
+* `device` the device to use for sending 
+
+* `count` the count of bytes to send 
+
+* `array` the array of bytes
+

docs/internals_sysex_tools.md

@@ -0,0 +1,61 @@
+# group `sysex_tools` {#group__sysex__tools}
+
+## Summary
+
+ Members                        | Descriptions                                
+--------------------------------|---------------------------------------------
+`public uint16_t `[`sysex_encoded_length`](#group__sysex__tools_1ga061e5607030412d6e62e2390d8013f0a)`(uint16_t decoded_length)`            | Compute the length of a message after it is encoded.
+`public uint16_t `[`sysex_decoded_length`](#group__sysex__tools_1ga121fc227d3acc1c0ea08c9a5c26fa3b0)`(uint16_t encoded_length)`            | Compute the length of a message after it is decoded.
+`public uint16_t `[`sysex_encode`](#group__sysex__tools_1ga54d77f8d32f92a6f329daefa2b314742)`(uint8_t * encoded,const uint8_t * source,uint16_t length)`            | Encode data so that it can be transmitted safely in a sysex message.
+`public uint16_t `[`sysex_decode`](#group__sysex__tools_1gaaad1d9ba2d5eca709a0ab4ba40662229)`(uint8_t * decoded,const uint8_t * source,uint16_t length)`            | Decode encoded data.
+
+## Members
+
+#### `public uint16_t `[`sysex_encoded_length`](#group__sysex__tools_1ga061e5607030412d6e62e2390d8013f0a)`(uint16_t decoded_length)` {#group__sysex__tools_1ga061e5607030412d6e62e2390d8013f0a}
+
+Compute the length of a message after it is encoded.
+
+#### Parameters
+* `decoded_length` The length, in bytes, of the message to encode.
+
+#### Returns
+The length, in bytes, of the message after encodeing.
+
+#### `public uint16_t `[`sysex_decoded_length`](#group__sysex__tools_1ga121fc227d3acc1c0ea08c9a5c26fa3b0)`(uint16_t encoded_length)` {#group__sysex__tools_1ga121fc227d3acc1c0ea08c9a5c26fa3b0}
+
+Compute the length of a message after it is decoded.
+
+#### Parameters
+* `encoded_length` The length, in bytes, of the encoded message.
+
+#### Returns
+The length, in bytes, of the message after it is decoded.
+
+#### `public uint16_t `[`sysex_encode`](#group__sysex__tools_1ga54d77f8d32f92a6f329daefa2b314742)`(uint8_t * encoded,const uint8_t * source,uint16_t length)` {#group__sysex__tools_1ga54d77f8d32f92a6f329daefa2b314742}
+
+Encode data so that it can be transmitted safely in a sysex message.
+
+#### Parameters
+* `encoded` The output data buffer, must be at least sysex_encoded_length(length) bytes long. 
+
+* `source` The input buffer of data to be encoded. 
+
+* `length` The number of bytes from the input buffer to encode.
+
+#### Returns
+number of bytes encoded.
+
+#### `public uint16_t `[`sysex_decode`](#group__sysex__tools_1gaaad1d9ba2d5eca709a0ab4ba40662229)`(uint8_t * decoded,const uint8_t * source,uint16_t length)` {#group__sysex__tools_1gaaad1d9ba2d5eca709a0ab4ba40662229}
+
+Decode encoded data.
+
+#### Parameters
+* `decoded` The output data buffer, must be at least sysex_decoded_length(length) bytes long. 
+
+* `source` The input buffer of data to be decoded. 
+
+* `length` The number of bytes from the input buffer to decode.
+
+#### Returns
+number of bytes decoded.
+

docs/isp_flashing_guide.md

@@ -17,11 +17,11 @@ If you're having trouble flashing/erasing your board, and running into cryptic e
     atmel.c:1434: Error flashing the block: err -2.
     ERROR
     Memory write error, use debug for more info.
-    commands.c:360: Error writing memory data. (err -4)    
-    
+    commands.c:360: Error writing memory data. (err -4)
+
 You're likely going to need to ISP flash your board/device to get it working again. Luckily, this process is pretty straight-forward, provided you have any extra programmable keyboard, Arduino, or Teensy 2.0/Teensy 2.0++. There are also dedicated ISP flashers available for this, but most cost >$15, and it's assumed that if you are googling this error, this is the first you've heard about ISP flashing, and don't have one readily available (whereas you might have some other AVR board). __We'll be using a Teensy 2.0 with Windows 10 in this guide__ - if you are comfortable doing this on another system, please consider editing this guide and contributing those instructions!
 
-## Software needed
+## Software Needed
 
 * [The Arduino IDE](https://www.arduino.cc/en/Main/Software)
 * [Teensyduino](https://www.pjrc.com/teensy/td_download.html) (if you're using a Teensy)
@@ -37,8 +37,8 @@ This is pretty straight-forward - we'll be connecting like-things to like-things
     Flasher B3  <-> Keyboard B3 (MISO)
     Flasher VCC <-> Keyboard VCC
     Flasher GND <-> Keyboard GND
-    
-## The ISP firmware
+
+## The ISP Firmware
 
 Make sure your keyboard is unplugged from any device, and plug in your Teensy.
 
@@ -51,31 +51,31 @@ Then scroll down until you see something that looks like this block of code:
     // Configure which pins to use:
 
     // The standard pin configuration.
-    #ifndef ARDUINO_HOODLOADER2 
+    #ifndef ARDUINO_HOODLOADER2
 
     #define RESET     0  // Use 0 (B0) instead of 10
     #define LED_HB    11 // Use 11 (LED on the Teensy 2.0)
     #define LED_ERR   8  // This won't be used unless you have an LED hooked-up to 8 (D3)
     #define LED_PMODE 7  // This won't be used unless you have an LED hooked-up to 7 (D2)
-    
-And make the changes in the last four lines. If you're using something besides the Teenys 2.0, you'll want to choose something else that makes sense for `LED_HB`. We define `RESET` as `0`/`B0` because that's what's close - if you want to use another pin for some reason, [you can use the pinouts to choose something else](https://www.pjrc.com/teensy/pinout.html). 
 
-Once you've made your changes, you can click the Upload button (right arrow), which will open up the Teensy flasher app - you'll need to press the reset button on the Teensy the first time, but after that, it's automatic (you shouldn't be flashing this more than once, though). Once flashed, the orange LED on the Teensy will flash on and off, indicating it's ready for some action. 
+And make the changes in the last four lines. If you're using something besides the Teensy 2.0, you'll want to choose something else that makes sense for `LED_HB`. We define `RESET` as `0`/`B0` because that's what's close - if you want to use another pin for some reason, [you can use the pinouts to choose something else](https://www.pjrc.com/teensy/pinout.html).
+
+Once you've made your changes, you can click the Upload button (right arrow), which will open up the Teensy flasher app - you'll need to press the reset button on the Teensy the first time, but after that, it's automatic (you shouldn't be flashing this more than once, though). Once flashed, the orange LED on the Teensy will flash on and off, indicating it's ready for some action.
 
-## The .hex file
+## The `.hex` File
 
-Before flashing your firmware, you're going to need to and do a little preparation. We'll be appending [this bootloader (also a .hex file)](https://github.com/qmk/qmk_firmware/blob/master/util/bootloader_atmega32u4_1_0_0.hex) to the end of our firmware by opening the original .hex file in a text editor, and removing the last line, which should be `:00000001FF` (this is an EOF message). After that's been removed, copy the entire bootloader's contents and paste it at the end of the original file, and save it. 
+Before flashing your firmware, you're going to need to and do a little preparation. We'll be appending [this bootloader (also a .hex file)](https://github.com/qmk/qmk_firmware/blob/master/util/bootloader_atmega32u4_1_0_0.hex) to the end of our firmware by opening the original .hex file in a text editor, and removing the last line, which should be `:00000001FF` (this is an EOF message). After that's been removed, copy the entire bootloader's contents and paste it at the end of the original file, and save it.
 
 It's possible to use other bootloaders here in the same way, but __you need a bootloader__, otherwise you'll have to ISP to write new firmware to your keyboard.
 
-## Flashing your firmware
+## Flashing Your Firmware
 
 Make sure your keyboard is unplugged from any device, and plug in your Teensy.
 
 Open `cmd` and navigate to your where your modified .hex file is. We'll pretend this file is called `main.hex`, and that your Teensy 2.0 is on the `COM3` port - if you're unsure, you can open your Device Manager, and look for `Ports > USB Serial Device`. Use that COM port here. You can confirm it's the right port with:
 
     avrdude -c avrisp -P COM3 -p atmega32u4
-    
+
 and you should get something like the following output:
 
     avrdude: AVR device initialized and ready to accept instructions
@@ -90,8 +90,8 @@ and you should get something like the following output:
 
 Since our keyboard uses an `atmega32u4` (common), that is the chip we'll specify. This is the full command:
 
-     avrdude -c avrisp -P COM3 -p atmega32u4 -U flash:w:main.hex:i
-     
+    avrdude -c avrisp -P COM3 -p atmega32u4 -U flash:w:main.hex:i
+
 You should see a couple of progress bars, then you should see:
 
     avrdude: verifying ...
@@ -100,7 +100,7 @@ You should see a couple of progress bars, then you should see:
     avrdude: safemode: Fuses OK
 
     avrdude done.  Thank you.
-    
+
 Which means everything should be ok! Your board may restart automatically, otherwise, unplug your Teensy and plug in your keyboard - you can leave your Teensy wired to your keyboard while testing things, but it's recommended that you desolder it/remove the wiring once you're sure everything works.
 
 If you have any questions/problems, feel free to [open an issue](https://github.com/qmk/qmk_firmware/issues/new)!

docs/keycode.txt

@@ -183,7 +183,7 @@ KC_RSHIFT           KC_RSFT         E5 Keyboard RightShift
 KC_RALT                             E6 Keyboard RightAlt
 KC_RGUI                             E7 Keyboard Right GUI(Windows/Apple/Meta key)
 
-/* 
+/*
  * Virtual keycodes
  */
 /* System Control */

docs/keycodes.md

@@ -1,315 +1,405 @@
-# Overview
-
-When defining a [keymap](keymap.md) each key needs a valid key definition. This page documents the symbols that correspond to keycodes that are available to you in QMK. This is a reference only. Where possible keys link to the page documenting their functionality.
-
-## Keycode Index
-
-|Long Name|Short Name|Description|
-|---------|----------|-----------|
-|`KC_1`||||
-|`KC_2`||||
-|`KC_3`||||
-|`KC_4`||||
-|`KC_5`||||
-|`KC_6`||||
-|`KC_7`||||
-|`KC_8`||||
-|`KC_9`||||
-|`KC_0`||||
-|`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_F13`||||
-|`KC_F14`||||
-|`KC_F15`||||
-|`KC_F16`||||
-|`KC_F17`||||
-|`KC_F18`||||
-|`KC_F19`||||
-|`KC_F20`||||
-|`KC_F21`||||
-|`KC_F22`||||
-|`KC_F23`||||
-|`KC_F24`||||
-|`KC_A`||||
-|`KC_B`||||
-|`KC_C`||||
-|`KC_D`||||
-|`KC_E`||||
-|`KC_F`||||
-|`KC_G`||||
-|`KC_H`||||
-|`KC_I`||||
-|`KC_J`||||
-|`KC_K`||||
-|`KC_L`||||
-|`KC_M`||||
-|`KC_N`||||
-|`KC_O`||||
-|`KC_P`||||
-|`KC_Q`||||
-|`KC_R`||||
-|`KC_S`||||
-|`KC_T`||||
-|`KC_U`||||
-|`KC_V`||||
-|`KC_W`||||
-|`KC_X`||||
-|`KC_Y`||||
-|`KC_Z`||||
-|`KC_ENTER`|`KC_ENT`|`Return (ENTER)`|
-|`KC_ESCAPE`|`KC_ESC`|`ESCAPE`|
-|`KC_BSPACE`|`KC_BSPC`|`DELETE (Backspace)`|
-|`KC_TAB`||`Tab`|
-|`KC_SPACE`|`KC_SPC`|Spacebar|
-|`KC_MINUS`|`KC_MINS`|`-` and `_`|
-|`KC_EQUAL`|`KC_EQL`|`=` and `+`|
-|`KC_LBRACKET`|`KC_LBRC`|`[` and `{`|
-|`KC_RBRACKET`|`KC_RBRC`|`]` and `}`|
-|`KC_BSLASH`|`KC_BSLS`|`\` and <code>&#124;</code> |
-|`KC_NONUS_HASH`|`KC_NUHS`|Non-US `#` and `~`|
-|`KC_NONUS_BSLASH`|`KC_NUBS`|Non-US `\` and <code>&#124;</code> |
-|`KC_INT1`|`KC_RO`|JIS `\` and <code>&#124;</code> |
-|`KC_INT2`|`KC_KANA`|International216|
-|`KC_INT3`|`KC_JYEN`|Yen Symbol (`¥`)|
-|`KC_SCOLON`|`KC_SCLN`|`;` and `:`|
-|`KC_QUOTE`|`KC_QUOT`|`‘` and `“`|
-|`KC_GRAVE`|`KC_GRV`|Grave Accent and Tilde|
-|`KC_COMMA`|`KC_COMM`|`,` and `<`|
-|`KC_DOT`||`.` and `>`|
-|`KC_SLASH`|`KC_SLSH`|`/` and `?`|
-|`KC_CAPSLOCK`|`KC_CAPS`|Caps Lock|
-|`KC_LCTRL`|`KC_LCTL`|LeftControl|
-|`KC_LSHIFT`|`KC_LSFT`|LeftShift|
-|`KC_LALT`||LeftAlt|
-|`KC_LGUI`||Left GUI(Windows/Apple/Meta key)|
-|`KC_RCTRL`|`KC_RCTL`|RightControl|
-|`KC_RSHIFT`|`KC_RSFT`|RightShift|
-|`KC_RALT`||RightAlt|
-|`KC_RGUI`||Right GUI(Windows/Apple/Meta key)|
-|`KC_LOCKING_CAPS`|`KC_LCAP`|Locking Caps Lock|
-|`KC_LOCKING_NUM`|`KC_LNUM`|Locking Num Lock|
-|`KC_LOCKING_SCROLL`|`KC_LSCR`|Locking Scroll Lock|
-|`KC_INT4`|`KC_HENK`|JIS Henken|
-|`KC_INT5`|`KC_MHEN`|JIS Muhenken|
-|`KC_PSCREEN`|`KC_PSCR`|PrintScreen|
-|`KC_SCROLLLOCK`|`KC_SLCK`|Scroll Lock|
-|`KC_PAUSE`|`KC_PAUS`|Pause|
-|`KC_INSERT`|`KC_INS`|Insert|
-|`KC_HOME`||Home|
-|`KC_PGUP`||PageUp|
-|`KC_DELETE`|`KC_DEL`|Delete Forward|
-|`KC_END`||End|
-|`KC_PGDOWN`|`KC_PGDN`|PageDown|
-|`KC_RIGHT`|`KC_RGHT`|RightArrow|
-|`KC_LEFT`||LeftArrow|
-|`KC_DOWN`||DownArrow|
-|`KC_UP`||UpArrow|
-|`KC_APPLICATION`|`KC_APP`|Application|
-|`KC_POWER`||Old power button scancode. MS has deprecated this in favor of `KC_SYSTEM_POWER`.|
-|`KC_EXECUTE`||Execute|
-|`KC_HELP`||Help|
-|`KC_MENU`||Menu|
-|`KC_SELECT`||Select|
-|`KC_AGAIN`||Again|
-|`KC_UNDO`||Undo|
-|`KC_CUT`||Cut|
-|`KC_COPY`||Copy|
-|`KC_PASTE`||Paste|
-|`KC_FIND`||Find|
-|`KC_ALT_ERASE`||Alternate Erase|
-|`KC_SYSREQ`||SysReq/Attention|
-|`KC_CANCEL`||Cancel|
-|`KC_CLEAR`||Clear|
-|`KC_PRIOR`||Prior|
-|`KC_RETURN`||Return|
-|`KC_SEPARATOR`||Separator|
-|`KC_OUT`||Out|
-|`KC_OPER`||Oper|
-|`KC_CLEAR_AGAIN`||Clear/Again|
-|`KC_CRSEL`||CrSel/Props|
-|`KC_EXSEL`||ExSel|
-|`KC_SYSTEM_POWER`|`KC_PWR`|System Power Down. Recommended over `KC_POWER`.|
-|`KC_SYSTEM_SLEEP`|`KC_SLEP`|System Sleep|
-|`KC_SYSTEM_WAKE`|`KC_WAKE`|System Wake|
-|`KC_MAIL`|`KC_MAIL`||
-|`KC_CALCULATOR`|`KC_CALC`||
-|`KC_MY_COMPUTER`|`KC_MYCM`||
-|`KC_WWW_SEARCH`|`KC_WSCH`||
-|`KC_WWW_HOME`|`KC_WHOM`||
-|`KC_WWW_BACK`|`KC_WBAK`||
-|`KC_WWW_FORWARD`|`KC_WFWD`||
-|`KC_WWW_STOP`|`KC_WSTP`||
-|`KC_WWW_REFRESH`|`KC_WREF`||
-|`KC_WWW_FAVORITES`|`KC_WFAV`||
-|`KC_STOP`||Stop|
-|`KC__MUTE`||Mute (macOS)|
-|`KC__VOLUP`||Volume Up (macOS)|
-|`KC__VOLDOWN`||Volume Down (macOS)|
-|`KC_AUDIO_MUTE`|`KC_MUTE`|Mute (Windows/macOS/Linux)|
-|`KC_AUDIO_VOL_UP`|`KC_VOLU`|Volume Up (Windows/macOS/Linux)|
-|`KC_AUDIO_VOL_DOWN`|`KC_VOLD`|Volume Down (Windows/macOS/Linux)|
-|`KC_MEDIA_NEXT_TRACK`|`KC_MNXT`|Next Track (Windows)|
-|`KC_MEDIA_PREV_TRACK`|`KC_MPRV`|Previous Track (Windows)|
-|`KC_MEDIA_FAST_FORWARD`|`KC_MFFD`|Next Track (macOS)|
-|`KC_MEDIA_REWIND`|`KC_MRWD`|Previous Track (macOS)|
-|`KC_MEDIA_STOP`|`KC_MSTP`||
-|`KC_MEDIA_PLAY_PAUSE`|`KC_MPLY`||
-|`KC_MEDIA_SELECT`|`KC_MSEL`||
-|`KC_NUMLOCK`|`KC_NLCK`|Keypad Num Lock and Clear|
-|`KC_KP_SLASH`|`KC_PSLS`|Keypad /|
-|`KC_KP_ASTERISK`|`KC_PAST`|Keypad *|
-|`KC_KP_MINUS`|`KC_PMNS`|Keypad -|
-|`KC_KP_PLUS`|`KC_PPLS`|Keypad +|
-|`KC_KP_ENTER`|`KC_PENT`|Keypad ENTER`|
-|`KC_KP_1`|`KC_P1`|Keypad 1 and End|
-|`KC_KP_2`|`KC_P2`|Keypad 2 and Down Arrow|
-|`KC_KP_3`|`KC_P3`|Keypad 3 and PageDn|
-|`KC_KP_4`|`KC_P4`|Keypad 4 and Left Arrow|
-|`KC_KP_5`|`KC_P5`|Keypad 5|
-|`KC_KP_6`|`KC_P6`|Keypad 6 and Right Arrow|
-|`KC_KP_7`|`KC_P7`|Keypad 7 and Home|
-|`KC_KP_8`|`KC_P8`|Keypad 8 and Up Arrow|
-|`KC_KP_9`|`KC_P9`|Keypad 9 and PageUp|
-|`KC_KP_0`|`KC_P0`|Keypad 0 and Insert|
-|`KC_KP_DOT`|`KC_PDOT`|Keypad . and Delete|
-|`KC_KP_EQUAL`|`KC_PEQL`|Keypad =|
-|`KC_KP_COMMA`|`KC_PCMM`|Keypad Comma|
-|`KC_KP_EQUAL_AS400`||Keypad Equal Sign|
-|`KC_NO`||Ignore this key. (NOOP) |
-|`KC_TRNS`||Make this key transparent to find the key on a lower layer.|
-|[`KC_MS_UP`](feature_mouse_keys.md)|`KC_MS_U`|Mouse Cursor Up|
-|[`KC_MS_DOWN`](feature_mouse_keys.md)|`KC_MS_D`|Mouse Cursor Down|
-|[`KC_MS_LEFT`](feature_mouse_keys.md)|`KC_MS_L`|Mouse Cursor Left|
-|[`KC_MS_RIGHT`](feature_mouse_keys.md)|`KC_MS_R`|Mouse Cursor Right|
-|[`KC_MS_BTN1`](feature_mouse_keys.md)|`KC_BTN1`|Mouse Button 1|
-|[`KC_MS_BTN2`](feature_mouse_keys.md)|`KC_BTN2`|Mouse Button 2|
-|[`KC_MS_BTN3`](feature_mouse_keys.md)|`KC_BTN3`|Mouse Button 3|
-|[`KC_MS_BTN4`](feature_mouse_keys.md)|`KC_BTN4`|Mouse Button 4|
-|[`KC_MS_BTN5`](feature_mouse_keys.md)|`KC_BTN5`|Mouse Button 5|
-|[`KC_MS_WH_UP`](feature_mouse_keys.md)|`KC_WH_U`|Mouse Wheel Up|
-|[`KC_MS_WH_DOWN`](feature_mouse_keys.md)|`KC_WH_D`|Mouse Wheel Down|
-|[`KC_MS_WH_LEFT`](feature_mouse_keys.md)|`KC_WH_L`|Mouse Wheel Left|
-|[`KC_MS_WH_RIGHT`](feature_mouse_keys.md)|`KC_WH_R`|Mouse Wheel Right|
-|[`KC_MS_ACCEL0`](feature_mouse_keys.md)|`KC_ACL0`|Mouse Acceleration 0|
-|[`KC_MS_ACCEL1`](feature_mouse_keys.md)|`KC_ACL1`|Mouse Acceleration 1|
-|[`KC_MS_ACCEL2`](feature_mouse_keys.md)|`KC_ACL2`|Mouse Acceleration 2|
-|[`RESET`](quantum_keycodes.md#qmk-keycodes)||Put the keyboard into DFU mode for flashing|
-|[`DEBUG`](quantum_keycodes.md#qmk-keycodes)||Toggles debug mode|
-|[`KC_GESC`](quantum_keycodes.md#qmk-keycodes)|`GRAVE_ESC`|Acts as escape when pressed normally but when pressed with Shift or GUI will send a `~`|
-|[`KC_LSPO`](quantum_keycodes.md#qmk-keycodes)||Left shift when held, open paranthesis when tapped|
-|[`KC_RSPC`](quantum_keycodes.md#qmk-keycodes)||Right shift when held, close paranthesis when tapped|
-|[`KC_LEAD`](feature_leader_key.md)||The leader key|
-|[`FUNC(n)`](quantum_keycodes.md#qmk-keycodes)|`F(n)`|Call `fn_action(n)`|
-|[`M(n)`](quantum_keycodes.md#qmk-keycodes)||to call macro n|
-|[`MACROTAP(n)`](quantum_keycodes.md#qmk-keycodes)||to macro-tap n idk FIXME`|
-|[`MAGIC_SWAP_CONTROL_CAPSLOCK`](feature_bootmagic.md)||Swap Capslock and Left Control|
-|[`MAGIC_CAPSLOCK_TO_CONTROL`](feature_bootmagic.md)||Treat Capslock like a Control Key|
-|[`MAGIC_SWAP_LALT_LGUI`](feature_bootmagic.md)||Swap the left Alt and GUI keys|
-|[`MAGIC_SWAP_RALT_RGUI`](feature_bootmagic.md)||Swap the right Alt and GUI keys|
-|[`MAGIC_NO_GUI`](feature_bootmagic.md)||Disable the GUI key|
-|[`MAGIC_SWAP_GRAVE_ESC`](feature_bootmagic.md)||Swap the Grave and Esc key.|
-|[`MAGIC_SWAP_BACKSLASH_BACKSPACE`](feature_bootmagic.md)||Swap backslack and backspace|
-|[`MAGIC_HOST_NKRO`](feature_bootmagic.md)||Force NKRO on|
-|[`MAGIC_SWAP_ALT_GUI`/`AG_SWAP`](feature_bootmagic.md)||Swap Alt and Gui on both sides|
-|[`MAGIC_UNSWAP_CONTROL_CAPSLOCK`](feature_bootmagic.md)||Disable the Control/Capslock swap|
-|[`MAGIC_UNCAPSLOCK_TO_CONTROL`](feature_bootmagic.md)||Disable treating Capslock like Control |
-|[`MAGIC_UNSWAP_LALT_LGUI`](feature_bootmagic.md)||Disable Left Alt and GUI switching|
-|[`MAGIC_UNSWAP_RALT_RGUI`](feature_bootmagic.md)||Disable Right Alt and GUI switching|
-|[`MAGIC_UNNO_GUI`](feature_bootmagic.md)||Enable the GUI key |
-|[`MAGIC_UNSWAP_GRAVE_ESC`](feature_bootmagic.md)||Disable the Grave/Esc swap |
-|[`MAGIC_UNSWAP_BACKSLASH_BACKSPACE`](feature_bootmagic.md)||Disable the backslash/backspace swap|
-|[`MAGIC_UNHOST_NKRO`](feature_bootmagic.md)||Force NKRO off|
-|[`MAGIC_UNSWAP_ALT_GUI`/`AG_NORM`](feature_bootmagic.md)||Disable the Alt/GUI switching|
-|[`MAGIC_TOGGLE_NKRO`](feature_bootmagic.md)||Turn NKRO on or off|
-|[`BL_x`](feature_backlight.md)||Set a specific backlight level between 0-9|
-|[`BL_ON`](feature_backlight.md)||An alias for `BL_9`|
-|[`BL_OFF`](feature_backlight.md)||An alias for `BL_0`|
-|[`BL_DEC`](feature_backlight.md)||Turn the backlight level down by 1|
-|[`BL_INC`](feature_backlight.md)||Turn the backlight level up by 1|
-|[`BL_TOGG`](feature_backlight.md)||Toggle the backlight on or off|
-|[`BL_STEP`](feature_backlight.md)||Step through backlight levels, wrapping around to 0 when you reach the top.|
-|[`RGB_TOG`](feature_rgblight.md)||toggle on/off|
-|[`RGB_MOD`](feature_rgblight.md)||cycle through modes|
-|[`RGB_HUI`](feature_rgblight.md)||hue increase|
-|[`RGB_HUD`](feature_rgblight.md)||hue decrease|
-|[`RGB_SAI`](feature_rgblight.md)||saturation increase|
-|[`RGB_SAD`](feature_rgblight.md)||saturation decrease|
-|[`RGB_VAI`](feature_rgblight.md)||value increase|
-|[`RGB_VAD`](feature_rgblight.md)||value decrease|
-|[`PRINT_ON`](feature_thermal_printer.md)||Start printing everything the user types|
-|[`PRINT_OFF`](feature_thermal_printer.md)||Stop printing everything the user types|
-|[`OUT_AUTO`](feature_bluetooth.md)||auto mode|
-|[`OUT_USB`](feature_bluetooth.md)||usb only|
-|[`OUT_BT`](feature_bluetooth.md)||bluetooth (when `BLUETOOTH_ENABLE`)|
-|[`KC_HYPR`](quantum_keycodes.md#modifiers)||Hold down LCTL + LSFT + LALT + LGUI`|
-|[`KC_MEH`](quantum_keycodes.md#modifiers)||Hold down LCTL + LSFT + LALT`|
-|[`LCTL(kc)`](quantum_keycodes.md#modifiers)||`LCTL` + `kc`|
-|[`LSFT(kc)`](quantum_keycodes.md#modifiers)|[`S(kc)`](quantum_keycodes.md#modifiers)|`LSFT` + `kc`|
-|[`LALT(kc)`](quantum_keycodes.md#modifiers)||`LALT` + `kc`|
-|[`LGUI(kc)`](quantum_keycodes.md#modifiers)||`LGUI` + `kc`|
-|[`RCTL(kc)`](quantum_keycodes.md#modifiers)||`RCTL` + `kc`|
-|[`RSFT(kc)`](quantum_keycodes.md#modifiers)||`RSFT` + `kc`|
-|[`RALT(kc)`](quantum_keycodes.md#modifiers)||`RALT` + `kc`|
-|[`RGUI(kc)`](quantum_keycodes.md#modifiers)||`RGUI` + `kc`|
-|[`HYPR(kc)`](quantum_keycodes.md#modifiers)||`LCTL` + `LSFT` + `LALT` + `LGUI` + `kc`|
-|[`MEH(kc)`](quantum_keycodes.md#modifiers)||`LCTL` + `LSFT` + `LALT` + `kc`|
-|[`LCAG(kc)`](quantum_keycodes.md#modifiers)||`LCTL` + `LALT` + `LGUI` + `kc`|
-|[`ALTG(kc)`](quantum_keycodes.md#modifiers)||`RCTL` + `RALT` + `kc`|
-|[`SCMD(kc)`](quantum_keycodes.md#modifiers)|[`SWIN(kc)`](quantum_keycodes.md#modifiers)|`LGUI` + `LSFT` + `kc`|
-|[`LCA(kc)`](quantum_keycodes.md#modifiers)||`LCTL` + `LALT` + `kc`|
-|[`CTL_T(kc)`](quantum_keycodes.md#mod-tap-keys)|[`LCTL_T(kc)`](quantum_keycodes.md#mod-tap-keys)|`LCTL` when held, `kc` when tapped|
-|[`RCTL_T(kc)`](quantum_keycodes.md#mod-tap-keys)||[`RCTL` when held, `kc` when tapped|
-|[`SFT_T(kc)`](quantum_keycodes.md#mod-tap-keys)|[`LSFT_T(kc)`](quantum_keycodes.md#mod-tap-keys)|`LSFT` when held, `kc` when tapped|
-|[`RSFT_T(kc)`](quantum_keycodes.md#mod-tap-keys)||[`RSFT` when held, `kc` when tapped|
-|[`ALT_T(kc)`](quantum_keycodes.md#mod-tap-keys)|[`LALT_T(kc)`](quantum_keycodes.md#mod-tap-keys)|`LALT` when held, `kc` when tapped|
-|[`RALT_T(kc)`](quantum_keycodes.md#mod-tap-keys)|[`ALGR_T(kc)`](quantum_keycodes.md#mod-tap-keys)|`RALT` when held, `kc` when tapped|
-|[`GUI_T(kc)`](quantum_keycodes.md#mod-tap-keys)|[`LGUI_T(kc)`](quantum_keycodes.md#mod-tap-keys)|`LGUI` when held, `kc` when tapped|
-|[`RGUI_T(kc)`](quantum_keycodes.md#mod-tap-keys)||`RGUI` when held, `kc` when tapped|
-|[`C_S_T(kc)`](quantum_keycodes.md#mod-tap-keys)||`LCTL` + `LSFT` when held, `kc` when tapped|
-|[`MEH_T(kc)`](quantum_keycodes.md#mod-tap-keys)||`LCTL` + `LSFT` + `LALT` when held, `kc` when tapped|
-|[`LCAG_T(kc)`](quantum_keycodes.md#mod-tap-keys)||`LCTL` + `LALT` + `LGUI` when held, `kc` when tapped|
-|[`RCAG_T(kc)`](quantum_keycodes.md#mod-tap-keys)||`RCTL` + `RALT` + `RGUI` when held, `kc` when tapped|
-|[`ALL_T(kc)`](quantum_keycodes.md#mod-tap-keys)||`LCTL` + `LSFT` + `LALT` + `LGUI` when held, `kc` when tapped [more info](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)|
-|[`SCMD_T(kc)`](quantum_keycodes.md#mod-tap-keys)|[`SWIN_T(kc)`](quantum_keycodes.md#mod-tap-keys)|`LGUI` + `LSFT` when held, `kc` when tapped|
-|[`LCA_T(kc)`](quantum_keycodes.md#mod-tap-keys)||`LCTL` + `LALT` when held, `kc` when tapped|
-|[`KC_TILD`](keycodes_us_ansi_shifted.md)|`KC_TILDE`|tilde `~`|
-|[`KC_EXLM`](keycodes_us_ansi_shifted.md)|`KC_EXCLAIM`|exclamation mark `!`|
-|[`KC_AT`](keycodes_us_ansi_shifted.md)||at sign `@`|
-|[`KC_HASH`](keycodes_us_ansi_shifted.md)||hash sign `#`|
-|[`KC_DLR`](keycodes_us_ansi_shifted.md)|`KC_DOLLAR`|dollar sign `$`|
-|[`KC_PERC`](keycodes_us_ansi_shifted.md)|`KC_PERCENT`|percent sign `%`|
-|[`KC_CIRC`](keycodes_us_ansi_shifted.md)|`KC_CIRCUMFLEX`|circumflex `^`|
-|[`KC_AMPR`](keycodes_us_ansi_shifted.md)|`KC_AMPERSAND`|ampersand `&`|
-|[`KC_ASTR`](keycodes_us_ansi_shifted.md)|`KC_ASTERISK`|asterisk `*`|
-|[`KC_LPRN`](keycodes_us_ansi_shifted.md)|`KC_LEFT_PAREN`|left parenthesis `(`|
-|[`KC_RPRN`](keycodes_us_ansi_shifted.md)|`KC_RIGHT_PAREN`|right parenthesis `)`|
-|[`KC_UNDS`](keycodes_us_ansi_shifted.md)|`KC_UNDERSCORE`|underscore `_`|
-|[`KC_PLUS`](keycodes_us_ansi_shifted.md)||plus sign `+`|
-|[`KC_LCBR`](keycodes_us_ansi_shifted.md)|`KC_LEFT_CURLY_BRACE`|left curly brace `{`|
-|[`KC_RCBR`](keycodes_us_ansi_shifted.md)|`KC_RIGHT_CURLY_BRACE`|right curly brace `}`|
-|[`KC_LT`/`KC_LABK`](keycodes_us_ansi_shifted.md)|`KC_LEFT_ANGLE_BRACKET`|left angle bracket `<`|
-|[`KC_GT`/`KC_RABK`](keycodes_us_ansi_shifted.md)|`KC_RIGHT_ANGLE_BRACKET`|right angle bracket `>`|
-|[`KC_COLN`](keycodes_us_ansi_shifted.md)|`KC_COLON`|colon `:`|
-|[`KC_PIPE`](keycodes_us_ansi_shifted.md)||pipe `\|`|
-|[`KC_QUES`](keycodes_us_ansi_shifted.md)|`KC_QUESTION`|question mark `?`|
-|[`KC_DQT`/`KC_DQUO`](keycodes_us_ansi_shifted.md)|`KC_DOUBLE_QUOTE`|double quote `"`|
-|[`LT(layer, kc)`](feature_common_shortcuts.md#switching-and-toggling-layers)||turn on layer (0-15) when held, kc ([basic keycodes](keycodes_basic.md)) when tapped|
-|[`TO(layer)`](feature_common_shortcuts.md#switching-and-toggling-layers)||turn on layer when depressed|
-|[`MO(layer)`](feature_common_shortcuts.md#switching-and-toggling-layers)||momentarily turn on layer when depressed (requires `KC_TRNS` on destination layer)|
-|[`DF(layer)`](feature_common_shortcuts.md#switching-and-toggling-layers)||sets the base (default) layer|
-|[`TG(layer)`](feature_common_shortcuts.md#switching-and-toggling-layers)||toggle layer on/off|
-|[`TT(layer)`](feature_common_shortcuts.md#switching-and-toggling-layers)||tap toggle? idk FIXME`|
-|[`OSM(mod)`](quantum_keycodes.md#one-shot-keys)||hold mod for one keypress|
-|[`OSL(layer)`](quantum_keycodes.md#one-shot-keys)||switch to layer for one keypress|
-|[`UNICODE(n)`](feature_unicode.md)|[`UC(n)`](feature_unicode.md)|if `UNICODE_ENABLE`, this will send characters up to `0x7FFF`|
-|[`X(n)`](feature_unicode.md)||if `UNICODEMAP_ENABLE`, also sends unicode via a different method|
+# Keycodes Overview
+
+When defining a [keymap](keymap.md) each key needs a valid key definition. This page documents the symbols that correspond to keycodes that are available to you in QMK.
+
+This is a reference only. Each group of keys links to the page documenting their functionality in more detail.
+
+## [Basic Keycodes](keycodes_basic.md)
+
+|Key                    |Aliases             |Description                                    |
+|-----------------------|--------------------|-----------------------------------------------|
+|`KC_1`                 |                    |`1` and `!`                                    |
+|`KC_2`                 |                    |`2` and `@`                                    |
+|`KC_3`                 |                    |`3` and `#`                                    |
+|`KC_4`                 |                    |`4` and `$`                                    |
+|`KC_5`                 |                    |`5` and `%`                                    |
+|`KC_6`                 |                    |`6` and `^`                                    |
+|`KC_7`                 |                    |`7` and `&`                                    |
+|`KC_8`                 |                    |`8` and `*`                                    |
+|`KC_9`                 |                    |`9` and `(`                                    |
+|`KC_0`                 |                    |`0` and `)`                                    |
+|`KC_F1`                |                    |                                               |
+|`KC_F2`                |                    |                                               |
+|`KC_F3`                |                    |                                               |
+|`KC_F4`                |                    |                                               |
+|`KC_F5`                |                    |                                               |
+|`KC_F6`                |                    |                                               |
+|`KC_F7`                |                    |                                               |
+|`KC_F8`                |                    |                                               |
+|`KC_F9`                |                    |                                               |
+|`KC_F10`               |                    |                                               |
+|`KC_F11`               |                    |                                               |
+|`KC_F12`               |                    |                                               |
+|`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_A`                 |                    |`a` and `A`                                    |
+|`KC_B`                 |                    |`b` and `B`                                    |
+|`KC_C`                 |                    |`c` and `C`                                    |
+|`KC_D`                 |                    |`d` and `D`                                    |
+|`KC_E`                 |                    |`e` and `E`                                    |
+|`KC_F`                 |                    |`f` and `F`                                    |
+|`KC_G`                 |                    |`g` and `G`                                    |
+|`KC_H`                 |                    |`h` and `H`                                    |
+|`KC_I`                 |                    |`i` and `I`                                    |
+|`KC_J`                 |                    |`j` and `J`                                    |
+|`KC_K`                 |                    |`k` and `K`                                    |
+|`KC_L`                 |                    |`l` and `L`                                    |
+|`KC_M`                 |                    |`m` and `M`                                    |
+|`KC_N`                 |                    |`n` and `N`                                    |
+|`KC_O`                 |                    |`o` and `O`                                    |
+|`KC_P`                 |                    |`p` and `P`                                    |
+|`KC_Q`                 |                    |`q` and `Q`                                    |
+|`KC_R`                 |                    |`r` and `R`                                    |
+|`KC_S`                 |                    |`s` and `S`                                    |
+|`KC_T`                 |                    |`t` and `T`                                    |
+|`KC_U`                 |                    |`u` and `U`                                    |
+|`KC_V`                 |                    |`v` and `V`                                    |
+|`KC_W`                 |                    |`w` and `W`                                    |
+|`KC_X`                 |                    |`x` and `X`                                    |
+|`KC_Y`                 |                    |`y` and `Y`                                    |
+|`KC_Z`                 |                    |`z` and `Z`                                    |
+|`KC_ENTER`             |`KC_ENT`            |Return (Enter)                                 |
+|`KC_ESCAPE`            |`KC_ESC`            |Escape                                         |
+|`KC_BSPACE`            |`KC_BSPC`           |Delete (Backspace)                             |
+|`KC_TAB`               |                    |Tab                                            |
+|`KC_SPACE`             |`KC_SPC`            |Spacebar                                       |
+|`KC_MINUS`             |`KC_MINS`           |`-` and `_`                                    |
+|`KC_EQUAL`             |`KC_EQL`            |`=` and `+`                                    |
+|`KC_LBRACKET`          |`KC_LBRC`           |`[` and `{`                                    |
+|`KC_RBRACKET`          |`KC_RBRC`           |`]` and `}`                                    |
+|`KC_BSLASH`            |`KC_BSLS`           |`\` and <code>&#124;</code>                    |
+|`KC_NONUS_HASH`        |`KC_NUHS`           |Non-US `#` and `~`                             |
+|`KC_NONUS_BSLASH`      |`KC_NUBS`           |Non-US `\` and <code>&#124;</code>             |
+|`KC_INT1`              |`KC_RO`             |JIS `\` and <code>&#124;</code>                |
+|`KC_INT2`              |`KC_KANA`           |JIS Katakana/Hiragana                          |
+|`KC_INT3`              |`KC_JYEN`           |JIS `¥`                                        |
+|`KC_SCOLON`            |`KC_SCLN`           |`;` and `:`                                    |
+|`KC_QUOTE`             |`KC_QUOT`           |`'` and `"`                                    |
+|`KC_GRAVE`             |`KC_GRV`            |<code>&#96;</code> and `~`                     |
+|`KC_COMMA`             |`KC_COMM`           |`,` and `<`                                    |
+|`KC_DOT`               |                    |`.` and `>`                                    |
+|`KC_SLASH`             |`KC_SLSH`           |`/` and `?`                                    |
+|`KC_CAPSLOCK`          |`KC_CAPS`           |Caps Lock                                      |
+|`KC_LCTRL`             |`KC_LCTL`           |Left Control                                   |
+|`KC_LSHIFT`            |`KC_LSFT`           |Left Shift                                     |
+|`KC_LALT`              |                    |Left Alt                                       |
+|`KC_LGUI`              |`KC_LCMD`, `KC_LWIN`|Left GUI (Windows/Command/Meta key)            |
+|`KC_RCTRL`             |`KC_RCTL`           |Right Control                                  |
+|`KC_RSHIFT`            |`KC_RSFT`           |Right Shift                                    |
+|`KC_RALT`              |                    |Right Alt                                      |
+|`KC_RGUI`              |`KC_RCMD`, `KC_RWIN`|Right GUI (Windows/Command/Meta key)           |
+|`KC_LOCKING_CAPS`      |`KC_LCAP`           |Locking Caps Lock                              |
+|`KC_LOCKING_NUM`       |`KC_LNUM`           |Locking Num Lock                               |
+|`KC_LOCKING_SCROLL`    |`KC_LSCR`           |Locking Scroll Lock                            |
+|`KC_INT4`              |`KC_HENK`           |JIS Henkan                                     |
+|`KC_INT5`              |`KC_MHEN`           |JIS Muhenkan                                   |
+|`KC_PSCREEN`           |`KC_PSCR`           |Print Screen                                   |
+|`KC_SCROLLLOCK`        |`KC_SLCK`           |Scroll Lock                                    |
+|`KC_PAUSE`             |`KC_PAUS`           |Pause                                          |
+|`KC_INSERT`            |`KC_INS`            |Insert                                         |
+|`KC_HOME`              |                    |Home                                           |
+|`KC_PGUP`              |                    |Page Up                                        |
+|`KC_DELETE`            |`KC_DEL`            |Forward Delete                                 |
+|`KC_END`               |                    |End                                            |
+|`KC_PGDOWN`            |`KC_PGDN`           |Page Down                                      |
+|`KC_RIGHT`             |`KC_RGHT`           |Right Arrow                                    |
+|`KC_LEFT`              |                    |Left Arrow                                     |
+|`KC_DOWN`              |                    |Down Arrow                                     |
+|`KC_UP`                |                    |Up Arrow                                       |
+|`KC_APPLICATION`       |`KC_APP`            |Application (Windows Menu Key)                 |
+|`KC_POWER`             |                    |Deprecated by MS in favor of `KC_SYSTEM_POWER`.|
+|`KC_EXECUTE`           |                    |Execute                                        |
+|`KC_HELP`              |                    |Help                                           |
+|`KC_MENU`              |                    |Menu                                           |
+|`KC_SELECT`            |                    |Select                                         |
+|`KC_AGAIN`             |                    |Again                                          |
+|`KC_UNDO`              |                    |Undo                                           |
+|`KC_CUT`               |                    |Cut                                            |
+|`KC_COPY`              |                    |Copy                                           |
+|`KC_PASTE`             |                    |Paste                                          |
+|`KC_FIND`              |                    |Find                                           |
+|`KC_ALT_ERASE`         |                    |Alternate Erase                                |
+|`KC_SYSREQ`            |                    |SysReq/Attention                               |
+|`KC_CANCEL`            |                    |Cancel                                         |
+|`KC_CLEAR`             |                    |Clear                                          |
+|`KC_PRIOR`             |                    |Prior                                          |
+|`KC_RETURN`            |                    |Return                                         |
+|`KC_SEPARATOR`         |                    |Separator                                      |
+|`KC_OUT`               |                    |Out                                            |
+|`KC_OPER`              |                    |Oper                                           |
+|`KC_CLEAR_AGAIN`       |                    |Clear/Again                                    |
+|`KC_CRSEL`             |                    |CrSel/Props                                    |
+|`KC_EXSEL`             |                    |ExSel                                          |
+|`KC_SYSTEM_POWER`      |`KC_PWR`            |System Power Down. Recommended over `KC_POWER`.|
+|`KC_SYSTEM_SLEEP`      |`KC_SLEP`           |System Sleep                                   |
+|`KC_SYSTEM_WAKE`       |`KC_WAKE`           |System Wake                                    |
+|`KC_MAIL`              |`KC_MAIL`           |                                               |
+|`KC_CALCULATOR`        |`KC_CALC`           |                                               |
+|`KC_MY_COMPUTER`       |`KC_MYCM`           |                                               |
+|`KC_WWW_SEARCH`        |`KC_WSCH`           |                                               |
+|`KC_WWW_HOME`          |`KC_WHOM`           |                                               |
+|`KC_WWW_BACK`          |`KC_WBAK`           |                                               |
+|`KC_WWW_FORWARD`       |`KC_WFWD`           |                                               |
+|`KC_WWW_STOP`          |`KC_WSTP`           |                                               |
+|`KC_WWW_REFRESH`       |`KC_WREF`           |                                               |
+|`KC_WWW_FAVORITES`     |`KC_WFAV`           |                                               |
+|`KC_STOP`              |                    |Stop                                           |
+|`KC__MUTE`             |                    |Mute (macOS)                                   |
+|`KC__VOLUP`            |                    |Volume Up (macOS)                              |
+|`KC__VOLDOWN`          |                    |Volume Down (macOS)                            |
+|`KC_AUDIO_MUTE`        |`KC_MUTE`           |Mute (Windows/macOS/Linux)                     |
+|`KC_AUDIO_VOL_UP`      |`KC_VOLU`           |Volume Up (Windows/macOS/Linux)                |
+|`KC_AUDIO_VOL_DOWN`    |`KC_VOLD`           |Volume Down (Windows/macOS/Linux)              |
+|`KC_MEDIA_NEXT_TRACK`  |`KC_MNXT`           |Next Track (Windows)                           |
+|`KC_MEDIA_PREV_TRACK`  |`KC_MPRV`           |Previous Track (Windows)                       |
+|`KC_MEDIA_FAST_FORWARD`|`KC_MFFD`           |Next Track (macOS)                             |
+|`KC_MEDIA_REWIND`      |`KC_MRWD`           |Previous Track (macOS)                         |
+|`KC_MEDIA_STOP`        |`KC_MSTP`           |Stop Track                                     |
+|`KC_MEDIA_PLAY_PAUSE`  |`KC_MPLY`           |Play/Pause Track                               |
+|`KC_MEDIA_SELECT`      |`KC_MSEL`           |                                               |
+|`KC_NUMLOCK`           |`KC_NLCK`           |Keypad Num Lock and Clear                      |
+|`KC_KP_SLASH`          |`KC_PSLS`           |Keypad `/`                                     |
+|`KC_KP_ASTERISK`       |`KC_PAST`           |Keypad `*`                                     |
+|`KC_KP_MINUS`          |`KC_PMNS`           |Keypad `-`                                     |
+|`KC_KP_PLUS`           |`KC_PPLS`           |Keypad `+`                                     |
+|`KC_KP_ENTER`          |`KC_PENT`           |Keypad Enter                                   |
+|`KC_KP_1`              |`KC_P1`             |Keypad `1` and End                             |
+|`KC_KP_2`              |`KC_P2`             |Keypad `2` and Down Arrow                      |
+|`KC_KP_3`              |`KC_P3`             |Keypad `3` and Page Down                       |
+|`KC_KP_4`              |`KC_P4`             |Keypad `4` and Left Arrow                      |
+|`KC_KP_5`              |`KC_P5`             |Keypad `5`                                     |
+|`KC_KP_6`              |`KC_P6`             |Keypad `6` and Right Arrow                     |
+|`KC_KP_7`              |`KC_P7`             |Keypad `7` and Home                            |
+|`KC_KP_8`              |`KC_P8`             |Keypad `8` and Up Arrow                        |
+|`KC_KP_9`              |`KC_P9`             |Keypad `9` and Page Up                         |
+|`KC_KP_0`              |`KC_P0`             |Keypad `0` and Insert                          |
+|`KC_KP_DOT`            |`KC_PDOT`           |Keypad `.` and Delete                          |
+|`KC_KP_EQUAL`          |`KC_PEQL`           |Keypad `=`                                     |
+|`KC_KP_COMMA`          |`KC_PCMM`           |Keypad `,`                                     |
+|`KC_KP_EQUAL_AS400`    |                    |Keypad `=` on AS/400 keyboards                 |
+|`KC_NO`                |                    |Ignore this key (NOOP)                         |
+|`KC_TRANSPARENT`       |`KC_TRNS`           |Use the next lowest non-transparent key        |
+
+## [Mouse Keys](feature_mouse_keys.md)
+
+|Key             |Aliases  |Description                |
+|----------------|---------|---------------------------|
+|`KC_MS_UP`      |`KC_MS_U`|Mouse Cursor Up            |
+|`KC_MS_DOWN`    |`KC_MS_D`|Mouse Cursor Down          |
+|`KC_MS_LEFT`    |`KC_MS_L`|Mouse Cursor Left          |
+|`KC_MS_RIGHT`   |`KC_MS_R`|Mouse Cursor Right         |
+|`KC_MS_BTN1`    |`KC_BTN1`|Mouse Button 1             |
+|`KC_MS_BTN2`    |`KC_BTN2`|Mouse Button 2             |
+|`KC_MS_BTN3`    |`KC_BTN3`|Mouse Button 3             |
+|`KC_MS_BTN4`    |`KC_BTN4`|Mouse Button 4             |
+|`KC_MS_BTN5`    |`KC_BTN5`|Mouse Button 5             |
+|`KC_MS_WH_UP`   |`KC_WH_U`|Mouse Wheel Up             |
+|`KC_MS_WH_DOWN` |`KC_WH_D`|Mouse Wheel Down           |
+|`KC_MS_WH_LEFT` |`KC_WH_L`|Mouse Wheel Left           |
+|`KC_MS_WH_RIGHT`|`KC_WH_R`|Mouse Wheel Right          |
+|`KC_MS_ACCEL0`  |`KC_ACL0`|Set mouse acceleration to 0|
+|`KC_MS_ACCEL1`  |`KC_ACL1`|Set mouse acceleration to 1|
+|`KC_MS_ACCEL2`  |`KC_ACL2`|Set mouse acceleration to 2|
+
+## [Quantum Keycodes](quantum_keycodes.md#qmk-keycodes)
+
+|Key          |Aliases    |Description                                                          |
+|-------------|-----------|---------------------------------------------------------------------|
+|`RESET`      |           |Put the keyboard into DFU mode for flashing                          |
+|`DEBUG`      |           |Toggle debug mode                                                    |
+|`KC_GESC`    |`GRAVE_ESC`|Escape when tapped, <code>&#96;</code> when pressed with Shift or GUI|
+|`KC_LSPO`    |           |Left Shift when held, `(` when tapped                                |
+|`KC_RSPC`    |           |Right Shift when held, `)` when tapped                               |
+|`KC_LEAD`    |           |The [Leader key](feature_leader_key.md)                              |
+|`KC_LOCK`    |           |The [Lock key](feature_key_lock.md)                                  |
+|`FUNC(n)`    |`F(n)`     |Call `fn_action(n)` (deprecated)                                     |
+|`M(n)`       |           |Call macro `n`                                                       |
+|`MACROTAP(n)`|           |Macro-tap `n` idk FIXME                                              |
+
+## [Bootmagic](feature_bootmagic.md)
+
+|Key                               |Aliases  |Description                         |
+|----------------------------------|---------|------------------------------------|
+|`MAGIC_SWAP_CONTROL_CAPSLOCK`     |         |Swap Caps Lock and Left Control     |
+|`MAGIC_CAPSLOCK_TO_CONTROL`       |         |Treat Caps Lock as Control          |
+|`MAGIC_SWAP_LALT_LGUI`            |         |Swap Left Alt and GUI               |
+|`MAGIC_SWAP_RALT_RGUI`            |         |Swap Right Alt and GUI              |
+|`MAGIC_NO_GUI`                    |         |Disable the GUI key                 |
+|`MAGIC_SWAP_GRAVE_ESC`            |         |Swap <code>&#96;</code> and Escape  |
+|`MAGIC_SWAP_BACKSLASH_BACKSPACE`  |         |Swap `\` and Backspace              |
+|`MAGIC_HOST_NKRO`                 |         |Force NKRO on                       |
+|`MAGIC_SWAP_ALT_GUI`              |`AG_SWAP`|Swap Alt and GUI on both sides      |
+|`MAGIC_UNSWAP_CONTROL_CAPSLOCK`   |         |Unswap Caps Lock and Left Control   |
+|`MAGIC_UNCAPSLOCK_TO_CONTROL`     |         |Stop treating Caps Lock as Control  |
+|`MAGIC_UNSWAP_LALT_LGUI`          |         |Unswap Left Alt and GUI             |
+|`MAGIC_UNSWAP_RALT_RGUI`          |         |Unswap Right Alt and GUI            |
+|`MAGIC_UNNO_GUI`                  |         |Enable the GUI key                  |
+|`MAGIC_UNSWAP_GRAVE_ESC`          |         |Unswap <code>&#96;</code> and Escape|
+|`MAGIC_UNSWAP_BACKSLASH_BACKSPACE`|         |Unswap `\` and Backspace            |
+|`MAGIC_UNHOST_NKRO`               |         |Force NKRO off                      |
+|`MAGIC_UNSWAP_ALT_GUI`            |`AG_NORM`|Unswap Alt and GUI on both sides    |
+|`MAGIC_TOGGLE_NKRO`               |         |Turn NKRO on or off                 |
+
+## [Backlighting](feature_backlight.md)
+
+|Key      |Description                               |
+|---------|------------------------------------------|
+|`BL_TOGG`|Turn the backlight on or off              |
+|`BL_STEP`|Cycle through backlight levels            |
+|`BL_ON`  |Set the backlight to max brightness       |
+|`BL_OFF` |Turn the backlight off                    |
+|`BL_INC` |Increase the backlight level              |
+|`BL_DEC` |Decrease the backlight level              |
+|`BL_BRTG`|Toggle backlight breathing                |
+
+## [RGB Lighting](feature_rgblight.md)
+
+|Key                |Aliases   |Description                                                         |
+|-------------------|----------|--------------------------------------------------------------------|
+|`RGB_TOG`          |          |Toggle RGB lighting on or off                                       |
+|`RGB_MODE_FORWARD` |`RGB_MOD` |Cycle through modes, reverse direction when Shift is held           |
+|`RGB_MODE_REVERSE` |`RGB_RMOD`|Cycle through modes in reverse, forward direction when Shift is held|
+|`RGB_HUI`          |          |Increase hue                                                        |
+|`RGB_HUD`          |          |Decrease hue                                                        |
+|`RGB_SAI`          |          |Increase saturation                                                 |
+|`RGB_SAD`          |          |Decrease saturation                                                 |
+|`RGB_VAI`          |          |Increase value (brightness)                                         |
+|`RGB_VAD`          |          |Decrease value (brightness)                                         |
+|`RGB_MODE_PLAIN`   |`RGB_M_P `|Static (no animation) mode                                          |
+|`RGB_MODE_BREATHE` |`RGB_M_B` |Breathing animation mode                                            |
+|`RGB_MODE_RAINBOW` |`RGB_M_R` |Rainbow animation mode                                              |
+|`RGB_MODE_SWIRL`   |`RGB_M_SW`|Swirl animation mode                                                |
+|`RGB_MODE_SNAKE`   |`RGB_M_SN`|Snake animation mode                                                |
+|`RGB_MODE_KNIGHT`  |`RGB_M_K` |"Knight Rider" animation mode                                       |
+|`RGB_MODE_XMAS`    |`RGB_M_X` |Christmas animation mode                                            |
+|`RGB_MODE_GRADIENT`|`RGB_M_G` |Static gradient animation mode                                      |
+
+## [Thermal Printer](feature_thermal_printer.md)
+
+|Key        |Description                             |
+|-----------|----------------------------------------|
+|`PRINT_ON` |Start printing everything the user types|
+|`PRINT_OFF`|Stop printing everything the user types |
+
+## [Bluetooth](feature_bluetooth.md)
+
+|Key       |Description                                   |
+|----------|----------------------------------------------|
+|`OUT_AUTO`|Automatically switch between USB and Bluetooth|
+|`OUT_USB` |USB only                                      |
+|`OUT_BT`  |Bluetooth only                                |
+
+## [Modifiers](quantum_keycodes.md#modifiers)
+
+|Key       |Aliases               |Description                                         |
+|----------|----------            |----------------------------------------------------|
+|`KC_HYPR` |                      |Hold Left Control, Shift, Alt and GUI               |
+|`KC_MEH`  |                      |Hold Left Control, Shift and Alt                    |
+|`LCTL(kc)`|                      |Hold Left Control and press `kc`                    |
+|`LSFT(kc)`|`S(kc)`               |Hold Left Shift and press `kc`                      |
+|`LALT(kc)`|                      |Hold Left Alt and press `kc`                        |
+|`LGUI(kc)`|`LCMD(kc)`, `LWIN(kc)`|Hold Left GUI and press `kc`                        |
+|`RCTL(kc)`|                      |Hold Right Control and press `kc`                   |
+|`RSFT(kc)`|                      |Hold Right Shift and press `kc`                     |
+|`RALT(kc)`|                      |Hold Right Alt and press `kc`                       |
+|`RGUI(kc)`|`RCMD(kc)`, `LWIN(kc)`|Hold Right GUI and press `kc`                       |
+|`HYPR(kc)`|                      |Hold Left Control, Shift, Alt and GUI and press `kc`|
+|`MEH(kc)` |                      |Hold Left Control, Shift and Alt and press `kc`     |
+|`LCAG(kc)`|                      |Hold Left Control, Alt and GUI and press `kc`       |
+|`ALTG(kc)`|                      |Hold Right Control and Alt and press `kc`           |
+|`SGUI(kc)`|`SCMD(kc)`, `SWIN(kc)`|Hold Left Shift and GUI and press `kc`              |
+|`LCA(kc)` |                      |Hold Left Control and Alt and press `kc`            |
+
+## [Mod-Tap Keys](quantum_keycodes.md#mod-tap-keys)
+
+|Key         |Aliases                                |Description                                            |
+|------------|---------------------------------------|-------------------------------------------------------|
+|`LCTL_T(kc)`|`CTL_T(kc)`                            |Left Control when held, `kc` when tapped               |
+|`RCTL_T(kc)`|                                       |Right Control when held, `kc` when tapped              |
+|`LSFT_T(kc)`|`SFT_T(kc)`                            |Left Shift when held, `kc` when tapped                 |
+|`RSFT_T(kc)`|                                       |Right Shift when held, `kc` when tapped                |
+|`LALT_T(kc)`|`ALT_T(kc)`                            |Left Alt when held, `kc` when tapped                   |
+|`RALT_T(kc)`|`ALGR_T(kc)`                           |Right Alt when held, `kc` when tapped                  |
+|`LGUI_T(kc)`|`LCMD_T(kc)`, `RWIN_T(kc)`, `GUI_T(kc)`|Left GUI when held, `kc` when tapped                   |
+|`RGUI_T(kc)`|`RCMD_T(kc)`, `RWIN_T(kc)`             |Right GUI when held, `kc` when tapped                  |
+|`C_S_T(kc)` |                                       |Left Control and Shift when held, `kc` when tapped     |
+|`MEH_T(kc)` |                                       |Left Control, Shift and Alt when held, `kc` when tapped|
+|`LCAG_T(kc)`|                                       |Left Control, Alt and GUI when held, `kc` when tapped  |
+|`RCAG_T(kc)`|                                       |Right Control, Alt and GUI when held, `kc` when tapped |
+|`ALL_T(kc)` |                                       |Left Control, Shift, Alt and GUI when held, `kc` when tapped - more info [here](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)|
+|`SCMD_T(kc)`|`SWIN_T(kc)`                           |Left Shift and GUI when held, `kc` when tapped         |
+|`LCA_T(kc)` |                                       |Left Control and Alt when held, `kc` when tapped       |
+
+## [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
+
+|Key                     |Aliases           |Description        |
+|------------------------|------------------|-------------------|
+|`KC_TILDE`              |`KC_TILD`         |`~`                |
+|`KC_EXCLAIM`            |`KC_EXLM`         |`!`                |
+|`KC_AT`                 |                  |`@`                |
+|`KC_HASH`               |                  |`#`                |
+|`KC_DOLLAR`             |`KC_DLR`          |`$`                |
+|`KC_PERCENT`            |`KC_PERC`         |`%`                |
+|`KC_CIRCUMFLEX`         |`KC_CIRC`         |`^`                |
+|`KC_AMPERSAND`          |`KC_AMPR`         |`&`                |
+|`KC_ASTERISK`           |`KC_ASTR`         |`*`                |
+|`KC_LEFT_PAREN`         |`KC_LPRN`         |`(`                |
+|`KC_RIGHT_PAREN`        |`KC_RPRN`         |`)`                |
+|`KC_UNDERSCORE`         |`KC_UNDS`         |`_`                |
+|`KC_PLUS`               |                  |`+`                |
+|`KC_LEFT_CURLY_BRACE`   |`KC_LCBR`         |`{`                |
+|`KC_RIGHT_CURLY_BRACE`  |`KC_RCBR`         |`}`                |
+|`KC_PIPE`               |                  |<code>&#124;</code>|
+|`KC_COLON`              |`KC_COLN`         |`:`                |
+|`KC_DOUBLE_QUOTE`       |`KC_DQT`/`KC_DQUO`|`"`                |
+|`KC_LEFT_ANGLE_BRACKET` |`KC_LT`/`KC_LABK` |`<`                |
+|`KC_RIGHT_ANGLE_BRACKET`|`KC_GT`/`KC_RABK` |`>`                |
+|`KC_QUESTION`           |`KC_QUES`         |`?`                |
+
+## [Switching and Toggling Layers](feature_advanced_keycodes.md#switching-and-toggling-layers)
+
+|Key             |Description                                                                       |
+|----------------|----------------------------------------------------------------------------------|
+|`LT(layer, kc)` |Turn on `layer` when held, `kc` when tapped                                       |
+|`TO(layer)`     |Turn on `layer` when pressed                                                      |
+|`MO(layer)`     |Momentarily turn on `layer` when pressed (requires `KC_TRNS` on destination layer)|
+|`DF(layer)`     |Set the base (default) layer                                                      |
+|`TG(layer)`     |Toggle `layer` on or off                                                          |
+|`TT(layer)`     |Normally acts like MO unless it's tapped multiple times, which toggles `layer` on |
+|`LM(layer, mod)`|Momentarily turn on `layer` (like MO) with `mod` active as well.                  |
+
+## [One Shot Keys](quantum_keycodes.md#one-shot-keys)
+
+|Key         |Description                       |
+|------------|----------------------------------|
+|`OSM(mod)`  |Hold `mod` for one keypress       |
+|`OSL(layer)`|Switch to `layer` for one keypress|
+
+## [Unicode Support](feature_unicode.md)
+
+|Key         |Aliases|                                                 |
+|------------|-------|-------------------------------------------------|
+|`UNICODE(n)`|`UC(n)`|Send Unicode character `n`                       |
+|`X(n)`      |       |Send Unicode character `n` via a different method|
+
+## [Swap Hands](feature_swap_hands.md)
+
+|Key        |Description                                                              |
+|-----------|-------------------------------------------------------------------------|
+|`SH_T(key)`|Sends `key` with a tap; momentary swap when held.                        |
+|`SW_ON`    |Turns on swapping and leaves it on.                                      |
+|`SW_OFF`   |Turn off swapping and leaves it off. Good for returning to a known state.|
+|`SH_MON`   |Swaps hands when pressed, returns to normal when released (momentary).   |
+|`SH_MOFF`  |Momentarily turns off swap.                                              |
+|`SH_TG`    |Toggles swap on and off with every key press.                            |
+|`SH_TT`    |Toggles with a tap; momentary when held.                                 |

docs/keycodes_basic.md

@@ -1,192 +1,230 @@
-# Basic keycodes
+# Basic Keycodes
 
-Basic keycodes are based on [HID Usage Keyboard/Keypad Page(0x07)](http://www.usb.org/developers/hidpage/Hut1_12v2.pdf) with following exceptions:
-
-* `KC_NO` = 0 for no action
-* `KC_TRNS` = 1 for layer transparency
-* internal special keycodes in the `0xA5-DF` range (tmk heritage).
+The basic set of keycodes are based on the [HID Keyboard/Keypad Usage Page (0x07)](http://www.usb.org/developers/hidpage/Hut1_12v2.pdf) with the exception of `KC_NO`, `KC_TRNS` and keycodes in the `0xA5-DF` range. See below for more details.
 
 ## Letters and Numbers
 
-|KC_1|KC_2|KC_3|KC_4|KC_5|KC_6|KC_7|KC_8|
-|----|----|----|----|----|----|----|----|
-|KC_9|KC_0|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_F13|KC_F14|
-|KC_F15|KC_F16|KC_F17|KC_F18|KC_F19|KC_F20|KC_F21|KC_F22|
-|KC_F23|KC_F24|KC_A|KC_B|KC_C|KC_D|KC_E|KC_F|
-|KC_G|KC_H|KC_I|KC_J|KC_K|KC_L|KC_M|KC_N|
-|KC_O|KC_P|KC_Q|KC_R|KC_S|KC_T|KC_U|KC_V|
-|KC_W|KC_X|KC_Y|KC_Z|||||
+|Key   |Description|
+|------|-----------|
+|`KC_A`|`a` and `A`|
+|`KC_B`|`b` and `B`|
+|`KC_C`|`c` and `C`|
+|`KC_D`|`d` and `D`|
+|`KC_E`|`e` and `E`|
+|`KC_F`|`f` and `F`|
+|`KC_G`|`g` and `G`|
+|`KC_H`|`h` and `H`|
+|`KC_I`|`i` and `I`|
+|`KC_J`|`j` and `J`|
+|`KC_K`|`k` and `K`|
+|`KC_L`|`l` and `L`|
+|`KC_M`|`m` and `M`|
+|`KC_N`|`n` and `N`|
+|`KC_O`|`o` and `O`|
+|`KC_P`|`p` and `P`|
+|`KC_Q`|`q` and `Q`|
+|`KC_R`|`r` and `R`|
+|`KC_S`|`s` and `S`|
+|`KC_T`|`t` and `T`|
+|`KC_U`|`u` and `U`|
+|`KC_V`|`v` and `V`|
+|`KC_W`|`w` and `W`|
+|`KC_X`|`x` and `X`|
+|`KC_Y`|`y` and `Y`|
+|`KC_Z`|`z` and `Z`|
+|`KC_1`|`1` and `!`|
+|`KC_2`|`2` and `@`|
+|`KC_3`|`3` and `#`|
+|`KC_4`|`4` and `$`|
+|`KC_5`|`5` and `%`|
+|`KC_6`|`6` and `^`|
+|`KC_7`|`7` and `&`|
+|`KC_8`|`8` and `*`|
+|`KC_9`|`9` and `(`|
+|`KC_0`|`0` and `)`|
+
+## F Keys
+
+|Key     |Description|
+|--------|-----------|
+|`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_F13`|           |
+|`KC_F14`|           |
+|`KC_F15`|           |
+|`KC_F16`|           |
+|`KC_F17`|           |
+|`KC_F18`|           |
+|`KC_F19`|           |
+|`KC_F20`|           |
+|`KC_F21`|           |
+|`KC_F22`|           |
+|`KC_F23`|           |
+|`KC_F24`|           |
 
 ## Punctuation
 
-|Long Name|Short Name|Description|
-|---------|----------|-----------|
-|KC_ENTER|KC_ENT|`Return (ENTER)`|
-|KC_ESCAPE|KC_ESC|`ESCAPE`|
-|KC_BSPACE|KC_BSPC|`DELETE (Backspace)`|
-|KC_TAB||`Tab`|
-|KC_SPACE|KC_SPC|Spacebar|
-|KC_MINUS|KC_MINS|`-` and `_`|
-|KC_EQUAL|KC_EQL|`=` and `+`|
-|KC_LBRACKET|KC_LBRC|`[` and `{`|
-|KC_RBRACKET|KC_RBRC|`]` and `}`|
-|KC_BSLASH|KC_BSLS|`\` and <code>&#124;</code> |
-|KC_NONUS_HASH|KC_NUHS|Non-US `#` and `~`|
-|KC_NONUS_BSLASH|KC_NUBS|Non-US `\` and <code>&#124;</code> |
-|KC_INT1|KC_RO|JIS `\` and <code>&#124;</code> |
-|KC_INT2|KC_KANA|International216|
-|KC_INT3|KC_JYEN|Yen Symbol (`¥`)|
-|KC_SCOLON|KC_SCLN|`;` and `:`|
-|KC_QUOTE|KC_QUOT|`‘` and `“`|
-|KC_GRAVE|KC_GRV|Grave Accent and Tilde|
-|KC_COMMA|KC_COMM|`,` and `<`|
-|KC_DOT||`.` and `>`|
-|KC_SLASH|KC_SLSH|`/` and `?`|
-|KC_CAPSLOCK|KC_CAPS|Caps Lock|
+|Key              |Aliases  |Description                       |
+|-----------------|---------|----------------------------------|
+|`KC_ENTER`       |`KC_ENT` |Return (Enter)                    |
+|`KC_ESCAPE`      |`KC_ESC` |Escape                            |
+|`KC_BSPACE`      |`KC_BSPC`|Delete (Backspace)                |
+|`KC_TAB`         |         |Tab                               |
+|`KC_SPACE`       |`KC_SPC` |Spacebar                          |
+|`KC_MINUS`       |`KC_MINS`|`-` and `_`                       |
+|`KC_EQUAL`       |`KC_EQL` |`=` and `+`                       |
+|`KC_LBRACKET`    |`KC_LBRC`|`[` and `{`                       |
+|`KC_RBRACKET`    |`KC_RBRC`|`]` and `}`                       |
+|`KC_BSLASH`      |`KC_BSLS`|`\` and <code>&#124;</code>       |
+|`KC_NONUS_HASH`  |`KC_NUHS`|Non-US `#` and `~`                |
+|`KC_NONUS_BSLASH`|`KC_NUBS`|Non-US `\` and <code>&#124;</code>|
+|`KC_INT1`        |`KC_RO`  |JIS `\` and <code>&#124;</code>   |
+|`KC_INT2`        |`KC_KANA`|JIS Katakana/Hiragana             |
+|`KC_INT3`        |`KC_JYEN`|JIS `¥`                           |
+|`KC_SCOLON`      |`KC_SCLN`|`;` and `:`                       |
+|`KC_QUOTE`       |`KC_QUOT`|`'` and `"`                       |
+|`KC_GRAVE`       |`KC_GRV` |<code>&#96;</code> and `~`        |
+|`KC_COMMA`       |`KC_COMM`|`,` and `<`                       |
+|`KC_DOT`         |         |`.` and `>`                       |
+|`KC_SLASH`       |`KC_SLSH`|`/` and `?`                       |
+|`KC_CAPSLOCK`    |`KC_CAPS`|Caps Lock                         |
 
 ## Modifiers
 
-|Long Name|Short Name|Description|
-|---------|----------|-----------|
-|KC_LCTRL|KC_LCTL|LeftControl|
-|KC_LSHIFT|KC_LSFT|LeftShift|
-|KC_LALT||LeftAlt|
-|KC_LGUI||Left GUI(Windows/Apple/Meta key)|
-|KC_RCTRL|KC_RCTL|RightControl|
-|KC_RSHIFT|KC_RSFT|RightShift|
-|KC_RALT||RightAlt|
-|KC_RGUI||Right GUI(Windows/Apple/Meta key)|
-|KC_LOCKING_CAPS|KC_LCAP|Locking Caps Lock|
-|KC_LOCKING_NUM|KC_LNUM|Locking Num Lock|
-|KC_LOCKING_SCROLL|KC_LSCR|Locking Scroll Lock|
-|KC_INT4|KC_HENK|JIS Henken|
-|KC_INT5|KC_MHEN|JIS Muhenken|
+|Key                |Aliases             |Description                         |
+|-------------------|--------------------|------------------------------------|
+|`KC_LCTRL`         |`KC_LCTL`           |Left Control                        |
+|`KC_LSHIFT`        |`KC_LSFT`           |Left Shift                          |
+|`KC_LALT`          |                    |Left Alt                            |
+|`KC_LGUI`          |`KC_LCMD`, `KC_LWIN`|Left GUI (Windows/Command/Meta key) |
+|`KC_RCTRL`         |`KC_RCTL`           |Right Control                       |
+|`KC_RSHIFT`        |`KC_RSFT`           |Right Shift                         |
+|`KC_RALT`          |                    |Right Alt                           |
+|`KC_RGUI`          |`KC_RCMD`, `KC_RWIN`|Right GUI (Windows/Command/Meta key)|
+|`KC_LOCKING_CAPS`  |`KC_LCAP`           |Locking Caps Lock                   |
+|`KC_LOCKING_NUM`   |`KC_LNUM`           |Locking Num Lock                    |
+|`KC_LOCKING_SCROLL`|`KC_LSCR`           |Locking Scroll Lock                 |
+|`KC_INT4`          |`KC_HENK`           |JIS Henkan                          |
+|`KC_INT5`          |`KC_MHEN`           |JIS Muhenkan                        |
 
 ## Commands
 
-|Long Name|Short Name|Description|
-|---------|----------|-----------|
-|KC_PSCREEN|KC_PSCR|PrintScreen|
-|KC_SCROLLLOCK|KC_SLCK|Scroll Lock|
-|KC_PAUSE|KC_PAUS|Pause|
-|KC_INSERT|KC_INS|Insert|
-|KC_HOME||Home|
-|KC_PGUP||PageUp|
-|KC_DELETE|KC_DEL|Delete Forward|
-|KC_END||End|
-|KC_PGDOWN|KC_PGDN|PageDown|
-|KC_RIGHT|KC_RGHT|RightArrow|
-|KC_LEFT||LeftArrow|
-|KC_DOWN||DownArrow|
-|KC_UP||UpArrow|
-|KC_APPLICATION|KC_APP|Application|
-|KC_POWER||Power|
-|KC_EXECUTE||Execute|
-|KC_HELP||Help|
-|KC_MENU||Menu|
-|KC_SELECT||Select|
-|KC_AGAIN||Again|
-|KC_UNDO||Undo|
-|KC_CUT||Cut|
-|KC_COPY||Copy|
-|KC_PASTE||Paste|
-|KC_FIND||Find|
-|KC_ALT_ERASE||Alternate Erase|
-|KC_SYSREQ||SysReq/Attention|
-|KC_CANCEL||Cancel|
-|KC_CLEAR||Clear|
-|KC_PRIOR||Prior|
-|KC_RETURN||Return|
-|KC_SEPARATOR||Separator|
-|KC_OUT||Out|
-|KC_OPER||Oper|
-|KC_CLEAR_AGAIN||Clear/Again|
-|KC_CRSEL||CrSel/Props|
-|KC_EXSEL||ExSel|
-|KC_SYSTEM_POWER|KC_PWR|System Power Down|
-|KC_SYSTEM_SLEEP|KC_SLEP|System Sleep|
-|KC_SYSTEM_WAKE|KC_WAKE|System Wake|
-|KC_MAIL|KC_MAIL||
-|KC_CALCULATOR|KC_CALC||
-|KC_MY_COMPUTER|KC_MYCM||
-|KC_WWW_SEARCH|KC_WSCH||
-|KC_WWW_HOME|KC_WHOM||
-|KC_WWW_BACK|KC_WBAK||
-|KC_WWW_FORWARD|KC_WFWD||
-|KC_WWW_STOP|KC_WSTP||
-|KC_WWW_REFRESH|KC_WREF||
-|KC_WWW_FAVORITES|KC_WFAV||
+|Key               |Aliases  |Description                   |
+|------------------|---------|------------------------------|
+|`KC_PSCREEN`      |`KC_PSCR`|Print Screen                  |
+|`KC_SCROLLLOCK`   |`KC_SLCK`|Scroll Lock                   |
+|`KC_PAUSE`        |`KC_PAUS`|Pause                         |
+|`KC_INSERT`       |`KC_INS` |Insert                        |
+|`KC_HOME`         |         |Home                          |
+|`KC_PGUP`         |         |Page Up                       |
+|`KC_DELETE`       |`KC_DEL` |Forward Delete                |
+|`KC_END`          |         |End                           |
+|`KC_PGDOWN`       |`KC_PGDN`|Page Down                     |
+|`KC_RIGHT`        |`KC_RGHT`|Right Arrow                   |
+|`KC_LEFT`         |         |Left Arrow                    |
+|`KC_DOWN`         |         |Down Arrow                    |
+|`KC_UP`           |         |Up Arrow                      |
+|`KC_APPLICATION`  |`KC_APP` |Application (Windows Menu Key)|
+|`KC_POWER`        |         |Power                         |
+|`KC_EXECUTE`      |         |Execute                       |
+|`KC_HELP`         |         |Help                          |
+|`KC_MENU`         |         |Menu                          |
+|`KC_SELECT`       |         |Select                        |
+|`KC_AGAIN`        |         |Again                         |
+|`KC_UNDO`         |         |Undo                          |
+|`KC_CUT`          |         |Cut                           |
+|`KC_COPY`         |         |Copy                          |
+|`KC_PASTE`        |         |Paste                         |
+|`KC_FIND`         |         |Find                          |
+|`KC_ALT_ERASE`    |         |Alternate Erase               |
+|`KC_SYSREQ`       |         |SysReq/Attention              |
+|`KC_CANCEL`       |         |Cancel                        |
+|`KC_CLEAR`        |         |Clear                         |
+|`KC_PRIOR`        |         |Prior                         |
+|`KC_RETURN`       |         |Return                        |
+|`KC_SEPARATOR`    |         |Separator                     |
+|`KC_OUT`          |         |Out                           |
+|`KC_OPER`         |         |Oper                          |
+|`KC_CLEAR_AGAIN`  |         |Clear/Again                   |
+|`KC_CRSEL`        |         |CrSel/Props                   |
+|`KC_EXSEL`        |         |ExSel                         |
 
 ## Media Keys
 
-Windows and Mac use different key codes for next track and previous track. Make sure you choose the keycode that corresponds to your OS.
-
-|Long Name|Short Name|Description|
-|---------|----------|-----------|
-|KC_STOP||Stop|
-|KC__MUTE||Mute (macOS)|
-|KC__VOLUP||Volume Up (macOS)|
-|KC__VOLDOWN||Volume Down (macOS)|
-|KC_AUDIO_MUTE|KC_MUTE|Mute (Windows/macOS/Linux)|
-|KC_AUDIO_VOL_UP|KC_VOLU|Volume Up (Windows/macOS/Linux)|
-|KC_AUDIO_VOL_DOWN|KC_VOLD|Volume Down (Windows/macOS/Linux)|
-|KC_MEDIA_NEXT_TRACK|KC_MNXT|Next Track (Windows)|
-|KC_MEDIA_PREV_TRACK|KC_MPRV|Previous Track (Windows)|
-|KC_MEDIA_FAST_FORWARD|KC_MFFD|Next Track (macOS)|
-|KC_MEDIA_REWIND|KC_MRWD|Previous Track (macOS)|
-|KC_MEDIA_STOP|KC_MSTP||
-|KC_MEDIA_PLAY_PAUSE|KC_MPLY||
-|KC_MEDIA_SELECT|KC_MSEL||
-
-## Numpad
-
-|Long Name|Short Name|Description|
-|---------|----------|-----------|
-|KC_NUMLOCK|KC_NLCK|Keypad Num Lock and Clear|
-|KC_KP_SLASH|KC_PSLS|Keypad /|
-|KC_KP_ASTERISK|KC_PAST|Keypad *|
-|KC_KP_MINUS|KC_PMNS|Keypad -|
-|KC_KP_PLUS|KC_PPLS|Keypad +|
-|KC_KP_ENTER|KC_PENT|Keypad ENTER|
-|KC_KP_1|KC_P1|Keypad 1 and End|
-|KC_KP_2|KC_P2|Keypad 2 and Down Arrow|
-|KC_KP_3|KC_P3|Keypad 3 and PageDn|
-|KC_KP_4|KC_P4|Keypad 4 and Left Arrow|
-|KC_KP_5|KC_P5|Keypad 5|
-|KC_KP_6|KC_P6|Keypad 6 and Right Arrow|
-|KC_KP_7|KC_P7|Keypad 7 and Home|
-|KC_KP_8|KC_P8|Keypad 8 and Up Arrow|
-|KC_KP_9|KC_P9|Keypad 9 and PageUp|
-|KC_KP_0|KC_P0|Keypad 0 and Insert|
-|KC_KP_DOT|KC_PDOT|Keypad . and Delete|
-|KC_KP_EQUAL|KC_PEQL|Keypad =|
-|KC_KP_COMMA|KC_PCMM|Keypad Comma|
-|KC_KP_EQUAL_AS400||Keypad Equal Sign|
+These keycodes are not part of the Keyboard/Keypad usage page. The `SYSTEM_` keycodes are found in the Generic Desktop page, and the rest are located in the Consumer page.
+
+Windows and macOS use different keycodes for "next track" and "previous track". Make sure you choose the keycode that corresponds to your OS.
+
+|Key                    |Aliases  |Description                      |
+|-----------------------|---------|---------------------------------|
+|`KC_SYSTEM_POWER`      |`KC_PWR` |System Power Down                |
+|`KC_SYSTEM_SLEEP`      |`KC_SLEP`|System Sleep                     |
+|`KC_SYSTEM_WAKE`       |`KC_WAKE`|System Wake                      |
+|`KC_MAIL`              |`KC_MAIL`|                                 |
+|`KC_CALCULATOR`        |`KC_CALC`|                                 |
+|`KC_MY_COMPUTER`       |`KC_MYCM`|                                 |
+|`KC_WWW_SEARCH`        |`KC_WSCH`|                                 |
+|`KC_WWW_HOME`          |`KC_WHOM`|                                 |
+|`KC_WWW_BACK`          |`KC_WBAK`|                                 |
+|`KC_WWW_FORWARD`       |`KC_WFWD`|                                 |
+|`KC_WWW_STOP`          |`KC_WSTP`|                                 |
+|`KC_WWW_REFRESH`       |`KC_WREF`|                                 |
+|`KC_STOP`              |         |Stop                             |
+|`KC_WWW_FAVORITES`     |`KC_WFAV`|                                 |
+|`KC__MUTE`             |         |Mute (macOS)                     |
+|`KC__VOLUP`            |         |Volume Up (macOS)                |
+|`KC__VOLDOWN`          |         |Volume Down (macOS)              |
+|`KC_AUDIO_MUTE`        |`KC_MUTE`|Mute (Windows/macOS/Linux)       |
+|`KC_AUDIO_VOL_UP`      |`KC_VOLU`|Volume Up (Windows/macOS/Linux)  |
+|`KC_AUDIO_VOL_DOWN`    |`KC_VOLD`|Volume Down (Windows/macOS/Linux)|
+|`KC_MEDIA_NEXT_TRACK`  |`KC_MNXT`|Next Track (Windows)             |
+|`KC_MEDIA_PREV_TRACK`  |`KC_MPRV`|Previous Track (Windows)         |
+|`KC_MEDIA_FAST_FORWARD`|`KC_MFFD`|Next Track (macOS)               |
+|`KC_MEDIA_REWIND`      |`KC_MRWD`|Previous Track (macOS)           |
+|`KC_MEDIA_STOP`        |`KC_MSTP`|Stop Track                       |
+|`KC_MEDIA_PLAY_PAUSE`  |`KC_MPLY`|Play/Pause Track                 |
+|`KC_MEDIA_SELECT`      |`KC_MSEL`|                                 |
+
+## Number Pad
+
+|Key                |Aliases  |Description                   |
+|-------------------|---------|------------------------------|
+|`KC_NUMLOCK`       |`KC_NLCK`|Keypad Num Lock and Clear     |
+|`KC_KP_SLASH`      |`KC_PSLS`|Keypad `/`                    |
+|`KC_KP_ASTERISK`   |`KC_PAST`|Keypad `*`                    |
+|`KC_KP_MINUS`      |`KC_PMNS`|Keypad `-`                    |
+|`KC_KP_PLUS`       |`KC_PPLS`|Keypad `+`                    |
+|`KC_KP_ENTER`      |`KC_PENT`|Keypad Enter                  |
+|`KC_KP_1`          |`KC_P1`  |Keypad `1` and End            |
+|`KC_KP_2`          |`KC_P2`  |Keypad `2` and Down Arrow     |
+|`KC_KP_3`          |`KC_P3`  |Keypad `3` and Page Down      |
+|`KC_KP_4`          |`KC_P4`  |Keypad `4` and Left Arrow     |
+|`KC_KP_5`          |`KC_P5`  |Keypad `5`                    |
+|`KC_KP_6`          |`KC_P6`  |Keypad `6` and Right Arrow    |
+|`KC_KP_7`          |`KC_P7`  |Keypad `7` and Home           |
+|`KC_KP_8`          |`KC_P8`  |Keypad `8` and Up Arrow       |
+|`KC_KP_9`          |`KC_P9`  |Keypad `9` and Page Up        |
+|`KC_KP_0`          |`KC_P0`  |Keypad `0` and Insert         |
+|`KC_KP_DOT`        |`KC_PDOT`|Keypad `.` and Delete         |
+|`KC_KP_EQUAL`      |`KC_PEQL`|Keypad `=`                    |
+|`KC_KP_COMMA`      |`KC_PCMM`|Keypad `,`                    |
+|`KC_KP_EQUAL_AS400`|         |Keypad `=` on AS/400 keyboards|
 
 ## Special Keys
 
-|Long Name|Short Name|Description|
-|---------|----------|-----------|
-|KC_NO||Ignore this key. (NOOP) |
-
-## Mousekey
-
-|Long Name|Short Name|Description|
-|---------|----------|-----------|
-|KC_MS_UP|KC_MS_U|Mouse Cursor Up|
-|KC_MS_DOWN|KC_MS_D|Mouse Cursor Down|
-|KC_MS_LEFT|KC_MS_L|Mouse Cursor Left|
-|KC_MS_RIGHT|KC_MS_R|Mouse Cursor Right|
-|KC_MS_BTN1|KC_BTN1|Mouse Button 1|
-|KC_MS_BTN2|KC_BTN2|Mouse Button 2|
-|KC_MS_BTN3|KC_BTN3|Mouse Button 3|
-|KC_MS_BTN4|KC_BTN4|Mouse Button 4|
-|KC_MS_BTN5|KC_BTN5|Mouse Button 5|
-|KC_MS_WH_UP|KC_WH_U|Mouse Wheel Up|
-|KC_MS_WH_DOWN|KC_WH_D|Mouse Wheel Down|
-|KC_MS_WH_LEFT|KC_WH_L|Mouse Wheel Left|
-|KC_MS_WH_RIGHT|KC_WH_R|Mouse Wheel Right|
-|KC_MS_ACCEL0|KC_ACL0|Mouse Acceleration 0|
-|KC_MS_ACCEL1|KC_ACL1|Mouse Acceleration 1|
-|KC_MS_ACCEL2|KC_ACL2|Mouse Acceleration 2|
+In addition to these, keycodes in the range of `0xA5-DF` are reserved for internal use by TMK.
+
+|Key             |Aliases  |Description                            |
+|----------------|---------|---------------------------------------|
+|`KC_NO`         |         |Ignore this key (NOOP)                 |
+|`KC_TRANSPARENT`|`KC_TRNS`|Use the next lowest non-transparent key|

docs/keycodes_us_ansi_shifted.md

@@ -1,31 +1,31 @@
-# US ANSI Shifted symbols
+# US ANSI Shifted Symbols
 
-These keycodes correspond to characters that are "shifted" on a standard US ANSI keyboards. They do not have dedicated keycodes but are instead typed by holding down shift and then sending a keycode. 
+These keycodes correspond to characters that are "shifted" on a standard US ANSI keyboards. They do not have dedicated keycodes but are instead typed by holding down shift and then sending a keycode.
 
 It's important to remember that all of these keycodes send a left shift - this may cause unintended actions if unaccounted for. The short code is preferred in most situations.
 
 ## US ANSI Shifted Keycodes
 
-|Short Name|Long Name|Description|
-|----------|---------|-----------|
-|`KC_TILD`|`KC_TILDE`|tilde `~`|
-|`KC_EXLM`|`KC_EXCLAIM`|exclamation mark `!`|
-|`KC_AT`||at sign `@`|
-|`KC_HASH`||hash sign `#`|
-|`KC_DLR`|`KC_DOLLAR`|dollar sign `$`|
-|`KC_PERC`|`KC_PERCENT`|percent sign `%`|
-|`KC_CIRC`|`KC_CIRCUMFLEX`|circumflex `^`|
-|`KC_AMPR`|`KC_AMPERSAND`|ampersand `&`|
-|`KC_ASTR`|`KC_ASTERISK`|asterisk `*`|
-|`KC_LPRN`|`KC_LEFT_PAREN`|left parenthesis `(`|
-|`KC_RPRN`|`KC_RIGHT_PAREN`|right parenthesis `)`|
-|`KC_UNDS`|`KC_UNDERSCORE`|underscore `_`|
-|`KC_PLUS`||plus sign `+`|
-|`KC_LCBR`|`KC_LEFT_CURLY_BRACE`|left curly brace `{`|
-|`KC_RCBR`|`KC_RIGHT_CURLY_BRACE`|right curly brace `}`|
-|`KC_LT`/`KC_LABK`|`KC_LEFT_ANGLE_BRACKET`|left angle bracket `<`|
-|`KC_GT`/`KC_RABK`|`KC_RIGHT_ANGLE_BRACKET`|right angle bracket `>`|
-|`KC_COLN`|`KC_COLON`|colon `:`|
-|`KC_PIPE`||pipe `\|`|
-|`KC_QUES`|`KC_QUESTION`|question mark `?`|
-|`KC_DQT`/`KC_DQUO`|`KC_DOUBLE_QUOTE`|double quote `"`|
+|Key                     |Aliases           |Description        |
+|------------------------|------------------|-------------------|
+|`KC_TILDE`              |`KC_TILD`         |`~`                |
+|`KC_EXCLAIM`            |`KC_EXLM`         |`!`                |
+|`KC_AT`                 |                  |`@`                |
+|`KC_HASH`               |                  |`#`                |
+|`KC_DOLLAR`             |`KC_DLR`          |`$`                |
+|`KC_PERCENT`            |`KC_PERC`         |`%`                |
+|`KC_CIRCUMFLEX`         |`KC_CIRC`         |`^`                |
+|`KC_AMPERSAND`          |`KC_AMPR`         |`&`                |
+|`KC_ASTERISK`           |`KC_ASTR`         |`*`                |
+|`KC_LEFT_PAREN`         |`KC_LPRN`         |`(`                |
+|`KC_RIGHT_PAREN`        |`KC_RPRN`         |`)`                |
+|`KC_UNDERSCORE`         |`KC_UNDS`         |`_`                |
+|`KC_PLUS`               |                  |`+`                |
+|`KC_LEFT_CURLY_BRACE`   |`KC_LCBR`         |`{`                |
+|`KC_RIGHT_CURLY_BRACE`  |`KC_RCBR`         |`}`                |
+|`KC_PIPE`               |                  |<code>&#124;</code>|
+|`KC_COLON`              |`KC_COLN`         |`:`                |
+|`KC_DOUBLE_QUOTE`       |`KC_DQT`/`KC_DQUO`|`"`                |
+|`KC_LEFT_ANGLE_BRACKET` |`KC_LT`/`KC_LABK` |`<`                |
+|`KC_RIGHT_ANGLE_BRACKET`|`KC_GT`/`KC_RABK` |`>`                |
+|`KC_QUESTION`           |`KC_QUES`         |`?`                |

docs/keymap.md

@@ -3,7 +3,7 @@
 QMK keymaps are defined inside a C source file. The data structure is an array of arrays. The outer array is a list of layer arrays while the inner layer array is a list of keys. Most keyboards define a `KEYMAP()` macro to help you create this array of arrays.
 
 
-## Keymap and layers
+## Keymap and Layers
 In QMK,  **`const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS]`** holds multiple **layers** of keymap information in **16 bit** data holding the **action code**. You can define **32 layers** at most.
 
 For trivial key definitions, the higher 8 bits of the **action code** are all 0 and the lower 8 bits holds the USB HID usage code generated by the key as **keycode**.
@@ -27,16 +27,16 @@ Respective layers can be validated simultaneously. Layers are indexed with 0 to
 
 Sometimes, the action code stored in keymap may be referred as keycode in some documents due to the TMK history.
 
-### Keymap layer status
+### Keymap Layer Status
 The state of the Keymap layer is determined by two 32 bit parameters:
 
 * **`default_layer_state`** indicates a base keymap layer (0-31) which is always valid and to be referred (the default layer).
 * **`layer_state`** has current on/off status of each layer in its bits.
 
-Keymap layer '0' is usually `default_layer`, wither other layers initially off after booting up the firmware, although this can configured differently in `config.h`. It is useful to change `default_layer` when you completely switch a key layout, for example, if you want to switch to Colemak instead of Qwerty.
+Keymap layer '0' is usually the `default_layer`, with other layers initially off after booting up the firmware, although this can configured differently in `config.h`. It is useful to change `default_layer` when you completely switch a key layout, for example, if you want to switch to Colemak instead of Qwerty.
 
-    Initial state of Keymap          Change base layout              
-    -----------------------          ------------------              
+    Initial state of Keymap          Change base layout
+    -----------------------          ------------------
 
       31                               31
       30                               30
@@ -75,9 +75,9 @@ Note that ***higher layer has higher priority on stack of layers***, namely firm
 You can place `KC_TRANS` on overlay layer changes just part of layout to fall back on lower or base layer.
 Key with `KC_TRANS` (`KC_TRNS` and `_______` are the alias) doesn't has its own keycode and refers to lower valid layers for keycode, instead.
 
-## Anatomy Of A `keymap.c`
+## Anatomy of a `keymap.c`
 
-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.
+For this example we will walk through an [older version of the default Clueboard 66% keymap](https://github.com/qmk/qmk_firmware/blob/ca01d94005f67ec4fa9528353481faa622d949ae/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.
 
 There are 3 main sections of a `keymap.c` file you'll want to concern yourself with:
 
@@ -98,7 +98,7 @@ At the top of the file you'll find this:
     // Each layer gets a name for readability.
     // 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 
+    // Layer names don't all need to be of the same
     // length, and you can also skip them entirely
     // and just use numbers.
     #define _BL 0
@@ -113,9 +113,9 @@ The main part of this file is the `keymaps[]` definition. This is where you list
 
     const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
-After this you'll find a list of KEYMAP() macros. A KEYMAP() is simply a list of keys to define a single layer. Typically you'll have one or more "base layers" (such as QWERTY, Dvorak, or Colemak) and then you'll layer on top of that one or more "function" layers. Due to the way layers are processed you can't overlay a "lower" layer on top of a "higher" layer. 
+After this you'll find a list of KEYMAP() macros. A KEYMAP() is simply a list of keys to define a single layer. Typically you'll have one or more "base layers" (such as QWERTY, Dvorak, or Colemak) and then you'll layer on top of that one or more "function" layers. Due to the way layers are processed you can't overlay a "lower" layer on top of a "higher" layer.
 
-`keymaps[][MATRIX_ROWS][MATRIX_COLS]` in QMK holds the 16 bit action code (sometimes referred as the quantum keycode) in it.  For the keycode representing typical keys, its high byte is 0 and its low byte is the USB HID usage ID for keyboard. 
+`keymaps[][MATRIX_ROWS][MATRIX_COLS]` in QMK holds the 16 bit action code (sometimes referred as the quantum keycode) in it.  For the keycode representing typical keys, its high byte is 0 and its low byte is the USB HID usage ID for keyboard.
 
 > TMK from which QMK was forked uses `const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS]` instead and holds the 8 bit keycode.  Some keycode values are reserved to induce execution of certain action codes via the `fn_actions[]` array.
 
@@ -153,11 +153,11 @@ Our function layer is, from a code point of view, no different from the base lay
 Some interesting things to note:
 
 * We have used our `_______` definition to turn `KC_TRNS` into `_______`. This makes it easier to spot the keys that have changed on this layer.
-* While in this layer if you press one of the `_______` keys it will activate the key in the next lowest active layer. 
+* While in this layer if you press one of the `_______` keys it will activate the key in the next lowest active layer.
 
 ### Custom Functions
 
-At the bottom of the file we've defined a single custom function. This function defines a key that sends `KC_ESC` when pressed without modifiers and `KC_GRAVE` when modifiers are held. There are a couple pieces that need to be in place for this to work, and we will go over both of them. 
+At the bottom of the file we've defined a single custom function. This function defines a key that sends `KC_ESC` when pressed without modifiers and `KC_GRAVE` when modifiers are held. There are a couple pieces that need to be in place for this to work, and we will go over both of them.
 
 #### `fn_actions[]`
 
@@ -171,6 +171,8 @@ In this case we've instructed QMK to call the `ACTION_FUNCTION` callback, which
 
 > This `fn_actions[]` interface is mostly for backward compatibility.  In QMK, you don't need to use `fn_actions[]`.  You can directly use `ACTION_FUNCTION(N)` or any other action code value itself normally generated by the macro in `keymaps[][MATRIX_ROWS][MATRIX_COLS]`.  N in `F(N)` can only be 0 to 31.  Use of the action code directly in `keymaps` unlocks this limitation.
 
+You can get a full list of Action Functions in [action_code.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action_code.h). 
+
 #### `action_function()`
 
 To actually handle the keypress event we define an `action_function()`. This function will be called when the key is pressed, and then again when the key is released. We have to handle both situations within our code, as well as determining whether to send/release `KC_ESC` or `KC_GRAVE`.

docs/newbs.md

@@ -0,0 +1,16 @@
+# The Compelete Newbs Guide To QMK
+
+QMK is a powerful Open Source firmware for your mechanical keyboard. You can use QMK to customize your keyboard in ways both simple and powerful. People of all skill levels, from complete newbie to master programmer, have successfully used QMK to customize their keyboard. This guide will help you do the same, no matter your skill level.
+
+Not sure if your keyboard can run QMK? If it's a mechanical keyboard you built yourself chances are good it can. We support a [large number of hobbyist boards](http://qmk.fm/keyboards/), so even if your current keyboard can't run QMK you shouldn't have trouble finding one to suit your needs.
+
+## Overview
+
+There are 4 main sections to this guide:
+
+* [Getting Started](newbs_getting_started.md)
+* [Building Your First Firmware](newbs_building_firmware.md)
+* [Flashing Firmware](newbs_flashing.md)
+* [Testing and Debugging](newbs_testing_debugging.md)
+
+This guide is focused on helping someone who has never compiled software before. It makes choices and recommendations based on that viewpoint. There are alternative methods for many of these procedures, and we support most of those alternatives. If you have any doubt about how to accomplish a task you can [ask us for guidance](getting_started_getting_help.md).

docs/newbs_building_firmware.md

@@ -0,0 +1,73 @@
+# Building Your First Firmware
+
+Now that you have setup your build environment you are ready to start building custom firmware. For this section of the guide we will bounce between 3 programs- your file manager, your text editor, and your terminal window. Keep all 3 open until you are done and happy with your keyboard firmware.
+
+If you have closed and reopened your terminal window since following the first part of the guide, don't forget to `cd qmk_firmware` so that your terminal is in the correct directory.
+
+## Navigate To Your Keymaps Folder
+
+Start by navigating to the `keymaps` folder for your keyboard.
+
+{% hint style='info' %}
+If you are on macOS or Windows there are commands you can use to easily open the keymaps folder.
+
+macOS:
+
+    open keyboards/<keyboard_folder>/keymaps
+
+Windows:
+
+    start keyboards/<keyboard_folder>/keymaps
+{% endhint %}
+
+## Create a Copy Of The `default` Keymap
+
+Once you have the `keymaps` folder open you will want to create a copy of the `default` folder. We highly recommend you name your folder the same as your GitHub username, but you can use any name you want as long as it contains only lower case letters, numbers, and the underscore character.
+
+## Open `keymap.c` In Your Favorite Text Editor
+
+Open up your `keymap.c`. Inside this file you'll find the structure that controls how your keyboard behaves. At the top of `keymap.c` there may be some defines and enums that make the keymap easier to read. Farther down you'll find a line that looks like this:
+
+    const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+This line indicates the start of the list of Layers. Below that you'll find lines containing either `LAYOUT` or `KEYMAP`, and these lines indicate the start of a layer. Below that line is the list of keys that comprise a that particular layer.
+
+{% hint style='danger' %}
+When editing your keymap file be careful not to add or remove any commas. If you do you will prevent your firmware from compiling and it may not be easy to figure out where the extra, or missing, comma is.
+{% endhint %}
+
+## Customize The Layout To Your Liking
+
+How to complete this step is entirely up to you. Make the one change that's been bugging you, or completely rework everything. You can remove layers if you don't need all of them, or add layers up to a total of 32. Check the following documentation to find out what you can define here:
+
+* [Keycodes](keycodes.md)
+* [Features](features.md)
+* [FAQ](faq.md)
+
+{% hint style='info' %}
+While you get a feel for how keymaps work, keep each change small. Bigger changes make it harder to debug any problems that arise.
+{% endhint %}
+
+## Build Your Firmware
+
+When your changes to the keymap are complete you will need to build the firmware. To do so go back to your terminal window and run the build command:
+
+    make <my_keyboard>:<my_keymap>
+
+For example, if your keymap is named "xyverz" and you're building a keymap for a rev5 planck, you'll use this command:
+
+    make planck/rev5:xyverz
+
+While this compiles you will have a lot of output going to the screen informing you of what files are being compiled. It should end with output that looks similar to this:
+
+```
+Linking: .build/planck_rev5_xyverz.elf                                                              [OK]
+Creating load file for flashing: .build/planck_rev5_xyverz.hex                                      [OK]
+Copying planck_rev5_xyverz.hex to qmk_firmware folder                                               [OK]
+Checking file size of planck_rev5_xyverz.hex                                                        [OK]
+ * File size is fine - 18392/28672
+```
+
+## Flash Your Firmware
+
+Move on to [Flashing Firmware](newbs_flashing.md) to learn how to write your new firmware to your keyboard.

docs/newbs_flashing.md

@@ -0,0 +1,242 @@
+# Flashing Your Keyboard 
+
+Now that you've built a custom firmware file you'll want to flash your keyboard. 
+
+## Flashing Your Keyboard with QMK Toolbox
+
+The simplest way to flash your keyboard will be with the [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases). 
+
+However, the QMK Toolbox is only available for Windows and macOS currently.  If you're using Linux (or just wish to flash the firmware from the command line), you'll have to use the [method outlined below](newbs_flashing.md#flash-your-keyboard-from-the-command-line).
+
+### Load The File Into QMK Toolbox
+
+Begin by opening the QMK Toolbox application. You'll want to locate the firmware file in Finder or Explorer. Your keyboard firmware may be in one of two formats- `.hex` or `.bin`. QMK tries to copy the appropriate one for your keyboard into the root `qmk_firmware` directory.
+
+{% hint style='info' %}
+If you are on Windows or macOS there are commands you can use to easily open the current firmware folder in Explorer or Finder.
+
+Windows:
+
+    start .
+
+macOS:
+
+    open .
+{% endhint %}
+
+The firmware file always follows this naming format:
+
+    <keyboard_name>_<keymap_name>.{bin,hex}
+
+For example, the `plank/rev5` with a `default` keymap will have this filename:
+
+    planck_rev5_default.hex
+
+Once you have located your firmware file drag it into the "Local file" box in QMK Toolbox, or click "Open" and navigate to where your firmware file is stored. 
+
+### Put Your Keyboard Into DFU (Bootloader) Mode
+
+In order to flash your custom firmware you have to put your keyboard into a special flashing mode. While it is in this mode you will not be able to type or otherwise use your keyboard. It is very important that you do not unplug your keyboard or otherwise interrupt the flashing process while the firmware is being written.
+
+Different keyboards have different ways to enter this special mode. If your PCB currently runs QMK or TMK and you have not been given specific instructions try the following, in order:
+
+* Hold down both shift keys and press `Pause`
+* Hold down both shift keys and press `B`
+* Unplug your keyboard, hold down the Spacebar and `B` at the same time, plug in your keyboard and wait a second before releasing the keys
+* Press the physical `RESET` button on the bottom of the PCB
+* Locate header pins on the PCB labeled `BOOT0` or `RESET`, short those together while plugging your PCB in
+
+When you are successful you will see a message similar to this in QMK Toolbox:
+
+```
+*** Clueboard - Clueboard 66% HotSwap disconnected -- 0xC1ED:0x2390
+*** DFU device connected
+```
+
+### Flash Your Keyboard
+
+Click the `Flash` button in QMK Toolbox. You will see output similar to the following:
+
+```
+*** Clueboard - Clueboard 66% HotSwap disconnected -- 0xC1ED:0x2390
+*** DFU device connected
+*** Attempting to flash, please don't remove device
+>>> dfu-programmer atmega32u4 erase --force
+    Erasing flash...  Success
+    Checking memory from 0x0 to 0x6FFF...  Empty.
+>>> dfu-programmer atmega32u4 flash /Users/skully/qmk_firmware/clueboard_66_hotswap_gen1_skully.hex
+    Checking memory from 0x0 to 0x55FF...  Empty.
+    0%                            100%  Programming 0x5600 bytes...
+    [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
+    0%                            100%  Reading 0x7000 bytes...
+    [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
+    Validating...  Success
+    0x5600 bytes written into 0x7000 bytes memory (76.79%).
+>>> dfu-programmer atmega32u4 reset
+    
+*** DFU device disconnected
+*** Clueboard - Clueboard 66% HotSwap connected -- 0xC1ED:0x2390
+```
+
+## Flash your Keyboard from the Command Line
+
+First thing you'll need to know is which bootloader that your keyboard uses.  There are four main bootloaders that are used, usually. Pro-Micro and clones use CATERINA, and Teensy's use Halfkay, OLKB boards use QMK-DFU, and other atmega32u4 chips use DFU. 
+
+You can find more information about the bootloaders in the [Flashing Instructions and Bootloader Information](flashing.md) page. 
+
+If you know what bootloader that you're using, then when compiling the firmware, you can actually add some extra text to the `make` command to automate the flashing process. 
+
+### DFU
+
+For the DFU bootloader, when you're ready to compile and flash your firmware, open up your terminal window and run the built command: 
+
+    make <my_keyboard>:<my_keymap>:dfu
+
+For example, if your keymap is named "xyverz" and you're building a keymap for a rev5 planck, you'll use this command:
+
+    make planck/rev5:xyverz:dfu
+
+Once it finishes compiling, it should output the following:
+
+```
+Linking: .build/planck_rev5_xyverz.elf                                                              [OK]
+Creating load file for flashing: .build/planck_rev5_xyverz.hex                                      [OK]
+Copying planck_rev5_xyverz.hex to qmk_firmware folder                                               [OK]
+Checking file size of planck_rev5_xyverz.hex                                                        
+ * File size is fine - 18574/28672
+ ```
+
+After it gets to this point, the build script will look for the DFU bootloader every 5 seconds.  It will repeat the following until the device is found or you cancel it. 
+
+    dfu-programmer: no device present.
+    Error: Bootloader not found. Trying again in 5s.
+
+Once it does this, you'll want to reset the controller.  It should then show output similiar to this: 
+
+```
+*** Attempting to flash, please don't remove device
+>>> dfu-programmer atmega32u4 erase --force
+    Erasing flash...  Success
+    Checking memory from 0x0 to 0x6FFF...  Empty.
+>>> dfu-programmer atmega32u4 flash /Users/skully/qmk_firmware/clueboard_66_hotswap_gen1_skully.hex
+    Checking memory from 0x0 to 0x55FF...  Empty.
+    0%                            100%  Programming 0x5600 bytes...
+    [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
+    0%                            100%  Reading 0x7000 bytes...
+    [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
+    Validating...  Success
+    0x5600 bytes written into 0x7000 bytes memory (76.79%).
+>>> dfu-programmer atmega32u4 reset
+```
+
+If you have any issues with this, you may need to this: 
+
+    sudo make <my_keyboard>:<my_keymap>:dfu
+
+### Caterina 
+
+For Arduino boards and their close (such as the SparkFun ProMicro), when you're ready to compile and flash your firmware, open up your terminal window and run the built command: 
+
+    make <my_keyboard>:<my_keymap>:avrdude
+
+For example, if your keymap is named "xyverz" and you're building a keymap for a rev2 Lets Split, you'll use this command:
+
+    make lets_split/rev2:xyverz:avrdude
+
+Once the firmware finishes compiling, it will output something like this: 
+
+```
+Linking: .build/lets_split_rev2_xyverz.elf                                                            [OK]
+Creating load file for flashing: .build/lets_split_rev2_xyverz.hex                                    [OK]
+Checking file size of lets_split_rev2_xyverz.hex                                                      [OK]
+ * File size is fine - 27938/28672
+Detecting USB port, reset your controller now..............
+```
+
+At this point, reset the board and then the script will detect the bootloader and then flash the board.  The output should look something like this: 
+
+```
+Detected controller on USB port at /dev/ttyS15
+
+Connecting to programmer: .
+Found programmer: Id = "CATERIN"; type = S
+    Software Version = 1.0; No Hardware Version given.
+Programmer supports auto addr increment.
+Programmer supports buffered memory access with buffersize=128 bytes.
+
+Programmer supports the following devices:
+    Device code: 0x44
+
+avrdude.exe: AVR device initialized and ready to accept instructions
+
+Reading | ################################################## | 100% 0.00s
+
+avrdude.exe: Device signature = 0x1e9587 (probably m32u4)
+avrdude.exe: NOTE: "flash" memory has been specified, an erase cycle will be performed
+             To disable this feature, specify the -D option.
+avrdude.exe: erasing chip
+avrdude.exe: reading input file "./.build/lets_split_rev2_xyverz.hex"
+avrdude.exe: input file ./.build/lets_split_rev2_xyverz.hex auto detected as Intel Hex
+avrdude.exe: writing flash (27938 bytes):
+
+Writing | ################################################## | 100% 2.40s
+
+avrdude.exe: 27938 bytes of flash written
+avrdude.exe: verifying flash memory against ./.build/lets_split_rev2_xyverz.hex:
+avrdude.exe: load data flash data from input file ./.build/lets_split_rev2_xyverz.hex:
+avrdude.exe: input file ./.build/lets_split_rev2_xyverz.hex auto detected as Intel Hex
+avrdude.exe: input file ./.build/lets_split_rev2_xyverz.hex contains 27938 bytes
+avrdude.exe: reading on-chip flash data:
+
+Reading | ################################################## | 100% 0.43s
+
+avrdude.exe: verifying ...
+avrdude.exe: 27938 bytes of flash verified
+
+avrdude.exe: safemode: Fuses OK (E:CB, H:D8, L:FF)
+
+avrdude.exe done.  Thank you.
+```
+If you have any issues with this, you may need to this: 
+
+    sudo make <my_keyboard>:<my_keymap>:avrdude
+
+## HalfKay
+
+For the PJRC devices (Teensy's), when you're ready to compile and flash your firmware, open up your terminal window and run the built command: 
+
+    make <my_keyboard>:<my_keymap>:teensy
+
+For example, if your keymap is named "xyverz" and you're building a keymap for an Ergodox or Ergodox EZ, you'll use this command:
+
+    make erdogox_ez:xyverz:teensy
+
+Once the firmware finishes compiling, it will output something like this: 
+
+```
+Linking: .build/ergodox_ez_xyverz.elf                                                               [OK]
+Creating load file for flashing: .build/ergodox_ez_xyverz.hex                                       [OK]
+Checking file size of ergodox_ez_xyverz.hex                                                         [OK]
+ * File size is fine - 25584/32256
+ Teensy Loader, Command Line, Version 2.1
+Read "./.build/ergodox_ez_xyverz.hex": 25584 bytes, 79.3% usage
+Waiting for Teensy device...
+ (hint: press the reset button)
+ ```
+
+ At this point, reset your board.  Once you've done that, you'll see output like this: 
+
+ ```
+ Found HalfKay Bootloader
+Read "./.build/ergodox_ez_drashna.hex": 28532 bytes, 88.5% usage
+Programming............................................................................................................................................................................
+...................................................
+Booting
+```
+
+
+## Test It Out!
+
+Congrats! Your custom firmware has been programmed to your keyboard!
+
+Give it a try and make sure everything works the way you want it to. We've written [Testing and Debugging](newbs_testing_debugging.md) to round out this Newbie Guide, so head over there to learn about how to troubleshoot your custom functionality.

docs/newbs_getting_started.md

@@ -0,0 +1,98 @@
+# Introduction
+
+Your computer keyboard has a processor inside of it, not unlike the one inside your computer. This processor runs software that is responsible for detecting button presses and sending reports about the state of the keyboard when they are pressed or released. QMK fills the role of that software, detecting button presses and passing that information on to the host computer. When you build your custom layout you are creating the equivalent of an .exe for your keyboard.
+
+QMK tries to put a lot of power into your hands by making easy things easy, and hard things possible. You don't have to know how to program to create powerful layouts, you only have to follow a few simple syntax rules. 
+
+# Getting Started
+
+Before you can build keymaps you need to install some software and setup your build environment. This only has to be done one time no matter how many keyboards you want to compile firmware for.
+
+## Download Software
+
+### Text Editor
+
+You'll need a program that can edit and save **plain text** files. If you are on Windows you can make due with Notepad, and on Linux you can use Gedit, both of which are simple but functional text editors. On macOS you can not use TextEdit.app, it will not save plain text files. You will need to install another program such as Sublime Text.
+
+{% hint style='info' %}
+Not sure which text editor to use? Laurence Bradford wrote [a great introduction](https://learntocodewith.me/programming/basics/text-editors/) to the subject.
+{% endhint %}
+
+### QMK Toolbox
+
+QMK Toolbox is a Windows and macOS program that allows you to both program and debug your custom keyboard. You will want to install it so that you can easily flash your keyboard and receive the debugging messages that your keyboard will print.
+
+* [Newest Release](https://github.com/qmk/qmk_toolbox/releases/latest)
+* [Source Code](https://github.com/qmk/qmk_toolbox/)
+
+## Environment Setup
+
+We've tried to make QMK as easy to setup as possible. You only have to prepare your Linux or Unix environment and let QMK install the rest.
+
+{% hint style="info" %}
+If you haven't worked with the Linux/Unix command line before there are a few basic concepts and commands you should learn. These resources will teach you enough to work with QMK:
+
+* [Must Know Linux Commands](https://www.guru99.com/must-know-linux-commands.html)
+* [Some Basic Unix Commands](https://www.tjhsst.edu/~dhyatt/superap/unixcmd.html)
+{% endhint %}
+
+### Windows
+
+You will need to install msys2 and git.
+
+* Follow the installation instructions on the msys2 homepage: http://www.msys2.org
+* Close any open msys2 terminals, and open a new terminal
+* Install git by running this command: `pacman -S git`
+
+### macOS
+
+You will need to install homebrew. Follow the instructions on the homebrew homepage: https://brew.sh
+
+### Linux
+
+You will need to install git. It's extremely likely you already have it, but if not one of the following commands should install it:
+
+* Debian/Ubuntu/Devuan: `apt-get install git`
+* Fedora/Redhat/Centos: `yum install git`
+* Arch: `pacman -S git`
+
+## Download QMK
+
+Once you have setup your Linux/Unix environment you are ready to download QMK. We will do this by using git to "clone" the QMK repository. Open a Terminal or MSYS2 Console window and leave it open for the remainder of this guide. Inside that window run these two commands:
+
+    git clone https://github.com/qmk/qmk_firmware.git
+    cd qmk_firmware
+
+{% hint style='info' %}
+If you already know [how to use GitHub](getting_started_github.md) we recommend you create and clone your own fork instead. If you don't know what that means you can safely ignore this message.
+{% endhint %}
+
+## Setup QMK
+
+QMK comes with a script to help you setup the rest of what you'll need. You should run it now by typing in this command:
+
+    ./util/qmk_install.sh
+
+## Test Your Build Environment
+
+Now that your QMK build environment is setup you can build a firmware for your keyboard. Start by trying to build the default layout for your keyboard. You should be able to do that with a command in this format:
+
+    make <keyboard>:default
+
+For example, to build a firmware for a Clueboard 66% use:
+
+    make clueboard/66/rev3:default
+
+When it is done you should have a lot of output that ends similar to this:
+
+```
+Linking: .build/clueboard_66_rev2_default.elf                                                       [OK]
+Creating load file for flashing: .build/clueboard_66_rev2_default.hex                               [OK]
+Copying clueboard_66_rev2_default.hex to qmk_firmware folder                                        [OK]
+Checking file size of clueboard_66_rev2_default.hex                                                 [OK]
+ * File size is fine - 25174/28672
+```
+
+## Creating Your Layout
+
+Now you are ready to create your own personal layout. Move on to [Building Your First Firmware](newbs_building_firmware.md) for that.

docs/newbs_testing_debugging.md

@@ -0,0 +1,33 @@
+# Testing and Debugging
+
+Once you've flashed your keyboard with a custom firmware you're ready to test it out. With a little bit of luck everything will work perfectly, but if not this document will help you figure out what's wrong.
+
+## Testing
+
+Testing your keyboard is usually pretty straightforward. Press every single key and make sure it sends the keys you expect. There are even programs that will help you make sure that no key is missed.
+
+Note: These programs are not provided by or endorsed by QMK.
+
+* [Switch Hitter](https://elitekeyboards.com/switchhitter.php) (Windows Only)
+* [Keyboard Viewer](https://www.imore.com/how-use-keyboard-viewer-your-mac) (Mac Only)
+* [Keyboard Tester](http://www.keyboardtester.com) (Web Based)
+* [Keyboard Checker](http://keyboardchecker.com) (Web Based)
+
+## Debugging With QMK Toolbox
+
+[QMK Toolbox](https://github.com/qmk/qmk_toolbox) will show messages from your keyboard if you have `CONSOLE_ENABLE = yes` in your `rules.mk`. By default the output is very limited, but you can turn on debug mode to increase the amount of debug output. Use the `DEBUG` keycode in your keymap, or use the [Command](feature_command.md) feature to enable debug mode.
+
+<!-- FIXME: Describe the debugging messages here. -->
+
+## Sending Your Own Debug Messages
+
+Sometimes it's useful to print debug messages from within your [custom code](custom_quantum_functions.md). Doing so is pretty simple. Start by including `print.h` at the top of your file:
+
+    #include <print.h>
+
+After that you can use a few different print functions:
+
+* `print("string")`: Print a simple string.
+* `sprintf("%s string", var)`: Print a formatted string
+* `dprint("string")` Print a simple string, but only when debug mode is enabled
+* `dprintf("%s string", var)`: Print a formatted string, but only when debug mode is enabled

docs/porting_your_keyboard_to_qmk_(arm_and_other_chibios_cpus).md

@@ -42,7 +42,7 @@ The values at the top likely won't need to be changed, since most boards use the
 OPT_DEFS += -DBOOTLOADER_SIZE=512
 ```
 
-At the bottom of the file, you'll find lots of features to turn on and off - all of these options should be set with `?=` to allow for the keymap overrides. `?=` only assigns if the variable was previously undefined. For the full documenation of these features, see the [Makefile options](#makefile-options).
+At the bottom of the file, you'll find lots of features to turn on and off - all of these options should be set with `?=` to allow for the keymap overrides. `?=` only assigns if the variable was previously undefined. For the full documentation of these features, see the [Makefile options](#makefile-options).
 
 ## `/keyboards/<keyboard>/readme.md`
 
@@ -54,7 +54,7 @@ This is where all of the custom logic for your keyboard goes - you may not need
 
 ## `/keyboards/<keyboard>/<keyboard>.h`
 
-Here is where you can (optionally) define your `KEYMAP` function to remap your matrix into a more readable format. With ortholinear boards, this isn't always necessary, but it can help to accomodate the dead spots on your matrix, where there are keys that take up more than one space (2u, staggering, 6.25u, etc). The example shows the difference between the physical keys, and the matrix design:
+Here is where you can (optionally) define your `KEYMAP` function to remap your matrix into a more readable format. With ortholinear boards, this isn't always necessary, but it can help to accommodate the dead spots on your matrix, where there are keys that take up more than one space (2u, staggering, 6.25u, etc). The example shows the difference between the physical keys, and the matrix design:
 
 ```
 #define KEYMAP( \

docs/power.txt

@@ -21,7 +21,7 @@ MCUSR   MCU Status Register
 
 SMCR    Sleep Mode Control Register
     SE      Sleep Enable
-    SM2:0   
+    SM2:0
         #define set_sleep_mode(mode) \
         #define SLEEP_MODE_IDLE         (0)
         #define SLEEP_MODE_ADC          _BV(SM0)

docs/quantum_keycodes.md

@@ -2,21 +2,21 @@
 
 Quantum keycodes allow for easier customisation of your keymap than the basic ones provide, without having to define custom actions.
 
-All keycodes within quantum are numbers between `0x0000` and `0xFFFF`. Within your `keymap.c` it may look like you have functions and other special cases, but ultimately the C preprocessor will translate those into a single 4 byte integer. QMK has reserved `0x0000` through `0x00FF` for standard keycodes. These are keycodes such as `KC_A`, `KC_1`, and `KC_LCTL`, which are basic keys defined in the USB HID specification. 
+All keycodes within quantum are numbers between `0x0000` and `0xFFFF`. Within your `keymap.c` it may look like you have functions and other special cases, but ultimately the C preprocessor will translate those into a single 4 byte integer. QMK has reserved `0x0000` through `0x00FF` for standard keycodes. These are keycodes such as `KC_A`, `KC_1`, and `KC_LCTL`, which are basic keys defined in the USB HID specification.
 
 On this page we have documented keycodes between `0x00FF` and `0xFFFF` which are used to implement advanced quantum features. If you define your own custom keycodes they will be put into this range as well.
 
-## QMK keycodes
+## QMK Keycodes
 
-|Name|Description|
-|----|-----------|
-|`RESET`|Put the keyboard into DFU mode for flashing|
-|`DEBUG`|Toggles debug mode|
-|`KC_GESC`/`GRAVE_ESC`|Acts as escape when pressed normally but when pressed with Shift or GUI will send a ```|
-|`KC_LSPO`|Left shift when held, open paranthesis when tapped|
-|`KC_RSPC`|Right shift when held, close paranthesis when tapped|
-|`KC_LEAD`|The [leader key](feature_leader_key.md)|
-|`KC_LOCK`|The [lock key](feature_key_lock.md)|
-|`FUNC(n)`/`F(n)`|Call `fn_action(n)` (deprecated)|
-|`M(n)`|to call macro n|
-|`MACROTAP(n)`|to macro-tap n idk FIXME|
+|Key          |Aliases    |Description                                                          |
+|-------------|-----------|---------------------------------------------------------------------|
+|`RESET`      |           |Put the keyboard into DFU mode for flashing                          |
+|`DEBUG`      |           |Toggle debug mode                                                    |
+|`KC_GESC`    |`GRAVE_ESC`|Escape when tapped, <code>&#96;</code> when pressed with Shift or GUI|
+|`KC_LSPO`    |           |Left Shift when held, `(` when tapped                                |
+|`KC_RSPC`    |           |Right Shift when held, `)` when tapped                               |
+|`KC_LEAD`    |           |The [Leader key](feature_leader_key.md)                              |
+|`KC_LOCK`    |           |The [Lock key](feature_key_lock.md)                                  |
+|`FUNC(n)`    |`F(n)`     |Call `fn_action(n)` (deprecated)                                     |
+|`M(n)`       |           |Call macro `n`                                                       |
+|`MACROTAP(n)`|           |Macro-tap `n` idk FIXME                                              |

docs/redirects.json

@@ -16,6 +16,10 @@
                 "from": "feature_common_shortcuts.html",
                 "to": "feature_advanced_keycodes.html"
             },
+            {
+                "from": "glossary.html",
+                "to": "reference_glossary.html"
+            },
             {
                 "from": "key_lock.html",
                 "to": "feature_key_lock.html"

docs/reference_glossary.md

@@ -1,10 +1,10 @@
-# Glossary of QMK terms
+# Glossary of QMK Terms
 
 ## ARM
 A line of 32-bit MCU's produced by a number of companies, such as Atmel, Cypress, Kinetis, NXP, ST, and TI.
 
 ## AVR
-A line of 8-bit MCU's produced by [Atmel](http://atmel.com). AVR was the original platform that TMK supported.
+A line of 8-bit MCU's produced by [Atmel](http://www.microchip.com/). AVR was the original platform that TMK supported.
 
 ## AZERTY
 The standard Français (French) keyboard layout. Named for the first 6 keys on the keyboard.
@@ -41,7 +41,7 @@ A macro which has been recorded on the keyboard and which will be lost when the
 ## Eclipse
 An IDE that is popular with many C developers.
 
-* [Eclipse Setup Instructions](eclipse.html)
+* [Eclipse Setup Instructions](eclipse.md)
 
 ## Firmware
 The software that controls your MCU.
@@ -50,7 +50,7 @@ The software that controls your MCU.
 Software provided by Atmel for flashing AVR devices. We generally recommend [QMK Flasher](https://github.com/qmk/qmk_flasher) instead, but for some advanced use cases FLIP is required.
 
 ## git
-Versioning software used at the commandline
+Versioning software used at the command line
 
 ## GitHub
 The website that hosts most of the QMK project. It provides integration with git, issue tracking, and other features that help us run QMK.
@@ -62,7 +62,7 @@ In-system programming, a method of programming an AVR chip using external hardwa
 An interface for receiving debugging messages from your keyboard. You can view these messages using [QMK Flasher](https://github.com/qmk/qmk_flasher) or [PJRC's hid_listen](https://www.pjrc.com/teensy/hid_listen.html)
 
 ## Keycode
-A 2-byte number that represents a particular key. `0x00`-`0xFF` are used for [Basic Keycodes](keycodes_basic.html) while `0x100`-`0xFFFF` are used for [Quantum Keycodes](quantum_keycodes.html).
+A 2-byte number that represents a particular key. `0x00`-`0xFF` are used for [Basic Keycodes](keycodes_basic.md) while `0x100`-`0xFFFF` are used for [Quantum Keycodes](quantum_keycodes.md).
 
 ## Key Down
 An event that happens when a key is pressed down, but is completed before a key is released.
@@ -79,7 +79,7 @@ An abstraction used to allow a key to serve multiple purposes. The highest activ
 ## Leader Key
 A feature that allows you to tap the leader key followed by a sequence of 1, 2, or 3 keys to activate key presses or other quantum features.
 
-* [Leader Key Documentation](feature_leader_key.html)
+* [Leader Key Documentation](feature_leader_key.md)
 
 ## LED
 Light Emitting Diode, the most common device used for indicators on a keyboard.
@@ -91,7 +91,7 @@ Software package that is used to compile all the source files. You run `make` wi
 A wiring pattern of columns and rows that enables the MCU to detect keypresses with a fewer number of pins. The matrix often incorporates diodes to allow for NKRO.
 
 ## Macro
-A feature that lets you send muiltple keypress events (hid reports) after having pressed only a single key.
+A feature that lets you send multiple keypress events (hid reports) after having pressed only a single key.
 
 * [Macro Documentation](feature_macros.md)
 
@@ -104,13 +104,13 @@ A key that is held down while typing another key to modify the action of that ke
 ## Mousekeys
 A feature that lets you control your mouse cursor and click from your keyboard.
 
-* [Mousekeys Documentation](feature_mouse_keys.html)
+* [Mousekeys Documentation](feature_mouse_keys.md)
 
 ## N-Key Rollover (NKRO)
 A term that applies to keyboards that are capable of reporting any number of key-presses at once.
 
 ## Oneshot Modifier
-A modifier that acts as if it is held down until another key is released, so you can press the mod and then press the key, rather than holding the mod while pressing the key.
+A modifier that acts as if it is held down until another key is released, so you can press the mod and then press the key, rather than holding the mod while pressing the key. Also known as a Sticky key or a Dead key.
 
 ## ProMicro
 A low cost AVR development board. Clones of this device are often found on ebay very inexpensively (under $5) but people often struggle with flashing their pro micros.
@@ -133,18 +133,18 @@ A 1 byte number that is sent as part of a HID report over USB that represents a
 ## Space Cadet Shift
 A special set of shift keys which allow you to type various types of braces by tapping the left or right shift one or more times.
 
-* [Space Cadet Shift Documentation](feature_space_cadet.html)
+* [Space Cadet Shift Documentation](feature_space_cadet.md)
 
 ## Tap
 Pressing and releasing a key. In some situations you will need to distinguish between a key down and a key up event, and Tap always refers to both at once.
 
 ## Tap Dance
-A feature that lets you assign muiltple keycodes to the same key based on how many times you press it.
+A feature that lets you assign multiple keycodes to the same key based on how many times you press it.
 
 * [Tap Dance Documentation](feature_tap_dance.md)
 
 ## Teensy
-A low-cost AVR development board that is commonly used for hand-wired builds. A teensy is often chosen despite costing a few dollors more due to its halfkay bootloader, which makes flashing very simple.
+A low-cost AVR development board that is commonly used for hand-wired builds. A teensy is often chosen despite costing a few dollars more due to its halfkay bootloader, which makes flashing very simple.
 
 ## Underlight
 A generic term for LEDs that light the underside of the board. These LED's typically shine away from the bottom of the PCB and towards the surface the keyboard rests on.
@@ -165,6 +165,6 @@ Universal Serial Bus, the most common wired interface for a keyboard.
 ## USB Host (or simply Host)
 The USB Host is your computer, or whatever device your keyboard is plugged into.
 
-# Couldn't find the term you're looking for?
+# Couldn't Find the Term You're Looking For?
 
-[Open an issue](https://github.com/qmk/qmk_firmware/issues) with your question and the term in question could be added here. Better still, open a pull request with the definition. :)  
+[Open an issue](https://github.com/qmk/qmk_firmware/issues) with your question and the term in question could be added here. Better still, open a pull request with the definition. :)

docs/subvendor_ids.md

@@ -1,32 +0,0 @@
-# Vendor, Subvendor, Product, Project IDs in QMK
-
-    #define VENDOR_ID  0x03A8
-                         ^ 
-                         + QMK's self-assigned Vendor ID
-    
-    #define PRODUCT_ID 0x0000
-                         ^  ^ 
-                         |  + Project ID
-                         + Subvendor ID
-
-There are many projects using QMK that aren't large enough where it would make sense to obtain a Vendor ID of their own, and [the USB-IF isn't interested in others transferring a VID to communities like ours](http://www.arachnidlabs.com/blog/2013/10/18/usb-if-no-vid-for-open-source/), so QMK uses the unassigned Vendor ID `0x03A8` for all Vendors/Makers/Companies (Subvendors for clarification) that aren't interested in obtaining their own, and maintains a master list (`subvendor_ids.txt`) in the repo to ensure unique values for each project. 
-
-Subvendor IDs in QMK are a bitmask of the `PRODUCT_ID`: `0xFFE0` - this leaves 5 bits for the Project ID (0x001F bitmask), of which each Subvendor can have 32. If the Project ID is larger than 15, add 1 to the Subvendor ID (`0xFA4 -> 0xFA5`) - all Subvendor IDs are even (in hex) to allow this. All Subvendor IDs are randomly generated.
-
-For projects that are heavily DIY in nature, hand-wired, or historical, a Subvendor ID may be established for each.
-
-## Using other values
-
-It's not recommended using custom Vendor IDs, but some projects may have obtained their own, and are welcome to use them in QMK, but only with permission of the project's creator (the owner of the Vendor ID).
-
-## Creating a new Subvendor ID
-
-To generate a new valid, random ID, run this bash script from the root qmk_firmware folder by substituting `<subvendor>` with your company/vendor name (leave the quotes):
-
-    util/new_subvendor_id.sh "<subvendor>"
-
-This script will output your ID, and automatically append it to the list below as well as the master list (`subvendor_ids.txt`).
-
-# Currently used Subvendor IDs:
-
- * 0x5A6: OLKB

docs/understanding_qmk.md

@@ -2,7 +2,7 @@
 
 This document attempts to explain how the QMK firmware works from a very high level. It assumes you understand basic programming concepts but does not (except where needed to demonstrate) assume familiarity with C. It assumes that you have a basic understanding of the following documents:
 
-* [QMK Overview](qmk_overview.md)
+* [Introduction](getting_started_introduction.md)
 * [How Keyboards Work](how_keyboards_work.md)
 * [FAQ](faq.md)
 
@@ -77,7 +77,7 @@ At the keyboard level we define a C macro (typically named `KEYMAP()`) which map
 
 Notice how the second block of our `KEYMAP()` macro matches the Matrix Scanning array above? This macro is what will map the matrix scanning array to keycodes. However, if you look at a 17 key numpad you'll notice that it has 3 places where the matrix could have a switch but doesn't, due to larger keys. We have populated those spaces with `KC_NO` so that our keymap definition doesn't have to.
 
-You can also use this macro to handle unusual matrix layouts, for example the [Clueboard rev 2](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/rev2/rev2.h). Explaining that is outside the scope of this document.
+You can also use this macro to handle unusual matrix layouts, for example the [Clueboard rev 2](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/66/rev2/rev2.h). Explaining that is outside the scope of this document.
 
 ##### Keycode Assignment
 
@@ -94,11 +94,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 }
 ```
 
-Notice how all of these arguments match up with the first half of the `KEYMAP()` macro from the last section? This is how we take a keycode and map it to our Matrix Scan from earlier. 
+Notice how all of these arguments match up with the first half of the `KEYMAP()` macro from the last section? This is how we take a keycode and map it to our Matrix Scan from earlier.
 
 ##### State Change Detection
 
-The matrix scanning described above tells us the state of the matrix at a given moment, but your computer only wants to know about changes, it doesn't care about the current state. QMK stores the results from the last matrix scan and compares the results from this matrix to determine when a key has been pressed or released. 
+The matrix scanning described above tells us the state of the matrix at a given moment, but your computer only wants to know about changes, it doesn't care about the current state. QMK stores the results from the last matrix scan and compares the results from this matrix to determine when a key has been pressed or released.
 
 Let's look at an example. We'll hop into the middle of a keyboard scanning loop to find that our previous scan looks like this:
 
@@ -135,8 +135,8 @@ The `process_record()` function itself is deceptively simple, but hidden within
 * [`void process_record(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action.c#L128)
   * [`bool process_record_quantum(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L140)
     * [Map this record to a keycode](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L143)
-    * [`bool process_record_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/cluecard.c#L20)
-      * [`bool process_record_user(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/keymaps/default/keymap.c#L58)
+    * [`bool process_record_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/card/card.c#L20)
+      * [`bool process_record_user(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/card/keymaps/default/keymap.c#L58)
     * [`bool process_midi(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_midi.c#L102)
     * [`bool process_audio(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_audio.c#L10)
     * [`bool process_music(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_music.c#L69)
@@ -150,7 +150,7 @@ The `process_record()` function itself is deceptively simple, but hidden within
     * [`bool process_auto_shift(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_auto_shift.c#L47)
     * [`bool process_unicode_map(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_unicodemap.c#L47)
     * [Identify and process quantum specific keycodes](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L211)
-  
+
 At any step during this chain of events a function (such as `process_record_kb()`) can `return false` to halt all further processing.
 
 <!--

docs/unit_testing.md

@@ -18,7 +18,7 @@ Note that Google Test and therefore any test has to be written in C++, even if t
 
 One thing to remember, is that you have to append `extern "C"` around all of your C file includes.
 
-## Adding tests for new or existing features
+## Adding Tests for New or Existing Features
 
 If you want to unit test some feature, then take a look at the existing serial_link tests, in the `quantum/serial_link/tests folder`, and follow the steps below to create a similar structure.
 
@@ -34,25 +34,25 @@ If you want to unit test some feature, then take a look at the existing serial_l
 
 Note how there's several different tests, each mocking out a separate part. Also note that each of them only compiles the very minimum that's needed for the tests. It's recommend that you try to do the same. For a relevant video check out [Matt Hargett "Advanced Unit Testing in C & C++](https://www.youtube.com/watch?v=Wmy6g-aVgZI)
 
-## Running the tests
+## 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.
 
-## Debugging the tests
+## Debugging the Tests
 
 If there are problems with the tests, you can find the executable in the `./build/test` folder. You should be able to run those with GDB or a similar debugger.
 
-## Full Integration tests
+## Full Integration Tests
 
 It's not yet possible to do a full integration test, where you would compile the whole firmware and define a keymap that you are going to test. However there are plans for doing that, because writing tests that way would probably be easier, at least for people that are not used to unit testing.
 
 In that model you would emulate the input, and expect a certain output from the emulated keyboard.
 
-# Tracing variables 
+# Tracing Variables
 
 Sometimes you might wonder why a variable gets changed and where, and this can be quite tricky to track down without having a debugger. It's of course possible to manually add print statements to track it, but you can also enable the variable trace feature. This works for both for variables that are changed by the code, and when the variable is changed by some memory corruption.
 
-To take the feature into use add `VARIABLE_TRACE=x` to the end of you make command. `x` represents the number of variables you want to trace, which is usually 1. 
+To take the feature into use add `VARIABLE_TRACE=x` to the end of you make command. `x` represents the number of variables you want to trace, which is usually 1.
 
 Then at a suitable place in the code, call `ADD_TRACED_VARIABLE`, to begin the tracing. For example to trace all the layer changes, you can do this
 ```c
@@ -65,4 +65,4 @@ This will add a traced variable named "layer" (the name is just for your informa
 
 In order to actually detect changes to the variables you should call `VERIFY_TRACED_VARIABLES` around the code that you think that modifies the variable. If a variable is modified it will tell you between which two `VERIFY_TRACED_VARIABLES` calls the modification happened. You can then add more calls to track it down further. I don't recommend spamming the codebase with calls. It's better to start with a few, and then keep adding them in a binary search fashion. You can also delete the ones you don't need, as each call need to store the file name and line number in the ROM, so you can run out of memory if you add too many calls.
 
-Also remember to delete all the tracing code once you have found the bug, as you wouldn't want to create a pull request with tracing code.
+Also remember to delete all the tracing code once you have found the bug, as you wouldn't want to create a pull request with tracing code.

doxygen-todo

@@ -0,0 +1,32 @@
+tmk_core/protocol
+tmk_core/protocol/bluefruit
+tmk_core/protocol/chibios
+tmk_core/protocol/iwrap
+tmk_core/protocol/lufa
+tmk_core/protocol/mbed
+tmk_core/protocol/midi
+tmk_core/protocol/midi/bytequeue
+tmk_core/protocol/midi/Config
+tmk_core/protocol/pjrc
+tmk_core/protocol/usb_hid
+tmk_core/protocol/vusb
+tmk_core/tool
+tmk_core/tool/chibios
+quantum
+quantum/api
+quantum/audio
+quantum/keymap_extras
+quantum/process_keycode
+quantum/serial_link
+quantum/serial_link/protocol
+quantum/serial_link/system
+quantum/serial_link/tests
+quantum/tools
+quantum/visualizer
+quantum/visualizer/resources
+drivers
+drivers/avr
+drivers/ugfx
+drivers/ugfx/gdisp
+drivers/ugfx/gdisp/is31fl3731c
+drivers/ugfx/gdisp/st7565

drivers/boards/IC_TEENSY_3_1/board.c

@@ -0,0 +1,191 @@
+/*
+    ChibiOS - Copyright (C) 2015 RedoX https://github.com/RedoXyde
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+#include "hal.h"
+
+#if HAL_USE_PAL || defined(__DOXYGEN__)
+/**
+ * @brief   PAL setup.
+ * @details Digital I/O ports static configuration as defined in @p board.h.
+ *          This variable is used by the HAL when initializing the PAL driver.
+ */
+const PALConfig pal_default_config =
+{
+    .ports = {
+        {
+            /*
+             * PORTA setup.
+             *
+             * PTA4  - PIN33
+             * PTA5  - PIN24
+             * PTA12 - PIN3
+             * PTA13 - PIN4
+             *
+             * PTA18/19 crystal
+             * PTA0/3 SWD
+             */
+            .port = IOPORT1,
+            .pads = {
+                PAL_MODE_ALTERNATIVE_7,     PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_ALTERNATIVE_7,     PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_INPUT_ANALOG,      PAL_MODE_INPUT_ANALOG,      PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+            },
+        },
+        {
+            /*
+             * PORTB setup.
+             *
+             * PTB0  - PIN16
+             * PTB1  - PIN17
+             * PTB2  - PIN19
+             * PTB3  - PIN18
+             * PTB16 - PIN0 - UART0_TX
+             * PTB17 - PIN1 - UART0_RX
+             * PTB18 - PIN32
+             * PTB19 - PIN25
+             */
+            .port = IOPORT2,
+            .pads = {
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_ALTERNATIVE_3,     PAL_MODE_ALTERNATIVE_3,
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+            },
+        },
+        {
+            /*
+             * PORTC setup.
+             *
+             * PTC0  - PIN15
+             * PTC1  - PIN22
+             * PTC2  - PIN23
+             * PTC3  - PIN9
+             * PTC4  - PIN10
+             * PTC5  - PIN13
+             * PTC6  - PIN11
+             * PTC7  - PIN12
+             * PTC8  - PIN28
+             * PTC9  - PIN27
+             * PTC10 - PIN29
+             * PTC11 - PIN30
+             */
+            .port = IOPORT3,
+            .pads = {
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+            },
+        },
+        {
+            /*
+             * PORTD setup.
+             *
+             * PTD0  - PIN2
+             * PTD1  - PIN14
+             * PTD2  - PIN7
+             * PTD3  - PIN8
+             * PTD4  - PIN6
+             * PTD5  - PIN20
+             * PTD6  - PIN21
+             * PTD7  - PIN5
+             */
+            .port = IOPORT4,
+            .pads = {
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+            },
+        },
+        {
+            /*
+             * PORTE setup.
+             *
+             * PTE0  - PIN31
+             * PTE1  - PIN26
+             */
+            .port = IOPORT5,
+            .pads = {
+                PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_OUTPUT_PUSHPULL,   PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+                PAL_MODE_UNCONNECTED,       PAL_MODE_UNCONNECTED,
+            },
+        },
+    },
+};
+#endif
+
+// NOTE: This value comes from kiibohd/controller and is the location of a value
+// which needs to be checked before disabling the watchdog (which happens in
+// k20x_clock_init)
+#define WDOG_TMROUTL            *(volatile uint16_t *)0x40052012
+
+/**
+ * @brief   Early initialization code.
+ * @details This initialization must be performed just after stack setup
+ *          and before any other initialization.
+ */
+void __early_init(void) {
+  // This is a dirty hack and should only be used as a temporary fix until this
+  // is upstreamed.
+  while (WDOG_TMROUTL < 2); // Must wait for WDOG timer if already running, before jumping
+
+  k20x_clock_init();
+}
+
+/**
+ * @brief   Board-specific initialization code.
+ * @todo    Add your board-specific code, if any.
+ */
+void boardInit(void) {
+}

drivers/boards/IC_TEENSY_3_1/board.h

@@ -0,0 +1,295 @@
+/*
+    ChibiOS - Copyright (C) 2015 RedoX https://github.com/RedoXyde
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+#ifndef _BOARD_H_
+#define _BOARD_H_
+
+/*
+ * Setup for the PJRC Teensy 3.1 board.
+ */
+
+/*
+ * Board identifier.
+ */
+#define BOARD_PJRC_TEENSY_3_1
+#define BOARD_NAME                  "PJRC Teensy 3.1"
+
+/* External 16 MHz crystal */
+#define KINETIS_XTAL_FREQUENCY      16000000UL
+
+/* Use internal capacitors for the crystal */
+#define KINETIS_BOARD_OSCILLATOR_SETTING OSC_CR_SC8P|OSC_CR_SC2P
+
+/*
+ * MCU type
+ */
+#define K20x7
+
+/*
+ * IO pins assignments.
+ */
+#define PORTA_PIN0                  0
+#define PORTA_PIN1                  1
+#define PORTA_PIN2                  2
+#define PORTA_PIN3                  3
+#define TEENSY_PIN33                4
+#define TEENSY_PIN24                5
+#define PORTA_PIN6                  6
+#define PORTA_PIN7                  7
+#define PORTA_PIN8                  8
+#define PORTA_PIN9                  9
+#define PORTA_PIN10                 10
+#define PORTA_PIN11                 11
+#define TEENSY_PIN3                 12
+#define TEENSY_PIN4                 13
+#define PORTA_PIN14                 14
+#define PORTA_PIN15                 15
+#define PORTA_PIN16                 16
+#define PORTA_PIN17                 17
+#define PORTA_PIN18                 18
+#define PORTA_PIN19                 19
+#define PORTA_PIN20                 20
+#define PORTA_PIN21                 21
+#define PORTA_PIN22                 22
+#define PORTA_PIN23                 23
+#define PORTA_PIN24                 24
+#define PORTA_PIN25                 25
+#define PORTA_PIN26                 26
+#define PORTA_PIN27                 27
+#define PORTA_PIN28                 28
+#define PORTA_PIN29                 29
+#define PORTA_PIN30                 30
+#define PORTA_PIN31                 31
+
+#define TEENSY_PIN3_IOPORT  IOPORT1
+#define TEENSY_PIN4_IOPORT  IOPORT1
+#define TEENSY_PIN24_IOPORT IOPORT1
+#define TEENSY_PIN33_IOPORT IOPORT1
+
+#define TEENSY_PIN16                0
+#define TEENSY_PIN17                1
+#define TEENSY_PIN19                2
+#define TEENSY_PIN18                3
+#define PORTB_PIN4                  4
+#define PORTB_PIN5                  5
+#define PORTB_PIN6                  6
+#define PORTB_PIN7                  7
+#define PORTB_PIN8                  8
+#define PORTB_PIN9                  9
+#define PORTB_PIN10                 10
+#define PORTB_PIN11                 11
+#define PORTB_PIN12                 12
+#define PORTB_PIN13                 13
+#define PORTB_PIN14                 14
+#define PORTB_PIN15                 15
+#define TEENSY_PIN0                 16
+#define TEENSY_PIN1                 17
+#define TEENSY_PIN32                18
+#define TEENSY_PIN25                19
+#define PORTB_PIN20                 20
+#define PORTB_PIN21                 21
+#define PORTB_PIN22                 22
+#define PORTB_PIN23                 23
+#define PORTB_PIN24                 24
+#define PORTB_PIN25                 25
+#define PORTB_PIN26                 26
+#define PORTB_PIN27                 27
+#define PORTB_PIN28                 28
+#define PORTB_PIN29                 29
+#define PORTB_PIN30                 30
+#define PORTB_PIN31                 31
+
+#define TEENSY_PIN0_IOPORT  IOPORT2
+#define TEENSY_PIN1_IOPORT  IOPORT2
+#define TEENSY_PIN16_IOPORT IOPORT2
+#define TEENSY_PIN17_IOPORT IOPORT2
+#define TEENSY_PIN18_IOPORT IOPORT2
+#define TEENSY_PIN19_IOPORT IOPORT2
+#define TEENSY_PIN25_IOPORT IOPORT2
+#define TEENSY_PIN32_IOPORT IOPORT2
+
+#define TEENSY_PIN15                0
+#define TEENSY_PIN22                1
+#define TEENSY_PIN23                2
+#define TEENSY_PIN9                 3
+#define TEENSY_PIN10                4
+#define TEENSY_PIN13                5
+#define TEENSY_PIN11                6
+#define TEENSY_PIN12                7
+#define TEENSY_PIN28                8
+#define TEENSY_PIN27                9
+#define TEENSY_PIN29                10
+#define TEENSY_PIN30                11
+#define PORTC_PIN12                 12
+#define PORTC_PIN13                 13
+#define PORTC_PIN14                 14
+#define PORTC_PIN15                 15
+#define PORTC_PIN16                 16
+#define PORTC_PIN17                 17
+#define PORTC_PIN18                 18
+#define PORTC_PIN19                 19
+#define PORTC_PIN20                 20
+#define PORTC_PIN21                 21
+#define PORTC_PIN22                 22
+#define PORTC_PIN23                 23
+#define PORTC_PIN24                 24
+#define PORTC_PIN25                 25
+#define PORTC_PIN26                 26
+#define PORTC_PIN27                 27
+#define PORTC_PIN28                 28
+#define PORTC_PIN29                 29
+#define PORTC_PIN30                 30
+#define PORTC_PIN31                 31
+
+#define TEENSY_PIN9_IOPORT  IOPORT3
+#define TEENSY_PIN10_IOPORT IOPORT3
+#define TEENSY_PIN11_IOPORT IOPORT3
+#define TEENSY_PIN12_IOPORT IOPORT3
+#define TEENSY_PIN13_IOPORT IOPORT3
+#define TEENSY_PIN15_IOPORT IOPORT3
+#define TEENSY_PIN22_IOPORT IOPORT3
+#define TEENSY_PIN23_IOPORT IOPORT3
+#define TEENSY_PIN27_IOPORT IOPORT3
+#define TEENSY_PIN28_IOPORT IOPORT3
+#define TEENSY_PIN29_IOPORT IOPORT3
+#define TEENSY_PIN30_IOPORT IOPORT3
+
+#define TEENSY_PIN2                 0
+#define TEENSY_PIN14                1
+#define TEENSY_PIN7                 2
+#define TEENSY_PIN8                 3
+#define TEENSY_PIN6                 4
+#define TEENSY_PIN20                5
+#define TEENSY_PIN21                6
+#define TEENSY_PIN5                 7
+#define PORTD_PIN8                  8
+#define PORTD_PIN9                  9
+#define PORTD_PIN10                 10
+#define PORTD_PIN11                 11
+#define PORTD_PIN12                 12
+#define PORTD_PIN13                 13
+#define PORTD_PIN14                 14
+#define PORTD_PIN15                 15
+#define PORTD_PIN16                 16
+#define PORTD_PIN17                 17
+#define PORTD_PIN18                 18
+#define PORTD_PIN19                 19
+#define PORTD_PIN20                 20
+#define PORTD_PIN21                 21
+#define PORTD_PIN22                 22
+#define PORTD_PIN23                 23
+#define PORTD_PIN24                 24
+#define PORTD_PIN25                 25
+#define PORTD_PIN26                 26
+#define PORTD_PIN27                 27
+#define PORTD_PIN28                 28
+#define PORTD_PIN29                 29
+#define PORTD_PIN30                 30
+#define PORTD_PIN31                 31
+
+#define TEENSY_PIN2_IOPORT  IOPORT4
+#define TEENSY_PIN5_IOPORT  IOPORT4
+#define TEENSY_PIN6_IOPORT  IOPORT4
+#define TEENSY_PIN7_IOPORT  IOPORT4
+#define TEENSY_PIN8_IOPORT  IOPORT4
+#define TEENSY_PIN14_IOPORT IOPORT4
+#define TEENSY_PIN20_IOPORT IOPORT4
+#define TEENSY_PIN21_IOPORT IOPORT4
+
+#define TEENSY_PIN31                0
+#define TEENSY_PIN26                1
+#define PORTE_PIN2                  2
+#define PORTE_PIN3                  3
+#define PORTE_PIN4                  4
+#define PORTE_PIN5                  5
+#define PORTE_PIN6                  6
+#define PORTE_PIN7                  7
+#define PORTE_PIN8                  8
+#define PORTE_PIN9                  9
+#define PORTE_PIN10                 10
+#define PORTE_PIN11                 11
+#define PORTE_PIN12                 12
+#define PORTE_PIN13                 13
+#define PORTE_PIN14                 14
+#define PORTE_PIN15                 15
+#define PORTE_PIN16                 16
+#define PORTE_PIN17                 17
+#define PORTE_PIN18                 18
+#define PORTE_PIN19                 19
+#define PORTE_PIN20                 20
+#define PORTE_PIN21                 21
+#define PORTE_PIN22                 22
+#define PORTE_PIN23                 23
+#define PORTE_PIN24                 24
+#define PORTE_PIN25                 25
+#define PORTE_PIN26                 26
+#define PORTE_PIN27                 27
+#define PORTE_PIN28                 28
+#define PORTE_PIN29                 29
+#define PORTE_PIN30                 30
+#define PORTE_PIN31                 31
+
+#define TEENSY_PIN26_IOPORT IOPORT5
+#define TEENSY_PIN31_IOPORT IOPORT5
+
+#define LINE_PIN1           PAL_LINE(TEENSY_PIN1_IOPORT, TEENSY_PIN1)
+#define LINE_PIN2           PAL_LINE(TEENSY_PIN2_IOPORT, TEENSY_PIN2)
+#define LINE_PIN3           PAL_LINE(TEENSY_PIN3_IOPORT, TEENSY_PIN3)
+#define LINE_PIN4           PAL_LINE(TEENSY_PIN4_IOPORT, TEENSY_PIN4)
+#define LINE_PIN5           PAL_LINE(TEENSY_PIN5_IOPORT, TEENSY_PIN5)
+#define LINE_PIN6           PAL_LINE(TEENSY_PIN6_IOPORT, TEENSY_PIN6)
+#define LINE_PIN7           PAL_LINE(TEENSY_PIN7_IOPORT, TEENSY_PIN7)
+#define LINE_PIN8           PAL_LINE(TEENSY_PIN8_IOPORT, TEENSY_PIN8)
+#define LINE_PIN9           PAL_LINE(TEENSY_PIN9_IOPORT, TEENSY_PIN9)
+#define LINE_PIN10          PAL_LINE(TEENSY_PIN10_IOPORT, TEENSY_PIN10)
+#define LINE_PIN11          PAL_LINE(TEENSY_PIN11_IOPORT, TEENSY_PIN11)
+#define LINE_PIN12          PAL_LINE(TEENSY_PIN12_IOPORT, TEENSY_PIN12)
+#define LINE_PIN13          PAL_LINE(TEENSY_PIN13_IOPORT, TEENSY_PIN13)
+#define LINE_PIN14          PAL_LINE(TEENSY_PIN14_IOPORT, TEENSY_PIN14)
+#define LINE_PIN15          PAL_LINE(TEENSY_PIN15_IOPORT, TEENSY_PIN15)
+#define LINE_PIN16          PAL_LINE(TEENSY_PIN16_IOPORT, TEENSY_PIN16)
+#define LINE_PIN17          PAL_LINE(TEENSY_PIN17_IOPORT, TEENSY_PIN17)
+#define LINE_PIN18          PAL_LINE(TEENSY_PIN18_IOPORT, TEENSY_PIN18)
+#define LINE_PIN19          PAL_LINE(TEENSY_PIN19_IOPORT, TEENSY_PIN19)
+#define LINE_PIN20          PAL_LINE(TEENSY_PIN20_IOPORT, TEENSY_PIN20)
+#define LINE_PIN21          PAL_LINE(TEENSY_PIN21_IOPORT, TEENSY_PIN21)
+#define LINE_PIN22          PAL_LINE(TEENSY_PIN22_IOPORT, TEENSY_PIN22)
+#define LINE_PIN23          PAL_LINE(TEENSY_PIN23_IOPORT, TEENSY_PIN23)
+#define LINE_PIN24          PAL_LINE(TEENSY_PIN24_IOPORT, TEENSY_PIN24)
+#define LINE_PIN25          PAL_LINE(TEENSY_PIN25_IOPORT, TEENSY_PIN25)
+#define LINE_PIN25          PAL_LINE(TEENSY_PIN25_IOPORT, TEENSY_PIN25)
+#define LINE_PIN26          PAL_LINE(TEENSY_PIN26_IOPORT, TEENSY_PIN26)
+#define LINE_PIN27          PAL_LINE(TEENSY_PIN27_IOPORT, TEENSY_PIN27)
+#define LINE_PIN28          PAL_LINE(TEENSY_PIN28_IOPORT, TEENSY_PIN28)
+#define LINE_PIN29          PAL_LINE(TEENSY_PIN29_IOPORT, TEENSY_PIN29)
+#define LINE_PIN30          PAL_LINE(TEENSY_PIN30_IOPORT, TEENSY_PIN30)
+#define LINE_PIN31          PAL_LINE(TEENSY_PIN31_IOPORT, TEENSY_PIN31)
+#define LINE_PIN32          PAL_LINE(TEENSY_PIN32_IOPORT, TEENSY_PIN32)
+#define LINE_PIN33          PAL_LINE(TEENSY_PIN33_IOPORT, TEENSY_PIN33)
+
+#define LINE_LED            LINE_PIN13
+
+#if !defined(_FROM_ASM_)
+#ifdef __cplusplus
+extern "C" {
+#endif
+  void boardInit(void);
+#ifdef __cplusplus
+}
+#endif
+#endif /* _FROM_ASM_ */
+
+#endif /* _BOARD_H_ */

drivers/boards/IC_TEENSY_3_1/board.mk

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

keyboards/1up60rgb/1up60rgb.c

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

keyboards/1up60rgb/1up60rgb.h

@@ -0,0 +1,66 @@
+#ifndef KB_H
+#define KB_H
+
+#include "quantum.h"
+
+#define LAYOUT_all( \
+	K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K012, K013, K014, \
+	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, K214, \
+	K300, K301, K302, K303, K304, K305, K306, K307, K308, K309, K310, K311,       K313, K314, \
+	K400, K401,       K403,             K406,                   K410, K411,       K413, K414  \
+) { \
+	{ 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,  K214 }, \
+	{ K300,  K301,  K302,  K303,  K304,  K305,  K306,  K307,  K308,  K309,  K310,  K311,  KC_NO, K313,  K314 }, \
+	{ K400,  K401,  KC_NO, K403,  KC_NO, KC_NO, K406,  KC_NO, KC_NO, KC_NO, K410,  K411,  KC_NO, K413,  K414 }  \
+}
+
+
+/* ANSI variant. No extra keys for ISO */
+#define LAYOUT_60_ansi( \
+	K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K012,       K013, \
+	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,       K214, \
+	K300,       K302, K303, K304, K305, K306, K307, K308, K309, K310, K311,             K313, \
+	K400, K401,       K403,             K406,                   K410, K411,       K413, K414  \
+) LAYOUT_all( \
+	K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K012, K013, K013,\
+	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, K214, K214, \
+	K300, KC_NO,K302, K303, K304, K305, K306, K307, K308, K309, K310, K311,       K313, KC_NO,\
+	K400, K401,       K403,             K406,                   K410, K411,       K413, K414  \
+)
+
+/* ISO variant. Remove useless ANSI keys */
+#define LAYOUT_60_iso( \
+	K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K012,       K013, \
+	K100,       K102, K103, K104, K105, K106, K107, K108, K109, K110, K111, K112, K113,       \
+	K200,       K202, K203, K204, K205, K206, K207, K208, K209, K210, K211, K212, K213, K214, \
+	K300, K301, K302, K303, K304, K305, K306, K307, K308, K309, K310, K311,             K313, \
+	K400, K401,       K403,             K406,                   K410, K411,       K413, K414  \
+) LAYOUT_all( \
+	K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K012, K013, K013,\
+	K100,       K102, K103, K104, K105, K106, K107, K108, K109, K110, K111, K112, K113, K214, \
+	K200,       K202, K203, K204, K205, K206, K207, K208, K209, K210, K211, K212, K213, K214, \
+	K300, K301, K302, K303, K304, K305, K306, K307, K308, K309, K310, K311,       K313, KC_NO,\
+	K400, K401,       K403,             K406,                   K410, K411,       K413, K414  \
+)
+
+/* HHKB Variant */
+#define LAYOUT_60_ansi_split_bs_rshift( \
+	K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K012, K013, K014, \
+	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,       K214, \
+	K300,       K302, K303, K304, K305, K306, K307, K308, K309, K310, K311,       K313, K314, \
+	K400, K401,       K403,             K406,                   K410, K411,       K413, K414  \
+) LAYOUT_all( \
+	K000, K001, K002, K003, K004, K005, K006, K007, K008, K009, K010, K011, K012, K013, K014,\
+	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, K214, K214, \
+	K300, KC_NO,K302, K303, K304, K305, K306, K307, K308, K309, K310, K311,       K313, K314,\
+	K400, K401,       K403,             K406,                   K410, K411,       K413, K414  \
+)
+
+#endif

keyboards/1up60rgb/config.h

@@ -0,0 +1,58 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6060
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    1upkeyboards
+#define PRODUCT         1UP RGB Underglow PCB
+#define DESCRIPTION     60% keyboard with RGB underglow
+
+/* key matrix size */
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 15
+
+/* key matrix pins */
+#define MATRIX_ROW_PINS { D0, D1, D2, D3, D5 }
+#define MATRIX_COL_PINS { F0, F1, E6, C7, C6, B7, D4, B1, B0, B5, B4, D7, D6, B3, F4 }
+#define UNUSED_PINS
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+/* number of backlight levels */
+#define BACKLIGHT_PIN B6
+#ifdef BACKLIGHT_PIN
+#define BACKLIGHT_LEVELS 5
+#endif
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCING_DELAY 5
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/* key combination for command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+/* prevent stuck modifiers */
+#define PREVENT_STUCK_MODIFIERS
+
+#define RGB_DI_PIN E2
+#ifdef RGB_DI_PIN
+#define RGBLIGHT_ANIMATIONS
+#define RGBLED_NUM 20
+#define RGBLIGHT_HUE_STEP 8
+#define RGBLIGHT_SAT_STEP 8
+#define RGBLIGHT_VAL_STEP 8
+#endif
+
+#endif

keyboards/1up60rgb/info.json

@@ -0,0 +1,24 @@
+{
+  "keyboard_name": "1up60rgb",
+  "url": "",
+  "maintainer": "qmk",
+  "width": 15,
+  "height": 5,
+  "layouts": {
+    "LAYOUT_all": {
+      "layout": [{"label":"~", "x":0, "y":0}, {"label":"!", "x":1, "y":0}, {"label":"@", "x":2, "y":0}, {"label":"#", "x":3, "y":0}, {"label":"$", "x":4, "y":0}, {"label":"%", "x":5, "y":0}, {"label":"^", "x":6, "y":0}, {"label":"&", "x":7, "y":0}, {"label":"*", "x":8, "y":0}, {"label":"(", "x":9, "y":0}, {"label":")", "x":10, "y":0}, {"label":"_", "x":11, "y":0}, {"label":"+", "x":12, "y":0}, {"label":"~", "x":13, "y":0}, {"label":"Del", "x":14, "y":0}, {"label":"Tab", "x":0, "y":1, "w":1.5}, {"label":"Q", "x":1.5, "y":1}, {"label":"W", "x":2.5, "y":1}, {"label":"E", "x":3.5, "y":1}, {"label":"R", "x":4.5, "y":1}, {"label":"T", "x":5.5, "y":1}, {"label":"Y", "x":6.5, "y":1}, {"label":"U", "x":7.5, "y":1}, {"label":"I", "x":8.5, "y":1}, {"label":"O", "x":9.5, "y":1}, {"label":"P", "x":10.5, "y":1}, {"label":"{", "x":11.5, "y":1}, {"label":"}", "x":12.5, "y":1}, {"label":"|", "x":13.5, "y":1, "w":1.5}, {"label":"Caps Lock", "x":0, "y":2, "w":1.75}, {"label":"A", "x":1.75, "y":2}, {"label":"S", "x":2.75, "y":2}, {"label":"D", "x":3.75, "y":2}, {"label":"F", "x":4.75, "y":2}, {"label":"G", "x":5.75, "y":2}, {"label":"H", "x":6.75, "y":2}, {"label":"J", "x":7.75, "y":2}, {"label":"K", "x":8.75, "y":2}, {"label":"L", "x":9.75, "y":2}, {"label":":", "x":10.75, "y":2}, {"label":"\"", "x":11.75, "y":2}, {"x":12.75, "y":2}, {"label":"Enter", "x":13.75, "y":2, "w":1.25}, {"label":"Shift", "x":0, "y":3, "w":1.25}, {"x":1.25, "y":3}, {"label":"Z", "x":2.25, "y":3}, {"label":"X", "x":3.25, "y":3}, {"label":"C", "x":4.25, "y":3}, {"label":"V", "x":5.25, "y":3}, {"label":"B", "x":6.25, "y":3}, {"label":"N", "x":7.25, "y":3}, {"label":"M", "x":8.25, "y":3}, {"label":"<", "x":9.25, "y":3}, {"label":">", "x":10.25, "y":3}, {"label":"?", "x":11.25, "y":3}, {"label":"Shift", "x":12.25, "y":3, "w":1.75}, {"label":"Fn", "x":14, "y":3}, {"label":"Ctrl", "x":0, "y":4, "w":1.25}, {"label":"Win", "x":1.25, "y":4, "w":1.25}, {"label":"Alt", "x":2.5, "y":4, "w":1.25}, {"x":3.75, "y":4, "w":6.25}, {"label":"Alt", "x":10, "y":4, "w":1.25}, {"label":"Win", "x":11.25, "y":4, "w":1.25}, {"label":"Menu", "x":12.5, "y":4, "w":1.25}, {"label":"Ctrl", "x":13.75, "y":4, "w":1.25}]
+    },
+
+    "LAYOUT_60_ansi": {
+      "layout": [{"x":0, "y":0, "label":"~"}, {"x":1, "y":0, "label":"!"}, {"x":2, "y":0, "label":"@"}, {"x":3, "y":0, "label":"#"}, {"x":4, "y":0, "label":"$"}, {"x":5, "y":0, "label":"%"}, {"x":6, "y":0, "label":"^"}, {"x":7, "y":0, "label":"&"}, {"x":8, "y":0, "label":"*"}, {"x":9, "y":0, "label":"("}, {"x":10, "y":0, "label":")"}, {"x":11, "y":0, "label":"_"}, {"x":12, "y":0, "label":"+"}, {"x":13, "y":0, "label":"Backspace", "w":2}, {"x":0, "y":1, "label":"Tab", "w":1.5}, {"x":1.5, "y":1, "label":"Q"}, {"x":2.5, "y":1, "label":"W"}, {"x":3.5, "y":1, "label":"E"}, {"x":4.5, "y":1, "label":"R"}, {"x":5.5, "y":1, "label":"T"}, {"x":6.5, "y":1, "label":"Y"}, {"x":7.5, "y":1, "label":"U"}, {"x":8.5, "y":1, "label":"I"}, {"x":9.5, "y":1, "label":"O"}, {"x":10.5, "y":1, "label":"P"}, {"x":11.5, "y":1, "label":"{"}, {"x":12.5, "y":1, "label":"}"}, {"x":13.5, "y":1, "label":"|", "w":1.5}, {"x":0, "y":2, "label":"Caps Lock", "w":1.75}, {"x":1.75, "y":2, "label":"A"}, {"x":2.75, "y":2, "label":"S"}, {"x":3.75, "y":2, "label":"D"}, {"x":4.75, "y":2, "label":"F"}, {"x":5.75, "y":2, "label":"G"}, {"x":6.75, "y":2, "label":"H"}, {"x":7.75, "y":2, "label":"J"}, {"x":8.75, "y":2, "label":"K"}, {"x":9.75, "y":2, "label":"L"}, {"x":10.75, "y":2, "label":":"}, {"x":11.75, "y":2, "label":"\""}, {"x":12.75, "y":2, "label":"Enter", "w":2.25}, {"x":0, "y":3, "label":"Shift", "w":2.25}, {"x":2.25, "y":3, "label":"Z"}, {"x":3.25, "y":3, "label":"X"}, {"x":4.25, "y":3, "label":"C"}, {"x":5.25, "y":3, "label":"V"}, {"x":6.25, "y":3, "label":"B"}, {"x":7.25, "y":3, "label":"N"}, {"x":8.25, "y":3, "label":"M"}, {"x":9.25, "y":3, "label":"<"}, {"x":10.25, "y":3, "label":">"}, {"x":11.25, "y":3, "label":"?"}, {"x":12.25, "y":3, "label":"Shift", "w":2.75}, {"x":0, "y":4, "label":"Ctrl", "w":1.25}, {"x":1.25, "y":4, "label":"Win", "w":1.25}, {"x":2.5, "y":4, "label":"Alt", "w":1.25}, {"x":3.75, "y":4, "w":6.25}, {"x":10, "y":4, "label":"Alt", "w":1.25}, {"x":11.25, "y":4, "label":"Win", "w":1.25}, {"x":12.5, "y":4, "label":"Menu", "w":1.25}, {"x":13.75, "y":4, "label":"Ctrl", "w":1.25}]
+    },
+
+    "LAYOUT_60_iso": {
+      "layout": [{"label":"\u00ac", "x":0, "y":0}, {"label":"!", "x":1, "y":0}, {"label":"\"", "x":2, "y":0}, {"label":"\u00a3", "x":3, "y":0}, {"label":"$", "x":4, "y":0}, {"label":"%", "x":5, "y":0}, {"label":"^", "x":6, "y":0}, {"label":"&", "x":7, "y":0}, {"label":"*", "x":8, "y":0}, {"label":"(", "x":9, "y":0}, {"label":")", "x":10, "y":0}, {"label":"_", "x":11, "y":0}, {"label":"+", "x":12, "y":0}, {"label":"Backspace", "x":13, "y":0, "w":2}, {"label":"Tab", "x":0, "y":1, "w":1.5}, {"label":"Q", "x":1.5, "y":1}, {"label":"W", "x":2.5, "y":1}, {"label":"E", "x":3.5, "y":1}, {"label":"R", "x":4.5, "y":1}, {"label":"T", "x":5.5, "y":1}, {"label":"Y", "x":6.5, "y":1}, {"label":"U", "x":7.5, "y":1}, {"label":"I", "x":8.5, "y":1}, {"label":"O", "x":9.5, "y":1}, {"label":"P", "x":10.5, "y":1}, {"label":"{", "x":11.5, "y":1}, {"label":"}", "x":12.5, "y":1}, {"label":"Enter", "x":13.75, "y":1, "w":1.25, "h":2}, {"label":"Caps Lock", "x":0, "y":2, "w":1.75}, {"label":"A", "x":1.75, "y":2}, {"label":"S", "x":2.75, "y":2}, {"label":"D", "x":3.75, "y":2}, {"label":"F", "x":4.75, "y":2}, {"label":"G", "x":5.75, "y":2}, {"label":"H", "x":6.75, "y":2}, {"label":"J", "x":7.75, "y":2}, {"label":"K", "x":8.75, "y":2}, {"label":"L", "x":9.75, "y":2}, {"label":":", "x":10.75, "y":2}, {"label":"@", "x":11.75, "y":2}, {"label":"~", "x":12.75, "y":2}, {"label":"Shift", "x":0, "y":3, "w":1.25}, {"label":"|", "x":1.25, "y":3}, {"label":"Z", "x":2.25, "y":3}, {"label":"X", "x":3.25, "y":3}, {"label":"C", "x":4.25, "y":3}, {"label":"V", "x":5.25, "y":3}, {"label":"B", "x":6.25, "y":3}, {"label":"N", "x":7.25, "y":3}, {"label":"M", "x":8.25, "y":3}, {"label":"<", "x":9.25, "y":3}, {"label":">", "x":10.25, "y":3}, {"label":"?", "x":11.25, "y":3}, {"label":"Shift", "x":12.25, "y":3, "w":2.75}, {"label":"Ctrl", "x":0, "y":4, "w":1.25}, {"label":"Win", "x":1.25, "y":4, "w":1.25}, {"label":"Alt", "x":2.5, "y":4, "w":1.25}, {"x":3.75, "y":4, "w":6.25}, {"label":"AltGr", "x":10, "y":4, "w":1.25}, {"label":"Win", "x":11.25, "y":4, "w":1.25}, {"label":"Menu", "x":12.5, "y":4, "w":1.25}, {"label":"Ctrl", "x":13.75, "y":4, "w":1.25}]
+    },
+
+    "LAYOUT_60_ansi_split_bs_rshift": {
+      "layout": [{"label":"~", "x":0, "y":0}, {"label":"!", "x":1, "y":0}, {"label":"@", "x":2, "y":0}, {"label":"#", "x":3, "y":0}, {"label":"$", "x":4, "y":0}, {"label":"%", "x":5, "y":0}, {"label":"^", "x":6, "y":0}, {"label":"&", "x":7, "y":0}, {"label":"*", "x":8, "y":0}, {"label":"(", "x":9, "y":0}, {"label":")", "x":10, "y":0}, {"label":"_", "x":11, "y":0}, {"label":"+", "x":12, "y":0}, {"x":13, "y":0}, {"x":14, "y":0}, {"label":"Tab", "x":0, "y":1, "w":1.5}, {"label":"Q", "x":1.5, "y":1}, {"label":"W", "x":2.5, "y":1}, {"label":"E", "x":3.5, "y":1}, {"label":"R", "x":4.5, "y":1}, {"label":"T", "x":5.5, "y":1}, {"label":"Y", "x":6.5, "y":1}, {"label":"U", "x":7.5, "y":1}, {"label":"I", "x":8.5, "y":1}, {"label":"O", "x":9.5, "y":1}, {"label":"P", "x":10.5, "y":1}, {"label":"{", "x":11.5, "y":1}, {"label":"}", "x":12.5, "y":1}, {"label":"|", "x":13.5, "y":1, "w":1.5}, {"label":"Caps Lock", "x":0, "y":2, "w":1.75}, {"label":"A", "x":1.75, "y":2}, {"label":"S", "x":2.75, "y":2}, {"label":"D", "x":3.75, "y":2}, {"label":"F", "x":4.75, "y":2}, {"label":"G", "x":5.75, "y":2}, {"label":"H", "x":6.75, "y":2}, {"label":"J", "x":7.75, "y":2}, {"label":"K", "x":8.75, "y":2}, {"label":"L", "x":9.75, "y":2}, {"label":":", "x":10.75, "y":2}, {"label":"\"", "x":11.75, "y":2}, {"label":"Enter", "x":12.75, "y":2, "w":2.25}, {"label":"Shift", "x":0, "y":3, "w":2.25}, {"label":"Z", "x":2.25, "y":3}, {"label":"X", "x":3.25, "y":3}, {"label":"C", "x":4.25, "y":3}, {"label":"V", "x":5.25, "y":3}, {"label":"B", "x":6.25, "y":3}, {"label":"N", "x":7.25, "y":3}, {"label":"M", "x":8.25, "y":3}, {"label":"<", "x":9.25, "y":3}, {"label":">", "x":10.25, "y":3}, {"label":"?", "x":11.25, "y":3}, {"label":"Shift", "x":12.25, "y":3, "w":1.75}, {"x":14, "y":3}, {"label":"Ctrl", "x":0, "y":4, "w":1.5}, {"label":"Win", "x":1.5, "y":4}, {"label":"Alt", "x":2.5, "y":4, "w":1.5}, {"x":4, "y":4, "w":6}, {"label":"Alt", "x":10, "y":4, "w":1.5}, {"label":"Win", "x":11.5, "y":4}, {"label":"Menu", "x":12.5, "y":4}, {"label":"Ctrl", "x":13.5, "y":4, "w":1.5}]
+    }
+  }
+}

keyboards/1up60rgb/keymaps/default/keymap.c

@@ -0,0 +1,72 @@
+#include "1up60rgb.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+	LAYOUT_all(
+		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_BSPC, KC_BSPC,
+		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_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_ENT,
+		KC_LSFT, KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_RSFT,
+		KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RGUI, MO(1), KC_RCTL),
+
+	LAYOUT_all(
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+	;
+
+	switch (id) {
+
+	}
+	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) {
+
+	if (usb_led & (1 << USB_LED_NUM_LOCK)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
+		DDRB |= (1 << 2); PORTB &= ~(1 << 2);
+	} else {
+		DDRB &= ~(1 << 2); PORTB &= ~(1 << 2);
+	}
+
+	if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_COMPOSE)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_KANA)) {
+
+	} else {
+
+	}
+
+}

keyboards/1up60rgb/keymaps/iso/keymap.c

@@ -0,0 +1,72 @@
+#include "1up60rgb.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+	LAYOUT_all(
+		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_BSPC, KC_BSPC,
+		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_ENT,
+		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_LSFT, KC_NUBS, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_RSFT,
+		KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RGUI, MO(1), KC_RCTL),
+
+	LAYOUT_all(
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+	;
+
+	switch (id) {
+
+	}
+	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) {
+
+	if (usb_led & (1 << USB_LED_NUM_LOCK)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
+		DDRB |= (1 << 2); PORTB &= ~(1 << 2);
+	} else {
+		DDRB &= ~(1 << 2); PORTB &= ~(1 << 2);
+	}
+
+	if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_COMPOSE)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_KANA)) {
+
+	} else {
+
+	}
+
+}