Branch point for 2020 Feb 29 Breaking Change.

* [Docs] fix installation commands for macos

* Update docs/getting_started_build_tools.md

.github/ISSUE_TEMPLATE/blank.md

@@ -1,5 +1,11 @@
 ---
 name: Blank issue
-about: If you're 100% sure that you don't need one of the other issue templates, use this one instead. 
+about: If you're 100% sure that you don't need one of the other issue templates, use
+  this one instead.
+title: ''
+labels: help wanted, question
+assignees: ''
 
 ---
+
+

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,7 +1,12 @@
 ---
 name: Bug report
-about: Create a report to help us improve the QMK Firmware
+about: Create a report to help us improve QMK Firmware.
+title: "[Bug] "
+labels: bug, help wanted
+assignees: ''
+
 ---
+
 <!-- Provide a general summary of the bug in the title above. -->
 
 <!--- This template is entirely optional and can be removed, but is here to help both you and us. -->

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: QMK Discord
+    url: https://discord.gg/Uq7gcHh
+    about: Ask questions, discuss issues and features. Chill.
+  - name: OLKB Subreddit
+    url: https://www.reddit.com/r/olkb
+    about: All things OLKB and QMK.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,7 +1,12 @@
 ---
 name: Feature request
-about: Suggest a new feature or changes to existing features 
+about: Suggest a new feature or changes to existing features.
+title: "[Feature Request] "
+labels: enhancement, help wanted
+assignees: ''
+
 ---
+
 <!--- Provide a general summary of the changes you want in the title above. -->
 
 <!--- This template is entirely optional and can be removed, but is here to help both you and us. -->

.github/ISSUE_TEMPLATE/other_issues.md

@@ -1,7 +1,12 @@
 ---
 name: Other issues
-about: Anything else that doesn't fall into the above categories. 
+about: Anything else that doesn't fall into the above categories.
+title: ''
+labels: help wanted, question
+assignees: ''
+
 ---
+
 <!--- Provide a general summary of the changes you want in the title above. -->
 
 <!--- Anything on lines wrapped in comments like these will not show up in the final text. -->

.github/stale.yml

@@ -0,0 +1,58 @@
+# Configuration for probot-stale - https://github.com/probot/stale
+
+# General configuration
+
+# Pull request specific configuration
+pulls:
+  staleLabel: awaiting changes
+  # Number of days of inactivity before an Issue or Pull Request becomes stale
+  daysUntilStale: 45
+  # Number of days of inactivity before a stale Issue or Pull Request is closed.
+  # Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
+  daysUntilClose: 30
+  # Comment to post when marking as stale. Set to `false` to disable
+  markComment: >
+    Thank you for your contribution!
+
+    This pull request has been automatically marked as stale because it has not had
+    activity in the last 45 days. It will be closed in 30 days if no further activity occurs.
+    Please feel free to give a status update now, or re-open when it's ready.
+    
+    For maintainers: Please label with `awaiting review`, `breaking_change`, `in progress`, or `on hold` to prevent 
+    the issue from being re-flagged.
+  # Comment to post when closing a stale Issue or Pull Request.
+  closeComment: >
+    Thank you for your contribution!
+
+    This pull request has been automatically closed because it has not had activity in the last 30 days.
+    Please feel free to give a status update now, ping for review, or re-open when it's ready.
+  # Limit the number of actions per hour, from 1-30. Default is 30
+  limitPerRun: 30
+  exemptLabels:
+    - awaiting review
+    - breaking_change
+    - in progress
+    - on hold
+
+# Issue specific configuration
+issues:
+  staleLabel: stale
+  limitPerRun: 10
+  daysUntilStale: 90
+  daysUntilClose: 30
+  markComment: >
+    This issue has been automatically marked as stale because it has not had activity in the
+    last 90 days. It will be closed in the next 30 days unless it is tagged properly or other activity
+    occurs.
+    
+    For maintainers: Please label with `bug`, `in progress`, `on hold`, `discussion` or `to do` to prevent 
+    the issue from being re-flagged.
+  closeComment: >
+    This issue has been automatically closed because it has not had activity in the last 30 days.
+    If this issue is still valid, re-open the issue and let us know.
+  exemptLabels:
+    - bug
+    - in progress
+    - on hold
+    - discussion
+    - to do

.travis.yml

@@ -16,6 +16,7 @@ install:
   - npm install -g moxygen
 script:
   - git rev-parse --short HEAD
+  - git diff --name-only HEAD $TRAVIS_BRANCH
   - bash util/travis_test.sh
   - bash util/travis_build.sh
   - bash util/travis_docs.sh

Makefile

@@ -272,12 +272,14 @@ define PARSE_RULE
     # If the rule starts with all, then continue the parsing from
     # PARSE_ALL_KEYBOARDS
     ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,all),true)
+        KEYBOARD_RULE=all
         $$(eval $$(call PARSE_ALL_KEYBOARDS))
     else ifeq ($$(call COMPARE_AND_REMOVE_FROM_RULE,test),true)
         $$(eval $$(call PARSE_TEST))
     # If the rule starts with the name of a known keyboard, then continue
     # the parsing from PARSE_KEYBOARD
     else ifeq ($$(call TRY_TO_MATCH_RULE_FROM_LIST,$$(KEYBOARDS)),true)
+        KEYBOARD_RULE=$$(MATCHED_ITEM)
         $$(eval $$(call PARSE_KEYBOARD,$$(MATCHED_ITEM)))
     # Otherwise use the KEYBOARD variable, which is determined either by
     # the current directory you run make from, or passed in as an argument
@@ -380,6 +382,9 @@ define PARSE_KEYBOARD
     # Otherwise try to match the keymap from the current folder, or arguments to the make command
     else ifneq ($$(KEYMAP),)
         $$(eval $$(call PARSE_KEYMAP,$$(KEYMAP)))
+    # Otherwise if we are running make all:<user> just skip
+    else ifeq ($$(KEYBOARD_RULE),all)
+        # $$(info Skipping: No user keymap for $$(CURRENT_KB))
     # Otherwise, make all keymaps, again this is consistent with how it works without
     # any arguments
     else
@@ -558,10 +563,10 @@ endef
 	if ! python3 --version 1> /dev/null 2>&1; then printf "$(MSG_PYTHON_MISSING)"; fi
 	# Check if the submodules are dirty, and display a warning if they are
 ifndef SKIP_GIT
-	if [ ! -e lib/chibios ]; then git submodule sync lib/chibios && git submodule update --depth 1 --init lib/chibios; fi
-	if [ ! -e lib/chibios-contrib ]; then git submodule sync lib/chibios-contrib && git submodule update --depth 1 --init lib/chibios-contrib; fi
-	if [ ! -e lib/ugfx ]; then git submodule sync lib/ugfx && git submodule update --depth 1 --init lib/ugfx; fi
-	if [ ! -e lib/lufa ]; then git submodule sync lib/lufa && git submodule update --depth 1 --init lib/lufa; fi
+	if [ ! -e lib/chibios ]; then git submodule sync lib/chibios && git submodule update --depth 50 --init lib/chibios; fi
+	if [ ! -e lib/chibios-contrib ]; then git submodule sync lib/chibios-contrib && git submodule update --depth 50 --init lib/chibios-contrib; fi
+	if [ ! -e lib/ugfx ]; then git submodule sync lib/ugfx && git submodule update --depth 50 --init lib/ugfx; fi
+	if [ ! -e lib/lufa ]; then git submodule sync lib/lufa && git submodule update --depth 50 --init lib/lufa; fi
 	git submodule status --recursive 2>/dev/null | \
 	while IFS= read -r x; do \
 		case "$$x" in \

bin/qmk

@@ -25,6 +25,11 @@ with open(os.path.join(qmk_dir, 'requirements.txt'), 'r') as fd:
             line = line.split('#')[0]
 
         module = line.split('=')[0] if '=' in line else line
+
+        if module in ['pep8-naming']:
+            # Not every module is importable by its own name.
+            continue
+
         if not find_spec(module):
             print('Could not find module %s!' % module)
             print('Please run `pip3 install -r requirements.txt` to install the python dependencies.')
@@ -41,7 +46,7 @@ else:
     os.environ['QMK_VERSION'] = 'nogit-' + strftime('%Y-%m-%d-%H:%M:%S') + '-dirty'
 
 # Setup the CLI
-import milc
+import milc  # noqa
 
 milc.EMOJI_LOGLEVELS['INFO'] = '{fg_blue}Ψ{style_reset_all}'
 
@@ -61,7 +66,7 @@ def main():
     os.chdir(qmk_dir)
 
     # Import the subcommands
-    import qmk.cli
+    import qmk.cli  # noqa
 
     # Execute
     return_code = milc.cli()

bootloader.mk

@@ -82,6 +82,13 @@ ifeq ($(strip $(BOOTLOADER)), USBasp)
     OPT_DEFS += -DBOOTLOADER_USBASP
     BOOTLOADER_SIZE = 4096
 endif
+ifeq ($(strip $(BOOTLOADER)), lufa-ms)
+    # DO NOT USE THIS BOOTLOADER IN NEW PROJECTS!
+    # It is extremely prone to bricking, and is only included to support existing boards.
+    OPT_DEFS += -DBOOTLOADER_MS
+    BOOTLOADER_SIZE = 6144
+    FIRMWARE_FORMAT = bin
+endif
 
 ifdef BOOTLOADER_SIZE
     OPT_DEFS += -DBOOTLOADER_SIZE=$(strip $(BOOTLOADER_SIZE))

build_json.mk

@@ -22,6 +22,5 @@ else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.json)","")
 endif
 
 # Generate the keymap.c
-ifneq ("$(KEYMAP_JSON)","")
-    _ = $(shell test -e $(KEYMAP_C) || bin/qmk json-keymap $(KEYMAP_JSON) -o $(KEYMAP_C))
-endif
+$(KEYBOARD_OUTPUT)/src/keymap.c: $(KEYMAP_JSON)
+	bin/qmk json-keymap --quiet --output $(KEYMAP_C) $(KEYMAP_JSON)

common_features.mk

@@ -82,19 +82,19 @@ endif
 
 ifeq ($(strip $(UCIS_ENABLE)), yes)
     OPT_DEFS += -DUCIS_ENABLE
-    UNICODE_COMMON = yes
+    UNICODE_COMMON := yes
     SRC += $(QUANTUM_DIR)/process_keycode/process_ucis.c
 endif
 
 ifeq ($(strip $(UNICODEMAP_ENABLE)), yes)
     OPT_DEFS += -DUNICODEMAP_ENABLE
-    UNICODE_COMMON = yes
+    UNICODE_COMMON := yes
     SRC += $(QUANTUM_DIR)/process_keycode/process_unicodemap.c
 endif
 
 ifeq ($(strip $(UNICODE_ENABLE)), yes)
     OPT_DEFS += -DUNICODE_ENABLE
-    UNICODE_COMMON = yes
+    UNICODE_COMMON := yes
     SRC += $(QUANTUM_DIR)/process_keycode/process_unicode.c
 endif
 
@@ -107,12 +107,13 @@ ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
     OPT_DEFS += -DRGBLIGHT_ENABLE
     SRC += $(QUANTUM_DIR)/color.c
     SRC += $(QUANTUM_DIR)/rgblight.c
-    CIE1931_CURVE = yes
-    LED_BREATHING_TABLE = yes
+    CIE1931_CURVE := yes
+    LED_BREATHING_TABLE := yes
+    RGB_KEYCODES_ENABLE := yes
     ifeq ($(strip $(RGBLIGHT_CUSTOM_DRIVER)), yes)
         OPT_DEFS += -DRGBLIGHT_CUSTOM_DRIVER
     else
-        WS2812_DRIVER_REQUIRED = yes
+        WS2812_DRIVER_REQUIRED := yes
     endif
 endif
 
@@ -146,11 +147,12 @@ endif
     SRC += $(QUANTUM_DIR)/color.c
     SRC += $(QUANTUM_DIR)/rgb_matrix.c
     SRC += $(QUANTUM_DIR)/rgb_matrix_drivers.c
-    CIE1931_CURVE = yes
+    CIE1931_CURVE := yes
+    RGB_KEYCODES_ENABLE := yes
 endif
 
 ifeq ($(strip $(RGB_MATRIX_ENABLE)), yes)
-	RGB_MATRIX_ENABLE = IS31FL3731
+	RGB_MATRIX_ENABLE := IS31FL3731
 endif
 
 ifeq ($(strip $(RGB_MATRIX_ENABLE)), IS31FL3731)
@@ -176,7 +178,7 @@ endif
 
 ifeq ($(strip $(RGB_MATRIX_ENABLE)), WS2812)
     OPT_DEFS += -DWS2812
-    WS2812_DRIVER_REQUIRED = yes
+    WS2812_DRIVER_REQUIRED := yes
 endif
 
 ifeq ($(strip $(RGB_MATRIX_CUSTOM_KB)), yes)
@@ -187,6 +189,10 @@ ifeq ($(strip $(RGB_MATRIX_CUSTOM_USER)), yes)
     OPT_DEFS += -DRGB_MATRIX_CUSTOM_USER
 endif
 
+ifeq ($(strip $(RGB_KEYCODES_ENABLE)), yes)
+    SRC += $(QUANTUM_DIR)/process_keycode/process_rgb.c
+endif
+
 ifeq ($(strip $(TAP_DANCE_ENABLE)), yes)
     OPT_DEFS += -DTAP_DANCE_ENABLE
     SRC += $(QUANTUM_DIR)/process_keycode/process_tap_dance.c
@@ -226,34 +232,35 @@ endif
 endif
 
 ifeq ($(strip $(LCD_ENABLE)), yes)
-    CIE1931_CURVE = yes
+    CIE1931_CURVE := yes
 endif
 
 # backward compat
 ifeq ($(strip $(BACKLIGHT_CUSTOM_DRIVER)), yes)
-    BACKLIGHT_ENABLE = custom
+    BACKLIGHT_DRIVER := custom
 endif
 
-VALID_BACKLIGHT_TYPES := yes software custom
+VALID_BACKLIGHT_TYPES := pwm software custom
 
 BACKLIGHT_ENABLE ?= no
-ifneq ($(strip $(BACKLIGHT_ENABLE)), no)
-    ifeq ($(filter $(BACKLIGHT_ENABLE),$(VALID_BACKLIGHT_TYPES)),)
-        $(error BACKLIGHT_ENABLE="$(BACKLIGHT_ENABLE)" is not a valid backlight type)
+BACKLIGHT_DRIVER ?= pwm
+ifeq ($(strip $(BACKLIGHT_ENABLE)), yes)
+    ifeq ($(filter $(BACKLIGHT_DRIVER),$(VALID_BACKLIGHT_TYPES)),)
+        $(error BACKLIGHT_DRIVER="$(BACKLIGHT_DRIVER)" is not a valid backlight type)
     endif
 
     ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
-        CIE1931_CURVE = yes
+        CIE1931_CURVE := yes
     endif
 
     COMMON_VPATH += $(QUANTUM_DIR)/backlight
     SRC += $(QUANTUM_DIR)/backlight/backlight.c
     OPT_DEFS += -DBACKLIGHT_ENABLE
 
-    ifeq ($(strip $(BACKLIGHT_ENABLE)), software)
+    ifeq ($(strip $(BACKLIGHT_DRIVER)), software)
         SRC += $(QUANTUM_DIR)/backlight/backlight_soft.c
     else
-        ifeq ($(strip $(BACKLIGHT_ENABLE)), custom)
+        ifeq ($(strip $(BACKLIGHT_DRIVER)), custom)
             OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER
         endif
 
@@ -287,12 +294,12 @@ endif
 
 ifeq ($(strip $(CIE1931_CURVE)), yes)
     OPT_DEFS += -DUSE_CIE1931_CURVE
-    LED_TABLES = yes
+    LED_TABLES := yes
 endif
 
 ifeq ($(strip $(LED_BREATHING_TABLE)), yes)
     OPT_DEFS += -DUSE_LED_BREATHING_TABLE
-    LED_TABLES = yes
+    LED_TABLES := yes
 endif
 
 ifeq ($(strip $(LED_TABLES)), yes)
@@ -342,6 +349,14 @@ ifeq ($(strip $(VELOCIKEY_ENABLE)), yes)
     SRC += $(QUANTUM_DIR)/velocikey.c
 endif
 
+ifeq ($(strip $(VIA_ENABLE)), yes)
+    DYNAMIC_KEYMAP_ENABLE := yes
+    RAW_ENABLE := yes
+    BOOTMAGIC_ENABLE := lite
+    SRC += $(QUANTUM_DIR)/via.c
+    OPT_DEFS += -DVIA_ENABLE
+endif
+
 ifeq ($(strip $(DYNAMIC_KEYMAP_ENABLE)), yes)
     OPT_DEFS += -DDYNAMIC_KEYMAP_ENABLE
     SRC += $(QUANTUM_DIR)/dynamic_keymap.c
@@ -407,6 +422,16 @@ ifeq ($(strip $(SPACE_CADET_ENABLE)), yes)
   OPT_DEFS += -DSPACE_CADET_ENABLE
 endif
 
+MAGIC_ENABLE ?= yes
+ifeq ($(strip $(MAGIC_ENABLE)), yes)
+    SRC += $(QUANTUM_DIR)/process_keycode/process_magic.c
+    OPT_DEFS += -DMAGIC_KEYCODE_ENABLE
+endif
+
+ifeq ($(strip $(DYNAMIC_MACRO_ENABLE)), yes)
+    SRC += $(QUANTUM_DIR)/process_keycode/process_dynamic_macro.c
+    OPT_DEFS += -DDYNAMIC_MACRO_ENABLE
+endif
 
 ifeq ($(strip $(DIP_SWITCH_ENABLE)), yes)
   SRC += $(QUANTUM_DIR)/dip_switch.c

docs/README.md

@@ -15,7 +15,7 @@ QMK (*Quantum Mechanical Keyboard*) is an open source community that maintains Q
 
 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`).
+Otherwise, you can clone it directly with `git clone https://github.com/qmk/qmk_firmware`. Do not download the zip or tar files; a git repository is required to download the submodules in order to compile.
 
 ## How to Compile
 

docs/_langs.md

@@ -4,4 +4,6 @@
   - [:es: Español](/es/)
   - [:fr: Français](/fr-fr/)
   - [:he: עברית](/he-il/)
+  - [:brazil: Português](/pt-br/)
   - [:ru: Русский](/ru-ru/)
+  - [:jp: 日本語](/ja/)

docs/_summary.md

@@ -3,7 +3,10 @@
   * [Building Your First Firmware](newbs_building_firmware.md)
   * [Flashing Firmware](newbs_flashing.md)
   * [Testing and Debugging](newbs_testing_debugging.md)
-  * [Git Best Practices](newbs_best_practices.md)
+  * [Best Git Practices](newbs_git_best_practices.md)
+    * [Using Your Fork's Master](newbs_git_using_your_master_branch.md)
+    * [Resolving Merge Conflicts](newbs_git_resolving_merge_conflicts.md)
+    * [Resynchronizing a Branch](newbs_git_resynchronize_a_branch.md)
   * [Learning Resources](newbs_learn_more_resources.md)
 
 * [QMK Basics](README.md)
@@ -33,6 +36,7 @@
   * [Keymap Overview](keymap.md)
 
 * [Hardware](hardware.md)
+  * [Compatible Microcontrollers](compatible_microcontrollers.md)
   * [AVR Processors](hardware_avr.md)
   * [Drivers](hardware_drivers.md)
 
@@ -97,6 +101,7 @@
   * [Hand Wiring Guide](hand_wire.md)
   * [ISP Flashing Guide](isp_flashing_guide.md)
   * [ARM Debugging Guide](arm_debugging.md)
+  * [ADC Driver](adc_driver.md)
   * [I2C Driver](i2c_driver.md)
   * [WS2812 Driver](ws2812_driver.md)
   * [GPIO Controls](internals_gpio_control.md)
@@ -110,7 +115,7 @@
   * [Using Eclipse with QMK](other_eclipse.md)
   * [Using VSCode with QMK](other_vscode.md)
   * [Support](support.md)
-  * [How to add translations](translating.md)
+  * [Translating the QMK Docs](translating.md)
 
 * QMK Internals (In Progress)
   * [Defines](internals_defines.md)

docs/adc_driver.md

@@ -0,0 +1,50 @@
+# ADC Driver
+
+QMK can leverage the Analog-to-Digital Converter (ADC) on supported MCUs to measure voltages on certain pins. This can be useful for implementing things such as battery level indicators for Bluetooth keyboards, or volume controls using a potentiometer, as opposed to a [rotary encoder](feature_encoders.md).
+
+This driver is currently AVR-only. The values returned are 10-bit integers (0-1023) mapped between 0V and VCC (usually 5V or 3.3V).
+
+## Usage
+
+To use this driver, add the following to your `rules.mk`:
+
+```make
+SRC += analog.c
+```
+
+Then place this include at the top of your code:
+
+```c
+#include "analog.h"
+```
+
+## Channels
+
+|Channel|AT90USB64/128|ATmega16/32U4|ATmega32A|ATmega328P|
+|-------|-------------|-------------|---------|----------|
+|0      |`F0`         |`F0`         |`A0`     |`C0`      |
+|1      |`F1`         |`F1`         |`A1`     |`C1`      |
+|2      |`F2`         |             |`A2`     |`C2`      |
+|3      |`F3`         |             |`A3`     |`C3`      |
+|4      |`F4`         |`F4`         |`A4`     |`C4`      |
+|5      |`F5`         |`F5`         |`A5`     |`C5`      |
+|6      |`F6`         |`F6`         |`A6`     |*         |
+|7      |`F7`         |`F7`         |`A7`     |*         |
+|8      |             |`D4`         |         |          |
+|9      |             |`D6`         |         |          |
+|10     |             |`D7`         |         |          |
+|11     |             |`B4`         |         |          |
+|12     |             |`B5`         |         |          |
+|13     |             |`B6`         |         |          |
+
+<sup>\* The ATmega328P possesses two extra ADC channels; however, they are not present on the DIP pinout, and are not shared with GPIO pins. You can use `adc_read()` directly to gain access to these.</sup>
+
+## Functions
+
+|Function                    |Description                                                                                                        |
+|----------------------------|-------------------------------------------------------------------------------------------------------------------|
+|`analogReference(mode)`     |Sets the analog voltage reference source. Must be one of `ADC_REF_EXTERNAL`, `ADC_REF_POWER` or `ADC_REF_INTERNAL`.|
+|`analogRead(pin)`           |Reads the value from the specified Arduino pin, eg. `4` for ADC6 on the ATmega32U4.                                |
+|`analogReadPin(pin)`        |Reads the value from the specified QMK pin, eg. `F6` for ADC6 on the ATmega32U4.                                   |
+|`pinToMux(pin)`             |Translates a given QMK pin to a mux value. If an unsupported pin is given, returns the mux value for "0V (GND)".   |
+|`adc_read(mux)`             |Reads the value from the ADC according to the specified mux. See your MCU's datasheet for more information.        |

docs/arm_debugging.md

@@ -1,4 +1,4 @@
-# ARM Debugging usign Eclipse
+# ARM Debugging using Eclipse
 
 This page describes how to setup debugging for ARM MCUs using an SWD adapter and open-source/free tools. In this guide we will install GNU MCU Eclipse IDE for C/C++ Developers and OpenOCD together with all the necessary dependencies.
 
@@ -18,7 +18,7 @@ XPM installation instructions can be found [here](https://www.npmjs.com/package/
 
 ### The ARM Toolchain
 
-Using XPM it is very easy to install the ARM toolchain. Enter the command `xpm install --global @gnu-mcu-eclipse/arm-none-eabi-gcc`.
+Using XPM it is very easy to install the ARM toolchain. Enter the command `xpm install --global @xpack-dev-tools/arm-none-eabi-gcc`.
 
 ### Windows build tools
 
@@ -33,7 +33,7 @@ If you have an ST-Link the drivers can be found [here](https://www.st.com/en/dev
 
 ### OpenOCD
 
-This dependency allows SWD access from GDB and it is essential for debugging. Run `xpm install --global @gnu-mcu-eclipse/openocd`.
+This dependency allows SWD access from GDB and it is essential for debugging. Run `xpm install --global @xpack-dev-tools/openocd`.
 
 ### Java
 
@@ -45,17 +45,17 @@ Now its finally time to install the IDE. Use the Release page [here](https://git
 
 ## Configuring Eclipse
 
-Open up the Eclipse IDE we just downloaded. To import our QMK directory select File -> Import -> C/C++ -> Existing code as Makefile Project. Select next and use Browse to select your QMK folder. In the tool-chain list select ARM Cross GCC and select Finish.
+Open up the Eclipse IDE we just downloaded. To import our QMK directory select File -> Import -> C/C++ -> Existing Code as Makefile Project. Select Next and use Browse to select your QMK folder. In the tool-chain list select ARM Cross GCC and select Finish.
 
-Now you can see the QMK folder on the left hand side. Right click it and select Properties. On the left hand side, expand MCU and select ARM Toolchain Paths. Press xPack and OK. Repeat for OpenOCD Path  and if you are on windows for Build Tool Path. Select Apply and Close.
+Now you can see the QMK folder on the left hand side. Right click it and select Properties. On the left hand side, expand MCU and select ARM Toolchains Paths. Press xPack and OK. Repeat for OpenOCD Path and if you are on Windows for Build Tools Path. Select Apply and Close.
 
-Now its time to install the necessary MCU packages. Go to Packs perspective by selecting Window -> Open Perspective -> Others -> Packs. Now select the yellow refresh symbol next to the Packs tab. This will take a long time as it is requesting the MCU definitions from various places. If some of the links fail you can probably select Ignore.
+Now its time to install the necessary MCU packages. Go to Packs perspective by selecting Window -> Perspective -> Open Perspective -> Other... -> Packs. Now select the yellow refresh symbol next to the Packs tab. This will take a long time as it is requesting the MCU definitions from various places. If some of the links fail you can probably select Ignore.
 
-When this finishes you must find the MCU which we will be building/debugging for. In this example I will be using the STM32F3 series MCUs. On the left, select STMicroelectonics -> STM32F3 Series. On the middle window we can see the pack. Right click and select Install. Once that is done we can go back to the default perspective, Window -> Open Perspective -> Others -> C/C++.
+When this finishes you must find the MCU which we will be building/debugging for. In this example I will be using the STM32F3 series MCUs. On the left, select STMicroelectronics -> STM32F3 Series. On the middle window we can see the pack. Right click and select Install. Once that is done we can go back to the default perspective, Window -> Perspective -> Open Perspective -> Other... -> C/C++.
 
-We need to let eclipse know the device we intent to build QMK on. Right click on the QMK folder -> Properties -> C/C++ Build -> Settings. Select the Devices tab and under devices select the appropriate variant of your MCU. For my example it is STM32F303CC
+We need to let eclipse know the device we intent to build QMK on. Right click on the QMK folder -> Properties -> C/C++ Build -> Settings. Select the Devices tab and under Devices select the appropriate variant of your MCU. For my example it is STM32F303CC
 
-While we are here let's setup the build command as well. Select C/C++ Build and then the Behavior tab. On the build command, replace `all` with your necessary make command. For example for a rev6 Planck with the default keymap this would be `planck/rev6:default`. Select Apply and Close.
+While we are here let's setup the build command as well. Select C/C++ Build and then the Behavior tab. On the Build command, replace `all` with your necessary make command. For example for a rev6 Planck with the default keymap this would be `planck/rev6:default`. Select Apply and Close.
 
 ## Building
 
@@ -71,7 +71,7 @@ NOTE: Make sure the SWCLK and SWDIO pins are not used in the matrix of your keyb
 
 ### Configuring the Debugger
 
-Right click on your QMK folder, select Debug As -> Debug Configuration. Here double click on GDB OpenOCD Debugging. Select the debugger tab and enter the configuration necessary for your MCU. This might take some fiddling and googleing to find out. The default script for the STM32F3 is called stm32f3discovery.cfg. To let OpenOCD know, in the Config options enter `-f board/stm32f3discovery.cfg`.
+Right click on your QMK folder, select Debug As -> Debug Configurations... . Here double click on GDB OpenOCD Debugging. Select the Debugger tab and enter the configuration necessary for your MCU. This might take some fiddling and Googling to find out. The default script for the STM32F3 is called `stm32f3discovery.cfg`. To let OpenOCD know, in the Config options enter `-f board/stm32f3discovery.cfg`.
 
 NOTE: In my case this configuration script requires editing to disable the reset assertion. The locations of the scripts can be found in the actual executable field usually under the path `openocd/version/.content/scripts/board`. Here I edited `reset_config srst_only` to `reset_config none`.
 
@@ -81,7 +81,7 @@ Select Apply and Close.
 
 Reset your keyboard.
 
-Press the bug icon and if all goes well you should soon find yourself in the debug perspective. Here the program counter will pause at the beginning of the main function and way for you to press Play. Most of the features of all debuggers work on ARM MCUs but for exact details google is your friend!
+Press the bug icon and if all goes well you should soon find yourself in the Debug perspective. Here the program counter will pause at the beginning of the main function and wait for you to press Play. Most of the features of all debuggers work on Arm MCUs but for exact details Google is your friend!
 
 
 Happy debugging!

docs/cli.md

@@ -95,6 +95,30 @@ qmk compile <configuratorExport.json>
 qmk compile -kb <keyboard_name> -km <keymap_name>
 ```
 
+## `qmk flash`
+
+This command is similar to `qmk compile`, but can also target a bootloader. The bootloader is optional, and is set to `:flash` by default.
+To specify a different bootloader, use `-bl <bootloader>`. Visit <https://docs.qmk.fm/#/flashing>
+for more details of the available bootloaders.
+
+**Usage for Configurator Exports**:
+
+```
+qmk flash <configuratorExport.json> -bl <bootloader>
+```
+
+**Usage for Keymaps**:
+
+```
+qmk flash -kb <keyboard_name> -km <keymap_name> -bl <bootloader>
+```
+
+**Listing the Bootloaders**
+
+```
+qmk flash -b
+```
+
 ## `qmk config`
 
 This command lets you configure the behavior of QMK. For the full `qmk config` documentation see [CLI Configuration](cli_configuration.md).
@@ -135,6 +159,28 @@ Creates a keymap.c from a QMK Configurator export.
 qmk json-keymap [-o OUTPUT] filename
 ```
 
+## `qmk kle2json`
+
+This command allows you to convert from raw KLE data to QMK Configurator JSON. It accepts either an absolute file path, or a file name in the current directory. By default it will not overwrite `info.json` if it is already present. Use the `-f` or `--force` flag to overwrite.
+
+**Usage**:
+
+```
+qmk kle2json [-f] <filename>
+```
+
+**Examples**:
+
+```
+$ qmk kle2json kle.txt 
+☒ File info.json already exists, use -f or --force to overwrite.
+```
+
+```
+$ qmk kle2json -f kle.txt -f
+Ψ Wrote out to info.json
+```
+
 ## `qmk list-keyboards`
 
 This command lists all the keyboards currently defined in `qmk_firmware`

docs/cli_development.md

@@ -173,3 +173,35 @@ You will only be able to access these arguments using `cli.args`. For example:
 ```
 cli.log.info('Reading from %s and writing to %s', cli.args.filename, cli.args.output)
 ```
+
+# Testing, and Linting, and Formatting (oh my!)
+
+We use nose2, flake8, and yapf to test, lint, and format code. You can use the `pytest` and `pyformat` subcommands to run these tests:
+
+### Testing and Linting
+
+    qmk pytest
+
+### Formatting
+
+    qmk pyformat
+
+## Formatting Details
+
+We use [yapf](https://github.com/google/yapf) to automatically format code. Our configuration is in the `[yapf]` section of `setup.cfg`.
+
+?> Tip- Many editors can use yapf as a plugin to automatically format code as you type.
+
+## Testing Details
+
+Our tests can be found in `lib/python/qmk/tests/`. You will find both unit and integration tests in this directory. We hope you will write both unit and integration tests for your code, but if you do not please favor integration tests. 
+
+If your PR does not include a comprehensive set of tests please add comments like this to your code so that other people know where they can help:
+
+    # TODO(unassigned/<yourGithubUsername>): Write <unit|integration> tests
+
+We use [nose2](https://nose2.readthedocs.io/en/latest/getting_started.html) to run our tests. You can refer to the nose2 documentation for more details on what you can do in your test functions.
+
+## Linting Details
+
+We use flake8 to lint our code. Your code should pass flake8 before you open a PR. This will be checked when you run `qmk pytest` and by CI when you submit a PR.

docs/coding_conventions_c.md

@@ -14,7 +14,7 @@ Most of our style is pretty easy to pick up on, but right now it's not entirely
   * Think of them as a story describing the feature
   * Use them liberally to explain why particular decisions were made.
   * Do not write obvious comments
-  * If you not sure if a comment is obvious, go ahead and include it.
+  * If you're not sure if a comment is obvious, go ahead and include it.
 * In general we don't wrap lines, they can be as long as needed. If you do choose to wrap lines please do not wrap any wider than 76 columns.
 * We use `#pragma once` at the start of header files rather than old-style include guards (`#ifndef THIS_FILE_H`, `#define THIS_FILE_H`, ..., `#endif`)
 * We accept both forms of preprocessor if's: `#ifdef DEFINED` and `#if defined(DEFINED)`

docs/coding_conventions_python.md

@@ -8,7 +8,7 @@ Most of our style follows PEP8 with some local modifications to make things less
   * Think of them as a story describing the feature
   * Use them liberally to explain why particular decisions were made.
   * Do not write obvious comments
-  * If you not sure if a comment is obvious, go ahead and include it.
+  * If you're not sure if a comment is obvious, go ahead and include it.
 * We require useful docstrings for all functions.
 * In general we don't wrap lines, they can be as long as needed. If you do choose to wrap lines please do not wrap any wider than 76 columns.
 * Some of our practices conflict with the wider python community to make our codebase more approachable to non-pythonistas.

docs/compatible_microcontrollers.md

@@ -1,25 +1,36 @@
-# Atmel AVR
+# Compatible Microcontrollers
 
-QMK should run on any Atmel AVR processor with enough Flash. It has been tested on the following:
+QMK runs on any USB-capable AVR or ARM microcontroller with enough flash space - generally 32kB or more, though it will *just* squeeze into 16kB with most features disabled.
 
-* ATmega32U4 ([PJRC Teensy 2.0](http://www.pjrc.com/teensy/))
-* AT90USB1286 ([PJRC Teensy++ 2.0](http://www.pjrc.com/teensy/))
-* AT90USB1287 ([Atmel USBKEY](http://www.atmel.com/tools/AT90USBKEY.aspx))
-* ATmega168P with using [V-USB](http://www.obdev.at/products/vusb/index.html)
-* ATmega328P with using [V-USB](http://www.obdev.at/products/vusb/index.html)
-* ATmega32U2
-* AT90USB1286, 646, 647 should work
-* AT90USB162 testing...
+## Atmel AVR
 
-NOTE: To enable full features of firmware you'll need 32KB flash size.
+The following use [LUFA](https://www.fourwalledcubicle.com/LUFA.php) as the USB stack:
 
-Please add any tested microcontrollers to this list.
+* [ATmega16U2](https://www.microchip.com/wwwproducts/en/ATmega16U2) / [ATmega32U2](https://www.microchip.com/wwwproducts/en/ATmega32U2)
+* [ATmega16U4](https://www.microchip.com/wwwproducts/en/ATmega16U4) / [ATmega32U4](https://www.microchip.com/wwwproducts/en/ATmega32U4)
+* [AT90USB64](https://www.microchip.com/wwwproducts/en/AT90USB646) / [AT90USB128](https://www.microchip.com/wwwproducts/en/AT90USB1286)
 
-# ARM
+Certain MCUs which do not have native USB will use [V-USB](https://www.obdev.at/products/vusb/index.html) instead:
 
-You can also use any ARM processor that [ChibiOS](http://www.chibios.org) supports. The following processors have been tested:
+* [ATmega32A](https://www.microchip.com/wwwproducts/en/ATmega32A)
+* [ATmega328P](https://www.microchip.com/wwwproducts/en/ATmega328P)
 
-* [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)
+## ARM
+
+You can also use any ARM chip with USB that [ChibiOS](http://www.chibios.org) supports. Most have plenty of flash. Known to work are:
+
+### STMicroelectronics (STM32)
+
+ * [STM32F0x2](https://www.st.com/en/microcontrollers-microprocessors/stm32f0x2.html)
+ * [STM32F103](https://www.st.com/en/microcontrollers-microprocessors/stm32f103.html)
+ * [STM32F303](https://www.st.com/en/microcontrollers-microprocessors/stm32f303.html)
+
+### NXP (Kinetis)
+
+ * [MKL26Z64](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/general-purpose-mcus/kl-series-cortex-m0-plus/kinetis-kl2x-72-96-mhz-usb-ultra-low-power-microcontrollers-mcus-based-on-arm-cortex-m0-plus-core:KL2x)
+ * [MK20DX128](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/general-purpose-mcus/k-series-cortex-m4/k2x-usb/kinetis-k20-50-mhz-full-speed-usb-mixed-signal-integration-microcontrollers-based-on-arm-cortex-m4-core:K20_50)
+ * [MK20DX256](https://www.nxp.com/products/processors-and-microcontrollers/arm-microcontrollers/general-purpose-mcus/k-series-cortex-m4/k2x-usb/kinetis-k20-72-mhz-full-speed-usb-mixed-signal-integration-microcontrollers-mcus-based-on-arm-cortex-m4-core:K20_72)
+
+## Atmel ATSAM
+
+There is limited support for one of Atmel's ATSAM microcontrollers, that being the [ATSAMD51J18A](https://www.microchip.com/wwwproducts/en/ATSAMD51J18A) used by the [Massdrop keyboards](https://github.com/qmk/qmk_firmware/tree/master/keyboards/massdrop).

docs/config_options.md

@@ -196,8 +196,8 @@ If you define these options you will enable the associated feature, which may in
   * 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)
+* `#define RGBW`
+  * Enables RGBW LED support
 
 ## Mouse Key Options
 
@@ -287,8 +287,27 @@ This is a [make](https://www.gnu.org/software/make/manual/make.html) file that i
   * Defines which format (bin, hex) is copied to the root `qmk_firmware` folder after building.
 * `SRC`
   * Used to add files to the compilation/linking list.
+* `LIB_SRC`
+  * Used to add files as a library to the compilation/linking list.  
+    The files specified by `LIB_SRC` is linked after the files specified by `SRC`.  
+    For example, if you specify:
+    ```
+    SRC += a.c
+    LIB_SRC += lib_b.c
+    SRC += c.c
+    LIB_SRC += lib_d.c
+    ```
+    The link order is as follows.
+    ```
+     ...  a.o c.o  ...  lib_b.a lib_d.a  ...
+    ```
 * `LAYOUTS`
   * A list of [layouts](feature_layouts.md) this keyboard supports.
+* `LINK_TIME_OPTIMIZATION_ENABLE`
+  * Enables Link Time Optimization (`LTO`) when compiling the keyboard.  This makes the process take longer, but can significantly reduce the compiled size (and since the firmware is small, the added time is not noticeable).  However, this will automatically disable the old Macros and Functions features automatically, as these break when `LTO` is enabled.
+  It does this by automatically defining `NO_ACTION_MACRO` and `NO_ACTION_FUNCTION`
+* `LTO_ENABLE`
+  * It has the same meaning as LINK_TIME_OPTIMIZATION_ENABLE.  You can use `LTO_ENABLE` instead of `LINK_TIME_OPTIMIZATION_ENABLE`.
 
 ## AVR MCU Options
 * `MCU = atmega32u4`
@@ -347,8 +366,6 @@ Use these to enable or disable building certain features. The more you have enab
   * Forces the keyboard to wait for a USB connection to be established before it starts up
 * `NO_USB_STARTUP_CHECK`
   * Disables usb suspend check after keyboard startup. Usually the keyboard waits for the host to wake it up before any tasks are performed. This is useful for split keyboards as one half will not get a wakeup call but must send commands to the master.
-* `LINK_TIME_OPTIMIZATION_ENABLE`
-  = Enables Link Time Optimization (`LTO`) when compiling the keyboard.  This makes the process take longer, but can significantly reduce the compiled size (and since the firmware is small, the added time is not noticable).  However, this will automatically disable the old Macros and Functions features automatically, as these break when `LTO` is enabled.  It does this by automatically defining `NO_ACTION_MACRO` and `NO_ACTION_FUNCTION`
 
 ## USB Endpoint Limitations
 

docs/contributing.md

@@ -85,7 +85,7 @@ Limited experimentation on the devices I have available shows that 7 is high eno
 
 Documentation is one of the easiest ways to get started contributing to QMK. Finding places where the documentation is wrong or incomplete and fixing those is easy! We also very badly need someone to edit our documentation, so if you have editing skills but aren't sure where or how to jump in please [reach out for help](#where-can-i-go-for-help)!
 
-You'll find all our documentation in the `qmk_firmware/docs` directory, or if you'd rather use a web based workflow you can click "Suggest An Edit" at the top of each page on http://docs.qmk.fm/.
+You'll find all our documentation in the `qmk_firmware/docs` directory, or if you'd rather use a web based workflow you can click the "Edit this page" link at the bottom of each page on https://docs.qmk.fm/.
 
 When providing code examples in your documentation, try to observe naming conventions used elsewhere in the docs. For example, standardizing enums as `my_layers` or `my_keycodes` for consistency:
 
@@ -101,6 +101,18 @@ enum my_keycodes {
 };
 ```
 
+### Previewing the Documentation
+
+Before opening a pull request, you can preview your changes if you have set up the development environment by running this command from the `qmk_firmware/` folder:
+
+    ./bin/qmk docs
+
+or if you only have Python 3 installed:
+
+    python3 -m http.server 8936
+
+and navigating to `http://localhost:8936/`.
+
 ## Keymaps
 
 Most first-time QMK contributors start with their personal keymaps. We try to keep keymap standards pretty casual (keymaps, after all, reflect the personality of their creators) but we do ask that you follow these guidelines to make it easier for others to discover and learn from your keymap.

docs/custom_quantum_functions.md

@@ -90,68 +90,93 @@ keyrecord_t record {
 
 # LED Control
 
-QMK provides methods to read the 5 LEDs defined as part of the HID spec:
+QMK provides methods to read 5 of the LEDs defined in the HID spec:
 
-* `USB_LED_NUM_LOCK`
-* `USB_LED_CAPS_LOCK`
-* `USB_LED_SCROLL_LOCK`
-* `USB_LED_COMPOSE`
-* `USB_LED_KANA`
+* Num Lock
+* Caps Lock
+* Scroll Lock
+* Compose
+* Kana
 
-These five constants correspond to the positional bits of the host LED state.
-There are two ways to get the host LED state:
+There are two ways to get the lock LED state:
 
-* by implementing `led_set_user()`
-* by calling `host_keyboard_leds()`
+* by implementing `bool led_update_kb(led_t led_state)` or `_user(led_t led_state)`; or
+* by calling `led_t host_keyboard_led_state()`
 
-## `led_set_user()`
+!> `host_keyboard_led_state()` may already reflect a new value before `led_update_user()` is called.
 
-This function will be called when the state of one of those 5 LEDs changes. It receives the LED state as a parameter.
-Use the `IS_LED_ON(usb_led, led_name)` and `IS_LED_OFF(usb_led, led_name)` macros to check the LED status.
+Two more deprecated functions exist that provide the LED state as a `uint8_t`:
 
-!> `host_keyboard_leds()` may already reflect a new value before `led_set_user()` is called.
+* `uint8_t led_set_kb(uint8_t usb_led)` and `_user(uint8_t usb_led)`
+* `uint8_t host_keyboard_leds()`
 
-### Example `led_set_user()` Implementation
+## `led_update_user()`
+
+This function will be called when the state of one of those 5 LEDs changes. It receives the LED state as a struct parameter.
+
+By convention, return `true` from `led_update_user()` to get the `led_update_kb()` hook to run its code, and
+return `false` when you would prefer not to run the code in `led_update_kb()`.
+
+Some examples include:
+
+  - overriding the LEDs to use them for something else like layer indication
+    - return `false` because you do not want the `_kb()` function to run, as it would override your layer behavior.
+  - play a sound when an LED turns on or off.
+    - return `true` because you want the `_kb` function to run, and this is in addition to the default LED behavior.
+
+?> Because the `led_set_*` functions return `void` instead of `bool`, they do not allow for overriding the keyboard LED control, and thus it's recommended to use `led_update_*` instead.
+
+### Example `led_update_kb()` Implementation
 
 ```c
-void led_set_user(uint8_t usb_led) {
-    if (IS_LED_ON(usb_led, USB_LED_NUM_LOCK)) {
-        writePinLow(B0);
-    } else {
-        writePinHigh(B0);
-    }
-    if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK)) {
-        writePinLow(B1);
-    } else {
-        writePinHigh(B1);
-    }
-    if (IS_LED_ON(usb_led, USB_LED_SCROLL_LOCK)) {
-        writePinLow(B2);
-    } else {
-        writePinHigh(B2);
-    }
-    if (IS_LED_ON(usb_led, USB_LED_COMPOSE)) {
-        writePinLow(B3);
-    } else {
-        writePinHigh(B3);
-    }
-    if (IS_LED_ON(usb_led, USB_LED_KANA)) {
-        writePinLow(B4);
-    } else {
-        writePinHigh(B4);
+bool led_update_kb(led_t led_state) {
+    bool res = led_update_user(led_state);
+    if(res) {
+        // writePin sets the pin high for 1 and low for 0.
+        // In this example the pins are inverted, setting
+        // it low/0 turns it on, and high/1 turns the LED off.
+        // This behavior depends on whether the LED is between the pin
+        // and VCC or the pin and GND.
+        writePin(B0, !led_state.num_lock);
+        writePin(B1, !led_state.caps_lock);
+        writePin(B2, !led_state.scroll_lock);
+        writePin(B3, !led_state.compose);
+        writePin(B4, !led_state.kana);
     }
+    return res;
 }
 ```
 
-### `led_set_*` Function Documentation
+### Example `led_update_user()` Implementation
 
-* Keyboard/Revision: `void led_set_kb(uint8_t usb_led)`
-* Keymap: `void led_set_user(uint8_t usb_led)`
+This incomplete example would play a sound if Caps Lock is turned on or off. It returns `true`, because you also want the LEDs to maintain their state.
 
-## `host_keyboard_leds()`
+```c
+#ifdef AUDIO_ENABLE
+  float caps_on[][2] = SONG(CAPS_LOCK_ON_SOUND);
+  float caps_off[][2] = SONG(CAPS_LOCK_OFF_SOUND);
+#endif
 
-Call this function to get the last received LED state. This is useful for reading the LED state outside `led_set_*`, e.g. in [`matrix_scan_user()`](#matrix-scanning-code).
-For convenience, you can use the `IS_HOST_LED_ON(led_name)` and `IS_HOST_LED_OFF(led_name)` macros instead of calling and checking `host_keyboard_leds()` directly.
+bool led_update_user(led_t led_state) {
+    #ifdef AUDIO_ENABLE
+    static uint8_t caps_state = 0;
+    if (caps_state != led_state.caps_lock) {
+        led_state.caps_lock ? PLAY_SONG(caps_on) : PLAY_SONG(caps_off);
+        caps_state = led_state.caps_lock;
+    }
+    #endif
+    return true;
+}
+```
+
+### `led_update_*` Function Documentation
+
+* Keyboard/Revision: `bool led_update_kb(led_t led_state)`
+* Keymap: `bool led_update_user(led_t led_state)`
+
+## `host_keyboard_led_state()`
+
+Call this function to get the last received LED state as a `led_t`. This is useful for reading the LED state outside `led_update_*`, e.g. in [`matrix_scan_user()`](#matrix-scanning-code).
 
 ## Setting Physical LED State
 
@@ -369,7 +394,7 @@ void keyboard_post_init_user(void) {
   // Set default layer, if enabled
   if (user_config.rgb_layer_change) {
     rgblight_enable_noeeprom();
-    rgblight_sethsv_noeeprom_cyan(); 
+    rgblight_sethsv_noeeprom_cyan();
     rgblight_mode_noeeprom(1);
   }
 }
@@ -417,18 +442,18 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         }
         return true; // Let QMK send the enter press/release events
     case RGB_LYR:  // This allows me to use underglow as layer indication, or as normal
-        if (record->event.pressed) { 
+        if (record->event.pressed) {
             user_config.rgb_layer_change ^= 1; // Toggles the status
             eeconfig_update_user(user_config.raw); // Writes the new status to EEPROM
-            if (user_config.rgb_layer_change) { // if layer state indication is enabled, 
+            if (user_config.rgb_layer_change) { // if layer state indication is enabled,
                 layer_state_set(layer_state);   // then immediately update the layer color
             }
         }
         return false; break;
     case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // For any of the RGB codes (see quantum_keycodes.h, L400 for reference)
         if (record->event.pressed) { //This disables layer indication, as it's assumed that if you're changing this ... you want that disabled
-            if (user_config.rgb_layer_change) {        // only if this is enabled 
-                user_config.rgb_layer_change = false;  // disable it, and 
+            if (user_config.rgb_layer_change) {        // only if this is enabled
+                user_config.rgb_layer_change = false;  // disable it, and
                 eeconfig_update_user(user_config.raw); // write the setings to EEPROM
             }
         }
@@ -441,7 +466,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 And lastly, you want to add the `eeconfig_init_user` function, so that when the EEPROM is reset, you can specify default values, and even custom actions. To force an EEPROM reset, use the `EEP_RST` keycode or [Bootmagic](feature_bootmagic.md) functionallity. For example, if you want to set rgb layer indication by default, and save the default valued. 
 
 ```c
-void eeconfig_init_user(void) {  // EEPROM is getting reset! 
+void eeconfig_init_user(void) {  // EEPROM is getting reset!
   user_config.raw = 0;
   user_config.rgb_layer_change = true; // We want this enabled by default
   eeconfig_update_user(user_config.raw); // Write default value to EEPROM now
@@ -466,7 +491,7 @@ The `val` is the value of the data that you want to write to EEPROM.  And the `e
 
 By default, the tapping term is defined globally, and is not configurable by key.  For most users, this is perfectly fine.  But in come cases, dual function keys would be greatly improved by different timeouts than `LT` keys, or because some keys may be easier to hold than others.  Instead of using custom key codes for each, this allows for per key configurable `TAPPING_TERM`.
 
-To enable this functionality, you need to add `#define TAPPING_TERM_PER_KEY` to your `config.h`, first.  
+To enable this functionality, you need to add `#define TAPPING_TERM_PER_KEY` to your `config.h`, first. 
 
 
 ## Example `get_tapping_term` Implementation

docs/de/README.md

@@ -0,0 +1,33 @@
+# Quantum Mechanical Keyboard Firmware
+
+[![Aktuelle Version](https://img.shields.io/github/tag/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/tags)
+[![Build Status](https://travis-ci.org/qmk/qmk_firmware.svg?branch=master)](https://travis-ci.org/qmk/qmk_firmware)
+[![Discord](https://img.shields.io/discord/440868230475677696.svg)](https://discord.gg/Uq7gcHh)
+[![Docs Status](https://img.shields.io/badge/docs-ready-orange.svg)](https://docs.qmk.fm)
+[![GitHub contributors](https://img.shields.io/github/contributors/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/pulse/monthly)
+[![GitHub forks](https://img.shields.io/github/forks/qmk/qmk_firmware.svg?style=social&label=Fork)](https://github.com/qmk/qmk_firmware/)
+
+## Was ist QMK Firmware?
+
+QMK (*Quantum Mechanical Keyboard*) ist eine Open-Source-Community, welche die QMK-Firmware, die QMK-Toolbox, [qmk.fm](https://qmk.fm) und diese Dokumententation betreut. QMK-Firmware ist eine Weiterentwicklung der [tmk\_keyboard](http://github.com/tmk/tmk_keyboard)-Tastatur-Firmware mit vielen nützlichen Zusatzfunktionen für Atmel AVR-Prozessoren. Ursprünglich wurde sie für Produkte von [OLKB](http://olkb.com), das [ErgoDox EZ](http://www.ergodox-ez.com) und das [Clueboard](http://clueboard.co/) entwickelt. Im Laufe der Zeit wurde sie mit Hilfe von [ChibiOS](http://chibios.org) auch für die ARM-Architektur angepasst. Außerdem ist es inzwischen möglich, auch handverdrahtete Tastaturen und selbst geätzte PCBs mit QMK zu verwenden.
+
+## Bezugsquelle für QMK
+
+Wenn Du vorhast, deine Tastatur, Tastaturbelegung oder Features zu QMK beizusteuern, geht das am einfachsten, indem Du das [Repository auf Github](https://github.com/qmk/qmk_firmware#fork-destination-box) forkst, die Änderungen in deinem lokalen Repo vornimmst und anschließend einen [Pull Request](https://github.com/qmk/qmk_firmware/pulls) einreichst.
+
+Ansonsten kannst Du es als [zip](https://github.com/qmk/qmk_firmware/zipball/master) oder [tar](https://github.com/qmk/qmk_firmware/tarball/master) herunterladen, oder es direkt via git klonen (`git clone git@github.com:qmk/qmk_firmware.git` bzw. `git clone https://github.com/qmk/qmk_firmware.git`).
+
+
+## Anleitung fürs Kompilieren
+
+Bevor Du in der Lage bist, die Firmware zu kompilieren, musst Du eine [Entwicklungsumgebung](de/getting_started_build_tools.md) für AVR und/oder ARM aufsetzen. Danach kannst Du mit dem `make` Befehl eine Keymap für deine Tastatur erzeugen. Die Notation dafür ist:
+
+    make planck/rev4:default
+
+Dies generiert die Revision `rev4` für eine Tastatur vom Type `planck` mit der `default` Tastaturbelegung. Nicht alle Tastaturen haben Revisionen (auch bekannt als Subprojekt oder Unterordner) weswegen dies auch ausgelassen werden kann:
+
+    make preonic:default
+
+## Möglichkeiten der Anpassung
+
+QMK hat viele [Features](de/features.md), die es zu entdecken gibt. In der [Dokumentation](https://docs.qmk.fmk) kannst Du Dir einen Überblick verschaffen. Die meisten Features basieren darauf, die [Tastaturbelegung](de/keymap.md) anzupassen und das Verhalten der [Keycodes](de/keycodes.md) zu verändern.

docs/de/_summary.md

@@ -0,0 +1,121 @@
+* [Anleitung für Anfänger](de/newbs.md)
+  * [Erste Schritte](de/newbs_getting_started.md)
+  * [Die erste Firmware](de/newbs_building_firmware.md)
+  * [Firmware flashen](de/newbs_flashing.md)
+  * [Testen und Debuggen](de/newbs_testing_debugging.md)
+  * [Git Tips und Tricks](de/newbs_best_practices.md)
+  * [Hilfreiche Ressourcen](de/newbs_learn_more_resources.md)
+
+* [QMK Basics](de/README.md)
+  * [QMK Einführung](de/getting_started_introduction.md)
+  * [QMK CLI](de/cli.md)
+  * [QMK CLI Konfiguration](de/cli_configuration.md)
+  * [Zu QMK beitragen](de/contributing.md)
+  * [Anleitung für Github](de/getting_started_github.md)
+  * [Nach Hilfe fragen](de/getting_started_getting_help.md)
+
+* [Breaking Changes](de/breaking_changes.md)
+  * [2019 Aug 30](de/ChangeLog/20190830.md)
+
+* [FAQ](de/faq.md)
+  * [Häufige Fragen](de/faq_general.md)
+  * [Build/Kompilieren](de/faq_build.md)
+  * [Debugging/Troubleshooting](de/faq_debug.md)
+  * [Keymap](de/faq_keymap.md)
+  * [Treiber Installation mit Zadig](de/driver_installation_zadig.md)
+
+* Detailierte Guides
+  * [Build Tools installieren](de/getting_started_build_tools.md)
+  * [Vagrant Guide](de/getting_started_vagrant.md)
+  * [Build/Compile Anleitung](de/getting_started_make_guide.md)
+  * [Firmware flashen](de/flashing.md)
+  * [Funktionalität anpassen](de/custom_quantum_functions.md)
+  * [Keymap Überblick](de/keymap.md)
+
+* [Hardware](de/hardware.md)
+  * [AVR Prozessoren](de/hardware_avr.md)
+  * [Treiber](de/hardware_drivers.md)
+
+* Referenz
+  * [Tastatur Richtlinien](de/hardware_keyboard_guidelines.md)
+  * [Konfigurations Optionen](de/config_options.md)
+  * [Keycodes](de/keycodes.md)
+  * [Coding Konventionen - C](de/coding_conventions_c.md)
+  * [Coding Konventionen - Python](de/coding_conventions_python.md)
+  * [Dokumentations Best Practices](de/documentation_best_practices.md)
+  * [Dokumentations Templates](de/documentation_templates.md)
+  * [Glossar](de/reference_glossary.md)
+  * [Unit Testing](de/unit_testing.md)
+  * [Nützliche Funktionen](de/ref_functions.md)
+  * [Configurator Support](de/reference_configurator_support.md)
+  * [info.json Format](de/reference_info_json.md)
+  * [Python CLI Development](de/cli_development.md)
+
+* [Features](de/features.md)
+  * [Basic Keycodes](de/keycodes_basic.md)
+  * [US ANSI Shifted Keys](de/keycodes_us_ansi_shifted.md)
+  * [Quantum Keycodes](de/quantum_keycodes.md)
+  * [Advanced Keycodes](de/feature_advanced_keycodes.md)
+  * [Audio](de/feature_audio.md)
+  * [Auto Shift](de/feature_auto_shift.md)
+  * [Backlight](de/feature_backlight.md)
+  * [Bluetooth](de/feature_bluetooth.md)
+  * [Bootmagic](de/feature_bootmagic.md)
+  * [Combos](de/feature_combo.md)
+  * [Command](de/feature_command.md)
+  * [Debounce API](de/feature_debounce_type.md)
+  * [DIP Switch](de/feature_dip_switch.md)
+  * [Dynamic Macros](de/feature_dynamic_macros.md)
+  * [Encoders](de/feature_encoders.md)
+  * [Grave Escape](de/feature_grave_esc.md)
+  * [Haptic Feedback](de/feature_haptic_feedback.md)
+  * [HD44780 LCD Controller](de/feature_hd44780.md)
+  * [Key Lock](de/feature_key_lock.md)
+  * [Layouts](de/feature_layouts.md)
+  * [Leader Key](de/feature_leader_key.md)
+  * [LED Matrix](de/feature_led_matrix.md)
+  * [Macros](de/feature_macros.md)
+  * [Mouse Keys](de/feature_mouse_keys.md)
+  * [OLED Driver](de/feature_oled_driver.md)
+  * [One Shot Keys](de/feature_advanced_keycodes.md#one-shot-keys)
+  * [Pointing Device](de/feature_pointing_device.md)
+  * [PS/2 Mouse](de/feature_ps2_mouse.md)
+  * [RGB Lighting](de/feature_rgblight.md)
+  * [RGB Matrix](de/feature_rgb_matrix.md)
+  * [Space Cadet](de/feature_space_cadet.md)
+  * [Split Keyboard](de/feature_split_keyboard.md)
+  * [Stenography](de/feature_stenography.md)
+  * [Swap Hands](de/feature_swap_hands.md)
+  * [Tap Dance](de/feature_tap_dance.md)
+  * [Terminal](de/feature_terminal.md)
+  * [Thermal Printer](de/feature_thermal_printer.md)
+  * [Unicode](de/feature_unicode.md)
+  * [Userspace](de/feature_userspace.md)
+  * [Velocikey](de/feature_velocikey.md)
+
+* Für Maker und Modder
+  * [Hand Wiring Guide](de/hand_wire.md)
+  * [ISP Flashing Guide](de/isp_flashing_guide.md)
+  * [ARM Debugging Guide](de/arm_debugging.md)
+  * [I2C Driver](de/i2c_driver.md)
+  * [GPIO Controls](de/internals_gpio_control.md)
+  * [Proton C Conversion](de/proton_c_conversion.md)
+
+* Für ein tieferes Verständnis
+  * [Wie Tastaturen funktionieren](de/how_keyboards_work.md)
+  * [QMK verstehen](de/understanding_qmk.md)
+
+* Andere Themen
+  * [Eclipse mit QMK](de/other_eclipse.md)
+  * [VSCode mit QMK](de/other_vscode.md)
+  * [Support](de/support.md)
+  * [Übersetzungen](de/translating.md)
+
+* QMK Internals (In Progress)
+  * [Defines](de/internals_defines.md)
+  * [Input Callback Reg](de/internals_input_callback_reg.md)
+  * [Midi Device](de/internals_midi_device.md)
+  * [Midi Device Setup Process](de/internals_midi_device_setup_process.md)
+  * [Midi Util](de/internals_midi_util.md)
+  * [Send Functions](de/internals_send_functions.md)
+  * [Sysex Tools](de/internals_sysex_tools.md)

docs/de/driver_installation_zadig.md

@@ -0,0 +1,47 @@
+# Bootloader Treiber Installation mit Zadig
+
+QMK erscheint für den Host als normales HID Eingabegerät und benötigt deshalb keine zusätzlichen Treiber. Der Bootloader, den Du für das Flashen der Firmware benötigst, jedoch meistens schon.
+
+Hierzu gibt es zwei Ausnahmen: den Caterina Bootloader, meistens auf Pro Micros, sowie den HalfKay Bootloader auf PJRC Teensys. Diese erscheinen als serieller Port und als generisches HID Gerät und benötigen keine Treiber.
+
+Wir empfehlen deshalb [Zadig](https://zadig.akeo.ie/). Wenn Du die Entwicklungsumgebung mit MSYS2 oder WSL installiert hast, wird dich dass `qmk_install.sh` Skript gefragt haben, ob es die Treiber für dich installieren sollte.
+
+## Installation
+
+Versetze deine Tastatur in den Bootloader-Modus, entweder durch Betätigung des physischen `RESET` Schalters - meist auf der Unterseite der Platine - oder durch das Auslösen des Key-Codes `RESET` bzw. `KC_RESET` (sollte in der zur Tastatur gehörigen `keycode.c` zu entnehmen sein). Sollte deine Tastatur weder noch besitzen, versuche es damit die `Escape`-Taste oder `Leertaste + B` zu halten während Du die Tastatur mit dem PC verbindest (Siehe auch [Bootmagic](de/feature_bootmagic.md) für weitere Details). Ein paar Tastaturen benutzen das [Command](de/feature_command.md)-Feature an Stelle von Bootmagic; in diesem Fall kannst du mit den Tastenkombinationen `linkes Shift + rechtes Shift + B` oder `linkes Shift + rechtes Shift + Escape` zu jeder Zeit in den Bootloader wechseln solange die Tastatur verbunden ist.
+
+Eingie Tastaturen haben u.U. spezielle Anweisungen um in den Bootloader-Modus zu gelangen. Zum Beispiel kann die [Bootmagic-Lite](de/feature_bootmagic.md#bootmagic-lite)-Taste (default: Escape) auf eine andere Taste gemappt sein; oder die magische Kombination (default: linkes Shift+rechtes Shift) verwendet anstatt Shift die STRG-Tasten. Die zur Tastatur gehörige README sollte dir Aufschluss darüber geben wie der Bootloader-Modus ausgelöst werden kann wenn Du unsicher bist.
+
+Um ein Gerät mit USBaspLoader in den Bootloader-Modus zu versetzen, halte `BOOT` gedrückt während Du den `RESET`-Knopf drückst.
+Alternativ, halte `BOOT` gedrückt während Du das USB-Kabel einsteckst.
+
+Zadig sollte das Bootloader-Gerät automatisch erkennen. Manchmal musst Du zusätzlich noch **Options → List All Devices** auswählen.
+
+ - Tastaturen mit Atmel AVR MCUs sollten als `ATm32U4DFU` (oder ähnlich) angezeigt werden, mit der Vendor ID `03EB`.
+ - USBasp werden als `USBasp` angezeigt, mit VID/PID `16C0:05DC`.
+ - Tastaturen AVR controller und dem QMK-DFU Bootloader haben den namen `<Tastatur Name> Bootloader` und die VID `03EB`.
+ - Die meisten ARM Tastaturen werden als `STM32 BOOTLOADER` angezeigt, mit VID/PID `0483:DF11`.
+
+!> Sollte Zadig ein oder mehrere Geräte mit `HidUsb`-Treiber anzeigen, dann ist deine Tastatur wahrscheinlich nicht im Bootloader-Modus. Der Pfeil wird orange eingefärbt sein und Du wirst nach einer Bestätigung gefragt um Veränderungen am System vorzunehmen. In diesem Fall **fahre nicht fort**!
+
+Wenn der Pfeil grün angezeigt wird, wähle den Treiber aus und klicke auf **Treiber installieren**. Der  `libusb-win32`-Treiber sollte gewöhnlich für AVR verwendet werden und `WinUSB` für ARM. Sollte es danach noch nicht möglich sein die Tastatur zu flashen, versuche es mit einem anderen Treiber. Für USBaspLoader Geräte, die über die Befehlszeile mit MSYS2 geflasht werden, wird der `libusbk`-Treiber empfohlen. Ansonsten sollte `libusb-win32` funktionieren wenn die QMK Toolbox verwendet wird.
+
+![Zadig mit Bootloader-Treiber korrekt installiert](https://i.imgur.com/b8VgXzx.png)
+
+Entferne nun deine Tastatur und verbinde sie erneut um sicherzugehen dass der neue Treiber erfolgreich installiert wurde. Wenn Du QMK Toolbox benutzt, starte die Anwendung zur Sicherheit einmal neu, da Veränderungen am Treiber manchmal nicht richtig erkannt werden. Wenn dies immer noch nicht erfolgreich war hilft es an dieser Stelle manchmal ein Neustart des Computers.
+
+## Wiederherstellung einer Installation für ein falsches Gerät
+
+Wenn Du feststellst dass Du anschließend auf deiner Tastatur nicht mehr tippen kannst, ist etwas bei der Installation schief gelaufen. Ein häufiger Fehler ist es dass die Tastatur nicht im Bootloader-Modus war und stattdessen der Treiber für das HID-Gerät ersetzt wurde. Dies kannst Du einfach mit Zadig überprüfen, eine funktionierende Tastatur verwendet als Treiber `HidUsb` auf allen Interfaces .
+
+![Eine funktionierende Tastatur aus Zadigs Sicht](https://i.imgur.com/Hx0E5kC.png)
+
+Öffne den Geräte-Manager und suche nach einem Gerät das wie deine Tastatur aussieht.
+
+![Die Tastatur mit dem falschen Treiber installiert, im Geräte-Manager](https://i.imgur.com/L3wvX8f.png)
+
+Rechtsklick und **Gerät deinstallieren** anklicken. Bitte gehe sicher dass in diesem Schritt auch **Treibersoftware für dieses Gerät löschen** markiert ist.
+
+![Der "Gerät deinstallieren"-Dialog, mit "Treibersoftware für dieses Gerät entfernen" markiert](https://i.imgur.com/aEs2RuA.png)
+
+Klick **Aktion → Suche nach veränderter Hardware**. Nun solltest Du wieder in der Lage sein normal zu tippen. Vergewissere dich mit Hilfe von Zadig dass die Tastatur nun `HidUsb` als Treiber verwendet. Wenn dies der Fall ist sollte wieder alles funktionieren.

docs/de/newbs.md

@@ -0,0 +1,22 @@
+# Anleitung für absolute Beginner
+QMK ist eine mächtige Open Source Firmware für mechanische Tastaturen. Mit QMK kannst Du deine Tastatur sowohl sehr einfach als auch sehr umfangreich anpassen. Menschen unterschiedlichen Wissensstandes - vom kompletten Anfänger bis zum erfahrenen Programmierer - haben ihre Tastaturen mit QMK erfolgreich auf ihre persönlichen Bedürfnisse angepasst. Diese Anleitung soll Dir unabhängig von deinen Vorkenntnissen dabei helfen dies ebenfalls zu bewältigen.
+
+Bist Du unsicher ob deine Tastatur QMK unterstützt? Wenn es eine mechanische Tastatur ist, die Du selbst gebaut hast, stehen deine Chancen gut. Wir unterstützen eine [Vielzahl](https://qmk.fm/keyboards/) selbst gebauter Tastaturen, sodass selbst wenn deine jetzige Tastatur nicht unterstützt wird Du keine Probleme haben solltest eine für deine Anforderungen zu finden.
+
+## Übersicht
+
+Diese Anleitung ist in 7 Abschnitte unterteilt:
+
+* [Die ersten Schritte](newbs_getting_started.md)
+* [Die erste Firmware auf der Kommandozeile erzeugen](newbs_building_firmware.md)
+* [Die erste Firmware mit der Online GUI erzeugen](newbs_building_firmware_configurator.md)
+* [Firmware flashen](newbs_flashing.md)
+* [Testen und Debuggen](newbs_testing_debugging.md)
+* [Git Leitfaden](newbs_best_practices.md)
+* [Weitere hilfreiche Ressourcen für Anfänger](newbs_learn_more_resources.md)
+
+Diese Anleitung richtet sich an Personen, die vorher noch nie Software kompiliert haben. Die Entscheidungen und Empfehlungen basieren auf dieser Grundannahme. Es gibt unterschiedliche Herangehensweisen für viele der Prozeduren und wir unterstützen die meisten Alternativen. Wenn Du mal nicht weiter weißt oder Dir nicht sicher bist, wie Du an ein Problem herangehen sollst, kannst Du uns gerne [um Hilfe bitten](getting_started_getting_help.md).
+
+## Weitere Ressourcen
+
+* [Thomas Baart's QMK Basics Blog](https://thomasbaart.nl/category/mechanical-keyboards/firmware/qmk/qmk-basics/) – Ein äußerst hilfreicher Blog eines Community-Mitglieds, der einige Grundlagen der QMK-Firmware aus der Sicht des Benutzers erklärt (auf Englisch).

docs/de/newbs_building_firmware.md

@@ -0,0 +1,78 @@
+# Eine eigene Firmware erstellen 
+
+Nachdem Du nun eine funktionierende Entwicklungsumgebung aufgesetzt hast, bist Du nun bereit, deine eigene Firmware zu erstellen. Dieses Sektion des Guides wird zwischen drei Programmen hin- und herwechseln: deinem Dateimanager, deinem Texteditor und der Befehlszeile. Lasse diese drei Fenster geöffnet, bis Du fertig und zufrieden mit deiner Tastatur-Firmware bist.
+
+Solltest Du die Befehlszeile zwischenzeitlich geschlossen haben, vergiss nicht wieder in das richtige Verzeichnis zu navigieren, benutze dazu den Befehl `cd qmk_firmware`.
+
+## Navigiere in deinen Keymap Ordner
+
+Beginne damit, in das `keymaps` Verzeichnis für deine Tastatur zu navigieren.
+
+Wenn Du macOS oder Windows benutzt, kannst Du einfach in das keymaps Verzeichnis wechseln.
+
+?> macOS:<br>
+    open keyboards/<keyboard_folder>/keymaps
+
+?> Windows:<br>
+    start .\\keyboards\\<keyboard_folder>\\keymaps
+
+## Eine Kopie der `default`  Tastaturbelegung erstellen
+
+Wenn Du den `keymaps` Ordner geöffnet hast, solltest Du zuerst eine Kopie des `default` Verzeichnisses erstellen. Wir empfehlen dafür deinen GitHub Benutzernamen zu verweden, aber Du kannst auch jeden anderen Namen verwenden solange er nur aus Kleinbuchstaben, Zahlen und Unterstrichen besteht.
+
+Um den Prozess zu automatisieren kannst Du dazu auch das Skript `new_keymap.sh` verwenden.
+
+Navigiere dazu in das `qmk_firmware/util` Verzeichnis und gib folgenden Befehl ein:
+
+```
+./new_keymap.sh <keyboard path> <username>
+```
+
+Um zum Beispiel den Benutzernamen John für die Tastaturbelegung eines 1up60hse zu verwenden, würdest Du Folgendes eingeben:
+
+```
+./new_keymap.sh 1upkeyboards/1up60hse john
+```
+
+## Öffne `keymap.c` in deinem bevorzugtem Text Editor
+
+Öffne deine `keymap.c`. In dieser Datei findest Du die Strukturen, die das Verhalten deiner Tastatur bestimmen. Oben in der `keymap.c` befinden sich Definitionen (defines) und Aufzählungen (enums), die die Tastaturbelegung leserlicher machen sollen. Weiter unten wirst Du eine Zeile finden, die wie folgt aussieht:
+
+    const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+Diese Zeile markiert den Anfang der Liste der Ebenen (Layers). Darunter befinden sich Zeilen die entweder `LAYOUT` oder `KEYMAP` enthalten, das deutet auf den Start einer Ebene hin. Danach folgt eine Liste von Tasten, die dieser Ebene zugewiesen sind.
+
+!> Beim Bearbeiten einer Tastaturbelegung solltest Du darauf achten, keine Kommata hinzuzufügen oder zu entfernen. Ansonsten kann dies dazu führen, dass deine Firmware nicht mehr kompiliert und es ist nicht immer einfach festzustellen, wo genau ein Komma zuviel oder zu wenig ist. Die letzte Zeile hat am Ende kein Komma, die Zeilen davor jedoch schon.
+
+## Personalisiere die Tastaturbelegung nach deinen Wünschen
+
+Wie Du diesen Schritt abschließt ist vollkommen Dir überlassen. Ändere die eine Sache die Dich stört oder verändere alles von Grund auf. Du kannst Ebenen entfernen die Du nicht brauchst oder Neue hinzufügen, bis zu 32 Stück. Die folgende Dokumentation verrät Dir was Du hier alles definieren kannst: 
+
+* [Keycodes](de/keycodes.md)
+* [Features](de/features.md)
+* [FAQ](de/faq.md)
+
+?> Während Du langsam ein Gefühl dafür kriegst wie Keymaps funktionieren, solltest Du darauf achten nicht zuviel auf einmal zu verändern. Größere Änderungen machen es schwieriger, Probleme zu debuggen.
+
+## Deine Firmware erzeugen
+
+Wenn Du damit fertig bist, deine Tastaturbelegung anzupassen, musst Du noch die Firmware erzeugen. Öffne dazu wieder die Befehlszeile und führe folgenden Befehl aus:
+
+    make <my_keyboard>:<my_keymap>
+
+Wenn deine Tastaturbelegung z.B. "xyverz" heißt und Du die Belegung für ein rev5 planck erzeugen möchtest, lautet der Befehl:
+
+    make planck/rev5:xyverz
+
+Während des Kompiliervorgangs wird viel Text auf dem Bildschirm ausgegeben. Es sollte am Ende mit etwas enden das ungefähr so aussieht:
+
+```
+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
+```
+
+## Deine Firmware flashen
+Bitte fahre mit [Firmware flashen](de/newbs_flashing.md) fort, um zu erfahren, wie Du deine neue Firmware auf deine Tastatur flashen kannst.

docs/de/newbs_flashing.md

@@ -0,0 +1,369 @@
+# Deine Tastatur flashen
+
+Nachdem deine Firmware nun fertig ist musst Du Sie noch auf deine Tastatur flashen.
+
+## Flash-Vorgang mit QMK Toolbox
+
+Der einfachste Weg deine Tastatur zu flashen ist mit Hilfe der [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases)
+
+Leider ist die QMK Toolbox derzeit nur für Windows und macOS verfügbar. Wenn Du Linux benutzt (oder es vorziehst die Firmware mit der Kommandozeile zu flashen) solltest Du die Methode benutzen die [hier](de/newbs_flashing.md#tastatur-mit-der-befehlszeile-flashen) beschrieben wird.
+
+### Lade die Datei in QMK Toolbox
+
+Beginne damit die Datei in der QMK Toolbox Anwendung zu laden. Versichere dich dass Du die Firmware-Datei im Finder oder Explorer findest. Deine Tastatur-Firmware sollte entweder vom Typ `.hex` oder `.bin` sein sein. QMK sollte die für deine Tastatur entsprechende Datei automatisch in das Root-Verzeichnis (normalerweise `qmk_firmware`) kopieren.
+
+?> Wenn Du Windows oder macOS benutzt kannst Du mit folgenden Befehlen ganz einfach das aktuelle Firmware-Verzeichnis im Explorer oder Finder öffnen.
+
+#### Windows:
+
+``` start . ```
+
+#### macOS:
+
+``` open . ```
+
+Die Firmware-Dateien folgen dabei immer folgendem Schema:
+
+    <meine_Tastatur>_<meine_Tastaturbelegung>.{bin,hex}
+
+Zum Beispiel würde ein `planck/rev5` mit der `default` Tastaturbelegung folgenden Dateinamen haben:
+
+    planck_rev5_default.hex
+
+Wenn Du die Firmware-Datei gefunden hast kannst Du sie in das "Local file" ("Lokale Datei") Feld in der QMK Toolbox ziehen, alternativ kannst Du auf "Öffnen" klicken und in das Verzeichnis navigieren indem sich die Firmware-Datei befindet.
+
+### Die Tastatur in den DFU (Bootloader) Modus versetzen
+
+Um deine angepasste Firmware auf deine Tastatur zu flashen musst Du diese erst in einen speziellen "flashing"-Modus versetzen. Während die Tastatur in diesem Modus ist kannst Du nicht auf ihr tippen oder sie wie gewohnt als Tastatur benutzen. Es ist wichtig dass der flashing-Prozesses nicht unterbrochen oder die Tastatur ausstöpselst wird, da der Vorgang ansonst wiederholt werden muss.
+
+Verschiedene Tastaturen verwenden unterschiedliche Methoden um in den Bootloader-Modus zu gelangen. Wenn dein PCB im Moment QMK oder TMK verwendet und Du keine spezifischen Anweisungen erhalten hast probiere die folgenden Methoden in dieser Reihenfolge:
+
+* Halte beide Shift-Tasten und drücke `Pause`
+* Halte beide Shift-Tasten und drücke `B`
+* Entferne deine Tastatur vom Computer, drücke gleichzeitig `Leertaste` und `B`, verbinde die Tastatur wieder mit dem Computer und warte eine Sekunde bevor Du die Tasten wieder loslässt.
+* Drücke den physischen `RESET`-Knopf auf der Unterseite des PCBs
+* Suche auf dem PCB den Pin mit dem Label `RESET`, verbinde diesen mit deinem GND-Pin
+* Suche auf dem PCB den Pin mit dem Label `BOOT0`, verbinde diesen mit GND und schließe die Tastatur wieder an den PC an TODO: DIS IS DANGEROUS!!
+
+Wenn Du damit erfolgreich warst solltest Du in der QMK Toolbox eine Nachricht sehen die ungefähr so aussieht:
+
+```
+*** Clueboard - Clueboard 66% HotSwap disconnected -- 0xC1ED:0x2390
+*** DFU device connected
+```
+
+### Tastatur flashen
+
+Klicke auf den `Flash`-Knopf in der QMK Toolbox. Die Ausgabe wird ungefähr so aussehen:
+
+```
+*** 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 qmk_firmware/clueboard_66_hotswap_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
+```
+
+## Tastatur mit der Befehlszeile flashen
+
+Zunächst solltest Du versuchen herauszufinden welchen Bootlader deine Tastatur benutzt. Diese vier Bootloader sind am Weitesten verbreitet:
+
+| MCU | Bootloader |
+| --- | --- |
+| Pro-Micro und Klone | CATERINA |
+| Teensy | Halfkay |
+| OLKB Boards | QMK-DFU |
+| sonstige atmega32u4 | DFU |
+
+Auf der Seite [Flash Anleitung und Bootloader Informationen](de/flashing.md) kannst Du mehr über das Thema erfahren.
+
+Wenn Du weißt welchen Bootloader deine Tastaur verwendet, kannst Du diese Information bei der Kompilation hinzufügen um den Flash-Vorgang mit dem `make`-Befehl zu automatisieren.
+```rules.mk
+...
+BOOTLOADER = caterina
+...
+```
+
+### DFU
+
+Wenn Du den DFU-Bootloader verwendest und Du bereit bist deine Firmware zu kompilieren und zu flashen, öffne ein Befehlszeile und führe folgenden Befehl aus:
+
+    make <meine_Tastatur>:<meine_Tastaturbelegung>:dfu
+
+Wenn deine Tastaturbelegung z.B den Namen "xzverz" trägt und Du ein rev5 planck flashen möchtest sähe der Befehl wie folgt aus:
+
+    make planck/rev5:xyverz:dfu
+
+
+Nachdem der Vorgang abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
+
+```
+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
+ ```
+
+Wenn dieser Punkt erreicht ist wird das Build-Skript alle 5 Sekunden nach einem DFU Bootloader suchen. Dieser Vorgang wird wiederholt bis er erfolgreich ist oder abgebrochen wird.
+
+    dfu-programmer: no device present.
+    Error: Bootloader not found. Trying again in 5s.
+
+Wenn diese Nachricht erscheint konnte das Build-Skript den Controller nicht eigenständig in den DFU Modus versetzen (z.B. weil der Modus in rules.mk falsch gesetzt wurde oder ein Problem mit der Hardware besteht), wenn dies eintritt musst Du die oben beschrieben Schritte benutzen um den Controller in den DFU Modus zu versetzen. Danach sollte die Ausgabe ungefähr so aussehen:
+
+```
+*** 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 qmk_firmware/clueboard_66_hotswap_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
+```
+
+?> Wenn Du mit diesem Schritt Probleme hast (z.B. `dfu-programmer: no device present`) hilft dir hoffentlich der Abschnitt [Häufig gestellte Fragen (Build/Kompilieren)](de/faq_build.md).
+
+#### DFU Befehle
+
+Es gibt verschiedene DFU Befehle um die Firmware auf ein DFU Gerät zu flashen:
+
+* `:dfu` - Dies ist die default Option. Es wird gecheckt ob ein DFU Gerät verfügbar ist, ist dies der Fall wird die Firmware geflasht. Dieser Check wird alle 5 Sekunden ausgeführt bis ein DFU Gerät erkannt wird.
+* `:dfu-ee` - Der Flash-Vorgang benutzt eine `.eep` Datei anstatt einer `.hex` Datei. Dies ist eher unüblich.
+* `:dfu-split-left` - Dies flasht die Firmware wie gewohnt (`:dfu`). Allerdings nur die "linke Seite" der EEPROM für geteilte Tastaturen. _Dies ist ideal für auf Elite C basierenden geteilten Tastaturen._
+* `:dfu-split-right` - Dies flasht die Firmware wie gewohnt (`:dfu`). Allerdings nur die "rechte Seite" der EEPROM für geteilte Tastaturen. _Dies ist ideal für auf Elite C basierenden geteilten Tastaturen._
+
+
+### Caterina
+Für Arduinos und andere ProMicro Klone (z.B. SparkFun ProMicro), wenn Du bereit bist zu kompilieren und die Tastatur zu flashen, öffne ein Befehlszeilen-Fenster und führe den Build-Befehl aus:
+
+    make <meine_Tastatur>:<meine_Tastaturbelegung>:avrdude
+
+Wenn deine Tastaturbelegung zum Beispiel den Namen "xyverz" hat und Du eine Tastaturbelegung für ein "rev2 Lets Split" erzeugen möchtest, lautet der Befehl dafür:
+
+    make lets_split/rev2:xyverz:avrdude
+
+Nachdem die Kompilation abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
+
+```
+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..............
+```
+
+Nun wird die Tastatur automatisch zurückgesetzt und das Skript wird die Firmware flashen sobald es den Bootloader erkennt. Die Ausgabe sollte ungefähr so aussehen:
+
+```
+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.
+```
+Sollten dabei Probleme auftreten (z.B. "Zugriff verweigert" / "Permission denied") muss der Make-Befehl mit privilegierten Berechtigungen ausgeführt werden:
+
+    sudo make <meine_Tastatur>:<meine_Tastaturbelegung>:avrdude
+
+Zusätzlich ist es möglich mehrere Tastaturen in einem Vorgang zu flashen:
+
+    make <keyboard>:<keymap>:avrdude-loop
+
+Du kannst den Loop mit STRG + C unterbrechen sobald der Vorgang abgeschlossen ist. Die korrekte Tastenkombination kann abweichen und hängt vom Betriebssystem ab.
+
+
+### HalfKay
+
+Für Tastaturen mit PJRC Controllern (Teensy's), wenn Du bereit bist zu kompilieren und die Tastatur zu flashen, öffne ein Befehlszeilen-Fenster und führe den Build-Befehl aus:
+
+    make <meine_Tastatur>:<meine_Tastaturbelegung>:teensy
+
+Wenn deine Tastaturbelegung zum Beispiel den Namen "xyverz" hat und Du eine Tastaturbelegung für ein Ergodox oder Ergodox EZ erzeugen möchtest, lautet der Befehl dafür:
+
+    make ergodox_ez:xyverz:teensy
+
+Nachdem die Kompilation abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
+
+```
+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)
+ ```
+
+An diesem Punkt solltest Du die Tastatur zurücksetzen um den Flash-Vorgang auszulösen. Wenn dies abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
+
+ ```
+Found HalfKay Bootloader
+Read "./.build/ergodox_ez_xyverz.hex": 28532 bytes, 88.5% usage
+Programming.............................................................
+...................................................
+Booting
+```
+
+### BootloadHID
+
+Für auf Bootmapper Client(BMC)/bootloaderHID/ATmega32A basierende Tastaturen, wenn Du bereit bist zu kompilieren und die Tastatur zu flashen, öffne ein Befehlszeilen-Fenster und führe den Build-Befehl aus:
+
+    make <meine_Tastatur>:<meine_Tastaturbelegung>:bootloaderHID
+
+Wenn deine Tastaturbelegung zum Beispiel den Namen "xyverz" hat und Du eine Tastaturbelegung für ein jj40 erzeugen möchtest, lautet der Befehl dafür:
+
+    make jj40:xyverz:bootloaderHID
+
+Nachdem die Kompilation abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
+
+```
+Linking: .build/jj40_default.elf                                 [OK]
+Creating load file for flashing: .build/jj40_default.hex         [OK]
+Copying jj40_default.hex to qmk_firmware folder                  [OK]
+Checking file size of jj40_default.hex                           [OK]
+ * The firmware size is fine - 21920/28672 (6752 bytes free)
+```
+
+Wenn dieser Punkt erreicht ist wird das Build-Skript alle 5 Sekunden nach einem DFU Bootloader suchen. Dieser Vorgang wird wiederholt bis er erfolgreich ist oder abgebrochen wird.
+
+```
+Error opening HIDBoot device: The specified device was not found
+Trying again in 5s.
+```
+
+An diesem Punkt solltest Du die Tastatur zurücksetzen um den Flash-Vorgang auszulösen. Wenn dies abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
+
+```
+Page size   = 128 (0x80)
+Device size = 32768 (0x8000); 30720 bytes remaining
+Uploading 22016 (0x5600) bytes starting at 0 (0x0)
+0x05580 ... 0x05600
+```
+
+### STM32 (ARM)
+
+Für die meisten ARM Tastaturen (inkl. Proton C, Planck Rev 6 und Preonic Rev 3), wenn Du bereit bist zu kompilieren und die Tastatur zu flashen, öffne ein Befehlszeilen-Fenster und führe den Build-Befehl aus:
+
+    make <meine_Tastatur>:<meine_Tastaturbelegung>:dfu-util
+
+Wenn deine Tastaturbelegung zum Beispiel den Namen "xyverz" hat und Du eine Tastaturbelegung für ein Planck Revision 6 erzeugen möchtest, benutze dafür den folgenden Befehl und reboote die Tastatur in den Bootloader (kurz bevor der Kompiliervorgang abgeschlossen ist):
+
+    make planck/rev6:xyverz:dfu-util
+
+Nachdem der Kompiliervorgang abgeschlossen ist sollte die Ausgabe ungefähr so aussehen:
+
+Für auf Bootmapper Client(BMC)/bootloaderHID/ATmega32A basierende Tastaturen, wenn Du bereit bist zu kompilieren und die Tastatur zu flashen, öffne ein Befehlszeilen-Fenster und führe den Build-Befehl aus:
+
+    make <meine_Tastatur>:<meine_Tastaturbelegung>:bootloaderHID
+
+Wenn deine Tastaturbelegung zum Beispiel den Namen "xyverz" hat und Du eine Tastaturbelegung für ein jj40 erzeugen möchtest, lautet der Befehl dafür:
+```
+Linking: .build/planck_rev6_xyverz.elf                                       [OK]
+Creating binary load file for flashing: .build/planck_rev6_xyverz.bin        [OK]
+Creating load file for flashing: .build/planck_rev6_xyverz.hex               [OK]
+
+Size after:
+   text    data     bss     dec     hex filename
+      0   41820       0   41820    a35c .build/planck_rev6_xyverz.hex
+
+Copying planck_rev6_xyverz.bin to qmk_firmware folder                        [OK]
+dfu-util 0.9
+
+Copyright 2005-2009 Weston Schmidt, Harald Welte and OpenMoko Inc.
+Copyright 2010-2016 Tormod Volden and Stefan Schmidt
+This program is Free Software and has ABSOLUTELY NO WARRANTY
+Please report bugs to http://sourceforge.net/p/dfu-util/tickets/
+
+Invalid DFU suffix signature
+A valid DFU suffix will be required in a future dfu-util release!!!
+Opening DFU capable USB device...
+ID 0483:df11
+Run-time device DFU version 011a
+Claiming USB DFU Interface...
+Setting Alternate Setting #0 ...
+Determining device status: state = dfuERROR, status = 10
+dfuERROR, clearing status
+Determining device status: state = dfuIDLE, status = 0
+dfuIDLE, continuing
+DFU mode device DFU version 011a
+Device returned transfer size 2048
+DfuSe interface name: "Internal Flash  "
+Downloading to address = 0x08000000, size = 41824
+Download        [=========================] 100%        41824 bytes
+Download done.
+File downloaded successfully
+Transitioning to dfuMANIFEST state
+```
+
+#### STM32 Befehle
+
+Für Tastaturen mit STM32 Controller sind die DFU Befehle wie folgt:
+
+* `:dfu-util` - The default command for flashing to STM32 devices.
+* `:dfu-util` - Der Standard-Befehl für STM32 Geräte.
+* `:dfu-util-wait` - Funktioniert wie der Standard-Befehl, aber mit einem 10 Sekunden Timeout bevor erneut versucht wird die Firmware zu flashen. Mit dem Parameter `TIME_DELAY=20` auf der Befehlszeile kann der Timeout beeinflusst werden.
+   * z.B.: `make <meine_Tastatur>:<meine_Tastaturbelegung>:dfu-util TIME_DELAY=5`
+* `:dfu-util-split-left` - Gleiche Funktionsweise wie `dfu-util`, jedoch wird zusätzlich das EEPROM Setting "linke Seite" für geteilte Tastaturen gesetzt.
+* `:dfu-util-split-right` - Gleiche Funktionsweise wie `dfu-util`, jedoch wird zusätzlich das EEPROM Setting "rechte Seite" für geteilte Tastaturen gesetzt.
+
+## Probier's aus!
+
+Herzlichen Glückwunsch! Deine individuell angepasst Firmware wurde auf deine Tastatur übertragen!
+
+ Probiere deine neue Tastatur aus und gehe sicher dass alles wie gewünscht funktioniert. Wir haben einen weiteren Artikel zum Thema [Testen und Debuggen](de/newbs_testing_debugging.md) verfasst der sich mit Problembeseitigung beschäftigt um den Beginnger-Guide abzuschließen.

docs/de/newbs_getting_started.md

@@ -0,0 +1,101 @@
+# Einleitung
+Genau wie in einem Computer befindet sich auch in einer Tastatur ein Prozessor.
+
+Dieser Prozessor führt Software aus, die registriert wenn Tasten gedrückt bzw. wieder losgelassen werden und leitet die entsprechenden Signale an den Computer weiter.
+
+QMK übernimmt die Rolle dieser Software und teilt dem Host-Computer den aktuellen Zustand der Tastatur mit. Wenn Du eine Tastaturbelegung definierst, ist dies äquivalent zu einem ausführbarem Programm, das auf deiner Tastatur läuft.
+
+QMK möchte seine BenutzerInnen in die Lage versetzen, simple Aufgaben möglichst einfach zu gestalten und gleichzeitig komplexe Dinge zu ermöglichen, die mit normalen Tastaturen ohne zusätzliche Software undenkbar wären. Du musst nicht programmieren können, um abgefahrene Tastaturbelegungen zu gestalten - es reicht wenn Du eine Idee hast und ein paar einfache syntaktische Regeln verstehen kannst.
+
+# Los geht's!
+Bevor Du damit loslegen kannst, deine Tastaturbelegung zu erstellen, musst Du ein wenig Software installieren und Dir eine Entwicklungsumgebung aufsetzen. Die gute Nachricht ist, dass das nur einmal erledigt werden muss, egal für wie viele verschiedene Tastaturen Du hinterher Firmware entwickeln willst.
+
+Wenn Du es vorziehst mit einer grafischen Oberfläche zu entwickeln kannst Du auch dazu gerne direkt mit dem online [QMK Konfigurator](https://config.qmk.fm) loslegen. Siehe auch: [Firmware mit der Online GUI erzeugen](de/newbs_building_firmware_configurator.md)
+
+## Software herunterladen
+
+### Text Editor
+
+Du wirst ein Programm benötigen, mit dem Du **plain text** (= reiner Text) Dateien bearbeiten und speichern kannst. Wenn Du Windows benutzt, reicht dafür schon das normale `Notepad` und für Linux z.B. `gedit` oder `leafpad`. Beide sind sehr rudimentäre Editoren deren Funktionsumfang aber vollkommen ausreicht. Für macOS' standard `TextEdit` muss man ein bisschen vorsichtig sein und darauf achten, beim Speichern explizit unter _Format_ die Option _Reiner Text_ auszuwählen.
+
+Ansonsten ist es empfehlenswert, einen Editor herunterzuladen der für die Programmierung und das Bearbeiten von Code ausgelegt ist wie z.b [Notepad++](http://notepad-plus-plus.org/), [Sublime Text](https://www.sublimetext.com/) oder [VS Code](https://code.visualstudio.com/).
+
+?> Immer noch unsicher, welcher Text Editor der Richtige für Dich ist? Laurence Bradford hat eine hervorragende [Einleitung](https://learntocodewith.me/programming/basics/text-editors/) zu dem Thema geschrieben (auf Englisch).
+
+### QMK Toolbox
+
+QMK Toolbox ist ein optionales grafisches Programm für Windows und macOS, das es erleichtern soll, deine Tastatur zu programmieren und zu debuggen. Du wirst es höchstwahrscheinlich früher oder später als unverzichtbar ansehen, wenn es darum geht eine Tastatur einfach zu flashen oder zu debuggen, da es ermöglicht, sich debug-Nachrichten direkt anzeigen zu lassen.
+
+[Hier kannst Du die aktuelle Version herunterladen.](https://github.com/qmk/qmk_toolbox/releases/latest)
+
+* Für Windows: `qmk_toolbox.exe` (portable) oder `qmk_toolbox_install.exe` (installer)
+* Für macOS: `QMK.Toolbox.app.zip` (portable) oder `QMK.Toolbox.pkg` (installer)
+
+## Die Entwicklungsumgebung aufsetzen
+
+
+Wir haben versucht, die Installation der Entwicklungsumgebung für QMK so einfach wie möglich zu gestalten. Alles, was Du tun musst, ist eine Linux oder Unix Umgebung aufzusetzen, danach macht QMK den Rest.
+
+?> Wenn Du das erste Mal mit der Linux/Unix Befehlszeile arbeitest, schadet es nicht, sich mit ein paar Grundlagen und Befehlen vertraut zu machen. Diese Ressourcen sollten ausreichen, um sich das Nötigste anzueignen um mit QMK arbeiten zu können:<br>
+[Erforderliche Linux Grundlagen](https://www.guru99.com/must-know-linux-commands.html)<br>
+[Noch ein paar Linux Befehle](https://www.tjhsst.edu/~dhyatt/superap/unixcmd.html)
+
+### Windows
+
+Du wirst MSYS2 (o.Ä.) und Git benötigen.
+
+* Befolge die Installationsanleitung auf der [MSYS2 Homepage](http://www.msys2.org)
+* Schließe alle offenen MSYS2 Fenster und öffne ein neues MSYS2 MinGW 64-bit Terminal
+* Installiere Git mit dem Kommando: `pacman -S git`
+
+### macOS
+
+Du wirst Homebrew benötigen. Folge dafür den Anweisungen auf der [Homebrew homepage](https://brew.sh).
+
+Nachdem Homebrew erfolgreich installiert ist, kannst Du mit _QMK aufsetzen_ fortfahren. 
+
+### Linux
+
+Du benötigst Git, aber es ist ziemlich wahrscheinlich, dass es bereits installiert ist. Sollte dies nicht der Fall sein, kannst Du es mit dem folgenden Aufruf installieren:
+
+* Debian / Ubuntu / Devuan: `apt-get install git`
+* Fedora / Red Hat / CentOS: `yum install git`
+* Arch Linux: `pacman -S git`
+
+?> Docker ist ebenfalls eine Option für alle Plattformen. [Hier](de/getting_started_build_tools.md#docker) kannst Du dazu weitere Informationen finden.
+
+## QMK aufsetzen
+Wenn Du damit fertig bist, deine Linux/Unix Umgebung zu installieren, kannst Du damit fortfahren QMK herunterzuladen. Dafür werden wir mit Git das QMK Repository "klonen". Öffne ein Terminal oder ein MSYS2 MinGW Fenster, dies wirst Du für den Rest der Anleitung benötigen. In diesem Fenster rufst Du nun die beiden folgenden Kommandos auf:
+
+```shell
+git clone --recurse-submodules https://github.com/qmk/qmk_firmware.git
+cd qmk_firmware
+```
+?> Wenn Du bereits weißt, [wie man GitHub benutzt](de/getting_started_github.md), empfehlen wir, dass Du Dir ein eigenen Fork erstellst. Wenn Du nicht weißt, was das bedeuten soll, kannst Du diesen Ratschlag getrost ignorieren.
+
+QMK liefert ein Script mit, das helfen soll, Dir alles Weitere abzunehmen. Du kannst es mit dem folgenden Befehl aufrufen:
+
+    util/qmk_install.sh
+
+## Die Build-Umgebung testen
+
+Nun sollte hoffentlich alles Nötige für eine funktionierende QMK Build-Umgebung installiert sein und Du solltest in der Lage sein, die QMK-Firmware zu kompilieren. Um dies mit einer `default` Tastaturbelegung zu testen, kannst Du den folgenden Befehl ausprobieren:
+
+    make <keyboard>:default
+
+Der Befehl um z.B. die Firmware für ein _Clueboard 66%_ zu erzeugen lautet:
+
+    make clueboard/66/rev3:default
+
+Wenn es fertig ist, sollte der Output ungefähr so ähnlich wie das Folgende aussehen:
+
+```
+Linking: .build/clueboard_66_rev3_default.elf                                                       [OK]
+Creating load file for flashing: .build/clueboard_66_rev3_default.hex                               [OK]
+Copying clueboard_66_rev3_default.hex to qmk_firmware folder                                        [OK]
+Checking file size of clueboard_66_rev3_default.hex                                                 [OK]
+ * The firmware size is fine - 26356/28672 (2316 bytes free)
+```
+
+# Eine eigene Tastaturbelegung erstellen
+Du bist nun fertig mit dem Setup der Entwicklungsumgebung und solltest somit in der Lage sein, deine eigenen Tastaturbelegungen zu erstellen. Um fortzufahren, folge bitte der nächsten Anleitung unter [Die erste Firmware](de/newbs_building_firmware.md).

docs/de/newbs_learn_more_resources.md

@@ -0,0 +1,14 @@
+# Lernmaterial
+
+Diese weiterführenden Ressourcen sind darauf ausgerichtet, Neulingen der QMK Commmunity mehr Informationen und ein besseres Verständnis zu einzelnen Themen zu bieten.
+
+Git Ressourcen:
+
+* [Gutes allgemeines Tutorial](https://www.codecademy.com/learn/learn-git) (auf Englisch)
+* [Git spielerisch anhand von Beispielen lernen](https://learngitbranching.js.org/) (auf Englisch)
+* [Mehr über den allgemeinen Umgang mit Github](getting_started_github.md)
+* [Mehr über Git im Bezug zu QMK](contributing.md)
+
+Mehr über die Arbeit mit der Befehlszeile:
+
+* [Gutes allgemeines Tutorial über die Arbeit mit der Befehlszeile](https://www.codecademy.com/learn/learn-the-command-line) (auf Englisch)

docs/de/newbs_testing_debugging.md

@@ -0,0 +1,100 @@
+# Testen und Debuggen
+
+Nachdem Du deine Tastatur mit deiner angepassten Firmware geflasht hast, ist es nun an der Zeit sie auszuprobieren. Mit ein bisschen Glück sollte alles ohne Probleme funktionieren, wenn dies nicht der Fall ist, soll dieses Dokument dir dabei helfen, herauszufinden wo das Problem liegt.
+
+## Testen
+
+Die Tastatur zu testen ist relativ selbsterklärend. Drücke jede der Tasten um dich zu versichern, dass der gesendete Keyode der ist, den du erwarten würdest. Dafür gibt es sogar ein paar Programme die helfen sollen, dass keine Taste ausgelassen wurde.
+
+Anmerkung: Diese Programme werden weder von QMK bereitgestellt oder gutgeheißen.
+
+* [Switch Hitter](https://elitekeyboards.com/switchhitter.php) (Nur für Windows)
+* [Keyboard Viewer](https://www.imore.com/how-use-keyboard-viewer-your-mac) (Nur für Mac)
+* [Keyboard Tester](http://www.keyboardtester.com) (Web basiert)
+* [Keyboard Checker](http://keyboardchecker.com) (Web basiert)
+
+## Debuggen
+
+Deine Tastatur wird Debug Informationen liefern wenn Du `CONSOLE_ENABLE = yes` in deiner `rules.mk` gesetzt hast. Die default-Ausgabe ist sehr beschränkt und kann wenn nötig durch die Aktivierung des Debug-Modes erhöht werden. Benutze dafür entweder den `DEBUG` Keycode in deiner Tastaturbelegung, das [Command](de/feature_command.md)-Feature oder füge den folgenden Code zu deiner Tastaturbelegung hinzu.
+
+```c
+void keyboard_post_init_user(void) {
+  // Customise these values to desired behaviour
+  debug_enable=true;
+  debug_matrix=true;
+  //debug_keyboard=true;
+  //debug_mouse=true;
+}
+```
+
+### Debuggen mit der QMK Toolbox
+
+Für kompatible Plattformen kann die [QMK Toolbox](https://github.com/qmk/qmk_toolbox) benutzt werden um Debug-Nachrichten deiner Tastatur anzuzeigen.
+
+### Debuggen mit hid_listen
+
+Bevorzugst Du es lieber auf der Befehlszeile zu debuggen? Dafür eignet sich das Programm [hid_listen](https://www.pjrc.com/teensy/hid_listen.html) von PJRC. Binaries sind für Windows, Linux und MacOS verfügbar.
+
+<!-- FIXME: Describe the debugging messages here. -->
+
+## Eigene Debug-Nachrichten senden
+
+Manchmal ist es hilfreich Debug-Nachrichten innerhalb deines eigenen [Custom Codes](de/custom_quantum_functions.md) zu drucken. Das ist ziemlich einfach. Beginne damit `print.h` am Anfang deiner Datei zu inkludieren:
+
+    #include <print.h>
+
+Danach stehen dir verschiedene Druck-Funktionen zur Verfügung:
+
+* `print("string")`: Druckt einen simplen String
+* `uprintf("%s string", var)`: Druckt einen formatierten String
+* `dprint("string")` Druckt einen simplen String, aber nur wenn der Debug-Mode aktiviert ist
+* `dprintf("%s string", var)`: Druckt einen formatierten String, aber nur wenn der Debug-Mode aktiviert ist
+
+## Debug Beispiele
+
+Anbei findest Du eine Sammlung von hilfreichen Beispielen. Für weitere Informationen Informationen sei an dieser Stelle auf [Debugging/Troubleshooting QMK](de/faq_debug.md) verwiesen.
+
+### Which matrix position is this keypress?
+### Welche Matrix Position hat dieser Tastenanschlag
+
+Beim Portieren, oder bei der Fehlerdiagnose von PCB Problemen, ist es nützlich sich anzeigen zu lassen ob ein Tastenanschlag richtig erkannt wurde. Um die Protokollierung für diesen Fall zu aktivieren, füge bitte folgenden Code zu deiner Tastaturbelegung `keymap.c` hinzu.
+
+```c
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  // Wenn 'console' aktiviert ist wird die Matrix-Position und der Status jedes Tastenanschlags ausgegeben 
+#ifdef CONSOLE_ENABLE
+    uprintf("KL: kc: %u, col: %u, row: %u, pressed: %u\n", keycode, record->event.key.col, record->event.key.row, record->event.pressed);
+#endif 
+  return true;
+}
+```
+
+Beispiel Ausgabe:
+```text
+Waiting for device:.......
+Listening:
+KL: kc: 169, col: 0, row: 0, pressed: 1
+KL: kc: 169, col: 0, row: 0, pressed: 0
+KL: kc: 174, col: 1, row: 0, pressed: 1
+KL: kc: 174, col: 1, row: 0, pressed: 0
+KL: kc: 172, col: 2, row: 0, pressed: 1
+KL: kc: 172, col: 2, row: 0, pressed: 0
+```
+
+### Wieviel Zeit wurde benötigt um einen Tastenanschlag zu detektieren?
+
+Wenn Performance-Probleme auftreten ist es hilfreich die Frequenz, mit der die Matrix gescannt wird, zu wissen. Um dies in diesem Fall zu aktiveren füge, den folgenden Code zu deiner Tastaturbelegung in `config.h` hinzu.
+
+```c
+#define DEBUG_MATRIX_SCAN_RATE
+```
+
+Beispiel Ausgabe
+```text
+  > matrix scan frequency: 315
+  > matrix scan frequency: 313
+  > matrix scan frequency: 316
+  > matrix scan frequency: 316
+  > matrix scan frequency: 316
+  > matrix scan frequency: 316
+```

docs/documentation_templates.md

@@ -28,9 +28,9 @@ the Ctrl, Alt, or GUI modifiers are held down.
 
 A compact 40% (12x4) ortholinear keyboard kit made and sold by OLKB and Massdrop. [More info on qmk.fm](http://qmk.fm/planck/)
 
-Keyboard Maintainer: [Jack Humbert](https://github.com/jackhumbert)  
-Hardware Supported: Planck PCB rev1, rev2, rev3, rev4, Teensy 2.0  
-Hardware Availability: [OLKB.com](https://olkb.com), [Massdrop](https://www.massdrop.com/buy/planck-mechanical-keyboard?mode=guest_open)
+* Keyboard Maintainer: [Jack Humbert](https://github.com/jackhumbert)
+* Hardware Supported: Planck PCB rev1, rev2, rev3, rev4, Teensy 2.0
+* Hardware Availability: [OLKB.com](https://olkb.com), [Massdrop](https://www.massdrop.com/buy/planck-mechanical-keyboard?mode=guest_open)
 
 Make example for this keyboard (after setting up your build environment):
 
@@ -38,5 +38,3 @@ Make example for this keyboard (after setting up your build environment):
 
 See the [build environment setup](https://docs.qmk.fm/#/getting_started_build_tools) and the [make instructions](https://docs.qmk.fm/#/getting_started_make_guide) for more information. Brand new to QMK? Start with our [Complete Newbs Guide](https://docs.qmk.fm/#/newbs).
 ```
-
-There needs to be two spaces at the end of the `Keyboard Maintainer` and `Hardware Supported` lines for it to render correctly with Markdown.

docs/es/README.md

@@ -19,7 +19,7 @@ De cualquier manera, también puedes descargarlo directamente en formatos ([zip]
 
 ## Cómo compilar
 
-Antes de poder compilar, necesitarás [instalar un entorno](getting_started_build_tools.md) para el desarrollo de AVR y/o ARM. Una vez hayas completado este paso, usarás el comando `make` para compilar un teclado y keymap con la siguiente notación:
+Antes de poder compilar, necesitarás [instalar un entorno](es/getting_started_build_tools.md) para el desarrollo de AVR y/o ARM. Una vez hayas completado este paso, usarás el comando `make` para compilar un teclado y keymap con la siguiente notación:
 
     make planck/rev4:default
 
@@ -29,4 +29,4 @@ Este ejemplo compilaría la revisión `rev4` del teclado `planck` con el keymap
 
 ## Cómo personalizar
 
-QMK tiene montones de [características](features.md) para explorar, y una buena cantidad de [documentación de referencia](http://docs.qmk.fm) en la que sumergirse. Se pueden sacar provecho de la mayoría de las características modificando tu [keymap](keymap.md), y cambiando los [keycodes](keycodes.md).
+QMK tiene montones de [características](es/features.md) para explorar, y una buena cantidad de [documentación de referencia](http://docs.qmk.fm) en la que sumergirse. Se pueden sacar provecho de la mayoría de las características modificando tu [keymap](es/keymap.md), y cambiando los [keycodes](es/keycodes.md).

docs/es/_summary.md

@@ -1,121 +1,121 @@
-* [Guía completa para novatos](newbs.md)
-  * [Empezando](newbs_getting_started.md)
-  * [Construyendo tu primer firmare](newbs_building_firmware.md)
-  * [Flasheando el firmware](newbs_flashing.md)
-  * [Testeando y depurando ](newbs_testing_debugging.md)
-  * [Mejores práticas](newbs_best_practices.md)
-  * [Recursos de aprendizaje](newbs_learn_more_resources.md)
+* [Guía completa para novatos](es/newbs.md)
+  * [Empezando](es/newbs_getting_started.md)
+  * [Construyendo tu primer firmare](es/newbs_building_firmware.md)
+  * [Flasheando el firmware](es/newbs_flashing.md)
+  * [Testeando y depurando ](es/newbs_testing_debugging.md)
+  * [Mejores práticas](es/newbs_best_practices.md)
+  * [Recursos de aprendizaje](es/newbs_learn_more_resources.md)
 
-* [QMK Basics](README.md)
-  * [Introducción a QMK](getting_started_introduction.md)
-  * [QMK CLI](cli.md)
-  * [Configuración de QMK CLI](cli_configuration.md)
-  * [Contribuyendo a QMK](contributing.md)
-  * [Cómo usar Github](getting_started_github.md)
-  * [Obtener ayuda](getting_started_getting_help.md)
+* [QMK Basics](es/README.md)
+  * [Introducción a QMK](es/getting_started_introduction.md)
+  * [QMK CLI](es/cli.md)
+  * [Configuración de QMK CLI](es/cli_configuration.md)
+  * [Contribuyendo a QMK](es/contributing.md)
+  * [Cómo usar Github](es/getting_started_github.md)
+  * [Obtener ayuda](es/getting_started_getting_help.md)
 
-* [Cambios incompatibles](breaking_changes.md)
-  * [30 Ago 2019](ChangeLog/20190830.md)
+* [Cambios incompatibles](es/breaking_changes.md)
+  * [30 Ago 2019](es/ChangeLog/20190830.md)
 
-* [Preguntas frecuentes](faq.md)
-  * [General](faq_general.md)
-  * [Construir/Compilar QMK](faq_build.md)
-  * [Depurando/Encontrando problemas en QMK](faq_debug.md)
-  * [Keymap](faq_keymap.md)
-  * [Instalación de drivers con Zadig](driver_installation_zadig.md)
+* [Preguntas frecuentes](es/faq.md)
+  * [General](es/faq_general.md)
+  * [Construir/Compilar QMK](es/faq_build.md)
+  * [Depurando/Encontrando problemas en QMK](es/faq_debug.md)
+  * [Keymap](es/faq_keymap.md)
+  * [Instalación de drivers con Zadig](es/driver_installation_zadig.md)
 
 * Guías detalladas
-  * [Instalar herramientas construcción](getting_started_build_tools.md)
-  * [Guía Vagrant](getting_started_vagrant.md)
-  * [Instrucciones de Construcción/Compilado](getting_started_make_guide.md)
-  * [Flasheando Firmware](flashing.md)
-  * [Personalizando funcionalidad](custom_quantum_functions.md)
-  * [Visión general del Keymap](keymap.md)
+  * [Instalar herramientas construcción](es/getting_started_build_tools.md)
+  * [Guía Vagrant](es/getting_started_vagrant.md)
+  * [Instrucciones de Construcción/Compilado](es/getting_started_make_guide.md)
+  * [Flasheando Firmware](es/flashing.md)
+  * [Personalizando funcionalidad](es/custom_quantum_functions.md)
+  * [Visión general del Keymap](es/keymap.md)
 
-* [Hardware](hardware.md)
-  * [Procesadores AVR](hardware_avr.md)
-  * [Drivers](hardware_drivers.md)
+* [Hardware](es/hardware.md)
+  * [Procesadores AVR](es/hardware_avr.md)
+  * [Drivers](es/hardware_drivers.md)
 
 * Referencia
-  * [Pautas de teclados](hardware_keyboard_guidelines.md)
-  * [Opciones de configuración](config_options.md)
-  * [Keycodes](keycodes.md)
-  * [Convenciones de código - C](coding_conventions_c.md)
-  * [Convenciones de código - Python](coding_conventions_python.md)
-  * [Mejores prácticas de documentación](documentation_best_practices.md)
-  * [Plantillas de documentación](documentation_templates.md)
-  * [Glosario](reference_glossary.md)
-  * [Tests unitarios](unit_testing.md)
-  * [Funciones útiles](ref_functions.md)
-  * [Sporte configurador](reference_configurator_support.md)
-  * [Formato info.json](reference_info_json.md)
-  * [Desarrollo Python CLI](cli_development.md)
+  * [Pautas de teclados](es/hardware_keyboard_guidelines.md)
+  * [Opciones de configuración](es/config_options.md)
+  * [Keycodes](es/keycodes.md)
+  * [Convenciones de código - C](es/coding_conventions_c.md)
+  * [Convenciones de código - Python](es/coding_conventions_python.md)
+  * [Mejores prácticas de documentación](es/documentation_best_practices.md)
+  * [Plantillas de documentación](es/documentation_templates.md)
+  * [Glosario](es/reference_glossary.md)
+  * [Tests unitarios](es/unit_testing.md)
+  * [Funciones útiles](es/ref_functions.md)
+  * [Sporte configurador](es/reference_configurator_support.md)
+  * [Formato info.json](es/reference_info_json.md)
+  * [Desarrollo Python CLI](es/cli_development.md)
 
-* [Características](features.md)
-  * [Keycodes Básicos](keycodes_basic.md)
-  * [Teclas US ANSI Shifted](keycodes_us_ansi_shifted.md)
-  * [Keycodes Quantum](quantum_keycodes.md)
-  * [Keycodes Avanzados](feature_advanced_keycodes.md)
-  * [Audio](feature_audio.md)
-  * [Auto Shift](feature_auto_shift.md)
-  * [Retroiluminación](feature_backlight.md)
-  * [Bluetooth](feature_bluetooth.md)
-  * [Bootmagic](feature_bootmagic.md)
-  * [Combos](feature_combo.md)
-  * [Comando](feature_command.md)
-  * [API Debounce](feature_debounce_type.md)
-  * [Switch DIP](feature_dip_switch.md)
-  * [Macros Dinámicas](feature_dynamic_macros.md)
-  * [Encoders](feature_encoders.md)
-  * [Grave Escape](feature_grave_esc.md)
-  * [Feedback Háptico](feature_haptic_feedback.md)
-  * [Controlador LCD HD44780](feature_hd44780.md)
-  * [Key Lock](feature_key_lock.md)
-  * [Layouts](feature_layouts.md)
-  * [Tecla Leader](feature_leader_key.md)
-  * [Matriz LED](feature_led_matrix.md)
-  * [Macros](feature_macros.md)
-  * [Teclas del ratón](feature_mouse_keys.md)
-  * [Driver OLED](feature_oled_driver.md)
-  * [Teclas One Shot](feature_advanced_keycodes.md#one-shot-keys)
-  * [Dispositivo de apuntado](feature_pointing_device.md)
-  * [Ratón PS/2](feature_ps2_mouse.md)
-  * [Iluminación RGB](feature_rgblight.md)
-  * [Matriz RGB](feature_rgb_matrix.md)
-  * [Cadete espacial](feature_space_cadet.md)
-  * [Teclado dividido](feature_split_keyboard.md)
-  * [Stenografía](feature_stenography.md)
-  * [Swap Hands](feature_swap_hands.md)
-  * [Tap Dance](feature_tap_dance.md)
-  * [Terminal](feature_terminal.md)
-  * [Impresora Térmica](feature_thermal_printer.md)
-  * [Unicode](feature_unicode.md)
-  * [Userspace](feature_userspace.md)
-  * [Velocikey](feature_velocikey.md)
+* [Características](es/features.md)
+  * [Keycodes Básicos](es/keycodes_basic.md)
+  * [Teclas US ANSI Shifted](es/keycodes_us_ansi_shifted.md)
+  * [Keycodes Quantum](es/quantum_keycodes.md)
+  * [Keycodes Avanzados](es/feature_advanced_keycodes.md)
+  * [Audio](es/feature_audio.md)
+  * [Auto Shift](es/feature_auto_shift.md)
+  * [Retroiluminación](es/feature_backlight.md)
+  * [Bluetooth](es/feature_bluetooth.md)
+  * [Bootmagic](es/feature_bootmagic.md)
+  * [Combos](es/feature_combo.md)
+  * [Comando](es/feature_command.md)
+  * [API Debounce](es/feature_debounce_type.md)
+  * [Switch DIP](es/feature_dip_switch.md)
+  * [Macros Dinámicas](es/feature_dynamic_macros.md)
+  * [Encoders](es/feature_encoders.md)
+  * [Grave Escape](es/feature_grave_esc.md)
+  * [Feedback Háptico](es/feature_haptic_feedback.md)
+  * [Controlador LCD HD44780](es/feature_hd44780.md)
+  * [Key Lock](es/feature_key_lock.md)
+  * [Layouts](es/feature_layouts.md)
+  * [Tecla Leader](es/feature_leader_key.md)
+  * [Matriz LED](es/feature_led_matrix.md)
+  * [Macros](es/feature_macros.md)
+  * [Teclas del ratón](es/feature_mouse_keys.md)
+  * [Driver OLED](es/feature_oled_driver.md)
+  * [Teclas One Shot](es/feature_advanced_keycodes.md#one-shot-keys)
+  * [Dispositivo de apuntado](es/feature_pointing_device.md)
+  * [Ratón PS/2](es/feature_ps2_mouse.md)
+  * [Iluminación RGB](es/feature_rgblight.md)
+  * [Matriz RGB](es/feature_rgb_matrix.md)
+  * [Cadete espacial](es/feature_space_cadet.md)
+  * [Teclado dividido](es/feature_split_keyboard.md)
+  * [Stenografía](es/feature_stenography.md)
+  * [Swap Hands](es/feature_swap_hands.md)
+  * [Tap Dance](es/feature_tap_dance.md)
+  * [Terminal](es/feature_terminal.md)
+  * [Impresora Térmica](es/feature_thermal_printer.md)
+  * [Unicode](es/feature_unicode.md)
+  * [Userspace](es/feature_userspace.md)
+  * [Velocikey](es/feature_velocikey.md)
 
 * Para Makers y Modders
-  * [Guía de cableado a mano](hand_wire.md)
-  * [Guía de flasheado de ISP](isp_flashing_guide.md)
-  * [Guía de depuración de ARM](arm_debugging.md)
-  * [Driver I2C](i2c_driver.md)
-  * [Controles GPIO](internals_gpio_control.md)
-  * [Conversión Proton C](proton_c_conversion.md)
+  * [Guía de cableado a mano](es/hand_wire.md)
+  * [Guía de flasheado de ISP](es/isp_flashing_guide.md)
+  * [Guía de depuración de ARM](es/arm_debugging.md)
+  * [Driver I2C](es/i2c_driver.md)
+  * [Controles GPIO](es/internals_gpio_control.md)
+  * [Conversión Proton C](es/proton_c_conversion.md)
 
 * Para entender en profundidad
-  * [Cómo funcionan los teclados](how_keyboards_work.md)
-  * [Entendiendo QMK](understanding_qmk.md)
+  * [Cómo funcionan los teclados](es/how_keyboards_work.md)
+  * [Entendiendo QMK](es/understanding_qmk.md)
 
 * Otros temas
-  * [Usando Eclipse con QMK](other_eclipse.md)
-  * [Usando VSCode con QMK](other_vscode.md)
-  * [Soporte](support.md)
-  * [Cómo añadir traducciones](translating.md)
+  * [Usando Eclipse con QMK](es/other_eclipse.md)
+  * [Usando VSCode con QMK](es/other_vscode.md)
+  * [Soporte](es/support.md)
+  * [Cómo añadir traducciones](es/translating.md)
 
 * QMK Internals (En progreso)
-  * [Defines](internals_defines.md)
-  * [Input Callback Reg](internals_input_callback_reg.md)
-  * [Dispositivo Midi](internals_midi_device.md)
-  * [Proceso de configuración de un dispositivo Midi](internals_midi_device_setup_process.md)
-  * [Utilidad Midi](internals_midi_util.md)
-  * [Funciones Send](internals_send_functions.md)
-  * [Herramientas Sysex](internals_sysex_tools.md)
+  * [Defines](es/internals_defines.md)
+  * [Input Callback Reg](es/internals_input_callback_reg.md)
+  * [Dispositivo Midi](es/internals_midi_device.md)
+  * [Proceso de configuración de un dispositivo Midi](es/internals_midi_device_setup_process.md)
+  * [Utilidad Midi](es/internals_midi_util.md)
+  * [Funciones Send](es/internals_send_functions.md)
+  * [Herramientas Sysex](es/internals_sysex_tools.md)

docs/faq_build.md

@@ -47,7 +47,7 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="1c11", MODE:="0666"
 ```
 
-**/etc/udev/rules.d/55-catalina.rules:**
+**/etc/udev/rules.d/55-caterina.rules:**
 ```
 # ModemManager should ignore the following devices
 ATTRS{idVendor}=="2a03", ENV{ID_MM_DEVICE_IGNORE}="1"
@@ -69,6 +69,12 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="1eaf", ATTRS{idProduct}=="0003", MODE:="066
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", MODE:="0666"
 ```
 
+**/etc/udev/rules.d/57-bootloadhid.rules:**
+```
+# bootloadHID
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="05df", MODE:="0666"
+```
+
 ### Serial device is not detected in bootloader mode on Linux
 Make sure your kernel has appropriate support for your device. If your device uses USB ACM, such as
 Pro Micro (Atmega32u4), make sure to include `CONFIG_USB_ACM=y`. Other devices may require `USB_SERIAL` and any of its sub options.
@@ -81,10 +87,6 @@ Re-running the QMK installation script (`./util/qmk_install.sh` from the `qmk_fi
 
 If that doesn't work, then you may need to download and run Zadig. See [Bootloader Driver Installation with Zadig](driver_installation_zadig.md) for more detailed information.
 
-## 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.
 
@@ -97,29 +99,6 @@ You can buy a really unique VID:PID here. I don't think you need this for person
 - 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`
-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
-
-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
-Your toolchain is too old to support the MCU. For example WinAVR 20100110 doesn't support ATMega32u2.
-
-```
-Compiling C: ../../tmk_core/protocol/lufa/lufa.c
-avr-gcc -c -mmcu=atmega32u2 -gdwarf-2 -DF_CPU=16000000UL -DINTERRUPT_CONTROL_ENDPOINT -DBOOTLOADER_SIZE=4096 -DF_USB=16000000UL -DARCH=ARCH_AVR8 -DUSB_DEVICE_ONLY -DUSE_FLASH_DESCRIPTORS -DUSE_STATIC_OPTIONS="(USB_DEVICE_OPT_FULLSPEED | USB_OPT_REG_ENABLED | USB_OPT_AUTO_PLL)" -DFIXED_CONTROL_ENDPOINT_SIZE=8  -DFIXED_NUM_CONFIGURATIONS=1 -DPROTOCOL_LUFA -DEXTRAKEY_ENABLE -DCONSOLE_ENABLE -DCOMMAND_ENABLE -DVERSION=unknown -Os -funsigned-char -funsigned-bitfields -ffunction-sections -fdata-sections -fno-inline-small-functions -fpack-struct -fshort-enums -fno-strict-aliasing -Wall -Wstrict-prototypes -Wa,-adhlns=obj_alps64/protocol/lufa/lufa.lst -I. -I../../tmk_core -I../../tmk_core/protocol/lufa -I../../tmk_core/protocol/lufa/LUFA-git -I../../tmk_core/common -std=gnu99 -include config.h -MMD -MP -MF .dep/obj_alps64_protocol_lufa_lufa.o.d  ../../tmk_core/protocol/lufa/lufa.c -o obj_alps64/protocol/lufa/lufa.o
-../../tmk_core/protocol/lufa/lufa.c: In function 'setup_mcu':
-../../tmk_core/protocol/lufa/lufa.c:575: warning: implicit declaration of function 'clock_prescale_set'
-../../tmk_core/protocol/lufa/lufa.c:575: error: 'clock_div_1' undeclared (first use in this function)
-../../tmk_core/protocol/lufa/lufa.c:575: error: (Each undeclared identifier is reported only once
-../../tmk_core/protocol/lufa/lufa.c:575: error: for each function it appears in.)
-make: *** [obj_alps64/protocol/lufa/lufa.o] Error 1
-```
-
-
 ## BOOTLOADER_SIZE for AVR
 Note that Teensy2.0++ bootloader size is 2048byte. Some Makefiles may have wrong comment.
 
@@ -140,24 +119,29 @@ The solution is to remove and reinstall all affected modules.
 
 ```
 brew rm avr-gcc
+brew rm avr-gcc@8
 brew rm dfu-programmer
 brew rm dfu-util
 brew rm gcc-arm-none-eabi
+brew rm arm-gcc-bin@8
 brew rm avrdude
-brew install avr-gcc
+brew install avr-gcc@8
 brew install dfu-programmer
 brew install dfu-util
-brew install gcc-arm-none-eabi
+brew install arm-gcc-bin@8
 brew install avrdude
+brew link --force avr-gcc@8
+brew link --force arm-gcc-bin@8
+
 ```
 
-### avr-gcc 8.1 and LUFA
+### `avr-gcc` and LUFA
 
-If you updated your avr-gcc to above 7 you may see errors involving LUFA. For example:
+If you updated your `avr-gcc` and you see errors involving LUFA, for example:
 
 `lib/lufa/LUFA/Drivers/USB/Class/Device/AudioClassDevice.h:380:5: error: 'const' attribute on function returning 'void'`
 
-For now, you need to rollback avr-gcc to 7 in brew.
+For now, you need to rollback `avr-gcc` to 8 in Homebrew.
 
 ```
 brew uninstall --force avr-gcc

docs/faq_debug.md

@@ -27,7 +27,7 @@ You may need privilege to access the device on OS like Linux.
 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).
-- set `debug_enable=true` usually in `matrix_init()` in **matrix.c**.
+- set `debug_enable=true`. See [Testing and Debugging](newbs_testing_debugging.md#debugging)
 - 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).
 
@@ -112,56 +112,6 @@ In C `1` means one of [int] type which is [16 bit] in case of AVR so you can't s
 
 http://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
 
-
-## 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
-#   Teensy++ halfKay(AT90USB128)   2048
-OPT_DEFS += -DBOOTLOADER_SIZE=4096
-```
-AVR Boot section size are defined by setting **BOOTSZ** fuse in fact. Consult with your MCU datasheet.
-Note that **Word**(2 bytes) size and address are used in datasheet while TMK uses **Byte**.
-
-AVR Boot section is located at end of Flash memory like the followings.
-```
-byte     Atmel/LUFA(ATMega32u4)          byte     Atmel(AT90SUB1286)
-0x0000   +---------------+               0x00000  +---------------+
-         |               |                        |               |
-         |               |                        |               |
-         |  Application  |                        |  Application  |
-         |               |                        |               |
-         =               =                        =               =
-         |               | 32KB-4KB               |               | 128KB-8KB
-0x6000   +---------------+               0x1E000  +---------------+
-         |  Bootloader   | 4KB                    |  Bootloader   | 8KB
-0x7FFF   +---------------+               0x1FFFF  +---------------+
-
-
-byte     Teensy(ATMega32u4)              byte     Teensy++(AT90SUB1286)
-0x0000   +---------------+               0x00000  +---------------+
-         |               |                        |               |
-         |               |                        |               |
-         |  Application  |                        |  Application  |
-         |               |                        |               |
-         =               =                        =               =
-         |               | 32KB-512B              |               | 128KB-2KB
-0x7E00   +---------------+               0x1FC00  +---------------+
-         |  Bootloader   | 512B                   |  Bootloader   | 2KB
-0x7FFF   +---------------+               0x1FFFF  +---------------+
-```
-
-And see this discussion for further reference.
-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)
 You need to define `EXTRAKEY_ENABLE` in `rules.mk` to use them in QMK.
 
@@ -194,24 +144,6 @@ If you would like to keep JTAG enabled, just add the following to your `config.h
 #define NO_JTAG_DISABLE
 ```
 
-## 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
-
-## Program Arduino Micro/Leonardo
-Push reset button and then run command like this within 8 seconds.
-
-```
-avrdude -patmega32u4 -cavr109 -b57600 -Uflash:w:adb_usb.hex -P/dev/ttyACM0
-```
-
-Device name will vary depending on your system.
-
-http://arduino.cc/en/Main/ArduinoBoardMicro
-https://geekhack.org/index.php?topic=14290.msg1563867#msg1563867
-
-
 ## USB 3 Compatibility
 I heard some people have a problem with USB 3 port, try USB 2 port.
 

docs/faq_keymap.md

@@ -67,24 +67,8 @@ 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 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.
-
-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
-
-On **Mac** OS defines `Option` key combinations.
-* 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
-
-And see this for **Unicode** input.
-* http://en.wikipedia.org/wiki/Unicode_input
+See the [Unicode](feature_unicode.md) feature.
 
 ## `Fn` Key on macOS
 
@@ -130,51 +114,6 @@ https://github.com/tekezo/Karabiner/issues/403
 
 See the [Grave Escape](feature_grave_esc.md) feature.
 
-## 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"
-
-
-/* Arrow keys on right modifier keys with TMK dual role feature
- *
- *  https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#213-modifier-with-tap-keydual-role
- *  https://en.wikipedia.org/wiki/Modifier_key#Dual-role_keys
- */
-const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    /* 0: qwerty */
-    [0] = LAYOUT( \
-        ESC, 1,   2,   3,   4,   5,   6,   7,   8,   9,   0,   MINS,EQL, NUHS,BSPC, \
-        TAB, Q,   W,   E,   R,   T,   Y,   U,   I,   O,   P,   LBRC,RBRC,BSLS, \
-        LCTL,A,   S,   D,   F,   G,   H,   J,   K,   L,   SCLN,QUOT,ENT,  \
-        LSFT,NUBS,Z,   X,   C,   V,   B,   N,   M,   COMM,DOT, SLSH,FN0, ESC, \
-        FN4, LGUI,LALT,          SPC,                     APP, FN2, FN1, FN3),
-    [1] = LAYOUT( \
-        GRV, F1,  F2,  F3,  F4,  F5,  F6,  F7,  F8,  F9,  F10, F11, F12, TRNS,TRNS, \
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,\
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \
-        TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,FN5, TRNS, \
-        TRNS,TRNS,TRNS,          TRNS,                    TRNS,FN7, FN6, FN8),
-};
-
-const uint16_t PROGMEM fn_actions[] = {
-    [0] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_UP),
-    [1] = ACTION_MODS_TAP_KEY(MOD_RGUI, KC_DOWN),
-    [2] = ACTION_MODS_TAP_KEY(MOD_RALT, KC_LEFT),
-    [3] = ACTION_MODS_TAP_KEY(MOD_RCTL, KC_RIGHT),
-    [4] = ACTION_LAYER_MOMENTARY(1),
-    [5] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_PGUP),
-    [6] = ACTION_MODS_TAP_KEY(MOD_RGUI, KC_PGDN),
-    [7] = ACTION_MODS_TAP_KEY(MOD_RALT, KC_HOME),
-    [8] = ACTION_MODS_TAP_KEY(MOD_RCTL, KC_END),
-};
-
-```
-
-Dual-role key: https://en.wikipedia.org/wiki/Modifier_key#Dual-role_keys
-
-
 ## Eject on Mac OSX
 `KC_EJCT` keycode works on OSX. https://github.com/tmk/tmk_keyboard/issues/250
 It seems Windows 10 ignores the code and Linux/Xorg recognizes but has no mapping by default.

docs/feature_advanced_keycodes.md

@@ -15,7 +15,7 @@ This will allow you to use `FN_CAPS` and `ALT_TAB` in your keymap, keeping it mo
 
 ## Caveats
 
-Currently, `LT()` and `MT()` are limited to the [Basic Keycode set](keycodes_basic.md), meaning you can't use keycodes like `LCTL()`, `KC_TILD`, or anything greater than `0xFF`. Modifiers specified as part of a Layer Tap or Mod Tap's keycode will be ignored. If you need to apply modifiers to your tapped keycode, [Tap Dance](https://github.com/qmk/qmk_firmware/blob/master/docs/feature_tap_dance.md#example-5-using-tap-dance-for-advanced-mod-tap-and-layer-tap-keys) can be used to accomplish this.
+Currently, `LT()` and `MT()` are limited to the [Basic Keycode set](keycodes_basic.md), meaning you can't use keycodes like `LCTL()`, `KC_TILD`, or anything greater than `0xFF`. Modifiers specified as part of a Layer Tap or Mod Tap's keycode will be ignored. If you need to apply modifiers to your tapped keycode, [Tap Dance](feature_tap_dance.md#example-5-using-tap-dance-for-advanced-mod-tap-and-layer-tap-keys) can be used to accomplish this.
 
 Additionally, if at least one right-handed modifier is specified in a Mod Tap or Layer Tap, it will cause all modifiers specified to become right-handed, so it is not possible to mix and match the two.
 
@@ -155,7 +155,7 @@ You can control the behavior of one shot keys by defining these in `config.h`:
 
 Sometimes, you want to activate a one-shot key as part of a macro or tap dance routine.  
 
-For one shot layers, 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 one shot layers, you need to call `set_oneshot_layer(LAYER, ONESHOT_START)` on key down, and `clear_oneshot_layer_state(ONESHOT_OTHER_KEY_PRESSED)` on key up. If you want to cancel the oneshot, call `reset_oneshot_layer()`.
 
 For one shot mods, you need to call `set_oneshot_mods(MOD)` to set it, or `clear_oneshot_mods()` to cancel it.
 

docs/feature_auto_shift.md

@@ -51,12 +51,15 @@ By default, Auto Shift is disabled for any key press that is accompanied by one
 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`
+You can re-enable Auto Shift for modifiers by adding a define to your `config.h`
 
-    AUTO_SHIFT_MODIFIERS = yes
+```c
+#define AUTO_SHIFT_MODIFIERS
+```
 
 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
@@ -65,15 +68,12 @@ behavior of Auto Shift. This is done by setting various variables the
 
 A sample is
 
-    #ifndef CONFIG_USER_H
-    #define CONFIG_USER_H
+```c
+#pragma once
 
-    #include "../../config.h"
-
-    #define AUTO_SHIFT_TIMEOUT 150
-    #define NO_AUTO_SHIFT_SPECIAL
-
-    #endif
+#define AUTO_SHIFT_TIMEOUT 150
+#define NO_AUTO_SHIFT_SPECIAL
+```
 
 ### AUTO_SHIFT_TIMEOUT (Value in ms)
 

docs/feature_backlight.md

@@ -6,16 +6,14 @@ QMK is able to control the brightness of these LEDs by switching them on and off
 
 The MCU can only supply so much current to its GPIO pins. Instead of powering the backlight directly from the MCU, the backlight pin is connected to a transistor or MOSFET that switches the power to the LEDs.
 
-## Driver configuration
+## Feature Configuration
 
 Most keyboards have backlighting enabled by default if they support it, but if it is not working for you, check that your `rules.mk` includes the following:
 
 ```makefile
-BACKLIGHT_ENABLE = software # Valid driver values are 'yes,software,no'
+BACKLIGHT_ENABLE = yes
 ```
 
-See below for help on individual drivers.
-
 ## Keycodes
 Once enabled the following keycodes below can be used to change the backlight level.
 
@@ -51,6 +49,16 @@ Once enabled the following keycodes below can be used to change the backlight le
 |`breathing_enable()`  |Turns on backlight breathing           |
 |`breathing_disable()` |Turns off backlight breathing          |
 
+## Driver Configuration
+
+To select which driver to use, configure your `rules.mk` with the following:
+
+```makefile
+BACKLIGHT_DRIVER = software # Valid driver values are 'pwm,software,no'
+```
+
+See below for help on individual drivers.
+
 ## Common Driver Configuration
 
 To change the behavior of the backlighting, `#define` these in your `config.h`:
@@ -72,9 +80,9 @@ This functionality is configured at the keyboard level with the `BACKLIGHT_ON_ST
 
 ## AVR driver
 
-On AVR boards, the default driver currently sniffs the configuration to pick the best scenario. To enable it, add this to your rules.mk:
+On AVR boards, the default driver currently sniffs the configuration to pick the best scenario. The driver is configured by default, however the equivalent setting within rules.mk would be:
 ```makefile
-BACKLIGHT_ENABLE = yes
+BACKLIGHT_DRIVER = pwm
 ```
 
 ### Caveats
@@ -150,9 +158,9 @@ The breathing effect is the same as in the hardware PWM implementation.
 
 ## ARM Driver
 
-While still in its early stages, ARM backlight support aims to eventually have feature parity with AVR. To enable it, add this to your rules.mk:
+While still in its early stages, ARM backlight support aims to eventually have feature parity with AVR. The driver is configured by default, however the equivalent setting within rules.mk would be:
 ```makefile
-BACKLIGHT_ENABLE = yes
+BACKLIGHT_DRIVER = pwm
 ```
 
 ### Caveats
@@ -176,7 +184,7 @@ To change the behavior of the backlighting, `#define` these in your `config.h`:
 
 Emulation of PWM while running other keyboard tasks, it offers maximum hardware compatibility without extra platform configuration. The tradeoff is the backlight might jitter when the keyboard is busy. To enable, add this to your rules.mk:
 ```makefile
-BACKLIGHT_ENABLE = software
+BACKLIGHT_DRIVER = software
 ```
 
 ### Software PWM Configuration
@@ -200,3 +208,29 @@ To activate multiple backlight pins, you need to add something like this to your
 #undef BACKLIGHT_PIN
 #define BACKLIGHT_PINS { F5, B2 }
 ```
+
+## Custom Driver
+
+To enable, add this to your rules.mk:
+
+```makefile
+BACKLIGHT_DRIVER = custom
+```
+
+When implementing the custom driver API, the provided keyboard hooks are as follows:
+
+```c
+void backlight_init_ports(void) {
+    // Optional - Run on startup
+    //          - usually you want to configure pins here
+}
+void backlight_set(uint8_t level) {
+    // Optional - Run on level change
+    //          - usually you want to respond to the new value
+}
+
+void backlight_task(void) {
+    // Optional - Run periodically
+    //          - long running actions here can cause performance issues
+}
+```

docs/feature_bootmagic.md

@@ -56,37 +56,37 @@ Hold down the Bootmagic key (Space by default) and the desired hotkey while plug
 
 ## Keycodes
 
-|Keycode                           |Aliases  |Description                               |
-|----------------------------------|---------|------------------------------------------|
-|`MAGIC_CAPSLOCK_TO_CONTROL`       |         |Treat Caps Lock as Left Control           |
-|`MAGIC_UNCAPSLOCK_TO_CONTROL`     |         |Stop treating Caps Lock as Left Control   |
-|`MAGIC_HOST_NKRO`                 |         |Force N-Key Rollover (NKRO) on            |
-|`MAGIC_UNHOST_NKRO`               |         |Force NKRO off                            |
-|`MAGIC_TOGGLE_NKRO`               |         |Turn NKRO on or off                       |
-|`MAGIC_NO_GUI`                    |         |Disable the GUI keys (useful when gaming) |
-|`MAGIC_UNNO_GUI`                  |         |Enable the GUI keys                       |
-|`MAGIC_SWAP_ALT_GUI`              |`AG_SWAP`|Swap Alt and GUI on both sides (for macOS)|
-|`MAGIC_UNSWAP_ALT_GUI`            |`AG_NORM`|Unswap Alt and GUI                        |
-|`MAGIC_TOGGLE_ALT_GUI`            |`AG_TOGG`|Toggle Alt and GUI swap                   |
-|`MAGIC_SWAP_CTL_GUI`              |`CG_SWAP`|Swap Ctrl and GUI on both sides (for macOS)|
-|`MAGIC_UNSWAP_CTL_GUI`            |`CG_NORM`|Unswap Ctrl and GUI                       |
-|`MAGIC_TOGGLE_CTL_GUI`            |`CG_TOGG`|Toggle Ctrl and GUI swap                  |
-|`MAGIC_SWAP_BACKSLASH_BACKSPACE`  |         |Swap `\` and Backspace                    |
-|`MAGIC_UNSWAP_BACKSLASH_BACKSPACE`|         |Unswap `\` and Backspace                  |
-|`MAGIC_SWAP_CONTROL_CAPSLOCK`     |         |Swap Left Control and Caps Lock           |
-|`MAGIC_UNSWAP_CONTROL_CAPSLOCK`   |         |Unswap Left Control and Caps Lock         |
-|`MAGIC_SWAP_GRAVE_ESC`            |         |Swap <code>&#96;</code> and Escape        |
-|`MAGIC_UNSWAP_GRAVE_ESC`          |         |Unswap <code>&#96;</code> and Escape      |
-|`MAGIC_SWAP_LALT_LGUI`            |         |Swap Left Alt and Left GUI                |
-|`MAGIC_UNSWAP_LALT_LGUI`          |         |Unswap Left Alt and Left GUI              |
-|`MAGIC_SWAP_RALT_RGUI`            |         |Swap Right Alt and Right GUI              |
-|`MAGIC_UNSWAP_RALT_RGUI`          |         |Unswap Right Alt and Right GUI            |
-|`MAGIC_SWAP_LCTL_LGUI`            |         |Swap Left Control and Left GUI            |
-|`MAGIC_UNSWAP_LCTL_LGUI`          |         |Unswap Left Control and Left GUI          |
-|`MAGIC_SWAP_RCTL_RGUI`            |         |Swap Right Control and Right GUI          |
-|`MAGIC_UNSWAP_RCTL_RGUI`          |         |Unswap Right Control and Right GUI        |
-|`MAGIC_EE_HANDS_LEFT`             |         |Set "Left Hand" for EE_HANDS handedness   |
-|`MAGIC_EE_HANDS_RIGHT`            |         |Set "Right Hand" for EE_HANDS handedness  |
+|Key                               |Aliases  |Description                                                               |
+|----------------------------------|---------|--------------------------------------------------------------------------|
+|`MAGIC_SWAP_CONTROL_CAPSLOCK`     |`CL_SWAP`|Swap Caps Lock and Left Control                                           |
+|`MAGIC_UNSWAP_CONTROL_CAPSLOCK`   |`CL_NORM`|Unswap Caps Lock and Left Control                                         |
+|`MAGIC_CAPSLOCK_TO_CONTROL`       |`CL_CTRL`|Treat Caps Lock as Control                                                |
+|`MAGIC_UNCAPSLOCK_TO_CONTROL`     |`CL_CAPS`|Stop treating Caps Lock as Control                                        |
+|`MAGIC_SWAP_LCTL_LGUI`            |`LCG_SWP`|Swap Left Control and GUI                                                 |
+|`MAGIC_UNSWAP_LCTL_LGUI`          |`LCG_NRM`|Unswap Left Control and GUI                                               |
+|`MAGIC_SWAP_RCTL_RGUI`            |`RCG_SWP`|Swap Right Control and GUI                                                |
+|`MAGIC_UNSWAP_RCTL_RGUI`          |`RCG_NRM`|Unswap Right Control and GUI                                              |
+|`MAGIC_SWAP_CTL_GUI`              |`CG_SWAP`|Swap Control and GUI on both sides                                        |
+|`MAGIC_UNSWAP_CTL_GUI`            |`CG_NORM`|Unswap Control and GUI on both sides                                      |
+|`MAGIC_TOGGLE_CTL_GUI`            |`CG_TOGG`|Toggle Control and GUI swap on both sides                                 |
+|`MAGIC_SWAP_LALT_LGUI`            |`LAG_SWP`|Swap Left Alt and GUI                                                     |
+|`MAGIC_UNSWAP_LALT_LGUI`          |`LAG_NRM`|Unswap Left Alt and GUI                                                   |
+|`MAGIC_SWAP_RALT_RGUI`            |`RAG_SWP`|Swap Right Alt and GUI                                                    |
+|`MAGIC_UNSWAP_RALT_RGUI`          |`RAG_NRM`|Unswap Right Alt and GUI                                                  |
+|`MAGIC_SWAP_ALT_GUI`              |`AG_SWAP`|Swap Alt and GUI on both sides                                            |
+|`MAGIC_UNSWAP_ALT_GUI`            |`AG_NORM`|Unswap Alt and GUI on both sides                                          |
+|`MAGIC_TOGGLE_ALT_GUI`            |`AG_TOGG`|Toggle Alt and GUI swap on both sides                                     |
+|`MAGIC_NO_GUI`                    |`GUI_OFF`|Disable the GUI keys                                                      |
+|`MAGIC_UNNO_GUI`                  |`GUI_ON` |Enable the GUI keys                                                       |
+|`MAGIC_SWAP_GRAVE_ESC`            |`GE_SWAP`|Swap <code>&#96;</code> and Escape                                        |
+|`MAGIC_UNSWAP_GRAVE_ESC`          |`GE_NORM`|Unswap <code>&#96;</code> and Escape                                      |
+|`MAGIC_SWAP_BACKSLASH_BACKSPACE`  |`BS_SWAP`|Swap `\` and Backspace                                                    |
+|`MAGIC_UNSWAP_BACKSLASH_BACKSPACE`|`BS_NORM`|Unswap `\` and Backspace                                                  |
+|`MAGIC_HOST_NKRO`                 |`NK_ON`  |Enable N-key rollover                                                     |
+|`MAGIC_UNHOST_NKRO`               |`NK_OFF` |Disable N-key rollover                                                    |
+|`MAGIC_TOGGLE_NKRO`               |`NK_TOGG`|Toggle N-key rollover                                                     |
+|`MAGIC_EE_HANDS_LEFT`             |`EH_LEFT`|Set the master half of a split keyboard as the left hand (for `EE_HANDS`) |
+|`MAGIC_EE_HANDS_RIGHT`            |`EH_RGHT`|Set the master half of a split keyboard as the right hand (for `EE_HANDS`)|
 
 ## Configuration
 

docs/feature_debounce_type.md

@@ -17,14 +17,14 @@ endif
 | DEBOUNCE_TYPE    | Description                                          | What else is needed           |
 | -------------    | ---------------------------------------------------  | ----------------------------- |
 | Not defined      | Use the default algorithm, currently sym_g           | Nothing                       |
-| custom           | Use your own debounce.c                              | ```SRC += debounce.c``` add your own debounce.c and implement necessary functions |
+| custom           | Use your own debounce code                           | ```SRC += debounce.c``` add your own debounce.c and implement necessary functions |
 | anything_else    | Use another algorithm from quantum/debounce/*        | Nothing                       |
 
 **Regarding split keyboards**:
 The debounce code is compatible with split keyboards.
 
 # Use your own debouncing code
-* Set ```DEBOUNCE_TYPE = custom ```.
+* Set ```DEBOUNCE_TYPE = custom```.
 * Add ```SRC += debounce.c```
 * Add your own ```debounce.c```. Look at current implementations in ```quantum/debounce``` for examples.
 * Debouncing occurs after every raw matrix scan.
@@ -33,10 +33,10 @@ The debounce code is compatible with split keyboards.
 # Changing between included debouncing methods
 You can either use your own code, by including your own debounce.c, or switch to another included one.
 Included debounce methods are:
-* eager_pr - debouncing per row. On any state change, response is immediate, followed by locking the row ```DEBOUNCE_DELAY``` milliseconds of no further input for that row. 
+* eager_pr - debouncing per row. On any state change, response is immediate, followed by locking the row ```DEBOUNCE``` milliseconds of no further input for that row. 
 For use in keyboards where refreshing ```NUM_KEYS``` 8-bit counters is computationally expensive / low scan rate, and fingers usually only hit one row at a time. This could be
 appropriate for the ErgoDox models; the matrix is rotated 90°, and hence its "rows" are really columns, and each finger only hits a single "row" at a time in normal use.
-* eager_pk - debouncing per key. On any state change, response is immediate, followed by ```DEBOUNCE_DELAY``` milliseconds of no further input for that key
-* sym_g - debouncing per keyboard. On any state change, a global timer is set. When ```DEBOUNCE_DELAY``` milliseconds of no changes has occured, all input changes are pushed.
+* eager_pk - debouncing per key. On any state change, response is immediate, followed by ```DEBOUNCE``` milliseconds of no further input for that key
+* sym_g - debouncing per keyboard. On any state change, a global timer is set. When ```DEBOUNCE``` milliseconds of no changes has occured, all input changes are pushed.
 
 

docs/feature_dynamic_macros.md

@@ -4,51 +4,45 @@ QMK supports temporary macros created on the fly. We call these Dynamic Macros.
 
 You can store one or two macros and they may have a combined total of 128 keypresses. You can increase this size at the cost of RAM.
 
-To enable them, first add a new element to the end of your `keycodes` enum — `DYNAMIC_MACRO_RANGE`:
+To enable them, first include `DYNAMIC_MACRO_ENABLE = yes` in your `rules.mk`. Then, add the following keys to your keymap:
 
-```c
-enum keycodes {
-	QWERTY = SAFE_RANGE,
-	COLEMAK,
-	DVORAK,
-	PLOVER,
-	LOWER,
-	RAISE,
-	BACKLIT,
-	EXT_PLV,
-	DYNAMIC_MACRO_RANGE,
-};
-```
+|Key               |Alias     |Description                                        |
+|------------------|----------|---------------------------------------------------|
+|`DYN_REC_START1`  |`DM_REC1` |Start recording Macro 1                            |
+|`DYN_REC_START2`  |`DM_REC2` |Start recording Macro 2                            |
+|`DYN_MACRO_PLAY1` |`DM_PLY1` |Replay Macro 1                                     |
+|`DYN_MACRO_PLAY2` |`DM_PLY2` |Replay Macro 2                                     |
+|`DYN_REC_STOP`    |`DM_RSTP` |Finish the macro that is currently being recorded. |
 
-Your `keycodes` enum may have a slightly different name. You must add `DYNAMIC_MACRO_RANGE` as the last element because `dynamic_macros.h` will add some more keycodes after it.
+That should be everything necessary. 
 
-Below it, include the `dynamic_macro.h` header:
+To start recording the macro, press either `DYN_REC_START1` or `DYN_REC_START2`. 
 
-```c
-	#include "dynamic_macro.h"`
-```
+To finish the recording, press the `DYN_REC_STOP` layer button. 
 
-Add the following keys to your keymap:
+To replay the macro, press either `DYN_MACRO_PLAY1` or `DYN_MACRO_PLAY2`.
 
-* `DYN_REC_START1` — start recording the macro 1,
-* `DYN_REC_START2` — start recording the macro 2,
-* `DYN_MACRO_PLAY1` — replay the macro 1,
-* `DYN_MACRO_PLAY2` — replay the macro 2,
-* `DYN_REC_STOP` — finish the macro that is currently being recorded.
+It is possible to replay a macro as part of a macro. It's ok to replay macro 2 while recording macro 1 and vice versa but never create recursive macros i.e. macro 1 that replays macro 1. If you do so and the keyboard will get unresponsive, unplug the keyboard and plug it again.  You can disable this completly by defining `DYNAMIC_MACRO_NO_NESTING`  in your `config.h` file.
 
-Add the following code to the very beginning of your `process_record_user()` function:
+?> For the details about the internals of the dynamic macros, please read the comments in the `process_dynamic_macro.h` and `process_dynamic_macro.c` files.
 
-```c
-	if (!process_record_dynamic_macro(keycode, record)) {
-		return false;
-	}
-```
+## Customization 
 
-That should be everything necessary. To start recording the macro, press either `DYN_REC_START1` or `DYN_REC_START2`. To finish the recording, press the `DYN_REC_STOP` layer button. To replay the macro, press either `DYN_MACRO_PLAY1` or `DYN_MACRO_PLAY2`.
+There are a number of options added that should allow some additional degree of customization
 
-Note that it's possible to replay a macro as part of a macro. It's ok to replay macro 2 while recording macro 1 and vice versa but never create recursive macros i.e. macro 1 that replays macro 1. If you do so and the keyboard will get unresponsive, unplug the keyboard and plug it again.
+|Define                      |Default         |Description                                                                                                      |
+|----------------------------|----------------|-----------------------------------------------------------------------------------------------------------------|
+|`DYNAMIC_MACRO_SIZE`        |128             |Sets the amount of memory that Dynamic Macros can use. This is a limited resource, dependent on the controller.  |
+|`DYNAMIC_MACRO_USER_CALL`   |*Not defined*   |Defining this falls back to using the user `keymap.c` file to trigger the macro behavior.                        |
+|`DYNAMIC_MACRO_NO_NESTING`  |*Not Defined*   |Defining this disables the ability to call a macro from another macro (nested macros).                           | 
 
-For users of the earlier versions of dynamic macros: It is still possible to finish the macro recording using just the layer modifier used to access the dynamic macro keys, without a dedicated `DYN_REC_STOP` key. If you want this behavior back, use the following snippet instead of the one above:
+
+If the LEDs start blinking during the recording with each keypress, it means there is no more space for the macro in the macro buffer. To fit the macro in, either make the other macro shorter (they share the same buffer) or increase the buffer size by adding the `DYNAMIC_MACRO_SIZE` define in your `config.h` (default value: 128; please read the comments for it in the header).
+
+
+### DYNAMIC_MACRO_USER_CALL
+
+For users of the earlier versions of dynamic macros: It is still possible to finish the macro recording using just the layer modifier used to access the dynamic macro keys, without a dedicated `DYN_REC_STOP` key. If you want this behavior back, add `#define DYNAMIC_MACRO_USER_CALL` to your `config.h` and insert the following snippet at the beginning of your `process_record_user()` function:
 
 ```c
 	uint16_t macro_kc = (keycode == MO(_DYN) ? DYN_REC_STOP : keycode);
@@ -58,6 +52,15 @@ For users of the earlier versions of dynamic macros: It is still possible to fin
 	}
 ```
 
-If the LEDs start blinking during the recording with each keypress, it means there is no more space for the macro in the macro buffer. To fit the macro in, either make the other macro shorter (they share the same buffer) or increase the buffer size by setting the `DYNAMIC_MACRO_SIZE` preprocessor macro (default value: 128; please read the comments for it in the header).
+### User Hooks
 
-For the details about the internals of the dynamic macros, please read the comments in the `dynamic_macro.h` header.
+There are a number of hooks that you can use to add custom functionality and feedback options to Dynamic Macro feature.  This allows for some additional degree of customization. 
+
+Note, that direction indicates which macro it is, with `1` being Macro 1, `-1` being Macro 2, and 0 being no macro. 
+
+* `dynamic_macro_record_start_user(void)` - Triggered when you start recording a macro.
+* `dynamic_macro_play_user(int8_t direction)` - Triggered when you play back a macro.
+* `dynamic_macro_record_key_user(int8_t direction, keyrecord_t *record)` - Triggered on each keypress while recording a macro.
+* `dynamic_macro_record_end_user(int8_t direction)` - Triggered when the macro recording is stopped. 
+
+Additionally, you can call `dynamic_macro_led_blink()` to flash the backlights if that feature is enabled. 

docs/feature_haptic_feedback.md

@@ -2,7 +2,7 @@
 
 ## Haptic feedback rules.mk options
 
-The following options are currently available for haptic feedback in `rule.mk`:
+The following options are currently available for haptic feedback in `rules.mk`:
 
 `HAPTIC_ENABLE += DRV2605L`
 
@@ -41,11 +41,15 @@ First you will need a build a circuit to drive the solenoid through a mosfet as
 
 [Wiring diagram provided by Adafruit](https://playground.arduino.cc/uploads/Learning/solenoid_driver.pdf)
 
-Select a pin that has PWM for the signal pin
 
-```
-#define SOLENOID_PIN *pin*
-```
+| Settings                 | Default       | Description                                           |
+|--------------------------|---------------|-------------------------------------------------------|
+|`SOLENOID_PIN`            | *Not defined* |Configures the pin that the Solenoid is connected to.  |
+|`SOLENOID_DEFAULT_DWELL`  | `12` ms       |Configures the default dwell time for the solenoid.    |
+|`SOLENOID_MIN_DWELL`      | `4` ms        |Sets the lower limit for the dwell.                    |
+|`SOLENOID_MAX_DWELL`      | `100` ms      |Sets the upper limit for the dwell.                    |
+
+?> Dwell time is how long the "plunger" stays activated.  The dwell time changes how the solenoid sounds.
 
 Beware that some pins may be powered during bootloader (ie. A13 on the STM32F303 chip) and will result in the solenoid kept in the on state through the whole flashing process. This may overheat and damage the solenoid. If you find that the pin the solenoid is connected to is triggering the solenoid during bootloader/DFU, select another pin.
 
@@ -151,4 +155,4 @@ This will set what sequence HPT_RST will set as the active mode. If not defined,
 
 ### DRV2605L Continuous Haptic Mode
 
-This mode sets continuous haptic feedback with the option to increase or decrease strength. 
+This mode sets continuous haptic feedback with the option to increase or decrease strength. 

docs/feature_leader_key.md

@@ -22,10 +22,10 @@ void matrix_scan_user(void) {
       SEND_STRING("QMK is awesome.");
     }
     SEQ_TWO_KEYS(KC_D, KC_D) {
-      SEND_STRING(SS_LCTRL("a")SS_LCTRL("c"));
+      SEND_STRING(SS_LCTL("a") SS_LCTL("c"));
     }
     SEQ_THREE_KEYS(KC_D, KC_D, KC_S) {
-      SEND_STRING("https://start.duckduckgo.com"SS_TAP(X_ENTER));
+      SEND_STRING("https://start.duckduckgo.com\n");
     }
     SEQ_TWO_KEYS(KC_A, KC_S) {
       register_code(KC_LGUI);
@@ -115,11 +115,11 @@ void matrix_scan_user(void) {
 
     SEQ_ONE_KEY(KC_E) {
       // Anything you can do in a macro.
-      SEND_STRING(SS_LCTRL(SS_LSFT("t")));
+      SEND_STRING(SS_LCTL(SS_LSFT("t")));
       did_leader_succeed = true;
     } else 
     SEQ_TWO_KEYS(KC_E, KC_D) {
-      SEND_STRING(SS_LGUI("r")"cmd"SS_TAP(KC_ENTER)SS_LCTRL("c"));
+      SEND_STRING(SS_LGUI("r") "cmd\n" SS_LCTL("c"));
       did_leader_succeed = true;
     }
     leader_end();

docs/feature_macros.md

@@ -67,14 +67,14 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
     case QMKURL:
       if (record->event.pressed) {
         // when keycode QMKURL is pressed
-        SEND_STRING("https://qmk.fm/" SS_TAP(X_ENTER));
+        SEND_STRING("https://qmk.fm/\n");
       } else {
         // when keycode QMKURL is released
       }
       break;
     case MY_OTHER_MACRO:
       if (record->event.pressed) {
-                SEND_STRING(SS_LCTRL("ac")); // selects all and copies
+                SEND_STRING(SS_LCTL("ac")); // selects all and copies
       }
       break;
   }
@@ -109,18 +109,21 @@ Which would send "VE" followed by a `KC_HOME` tap, and "LO" (spelling "LOVE" if
 
 There's also a couple of mod shortcuts you can use:
 
-* `SS_LCTRL(string)`
-* `SS_LGUI(string)`
-* `SS_LALT(string)`
+* `SS_LCTL(string)`
 * `SS_LSFT(string)`
-* `SS_RALT(string)`
+* `SS_LALT(string)`
+* `SS_LGUI(string)`, `SS_LCMD(string)` or `SS_LWIN(string)`
+* `SS_RCTL(string)`
+* `SS_RSFT(string)`
+* `SS_RALT(string)` or `SS_ALGR(string)`
+* `SS_RGUI(string)`, `SS_RCMD(string)` or `SS_RWIN(string)`
 
 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"));
+    SEND_STRING(SS_LCTL("a"));
 
-Which would send LCTRL+a (LCTRL down, a, LCTRL up) - notice that they take strings (eg `"k"`), and not the `X_K` keycodes.
+Which would send Left Control+`a` (Left Control down, `a`, Left Control up) - notice that they take strings (eg `"k"`), and not the `X_K` keycodes.
 
 ### Alternative Keymaps
 

docs/feature_oled_driver.md

@@ -229,6 +229,12 @@ void oled_write_P(const char *data, bool invert);
 // Remapped to call 'void oled_write_ln(const char *data, bool invert);' on ARM
 void oled_write_ln_P(const char *data, bool invert);
 
+// Writes a string to the buffer at current cursor position
+void oled_write_raw(const char *data, uint16_t size);
+
+// Writes a PROGMEM string to the buffer at current cursor position
+void oled_write_raw_P(const char *data, uint16_t size);
+
 // Can be used to manually turn on the screen if it is off
 // Returns true if the screen was on or turns on
 bool oled_on(void);

docs/feature_rgb_matrix.md

@@ -107,7 +107,7 @@ Where `X_Y` is the location of the LED in the matrix defined by [the datasheet](
 
 ---
 
-### WS2812 (AVR only)
+### WS2812
 
 There is basic support for addressable RGB matrix lighting with a WS2811/WS2812{a,b,c} addressable LED strand. To enable it, add this to your `rules.mk`:
 
@@ -173,16 +173,20 @@ As mentioned earlier, the center of the keyboard by default is expected to be `{
 
 All RGB keycodes are currently shared with the RGBLIGHT system:
 
-* `RGB_TOG` - toggle
-* `RGB_MOD` - cycle through modes
-* `RGB_HUI` - increase hue
-* `RGB_HUD` - decrease hue
-* `RGB_SAI` - increase saturation
-* `RGB_SAD` - decrease saturation
-* `RGB_VAI` - increase value
-* `RGB_VAD` - decrease value
-* `RGB_SPI` - increase speed effect (no EEPROM support)
-* `RGB_SPD` - decrease speed effect (no EEPROM support)
+|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, decrease hue when Shift is held                                         |
+|`RGB_HUD`          |          |Decrease hue, increase hue when Shift is held                                         |
+|`RGB_SAI`          |          |Increase saturation, decrease saturation when Shift is held                           |
+|`RGB_SAD`          |          |Decrease saturation, increase saturation when Shift is held                           |
+|`RGB_VAI`          |          |Increase value (brightness), decrease value when Shift is held                        |
+|`RGB_VAD`          |          |Decrease value (brightness), increase value when Shift is held                        |
+|`RGB_SPI`          |          |Increase effect speed (does not support eeprom yet), decrease speed when Shift is held|
+|`RGB_SPD`          |          |Decrease effect speed (does not support eeprom yet), increase speed when Shift is held|
+
 * `RGB_MODE_*` keycodes will generally work, but are not currently mapped to the correct effects for the RGB Matrix system
 
 ## RGB Matrix Effects
@@ -282,7 +286,7 @@ You can disable a single effect by defining `DISABLE_[EFFECT_NAME]` in your `con
 
 ## Custom RGB Matrix Effects
 
-By setting `RGB_MATRIX_CUSTOM_USER` (and/or `RGB_MATRIX_CUSTOM_KB`) in `rule.mk`, new effects can be defined directly from userspace, without having to edit any QMK core files.
+By setting `RGB_MATRIX_CUSTOM_USER` (and/or `RGB_MATRIX_CUSTOM_KB`) in `rules.mk`, new effects can be defined directly from userspace, without having to edit any QMK core files.
 
 To declare new effects, create a new `rgb_matrix_user/kb.inc` that looks something like this:
 

docs/feature_rgblight.md

@@ -6,7 +6,7 @@ QMK has the ability to control RGB LEDs attached to your keyboard. This is commo
 
 Some keyboards come with RGB LEDs preinstalled. Others must have them installed after the fact. See the [Hardware Modification](#hardware-modification) section for information on adding RGB lighting to your keyboard.
 
-Currently QMK supports the following addressable LEDs on AVR microcontrollers (however, the white LED in RGBW variants is not supported):
+Currently QMK supports the following addressable LEDs (however, the white LED in RGBW variants is not supported):
 
  * WS2811, WS2812, WS2812B, WS2812C, etc.
  * SK6812, SK6812MINI, SK6805
@@ -48,12 +48,12 @@ Changing the **Value** sets the overall brightness.<br>
 |`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_HUI`          |          |Increase hue, decrease hue when Shift is held                       |
+|`RGB_HUD`          |          |Decrease hue, increase hue when Shift is held                       |
+|`RGB_SAI`          |          |Increase saturation, decrease saturation when Shift is held         |
+|`RGB_SAD`          |          |Decrease saturation, increase saturation when Shift is held         |
+|`RGB_VAI`          |          |Increase value (brightness), decrease value when Shift is held      |
+|`RGB_VAD`          |          |Decrease value (brightness), increase value when Shift is held      |
 |`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                                              |
@@ -363,8 +363,8 @@ Using the `rgblight_set_clipping_range()` function, you can prepare more buffers
 You can set the Clipping Range by executing the following code.
 
 ```c
-// some soruce
-  rgblight_set_clipping_range(3, 4);
+// some source
+rgblight_set_clipping_range(3, 4);
 ```
 <img src="https://user-images.githubusercontent.com/2170248/55743785-2bd82a00-5a6e-11e9-9d4b-1b4ffaf4932b.JPG" alt="clip direct" width="70%"/>
 

docs/feature_tap_dance.md

@@ -333,6 +333,8 @@ And then simply use `TD(X_CTL)` anywhere in your keymap.
 
 If you want to implement this in your userspace, then you may want to check out how [DanielGGordon](https://github.com/qmk/qmk_firmware/tree/master/users/gordon) has implemented this in their userspace.
 
+> In this configuration "hold" takes place **after** tap dance timeout (see `ACTION_TAP_DANCE_FN_ADVANCED_TIME`). To achieve instant hold, remove `state->interrupted` checks in conditions. As a result you may use comfortable longer tapping periods to have more time for taps and not to wait too long for holds (try starting with doubled `TAPPING_TERM`).
+
 ### Example 5: Using tap dance for advanced mod-tap and layer-tap keys
 
 Tap dance can be used to emulate `MT()` and `LT()` behavior when the tapped code is not a basic keycode. This is useful to send tapped keycodes that normally require `Shift`, such as parentheses or curly braces—or other modified keycodes, such as `Control + X`.

docs/feature_userspace.md

@@ -208,15 +208,15 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
             clear_mods(); clear_oneshot_mods();
             SEND_STRING("make " QMK_KEYBOARD ":" QMK_KEYMAP);
     #ifndef FLASH_BOOTLOADER
-            if ( (temp_mod | temp_osm) & MOD_MASK_SHIFT ) 
+            if ((temp_mod | temp_osm) & MOD_MASK_SHIFT)
     #endif
-            { // 
+            {
                 SEND_STRING(":flash");
             }
-            if ( (temp_mod | temp_osm) & MOD_MASK_CTRL) { 
-                SEND_STRING(" -j8 --output-sync"); 
+            if ((temp_mod | temp_osm) & MOD_MASK_CTRL) {
+                SEND_STRING(" -j8 --output-sync");
             }
-            SEND_STRING(SS_TAP(X_ENTER));
+            tap_code(KC_ENT);
             set_mods(temp_mod);
         }
         break;

docs/flashing_bootloadhid.md

@@ -13,7 +13,7 @@ General flashing sequence:
 
 ## bootloadHID Flashing Target
 
-Using the QMK installation script, detailed [here](newbs_getting_started.md), the required bootloadHID tools should be automatically installed.
+?> Using the QMK installation script, detailed [here](newbs_getting_started.md), the required bootloadHID tools should be automatically installed.
 
 To flash via the command line, use the target `:bootloadHID` by executing the following command:
 

docs/fr-FR/_summary.md

@@ -1,125 +0,0 @@
-**En Français**
-
-* [Guide pour débutant complet](fr-FR/newbs.md)
-  * [Pour débuter](fr-FR/newbs_getting_started.md)
-  * [Compiler son premier firmware](fr-FR/newbs_building_firmware.md)
-  * [Flasher le Firmware](fr-FR/newbs_flashing.md)
-  * [Test et Débuggage](fr-FR/newbs_testing_debugging.md)
-  * [Bonnes pratiques Git](fr-FR/newbs_best_practices.md)
-  * [Ressources d'apprentissage](fr-FR/newbs_learn_more_resources.md)
-
-* [Les bases de QMK](fr-FR/README.md)
-  * [Indroduction à QMK](fr-FR/getting_started_introduction.md)
-  * [QMK CLI](fr-FR/cli.md)
-  * [Configuration de la CLI QMK](fr-FR/cli_configuration.md)
-  * [Contribuer à QMK](fr-FR/contributing.md)
-  * [Comment utiliser GitHub](fr-FR/getting_started_github.md)
-  * [Trouver de l'aide](fr-FR/getting_started_getting_help.md)
-
-* [Breaking changes](fr-FR/breaking_changes.md)
-  * [30 août 2019](fr-FR/ChangeLog/20190830.md)
-
-**En Anglais**
-
-* [FAQ](faq.md)
-  * [FAQ Générale](faq_general.md)
-  * [Compiler QMK](faq_build.md)
-  * [Débugguer / Dépanner QMK](faq_debug.md)
-  * [Keymap / Disposition](faq_keymap.md)
-  * [Installer les drivers avec Zadig](driver_installation_zadig.md)
-
-* Guides détaillés
-  * [Installation des outils de compilation](getting_started_build_tools.md)
-  * [Guide Vagrant](getting_started_vagrant.md)
-  * [Commandes de compilations](getting_started_make_guide.md)
-  * [Flasher les firmwares](fr-fr/flashing.md)
-  * [Personnaliser les fonctionnalités](custom_quantum_functions.md)
-  * [Aperçu des fonctionnalités des dispositions](keymap.md)
-
-* [Hardware](hardware.md)
-  * [Processeurs AVR](hardware_avr.md)
-  * [Pilotes / Drivers](hardware_drivers.md)
-
-* Réferences
-  * [Lignes de conduite des claviers](hardware_keyboard_guidelines.md)
-  * [Options de configurations](config_options.md)
-  * [Keycodes / Codes des caractères](keycodes.md)
-  * [Conventions de codage - C](coding_conventions_c.md)
-  * [Conventions de codage - Python](coding_conventions_python.md)
-  * [Meilleurs pratiques sur la documentation](documentation_best_practices.md)
-  * [Modèles de documentation](documentation_templates.md)
-  * [Glossaire](reference_glossary.md)
-  * [Tests unitaires](unit_testing.md)
-  * [Fonctions utiles](ref_functions.md)
-  * [Support de configuration](reference_configurator_support.md)
-  * [Format du fichier info.json](reference_info_json.md)
-  * [Développer la CLI en Python](cli_development.md)
-
-* [Fonctionnalités](features.md)
-  * [Keycodes basiques](keycodes_basic.md)
-  * [Touches utilisées avec Shift (US ANSI)](keycodes_us_ansi_shifted.md)
-  * [Keycodes quantiques](quantum_keycodes.md)
-  * [Keycodes avancés](feature_advanced_keycodes.md)
-  * [Fonctionnalités audio](feature_audio.md)
-  * [Majuscule automatique](feature_auto_shift.md)
-  * [Rétroéclairage](feature_backlight.md)
-  * [Bluetooth](feature_bluetooth.md)
-  * [Bootmagic](feature_bootmagic.md)
-  * [Combos](feature_combo.md)
-  * [Commande](feature_command.md)
-  * [API anti-rebond](feature_debounce_type.md)
-  * [DIP Switch](feature_dip_switch.md)
-  * [Macros dynamiques](feature_dynamic_macros.md)
-  * [Interrupteurs rotatifs](feature_encoders.md)
-  * [Grave Escape](feature_grave_esc.md)
-  * [Retour haptique](feature_haptic_feedback.md)
-  * [Contrôleur LCD HD44780](feature_hd44780.md)
-  * [Touche à verrou / Lock-key](feature_key_lock.md)
-  * [Dispositions / layouts](feature_layouts.md)
-  * [Touche leader](feature_leader_key.md)
-  * [Matrice LED](feature_led_matrix.md)
-  * [Macros](feature_macros.md)
-  * [Boutons de souris](feature_mouse_keys.md)
-  * [Pilotes / Drivers OLED](feature_oled_driver.md)
-  * [Touche one-shot](feature_advanced_keycodes.md#one-shot-keys)
-  * [Périphériques de pointage](feature_pointing_device.md)
-  * [Souris PS/2](feature_ps2_mouse.md)
-  * [Éclairage RGB](feature_rgblight.md)
-  * [Matrice RGB](feature_rgb_matrix.md)
-  * [Space Cadet](feature_space_cadet.md)
-  * [Claviers scindés / splittés](feature_split_keyboard.md)
-  * [Stenographie](feature_stenography.md)
-  * [Inversion des mains](feature_swap_hands.md)
-  * [Tap Dance](feature_tap_dance.md)
-  * [Terminale](feature_terminal.md)
-  * [Imprimante thermique](feature_thermal_printer.md)
-  * [Caractères unicodes](feature_unicode.md)
-  * [Dossier utilisateur](feature_userspace.md)
-  * [Velocikey](feature_velocikey.md)
-
-* Pour les makers et les bricoleurs
-  * [Guide des claviers soudés à la main](hand_wire.md)
-  * [Guide de flash de l’ISP](isp_flashing_guide.md)
-  * [Guide du débogage ARM](arm_debugging.md)
-  * [Drivers i2c](i2c_driver.md)
-  * [Contrôles des GPIO](internals_gpio_control.md)
-  * [Conversion en Proton C](proton_c_conversion.md)
-
-* Pour aller plus loin
-  * [Comment fonctionnent les claviers](how_keyboards_work.md)
-  * [Comprendre QMK](understanding_qmk.md)
-
-* Autres sujets
-  * [Utiliser Eclipse avec QMK](other_eclipse.md)
-  * [Utiliser VSCode avec QMK](other_vscode.md)
-  * [Support](support.md)
-  * [Comment ajouter des traductions](translating.md)
-
-* À l’intérieur de QMK (En cours de documentation)
-  * [Définitions](internals_defines.md)
-  * [Input Callback Reg](internals_input_callback_reg.md)
-  * [Appareils Midi](internals_midi_device.md)
-  * [Installation d’un appareil Midi](internals_midi_device_setup_process.md)
-  * [Utilitaires Midi](internals_midi_util.md)
-  * [Fonctions Midi](internals_send_functions.md)
-  * [Outils Sysex](internals_sysex_tools.md)

docs/fr-fr/README.md

@@ -19,7 +19,7 @@ Sinon, vous pouvez aussi le télécharger directement en ([zip](https://github.c
 
 ## Comment le compiler
 
-Avant d'être prêt à compiler vous allez devoir [installer un environnement](getting_started_build_tools.md) pour les développements AVR et/ou ARM. Une fois ceci fait, vous pourrez utiliser la commande `make` pour compiler le clavier et la disposition avec une commande de ce type :
+Avant d'être prêt à compiler vous allez devoir [installer un environnement](fr-fr/getting_started_build_tools.md) pour les développements AVR et/ou ARM. Une fois ceci fait, vous pourrez utiliser la commande `make` pour compiler le clavier et la disposition avec une commande de ce type :
 
     make planck/rev4:default
 
@@ -29,4 +29,4 @@ Cette commande compilera la révision `rev4` du clavier `planck` avec la disposi
 
 ## Comment le personnaliser
 
-QMK a beaucoup de [fonctionnalités](features.md) à explorer, et [une documentation](http://docs.qmk.fm) très abondante que vous pourrez parcourir. La plupart des fonctionnalités vous permettrons de modifier vos [dispositions](keymap.md) (keymaps) et de changer [les codes de caractères](keycodes.md) (keycodes).
+QMK a beaucoup de [fonctionnalités](fr-fr/features.md) à explorer, et [une documentation](http://docs.qmk.fm) très abondante que vous pourrez parcourir. La plupart des fonctionnalités vous permettrons de modifier vos [dispositions](fr-fr/keymap.md) (keymaps) et de changer [les codes de caractères](fr-fr/keycodes.md) (keycodes).

docs/fr-fr/_summary.md

@@ -0,0 +1,125 @@
+**En Français**
+
+* [Guide pour débutant complet](fr-fr/newbs.md)
+  * [Pour débuter](fr-fr/newbs_getting_started.md)
+  * [Compiler son premier firmware](fr-fr/newbs_building_firmware.md)
+  * [Flasher le Firmware](fr-fr/newbs_flashing.md)
+  * [Test et Débuggage](fr-fr/newbs_testing_debugging.md)
+  * [Bonnes pratiques Git](fr-fr/newbs_best_practices.md)
+  * [Ressources d'apprentissage](fr-fr/newbs_learn_more_resources.md)
+
+* [Les bases de QMK](fr-fr/README.md)
+  * [Indroduction à QMK](fr-fr/getting_started_introduction.md)
+  * [QMK CLI](fr-fr/cli.md)
+  * [Configuration de la CLI QMK](fr-fr/cli_configuration.md)
+  * [Contribuer à QMK](fr-fr/contributing.md)
+  * [Comment utiliser GitHub](fr-fr/getting_started_github.md)
+  * [Trouver de l'aide](fr-fr/getting_started_getting_help.md)
+
+* [Breaking changes](fr-fr/breaking_changes.md)
+  * [30 août 2019](fr-fr/ChangeLog/20190830.md)
+
+* [FAQ](fr-fr/faq.md)
+  * [FAQ Générale](fr-fr/faq_general.md)
+  * [Compiler QMK](fr-fr/faq_build.md)
+  * [Débugguer / Dépanner QMK](fr-fr/faq_debug.md)
+  * [Keymap / Disposition](fr-fr/faq_keymap.md)
+  * [Installer les drivers avec Zadig](fr-fr/driver_installation_zadig.md)
+
+**En Anglais**
+
+* Guides détaillés
+  * [Installation des outils de compilation](fr-fr/getting_started_build_tools.md)
+  * [Guide Vagrant](fr-fr/getting_started_vagrant.md)
+  * [Commandes de compilations](fr-fr/getting_started_make_guide.md)
+  * [Flasher les firmwares](fr-fr/flashing.md)
+  * [Personnaliser les fonctionnalités](fr-fr/custom_quantum_functions.md)
+  * [Aperçu des fonctionnalités des dispositions](fr-fr/keymap.md)
+
+* [Hardware](fr-fr/hardware.md)
+  * [Processeurs AVR](fr-fr/hardware_avr.md)
+  * [Pilotes / Drivers](fr-fr/hardware_drivers.md)
+
+* Réferences
+  * [Lignes de conduite des claviers](fr-fr/hardware_keyboard_guidelines.md)
+  * [Options de configurations](fr-fr/config_options.md)
+  * [Keycodes / Codes des caractères](fr-fr/keycodes.md)
+  * [Conventions de codage - C](fr-fr/coding_conventions_c.md)
+  * [Conventions de codage - Python](fr-fr/coding_conventions_python.md)
+  * [Meilleurs pratiques sur la documentation](fr-fr/documentation_best_practices.md)
+  * [Modèles de documentation](fr-fr/documentation_templates.md)
+  * [Glossaire](fr-fr/reference_glossary.md)
+  * [Tests unitaires](fr-fr/unit_testing.md)
+  * [Fonctions utiles](fr-fr/ref_functions.md)
+  * [Support de configuration](fr-fr/reference_configurator_support.md)
+  * [Format du fichier info.json](fr-fr/reference_info_json.md)
+  * [Développer la CLI en Python](fr-fr/cli_development.md)
+
+* [Fonctionnalités](fr-fr/features.md)
+  * [Keycodes basiques](fr-fr/keycodes_basic.md)
+  * [Touches utilisées avec Shift (US ANSI)](fr-fr/keycodes_us_ansi_shifted.md)
+  * [Keycodes quantiques](fr-fr/quantum_keycodes.md)
+  * [Keycodes avancés](fr-fr/feature_advanced_keycodes.md)
+  * [Fonctionnalités audio](fr-fr/feature_audio.md)
+  * [Majuscule automatique](fr-fr/feature_auto_shift.md)
+  * [Rétroéclairage](fr-fr/feature_backlight.md)
+  * [Bluetooth](fr-fr/feature_bluetooth.md)
+  * [Bootmagic](fr-fr/feature_bootmagic.md)
+  * [Combos](fr-fr/feature_combo.md)
+  * [Commande](fr-fr/feature_command.md)
+  * [API anti-rebond](fr-fr/feature_debounce_type.md)
+  * [DIP Switch](fr-fr/feature_dip_switch.md)
+  * [Macros dynamiques](fr-fr/feature_dynamic_macros.md)
+  * [Interrupteurs rotatifs](fr-fr/feature_encoders.md)
+  * [Grave Escape](fr-fr/feature_grave_esc.md)
+  * [Retour haptique](fr-fr/feature_haptic_feedback.md)
+  * [Contrôleur LCD HD44780](fr-fr/feature_hd44780.md)
+  * [Touche à verrou / Lock-key](fr-fr/feature_key_lock.md)
+  * [Dispositions / layouts](fr-fr/feature_layouts.md)
+  * [Touche leader](fr-fr/feature_leader_key.md)
+  * [Matrice LED](fr-fr/feature_led_matrix.md)
+  * [Macros](fr-fr/feature_macros.md)
+  * [Boutons de souris](fr-fr/feature_mouse_keys.md)
+  * [Pilotes / Drivers OLED](fr-fr/feature_oled_driver.md)
+  * [Touche one-shot](fr-fr/feature_advanced_keycodes.md#one-shot-keys)
+  * [Périphériques de pointage](fr-fr/feature_pointing_device.md)
+  * [Souris PS/2](fr-fr/feature_ps2_mouse.md)
+  * [Éclairage RGB](fr-fr/feature_rgblight.md)
+  * [Matrice RGB](fr-fr/feature_rgb_matrix.md)
+  * [Space Cadet](fr-fr/feature_space_cadet.md)
+  * [Claviers scindés / splittés](fr-fr/feature_split_keyboard.md)
+  * [Stenographie](fr-fr/feature_stenography.md)
+  * [Inversion des mains](fr-fr/feature_swap_hands.md)
+  * [Tap Dance](fr-fr/feature_tap_dance.md)
+  * [Terminale](fr-fr/feature_terminal.md)
+  * [Imprimante thermique](fr-fr/feature_thermal_printer.md)
+  * [Caractères unicodes](fr-fr/feature_unicode.md)
+  * [Dossier utilisateur](fr-fr/feature_userspace.md)
+  * [Velocikey](fr-fr/feature_velocikey.md)
+
+* Pour les makers et les bricoleurs
+  * [Guide des claviers soudés à la main](fr-fr/hand_wire.md)
+  * [Guide de flash de l’ISP](fr-fr/isp_flashing_guide.md)
+  * [Guide du débogage ARM](fr-fr/arm_debugging.md)
+  * [Drivers i2c](fr-fr/i2c_driver.md)
+  * [Contrôles des GPIO](fr-fr/internals_gpio_control.md)
+  * [Conversion en Proton C](fr-fr/proton_c_conversion.md)
+
+* Pour aller plus loin
+  * [Comment fonctionnent les claviers](fr-fr/how_keyboards_work.md)
+  * [Comprendre QMK](fr-fr/understanding_qmk.md)
+
+* Autres sujets
+  * [Utiliser Eclipse avec QMK](fr-fr/other_eclipse.md)
+  * [Utiliser VSCode avec QMK](fr-fr/other_vscode.md)
+  * [Support](fr-fr/support.md)
+  * [Comment ajouter des traductions](fr-fr/translating.md)
+
+* À l’intérieur de QMK (En cours de documentation)
+  * [Définitions](fr-fr/internals_defines.md)
+  * [Input Callback Reg](fr-fr/internals_input_callback_reg.md)
+  * [Appareils Midi](fr-fr/internals_midi_device.md)
+  * [Installation d’un appareil Midi](fr-fr/internals_midi_device_setup_process.md)
+  * [Utilitaires Midi](fr-fr/internals_midi_util.md)
+  * [Fonctions Midi](fr-fr/internals_send_functions.md)
+  * [Outils Sysex](fr-fr/internals_sysex_tools.md)

docs/fr-fr/driver_installation_zadig.md

@@ -0,0 +1,46 @@
+# Installation du driver du bootloader avec Zadig
+
+Vous n’aurez pas besoin de pilote particulier pour utiliser un clavier QMK. En effet, QMK  se présente à l'ordinateur hôte comme un clavier HID standard et sera reconnu sans problème. Cependant vous aurez peut-être besoin d'un pilote pour flasher votre clavier avec Windows. En effet, quand vous redémarrerez votre clavier en mode bootloader, le périphérique que détectera Windows ne sera pas un clavier mais un périphérique bootloader.
+
+Il existe deux exceptions : le bootloader Caterina, qui se trouve en général sur les Pro Micros, et le bootloader Halfkay, livré avec les Teensy de PJRC. Ils apparaissent respectivement sous la forme d'un port série et d'un périphérique HID générique, ne nécessitant pas de pilote particulier.
+
+Nous vous recommandons d'utiliser l'utilitaire [Zadig](https://zadig.akeo.ie/). Si vous avez configuré votre environnement de développement avec Msys2 ou WSL, le script `qmk_install.sh` vous aura proposé l'installation des pilotes durant le processus.
+
+## Installation
+
+Passez votre clavier en mode bootloader, soit en appuyant sur le keycode `RESET` (qui peut se trouver dans un calque différent) ou en appuyant sur le bouton reset qui se trouve en général sous la board. Si votre clavier n'a aucune de ces options, essayez de le brancher en maintenant Escape ou Espace+`B` appuyés (voir la documentation de [Bootmagic](feature_bootmagic.md) pour plus de détails). Certaines boards utilisent [Command](feature_command.md) à la place de Bootmagic. Dans ce cas, vous pouvez entrer en mode bootloader en appuyant, à n'importe quel moment lorsque le clavier est branché, sur les combinaisons de touches Shift Gauche+Shift Droit+`B` ou Shift Gauche+Shift Droit+Escape.
+Certains claviers ont des instructions spécifiques pour passer en mode bootloader. Par exemple, la touche [Bootmagic Lite]](feature_bootmagic.md#bootmagic-lite) (défaut : Échap) peut être sur une touche différente telle que Contrôle Gauche. La combinaison pour la Command (défaut : Shift Gauche+Shift Droit) peut être différente, par exemple Contrôle Gauche+Contrôle Droit. Référez-vous au fichier README de votre clavier.
+
+Pour mettre un clavier en mode bootloader avec USBaspLoader, appuyez sur le bouton `RESET` tout en maintenant le bouton `BOOT`. Vous pouvez aussi maintenir le bouton `BOOT` en branchant le câble USB.
+
+Zadig détectera automatiquement les périphériques en mode bootloader. Il se peut toutefois que vous deviez vérifier en passant par  **Options → List All Devices**.
+
+
+ - Pour les claviers avec des MCUs Atmel AVR, le bootloader aura un nom similaire à `ATm32U4DFU`, et un Vendor ID `03EB`.
+ - Les bootloaders USBasp s'appelleront `USBasp`, avec un VID/PID `16C0:05DC`.
+ - Les claviers AVR flashé avec le bootloader QMK-DFU s'appelleront `<nom du clavier> Bootloader` et auront aussi le VID `03EB`.
+ - Pour la plupart des claviers ARM, ils s'appelleront `STM32 BOOTLOADER`, et auront un VID/PID `0483:DF11`.
+
+!> Si Zadig affiche certains de vos périphériques avec le driver `HidUsb`, votre clavier n'est probablement pas en mode bootloader. La flèche aura une couleur orange et vous aurez un message de confirmation vous demandant de modifier un pilote système. **Ne continuez pas!**
+
+Si la flèche apparaît en vert, sélectionnez le driver et appuyez sur le bouton **Install Driver**. Le driver `libusb-win32` devrait normalement fonctionner pour AVR, et `WinUSB` pour ARM. Si vous avez des problèmes pour flasher la board, essayez d'installer un pilote différent de la liste. Pour flasher un périphérique USBaspLoader en ligne de commande avec msys2, le driver `libusbk` est recommandé, sinon `libusb-win32` devrait fonctionner correctement si vous utilisez QMK Toolbox pour flasher.
+
+![Zadig montrant un driver de bootloader installé correctement](https://i.imgur.com/b8VgXzx.png)
+
+Finalement, débranchez et rebranchez le clavier afin de vous assurer que le nouveau pilote a bien été chargé. Si vous utilisez QMK Toolbox pour flasher, redémarrez-le aussi, il arrive qu'il n'arrive pas à détecter le changement de driver.
+
+## Récupérer l'installation du mauvais périphérique
+
+Si vous n'arrivez plus à saisir de texte avec le clavier, il est possible que vous ayez installé le driver sur le clavier au lieu du bootloader. Vous pouvez facilement vérifier ceci dans Zadig. Un clavier fonctionnel a le pilote `HidUsb` installé sur toutes ses interfaces :
+
+![Un clavier fonctionnel vu par Zadig](https://i.imgur.com/Hx0E5kC.png)
+
+Ouvrez le Gestionnaire de périphériques et cherchez un périphérique qui ressemble à votre clavier.
+
+![La board avec le mauvais driver installé, dans le Gestionnaire de périphériques](https://i.imgur.com/L3wvX8f.png)
+
+Cliquez dessus avec le bouton droit et sélectionner **Désinstaller le périphérique**. Faites bien attention à sélectionner **Supprimer le pilote pour ce périphérique** avant de valider.
+
+![Le dialogue Suppression de périphérique, avec la boîte "suppression de pilote" cochée](https://i.imgur.com/aEs2RuA.png)
+
+Appuyez sur **Action → Analyser les changements de hardware**. A ce stade, vous devriez pouvoir saisir à nouveau. Vérifiez dans Zadig que les périphériques utilisent bien le pilote `HidUsb`. Si c'est le cas, vous avez corrigé le problème, votre clavier devrait fonctionner à nouveau !

docs/fr-fr/faq.md

@@ -0,0 +1,6 @@
+# Foire Aux Questions
+
+* [FAQ Générale](faq_general.md)
+* [Construire ou Compiler QMK](faq_build.md)
+* [Débuguer et Dépanner QMK](faq_debug.md)
+* [Keymap (disposition)](faq_keymap.md)

docs/fr-fr/faq_build.md

@@ -0,0 +1,154 @@
+# Foire aux questions sur la compilation
+
+Cette page couvre les questions concernant la compilation de QMK. Si vous ne l'avez pas encore fait, vous devriez lire les guides [Configuration de l'environnement de build](getting_started_build_tools.md) et [Instructions pour Make](getting_started_make_guide.md).
+
+## Je ne peux pas programmer sous Linux
+
+Vous aurez besoin des permissions appropriées pour utiliser un périphérique. Pour les utilisateurs de Linux, référez-vous aux instructions concernant les règles `udev` ci-dessous. Si `udev` vous pose des problèmes, une alternative est d'utiliser la commande `sudo`. Si vous ne connaissez pas cette commande, référez-vous à son manuel d'utilisation en utilisant `man sudo` ou [regardez cette page](https://linux.die.net/man/8/sudo).
+
+Un exemple utilisant `sudo`, lorsque votre contrôleur est un ATMega32u4 :
+
+    $ sudo dfu-programmer atmega32u4 erase --force
+    $ sudo dfu-programmer atmega32u4 flash your.hex
+    $ sudo dfu-programmer atmega32u4 reset
+
+ou simplement :
+
+    $ sudo make <keyboard>:<keymap>:dfu
+
+Veuillez noter que lancer `make` avec `sudo` est généralement une **mauvaise** idée, et vous devriez préférer une des méthodes précédente, si possible.
+
+### Règles `udev` pour Linux
+
+Sous Linux, vous aurez besoin des permissions appropriées pour accéder au MCU (le micro-contrôleur). Vous avez le choix d'utiliser `sudo` en flashant le firmware, ou placer ces fichiers dans `/etc/udev/rules.d`. Une fois ajouté, lancez les commandes suivantes :
+
+```console
+sudo udevadm control --reload-rules
+sudo udevadm trigger
+```
+
+**/etc/udev/rules.d/50-atmel-dfu.rules:**
+```
+# Atmel ATMega32U4
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2ff4", MODE:="0666"
+# Atmel USBKEY AT90USB1287
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2ffb", MODE:="0666"
+# Atmel ATMega32U2
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2ff0", MODE:="0666"
+```
+
+**/etc/udev/rules.d/52-tmk-keyboard.rules:**
+```
+# tmk keyboard products     https://github.com/tmk/tmk_keyboard
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
+```
+
+**/etc/udev/rules.d/54-input-club-keyboard.rules:**
+
+```
+# Input Club keyboard bootloader
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="1c11", MODE:="0666"
+```
+
+**/etc/udev/rules.d/55-catalina.rules:**
+```
+# ModemManager should ignore the following devices
+ATTRS{idVendor}=="2a03", ENV{ID_MM_DEVICE_IGNORE}="1"
+ATTRS{idVendor}=="2341", ENV{ID_MM_DEVICE_IGNORE}="1"
+```
+
+**Note:** Le filtrage utilisant ModemManager fonctionnera uniquement si vous n'êtes pas en mode strict. Les commandes suivantes peuvent changer cette option :
+
+```console
+sudo sed -i 's/--filter-policy=strict/--filter-policy=default/' /lib/systemd/system/ModemManager.service
+sudo systemctl daemon-reload
+sudo systemctl restart ModemManager
+```
+
+**/etc/udev/rules.d/56-dfu-util.rules:**
+
+```
+# stm32duino
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="1eaf", ATTRS{idProduct}=="0003", MODE:="0666"
+# Generic stm32
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="df11", MODE:="0666"
+```
+
+### Le périphérique sériel n'est pas détecté en mode bootloader sous Linux
+
+Assurez-vous que votre kernel ait un support approprié pour votre périphérique. Si votre périphérique utilise USB ACM, par exemple pour les Pro Micro (AtMega32u4), assurez-vous d'inclure `CONFIG_USB_ACM=y`. D'autres périphériques peuvent avoir besoin de `USB_SERIAL` et de ses sous-options.
+
+## Périphérique inconnu pour le bootloader DFU
+
+Les problèmes rencontrés lorsque l'on flash des claviers sous Windows sont, la plupart du temps, dus à une installation du mauvais pilote, ou un pilote manquant.
+
+Relancer le script d'installation de QMK (`./util/qmk_install.sh` situé dans répertoire `qmk_firmware`sous MSYS2 ou WSL) ou réinstaller la QMK Toolbox peut résoudre le problème. Une alternative est de télécharger et lancer manuellement le package [`qmk_driver_installer`](https://github.com/qmk/qmk_driver_installer).
+
+Si vous rencontrez toujours des problèmes, essayez de télécharger et lancer Zadig. Voir [Installation du driver du bootloader avec Zadig](driver_installation_zadig.md) pour plus d'informations.
+
+## USB VID et PID
+
+Vous pouvez utiliser l'ID de votre choix en modifier `config.h`. Il y a peu de chance de conflit avec d'autres produits.
+
+La plupart des boards QMK utilisent `0xFEED` comme vendor ID. Vérifiez les autres claviers pour être sûr de choisir un Product ID unique.
+
+Étudiez aussi ce ticket
+https://github.com/tmk/tmk_keyboard/issues/150
+
+Vous pouvez acheter un VID:PID unique ici. Je ne pense pas que ce soit nécessaire pour un usage personnel.
+- 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
+
+## BOOTLOADER_SIZE pour AVR
+
+Notez que la taille du bootloader pour les Teensy2.0++ est de 2048bytes. Quelques Makefiles peuvent contenir une erreur et avoir le mauvais commentaire.
+
+```
+# Boot Section Size in *bytes*
+#   Teensy halfKay   512
+#   Teensy++ halfKay 2048
+#   Atmel DFU loader 4096       (TMK Alt Controller)
+#   LUFA bootloader  4096
+#   USBaspLoader     2048
+OPT_DEFS += -DBOOTLOADER_SIZE=2048
+```
+
+## `avr-gcc: internal compiler error: Abort trap: 6 (program cc1)` sous MacOS
+
+C'est un problème de mise à jour avec brew, causée par des liens symboliques (symlinks) dont dépend avr-gcc qui sont détruits.
+
+La solution est de supprimer et réinstaller tous les modules affectés.
+
+```
+brew rm avr-gcc
+brew rm dfu-programmer
+brew rm dfu-util
+brew rm gcc-arm-none-eabi
+brew rm avrdude
+brew install avr-gcc
+brew install dfu-programmer
+brew install dfu-util
+brew install gcc-arm-none-eabi
+brew install avrdude
+```
+
+### avr-gcc 8.1 et LUFA
+
+Si vous avez mis à jour votre avr-gcc au-dessus de la version 7, vous risquez de voir des erreurs impliquant LUA. Par exemple :
+
+`lib/lufa/LUFA/Drivers/USB/Class/Device/AudioClassDevice.h:380:5: error: 'const' attribute on function returning 'void'`
+
+Pour le moment, vous devrez revenir à la version 7 de avr-gcc dans brew.
+
+```
+brew uninstall --force avr-gcc
+brew install avr-gcc@8
+brew link --force avr-gcc@8
+```
+
+### Je viens de flasher mon clavier et il ne fait rien/l'appui des touches n'est pas enregistré - c'est aussi un ARM(rev6 plank, clueboard 60, hs60v2, etc.) (Février 2019)
+
+A cause de la manière dont les EEPROM fonctionnent sur les puces ARM, les options sauvegardées peuvent ne plus être valides. Ceci affecte les calques par défaut et *peut*, sous certaines conditions que nous essayons encore de déterminer, rendre le clavier inutilisable. Réinitialiser l'EEPROM corrigera le problème.
+
+[Réinitialiser EEPROM sur Planck rev6](https://cdn.discordapp.com/attachments/473506116718952450/539284620861243409/planck_rev6_default.bin) peut être utilisé pour forcer une réinitialisation d'EEPROM. Une fois cette image flashée, flashez à nouveau votre firmware standard. Cela devrait rétablir le fonctionnement de votre clavier.
+Si bootmagic est activé dans n'importe quel forme, vous devriez être capable de faire aussi ceci (regardez  [Documentation Bootmagic](feature_bootmagic.md) et les informations spécifiques à votre clavier).

docs/fr-fr/faq_debug.md

@@ -0,0 +1,165 @@
+# FAQ Débugage
+
+Cette page détaille diverses questions fréquemment posées par les utilisateurs sur le dépannage de leurs claviers.
+
+# Console de débugage
+
+## `hid_listen` ne reconnaît pas de périphérique
+
+Lorsque la console de débugage sur votre périphérique n'est pas prêt, vous obtiendrez un message similaire :
+
+```
+Waiting for device:.........
+```
+
+Une fois le périphérique connecté, *hid_listen* le trouve et vous obtiendrez ce message :
+
+```
+Waiting for new device:.........................
+Listening:
+```
+
+Si vous ne recevez pas ce message `Listening:`, essayez de compiler avec `CONSOLE_ENABLE=yes` dans le [Makefile]
+
+Il se peut que vous ayez besoin de certains privilèges avancés pour accéder à des périphériques sur des OS comme Linux.
+
+- Essayez `sudo hid_listen`
+
+## Ne reçoit pas de messages sur la console
+
+Vérifiez :
+
+- *hid_listen* trouve votre périphérique. Voir ci-dessus.
+- Activez le débugage en appuyant sur **Magic**+d. Voir [Commandes Magic](https://github.com/tmk/tmk_keyboard#magic-commands).
+- Définissez `debug_enable=true` en général dans `matrix_init()` du fichier **matrix.c**.
+- Essayez d'utiliser la fonction `print` à la place du debug print. Voir **common/print.h**.
+- Déconnectez tous les autres périphériques qui utilisent la fonction console. Voir [Issue #97](https://github.com/tmk/tmk_keyboard/issues/97).
+
+## Linux ou les systèmes UNIX nécessitent des privilèges super utilisateur
+
+Utilisez `sudo` pour exécuter *hid_listen* avec des privilèges étendus.
+
+```
+$ sudo hid_listen
+```
+
+Ou ajoutez une *udev rule* pour les périphériques TMK en plaçant un fichier dans le répertoire rules. Le chemin vers ce répertoire peut varier en fonction du système.
+
+Fichier: /etc/udev/rules.d/52-tmk-keyboard.rules(sous Ubuntu)
+```
+# tmk keyboard products     https://github.com/tmk/tmk_keyboard
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
+```
+
+***
+
+# Divers
+
+## Considérations de sécurité
+
+Vous ne voulez probablement pas "briquer" votre clavier, rendre impossible d'écrire un firmware dessus. Il y a quelques paramètres qui montrent ce qui est (et n'est probablement pas) trop risqué.
+
+- Si votre map de clavier n'inclut pas de RESET, pour entrer en mode DFU, vous devrez appuyer sur le bouton reset du PCB. Cela implique que vous devrez certainement dévisser certaines pièces de votre clavier pour y accéder.
+- Modifier les fichiers tmk_core / common peut rendre le clavier inutilisable
+- Si un fichier .hex trop large est la cause du problème : `make dfu` supprime le bloc puis teste la taille (il ne fait pas les choses dans le bon ordre), ce qui provoque une erreur. En résultat, le flash n’aura pas été fait et le clavier restera en mode DFU.
+- Pour finir, notez que la taille maximale d'un fichier .hex sur un Plank est de 7000h (28672 decimal)
+
+```
+Linking: .build/planck_rev4_cbbrowne.elf                                                            [OK]
+Creating load file for Flash: .build/planck_rev4_cbbrowne.hex                                       [OK]
+
+Size after:
+   text    data     bss     dec     hex filename
+      0   22396       0   22396    577c planck_rev4_cbbrowne.hex
+```
+
+- La taille du fichier ci-dessus est de 22396/577ch, ce qui est en dessous de 28672/7000h
+- Tant que vous avez un fichier .hex alternatif correct, vous pouvez réessayer en le chargeant
+- Certaines options que vous pouvez spécifier dans votre Makefile consomme de la mémoire supplémentaire. Faites attention aux options BOOTMAGIC_ENABLE, MOUSEKEY_ENABLE, EXTRAKEY_ENABLE, CONSOLE_ENABLE, API_SYSEX_ENABLE.
+- Les outils DFU **ne** vous permettent **pas** d'écrire dans le bootloader (à moins que vous n'ajoutiez des options spéciales), il n'y a donc peu de risque.
+- Les EEPROM ont environ 100000 cycles d'écriture. Ne réécrivez pas le firmware de manière continue et répétée. Vous allez détruire définitivement l'EEPROM.
+
+## NKRO ne fonctionne pas
+
+Premièrement, vous devez compiler le firmware avec l'option de compilation `NKRO_ENABLE` dans le **Makefile**.
+
+Essayez la commande `Magic` **N** (`LShift+RShift+N` par défaut) si **NKRO** ne fonctionne toujours pas. Vous pouvez utiliser cette commande pour basculer temporairement entre le mode **NKRO** et **6KRO**. Sous certaines conditions, **NKRO** ne fonctionnera pas et vous devrez basculer en **6KRO**, en particulier lorsque vous êtes dans le BIOS.
+
+Si votre firmware est compilé avec `BOOTMAGIC_ENABLE` vous devrez l'activer avec la commande `BootMagic` **N** (`Espace+N` par défaut). Cette option est enregistrée dans l'EEPROM et sera gardé entre deux cycles de démarrage.
+
+https://github.com/tmk/tmk_keyboard#boot-magic-configuration---virtual-dip-switch
+
+## Le TrackPoint a besoin Circuit de réinitialisation (Support de souris PS/2)
+
+Sans circuit de réinitialisation vous allez avoir des résultats inconsistants à cause de la mauvaise initialisation du matériel. Regardez le schéma du circuit du TPM754.
+
+- http://geekhack.org/index.php?topic=50176.msg1127447#msg1127447
+- http://www.mikrocontroller.net/attachment/52583/tpm754.pdf
+
+## Impossible de lire la colonne de la matrice après 16
+
+Utilisez `1UL<<16` à la place de `1<<16` dans `read_cols()` du fichier [matrix.h] lorsque le nombre de vos colonnes dépassent 16.
+
+En C, `1` implique un type [int] qui est [16 bits] pour les AVR, ce qui implique que vous ne pouvez pas décaler à gauche de plus de 15. Si vous utilisez `1<<16`, vous aurez un résultat non attendu de zéro. Vous devez donc utiliser un type [unsigned long] en utilisant `1UL`.
+
+http://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
+
+## Les touches spéciales ne fonctionnent pas (Touche Système, Touches de contrôle du son)
+
+Vous devez définir `EXTRAKEY_ENABLE` dans le fichier `rules.mk` pour les utiliser dans QMK.
+
+```
+EXTRAKEY_ENABLE = yes          # Audio control and System control
+```
+
+## Réveiller du mode veille ne fonctionne pas
+
+Sous Windows, activez l'option `Permettre au périphérique de sortir l'ordinateur de veille` dans les paramètres des **Options d'alimentations** du **Gestionnaire de périphériques**. Vérifiez aussi les paramètres du BIOS.
+
+Appuyer sur n'importe quelle touche en mode veille devrait sortir l'ordinateur de veille.
+
+## Vous utilisez un Arduino ?
+
+**Faites attention au fait que le nommage des pin d'un Arduino diffère de la puce**. Par exemple, la pin `D0` n'est pas `PD0`. Vérifiez le circuit avec la fiche technique.
+
+- http://arduino.cc/en/uploads/Main/arduino-leonardo-schematic_3b.pdf
+- http://arduino.cc/en/uploads/Main/arduino-micro-schematic.pdf
+
+Les Arduino Leonardo et micro ont des **ATMega32U4** et peuvent être utilisés avec TMK, mais le bootloader Arduino peut causer des problèmes.
+
+## Activer JTAG
+
+Par défaut, le débugage des interfaces JTAG est désactivé dès que le clavier démarre. Les MCUs compatible JTAG viennent d'usine avec le fusible `JTAGEN` activé, et il prend certaines pins du MCU que la board pourrait utiliser pour la matrice, les LEDs, etc.
+
+Si vous voulez garder JTAG activé, ajoutez la ligne suivante à votre fichier `config.h` :
+
+```c
+#define NO_JTAG_DISABLE
+```
+
+## Compatibilité USB 3
+
+Il semble que certaines personnes ont eu des problèmes avec les ports USB 3, essayez un port USB 2.
+
+## Compatibilité Mac
+
+### OS X 10.11 et Hub
+
+https://geekhack.org/index.php?topic=14290.msg1884034#msg1884034
+
+## Problème sur BIOS (UEFI) / Resume (Mise en veille et réveil) / Redémarrage
+
+Certaines personnes ont eu des problèmes de fonctionnement de leur clavier dans le BIOS et/ou après des redémarrages.
+
+Pour le moment, l'origine du problème n'est pas comprise, mais certaines options de compilation semble liées. Dans le Makefile, essayez de désactiver les options comme  `CONSOLE_ENABLE`, `NKRO_ENABLE`, `SLEEP_LED_ENABLE` et/ou d'autres.
+
+https://github.com/tmk/tmk_keyboard/issues/266
+https://geekhack.org/index.php?topic=41989.msg1967778#msg1967778
+
+## FLIP ne marche pas
+
+### `AtLibUsbDfu.dll` Not Found
+
+Supprimez le pilote actuel et réinstallez celui donné par FLIP dans le gestionnaire de périphériques.
+
+http://imgur.com/a/bnwzy

docs/fr-fr/faq_general.md

@@ -0,0 +1,16 @@
+# Questions fréquemment posées
+
+## Qu'est-ce que QMK ?
+
+[QMK](https://github.com/qmk), acronyme pour Quantum Mechanical Keyboard, est un groupe de personnes qui construisent des outils pour des claviers personnalisés. Nous avons commencé par le [firmware QMK](https://github.com/qmk/qmk_firmware), un fork très modifié du firmware [TMK](https://github.com/tmk/tmk_keyboard).
+
+## Quelles sont les différences entre QMK et TMK ?
+
+TMK a été conçu et développé à l'origine par [Jun Wako](https://github.com/tmk). QMK a démarré comme étant le fork de [Jack Humbert](https://github.com/jackhumbert) pour le Planck. Au bout d'un moment, le fork de Jack a divergé de manière significative de TMK et, en 2015, Jack a décidé de le renommer QMK.
+
+D'un point de vue technique, QMK se base sur TMK en lui ajoutant plusieurs nouvelles fonctionnalités.
+QMK a notamment augmenté le nombre de keycodes disponibles et les a utilisé pour implémenter des fonctionnalités avancées telles que `S()`, `LCTL()` et `MO()`. Vous pouvez voir une liste complète de ces keycodes dans [Keycodes] (keycodes.md).
+
+D'un point de vue management de projet et communauté, Hasu, sur TMK maintient tous les claviers supportés officiellement par lui-même, avec un peu de support de la communauté. Il existe ou peuvent être créées d'autres communautés maintenant des fork pour d'autres claviers. Peu de keymaps sont définies par défaut, les utilisateurs ne se partagent donc pas leurs keymaps en général. QMK encourage le partage des claviers et des keymaps à l'aide d'un dépôt géré de manière centrale, acceptant les pull requests qui suivent les standards de qualité. Ceux-ci sont surtout maitenus par la communauté, mais l'équipe de QMK aide aussi lorsque c'est nécessaire.
+
+Les deux approches ont leurs avantages et leurs inconvénients, et le développements de fonctionnalités intéressantes sont partagées entre TMK et QMK lorsque fait sens.

docs/fr-fr/faq_keymap.md

@@ -0,0 +1,161 @@
+# FAQ Keymap
+
+Cette page couvre les questions souvent posées à propos des keymaps. Si vous ne l'avez pas encore fait, vous devriez commencer par là [Aperçu des Keymap](keymap.md).
+
+## Quels Keycodes puis-je utiliser ?
+
+Regardez [Keycodes](keycodes.md) pour une liste des keycodes disponibles. Certains keycodes spécifiques ont des documentations plus complètes de disponible.
+
+Les keycodes sont définies dans [common/keycode.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keycode.h).
+
+## Quels sont les keycodes par défaut ?
+
+Il existe 3 configurations de clavier standard utilisées dans le monde: ANSI, ISO et JIS. L'Amérique du Nord utilise principalement l'ANSI, l'Europe et l'Afrique l'ISO et le Japon utilise JIS. Les autres régions utilisent généralement ANSI ou ISO. Les keycodes correspondant à ces dispositions spécifiques sont affichés ici :
+
+<!-- Source for this image: http://www.keyboard-layout-editor.com/#/gists/bf431647d1001cff5eff20ae55621e9a -->
+![Keyboard Layout Image](https://i.imgur.com/5wsh5wM.png)
+
+## Certaines de mes touches sont permutées ou ne fonctionnent pas
+
+QMK possède deux fonctionnalités, Bootmagic et Command, qui vous permettent de modifier le comportement de votre clavier à la volée. Cela inclut, sans toutefois s'y limiter, l'échange de Ctrl / Majuscules, la désactivation de l'interface graphique, le basculement de Alt/Gui, le basculement de barre d'espacement arrière/barre oblique inversée, la désactivation de toutes les touches et d'autres modifications comportementales.
+
+Pour résoudre rapidement le problème, essayez de maintenir les touches Espace + Retour arrière enfoncées pendant que vous branchez votre clavier. Cela réinitialisera les paramètres stockés sur votre clavier, ramenant ces touches à un fonctionnement normal. Si cela ne fonctionne pas, regardez ici:
+
+* [Bootmagic](feature_bootmagic.md)
+* [Command](feature_command.md)
+
+## La touche de menu ne fonctionne pas
+
+La touche trouvée sur la plupart des claviers modernes située entre `KC_RGUI` et` KC_RCTL` est en réalité appelée `KC_APP`. En effet, lorsque cette touche a été inventée, il existait déjà une clé nommée `MENU` dans les normes correspondantes. MS a donc choisi de l'appeler la touche` APP`.
+
+## `KC_SYSREQ` ne fonctionne pas
+
+Utilisez le keycode pour Print Screen (`KC_PSCREEN` or `KC_PSCR`) à la place de `KC_SYSREQ`. La combinaison de touche 'Alt + Print Screen' est reconnue comme 'System request'.
+
+Voir [issue #168](https://github.com/tmk/tmk_keyboard/issues/168) et
+* http://en.wikipedia.org/wiki/Magic_SysRq_key
+* http://en.wikipedia.org/wiki/System_request
+
+## Les touches alimentation ne fonctionnent pas
+
+Un peu déroutant, il y a deux codes de touche "Alimentation" dans QMK: `KC_POWER` dans la page d'utilisation du clavier / keypad, et `KC_SYSTEM_POWER` (ou `KC_PWR`) dans la page Consumer.
+
+Le premier n'est reconnu que sur macOS, alors que le dernier, `KC_SLEP` et `KC_WAKE` sont supportés par les trois principaux systèmes d'exploitation. Il est donc recommandé de les utiliser à la place. Sous Windows, ces touches prennent effet immédiatement, mais sur macOS, elles doivent être maintenues enfoncées jusqu'à ce qu'une boîte de dialogue apparaisse.
+
+## Modificateur "One Shot"
+
+Cette fonctionnalité permet de corriger un problème avec la touche Shift. En effet, il arrive de saisir plusieurs majuscules en ne voulant en saisir qu'une sur un mot. Ex : `CEtte` à la place de `Cette`. La fonctionnalité « One shot » shift permet de corriger ça.
+
+https://github.com/tmk/tmk_keyboard/issues/67
+
+## Le modificateur d'un calque reste bloqué
+
+Les touches de modification ou les calques peuvent être bloquées si la commutation de calque n'est pas configurée correctement.
+Pour les touches de modification et les actions de calque, vous devez placer `KC_TRANS` sur la même position du calque de destination afin de désenregistrer la clé de modificateur ou de revenir au calque précédent lors de la libération.
+
+* 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
+
+## Support de touche à verrouillage mécanique
+
+Cette fonctionnalité permet l'usage de *touches à verrouillage mécanique* comme [ces interrupteurs Alps](http://deskthority.net/wiki/Alps_SKCL_Lock). Vous pouvez l'activer en ajoutant ceci à votre `config.h` :
+
+```
+#define LOCKING_SUPPORT_ENABLE
+#define LOCKING_RESYNC_ENABLE
+```
+
+Une fois la fonction activée, utilisez les keycodes `KC_LCAP`, `KC_LNUM` et `KC_LSCR` dans votre keymap.
+
+Des vieux claviers mécaniques ont parfois des touches à verrouillage, mais les claviers modernes n'en sont pas équipés. ***Vous n'avez pas besoin de cette fonction dans la majorité des cas et devez utiliser les keycodes `KC_CAPS`, `KC_NLCK` et `KC_SLCK`.***
+
+## Ajouter des caractères spéciaux autres que ASCII comme la cédille 'Ç'
+
+Voir la fonctionnalité [Unicode](feature_unicode.md).
+
+## Touche `Fn` sur macOS
+
+Contrairement à la plupart des touches Fn, celle des claviers Apple a son propre code d'activation... en quelque sorte. Il remplace le sixième code d'activation dans un rapport de base 6KRO HID - de sorte qu'un clavier Apple ne contient en réalité que 5KRO.
+
+Il est techniquement possible de demander à QMK d’envoyer ce keycode. Cependant, cela nécessite une modification du format du rapport pour ajouter l'état de la touche Fn.
+Pire encore, ce keycode n'est reconnu que si les identifiants du clavier VID et PID correspondent à ceux d'un vrai clavier Apple. Malheureusement QMK ne peut juridiquement prendre en charge cette fonctionnalité et il y a peu de chance que la situation s'améliore.
+
+Voir [cette issue](https://github.com/qmk/qmk_firmware/issues/2179) pour des informations détaillées.
+
+## Touches Media sous Mac OSX
+
+#### KC_MNXT et KC_MPRV ne fonctionnent pas sous Mac
+
+Utilisez `KC_MFFD`(`KC_MEDIA_FAST_FORWARD`) et `KC_MRWD`(`KC_MEDIA_REWIND`) à la place de `KC_MNXT` et `KC_MPRV`.
+Voir https://github.com/tmk/tmk_keyboard/issues/195
+
+## Touches supportées sous Mac OSX?
+
+Vous pouvez connaître les keycodes supportés par OSX en lisant ce code source.
+
+`usb_2_adb_keymap` contient les tableaux des pages Keyboard/Keypad vers les scancodes ADB (keycodes interne à OSX).
+
+https://opensource.apple.com/source/IOHIDFamily/IOHIDFamily-606.1.7/IOHIDFamily/Cosmo_USB2ADB.c
+
+Et `IOHIDConsumer::dispatchConsumerEvent` s'occupe des utilisations Consumer page.
+
+https://opensource.apple.com/source/IOHIDFamily/IOHIDFamily-606.1.7/IOHIDFamily/IOHIDConsumer.cpp
+
+## Touches JIS dans Mac OSX
+
+Les touches de clavier spécifiques JIS comme `無変換(Muhenkan)`, `変換(Henkan)`, `ひらがな(hiragana)` ne sont pas reconnues par OSX. Vous pouvez utiliser **Seil** pour les activer, esssayez les options suivantes.
+
+* Activer la touche NFER sur clavier PC
+* Activer la touche XFER sur clavier PC
+* Activer la touche KATAKANA sur clavier PC
+
+https://pqrs.org/osx/karabiner/seil.html
+
+## RN-42 Bluetooth ne fonctionne pas avec Karabiner
+
+Karabiner - Outil de Keymapping sous Mac OSX - Ignore les entrées du module RN-42. Vous devez activer cette option pour rendre Karabiner compatible avec votre clavier.
+https://github.com/tekezo/Karabiner/issues/403#issuecomment-102559237
+
+Plus de détails sur ce problème sur les liens suivants.
+https://github.com/tmk/tmk_keyboard/issues/213
+https://github.com/tekezo/Karabiner/issues/403
+
+## Esc et <code>&#96;</code> sur une touche simple.
+
+Cette fonctionnalité permet d'utiliser une touche à la fois comme touche Échap ou une touche  `§` (En Azerty) selon le cas d’utilisation. Cela est très utile sur un clavier de petite taille.
+
+Voir la fonctionnalité [Grave Escape](feature_grave_esc.md).
+
+## Eject sur Mac OSX
+
+Le keycode`KC_EJCT` fonctionne sous OSX. https://github.com/tmk/tmk_keyboard/issues/250
+
+Il semble que Windows 10 ignore le code et Linux/Xorg le reconnaît mais n'a pas de mapping par défaut.
+
+Nous ne sommes pas sûr quel keycode est utilisé pour la touche Eject sur les claviers Apple officiels. HHKB utilise `F20` pour la touche Eject (`Fn+f`) lorsqu'il est en mode Mac, mais ce n'est probablement pas la même chose que le keycode Eject d'Apple.
+
+## Qu'est-ce que `weak_mods` et `real_mods` dans `action_util.c`
+
+___TO BE IMPROVED___
+
+real_mods est prévu pour retenir l'état des touches modificateur réelles/physiques, alors que weak_mods ne retient l'état que des modificateurs temporaires ou virtuels qui ne devraient pas affecter l'état des touches modificaterus réelles.
+
+Par exemple, disons que vous maintenez la touche physique "shift gauche" et tapez ACTION_MODS_KEY(LSHIFT, KC_A),
+
+en weak_mods,
+
+* (1) maintenir shift gauche : real_mods |= MOD_BIT(LSHIFT)
+* (2) appuyer ACTION_MODS_KEY(LSHIFT, KC_A): weak_mods |= MOD_BIT(LSHIFT)
+* (3) lâcher ACTION_MODS_KEY(LSHIFT, KC_A): weak_mods &= ~MOD_BIT(LSHIFT)
+real_mods garde sur état modificateur.
+
+sans weak_mods,
+
+* (1) maintenir shift gauche : real_mods |= MOD_BIT(LSHIFT)
+* (2) appuyer ACTION_MODS_KEY(LSHIFT, KC_A): real_mods |= MOD_BIT(LSHIFT)
+* (3) lâcher ACTION_MODS_KEY(LSHIFT, KC_A): real_mods &= ~MOD_BIT(LSHIFT)
+ici real_mods a perdu son état pour 'shift gauche physique'.
+
+weak_mods est ORed avec real_mods lorsque le rapport du clavier est envoyé.
+https://github.com/tmk/tmk_core/blob/master/common/action_util.c#L57

docs/fr-fr/getting_started_github.md

@@ -16,17 +16,23 @@ Faites attention à sélectionner "HTTPS", et sélectionnez le lien et copiez-le
 
 ![HTTPS link](http://i.imgur.com/eGO0ohO.jpg)
 
-Ensuite, entrez `git clone` dans la ligne de commande, et collez votre lien:
+Ensuite, entrez `git clone --recurse-submodules ` dans la ligne de commande, et collez votre lien:
 
 ```
-user@computer:~$ git clone https://github.com/whoeveryouare/qmk_firmware.git
+user@computer:~$ git clone --recurse-submodules https://github.com/whoeveryouare/qmk_firmware.git
 Cloning into 'qmk_firmware'...
-remote: Counting objects: 46625, done.
-remote: Compressing objects: 100% (2/2), done.
-remote: Total 46625 (delta 0), reused 0 (delta 0), pack-reused 46623
-Receiving objects: 100% (46625/46625), 84.47 MiB | 3.14 MiB/s, done.
-Resolving deltas: 100% (29362/29362), done.
-Checking out files: 100% (2799/2799), done.
+remote: Enumerating objects: 9, done.
+remote: Counting objects: 100% (9/9), done.
+remote: Compressing objects: 100% (5/5), done.
+remote: Total 183883 (delta 5), reused 4 (delta 4), pack-reused 183874
+Receiving objects: 100% (183883/183883), 132.90 MiB | 9.57 MiB/s, done.
+Resolving deltas: 100% (119972/119972), done.
+...
+Submodule path 'lib/chibios': checked out '587968d6cbc2b0e1c7147540872f2a67e59ca18b'
+Submodule path 'lib/chibios-contrib': checked out 'ede48346eee4b8d6847c19bc01420bee76a5e486'
+Submodule path 'lib/googletest': checked out 'ec44c6c1675c25b9827aacd08c02433cccde7780'
+Submodule path 'lib/lufa': checked out 'ce10f7642b0459e409839b23cc91498945119b4d'
+Submodule path 'lib/ugfx': checked out '3e97b74e03c93631cdd3ddb2ce43b963fdce19b2'
 ```
 
 Vous avez maintenant votre fork QMK sur votre machine locale, vous pouvez ajouter votre keymap, la compiler et la flasher sur votre board. Une fois heureux avec vos changements, vous pouvez les ajouter, commit, et pousser vers votre fork comme suit:

docs/fr-fr/getting_started_introduction.md

@@ -4,7 +4,7 @@ Le but de cette page est d'expliquer les informations de base qui vous serons n
 
 ## Structure de base de QMK
 
-QMK est un fork du projet [tmk_keyboard](https://github.com/tmk/tmk_keyboard) créé par [Jun Wako](https://github.com/tmk). Le code originel de TMK, avec quelques modifications, se trouve dans le dossier `tmk`. Les additions que QMK amène au projet se trouvent dans le dossier `quantum`. Les projets de clavier se trouvent dans les dossiers `handwired` et `keyboard`.
+QMK est un fork du projet [tmk_keyboard](https://github.com/tmk/tmk_keyboard) créé par [Jun Wako](https://github.com/tmk). Le code originel de TMK, avec quelques modifications, se trouve dans le dossier `tmk_core`. Les additions que QMK amène au projet se trouvent dans le dossier `quantum`. Les projets de clavier se trouvent dans les dossiers `handwired` et `keyboard`.
 
 ### Structure du Userspace
 

docs/getting_started_build_tools.md

@@ -43,7 +43,7 @@ Debian / Ubuntu example:
 Fedora / Red Hat example:
 
     sudo dnf install gcc unzip wget zip dfu-util dfu-programmer avr-gcc avr-libc binutils-avr32-linux-gnu arm-none-eabi-gcc-cs arm-none-eabi-binutils-cs arm-none-eabi-newlib
-    
+
 Arch / Manjaro example:
 
     pacman -S base-devel gcc unzip wget zip avr-gcc avr-binutils avr-libc dfu-util arm-none-eabi-gcc arm-none-eabi-binutils arm-none-eabi-newlib git dfu-programmer dfu-util
@@ -57,16 +57,17 @@ By default, this will download compilers for both AVR and ARM. If you don't need
     nix-shell --arg arm false
 
 ## macOS
-If you're using [homebrew,](http://brew.sh/) you can use the following commands:
+If you're using [Homebrew](http://brew.sh/), you can use the following commands:
 
     brew tap osx-cross/avr
-    brew tap PX4/homebrew-px4
+    brew tap osx-cross/arm
     brew update
     brew install avr-gcc@8
     brew link --force avr-gcc@8
     brew install dfu-programmer
     brew install dfu-util
-    brew install gcc-arm-none-eabi
+    brew install arm-gcc-bin@8
+    brew link --force arm-gcc-bin@8
     brew install avrdude
 
 This is the recommended method. If you don't have homebrew, [install it!](http://brew.sh/) It's very much worth it for anyone who works in the command line. Note that the `make` and `make install` portion during the homebrew installation of `avr-gcc@8` can take over 20 minutes and exhibit high CPU usage.
@@ -112,21 +113,6 @@ The Toolchain setup is done through the Windows Subsystem for Linux, and the pro
 * 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)
-
-These are the old instructions for Windows Vista and later. We recommend you use [MSYS2 as outlined above](#windows-with-msys2-recommended).
-
-1. If you have ever installed WinAVR, uninstall it.
-2. Install [MHV AVR Tools](https://infernoembedded.com/sites/default/files/project/MHV_AVR_Tools_20131101.exe). Disable smatch, but **be sure to leave the option to add the tools to the PATH checked**.
-3. If you are going to flash Infinity based keyboards you will need to install dfu-util, refer to the instructions by [Input Club](https://github.com/kiibohd/controller/wiki/Loading-DFU-Firmware).
-4. Install [MinGW](https://sourceforge.net/projects/mingw/files/Installer/mingw-get-setup.exe/download). During installation, uncheck the option to install a graphical user interface. **DO NOT change the default installation folder.** The scripts depend on the default location.
-5. Clone this repository. [This link will download it as a zip file, which you'll need to extract.](https://github.com/qmk/qmk_firmware/archive/master.zip) Open the extracted folder in Windows Explorer.
-6. Open the `\util` folder.
-7. Double-click on the `1-setup-path-win` batch script to run it. You'll need to accept a User Account Control prompt. Press the spacebar to dismiss the success message in the command prompt that pops up.
-8. Right-click on the `2-setup-environment-win` batch script, select "Run as administrator", and accept the User Account Control prompt. This part may take a couple of minutes, and you'll need to approve a driver installation, but once it finishes, your environment is complete!
-
-If you have trouble and want to ask for help, it is useful to generate a *Win_Check_Output.txt* file by running `Win_Check.bat` in the `\util` folder.
-
 ## Docker
 
 If this is a bit complex for you, Docker might be the turnkey solution you need. After installing [Docker CE](https://docs.docker.com/install/#supported-platforms), run the following command from the `qmk_firmware` directory to build a keyboard/keymap:

docs/getting_started_github.md

@@ -16,17 +16,23 @@ And be sure to select "HTTPS", and select the link and copy it:
 
 ![HTTPS link](http://i.imgur.com/eGO0ohO.jpg)
 
-From here, enter `git clone ` into the command line, and then paste your link:
+From here, enter `git clone --recurse-submodules ` into the command line, and then paste your link:
 
 ```
-user@computer:~$ git clone https://github.com/whoeveryouare/qmk_firmware.git
+user@computer:~$ git clone --recurse-submodules https://github.com/whoeveryouare/qmk_firmware.git
 Cloning into 'qmk_firmware'...
-remote: Counting objects: 46625, done.
-remote: Compressing objects: 100% (2/2), done.
-remote: Total 46625 (delta 0), reused 0 (delta 0), pack-reused 46623
-Receiving objects: 100% (46625/46625), 84.47 MiB | 3.14 MiB/s, done.
-Resolving deltas: 100% (29362/29362), done.
-Checking out files: 100% (2799/2799), done.
+remote: Enumerating objects: 9, done.
+remote: Counting objects: 100% (9/9), done.
+remote: Compressing objects: 100% (5/5), done.
+remote: Total 183883 (delta 5), reused 4 (delta 4), pack-reused 183874
+Receiving objects: 100% (183883/183883), 132.90 MiB | 9.57 MiB/s, done.
+Resolving deltas: 100% (119972/119972), done.
+...
+Submodule path 'lib/chibios': checked out '587968d6cbc2b0e1c7147540872f2a67e59ca18b'
+Submodule path 'lib/chibios-contrib': checked out 'ede48346eee4b8d6847c19bc01420bee76a5e486'
+Submodule path 'lib/googletest': checked out 'ec44c6c1675c25b9827aacd08c02433cccde7780'
+Submodule path 'lib/lufa': checked out 'ce10f7642b0459e409839b23cc91498945119b4d'
+Submodule path 'lib/ugfx': checked out '3e97b74e03c93631cdd3ddb2ce43b963fdce19b2'
 ```
 
 You now have your QMK fork on your local machine, and you can add your keymap, compile it and flash it to your board. Once you're happy with your changes, you can add, commit, and push them to your fork like this:

docs/getting_started_introduction.md

@@ -4,7 +4,7 @@ This page attempts to explain the basic information you need to know to work wit
 
 ## 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.
+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_core` 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.
 
 ### Userspace Structure
 

docs/getting_started_make_guide.md

@@ -59,7 +59,7 @@ To disable debug messages (*dprint*) and reduce the .hex file size, include `#de
 
 To disable print messages (*print*, *xprintf*) and user print messages (*uprint*) and reduce the .hex file size, include `#define NO_PRINT` in your `config.h` file.
 
-To disable print messages (*print*, *xprintf*) and **KEEP** user print messages (*uprint*), include `#define USER_PRINT` in your `config.h` file.
+To disable print messages (*print*, *xprintf*) and **KEEP** user print messages (*uprint*), include `#define USER_PRINT` in your `config.h` file (do not also include `#define NO_PRINT` in this case).
 
 To see the text, open `hid_listen` and enjoy looking at your printed messages.
 

docs/hardware_drivers.md

@@ -22,7 +22,7 @@ Support for SSD1306 based OLED displays. For more information see the [OLED Driv
 
 You can make use of uGFX within QMK to drive character and graphic LCDs, 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
 
 Support for WS2811/WS2812{a,b,c} LED's. For more information see the [RGB Light](feature_rgblight.md) page.
 

docs/he-il/README.md

@@ -20,7 +20,7 @@ QMK (*Quantum Mechanical Keyboard*) היא קהילת קוד פתוח (open sour
 
 ## איך לקמפל
 
-לפני שתצליחו לקמפל, תדרשו [להתקין סביבה](getting_started_build_tools.md) עבור פיתוח AVR ו/או ARM. ברגע שהדבר בוצע, תוכלו להריץ פקודת `make` כדי לבנות מקלדת ומיפוי עם התחביר הבא: 
+לפני שתצליחו לקמפל, תדרשו [להתקין סביבה](he-il/getting_started_build_tools.md) עבור פיתוח AVR ו/או ARM. ברגע שהדבר בוצע, תוכלו להריץ פקודת `make` כדי לבנות מקלדת ומיפוי עם התחביר הבא: 
 
     make planck/rev4:default
 
@@ -30,5 +30,5 @@ QMK (*Quantum Mechanical Keyboard*) היא קהילת קוד פתוח (open sour
 
 ## איך להתאים
 
-לQMK יש המון [יכולות](features.md) שאפשר לנווט בהן, וכמות נכבדת של [תיעוד ודוקומנטציה](http://docs.qmk.fm) בה אפשר לנבור. רוב הפיצ׳רים באים לידי ביטוי על ידי שינוי  [מיפוי המקלדת](keymap.md) ושינוי  [קודי המקשים](keycodes.md).
+לQMK יש המון [יכולות](he-il/features.md) שאפשר לנווט בהן, וכמות נכבדת של [תיעוד ודוקומנטציה](http://docs.qmk.fm) בה אפשר לנבור. רוב הפיצ׳רים באים לידי ביטוי על ידי שינוי  [מיפוי המקלדת](he-il/keymap.md) ושינוי  [קודי המקשים](he-il/keycodes.md).
 </div>

docs/he-il/_summary.md

@@ -1,6 +1,7 @@
 <div dir="rtl" markdown="1">
+
 **בשפה העברית**
-* [המדריך המלא למתחילים](newbs.md)
+* [המדריך המלא למתחילים](he-il/newbs.md)
   * [מקורות ללמידה](he-il/newbs_learn_more_resources.md)
 * [בסיס QMK](he-il/README.md)
     * [מבוא לQMK](he-il/getting_started_introduction.md)
@@ -13,126 +14,126 @@
   * [איך לתעד נכון](he-il/documentation_best_practices.md)
 
 **בשפה האנגלית**
-* [המדריך המלא למתחילים](newbs.md)
-  * [התחלה](newbs_getting_started.md)
-  * [בנייה של הקושחה הראשונה שלך](newbs_building_firmware.md)
-  * [צריבה של הקושחה](newbs_flashing.md)
-  * [בדיקות ודיבאגינג](newbs_testing_debugging.md)
-  * [עבודה נכונה ב GIT](newbs_best_practices.md)
-  * [מקורות ללמידה](newbs_learn_more_resources.md)
+* [המדריך המלא למתחילים](he-il/newbs.md)
+  * [התחלה](he-il/newbs_getting_started.md)
+  * [בנייה של הקושחה הראשונה שלך](he-il/newbs_building_firmware.md)
+  * [צריבה של הקושחה](he-il/newbs_flashing.md)
+  * [בדיקות ודיבאגינג](he-il/newbs_testing_debugging.md)
+  * [עבודה נכונה ב GIT](he-il/newbs_best_practices.md)
+  * [מקורות ללמידה](he-il/newbs_learn_more_resources.md)
 
-* [בסיס QMK](README.md)
-  * [מבוא לQMK](getting_started_introduction.md)
-  * [QMK CLI](cli.md)
-  * [QMK CLI Config](cli_configuration.md)
-  * [תרומה ל QMK](contributing.md)
-  * [איך להשתמש בGithub](getting_started_github.md)
-  * [קבלת עזרה](getting_started_getting_help.md)
+* [בסיס QMK](he-il/README.md)
+  * [מבוא לQMK](he-il/getting_started_introduction.md)
+  * [QMK CLI](he-il/cli.md)
+  * [QMK CLI Config](he-il/cli_configuration.md)
+  * [תרומה ל QMK](he-il/contributing.md)
+  * [איך להשתמש בGithub](he-il/getting_started_github.md)
+  * [קבלת עזרה](he-il/getting_started_getting_help.md)
 
-* [שינויים משמעותיים](breaking_changes.md)
-  * [2019 Aug 30](ChangeLog/20190830.md)
+* [שינויים משמעותיים](he-il/breaking_changes.md)
+  * [2019 Aug 30](he-il/ChangeLog/20190830.md)
 
-* [שאלות נפוצות](faq.md)
-  * [שאלות נפוצות כלליות](faq_general.md)
-  * [בנייה/קומפילציה של QMK](faq_build.md)
-  * [דיבאגינג ופתרון תקלות של QMK](faq_debug.md)
-  * [מיפוי מקשים](faq_keymap.md)
-  * [התקנת דרייברים עם Zadig](driver_installation_zadig.md)
+* [שאלות נפוצות](he-il/faq.md)
+  * [שאלות נפוצות כלליות](he-il/faq_general.md)
+  * [בנייה/קומפילציה של QMK](he-il/faq_build.md)
+  * [דיבאגינג ופתרון תקלות של QMK](he-il/faq_debug.md)
+  * [מיפוי מקשים](he-il/faq_keymap.md)
+  * [התקנת דרייברים עם Zadig](he-il/driver_installation_zadig.md)
 
 * מדריכים מפורטים
-  * [התקנת כלי Build](getting_started_build_tools.md)
-  * [מדריך Vagrant](getting_started_vagrant.md)
-  * [הוראות בנייה/קומפילציה](getting_started_make_guide.md)
-  * [צריבת קושחה](flashing.md)
-  * [התאמה אישית של הפונקציונאליות](custom_quantum_functions.md)
-  * [מיפוי מקשים](keymap.md)
+  * [התקנת כלי Build](he-il/getting_started_build_tools.md)
+  * [מדריך Vagrant](he-il/getting_started_vagrant.md)
+  * [הוראות בנייה/קומפילציה](he-il/getting_started_make_guide.md)
+  * [צריבת קושחה](he-il/flashing.md)
+  * [התאמה אישית של הפונקציונאליות](he-il/custom_quantum_functions.md)
+  * [מיפוי מקשים](he-il/keymap.md)
 
-* [חומרה](hardware.md)
-  * [מעבדי AVR](hardware_avr.md)
-  * [דרייברים](hardware_drivers.md)
+* [חומרה](he-il/hardware.md)
+  * [מעבדי AVR](he-il/hardware_avr.md)
+  * [דרייברים](he-il/hardware_drivers.md)
 
 * התייחסויות
-  * [מדריך למקלדות](hardware_keyboard_guidelines.md)
-  * [אפשרויות הגדרות](config_options.md)
-  * [קודי מקשים](keycodes.md)
-  * [קונבנציות קוד - C](coding_conventions_c.md)
-  * [קונבנציות קוד - Python](coding_conventions_python.md)
-  * [איך לתעד נכון](documentation_best_practices.md)
-  * [טמפלטים לדוקומנטציה](documentation_templates.md)
-  * [מילון](reference_glossary.md)
-  * [בדיקות יחידה](unit_testing.md)
-  * [פונקציות שימושיות](ref_functions.md)
-  * [תמיכה בConfigurator](reference_configurator_support.md)
-  * [פורמט info.json](reference_info_json.md)
-  * [פיתוח בPython CLI](cli_development.md)
+  * [מדריך למקלדות](he-il/hardware_keyboard_guidelines.md)
+  * [אפשרויות הגדרות](he-il/config_options.md)
+  * [קודי מקשים](he-il/keycodes.md)
+  * [קונבנציות קוד - C](he-il/coding_conventions_c.md)
+  * [קונבנציות קוד - Python](he-il/coding_conventions_python.md)
+  * [איך לתעד נכון](he-il/documentation_best_practices.md)
+  * [טמפלטים לדוקומנטציה](he-il/documentation_templates.md)
+  * [מילון](he-il/reference_glossary.md)
+  * [בדיקות יחידה](he-il/unit_testing.md)
+  * [פונקציות שימושיות](he-il/ref_functions.md)
+  * [תמיכה בConfigurator](he-il/reference_configurator_support.md)
+  * [פורמט info.json](he-il/reference_info_json.md)
+  * [פיתוח בPython CLI](he-il/cli_development.md)
 
-* [תכונות](features.md)
-  * [Basic Keycodes](keycodes_basic.md)
-  * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
-  * [Quantum Keycodes](quantum_keycodes.md)
-  * [Advanced Keycodes](feature_advanced_keycodes.md)
-  * [Audio](feature_audio.md)
-  * [Auto Shift](feature_auto_shift.md)
-  * [Backlight](feature_backlight.md)
-  * [Bluetooth](feature_bluetooth.md)
-  * [Bootmagic](feature_bootmagic.md)
-  * [Combos](feature_combo.md)
-  * [Command](feature_command.md)
-  * [Debounce API](feature_debounce_type.md)
-  * [DIP Switch](feature_dip_switch.md)
-  * [Dynamic Macros](feature_dynamic_macros.md)
-  * [Encoders](feature_encoders.md)
-  * [Grave Escape](feature_grave_esc.md)
-  * [Haptic Feedback](feature_haptic_feedback.md)
-  * [HD44780 LCD Controller](feature_hd44780.md)
-  * [Key Lock](feature_key_lock.md)
-  * [Layouts](feature_layouts.md)
-  * [Leader Key](feature_leader_key.md)
-  * [LED Matrix](feature_led_matrix.md)
-  * [Macros](feature_macros.md)
-  * [Mouse Keys](feature_mouse_keys.md)
-  * [OLED Driver](feature_oled_driver.md)
-  * [One Shot Keys](feature_advanced_keycodes.md#one-shot-keys)
-  * [Pointing Device](feature_pointing_device.md)
-  * [PS/2 Mouse](feature_ps2_mouse.md)
-  * [RGB Lighting](feature_rgblight.md)
-  * [RGB Matrix](feature_rgb_matrix.md)
-  * [Space Cadet](feature_space_cadet.md)
-  * [Split Keyboard](feature_split_keyboard.md)
-  * [Stenography](feature_stenography.md)
-  * [Swap Hands](feature_swap_hands.md)
-  * [Tap Dance](feature_tap_dance.md)
-  * [Terminal](feature_terminal.md)
-  * [Thermal Printer](feature_thermal_printer.md)
-  * [Unicode](feature_unicode.md)
-  * [Userspace](feature_userspace.md)
-  * [Velocikey](feature_velocikey.md)
+* [תכונות](he-il/features.md)
+  * [Basic Keycodes](he-il/keycodes_basic.md)
+  * [US ANSI Shifted Keys](he-il/keycodes_us_ansi_shifted.md)
+  * [Quantum Keycodes](he-il/quantum_keycodes.md)
+  * [Advanced Keycodes](he-il/feature_advanced_keycodes.md)
+  * [Audio](he-il/feature_audio.md)
+  * [Auto Shift](he-il/feature_auto_shift.md)
+  * [Backlight](he-il/feature_backlight.md)
+  * [Bluetooth](he-il/feature_bluetooth.md)
+  * [Bootmagic](he-il/feature_bootmagic.md)
+  * [Combos](he-il/feature_combo.md)
+  * [Command](he-il/feature_command.md)
+  * [Debounce API](he-il/feature_debounce_type.md)
+  * [DIP Switch](he-il/feature_dip_switch.md)
+  * [Dynamic Macros](he-il/feature_dynamic_macros.md)
+  * [Encoders](he-il/feature_encoders.md)
+  * [Grave Escape](he-il/feature_grave_esc.md)
+  * [Haptic Feedback](he-il/feature_haptic_feedback.md)
+  * [HD44780 LCD Controller](he-il/feature_hd44780.md)
+  * [Key Lock](he-il/feature_key_lock.md)
+  * [Layouts](he-il/feature_layouts.md)
+  * [Leader Key](he-il/feature_leader_key.md)
+  * [LED Matrix](he-il/feature_led_matrix.md)
+  * [Macros](he-il/feature_macros.md)
+  * [Mouse Keys](he-il/feature_mouse_keys.md)
+  * [OLED Driver](he-il/feature_oled_driver.md)
+  * [One Shot Keys](he-il/feature_advanced_keycodes.md#one-shot-keys)
+  * [Pointing Device](he-il/feature_pointing_device.md)
+  * [PS/2 Mouse](he-il/feature_ps2_mouse.md)
+  * [RGB Lighting](he-il/feature_rgblight.md)
+  * [RGB Matrix](he-il/feature_rgb_matrix.md)
+  * [Space Cadet](he-il/feature_space_cadet.md)
+  * [Split Keyboard](he-il/feature_split_keyboard.md)
+  * [Stenography](he-il/feature_stenography.md)
+  * [Swap Hands](he-il/feature_swap_hands.md)
+  * [Tap Dance](he-il/feature_tap_dance.md)
+  * [Terminal](he-il/feature_terminal.md)
+  * [Thermal Printer](he-il/feature_thermal_printer.md)
+  * [Unicode](he-il/feature_unicode.md)
+  * [Userspace](he-il/feature_userspace.md)
+  * [Velocikey](he-il/feature_velocikey.md)
 
 * למייקרים ומודרים
-  * [מדריך לכתיבה ידנית](hand_wire.md)
-  * [מדריך לצריבת ISP](isp_flashing_guide.md)
-  * [מדריך לדיבאגינג ARM](arm_debugging.md)
-  * [מנהל התקן I2C](i2c_driver.md)
-  * [בקרת GPIO](internals_gpio_control.md)
-  * [המרת Proton C](proton_c_conversion.md)
+  * [מדריך לכתיבה ידנית](he-il/hand_wire.md)
+  * [מדריך לצריבת ISP](he-il/isp_flashing_guide.md)
+  * [מדריך לדיבאגינג ARM](he-il/arm_debugging.md)
+  * [מנהל התקן I2C](he-il/i2c_driver.md)
+  * [בקרת GPIO](he-il/internals_gpio_control.md)
+  * [המרת Proton C](he-il/proton_c_conversion.md)
 
 * להבנה עמוקה יותר
-  * [איך עובדות מקלדות](how_keyboards_work.md)
-  * [להבין את QMK](understanding_qmk.md)
+  * [איך עובדות מקלדות](he-il/how_keyboards_work.md)
+  * [להבין את QMK](he-il/understanding_qmk.md)
 
 * נושאים נוספים
-  * [שימוש ב - Eclipse עם QMK](other_eclipse.md)
-  * [שימוש ב - VSCode עם QMK](other_vscode.md)
-  * [תמיכה](support.md)
-  * [כיצד להוסיף תרגום](translating.md)
+  * [שימוש ב - Eclipse עם QMK](he-il/other_eclipse.md)
+  * [שימוש ב - VSCode עם QMK](he-il/other_vscode.md)
+  * [תמיכה](he-il/support.md)
+  * [כיצד להוסיף תרגום](he-il/translating.md)
 
 * QMK מבפנים (בתהליך)
-  * [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)
+  * [Defines](he-il/internals_defines.md)
+  * [Input Callback Reg](he-il/internals_input_callback_reg.md)
+  * [Midi Device](he-il/internals_midi_device.md)
+  * [Midi Device Setup Process](he-il/internals_midi_device_setup_process.md)
+  * [Midi Util](he-il/internals_midi_util.md)
+  * [Send Functions](he-il/internals_send_functions.md)
+  * [Sysex Tools](he-il/internals_sysex_tools.md)
 
 </div>

docs/he-il/getting_started_github.md

@@ -17,19 +17,25 @@ Github עלול להיות קצת טריקי למי שלא מכיר את העב
 
 ![קישור HTTPS](http://i.imgur.com/eGO0ohO.jpg)
 
-מכאן והלאה, הקיש `git clone ` בשורת הפקודה והדביקו את הלינק שלכם:
+מכאן והלאה, הקיש `git clone --recurse-submodules ` בשורת הפקודה והדביקו את הלינק שלכם:
 
 <div dir="ltr" markdown="1">
 
 ```
-user@computer:~$ git clone https://github.com/whoeveryouare/qmk_firmware.git
+user@computer:~$ git clone --recurse-submodules https://github.com/whoeveryouare/qmk_firmware.git
 Cloning into 'qmk_firmware'...
-remote: Counting objects: 46625, done.
-remote: Compressing objects: 100% (2/2), done.
-remote: Total 46625 (delta 0), reused 0 (delta 0), pack-reused 46623
-Receiving objects: 100% (46625/46625), 84.47 MiB | 3.14 MiB/s, done.
-Resolving deltas: 100% (29362/29362), done.
-Checking out files: 100% (2799/2799), done.
+remote: Enumerating objects: 9, done.
+remote: Counting objects: 100% (9/9), done.
+remote: Compressing objects: 100% (5/5), done.
+remote: Total 183883 (delta 5), reused 4 (delta 4), pack-reused 183874
+Receiving objects: 100% (183883/183883), 132.90 MiB | 9.57 MiB/s, done.
+Resolving deltas: 100% (119972/119972), done.
+...
+Submodule path 'lib/chibios': checked out '587968d6cbc2b0e1c7147540872f2a67e59ca18b'
+Submodule path 'lib/chibios-contrib': checked out 'ede48346eee4b8d6847c19bc01420bee76a5e486'
+Submodule path 'lib/googletest': checked out 'ec44c6c1675c25b9827aacd08c02433cccde7780'
+Submodule path 'lib/lufa': checked out 'ce10f7642b0459e409839b23cc91498945119b4d'
+Submodule path 'lib/ugfx': checked out '3e97b74e03c93631cdd3ddb2ce43b963fdce19b2'
 ```
 
 </div>
@@ -66,4 +72,4 @@ To https://github.com/whoeveryouare/qmk_firmware.git
 ![צרו Pull Request](http://i.imgur.com/Ojydlaj.jpg)
 
 אחרי שהגשתם, אנו עלולים לפנות אליכם לגבי השינויים שהצעתם, נבקש שתבצעו שינויים ובסופו של דבר נקבל את השינויים! תודה שתרמתם לפרוייקט QMK :)
-</div>
+</div>

docs/he-il/getting_started_introduction.md

@@ -5,7 +5,7 @@
 
 ## מבנה QMK בסיסי
 
-QMK הוא פורק של הפרוייקט [tmk_keyboard](https://github.com/tmk/tmk_keyboard) של [Jun Wako](https://github.com/tmk). קוד הTMK המקורי, עם התאמות, יכול להמצא בתיקיית `tmk`. התוספות של QMK לפרוייקט יכולות להמצא בתיקיית `quantum`. פרוייקטי מקלדות יכולות להמצא בתיקיות `handwired` ו- `keyboard`.
+QMK הוא פורק של הפרוייקט [tmk_keyboard](https://github.com/tmk/tmk_keyboard) של [Jun Wako](https://github.com/tmk). קוד הTMK המקורי, עם התאמות, יכול להמצא בתיקיית `tmk_core`. התוספות של QMK לפרוייקט יכולות להמצא בתיקיית `quantum`. פרוייקטי מקלדות יכולות להמצא בתיקיות `handwired` ו- `keyboard`.
 
 ### מבנה אחסון המשתמש
 
@@ -69,4 +69,4 @@ In every keymap folder, the following files may be found. Only `keymap.c` is req
 ```
 
 </div>
-</div>
+</div>

docs/index.html

@@ -21,7 +21,7 @@
   <div id="app"></div>
   <script>
     window.$docsify = {
-      alias : {
+      alias: {
         '/en/(.*)': '/$1',
         '/en-us/(.*)': '/$1',
         '/en-gb/(.*)': '/$1',
@@ -29,23 +29,47 @@
       },
       basePath: '/',
       name: 'QMK Firmware',
-      nameLink: '/',
+      nameLink: {
+        '/de/': '/#/de/',
+        '/es/': '/#/es/',
+        '/fr-fr/': '/#/fr-fr/',
+        '/he-il/': '/#/he-il/',
+        '/ja/': '/#/ja/',
+        '/pt-br/': '/#/pt-br/',
+        '/ru-ru/': '/#/ru-ru/',
+        '/zh-cn/': '/#/zh-cn/',
+        '/': '/#/'
+      },
       repo: 'qmk/qmk_firmware',
       loadSidebar: '_summary.md',
       loadNavbar: '_langs.md',
       mergeNavbar: true,
       auto2top: true,
+      fallbackLanguages: [
+        'de',
+        'es',
+        'fr-fr',
+        'he-il',
+        'ja',
+        'pt-br',
+        'ru-ru',
+        'zh-cn'
+      ],
       formatUpdated: '{YYYY}/{MM}/{DD} {HH}:{mm}',
       search: {
         paths: 'auto',
         placeholder: {
           '/es/': 'Buscar',
           '/zh-cn/': '搜索',
+          '/ja/': '検索',
+          '/pt-br/': 'Busca',
           '/': 'Search'
         },
         noData: {
           '/es/': '¡Ningún resultado!',
           '/zh-cn/': '没有结果!',
+          '/ja/': '見つかりません!',
+          '/pt-br/': 'Nenhum resultado!',
           '/': 'No results!'
         },
         depth: 6
@@ -58,9 +82,9 @@
                 .replace('raw.githubusercontent.com', 'github.com')
                 .replace(/\/master/, '/blob/master')
             } else {
-              url = 'https://github.com/qmk/qmk_firmware/blob/master/docs/' + vm.route.file
+              url = 'https://github.com/qmk/qmk_firmware/edit/master/docs/' + vm.route.file
             }
-            var editHtml = '[:memo: Edit Document](' + url + ')\n'
+            var editHtml = ':pencil2: [Edit this page](' + url + ')\n'
             return html
               + '\n\n----\n\n'
               + editHtml

docs/ja/README.md

@@ -0,0 +1,37 @@
+# Quantum Mechanical Keyboard Firmware
+
+<!---
+  original document: eae21eed7:docs/README.md
+  git diff eae21eed7 HEAD docs/README.md | cat
+-->
+
+[![現在のバージョン](https://img.shields.io/github/tag/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/tags)
+[![ビルド状態](https://travis-ci.org/qmk/qmk_firmware.svg?branch=master)](https://travis-ci.org/qmk/qmk_firmware)
+[![Discord](https://img.shields.io/discord/440868230475677696.svg)](https://discord.gg/Uq7gcHh)
+[![ドキュメントの状態](https://img.shields.io/badge/docs-ready-orange.svg)](https://docs.qmk.fm)
+[![GitHub 貢献者](https://img.shields.io/github/contributors/qmk/qmk_firmware.svg)](https://github.com/qmk/qmk_firmware/pulse/monthly)
+[![GitHub フォーク](https://img.shields.io/github/forks/qmk/qmk_firmware.svg?style=social&label=Fork)](https://github.com/qmk/qmk_firmware/)
+
+## QMK ファームウェアとは何か？
+
+QMK (*Quantum Mechanical Keyboard*)は QMK ファームウェア、QMK ツールボックス、qmk.fm およびそれらのドキュメントを保守するオープンソースコミュニティです。QMK ファームウェアは[tmk\_keyboard](http://github.com/tmk/tmk_keyboard) を元にしたキーボードファームウェアで、Atmel AVR コントローラ、より具体的には [OLKB 製品](http://olkb.com)、[ErgoDox EZ](http://www.ergodox-ez.com) キーボードおよび [Clueboard 製品](http://clueboard.co/) のための幾つかの便利な機能を持ちます。また、ChibiOS を使って ARM チップに移植されています。これを使ってあなたの作った手配線のキーボードあるいはカスタムキーボード PCB で作ったキーボードを動かすことができます。
+
+## 入手方法
+
+QMK のキーマップ、キーボード、機能に貢献をする予定がある場合、最も簡単なのは、[Github を介してリポジトリをフォークし](https://github.com/qmk/qmk_firmware#fork-destination-box)、リポジトリをあなたの開発環境にクローンして変更を加え、それらをプッシュし、[プルリクエスト](https://github.com/qmk/qmk_firmware/pulls)を開くことです。
+
+それ以外の場合は、`git clone https://github.com/qmk/qmk_firmware` を介して直接クローンすることができます。zip または tar ファイルをダウンロードしないでください。コンパイルするためのサブモジュールをダウンロードするために git リポジトリが必要です。
+
+## コンパイル方法
+
+コンパイルをする前に、AVR または ARM 開発のための[環境をインストール](ja/getting_started_build_tools.md)する必要があります。それが完了したら、`make` コマンドを使用して、以下の表記でキーボードとキーマップをビルドします。
+
+    make planck/rev4:default
+
+これは、`planck` の `rev4` リビジョンを `default` キーマップでビルドします。全てのキーボードにリビジョン(サブプロジェクトまたはフォルダとも呼ばれます)があるわけではありません。その場合は省略されます:
+
+    make preonic:default
+
+## カスタマイズ方法
+
+QMK には、探求すべき多くの[機能](ja/features.md)と、深堀りするための[リファレンス ドキュメント](http://docs.qmk.fm)がたくさんあります。ほとんどの機能は[キーマップ](ja/keymap.md)を変更し、[キーコード](ja/keycodes.md)を変更することで活用されます。

docs/ja/_summary.md

@@ -0,0 +1,124 @@
+* [完全な初心者のガイド](ja/newbs.md)
+   * [はじめに](ja/newbs_getting_started.md)
+   * [初めてのファームウェアの構築](ja/newbs_building_firmware.md)
+   * [ファームウェアのフラッシュ](ja/newbs_flashing.md)
+   * [テストとデバッグ](ja/newbs_testing_debugging.md)
+   * [QMK における Git 運用作法](ja/newbs_git_best_practices.md)
+     * [あなたのフォークの master ブランチ](ja/newbs_git_using_your_master_branch.md)
+     * [マージの競合の解決](ja/newbs_git_resolving_merge_conflicts.md)
+     * [同期のとれていない git ブランチの再同期](ja/newbs_git_resynchronize_a_branch.md)
+   * [学習リソース](ja/newbs_learn_more_resources.md)
+
+* [QMKの基本](ja/README.md)
+   * [QMKの導入](ja/getting_started_introduction.md)
+   * [QMK CLI](ja/cli.md)
+   * [QMK CLI 設定](ja/cli_configuration.md)
+   * [QMKへの貢献](ja/contributing.md)
+   * [Githubの使い方](ja/getting_started_github.md)
+   * [ヘルプ](ja/getting_started_getting_help.md)
+
+* [破壊的な変更](ja/breaking_changes.md)
+   * [2019年8月30日](ja/ChangeLog/20190830.md)
+
+* [FAQ](ja/faq.md)
+   * [一般的なFAQ](ja/faq_general.md)
+   * [QMKのビルド/コンパイル](ja/faq_build.md)
+   * [QMKのデバッグ/トラブルシューティング](ja/faq_debug.md)
+   * [キーマップ](ja/faq_keymap.md)
+   * [Zadigを使ったドライバのインストール](ja/driver_installation_zadig.md)
+
+* 詳細なガイド
+   * [ビルドツールのインストール](ja/getting_started_build_tools.md)
+   * [Vagrantのガイド](ja/getting_started_vagrant.md)
+   * [ビルド/コンパイルの説明](ja/getting_started_make_guide.md)
+   * [ファームウェアのフラッシュ](ja/flashing.md)
+   * [機能のカスタマイズ](ja/custom_quantum_functions.md)
+   * [キーマップの概要](ja/keymap.md)
+
+* [ハードウェア](ja/hardware.md)
+   * [AVR プロセッサ](ja/hardware_avr.md)
+   * [ドライバ](ja/hardware_drivers.md)
+
+* リファレンス
+   * [キーボード ガイドライン](ja/hardware_keyboard_guidelines.md)
+   * [設定オプション](ja/config_options.md)
+   * [キーコード](ja/keycodes.md)
+   * [コーディング規約 - C](ja/coding_conventions_c.md)
+   * [コーディング規約 - Python](ja/coding_conventions_python.md)
+   * [ドキュメント ベストプラクティス](ja/documentation_best_practices.md)
+   * [ドキュメント テンプレート](ja/documentation_templates.md)
+   * [用語](ja/reference_glossary.md)
+   * [ユニットテスト](ja/unit_testing.md)
+   * [便利な関数](ja/ref_functions.md)
+   * [Configurator サポート](ja/reference_configurator_support.md)
+   * [info.json 形式](ja/reference_info_json.md)
+   * [Python CLI 開発](ja/cli_development.md)
+
+* [機能](ja/features.md)
+   * [基本的なキーコード](ja/keycodes_basic.md)
+   * [US ANSI シフトキー](ja/keycodes_us_ansi_shifted.md)
+   * [Quantum キーコード](ja/quantum_keycodes.md)
+   * [Advanced キーコード](ja/feature_advanced_keycodes.md)
+   * [オーディオ](ja/feature_audio.md)
+   * [自動シフト](ja/feature_auto_shift.md)
+   * [バックライト](ja/feature_backlight.md)
+   * [ブルートゥース](ja/feature_bluetooth.md)
+   * [ブートマジック](ja/feature_bootmagic.md)
+   * [コンボ](ja/feature_combo.md)
+   * [コマンド](ja/feature_command.md)
+   * [Debounce API](ja/feature_debounce_type.md)
+   * [DIP スイッチ](ja/feature_dip_switch.md)
+   * [動的マクロ](ja/feature_dynamic_macros.md)
+   * [エンコーダ](ja/feature_encoders.md)
+   * [グレイブ エスケープ](ja/feature_grave_esc.md)
+   * [触覚フィードバック](ja/feature_haptic_feedback.md)
+   * [HD44780 LCD コントローラ](ja/feature_hd44780.md)
+   * [キーロック](ja/feature_key_lock.md)
+   * [レイアウト](ja/feature_layouts.md)
+   * [リーダー キー](ja/feature_leader_key.md)
+   * [LED マトリクス](ja/feature_led_matrix.md)
+   * [マクロ](ja/feature_macros.md)
+   * [マウスキー](ja/feature_mouse_keys.md)
+   * [OLED ドライバ](ja/feature_oled_driver.md)
+   * [One Shot Keys](ja/feature_advanced_keycodes.md#one-shot-keys)
+   * [ポインティング デバイス](ja/feature_pointing_device.md)
+   * [PS/2 マウス](ja/feature_ps2_mouse.md)
+   * [RGB ライト](ja/feature_rgblight.md)
+   * [RGB マトリクス](ja/feature_rgb_matrix.md)
+   * [Space Cadet](ja/feature_space_cadet.md)
+   * [分割キーボード](ja/feature_split_keyboard.md)
+   * [Stenography](ja/feature_stenography.md)
+   * [Swap Hands](ja/feature_swap_hands.md)
+   * [タップ ダンス](ja/feature_tap_dance.md)
+   * [Terminal](ja/feature_terminal.md)
+   * [感熱式プリンタ](ja/feature_thermal_printer.md)
+   * [ユニコード](ja/feature_unicode.md)
+   * [Userspace](ja/feature_userspace.md)
+   * [Velocikey](ja/feature_velocikey.md)
+
+* メーカーおよびモッダーのために
+   * [Hand Wiring Guide](ja/hand_wire.md)
+   * [ISP Flashing Guide](ja/isp_flashing_guide.md)
+   * [ARM デバッグ ガイド](ja/arm_debugging.md)
+   * [I2C ドライバ](ja/i2c_driver.md)
+   * [GPIO コントロール](ja/internals_gpio_control.md)
+   * [Proton C 規約](ja/proton_c_conversion.md)
+
+* より深く知るために
+   * [キーボードがどのように動作するか](ja/how_keyboards_work.md)
+   * [QMKの理解](ja/understanding_qmk.md)
+
+* 他の話題
+   * [EclipseでQMKを使用](ja/other_eclipse.md)
+   * [VSCodeでQMKを使用](ja/other_vscode.md)
+   * [サポート](ja/support.md)
+   * [翻訳を追加する方法](ja/translating.md)
+
+* QMK の内部詳細(作成中)
+   * [定義](ja/internals_defines.md)
+   * [Input Callback Reg](ja/internals_input_callback_reg.md)
+   * [Midi ドライバ](ja/internals_midi_device.md)
+   * [Midi デバイスのセットアップ手順](ja/internals_midi_device_setup_process.md)
+   * [Midi ユーティリティ](ja/internals_midi_util.md)
+   * [Send Functions](ja/internals_send_functions.md)
+   * [Sysex Tools](ja/internals_sysex_tools.md)

docs/ja/arm_debugging.md

@@ -0,0 +1,92 @@
+# Eclipse を使った ARM デバッグ
+
+<!---
+  original document: eae21eed7:docs/arm_debugging.md
+  git diff eae21eed7 HEAD docs/arm_debugging.md | cat
+-->
+
+このページでは、SWD アダプタとオープンソース/フリーツールを使って ARM MCU をデバッグするためのセットアップ方法について説明します。このガイドでは、GNU MCU Eclipse IDE for C/C++ Developers および OpenOCD を必要な依存関係と一緒にインストールします。
+
+このガイドは上級者向けであり、あなたのマシンで、MAKE フローを使って、ARM 互換キーボードをコンパイルできることを前提にしています。
+
+## ソフトウェアのインストール
+
+ここでの主な目的は MCU Eclipse IDE を正しくマシンにインストールすることです。必要な手順は[この](https://gnu-mcu-eclipse.github.io/install/)インストールガイドから派生しています。
+
+### xPack マネージャ
+
+このツールはソフトウェアパッケージマネージャであり、必要な依存関係を取得するために使われます。
+
+XPM は Node.js を使って実行されるため、[ここ](https://nodejs.org/en/)から取得してください。インストール後に、ターミナルを開き `npm -v` と入力します。バージョン番号が返ってくるとインストールは成功です。
+
+XPM のインストール手順は[ここ](https://www.npmjs.com/package/xpm)で見つけることができ、OS 固有のものです。ターミナルに `xpm --version` と入力すると、ソフトウェアのバージョンが返ってくるはずです。
+
+### ARM ツールチェーン
+
+XPM を使うと、ARM ツールチェーンをとても簡単にインストールできます。`xpm install --global @xpack-dev-tools/arm-none-eabi-gcc` とコマンドを入力します。
+
+### Windows ビルドツール
+
+Windows を使っている場合は、これをインストールする必要があります！
+
+`xpm install --global @gnu-mcu-eclipse/windows-build-tools`
+
+### プログラマ/デバッガドライバ
+
+プログラマのドライバをインストールします。このチュートリアルはほとんどどこでも入手できる ST-Link v2 を使って作成されました。
+ST-Link を持っている場合は、ドライバは[ここ](https://www.st.com/en/development-tools/stsw-link009.html)で見つけることができます。そうでない場合はツールの製造元にお問い合わせください。
+
+### OpenOCD
+
+この依存関係により、SWD は GDB からアクセスでき、デバッグに不可欠です。`xpm install --global @xpack-dev-tools/openocd` を実行します。
+
+### Java
+
+Java は Eclipse で必要とされるため、[ここ](https://www.oracle.com/technetwork/java/javase/downloads/index.html)からダウンロードしてください。
+
+### GNU MCU Eclipse IDE
+
+最後に IDE をインストールする番です。[ここ](https://github.com/gnu-mcu-eclipse/org.eclipse.epp.packages/releases/)のリリースページから最新バージョンを取得します。
+
+## Eclipse の設定
+
+ダウンロードした Eclipse IDE を開きます。QMK ディレクトリをインポートするために、File -> Import -> C/C++ -> Existing Code as Makefile Project を選択します。Next を選択し、Browse を使用して QMK フォルダを選択します。tool-chain リストから ARM Cross GCC を選択し、Finish を選択します。
+
+これで、左側に QMK フォルダが表示されます。右クリックして、Properties を選択します。左側で MCU を展開し、ARM Toolchains Paths を選択します。xPack を押して OK を押します。OpenOCD Path で同じことを繰り返し、Windows の場合は、Build Tools Path でも同じことを繰り返します。Apply and Close を選択します。
+
+ここで、必要な MCU パッケージをインストールします。Window -> Perspective -> Open Perspective -> Other... -> Packs を選択して、Packs perspective に移動します。Packs タブの横にある黄色のリフレッシュ記号を選択します。これは様々な場所から MCU の定義を要求するため、時間が掛かります。一部のリンクが失敗した場合は、おそらく Ignore を選択できます。
+
+これが終了すると、ビルドやデバッグする MCU を見つけることができるはずです。この例では、STM32F3 シリーズの MCU を使います。左側で、STMicroelectronics -> STM32F3 Series を選択します。中央のウィンドウに、pack が表示されます。右クリックし、Install を選択します。それが終了したら、Window -> Perspective -> Open Perspective -> Other... -> C/C++ を選択してデフォルトのパースペクティブに戻ることができます。
+
+Eclipse に QMK をビルドしようとするデバイスを教える必要があります。QMK フォルダを右クリック -> Properties -> C/C++ Build -> Settings を選択します。Devices タブを選択し、Devices の下から MCU の適切な種類を選択します。私の例では、STM32F303CC です。
+
+この間に、Build コマンドもセットアップしましょう。C/C++ Build を選択し、Behavior タブを選択します。build コマンドのところで、`all` を必要な make コマンドに置き換えます。例えば、rev6 Planck の default キーマップの場合、これは `planck/rev6:default` になります。Apply and Close を選択します。
+
+## ビルド
+
+全て正しくセットアップできていれば、ハンマーボタンを押すとファームウェアがビルドされ、.binファイルが出力されるはずです。
+
+## デバッグ
+
+### デバッガの接続
+
+ARM MCU は、クロック信号(SWCLK) とデータ信号(SWDIO) で構成される Single Wire Debug (SWD) プロトコルを使います。MCUを 完全に操作するには、この2本のワイヤとグラウンドを接続するだけで十分です。ここでは、キーボードは USB を介して電力が供給されると想定しています。手動でリセットボタンを使えるため、RESET 信号は必要ありません。より高度なセットアップのために printf と scanf をホストに非同期にパイプする SWO 信号を使用できますが、私たちのセットアップでは無視します。
+
+注意: SWCLK と SWDIO ピンがキーボードのマトリックスで使われていないことを確認してください。もし使われている場合は、一時的に他のピンに切り替えることができます。
+
+### デバッガの設定
+
+QMK フォルダを右クリックし、Debug As -> Debug Configurations... を選択します。ここで、GDB OpenOCD Debugging をダブルクリックします。Debugger タブを選択し、MCU に必要な設定を入力します。これを見つけるにはいじったりググったりする必要があるかもしれません。STM32F3 用のデフォルトスクリプトは stm32f3discovery.cfg と呼ばれます。OpenOCD に伝えるには、Config options で `-f board/stm32f3discovery.cfg` と入力します。
+
+注意: 私の場合、この設定スクリプトはリセット操作を無効にするために編集が必要です。スクリプトの場所は、通常はパス `openocd/version/.content/scripts/board` の下の実際の実行可能フィールドの中で見つかります。ここで、私は `reset_config srst_only` を `reset_config none` に編集しました。
+
+Apply and Close を選択します。
+
+### デバッガの実行
+
+キーボードをリセットしてください。
+
+虫アイコンをクリックし、もし全てうまく行けば Debug パースペクティブに移動します。ここでは、main 関数の最初でプログラムカウンタが停止するので、Play ボタンを押します。全てのデバッガのほとんどの機能は ARM MCU で動作しますが、正確な詳細については google があなたのお友達です！
+
+
+ハッピーデバッギング！

docs/ja/cli.md

@@ -0,0 +1,227 @@
+# QMK CLI
+
+<!---
+  original document: d598f01cb:cli.md
+  git diff d598f01cb HEAD cli.md | cat
+-->
+
+このページは QMK CLI のセットアップと使用方法について説明します。
+
+# 概要
+
+QMK CLI を使用すると QMK キーボードの構築と作業が簡単になります。QMK ファームウェアの取得とコンパイル、キーマップの作成などのようなタスクを簡素化し合理化するためのコマンドを多く提供します。
+
+* [グローバル CLI](#global-cli)
+* [ローカル CLI](#local-cli)
+* [CLI コマンド](#cli-commands)
+
+# 必要事項
+
+CLI は Python 3.5 以上を必要とします。我々は必要事項の数を少なくしようとしていますが、[`requirements.txt`](https://github.com/qmk/qmk_firmware/blob/master/requirements.txt) にリストされているパッケージもインストールする必要があります。
+
+# グローバル CLI :id=global-cli
+
+QMK は、QMK ビルド環境のセットアップ、QMK の操作、および `qmk_firmware` の複数のコピーの操作を容易にできるインストール可能な CLI を提供します。これを定期的にインストールおよび更新することをお勧めします。
+
+## Homebrew を使ったインストール (macOS、いくつかの Linux)
+
+[Homebrew](https://brew.sh) をインストールしている場合は、タップして QMK をインストールすることができます:
+
+```
+brew tap qmk/qmk
+brew install qmk
+export QMK_HOME='~/qmk_firmware' # オプション、`qmk_firmware` の場所を設定します
+qmk setup  # これは `qmk/qmk_firmware` をクローンし、オプションでビルド環境をセットアップします
+```
+
+## easy_install あるいは pip を使ってインストール
+
+上のリストにあなたのシステムがない場合は、QMK を手動でインストールすることができます。最初に、python 3.5 (以降)をインストールしていて、pip をインストールしていることを確認してください。次に以下のコマンドを使って QMK をインストールします:
+
+```
+pip3 install qmk
+export QMK_HOME='~/qmk_firmware' # オプション、`qmk_firmware` の場所を設定します
+qmk setup  # これは `qmk/qmk_firmware` をクローンし、オプションでビルド環境をセットアップします
+```
+
+## 他のオペレーティングシステムのためのパッケージ
+
+より多くのオペレーティングシステム用に `qmk` パッケージを作成および保守する人を探しています。OS 用のパッケージを作成する場合は、以下のガイドラインに従ってください:
+
+* これらのガイドラインと矛盾する場合は、OS のベストプラクティスに従ってください
+   * 逸脱する場合は、理由をコメントに文章化してください。
+* virtualenv を使ってインストールしてください
+* 環境変数 `QMK_HOME` を設定して、ファームウェアソースを `~/qmk_firmware` 以外のどこかにチェックアウトするようにユーザに指示してください。
+
+# ローカル CLI :id=local-cli
+
+グローバル CLI を使いたくない場合は、`qmk_firmware` に付属のローカル CLI があります。`qmk_firmware/bin/qmk` で見つけることができます。任意のディレクトリから `qmk` コマンドを実行でき、常に `qmk_firmware` のコピー上で動作します。
+
+**例**:
+
+```
+$ ~/qmk_firmware/bin/qmk hello
+Ψ Hello, World!
+```
+
+## ローカル CLI の制限
+
+グローバル CLI と比較して、ローカル CLI には幾つかの制限があります:
+
+* ローカル CLI は `qmk setup` あるいは `qmk clone` をサポートしません。
+* 複数のリポジトリがクローンされている場合でも、ローカル CLI は常に `qmk_firmware` ツリー上で動作します。
+* ローカル CLI は virtualenv で動作しません。そのため依存関係が競合する可能性があります
+
+# CLI コマンド :id=cli-commands
+
+## `qmk cformat`
+
+このコマンドは clang-format を使って C コードを整形します。引数無しで実行して全てのコアコードを整形するか、コマンドラインでファイル名を渡して特定のファイルに対して実行します。
+
+**使用法**:
+
+```
+qmk cformat [file1] [file2] [...] [fileN]
+```
+
+## `qmk compile`
+
+このコマンドにより、任意のディレクトリからファームウェアをコンパイルすることができます。<https://config.qmk.fm> からエクスポートした JSON をコンパイルするか、リポジトリ内でキーマップをコンパイルすることができます。
+
+**Configurator Exports での使い方**:
+
+```
+qmk compile <configuratorExport.json>
+```
+
+**キーマップでの使い方**:
+
+```
+qmk compile -kb <keyboard_name> -km <keymap_name>
+```
+
+## `qmk flash`
+
+このコマンドは `qmk compile` に似ていますが、ブートローダを対象にすることもできます。ブートローダはオプションで、デフォルトでは `:flash` に設定されています。
+違うブートローダを指定するには、`-bl <bootloader>` を使ってください。利用可能なブートローダの詳細については、<https://docs.qmk.fm/#/ja/flashing>
+を見てください。
+
+**Configurator Exports での使い方**:
+
+```
+qmk flash <configuratorExport.json> -bl <bootloader>
+```
+
+**キーマップでの使い方**:
+
+```
+qmk flash -kb <keyboard_name> -km <keymap_name> -bl <bootloader>
+```
+
+**ブートローダのリスト**
+
+```
+qmk flash -b
+```
+
+## `qmk config`
+
+このコマンドにより QMK の挙動を設定することができます。完全な `qmk config` のドキュメントについては、[CLI 設定](ja/cli_configuration.md)を見てください。
+
+**使用法**:
+
+```
+qmk config [-ro] [config_token1] [config_token2] [...] [config_tokenN]
+```
+
+## `qmk docs`
+
+このコマンドは、ドキュメントを参照または改善するために使うことができるローカル HTTP サーバを起動します。デフォルトのポートは 8936 です。
+
+**使用法**:
+
+```
+qmk docs [-p PORT]
+```
+
+## `qmk doctor`
+
+このコマンドは環境を調査し、潜在的なビルドあるいは書き込みの問題について警告します。
+
+**使用法**:
+
+```
+qmk doctor
+```
+
+## `qmk json-keymap`
+
+QMK Configurator からエクスポートしたものから keymap.c を生成します。
+
+**使用法**:
+
+```
+qmk json-keymap [-o OUTPUT] filename
+```
+
+## `qmk kle2json`
+
+このコマンドにより、生の KLE データから QMK Configurator の JSON へ変換することができます。絶対パスあるいは現在のディレクトリ内のファイル名のいずれかを受け取ります。デフォルトでは、`info.json` が既に存在している場合は上書きしません。上書きするには、`-f` あるいは `--force` フラグを使ってください。
+
+**使用法**:
+
+```
+qmk kle2json [-f] <filename>
+```
+
+**例**:
+
+```
+$ qmk kle2json kle.txt 
+☒ File info.json already exists, use -f or --force to overwrite.
+```
+
+```
+$ qmk kle2json -f kle.txt -f
+Ψ Wrote out to info.json
+```
+
+## `qmk list-keyboards`
+
+このコマンドは現在 `qmk_firmware` で定義されている全てのキーボードをリスト化します。
+
+**使用法**:
+
+```
+qmk list-keyboards
+```
+
+## `qmk new-keymap`
+
+このコマンドは、キーボードの既存のデフォルトのキーマップに基づいて新しいキーマップを作成します。
+
+**使用法**:
+
+```
+qmk new-keymap [-kb KEYBOARD] [-km KEYMAP]
+```
+
+## `qmk pyformat`
+
+このコマンドは `qmk_firmware` 内の python コードを整形します。
+
+**使用法**:
+
+```
+qmk pyformat
+```
+
+## `qmk pytest`
+
+このコマンドは python のテストスィートを実行します。python コードに変更を加えた場合、これの実行が成功することを確認する必要があります。
+
+**使用法**:
+
+```
+qmk pytest
+```

docs/ja/cli_configuration.md

@@ -0,0 +1,126 @@
+# QMK CLI 設定
+
+<!---
+  original document: d598f01cb:cli_configuration.md
+  git diff d598f01cb HEAD cli_configuration.md | cat
+-->
+
+このドキュメントは `qmk config` がどのように動作するかを説明します。
+
+# はじめに
+
+QMK CLI の設定はキーバリューシステムです。各キーはピリオドで区切られたサブコマンドと引数名で構成されます。これにより、設定キーと設定された引数の間で簡単かつ直接的な変換が可能になります。
+
+## 簡単な例
+
+例として、`qmk compile --keyboard clueboard/66/rev4 --keymap default` コマンドを見てみましょう。
+
+設定から読み取ることができる2つのコマンドライン引数があります:
+
+* `compile.keyboard`
+* `compile.keymap`
+
+これらを設定してみましょう:
+
+```
+$ qmk config compile.keyboard=clueboard/66/rev4 compile.keymap=default
+compile.keyboard: None -> clueboard/66/rev4
+compile.keymap: None -> default
+Ψ Wrote configuration to '/Users/example/Library/Application Support/qmk/qmk.ini'
+```
+
+これで、毎回キーボードとキーマップを設定することなく、`qmk compile` を実行することができます。
+
+## ユーザデフォルトの設定
+
+複数のコマンド間で設定を共有したい場合があります。例えば、いくつかのコマンドは引数 `--keyboard` を受け取ります。全てのコマンドでこの値を設定する代わりに、その引数を受け取る全てのコマンドで使われるユーザ値を設定することができます。
+
+例:
+
+```
+$ qmk config user.keyboard=clueboard/66/rev4 user.keymap=default
+user.keyboard: None -> clueboard/66/rev4
+user.keymap: None -> default
+Ψ Wrote configuration to '/Users/example/Library/Application Support/qmk/qmk.ini'
+```
+
+# CLI ドキュメント (`qmk config`)
+
+`qmk config` コマンドは基礎となる設定とやり取りするために使われます。引数無しで実行すると、現在の設定を表示します。引数が指定された場合、それらは設定トークンと見なされます。設定トークンは以下の形式の空白を含まない文字列です:
+
+    <subcommand|general|default>[.<key>][=<value>]
+
+## 設定値の設定
+
+設定キーに等号 (=) を入れることで、設定値を設定することができます。キーは常に完全な `<section>.<key>` 形式である必要があります。
+
+例:
+
+```
+$ qmk config default.keymap=default
+default.keymap: None -> default
+Ψ Wrote configuration to '/Users/example/Library/Application Support/qmk/qmk.ini'
+```
+
+## 設定値の読み込み
+
+設定全体、単一のキー、あるいはセクション全体の設定値を読み取ることができます。1つ以上の値を表示するために複数のキーを指定することができます。
+
+### 全体の構成例
+
+    qmk config
+
+### セクション全体の例
+
+    qmk config compile
+
+### 単一キーの例
+
+    qmk config compile.keyboard
+
+### 複数キーの例
+
+    qmk config user compile.keyboard compile.keymap
+
+## 設定値の削除
+
+設定値を特別な文字列 `None` に設定することで、設定値を削除することができます。
+
+例:
+
+```
+$ qmk config default.keymap=None
+default.keymap: default -> None
+Ψ Wrote configuration to '/Users/example/Library/Application Support/qmk/qmk.ini'
+```
+
+## 複数の操作
+
+複数の読み込みおよび書き込み操作を1つのコマンドに組み合わせることができます。それらは順番に実行および表示されます:
+
+```
+$ qmk config compile default.keymap=default compile.keymap=None
+compile.keymap=skully
+compile.keyboard=clueboard/66_hotswap/gen1
+default.keymap: None -> default
+compile.keymap: skully -> None
+Ψ Wrote configuration to '/Users/example/Library/Application Support/qmk/qmk.ini'
+```
+
+# ユーザ設定オプション
+
+| キー | デフォルト値 | 説明 |
+|-----|---------------|-------------|
+| user.keyboard | None | キーボードのパス (例: `clueboard/66/rev4`) |
+| user.keymap | None | キーマップ名 (例: `default`) |
+| user.name | None | ユーザの github のユーザ名。 |
+
+# 全ての設定オプション
+
+| キー | デフォルト値 | 説明 |
+|-----|---------------|-------------|
+| compile.keyboard | None | キーボードのパス (例: `clueboard/66/rev4`) |
+| compile.keymap | None | キーマップ名 (例: `default`) |
+| hello.name | None | 実行時の挨拶の名前 |
+| new_keyboard.keyboard | None | キーボードのパス (例: `clueboard/66/rev4`) |
+| new_keyboard.keymap | None | キーマップ名 (例: `default`) |

docs/ja/config_options.md

@@ -0,0 +1,391 @@
+# QMK の設定
+
+<!---
+  original document: 0f43c2652:docs/config_options.md
+  git diff 0f43c2652 HEAD -- docs/config_options.md | cat
+-->
+
+QMK はほぼ無制限に設定可能です。可能なところはいかなるところでも、やりすぎな程、ユーザーがコードサイズを犠牲にしてでも彼らのキーボードをカスタマイズをすることを許しています。ただし、このレベルの柔軟性により設定が困難になります。
+
+QMK には主に２種類の設定ファイルがあります- `config.h` と `rules.mk`。これらのファイルは QMK の様々なレベルに存在し、同じ種類の全てのファイルは最終的な設定を構築するために組み合わされます。最低の優先度から最高の優先度までのレベルは以下の通りです:
+
+* QMK デフォルト
+* キーボード
+* フォルダ (最大5レべルの深さ)
+* キーマップ
+
+## QMK デフォルト
+
+QMK での全ての利用可能な設定にはデフォルトがあります。その設定がキーボード、フォルダ、あるいはキーマップレべルで設定されない場合、これが使用される設定です。
+
+## キーボード
+
+このレベルにはキーボード全体に適用される設定オプションが含まれています。一部の設定は、リビジョンあるいはほとんどのキーマップで変更されません。他の設定はこのキーボードのデフォルトに過ぎず、フォルダあるいはキーマップによって上書きされる可能性があります。
+
+## フォルダ
+
+一部のキーボードには、異なるハードウェア構成のためのフォルダとサブフォルダがあります。ほとんどのキーボードは深さ1のフォルダのみですが、QMK は最大深さ5のフォルダの構造をサポートします。各フォルダは、最終的な設定に組み込まれる独自の `config.h` と `rules.mk` ファイルを持つことができます。
+
+## キーマップ
+
+このレベルには特定のキーマップのための全てのオプションが含まれています。以前の定義を上書きしたい場合は、`#undef <variable>` を使って定義を解除し、エラー無しで再定義することができます。
+
+# `config.h` ファイル
+
+これは最初に include されるものの 1 つである C ヘッダファイルで、プロジェクト全体(もし含まれる場合)にわたって持続します。多くの変数をここで設定し、他の場所からアクセスすることができます。`config.h` ファイルでは、以下のもの以外の、他の `config.h`  ファイルやその他のファイルの include をしないでください:
+
+    #include "config_common.h"
+
+
+## ハードウェアオプション
+* `#define VENDOR_ID 0x1234`
+   * VID を定義します。ほとんどの DIY プロジェクトにおいて、任意のものを定義できます
+* `#define PRODUCT_ID 0x5678`
+   * PID を定義します。ほとんどの DIY プロジェクトでは、任意のものを定義できます
+* `#define DEVICE_VER 0`
+   * デバイスのバージョンを定義します (多くの場合リビジョンに使われます)
+* `#define MANUFACTURER Me`
+   * 一般的に、誰もしくはどのブランドがボードを作成したか
+* `#define PRODUCT Board`
+   * キーボードの名前
+* `#define DESCRIPTION a keyboard`
+   * キーボードの簡単な説明
+* `#define MATRIX_ROWS 5`
+   * キーボードのマトリックスの行の数
+* `#define MATRIX_COLS 15`
+   * キーボードのマトリックスの列の数
+* `#define MATRIX_ROW_PINS { D0, D5, B5, B6 }`
+   * 行のピン、上から下へ
+* `#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }`
+   * 列のピン、左から右へ
+* `#define UNUSED_PINS { D1, D2, D3, B1, B2, B3 }`
+   * 参考として、キーボードで使われていないピン
+* `#define MATRIX_HAS_GHOST`
+   * マトリックスにゴーストがあるか(ありそうにないか)定義します
+* `#define DIODE_DIRECTION COL2ROW`
+   * COL2ROW あるいは ROW2COL - マトリックスがどのように設定されているか。COL2ROW は、スイッチとロウ(行)ラインの間にダイオードが黒い印をロウ(行)ラインに向けて置いてあることを意味します。
+* `#define DIRECT_PINS { { F1, F0, B0, C7 }, { F4, F5, F6, F7 } }`
+   * ロウ(行)ラインとカラム(列)ラインにマップされているピンを左から右に。各スイッチが個別のピンとグラウンドに接続されているマトリックスを定義します。
+* `#define AUDIO_VOICES`
+   * (循環させるために)代替音声を有効にします
+* `#define C4_AUDIO`
+   * ピン C4 のオーディオを有効にします
+* `#define C5_AUDIO`
+   * ピン C5 のオーディオを有効にします
+* `#define C6_AUDIO`
+   * ピン C6 のオーディオを有効にします
+* `#define B5_AUDIO`
+   * ピン B5 のオーディオを有効にします (C[4-6]\_AUDIO の1つとともに B[5-7]\_AUDIO の1つが有効にされている場合、疑似ステレオが有効にされます)
+* `#define B6_AUDIO`
+   * ピン B6 のオーディオを有効にします (C[4-6]\_AUDIO の1つとともに B[5-7]\_AUDIO の1つが有効にされている場合、疑似ステレオが有効にされます)
+* `#define B7_AUDIO`
+   * ピン B7 のオーディオを有効にします (C[4-6]\_AUDIO の1つとともに B[5-7]\_AUDIO の1つが有効にされている場合、疑似ステレオが有効にされます)
+* `#define BACKLIGHT_PIN B7`
+   * バックライトのピン
+* `#define BACKLIGHT_LEVELS 3`
+   * バックライトのレベル数 (off を除いて最大15)
+* `#define BACKLIGHT_BREATHING`
+   * バックライトのブレスを有効にします
+* `#define BREATHING_PERIOD 6`
+   * 1つのバックライトの "ブレス" の長さの秒数
+* `#define DEBOUNCE 5`
+   * ピンの値を読み取る時の遅延 (5がデフォルト)
+* `#define LOCKING_SUPPORT_ENABLE`
+   * メカニカルロックのサポート。キーマップで KC_LCAP、 KC_LNUM そして KC_LSCR を使えるようにします
+* `#define LOCKING_RESYNC_ENABLE`
+   * キーボードの LED の状態をスイッチの状態と一致させ続けようとします
+* `#define IS_COMMAND() (get_mods() == MOD_MASK_SHIFT)`
+   * マジックコマンドの使用を可能にするキーの組み合わせ (デバッグに便利です)
+* `#define USB_MAX_POWER_CONSUMPTION 500`
+   * デバイスの USB 経由の最大電力(mA) を設定します (デフォルト: 500)
+* `#define USB_POLLING_INTERVAL_MS 10`
+   * キーボード、マウス および 共有 (NKRO/メディアキー) インタフェースのための USB ポーリングレートをミリ秒で設定します
+* `#define F_SCL 100000L`
+   * I2C を使用するキーボードのための I2C クロックレート速度を設定します。デフォルトは `400000L` ですが、`split_common` を使っているキーボードは別でデフォルトは `100000L` です。
+
+## 無効にできる機能
+
+これらのオプションを定義すると、関連する機能が無効になり、コードサイズを節約できます。
+
+* `#define NO_DEBUG`
+   * デバッグを無効にします
+* `#define NO_PRINT`
+   * hid_listen を使った出力やデバッグを無効にします
+* `#define NO_ACTION_LAYER`
+   * レイヤーを無効にします
+* `#define NO_ACTION_TAPPING`
+   * タップダンスと他のタップ機能を無効にします
+* `#define NO_ACTION_ONESHOT`
+   * ワンショットモディファイアを無効にします
+* `#define NO_ACTION_MACRO`
+   * 古い形式のマクロ処理を無効にします: MACRO() & action_get_macro
+* `#define NO_ACTION_FUNCTION`
+   * fn_actions 配列(非推奨)からの action_function() の呼び出しを無効にします 
+
+## 有効にできる機能
+
+これらのオプションを定義すると、関連する機能が有効になり、コードサイズが大きくなるかもしれません。
+
+* `#define FORCE_NKRO`
+   * NKRO をデフォルトでオンにする必要があります。これにより EEPROM の設定に関係なく、キーボードの起動時に NKRO が強制的にオンになります。NKRO は引き続きオフにできますが、キーボードを再起動すると再びオンになります。
+* `#define STRICT_LAYER_RELEASE`
+   * キーリリースがどのレイヤーから来たのかを覚えるのではなく、現在のレイヤースタックを使って強制的に評価されるようにします (高度なケースに使われます)
+
+## 設定可能な挙動
+
+* `#define TAPPING_TERM 200`
+   * タップがホールドになるまでの時間。500以上に設定された場合、タップ期間中にタップされたキーもホールドになります。(訳注: PERMISSIVE_HOLDも参照)
+* `#define TAPPING_TERM_PER_KEY`
+   * キーごとの `TAPPING_TERM` 設定の処理を有効にします
+* `#define RETRO_TAPPING`
+   * 押下とリリースの間に他のキーによる中断がなければ、TAPPING_TERM の後であってもとにかくタップします
+   * 詳細は [Retro Tapping](ja/feature_advanced_keycodes.md#retro-tapping) を見てください
+* `#define TAPPING_TOGGLE 2`
+   * トグルを引き起こす前のタップ数
+* `#define PERMISSIVE_HOLD`
+   * `TAPPING_TERM` にヒットしていなくても、リリースする前に別のキーが押されると、タップとフォールドキーがホールドを引き起こします
+   * 詳細は [Permissive Hold](ja/feature_advanced_keycodes.md#permissive-hold) を見てください
+* `#define IGNORE_MOD_TAP_INTERRUPT`
+   * 両方のキーに `TAPPING_TERM` を適用することで、ホールド時に他のキーに変換するキーを使ってローリングコンボ (zx) をすることができるようにします
+   * 詳細は [Mod tap interrupt](ja/feature_advanced_keycodes.md#ignore-mod-tap-interrupt) を見てください
+* `#define TAPPING_FORCE_HOLD`
+   * タップされた直後に、デュアルロールキーを修飾子として使用できるようにします
+   * [Hold after tap](ja/feature_advanced_keycodes.md#tapping-force-hold)を見てください
+   * タップトグル機能を無効にします (`TT` あるいは One Shot Tap Toggle)
+* `#define LEADER_TIMEOUT 300`
+   * リーダーキーがタイムアウトするまでの時間
+      * タイムアウトする前にシーケンスを終了できない場合は、タイムアウトの設定を増やす必要があるかもしれません。あるいは、`LEADER_PER_KEY_TIMING` オプションを有効にすると良いでしょう。これは各キーがタップされた後でタイムアウトを再設定します。
+* `#define LEADER_PER_KEY_TIMING`
+   * 全体では無く各キーを押すたびに実行されるリーダーキーコードのタイマーを設定します
+* `#define LEADER_KEY_STRICT_KEY_PROCESSING`
+   * Mod-Tap および Layer-Tap キーコードのためのキーコードフィルタリングを無効にします。例えば、これを有効にすると、`KC_A` を使いたい場合は `MT(MOD_CTL, KC_A)` を指定する必要があります。
+* `#define ONESHOT_TIMEOUT 300`
+   * ワンショットがタイムアウトするまでの時間
+* `#define ONESHOT_TAP_TOGGLE 2`
+   * ワンショットトグルが引き起こされるまでのタップ数
+* `#define QMK_KEYS_PER_SCAN 4`
+   * 走査ごとに1つ以上のキーを送信できるようにします。デフォルトでは、走査ごとに `process_record()` 経由で1つのキーイベントのみが送信されます。これはほとんどのタイピングにほとんど影響しませんが、多くのコードを入力しているか、走査レートが最初から遅い場合、キーイベントの処理に多少の遅延が生じる可能性があります。それぞれのプレスとリリースは別のイベントです。スキャン時間が 1ms 程度のキーボードの場合、とても高速なタイピストでさえ、実際にキーボードから数 ms 以上の遅延を発生させるのに必要な 500 キーストロークを1秒間に生成することはないでしょう。しかし、3～4ms の走査時間でコードを入力している場合はどうでしょうか？おそらくこれが必要です。
+* `#define COMBO_COUNT 2`
+   * [コンボ](ja/feature_combo.md)機能で使っているコンボの数にこれを設定します。
+* `#define COMBO_TERM 200`
+   * コンボキーが検出されるまでの時間。定義されていない場合は、デフォルトは `TAPPING_TERM` です。
+* `#define TAP_CODE_DELAY 100`
+   * 適切な登録に問題がある場合(VUSB ボードで珍しくない)、`register_code` と `unregister_code` の間の遅延を設定します。値はミリ秒です。
+* `#define TAP_HOLD_CAPS_DELAY 80`
+   * MacOS で特別な処理が行われるため、`KC_CAPSLOCK` を使う時にタップホールドキー (`LT`, `MT`) に遅延を設定します。この値はミリ秒で、定義されていない場合はデフォルトは80msです。macOS については、これを200以上に設定すると良いでしょう。
+
+## RGB ライト設定 :id=rgb-light-configuration
+
+* `#define RGB_DI_PIN D7`
+   * WS2812 の DI 端子につなぐピン
+* `#define RGBLIGHT_ANIMATIONS`
+   * RGB アニメーションを実行します
+* `#define RGBLED_NUM 12`
+   * LED の数
+* `#define RGBLIGHT_SPLIT`
+   * 分割キーボードの左半分の RGB LED の出力を右半分の RGB LED の入力につなげるかわりに、それぞれの側で個別にコントローラの出力ピンが直接 RGB LED の入力に繋がっているときは、この定義が必要です。
+* `#define RGBLED_SPLIT { 6, 6 }`
+   * 分割キーボードの各半分の `RGB_DI_PIN` に直接配線されている接続されているLEDの数
+   * 最初の値は左半分の LED の数を示し、2番目の値は右半分です。
+   * RGBLED_SPLIT が定義されている場合、RGBLIGHT_SPLIT は暗黙的に定義されます。
+* `#define RGBLIGHT_HUE_STEP 12`
+   * 色相の増減時のステップ単位
+* `#define RGBLIGHT_SAT_STEP 25`
+   * 彩度の増減時のステップ単位
+* `#define RGBLIGHT_VAL_STEP 12`
+   * 値(明度)の増減時のステップ単位
+* `#define RGBW`
+   * RGBW LED のサポートを有効にします
+
+## マウスキーオプション
+
+* `#define MOUSEKEY_INTERVAL 20`
+* `#define MOUSEKEY_DELAY 0`
+* `#define MOUSEKEY_TIME_TO_MAX 60`
+* `#define MOUSEKEY_MAX_SPEED 7`
+* `#define MOUSEKEY_WHEEL_DELAY 0`
+
+## 分割キーボードオプション
+
+分割キーボード固有のオプション。あなたの rules.mk に 'SPLIT_KEYBOARD = yes' が有ることを確認してください。
+
+* `SPLIT_TRANSPORT = custom`
+   * 標準の分割通信ルーチンをカスタムのものに置き換えることができます。現在、ARM ベースの分割キーボードはこれを使わなければなりません。
+
+### 左右の設定
+
+一つ覚えておかなければならないことは、USB ポートが接続されている側が常にマスター側であるということです。USB に接続されていない側はスレーブです。
+
+分割キーボードの左右を設定するには、幾つかの異なる方法があります (優先度の順にリストされています):
+
+1. `SPLIT_HAND_PIN` を設定します: 左右を決定するためにピンを読み込みます。ピンが high の場合、それが左側です。low であれば、その半分側が右側であると決定されます。
+2. `EE_HANDS` を設定し、各半分に `eeprom-lefthand.eep`/`eeprom-righthand.eep` を書き込みます
+   * DFU ブートローダを搭載したボードでは、これらの EEPROM ファイルを書き込むために `:dfu-split-left`/`:dfu-split-right` を使うことができます
+   * Caterina ブートローダを搭載したボード (標準的な Pro Micros など)では、`:avrdude-split-left`/`:avrdude-split-right` を使ってください
+   * ARM DFU ブートローダを搭載したボード (Proton C など)では、`:dfu-util-split-left`/`:dfu-util-split-right` を使ってください
+3. `MASTER_RIGHT` を設定します: USBポートに差し込まれた側はマスター側で右側であると決定されます(デフォルトの逆)
+4. デフォルト: USB ポートに差し込まれている側がマスター側であり、左側であると見なされます。スレーブ側は右側です
+
+#### 左右を定義します
+
+* `#define SPLIT_HAND_PIN B7`
+   * high/low ピンを使って左右を決定します。low = 右手、high = 左手。`B7` を使っているピンに置き換えます。これはオプションで、`SPLIT_HAND_PIN` が未定義のままである場合、EE_HANDS メソッドまたは標準の Let's Splitが使っている MASTER_LEFT / MASTER_RIGHT 定義をまだ使うことができます。
+
+* `#define EE_HANDS` (`SPLIT_HAND_PIN` が定義されていない場合のみ動作します)
+   * `eeprom-lefthand.eep`/`eeprom-righthand.eep` がそれぞれの半分に書き込まれた後で、EEPROM 内に格納されている左右の設定の値を読み込みます。
+
+* `#define MASTER_RIGHT`
+   * マスター側が右側と定義されます。
+
+### 他のオプション
+
+* `#define USE_I2C`
+   * Serial の代わりに I2C を使う場合 (デフォルトは serial)
+
+* `#define SOFT_SERIAL_PIN D0`
+   * serial を使う場合、これを定義します。`D0` あるいは `D1`,`D2`,`D3`,`E6`。
+
+* `#define MATRIX_ROW_PINS_RIGHT { <row pins> }`
+* `#define MATRIX_COL_PINS_RIGHT { <col pins> }`
+   * 右半分に左半分と異なるピン配置を指定したい場合は、`MATRIX_ROW_PINS_RIGHT`/`MATRIX_COL_PINS_RIGHT` を定義することができます。現在のところ、`MATRIX_ROW_PINS` のサイズは `MATRIX_ROW_PINS_RIGHT` と同じでなければならず、列の定義も同様です。
+
+* `#define DIRECT_PINS_RIGHT { { F1, F0, B0, C7 }, { F4, F5, F6, F7 } }`
+   * 右半分に左半分と異なる直接ピン配置を指定したい場合は、`DIRECT_PINS_RIGHT` を定義することができます。現在のところ、`DIRECT_PINS` のサイズは `DIRECT_PINS_RIGHT` と同じでなければなりません。
+
+* `#define RGBLED_SPLIT { 6, 6 }`
+   * [RGB ライト設定](#rgb-light-configuration)を見てください。
+
+* `#define SELECT_SOFT_SERIAL_SPEED <speed>` (デフォルトの速度は1です)
+   * serial 通信を使う時のプロトコルの速度を設定します。
+   * 速度:
+      * 0: 約189kbps (実験目的のみ)
+      * 1: 約 137kbps (デフォルト)
+      * 2: 約 75kbps
+      * 3: 約 39kbps
+      * 4: 約 26kbps
+      * 5: 約 20kbps
+
+* `#define SPLIT_USB_DETECT`
+   * マスタ/スレーブを委任する時に(タイムアウト付きで) USB 接続を検出します
+   * ARM についてはデフォルトの挙動
+   * AVR Teensy については必須
+
+* `#define SPLIT_USB_TIMEOUT 2500`
+   * `SPLIT_USB_DETECT` を使う時のマスタ/スレーブを検出する場合の最大タイムアウト
+
+# `rules.mk` ファイル
+
+これは、トップレベルの `Makefile` から include される [make](https://www.gnu.org/software/make/manual/make.html) ファイルです。これは特定の機能を有効または無効にするだけでなく、コンパイルする MCU に関する情報を設定するために使われます。
+
+## ビルドオプション
+
+* `DEFAULT_FOLDER`
+   * キーボードに1つ以上のサブフォルダがある場合にデフォルトのフォルダを指定するために使われます。
+* `FIRMWARE_FORMAT`
+   * ビルドの後でルート `qmk_firmware` フォルダにコピーされる形式 (bin, hex) を定義します。
+* `SRC`
+   * コンパイル・リンクリストにファイルを追加するために使われます。
+* `LIB_SRC`
+  * コンパイル・リンクリストにライブラリとしてファイルを追加するために使われます。  
+    `LIB_SRC` で指定されたファイルは、`SRC` で指定されたファイルの後にリンクされます。  
+    例えば、次のように指定した場合:
+    ```
+    SRC += a.c
+    LIB_SRC += lib_b.c
+    SRC += c.c
+    LIB_SRC += lib_d.c
+    ```
+    リンク順は以下の通りです。
+    ```
+     ...  a.o c.o  ...  lib_b.a lib_d.a  ...
+    ```
+* `LAYOUTS`
+   * このキーボードがサポートする[レイアウト](ja/feature_layouts.md)のリスト
+* `LINK_TIME_OPTIMIZATION_ENABLE`
+   * キーボードをコンパイルする時に、Link Time Optimization (`LTO`) を有効にします。これは処理に時間が掛かりますが、コンパイルされたサイズを大幅に減らします (そして、ファームウェアが小さいため、追加の時間は分からないくらいです)。ただし、`LTO` が有効な場合、古いマクロと関数の機能が壊れるため、自動的にこれらの機能を無効にします。これは `NO_ACTION_MACRO` と `NO_ACTION_FUNCTION` を自動的に定義することで行われます。
+* `LTO_ENABLE`
+   * LINK_TIME_OPTIMIZATION_ENABLE と同じ意味です。`LINK_TIME_OPTIMIZATION_ENABLE` の代わりに `LTO_ENABLE` を使うことができます。
+
+## AVR MCU オプション
+* `MCU = atmega32u4`
+* `F_CPU = 16000000`
+* `ARCH = AVR8`
+* `F_USB = $(F_CPU)`
+* `OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT`
+* `BOOTLOADER = atmel-dfu` と以下のオプション:
+   * `atmel-dfu`
+   * `lufa-dfu`
+   * `qmk-dfu`
+   * `halfkay`
+   * `caterina`
+   * `bootloadHID`
+   * `USBasp`
+
+## 機能オプション
+
+これらを使って特定の機能のビルドを有効または無効にします。有効にすればするほどファームウェアが大きくなり、MCU には大きすぎるファームウェアを構築するリスクがあります。
+
+* `BOOTMAGIC_ENABLE`
+   * 仮想 DIP スイッチ設定
+* `MOUSEKEY_ENABLE`
+   * マウスキー
+* `EXTRAKEY_ENABLE`
+   * オーディオ制御とシステム制御
+* `CONSOLE_ENABLE`
+   * デバッグ用コンソール
+* `COMMAND_ENABLE`
+   * デバッグ及び設定用のコマンド
+* `COMBO_ENABLE`
+   * キーコンボ機能
+* `NKRO_ENABLE`
+   * USB N-キーロールオーバー - これが動作しない場合は、ここを見てください: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+* `AUDIO_ENABLE`
+   * オーディオサブシステムを有効にします。
+* `RGBLIGHT_ENABLE`
+   * キーボードアンダーライト機能を有効にします
+* `LEADER_ENABLE`
+   * リーダーキーコードを有効にします
+* `MIDI_ENABLE`
+   * MIDI 制御
+* `UNICODE_ENABLE`
+   * Unicode
+* `BLUETOOTH_ENABLE`
+   * Adafruit EZ-Key HID で Bluetooth を有効にするレガシーオプション。BLUETOOTH を見てください
+* `BLUETOOTH`
+   * 現在のオプションは、AdafruitEzKey、AdafruitBLE、RN42
+* `SPLIT_KEYBOARD`
+   * 分割キーボード (let's split や bakingpy のキーボードのようなデュアル MCU) のサポートを有効にし、quantum/split_common にある全ての必要なファイルをインクルードします
+* `CUSTOM_MATRIX`
+   * 標準マトリックス走査ルーチンを独自のものに置き換えることができます。
+* `DEBOUNCE_TYPE`
+   * 標準キーデバウンスルーチンを代替または独自のものに置き換えることができます。
+* `WAIT_FOR_USB`
+   * キーボードが起動する前に、USB 接続が確立されるのをキーボードに待機させます
+* `NO_USB_STARTUP_CHECK`
+   * キーボードの起動後の usb サスペンドチェックを無効にします。通常、キーボードはタスクが実行される前にホストがウェイク アップするのを待ちます。分割キーボードは半分はウェイクアップコールを取得できませんが、マスタにコマンドを送信する必要があるため、役に立ちます。
+
+## USB エンドポイントの制限
+
+USB 経由でサービスを提供するために、QMK は USB エンドポイントを使う必要があります。
+これらは有限なリソースです: 各マイクロコントローラは特定の数しか持ちません。
+これは一緒に有効にできる機能を制限します。
+利用可能なエンドポイントを超えると、ビルドエラーをひきおこします。
+
+以下の機能は個別のエンドポイントを必要とするかもしれません:
+
+* `MOUSEKEY_ENABLE`
+* `EXTRAKEY_ENABLE`
+* `CONSOLE_ENABLE`
+* `NKRO_ENABLE`
+* `MIDI_ENABLE`
+* `RAW_ENABLE`
+* `VIRTSER_ENABLE`
+
+エンドポイントの使用率を向上させるために、HID 機能を組み合わせて1つのエンドポイントを使うようにすることができます。
+デフォルトでは、`MOUSEKEY`、`EXTRAKEY` および `NKRO` が単一のエンドポイントに結合されます。
+
+基本キーボード機能も、`KEYBOARD_SHARED_EP = yes` を設定することで同じエンドポイントに結合することができます。
+これによりもう1つのエンドポイントが解放されますが、一部の BIOS ではブートキーボードプロトコルの切り替えを実装しないため、キーボードが動作しなくなるかもしれません。
+
+マウスの結合も、ブートマウス互換性を破壊します。
+この機能が必要な場合は、`MOUSE_SHARED_EP = no` を設定することで、マウスを結合しないようにすることができます。

docs/ja/contributing.md

@@ -0,0 +1,173 @@
+# 貢献方法
+
+<!---
+  original document: d47809575:docs/contributing.md
+  git diff d47809575 HEAD docs/contributing.md | cat
+-->
+
+👍🎉 まず、これを読み貢献する時間を作ってくれてありがとうございます！🎉👍
+
+サードパーティの貢献は、QMK の成長と改善に役立ちます。プルリクエストと貢献プロセスを貢献者とメンテナの両方にとって便利で簡単なものにしたいです。この目的のために、大きな変更をせずにプルリクエストが受け入れられるように貢献者向けのガイドラインをまとめました。
+
+* [プロジェクトの概要](#project-overview)
+* [コーディング規約](#coding-conventions)
+* [一般的なガイドライン](#general-guidelines)
+* [行動規範は私にとって何を意味しますか？](#what-does-the-code-of-conduct-mean-for-me)
+
+## この全てを読みたくはありません！単純に質問があります！
+
+QMK について質問したい場合は、[OLKB Subreddit](https://reddit.com/r/olkb) あるいは [Discord](https://discord.gg/Uq7gcHh) ですることができます。
+
+以下の事を覚えておいてください:
+
+* 誰かがあなたの質問に答えるのに数時間掛かるかもしれません。しばらくお待ちください！
+* QMK に関わる全ての人が彼らの時間とエネルギーを提供しています。QMK に関する作業や質問への回答に対する報酬はありません。
+* できるだけ簡単に答えられるように質問してみてください。その方法が分からない場合は、以下に幾つかの良いガイドがあります:
+   * https://opensource.com/life/16/10/how-ask-technical-questions
+   * http://www.catb.org/esr/faqs/smart-questions.html
+
+# プロジェクトの概要 :id=project-overview
+
+QMK は主に C で書かれており、特定の機能と部品は C++ で書かれています。QMK は、キーボードの中の組み込みプロセッサ、特に AVR ([LUFA](http://www.fourwalledcubicle.com/LUFA.php)) と ARM ([ChibiOS](http://www.chibios.com)) を対象にしています。すでに Arduino プログラミングに精通している場合は、多くの概念と制限がおなじみのものです。QMK に貢献するには Arduino を使用した経験は必要ありません。
+
+<!-- FIXME: We should include a list of resources for learning C here. -->
+
+# どこで助けを得られますか？
+
+助けが必要であれば、[issue を開く](https://github.com/qmk/qmk_firmware/issues) か [Discord で会話する](https://discord.gg/Uq7gcHh)ことができます。
+
+# どうやって貢献することができますか？
+
+以前にオープンソースに貢献したことはありませんか？ QMK で貢献がどのように機能するかが疑問ですか？ ここに簡単な説明があります！
+
+0. [GitHub](https://github.com) アカウントにサインアップします。
+1. 貢献するためのキーマップをまとめるか、解決に興味がある[問題を見つける](https://github.com/qmk/qmk_firmware/issues)、あるいは追加したい[機能](https://github.com/qmk/qmk_firmware/issues?q=is%3Aopen+is%3Aissue+label%3Afeature)を見つけます。
+2. 問題に関連付けられているリポジトリをあなたの GitHub アカウントにフォークします。これは、`GitHub上のあなたのユーザー名/qmk_firmware` の下にリポジトリのコピーを持つことを意味します。
+3. `git clone https://github.com/GitHub上のあなたのユーザー名/repository-name.git` を使ってローカルマシンにリポジトリをクローンします。
+4. 新しい機能に取り組んでいる場合は、issue を開きこれから行う作業について話し合うことを検討してください。
+5. `git checkout -b branch-name-here` を使って修正用の新しいブランチを作成します。
+6. 解決しようとしている問題、あるいは追加したい機能について適切な変更を加えます。
+7. `git add insert-paths-of-changed-files-here` を使って変更されたファイルの内容を git がプロジェクトの状態を管理するために使用する "snapshot"、インデックスとしても知られている、に追加します。
+8. `git commit -m "Insert a short message of the changes made here"` を使って、説明的なメッセージとともにインデックスの内容を保存します。
+9. `git push origin branch-name-here` を使って GitHub 上のリポジトリに変更をプッシュします。
+10. プルリクエストを [QMK Firmware](https://github.com/qmk/qmk_firmware/pull/new/master) にサブミットします。
+11. 行われた変更の簡単な説明と、変更に関する問題またはバグ番号を使って、プルリクエストにタイトルを付けます。例えば、issue に "Added more log outputting to resolve #4352" のようなタイトルをつけることができます。
+12. プルリクエストの説明では、行った変更、行ったプルリクエストに存在すると思われる問題、およびメンテナに対する質問を説明します。プルリクエストが完ぺきではない場合(プルリクエストが無い場合)でも問題ありません。レビュワーが問題の修正と改善を手伝います。
+13. プルリクエストがメンテナによってレビューされるのを待ちます。
+14. レビューをしているメンテナが変更を推奨する場合は、プルリクエストに変更を加えます。
+15. プルリクエストがマージされた後で成功を祝います！
+
+# コーディング規約 :id=coding-conventions
+
+私たちのスタイルのほとんどは簡単に理解できます。C あるいは Python のいずれかに精通している場合は、ローカルスタイルにそれほど問題はないはずです。
+
+* [コーディング規約 - C](ja/coding_conventions_c.md)
+* [コーディング規約 - Python](ja/coding_conventions_python.md)
+
+# 一般的なガイドライン :id=general-guidelines
+
+QMK には幾つかの異なるタイプの変更があり、それぞれ異なるレベルの厳密さが必要です。どのような種類の変更を行っても、次のガイドラインに留意してください。
+
+* PR を論理単位に分割します。例えば、2つの個別の機能をカバーする1つの PR を送信するのではなく、代わりに機能ごとに個別の PR をサブミットします。
+* コミットする前に、`git diff --check` を使って不要な空白を確認します。
+* コードの変更が実際にコンパイルされることを確認してください。
+   * キーマップ: `make keyboard:your_new_keymap` がエラーを返さないことを確認してください。
+   * キーボード: `make keyboard:all` がエラーを返さないことを確認してください。
+   * コア: `make all` がエラーを返さないことを確認してください。
+* コミットメッセージがそれ自体で理解できることを確認してください。最初の行に短い説明(70文字以内)を入れ、2行目は空にし、3行目以降では必要に応じてコミットを詳細に説明する必要があります。例:
+
+```
+kerpleplork の fronzlebop を調整します
+
+kerpleplork はエラーコード 23 で連続的に失敗していました。根本的な原因は fronzlebop 設定で、これにより kerpleplork はN回の繰り返しごとにアクティブになります。
+
+私が使用できるデバイスの限られた実験では、kerpleplork の混乱を避けるために 7 は十分高い値であることを示していますが、念のため ARM デバイスを持つ人たちからフィードバックを得たいです。
+```
+
+!> **重要:** デフォルト以外のキーマップ、ユーザスペースおよびレイアウトのようなユーザコードへのバグ修正あるいは改善に貢献したい場合は、PR にコードの元の提出者にタグをつけてください。Git と GitHub のスキルレベルに関係なく、多くのユーザは知らないうちにコードが変更されることに混乱したりイライラしたりするかもしれません。
+
+## ドキュメント
+
+ドキュメントは QMK への貢献を始める最も簡単な方法の1つです。ドキュメントが間違っているか不完全な場所を見つけ、これらを修正するのは簡単です！私たちもドキュメントを編集する人を非常に必要としています。編集するスキルがあるが、どこにどのように飛び乗ればいいのか分からない場合は、[助けをもとめて](#where-can-i-go-for-help)ください！
+
+全てのドキュメントは `qmk_firmware/docs` ディレクトリの中にあります。あるいは web ベースのワークフローを使いたい場合は、https://docs.qmk.fm/ の各ページの下部にある "Edit this page" リンクをクリックすることができます。
+
+ドキュメントの中にコードの例を提供する場合は、ドキュメント内の他の場所で使用されている命名規則を順守してください。例えば、一貫性を保つために、`my_layers` あるいは `my_keycodes` として列挙型を標準化します:
+
+```c
+enum my_layers {
+  _FIRST_LAYER,
+  _SECOND_LAYER
+};
+
+enum my_keycodes {
+  FIRST_LAYER = SAFE_RANGE,
+  SECOND_LAYER
+};
+```
+
+### ドキュメントのプレビュー
+
+開発環境をセットアップした場合は、プルリクエストを開く前に以下のコマンドを `qmk_firmware/` フォルダから実行することで、あなたの変更をプレビューすることができます:
+
+    ./bin/qmk docs
+
+または、Python 3 のみがインストールされている場合:
+
+    python3 -m http.server 8936
+
+その後、ウェブブラウザで、`http://localhost:8936/` を表示します。
+
+## キーマップ
+
+ほとんどの初めての QMK 貢献者は、個人のキーマップから始めます。キーマップの標準はかなりカジュアルなものにしようとしています(キーマップは結局のところ作成者の性格を反映しています)が、他の人があなたのキーマップを簡単に見つけて学ぶことができるように、これらのガイドラインに従うようにお願いします。
+
+* [the template](documentation_templates.md) を使って `readme.md` を書きます。
+* 全てのキーマップの PR は squash されるため、コミットがどのように squash されるかを気にする場合は、自分で行う必要があります。
+* キーマップの PR に機能をまとめないでください。最初に機能をサブミットし、次にキーマップのための2つ目の PR をサブミットします。
+* `Makefile` をキーマップフォルダに含めないでください(もう使われていません)。
+* ファイルヘッダの著作権を更新します (`%YOUR_NAME%` を探します)
+
+## キーボード
+
+キーボードは QMK の存在理由です。一部のキーボードはコミュニティによって管理されていますが、他のキーボードはそれぞれのキーボードを作成する責任者によって管理されています。`readme.md` を見るとそのキーボードを管理しているのが誰かが分かります。特定のキーボードに関する質問がある場合、[Issue を開いて](https://github.com/qmk/qmk_firmware/issues)質問にメンテナをタグ付けしてください。(訳注: タグ付け は [メンションする](https://help.github.com/ja/github/writing-on-github/basic-writing-and-formatting-syntax#mentioning-people-and-teams) という意味です。)
+
+また以下のガイドラインに従うことをお願いします:
+
+* [the template](ja/documentation_templates.md) を使って `readme.md` を書きます。
+* コミットの数を適切に保ってください。そうでなければあなたの PR を squash します。
+* コア機能を新しいキーボードにまとめないでください。最初に機能をサブミットし、次にキーボード用に別の PR をサブミットしてください。
+* `.c`/`.h` ファイルにすぐ上の親フォルダに従って名前を付けます。例えば、`/keyboards/<kb1>/<kb2>/<kb2>.[ch]`
+* `Makefile` をキーボードフォルダに含めないでください(もう使われていません)
+* ファイルヘッダの著作権を更新します (`%YOUR_NAME%` を探します)
+
+## Quantum/TMK コア
+
+新しい機能をビルドするために多くの作業を行う前に、最適な方法で実装していることを確認する必要があります。[QMK の理解](ja/understanding_qmk.md)を読むことで、QMK の基本的な理解を得ることができます。これはあなたを QMK のプログラムフローのツアーに連れて行きます。ここから、あなたのアイデアを実装するための最良の方法の感覚をつかむために、私たちと話す必要があります。これを行うには主に2つの方法があります:
+
+* [Discord でのチャット](https://discord.gg/Uq7gcHh)
+* [Issue を開く](https://github.com/qmk/qmk_firmware/issues/new)
+
+機能とバグ修正の PR は全てのキーボードに影響します。また、私たちは QMK の再編も進めています。このため、実装が行われる前に特に重要な変更について議論することが特に重要です。最初に私たちと話をせずに PR を開いた場合、あなたの選択が私たちの計画した方向とうまく合わない場合は幾つかの大きな再作業を行う覚悟をしてください。
+
+機能やバグの修正に取り組む時に留意すべき幾つかの事があります。
+
+* **デフォルトで無効** - QMK がサポートするほとんどのチップでメモリがかなり制限されており、現在のキーマップが壊れていないことが重要です。ですので、あなたの機能をオフにするのではなく**オン**にするようにしてください。デフォルトでオンにすべき場合、あるいはコードのサイズを小さくする必要がある場合は、相談してください。
+* **サブミットする前にローカルでコンパイル** - これが明白であることを願っていますが、コンパイルする必要があります。私たちの Travis システムは全ての問題をキャッチしますが、結果が返ってくるのを待つ代わりに幾つかのキーボードをローカルでコンパイルする方が一般的に速いです。
+* **リビジョンと異なるチップベースを考慮** - 僅かに異なる設定、さらには異なるチップベースを可能にするリビジョンを持つキーボードが幾つかあります。ARM および AVR でサポートされる機能を作成する、あるいは動作しないプラットフォームでは自動的に無効化するようにしてください。
+* **機能の説明** - 新しいファイルあるいは既存のファイルの一部として、`docs/` の中に文章化します。文章化しないと、他の人はあなたの苦労から利益を得ることができません。
+
+また以下のガイドラインに従うことをお願いします:
+
+* コミットの数を適切に保ってください。そうでなければあなたの PR を squash します。
+* キーボードあるいはキーマップをコアの変更にまとめないでください。コアの変更を最初にサブミットしてください。
+* 機能のための[ユニット テスト](ja/unit_testing.md)を書いてください。
+* 編集しているファイルのスタイルに従ってください。スタイルが明確でないか、スタイルが混在している場合は、上記の[コーディング規約](#coding-conventions)に準拠する必要があります。
+
+## リファクタリング
+
+QMK で物事がどのようにレイアウトされるかについて明確なビジョンを維持するために、私たちはリファクタリングを詳細に計画し、変更をする協力者がいます。リファクタリングのアイデアあるいは提案がある場合は、[issue を開いてください](https://github.com/qmk/qmk_firmware/issues)。QMK を改善する方法についてお話ししたいと思います。
+
+# 行動規範は私にとって何を意味しますか？ :id=what-does-the-code-of-conduct-mean-for-me
+
+私たちの[行動規範](https://github.com/qmk/qmk_firmware/blob/master/CODE_OF_CONDUCT.md)は、身元に関係なくあなたがプロジェクトの全員を敬意と礼儀を持って扱う責任があることを意味します。あなたが行動規範に記載されている不適切な行動やコメントの被害者である場合は、私たちはあなたのためにここにおり、私たちのコードに従って虐待者が適切に懲戒されるように最善を尽くします。

docs/ja/driver_installation_zadig.md

@@ -0,0 +1,53 @@
+# Zadig を使ったブートローダドライバのインストール
+
+<!---
+  original document: d598f01cb:docs/driver_installation_zadig.md
+  git diff d598f01cb HEAD docs/driver_installation_zadig.md | cat
+-->
+
+QMK はホストにたいして通常の HID キーボードデバイスとして振る舞うため特別なドライバは必要ありません。しかし、Windows でのキーボードへの書き込みは、多くの場合、キーボードをリセットした時に現れるブートローダデバイスで*行います*。
+
+2つの注目すべき例外があります: 通常 Pro Micro で見られる Caterina ブートローダや、PJRC Teensy に書き込まれている HalfKay ブートローダは、それぞれシリアルポートと汎用 HID デバイスとして振る舞うため、ドライバは必要ありません。
+
+[Zadig](https://zadig.akeo.ie/) ユーティリティを使うことをお勧めします。MSYS2 あるいは WSL を使って開発環境をセットアップした場合、`qmk_install.sh` スクリプトはドライバをインストールするかどうかをたずねます。
+
+## インストール
+
+`RESET` キーコード (別のレイヤにあるかもしれません)を押すか、通常はキーボードの下面にあるリセットスイッチを押して、キーボードをブートローダモードにします。どちらもキーボードに無い場合は、Escape または Space+`B` を押しながら接続してみてください (詳細は、[ブートマジック](ja/feature_bootmagic.md) ドキュメントを見てください)。一部のキーボードはブートマジックの代わりに[コマンド](ja/feature_command.md)を使います。この場合、キーボードが接続されている状態で「左Shift + 右Shift + `B`」あるいは「左Shift + 右Shift + Escape」を押すと、ブートローダモードに入ることができます。
+一部のキーボードはブートローダに入るために特定の操作をする必要があります。例えば、[ブートマジック Lite](ja/feature_bootmagic.md#bootmagic-lite) キー (デフォルト: Escape) は別のキー(例えば、左Control)かもしれません。また、コマンドを有効にするキーの組み合わせ (デフォルト: 左Shift + 右Shift) は何か他のキー(例えば 左Control + 右Control)を押し続ける必要がある場合があります。不明な場合は、キーボードの README ファイルを参照してください。
+
+USBaspLoader を使ってデバイスをブートローダモードにするには、`BOOT` ボタンを押しながら `RESET` ボタンをタップしてください。
+あるいは `BOOT` を押し続けながら USB ケーブルを挿入します。
+
+Zadig は自動的にブートローダデバイスを検知します。**Options → List All Devices** を確認する必要がある場合があります。
+
+- Atmel AVR MCU を搭載したキーボードの場合、ブートローダは `ATm32U4DFU` に似た名前が付けられ、ベンダー ID は `03EB` です。
+- USBasp ブートローダは `USBasp` として表示され、VID/PID は`16C0:05DC` です。
+- QMK-DFU ブートローダを使って書き込まれた AVR キーボードは `<keyboard name> Bootloader` という名前が付けられ、VID は `03EB` です。
+- ほとんどの ARM キーボードでは、`STM32 BOOTLOADER` と呼ばれ、VID/PID は `0483:DF11` です。
+
+!> Zadig が `HidUsb` ドライバを使用する1つ以上のデバイスを表示する場合、キーボードはおそらくブートローダモードではありません。矢印はオレンジ色になり、システムドライバの変更を確認するように求められます。この場合、続行**しないでください**！
+
+矢印が緑色で表示されたら、ドライバを選択し、**Install Driver** をクリックします。`libusb-win32` ドライバは通常 AVR で動作し、`WinUSB`は ARM で動作しますが、それでもキーボードに書き込みできない場合は、リストから異なるドライバをインストールしてみてください。msys2 を使ってコマンドライン経由で USBaspLoader デバイスに書き込むには、`libusbk` ドライバがお勧めです。そうではなく書き込みに QMK Toolbox を使っている場合は `libusb-win32` がうまく動作します。
+
+![ブートローダドライバが正常にインストールされた Zadig](https://i.imgur.com/b8VgXzx.png)
+
+最後に、新しいドライバがロードされたことを確認するためにキーボードのプラグを抜いて再接続します。書き込みに QMK Toolbox を使う場合は、ドライバの変更を認識しない場合があるため、QMK Toolkit を終了して再起動します。
+
+## 間違ったデバイスのインストールからの回復
+
+キーボードが入力できなくなった場合は、ブートローダではなくキーボード自体のドライバを間違って入れ替えた可能性があります。これはキーボードがブートローダモードでない場合に起こりえます。これは Zadig で簡単に確認することができます - 健全なキーボードには、全てのインタフェースに `HidUsb` ドライバがインストールされています:
+
+![Zadig から見た健全なキーボード](https://i.imgur.com/Hx0E5kC.png)
+
+デバイスマネージャーを開き、キーボードと思われるデバイスを探します。
+
+![デバイスマネージャーにおける、間違ったドライバがインストールされたキーボード](https://i.imgur.com/L3wvX8f.png)
+
+右クリックし、**デバイスのアンインストール** をクリックします。最初に **このデバイスのドライバーソフトウェアを削除します** にチェックが付いていることを確認してください。
+
+!["ドライバの削除"にチェックボックスにチェックが付いた、デバイスのアンインストールダイアログ](https://i.imgur.com/aEs2RuA.png)
+
+**Action → Scan for hardware changes** をクリックします。この時点で、再び入力できるようになっているはずです。Zadig でキーボードデバイスが `HidUsb` ドライバを使っていることを再確認します。そうであれば完了です。キーボードは再び機能するはずです！
+
+?> Windows が新しいドライバを使えるようにするために、この時点でコンピュータを完全に再起動する必要があるかもしれません。

docs/ja/faq.md

@@ -0,0 +1,11 @@
+# よくある質問
+
+<!---
+  original document: d598f01cb:docs/faq.md
+  git diff d598f01cb HEAD docs/faq.md | cat
+-->
+
+* [一般](ja/faq_general.md)
+* [QMK のビルドあるいはコンパイル](ja/faq_build.md)
+* [QMK のデバッグとトラブルシューティング](ja/faq_debug.md)
+* [キーマップ](ja/faq_keymap.md)