Update Norwegian keymap and add sendstring LUT (#8300)

* rename backlight_soft to match rules.mk

* rename backlight_soft to match rules.mk - update common_features

* Carve out a better location for private driver backlight functionality

.github/workflows/cli.yml

@@ -0,0 +1,28 @@
+name: CLI CI
+
+on:
+  push:
+    branches:
+    - master
+    - future
+  pull_request:
+    paths:
+    - 'lib/python/**'
+    - 'bin/qmk'
+    - 'requirements.txt'
+    - '.github/workflows/cli.yml'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    container: qmkfm/base_container
+
+    steps:
+    - uses: actions/checkout@v1
+      with:
+        submodules: recursive
+    - name: Install dependencies
+      run: pip3 install -r requirements.txt
+    - name: Run tests
+      run: bin/qmk pytest

.gitignore

@@ -63,9 +63,6 @@ util/Win_Check_Output.txt
 *.gif
 *.jpg
 
-# Do not ignore MiniDox left/right hand eeprom files
-!keyboards/minidox/*.eep
-
 # things travis sees
 secrets.tar
 id_rsa_*
@@ -73,3 +70,6 @@ id_rsa_*
 
 # python things
 __pycache__
+
+# prerequisites for updating ChibiOS
+/util/fmpp*

.gitmodules

@@ -1,13 +1,15 @@
 [submodule "lib/chibios"]
 	path = lib/chibios
 	url = https://github.com/qmk/ChibiOS
+	branch = master
 [submodule "lib/chibios-contrib"]
 	path = lib/chibios-contrib
 	url = https://github.com/qmk/ChibiOS-Contrib
-	branch = k-type-fix
+	branch = master
 [submodule "lib/ugfx"]
 	path = lib/ugfx
 	url = https://github.com/qmk/uGFX
+	branch = master
 [submodule "lib/googletest"]
 	path = lib/googletest
 	url = https://github.com/google/googletest

.travis.yml

@@ -12,6 +12,18 @@ env:
   - MAKEFLAGS="-j3 --output-sync"
 services:
   - docker
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+      - llvm-toolchain-trusty-7
+    packages:
+    - pandoc
+    - diffutils
+    - dos2unix
+    - doxygen
+    - clang-format-7
+    - libstdc++-7-dev
 install:
   - npm install -g moxygen
 script:
@@ -20,13 +32,6 @@ script:
   - bash util/travis_test.sh
   - bash util/travis_build.sh
   - bash util/travis_docs.sh
-addons:
-  apt:
-    packages:
-    - pandoc
-    - diffutils
-    - dos2unix
-    - doxygen
 after_script:
   bash util/travis_compiled_push.sh
 notifications:

.vscode/settings.json

@@ -5,7 +5,8 @@
     // Configure glob patterns for excluding files and folders.
     "files.exclude": {
         "**/.build": true,
-        "**/*.hex": true
+        "**/*.hex": true,
+        "**/*.bin": true
     },
     "files.associations": {
       "*.h": "c",

Makefile

@@ -623,13 +623,19 @@ endif
 # Generate the version.h file
 ifndef SKIP_GIT
     GIT_VERSION := $(shell git describe --abbrev=6 --dirty --always --tags 2>/dev/null || date +"%Y-%m-%d-%H:%M:%S")
+    CHIBIOS_VERSION := $(shell cd lib/chibios && git describe --abbrev=6 --dirty --always --tags 2>/dev/null || date +"%Y-%m-%d-%H:%M:%S")
+    CHIBIOS_CONTRIB_VERSION := $(shell cd lib/chibios-contrib && git describe --abbrev=6 --dirty --always --tags 2>/dev/null || date +"%Y-%m-%d-%H:%M:%S")
 else
     GIT_VERSION := NA
+    CHIBIOS_VERSION := NA
+    CHIBIOS_CONTRIB_VERSION := NA
 endif
 ifndef SKIP_VERSION
 BUILD_DATE := $(shell date +"%Y-%m-%d-%H:%M:%S")
 $(shell echo '#define QMK_VERSION "$(GIT_VERSION)"' > $(ROOT_DIR)/quantum/version.h)
 $(shell echo '#define QMK_BUILDDATE "$(BUILD_DATE)"' >> $(ROOT_DIR)/quantum/version.h)
+$(shell echo '#define CHIBIOS_VERSION "$(CHIBIOS_VERSION)"' >> $(ROOT_DIR)/quantum/version.h)
+$(shell echo '#define CHIBIOS_CONTRIB_VERSION "$(CHIBIOS_CONTRIB_VERSION)"' >> $(ROOT_DIR)/quantum/version.h)
 else
 BUILD_DATE := NA
 endif

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,5 +22,5 @@ else ifneq ("$(wildcard $(MAIN_KEYMAP_PATH_1)/keymap.json)","")
 endif
 
 # Generate the keymap.c
-$(KEYBOARD_OUTPUT)/src/keymap.c:
+$(KEYBOARD_OUTPUT)/src/keymap.c: $(KEYMAP_JSON)
 	bin/qmk json-keymap --quiet --output $(KEYMAP_C) $(KEYMAP_JSON)

common_features.mk

@@ -61,7 +61,7 @@ endif
 
 ifeq ($(strip $(STENO_ENABLE)), yes)
     OPT_DEFS += -DSTENO_ENABLE
-    VIRTSER_ENABLE := yes
+    VIRTSER_ENABLE ?= yes
     SRC += $(QUANTUM_DIR)/process_keycode/process_steno.c
 endif
 
@@ -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
 
@@ -102,17 +102,68 @@ ifeq ($(strip $(UNICODE_COMMON)), yes)
     SRC += $(QUANTUM_DIR)/process_keycode/process_unicode_common.c
 endif
 
+VALID_EEPROM_DRIVER_TYPES := vendor custom transient i2c
+EEPROM_DRIVER ?= vendor
+ifeq ($(filter $(EEPROM_DRIVER),$(VALID_EEPROM_DRIVER_TYPES)),)
+  $(error EEPROM_DRIVER="$(EEPROM_DRIVER)" is not a valid EEPROM driver)
+else
+  OPT_DEFS += -DEEPROM_ENABLE
+  ifeq ($(strip $(EEPROM_DRIVER)), custom)
+    OPT_DEFS += -DEEPROM_DRIVER -DEEPROM_CUSTOM
+    COMMON_VPATH += $(DRIVER_PATH)/eeprom
+    SRC += eeprom_driver.c
+  else ifeq ($(strip $(EEPROM_DRIVER)), i2c)
+    OPT_DEFS += -DEEPROM_DRIVER -DEEPROM_I2C
+    COMMON_VPATH += $(DRIVER_PATH)/eeprom
+    QUANTUM_LIB_SRC += i2c_master.c
+    SRC += eeprom_driver.c eeprom_i2c.c
+  else ifeq ($(strip $(EEPROM_DRIVER)), transient)
+    OPT_DEFS += -DEEPROM_DRIVER -DEEPROM_TRANSIENT
+    COMMON_VPATH += $(DRIVER_PATH)/eeprom
+    SRC += eeprom_driver.c eeprom_transient.c
+  else ifeq ($(strip $(EEPROM_DRIVER)), vendor)
+    OPT_DEFS += -DEEPROM_VENDOR
+    ifeq ($(PLATFORM),AVR)
+      # Automatically provided by avr-libc, nothing required
+    else ifeq ($(PLATFORM),CHIBIOS)
+      ifeq ($(MCU_SERIES), STM32F3xx)
+        SRC += $(PLATFORM_COMMON_DIR)/eeprom_stm32.c
+        SRC += $(PLATFORM_COMMON_DIR)/flash_stm32.c
+        OPT_DEFS += -DEEPROM_EMU_STM32F303xC
+        OPT_DEFS += -DSTM32_EEPROM_ENABLE
+      else ifeq ($(MCU_SERIES), STM32F1xx)
+        SRC += $(PLATFORM_COMMON_DIR)/eeprom_stm32.c
+        SRC += $(PLATFORM_COMMON_DIR)/flash_stm32.c
+        OPT_DEFS += -DEEPROM_EMU_STM32F103xB
+        OPT_DEFS += -DSTM32_EEPROM_ENABLE
+      else ifeq ($(MCU_SERIES)_$(MCU_LDSCRIPT), STM32F0xx_STM32F072xB)
+        SRC += $(PLATFORM_COMMON_DIR)/eeprom_stm32.c
+        SRC += $(PLATFORM_COMMON_DIR)/flash_stm32.c
+        OPT_DEFS += -DEEPROM_EMU_STM32F072xB
+        OPT_DEFS += -DSTM32_EEPROM_ENABLE
+      else
+        # This will effectively work the same as "transient" if not supported by the chip
+        SRC += $(PLATFORM_COMMON_DIR)/eeprom_teensy.c
+      endif
+    else ifeq ($(PLATFORM),ARM_ATSAM)
+      SRC += $(PLATFORM_COMMON_DIR)/eeprom.c
+    else ifeq ($(PLATFORM),TEST)
+      SRC += $(PLATFORM_COMMON_DIR)/eeprom.c
+    endif
+  endif
+endif
+
 ifeq ($(strip $(RGBLIGHT_ENABLE)), yes)
     POST_CONFIG_H += $(QUANTUM_DIR)/rgblight_post_config.h
     OPT_DEFS += -DRGBLIGHT_ENABLE
     SRC += $(QUANTUM_DIR)/color.c
     SRC += $(QUANTUM_DIR)/rgblight.c
-    CIE1931_CURVE = yes
-    LED_BREATHING_TABLE = yes
+    CIE1931_CURVE := 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
 
@@ -123,7 +174,9 @@ ifneq ($(strip $(LED_MATRIX_ENABLE)), no)
     ifeq ($(filter $(LED_MATRIX_ENABLE),$(VALID_MATRIX_TYPES)),)
         $(error LED_MATRIX_ENABLE="$(LED_MATRIX_ENABLE)" is not a valid matrix type)
     else
-        OPT_DEFS += -DLED_MATRIX_ENABLE -DBACKLIGHT_ENABLE -DBACKLIGHT_CUSTOM_DRIVER
+        BACKLIGHT_ENABLE = yes
+        BACKLIGHT_DRIVER = custom
+        OPT_DEFS += -DLED_MATRIX_ENABLE
         SRC += $(QUANTUM_DIR)/led_matrix.c
         SRC += $(QUANTUM_DIR)/led_matrix_drivers.c
     endif
@@ -146,11 +199,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 +230,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 +241,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,41 +284,40 @@ 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)
-    endif
-
-    ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
-        CIE1931_CURVE = yes
+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
 
     COMMON_VPATH += $(QUANTUM_DIR)/backlight
     SRC += $(QUANTUM_DIR)/backlight/backlight.c
+    SRC += $(QUANTUM_DIR)/process_keycode/process_backlight.c
     OPT_DEFS += -DBACKLIGHT_ENABLE
 
-    ifeq ($(strip $(BACKLIGHT_ENABLE)), software)
-        SRC += $(QUANTUM_DIR)/backlight/backlight_soft.c
+    ifeq ($(strip $(BACKLIGHT_DRIVER)), custom)
+        OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER
     else
-        ifeq ($(strip $(BACKLIGHT_ENABLE)), custom)
-            OPT_DEFS += -DBACKLIGHT_CUSTOM_DRIVER
-        endif
-
-        ifeq ($(PLATFORM),AVR)
-            SRC += $(QUANTUM_DIR)/backlight/backlight_avr.c
+        SRC += $(QUANTUM_DIR)/backlight/backlight_driver_common.c
+        ifeq ($(strip $(BACKLIGHT_DRIVER)), pwm)
+            ifeq ($(PLATFORM),AVR)
+                SRC += $(QUANTUM_DIR)/backlight/backlight_avr.c
+            else
+                SRC += $(QUANTUM_DIR)/backlight/backlight_arm.c
+            endif
         else
-            SRC += $(QUANTUM_DIR)/backlight/backlight_arm.c
+            SRC += $(QUANTUM_DIR)/backlight/backlight_$(strip $(BACKLIGHT_DRIVER)).c
         endif
     endif
 endif
@@ -273,6 +330,8 @@ ifeq ($(strip $(WS2812_DRIVER_REQUIRED)), yes)
         $(error WS2812_DRIVER="$(WS2812_DRIVER)" is not a valid WS2812 driver)
     endif
 
+    OPT_DEFS += -DWS2812_DRIVER_$(strip $(shell echo $(WS2812_DRIVER) | tr '[:lower:]' '[:upper:]'))
+
     ifeq ($(strip $(WS2812_DRIVER)), bitbang)
         SRC += ws2812.c
     else
@@ -285,14 +344,13 @@ ifeq ($(strip $(WS2812_DRIVER_REQUIRED)), yes)
     endif
 endif
 
-ifeq ($(strip $(CIE1931_CURVE)), yes)
-    OPT_DEFS += -DUSE_CIE1931_CURVE
-    LED_TABLES = yes
+ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
+    CIE1931_CURVE := yes
 endif
 
-ifeq ($(strip $(LED_BREATHING_TABLE)), yes)
-    OPT_DEFS += -DUSE_LED_BREATHING_TABLE
-    LED_TABLES = yes
+ifeq ($(strip $(CIE1931_CURVE)), yes)
+    OPT_DEFS += -DUSE_CIE1931_CURVE
+    LED_TABLES := yes
 endif
 
 ifeq ($(strip $(LED_TABLES)), yes)
@@ -342,6 +400,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
@@ -352,6 +418,12 @@ ifeq ($(strip $(LEADER_ENABLE)), yes)
   OPT_DEFS += -DLEADER_ENABLE
 endif
 
+
+ifeq ($(strip $(DIP_SWITCH_ENABLE)), yes)
+  SRC += $(QUANTUM_DIR)/dip_switch.c
+  OPT_DEFS += -DDIP_SWITCH_ENABLE
+endif
+
 include $(DRIVER_PATH)/qwiic/qwiic.mk
 
 QUANTUM_SRC:= \
@@ -359,12 +431,28 @@ QUANTUM_SRC:= \
     $(QUANTUM_DIR)/keymap_common.c \
     $(QUANTUM_DIR)/keycode_config.c
 
-# Include the standard or split matrix code if needed
+
+
+VALID_CUSTOM_MATRIX_TYPES:= yes lite no
+
+CUSTOM_MATRIX ?= no
+
 ifneq ($(strip $(CUSTOM_MATRIX)), yes)
-    ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
-        QUANTUM_SRC += $(QUANTUM_DIR)/split_common/matrix.c
-    else
-        QUANTUM_SRC += $(QUANTUM_DIR)/matrix.c
+    ifeq ($(filter $(CUSTOM_MATRIX),$(VALID_CUSTOM_MATRIX_TYPES)),)
+        $(error CUSTOM_MATRIX="$(CUSTOM_MATRIX)" is not a valid custom matrix type)
+    endif
+
+    # Include common stuff for all non custom matrix users
+    QUANTUM_SRC += $(QUANTUM_DIR)/matrix_common.c
+
+    # if 'lite' then skip the actual matrix implementation
+    ifneq ($(strip $(CUSTOM_MATRIX)), lite)
+        # Include the standard or split matrix code if needed
+        ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
+            QUANTUM_SRC += $(QUANTUM_DIR)/split_common/matrix.c
+        else
+            QUANTUM_SRC += $(QUANTUM_DIR)/matrix.c
+        endif
     endif
 endif
 
@@ -387,9 +475,17 @@ ifeq ($(strip $(SPLIT_KEYBOARD)), yes)
         QUANTUM_SRC += $(QUANTUM_DIR)/split_common/transport.c
         # Functions added via QUANTUM_LIB_SRC are only included in the final binary if they're called.
         # Unused functions are pruned away, which is why we can add multiple drivers here without bloat.
-        QUANTUM_LIB_SRC += $(QUANTUM_DIR)/split_common/serial.c \
-                           i2c_master.c \
-                           i2c_slave.c
+        ifeq ($(PLATFORM),AVR)
+            QUANTUM_LIB_SRC += i2c_master.c \
+                               i2c_slave.c
+        endif
+
+        SERIAL_DRIVER ?= bitbang
+        ifeq ($(strip $(SERIAL_DRIVER)), bitbang)
+            QUANTUM_LIB_SRC += serial.c
+        else
+            QUANTUM_LIB_SRC += serial_$(strip $(SERIAL_DRIVER)).c
+        endif
     endif
     COMMON_VPATH += $(QUANTUM_PATH)/split_common
 endif
@@ -413,12 +509,13 @@ ifeq ($(strip $(MAGIC_ENABLE)), yes)
     OPT_DEFS += -DMAGIC_KEYCODE_ENABLE
 endif
 
+GRAVE_ESC_ENABLE ?= yes
+ifeq ($(strip $(GRAVE_ESC_ENABLE)), yes)
+    SRC += $(QUANTUM_DIR)/process_keycode/process_grave_esc.c
+    OPT_DEFS += -DGRAVE_ESC_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
-  OPT_DEFS += -DDIP_SWITCH_ENABLE
-endif

docs/ChangeLog/20200229.md

@@ -0,0 +1,75 @@
+# QMK Breaking Change - 2020 Feb 29 Changelog
+
+Four times a year QMK runs a process for merging Breaking Changes. A Breaking Change is any change which modifies how QMK behaves in a way that is incompatible or potentially dangerous. We limit these changes to 4 times per year so that users can have confidence that updating their QMK tree will not break their keymaps.
+
+
+## Update ChibiOS/ChibiOS-Contrib/uGFX submodules
+
+* General Notes
+    * A `make git-submodule` may be required after pulling the latest QMK firmware code to update affected submodules to the upgraded revisions
+    * Enabling link-time-optimization (`LINK_TIME_OPTIMIZATION_ENABLE = yes`) should work on a lot more boards
+* Upgrade to ChibiOS ver19.1.3
+    * This will allow QMK to update to upstream ChibiOS a lot easier -- the old version was ~2 years out of date. Automated update scripts have been made available to simplify future upgrades.
+    * Includes improved MCU support and bugfixes
+    * ChibiOS revision is now included in Command output
+    * Timers should now be more accurate
+* Upgrade to newer ChibiOS-Contrib
+    * Also includes improved MCU support and bugfixes
+    * ChibiOS-Contrib revision is now included in Command output
+* Upgrade to newer uGFX
+    * Required in order to support updated ChibiOS
+
+
+## Fix ChibiOS timer overflow for 16-bit SysTick devices
+
+* On 16-bit SysTick devices, the timer subsystem in QMK was incorrectly dealing with overflow.
+    * When running at a 100000 SysTick frequency (possible on 16-bit devices, but uncommon), this overflow would occur after 0.65 seconds.
+* Timers are now correctly handling this overflow case and timing should now be correct on ChibiOS/ARM.
+
+
+## Update LUFA submodule
+
+* Updates the LUFA submodule to include updates from upstream (abcminiuser/lufa)
+* Includes some cleanup for QMK DFU generation
+
+
+## Encoder flip
+
+* Flips the encoder direction so that `clockwise == true` is for actually turning the knob clockwise
+* Adds `ENCODER_DIRECTION_FLIP` define, so that reversing the expected dirction is simple for users.
+* Cleans up documentation page for encoders
+
+
+## Adding support for `BACKLIGHT_ON_STATE` for hardware PWM backlight
+
+* Previously, the define only affected software PWM, and hardware PWM always assumed an N-channel MOSFET.
+* The hardware PWM backlight setup has been updated to respect this option.
+* The default "on" state has been changed to `1` - **this impacts all keyboards using software PWM backlight that do not define it explicitly**. If your keyboard's backlight is acting strange, it may have a P-channel MOSFET, and will need to have `#define BACKLIGHT_ON_STATE 0` added to the keyboard-level `config.h`. Please see the PR for more detailed information.
+
+
+## Migrating `ACTION_LAYER_TAP_KEY()` entries in `fn_actions` to `LT()` keycodes
+
+* `fn_actions` is deprecated, and its functionality has been superseded by direct keycodes and `process_record_user()`
+* The end result of removing this obsolete feature should result in a decent reduction in firmware size and code complexity
+* All keymaps affected are recommended to switch away from `fn_actions` in favour of the [custom keycode](https://docs.qmk.fm/#/custom_quantum_functions) and [macro](https://docs.qmk.fm/#/feature_macros) features
+
+
+## Moving backlight keycode handling to `process_keycode/`
+
+* This refactors the backlight keycode logic to be clearer and more modular.
+* All backlight-related keycodes are now actioned in a single file.
+* The `ACTION_BACKLIGHT_*` macros have also been deleted. If you are still using these in a `fn_actions[]` block, please switch to using the backlight keycodes or functions directly.
+
+
+## Refactor Planck keymaps to use Layout Macros
+
+* Refactor Planck keymaps to use layout macros instead of raw matrix assignments
+* Makes keymaps revision-agnostic
+* Should reduce noise and errors in Travis CI logs
+
+
+## GON NerD codebase refactor
+
+* Splits the codebase for GON NerD 60 and NerdD TKL PCBs into two separate directories.
+* If your keymap is for a NerD 60 PCB, your `make` command is now `make gon/nerd60:<keymap>`.
+* If your keymap is for a NerD TKL PCB, your `make` command is now `make gon/nerdtkl:<keymap>`.

docs/README.md

@@ -9,24 +9,35 @@
 
 ## What is QMK Firmware?
 
-QMK (*Quantum Mechanical Keyboard*) is an open source community that maintains QMK Firmware, QMK Toolbox, qmk.fm, and these docs. QMK Firmware is a keyboard firmware based on the [tmk\_keyboard](http://github.com/tmk/tmk_keyboard) with some useful features for Atmel AVR controllers, and more specifically, the [OLKB product line](http://olkb.com), the [ErgoDox EZ](http://www.ergodox-ez.com) keyboard, and the [Clueboard product line](http://clueboard.co/). It has also been ported to ARM chips using ChibiOS. You can use it to power your own hand-wired or custom keyboard PCB.
+QMK (*Quantum Mechanical Keyboard*) is an open source community centered around developing computer input devices. The community encompasses all sorts of input devices, such as keyboards, mice, and MIDI devices. A core group of collaborators maintains [QMK Firmware](https://github.com/qmk/qmk_firmware), [QMK Configurator](https://config.qmk.fm), [QMK Toolbox](https://github.com/qmk/qmk_toolbox), [qmk.fm](https://qmk.fm), and this documentation with the help of community members like you.
 
-## How to Get It
+## Get Started
 
-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.
+Totally new to QMK? There are two ways to get started:
 
-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.
+* Basic: [QMK Configurator](https://config.qmk.fm)
+    * Just select your keyboard from the dropdown and program your keyboard.
+    * We have an [introductory video](https://www.youtube.com/watch?v=-imgglzDMdY) you can watch.
+    * There is also an overview [document you can read](newbs_building_firmware_configurator.md).
+* Advanced: [Use The Source](newbs.md)
+    * More powerful, but harder to use
 
-## How to Compile
+## Make It Yours
 
-Before you are able to compile, you'll need to [install an environment](getting_started_build_tools.md) for AVR or/and ARM development. Once that is complete, you'll use the `make` command to build a keyboard and keymap with the following notation:
+QMK has lots of [features](features.md) to explore, and a good deal of reference documentation to dig through. Most features are taken advantage of by modifying your [keymap](keymap.md), and changing the [keycodes](keycodes.md).
 
-    make planck/rev4:default
+## Need help?
 
-This would build the `rev4` revision of the `planck` with the `default` keymap. Not all keyboards have revisions (also called subprojects or folders), in which case, it can be omitted:
+Check out the [support page](support.md) to see how you can get help using QMK.
 
-    make preonic:default
+## Give Back
 
-## How to Customize
+There are a lot of ways you can contribute to the QMK Community. The easiest way to get started is to use it and spread the word to your friends.
 
-QMK has lots of [features](features.md) to explore, and a good deal of [reference documentation](http://docs.qmk.fm) to dig through. Most features are taken advantage of by modifying your [keymap](keymap.md), and changing the [keycodes](keycodes.md).
+* Help people out on our forums and chat rooms:
+    * [/r/olkb](https://www.reddit.com/r/olkb/)
+    * [Discord Server](https://discord.gg/Uq7gcHh)
+* Contribute to our documentation by clicking "Edit This Page" at the bottom
+* [Translate our documentation into your language](translating.md)
+* [Report a bug](https://github.com/qmk/qmk_firmware/issues/new/choose)
+* [Open a Pull Request](contributing.md)

docs/_langs.md

@@ -4,5 +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

@@ -1,127 +1,162 @@
-* [Complete Newbs Guide](newbs.md)
-  * [Getting Started](newbs_getting_started.md)
+* Tutorial
+  * [Introduction](newbs.md)
+  * [Setup](newbs_getting_started.md)
   * [Building Your First Firmware](newbs_building_firmware.md)
   * [Flashing Firmware](newbs_flashing.md)
   * [Testing and Debugging](newbs_testing_debugging.md)
-  * [Best 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)
+  * [Getting Help/Support](support.md)
+  * [Other Resources](newbs_learn_more_resources.md)
 
-* [QMK Basics](README.md)
-  * [QMK Introduction](getting_started_introduction.md)
-  * [QMK CLI](cli.md)
-  * [QMK CLI Config](cli_configuration.md)
-  * [Contributing to QMK](contributing.md)
-  * [How to Use Github](getting_started_github.md)
-  * [Getting Help](getting_started_getting_help.md)
-
-* [Breaking Changes](breaking_changes.md)
-  * [2019 Aug 30](ChangeLog/20190830.md)
-
-* [FAQ](faq.md)
+* FAQs
   * [General FAQ](faq_general.md)
   * [Build/Compile QMK](faq_build.md)
   * [Debugging/Troubleshooting QMK](faq_debug.md)
-  * [Keymap](faq_keymap.md)
-  * [Driver Installation with Zadig](driver_installation_zadig.md)
-
-* Detailed Guides
-  * [Install Build Tools](getting_started_build_tools.md)
-  * [Vagrant Guide](getting_started_vagrant.md)
-  * [Build/Compile Instructions](getting_started_make_guide.md)
-  * [Flashing Firmware](flashing.md)
-  * [Customizing Functionality](custom_quantum_functions.md)
-  * [Keymap Overview](keymap.md)
-
-* [Hardware](hardware.md)
-  * [Compatible Microcontrollers](compatible_microcontrollers.md)
-  * [AVR Processors](hardware_avr.md)
-  * [Drivers](hardware_drivers.md)
-
-* Reference
-  * [Keyboard Guidelines](hardware_keyboard_guidelines.md)
-  * [Config Options](config_options.md)
-  * [Keycodes](keycodes.md)
-  * [Coding Conventions - C](coding_conventions_c.md)
-  * [Coding Conventions - Python](coding_conventions_python.md)
-  * [Documentation Best Practices](documentation_best_practices.md)
-  * [Documentation Templates](documentation_templates.md)
+  * [Keymap FAQ](faq_keymap.md)
   * [Glossary](reference_glossary.md)
-  * [Unit Testing](unit_testing.md)
-  * [Useful Functions](ref_functions.md)
-  * [Configurator Support](reference_configurator_support.md)
-  * [info.json Format](reference_info_json.md)
-  * [Python CLI Development](cli_development.md)
 
-* [Features](features.md)
-  * [Basic Keycodes](keycodes_basic.md)
-  * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
-  * [Quantum Keycodes](quantum_keycodes.md)
-  * [Advanced Keycodes](feature_advanced_keycodes.md)
-  * [Audio](feature_audio.md)
-  * [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)
+* Configurator
+  * [Overview](newbs_building_firmware_configurator.md)
+  * [Step by Step](configurator_step_by_step.md)
+  * [Troubleshooting](configurator_troubleshooting.md)
+  * [Problems and Bugs](configurator_problems.md)
+  * QMK API
+    * [Overview](api_overview.md)
+    * [API Documentation](api_docs.md)
+    * [Keyboard Support](reference_configurator_support.md)
 
-* For Makers and Modders
-  * [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)
-  * [Proton C Conversion](proton_c_conversion.md)
+* CLI
+    * [Overview](cli.md)
+    * [Configuration](cli_configuration.md)
+    * [Commands](cli_commands.md)
 
-* For a Deeper Understanding
-  * [How Keyboards Work](how_keyboards_work.md)
-  * [Understanding QMK](understanding_qmk.md)
+* Using QMK
+  * Guides
+    * [Customizing Functionality](custom_quantum_functions.md)
+    * [Driver Installation with Zadig](driver_installation_zadig.md)
+    * [Keymap Overview](keymap.md)
+    * [Vagrant Guide](getting_started_vagrant.md)
+    * Flashing
+      * [Flashing](flashing.md)
+      * [Flashing ATmega32A (ps2avrgb)](flashing_bootloadhid.md)
+    * IDEs
+      * [Using Eclipse with QMK](other_eclipse.md)
+      * [Using VSCode with QMK](other_vscode.md)
+    * Git Best Practices
+      * [Introduction](newbs_git_best_practices.md)
+      * [Your Fork](newbs_git_using_your_master_branch.md)
+      * [Merge Conflicts](newbs_git_resolving_merge_conflicts.md)
+      * [Fixing Your Branch](newbs_git_resynchronize_a_branch.md)
+    * Keyboard Building
+      * [Hand Wiring Guide](hand_wire.md)
+      * [ISP Flashing Guide](isp_flashing_guide.md)
 
-* Other Topics
-  * [Using Eclipse with QMK](other_eclipse.md)
-  * [Using VSCode with QMK](other_vscode.md)
-  * [Support](support.md)
-  * [Translating the QMK Docs](translating.md)
+  * Simple Keycodes
+    * [Full List](keycodes.md)
+    * [Basic Keycodes](keycodes_basic.md)
+    * [Layer Switching](feature_advanced_keycodes.md)
+    * [Quantum Keycodes](quantum_keycodes.md)
 
-* QMK Internals (In Progress)
-  * [Defines](internals_defines.md)
-  * [Input Callback Reg](internals_input_callback_reg.md)
-  * [Midi Device](internals_midi_device.md)
-  * [Midi Device Setup Process](internals_midi_device_setup_process.md)
-  * [Midi Util](internals_midi_util.md)
-  * [Send Functions](internals_send_functions.md)
-  * [Sysex Tools](internals_sysex_tools.md)
+  * Advanced Keycodes
+    * [Command](feature_command.md)
+    * [Dynamic Macros](feature_dynamic_macros.md)
+    * [Grave Escape](feature_grave_esc.md)
+    * [Leader Key](feature_leader_key.md)
+    * [Mod-Tap](mod_tap.md)
+    * [Macros](feature_macros.md)
+    * [Mouse Keys](feature_mouse_keys.md)
+    * [Space Cadet Shift](feature_space_cadet.md)
+    * [US ANSI Shifted Keys](keycodes_us_ansi_shifted.md)
+
+  * Software Features
+    * [Auto Shift](feature_auto_shift.md)
+    * [Combos](feature_combo.md)
+    * [Debounce API](feature_debounce_type.md)
+    * [Key Lock](feature_key_lock.md)
+    * [One Shot Keys](one_shot_keys.md)
+    * [Pointing Device](feature_pointing_device.md)
+    * [Swap Hands](feature_swap_hands.md)
+    * [Tap Dance](feature_tap_dance.md)
+    * [Tap-Hold Configuration](tap_hold.md)
+    * [Terminal](feature_terminal.md)
+    * [Unicode](feature_unicode.md)
+    * [Userspace](feature_userspace.md)
+
+  * Hardware Features
+    * Displays
+      * [HD44780 LCD Controller](feature_hd44780.md)
+      * [OLED Driver](feature_oled_driver.md)
+    * Lighting
+      * [Backlight](feature_backlight.md)
+      * [LED Matrix](feature_led_matrix.md)
+      * [RGB Lighting](feature_rgblight.md)
+      * [RGB Matrix](feature_rgb_matrix.md)
+    * [Audio](feature_audio.md)
+    * [Bluetooth](feature_bluetooth.md)
+    * [Bootmagic](feature_bootmagic.md)
+    * [Custom Matrix](custom_matrix.md)
+    * [DIP Switch](feature_dip_switch.md)
+    * [Encoders](feature_encoders.md)
+    * [Haptic Feedback](feature_haptic_feedback.md)
+    * [Proton C Conversion](proton_c_conversion.md)
+    * [PS/2 Mouse](feature_ps2_mouse.md)
+    * [Split Keyboard](feature_split_keyboard.md)
+    * [Stenography](feature_stenography.md)
+    * [Thermal Printer](feature_thermal_printer.md)
+    * [Velocikey](feature_velocikey.md)
+
+* Developing QMK
+  * Breaking Changes
+    * [Overview](breaking_changes.md)
+    * [My Pull Request Was Flagged](breaking_changes_instructions.md)
+    * History
+      * [2020 Feb 29](ChangeLog/20200229.md)
+      * [2019 Aug 30](ChangeLog/20190830.md)
+
+  * C Development
+    * [ARM Debugging Guide](arm_debugging.md)
+    * [AVR Processors](hardware_avr.md)
+    * [Coding Conventions](coding_conventions_c.md)
+    * [Compatible Microcontrollers](compatible_microcontrollers.md)
+    * [Drivers](hardware_drivers.md)
+      * [ADC Driver](adc_driver.md)
+      * [I2C Driver](i2c_driver.md)
+      * [WS2812 Driver](ws2812_driver.md)
+      * [EEPROM Driver](eeprom_driver.md)
+    * [GPIO Controls](internals_gpio_control.md)
+    * [Keyboard Guidelines](hardware_keyboard_guidelines.md)
+
+  * Python Development
+    * [Coding Conventions](coding_conventions_python.md)
+    * [QMK CLI Development](cli_development.md)
+    * [QMK CLI Config](cli_dev_configuration.md)
+
+  * Configurator Development
+    * QMK API
+      * [Development Environment](api_development_environment.md)
+      * [Architecture Overview](api_development_overview.md)
+
+  * QMK Reference
+    * [Contributing to QMK](contributing.md)
+    * [Translating the QMK Docs](translating.md)
+    * [Config Options](config_options.md)
+    * [Make Documentation](getting_started_make_guide.md)
+    * [Documentation Best Practices](documentation_best_practices.md)
+    * [Documentation Templates](documentation_templates.md)
+    * [Community Layouts](feature_layouts.md)
+    * [Unit Testing](unit_testing.md)
+    * [Useful Functions](ref_functions.md)
+    * [info.json Format](reference_info_json.md)
+
+  * For a Deeper Understanding
+    * [How Keyboards Work](how_keyboards_work.md)
+    * [How a Matrix Works](how_a_matrix_works.md)
+    * [Understanding QMK](understanding_qmk.md)
+
+  * QMK Internals (In Progress)
+    * [Defines](internals_defines.md)
+    * [Input Callback Reg](internals_input_callback_reg.md)
+    * [Midi Device](internals_midi_device.md)
+    * [Midi Device Setup Process](internals_midi_device_setup_process.md)
+    * [Midi Util](internals_midi_util.md)
+    * [Send Functions](internals_send_functions.md)
+    * [Sysex Tools](internals_sysex_tools.md)

docs/api_development_environment.md

@@ -0,0 +1,3 @@
+# Development Environment Setup
+
+To setup a development stack head over to the [qmk_web_stack](https://github.com/qmk/qmk_web_stack).

docs/api_development_overview.md

@@ -0,0 +1,44 @@
+# QMK Compiler Development Guide
+
+This page attempts to introduce developers to the QMK Compiler. It does not go into nitty gritty details- for that you should read code. What this will give you is a framework to hang your understanding on as you read the code.
+
+# Overview
+
+The QMK Compile API consists of a few movings parts:
+
+![Architecture Diagram](https://raw.githubusercontent.com/qmk/qmk_api/master/docs/architecture.svg)
+
+API Clients interact exclusively with the API service. This is where they submit jobs, check status, and download results. The API service inserts compile jobs into [Redis Queue](https://python-rq.org) and checks both RQ and S3 for the results of those jobs.
+
+Workers fetch new compile jobs from RQ, compile them, and then upload the source and the binary to an S3 compatible storage engine.
+
+# Workers
+
+QMK Compiler Workers are responsible for doing the actual building. When a worker pulls a job from RQ it does several things to complete that job:
+
+* Make a fresh qmk_firmware checkout
+* Use the supplied layers and keyboard metadata to build a `keymap.c`
+* Build the firmware
+* Zip a copy of the source
+* Upload the firmware, source zip, and a metadata file to S3.
+* Report the status of the job to RQ
+
+# API Service
+
+The API service is a relatively simple Flask application. There are a few main views you should understand.
+
+## @app.route('/v1/compile', methods=['POST'])
+
+This is the main entrypoint for the API. A client's interaction starts here. The client POST's a JSON document describing their keyboard, and the API does some (very) basic validation of that JSON before submitting the compile job.
+
+## @app.route('/v1/compile/<string:job_id>', methods=['GET'])
+
+This is the most frequently called endpoint. It pulls the job details from redis, if they're still available, or the cached job details on S3 if they're not.
+
+## @app.route('/v1/compile/<string:job_id>/download', methods=['GET'])
+
+This method allows users to download the compiled firmware file.
+
+## @app.route('/v1/compile/<string:job_id>/source', methods=['GET'])
+
+This method allows users to download the source for their firmware.

docs/api_docs.md

@@ -0,0 +1,68 @@
+# QMK API
+
+This page describes using the QMK API. If you are an application developer you can use this API to compile firmware for any [QMK](https://qmk.fm) Keyboard.
+
+## Overview
+
+This service is an asynchronous API for compiling custom keymaps. You POST some JSON to the API, periodically check the status, and when your firmware has finished compiling you can download the resulting firmware and (if desired) source code for that firmware.
+
+#### Example JSON Payload:
+
+```json
+{
+  "keyboard": "clueboard/66/rev2",
+  "keymap": "my_awesome_keymap",
+  "layout": "LAYOUT_all",
+  "layers": [
+    ["KC_GRV","KC_1","KC_2","KC_3","KC_4","KC_5","KC_6","KC_7","KC_8","KC_9","KC_0","KC_MINS","KC_EQL","KC_GRV","KC_BSPC","KC_PGUP","KC_TAB","KC_Q","KC_W","KC_E","KC_R","KC_T","KC_Y","KC_U","KC_I","KC_O","KC_P","KC_LBRC","KC_RBRC","KC_BSLS","KC_PGDN","KC_CAPS","KC_A","KC_S","KC_D","KC_F","KC_G","KC_H","KC_J","KC_K","KC_L","KC_SCLN","KC_QUOT","KC_NUHS","KC_ENT","KC_LSFT","KC_NUBS","KC_Z","KC_X","KC_C","KC_V","KC_B","KC_N","KC_M","KC_COMM","KC_DOT","KC_SLSH","KC_RO","KC_RSFT","KC_UP","KC_LCTL","KC_LGUI","KC_LALT","KC_MHEN","KC_SPC","KC_SPC","KC_HENK","KC_RALT","KC_RCTL","MO(1)","KC_LEFT","KC_DOWN","KC_RIGHT"],
+    ["KC_ESC","KC_F1","KC_F2","KC_F3","KC_F4","KC_F5","KC_F6","KC_F7","KC_F8","KC_F9","KC_F10","KC_F11","KC_F12","KC_TRNS","KC_DEL","BL_STEP","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","_______","KC_TRNS","KC_PSCR","KC_SLCK","KC_PAUS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","MO(2)","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_PGUP","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","MO(1)","KC_LEFT","KC_PGDN","KC_RGHT"],
+    ["KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","RESET","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","MO(2)","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","KC_TRNS","MO(1)","KC_TRNS","KC_TRNS","KC_TRNS"]
+  ]
+}
+```
+
+As you can see the payload describes all aspects of a keyboard necessary to create and generate a firmware. Each layer is a single list of QMK keycodes the same length as the keyboard's `LAYOUT` macro. If a keyboard supports mulitple `LAYOUT` macros you can specify which macro to use.
+
+## Submitting a Compile Job
+
+To compile your keymap into a firmware simply POST your JSON to the `/v1/compile` endpoint. In the following example we've placed the JSON payload into a file named `json_data`.
+
+```
+$ curl -H "Content-Type: application/json" -X POST -d "$(< json_data)" http://api.qmk.fm/v1/compile
+{
+  "enqueued": true,
+  "job_id": "ea1514b3-bdfc-4a7b-9b5c-08752684f7f6"
+}
+```
+
+## Checking The Status
+
+After submitting your keymap you can check the status using a simple HTTP GET call:
+
+```
+$ curl http://api.qmk.fm/v1/compile/ea1514b3-bdfc-4a7b-9b5c-08752684f7f6
+{
+  "created_at": "Sat, 19 Aug 2017 21:39:12 GMT",
+  "enqueued_at": "Sat, 19 Aug 2017 21:39:12 GMT",
+  "id": "f5f9b992-73b4-479b-8236-df1deb37c163",
+  "status": "running",
+  "result": null
+}
+```
+
+This shows us that the job has made it through the queue and is currently running. There are 5 possible statuses:
+
+* **failed**: Something about the compiling service has broken.
+* **finished**: The compilation is complete and you should check `result` to see the results.
+* **queued**: The keymap is waiting for a compilation server to become available.
+* **running**: The compilation is in progress and should be complete soon.
+* **unknown**: A serious error has occurred and you should [file a bug](https://github.com/qmk/qmk_compiler/issues).
+
+## Examining Finished Results
+
+Once your compile job has finished you'll check the `result` key. The value of this key is a hash containing several key bits of information:
+
+* `firmware_binary_url`: A list of URLs for the the flashable firmware
+* `firmware_keymap_url`: A list of URLs for the the `keymap.c`
+* `firmware_source_url`: A list of URLs for the full firmware source code
+* `output`: The stdout and stderr for this compile job. Errors will be found here.

docs/api_overview.md

@@ -0,0 +1,15 @@
+# QMK API
+
+The QMK API provides an asynchronous API that Web and GUI tools can use to compile arbitrary keymaps for any keyboard supported by [QMK](http://qmk.fm/). The stock keymap template supports all QMK keycodes that do not require supporting C code. Keyboard maintainers can supply their own custom templates to enable more functionality.
+
+## App Developers
+
+If you are an app developer interested in using this API in your application you should head over to [Using The API](api_docs.md).
+
+## Keyboard Maintainers
+
+If you would like to enhance your keyboard's support in the QMK Compiler API head over to the [Keyboard Support](reference_configurator_support.md) section.
+
+## Backend Developers
+
+If you are interested in working on the API itself you should start by setting up a [Development Environment](api_development_environment.md), then check out [Hacking On The API](api_development_overview.md).

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/becoming_a_qmk_collaborator.md

@@ -1,9 +0,0 @@
-# Becoming a QMK Collaborator
-
-A QMK collaborator is a keyboard maker or designer that is interested in helping QMK grow and fully support their keyboard(s), and encouraging their users and customers to submit features, ideas, and keymaps. We're always looking to add more keyboards and collaborators, but we ask that they fulfill these requirements:
-
-* **Have a PCB available for sale.** Unfortunately there's just too much variation and complications with handwired keyboards.
-* **Maintain your keyboard in QMK.** This may just require an initial setup to get your keyboard working, but it could also include accommodating changes made to QMK's core that might break or render any custom code redundant.
-* **Approve and merge keymap pull requests for your keyboard.** We like to encourage users to contribute their keymaps for others to see and work from when creating their own.
-
-If you feel you meet these requirements, shoot us an email at hello@qmk.fm with an introduction and some links to your keyboard!

docs/breaking_changes.md

@@ -6,20 +6,21 @@ The breaking change period is when we will merge PR's that change QMK in dangero
 
 ## What has been included in past Breaking Changes?
 
+* [2020 Feb 29](ChangeLog/20200229.md)
 * [2019 Aug 30](ChangeLog/20190830.md)
 
 ## When is the next Breaking Change?
 
-The next Breaking Change is scheduled for Nov 29.
+The next Breaking Change is scheduled for May 30, 2020.
 
 ### Important Dates
 
-* [x] 2019 Sep 21 - `future` is created. It will be rebased weekly.
-* [ ] 2019 Nov 01 - `future` closed to new PR's.
-* [ ] 2019 Nov 01 - Call for testers.
-* [ ] 2019 Nov 27 - `master` is locked, no PR's merged.
-* [ ] 2019 Nov 29 - Merge `future` to `master`.
-* [ ] 2019 Nov 30 - `master` is unlocked. PR's can be merged again.
+* [x] 2020 Feb 29 - `future` is created. It will be rebased weekly.
+* [ ] 2020 May 2 - `future` closed to new PR's.
+* [ ] 2020 May 2 - Call for testers.
+* [ ] 2020 May 28 - `master` is locked, no PR's merged.
+* [ ] 2020 May 30 - Merge `future` to `master`.
+* [ ] 2020 May 30 - `master` is unlocked. PR's can be merged again.
 
 ## What changes will be included?
 

docs/breaking_changes_instructions.md

@@ -0,0 +1,42 @@
+# Breaking Changes: My Pull Request Was Flagged
+
+A QMK member may have replied to your pull request stating that your submission is a breaking change. In their judgment, the changes you have proposed have greater implications for either QMK, or its users.
+
+Some things that may cause a pull request to be flagged are:
+
+- **Edits to User Keymaps**
+  A user may submit their keymap to QMK, then some time later open a pull request with further updates, only to find it can't be merged because it was edited in the `qmk/qmk_firmware` repository. As not all users are proficient at using Git or GitHub, the user may find themself unable to fix the issue on their own.
+- **Changes to Expected Behavior**
+  Changes to QMK behavior may cause users to believe their hardware or QMK is broken if they flash new firmware that incorporates changes to existing QMK features, and find themselves without a means to restore the desired behavior.
+- **Changes Requiring User Action**
+  Changes may also require action to be taken by users, such as updating a toolchain or taking some action in Git.
+- **Changes Necessitating Increased Scrutiny**
+  On occasion, a submission may have implications for QMK as a project. This could be copyright/licensing issues, coding conventions, large feature overhauls, "high-risk" changes that need wider testing by our community, or something else entirely.
+- **Changes Requiring Communication to End Users**
+  This includes warnings about future deprecations, outdated practices, and anything else that needs to be communicated but doesn't fit into one of the above categories.
+
+## What Do I Do?
+
+If it is determined that your submission is a breaking change, there are a few things you can do to smooth the process:
+
+### Consider Splitting Up Your PR
+
+If you are contributing core code, and the only reason it needs to go through breaking changes is that you are updating keymaps to match your change, consider whether you can submit your feature in a way that the old keymaps continue to work. Then submit a separate PR that goes through the breaking changes process to remove the old code.
+
+### Contribute a ChangeLog Entry
+
+We require submissions that go through the Breaking Change process to include a changelog entry. The entry should be a short summary of the changes your pull request makes – [each section here started as a changelog](ChangeLog/20190830.md "n.b. This should link to the 2019 Aug 30 Breaking Changes doc  - @noroadsleft").
+
+Your changelog should be located at `docs/ChangeLog/YYYYMMDD/PR####.md`, where `YYYYMMDD` is the date on which QMK's breaking change branch – usually named `future` – will be merged into the `master` branch, and `####` is the number of your pull request.
+
+If your submission requires action on the part of users, your changelog should instruct users what action(s) must be taken, or link to a location that does so.
+
+### Document Your Changes
+
+Understanding the purpose for your submission, and possible implications or actions it will require can make the review process more straightforward. A changelog may suffice for this purpose, but more extensive changes may require a level of detail that is ill-suited for a changelog.
+
+Commenting on your pull request and being responsive to questions, comments, and change requests is much appreciated.
+
+### Ask for Help
+
+Having your submission flagged may have caught you off guard. If you find yourself intimidated or overwhelmed, let us know. Comment on your pull request, or [reach out to the QMK team on Discord](https://discord.gg/Uq7gcHh).

docs/cli.md

@@ -71,17 +71,39 @@ There are some limitations to the local CLI compared to the global CLI:
 
 ## `qmk cformat`
 
-This command formats C code using clang-format. Run it with no arguments to format all core code, or pass filenames on the command line to run it on specific files.
+This command formats C code using clang-format. 
 
-**Usage**:
+Run it with no arguments to format all core code that has been changed. Default checks `origin/master` with `git diff`, branch can be changed using `-b <branch_name>`
+
+Run it with `-a` to format all core code, or pass filenames on the command line to run it on specific files.
+
+**Usage for specified files**:
 
 ```
 qmk cformat [file1] [file2] [...] [fileN]
 ```
 
+**Usage for all core files**:
+
+```
+qmk cformat -a
+```
+
+**Usage for only changed files against origin/master**:
+
+```
+qmk cformat
+```
+
+**Usage for only changed files against branch_name**:
+
+```
+qmk cformat -b branch_name
+```
+
 ## `qmk compile`
 
-This command allows you to compile firmware from any directory. You can compile JSON exports from <https://config.qmk.fm> or compile keymaps in the repo.
+This command allows you to compile firmware from any directory. You can compile JSON exports from <https://config.qmk.fm>, compile keymaps in the repo, or compile the keyboard in the current working directory.
 
 **Usage for Configurator Exports**:
 
@@ -95,11 +117,57 @@ qmk compile <configuratorExport.json>
 qmk compile -kb <keyboard_name> -km <keymap_name>
 ```
 
+**Usage in Keyboard Directory**:  
+
+Must be in keyboard directory with a default keymap, or in keymap directory for keyboard, or supply one with `--keymap <keymap_name>`
+```
+qmk compile
+```
+
+**Example**:
+```
+$ qmk config compile.keymap=default
+$ cd ~/qmk_firmware/keyboards/planck/rev6
+$ qmk compile
+Ψ Compiling keymap with make planck/rev6:default
+...
+```
+or with optional keymap argument
+
+```
+$ cd ~/qmk_firmware/keyboards/clueboard/66/rev4 
+$ qmk compile -km 66_iso
+Ψ Compiling keymap with make clueboard/66/rev4:66_iso
+...
+```
+or in keymap directory
+
+```
+$ cd ~/qmk_firmware/keyboards/gh60/satan/keymaps/colemak
+$ qmk compile
+Ψ Compiling keymap with make make gh60/satan:colemak
+...
+```
+
+**Usage in Layout Directory**:  
+
+Must be under `qmk_firmware/layouts/`, and in a keymap folder.
+```
+qmk compile -kb <keyboard_name>
+```
+
+**Example**:
+```
+$ cd ~/qmk_firmware/layouts/community/60_ansi/mechmerlin-ansi
+$ qmk compile -kb dz60
+Ψ Compiling keymap with make dz60:mechmerlin-ansi
+...
+```
+
 ## `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.
+To specify a different bootloader, use `-bl <bootloader>`. Visit the [Flashing Firmware](flashing.md) guide for more details of the available bootloaders.
 
 **Usage for Configurator Exports**:
 
@@ -141,14 +209,28 @@ qmk docs [-p PORT]
 
 ## `qmk doctor`
 
-This command examines your environment and alerts you to potential build or flash problems.
+This command examines your environment and alerts you to potential build or flash problems. It can fix many of them if you want it to.
 
 **Usage**:
 
 ```
-qmk doctor
+qmk doctor [-y] [-n]
 ```
 
+**Examples**:
+
+Check your environment for problems and prompt to fix them:
+
+    qmk doctor
+
+Check your environment and automatically fix any problems found:
+
+    qmk doctor -y
+
+Check your environment and report problems only:
+
+    qmk doctor -n
+
 ## `qmk json-keymap`
 
 Creates a keymap.c from a QMK Configurator export.
@@ -191,6 +273,16 @@ This command lists all the keyboards currently defined in `qmk_firmware`
 qmk list-keyboards
 ```
 
+## `qmk list-keymaps`
+
+This command lists all the keymaps for a specified keyboard (and revision).
+
+**Usage**:
+
+```
+qmk list-keymaps -kb planck/ez
+```
+
 ## `qmk new-keymap`
 
 This command creates a new keymap based on a keyboard's existing default keymap.

docs/cli_dev_configuration.md

@@ -4,7 +4,7 @@ This document explains how `qmk config` works.
 
 # Introduction
 
-Configuration for QMK CLI is a key/value system. Each key consists of a subcommand and an argument name separated by a period. This allows for a straightforward and direct translation between config keys and the arguments they set.
+Configuration for the QMK CLI is a key/value system. Each key consists of a subcommand and an argument name separated by a period. This allows for a straightforward and direct translation between config keys and the arguments they set.
 
 ## Simple Example
 

docs/coding_conventions_python.md

@@ -309,6 +309,18 @@ FIXME(username): Revisit this code when the frob feature is done.
 
 ...where username is your GitHub username.
 
-# Unit Tests
+# Testing
 
-These are good. We should have some one day.
+We use a combination of Integration and Unit testing to ensure that the our code is as bug-free as possible. All the tests can be found in `lib/python/qmk/tests/`. You can run all the tests with `qmk pytest`.
+
+At the time of this writing our tests are not very comprehensive. Looking at the current tests and writing new test cases for untested situations is a great way to both familiarize yourself with the codebase and contribute to QMK.
+
+## Integration Tests
+
+Integration tests can be found in `lib/python/qmk/tests/test_cli_commands.py`. This is where CLI commands are actually run and their overall behavior is verified. We use [`subprocess`](https://docs.python.org/3.5/library/subprocess.html#module-subprocess) to launch each CLI command and a combination of checking output and returncode to determine if the right thing happened.
+
+## Unit Tests
+
+The other `test_*.py` files in `lib/python/qmk/tests/` contain unit tests. You can write tests for individual functions inside `lib/python/qmk/` here. Generally these files are named after the module, with dots replaced by underscores.
+
+At the time of this writing we do not do any mocking for our tests. If you would like to help us change this please [open an issue](https://github.com/qmk/qmk_firmware/issues/new?assignees=&labels=cli%2C+python&template=other_issues.md&title=) or [join #cli on Discord](https://discord.gg/heQPAgy) and start a conversation there.

docs/config_options.md

@@ -53,6 +53,8 @@ This is a C header file that is one of the first things included, and will persi
   * pins of the rows, from top to bottom
 * `#define MATRIX_COL_PINS { F1, F0, B0, C7, F4, F5, F6, F7, D4, D6, B4, D7 }`
   * pins of the columns, from left to right
+* `#define MATRIX_IO_DELAY 30`
+  * the delay in microseconds when between changing matrix pin state and reading values
 * `#define UNUSED_PINS { D1, D2, D3, B1, B2, B3 }`
   * pins unused by the keyboard for reference
 * `#define MATRIX_HAS_GHOST`
@@ -78,7 +80,7 @@ This is a C header file that is one of the first things included, and will persi
 * `#define BACKLIGHT_PIN B7`
   * pin of the backlight
 * `#define BACKLIGHT_LEVELS 3`
-  * number of levels your backlight will have (maximum 15 excluding off)
+  * number of levels your backlight will have (maximum 31 excluding off)
 * `#define BACKLIGHT_BREATHING`
   * enables backlight breathing
 * `#define BREATHING_PERIOD 6`
@@ -134,19 +136,25 @@ If you define these options you will enable the associated feature, which may in
   * enables handling for per key `TAPPING_TERM` settings
 * `#define RETRO_TAPPING`
   * tap anyway, even after TAPPING_TERM, if there was no other key interruption between press and release
-  * See [Retro Tapping](feature_advanced_keycodes.md#retro-tapping) for details
+  * See [Retro Tapping](tap_hold.md#retro-tapping) for details
 * `#define TAPPING_TOGGLE 2`
   * how many taps before triggering the toggle
 * `#define PERMISSIVE_HOLD`
   * makes tap and hold keys trigger the hold if another key is pressed before releasing, even if it hasn't hit the `TAPPING_TERM`
-  * See [Permissive Hold](feature_advanced_keycodes.md#permissive-hold) for details
+  * See [Permissive Hold](tap_hold.md#permissive-hold) for details
+* `#define PERMISSIVE_HOLD_PER_KEY`
+  * enabled handling for per key `PERMISSIVE_HOLD` settings
 * `#define IGNORE_MOD_TAP_INTERRUPT`
   * makes it possible to do rolling combos (zx) with keys that convert to other keys on hold, by enforcing the `TAPPING_TERM` for both keys.
-  * See [Mod tap interrupt](feature_advanced_keycodes.md#ignore-mod-tap-interrupt) for details
+  * See [Ignore Mod Tap Interrupt](tap_hold.md#ignore-mod-tap-interrupt) for details
+* `#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY`
+  * enables handling for per key `IGNORE_MOD_TAP_INTERRUPT` settings
 * `#define TAPPING_FORCE_HOLD`
   * makes it possible to use a dual role key as modifier shortly after having been tapped
-  * See [Hold after tap](feature_advanced_keycodes.md#tapping-force-hold)
+  * See [Tapping Force Hold](tap_hold.md#tapping-force-hold)
   * Breaks any Tap Toggle functionality (`TT` or the One Shot Tap Toggle)
+* `#define TAPPING_FORCE_HOLD_PER_KEY`
+  * enables handling for per key `TAPPING_FORCE_HOLD` settings
 * `#define LEADER_TIMEOUT 300`
   * how long before the leader key times out
     * If you're having issues finishing the sequence before it times out, you may need to increase the timeout setting. Or you may want to enable the `LEADER_PER_KEY_TIMING` option, which resets the timeout after each key is tapped.
@@ -272,9 +280,12 @@ There are a few different ways to set handedness for split keyboards (listed in
   * Default behavior for ARM
   * Required for AVR Teensy
 
-* `#define SPLIT_USB_TIMEOUT 2500`
+* `#define SPLIT_USB_TIMEOUT 2000`
   * Maximum timeout when detecting master/slave when using `SPLIT_USB_DETECT`
 
+* `#define SPLIT_USB_TIMEOUT_POLL 10`
+  * Poll frequency when detecting master/slave when using `SPLIT_USB_DETECT`
+
 # The `rules.mk` File
 
 This is a [make](https://www.gnu.org/software/make/manual/make.html) file that is included by the top-level `Makefile`. It is used to set some information about the MCU that we will be compiling for as well as enabling and disabling certain features.
@@ -287,8 +298,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`
@@ -305,7 +335,7 @@ This is a [make](https://www.gnu.org/software/make/manual/make.html) file that i
   * `bootloadHID`
   * `USBasp`
 
-## Feature Options
+## Feature Options :id=feature-options
 
 Use these to enable or disable building certain features. The more you have enabled the bigger your firmware will be, and you run the risk of building a firmware too large for your MCU.
 
@@ -347,9 +377,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 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`
-  * Alternatively, you can use `LTO_ENABLE` instead of `LINK_TIME_OPTIMIZATION_ENABLE`. 
 
 ## USB Endpoint Limitations
 

docs/configurator_step_by_step.md

@@ -0,0 +1,58 @@
+# QMK Configurator: Step by Step
+
+This page describes the steps for building your firmware in QMK Configurator.
+
+## Step 1: Select Your Keyboard
+
+Click the drop down box and select the keyboard you want to create a keymap for.
+
+?> If your keyboard has several versions, make sure you select the correct one.
+
+I'll say that again because it's important:
+
+!> **MAKE SURE YOU SELECT THE RIGHT VERSION!**
+
+If your keyboard has been advertised to be powered by QMK but is not in the list, chances are a developer hasn't gotten to it yet or we haven't had a chance to merge it in yet. File an issue at [qmk_firmware](https://github.com/qmk/qmk_firmware/issues) requesting to support that particular keyboard, if there is no active [Pull Request](https://github.com/qmk/qmk_firmware/pulls?q=is%3Aopen+is%3Apr+label%3Akeyboard) for it. There are also QMK powered keyboards that are in their manufacturer's own github accounts. Double check for that as well.  <!-- FIXME(skullydazed): This feels too wordy and I'm not sure we want to encourage these kinds of issues. Also, should we prompt them to bug the manufacutrer? -->
+
+## Step 2: Select Your Keyboard Layout
+
+Choose the layout that best represents the keymap you want to create. Some keyboards do not have enough layouts or correct layouts defined yet. They will be supported in the future.
+
+!> Sometimes there isn't a layout that supports your exact build. In that case select `LAYOUT_all`.
+
+## Step 3: Name Your Keymap
+
+Call this keymap what you want.
+
+?> If you are running into issues when compiling, it may be worth changing this name, as it may already exist in the QMK Firmware repo.
+
+## Step 4: Define Your Keymap
+
+Keycode Entry is accomplished in one of 3 ways:
+
+1. Drag and drop
+2. Clicking on an empty spot on the layout, then clicking the keycode you desire
+3. Clicking on an empty spot on the layout, then pressing the physical key on your keyboard
+
+?> Hover your mouse over a key and a short blurb will tell you what that keycode does. For a more verbose description please see:
+
+* [Basic Keycode Reference](keycodes_basic.md)
+* [Advanced Keycode Reference](feature_advanced_keycodes.md)
+
+!> If your selected layout doesn't match your physical build leave the unused keys blank. If you're not sure which key is in use, for example you have a one backspace key but `LAYOUT_all` has 2 keys, put the same keycode in both locations.
+
+## Step 5: Save Your Keymap for Future Changes
+
+When you're satisfied with your keymap or just want to work on it later, press the `Export Keymap` button. It will save your keymap to your computer. You can then load this .json file in the future by pressing the `Import Keymap` button.
+
+!> **CAUTION:** This is not the same type of .json file used for kbfirmware.com or any other tool. If you try to use this for those tools, or the .json from those tools with QMK Configurator, you will encounter problems.
+
+## Step 6: Compile Your Firmware File
+
+Press the green `Compile` button.
+
+When the compilation is done, you will be able to press the green `Download Firmware` button.
+
+## Next steps: Flashing Your Keyboard
+
+Please refer to [Flashing Firmware](newbs_flashing.md).

docs/configurator_troubleshooting.md

@@ -0,0 +1,26 @@
+# Configurator Troubleshooting
+
+## My .json file is not working
+
+If the .json file was generated with QMK Configurator, congratulations you have stumbled upon a bug. File an issue at [qmk_configurator](https://github.com/qmk/qmk_configurator/issues).
+
+If not... how did you miss the big bold message at the top saying not to use other .json files?
+
+## There are extra spaces in my layout? What do I do?
+
+If you're referring to having three spots for space bar, the best course of action is to just fill them all with Space. The same can be done for Backspace and Shift keys.
+
+## What is the keycode for...
+
+Please see:
+
+* [Basic Keycode Reference](keycodes_basic.md)
+* [Advanced Keycode Reference](feature_advanced_keycodes.md)
+
+## It won't compile
+
+Please double check the other layers of your keymap to make sure there are no random keys present.
+
+## Problems and Bugs
+
+We are always accepting customer requests and bug reports. Please file them at [qmk_configurator](https://github.com/qmk/qmk_configurator/issues).

docs/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,7 +101,7 @@ enum my_keycodes {
 };
 ```
 
-### Previewing the Documentation
+### Previewing the Documentation :id=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:
 

docs/custom_matrix.md

@@ -0,0 +1,108 @@
+# Custom Matrix
+
+QMK provides a mechanism to supplement or replace the default matrix scanning routine with your own code.
+
+The reasons to use this feature include:
+
+* Extra hardware between the keyboard's switches and MCU pins
+  * I/O multiplexer
+  * Line decoder
+* Irregular switch matrix
+  * Simultaneous use of `COL2ROW` and `ROW2COL`
+
+## Prerequisites
+
+Implementing custom matrix usually involves compilation of an additional source file. It is recommended that for consistency, this file is called `matrix.c`.
+
+Add a new file to your keyboard directory:
+```text
+keyboards/<keyboard>/matrix.c
+```
+
+And to configure compilation for the new file, add this to your `rules.mk`:
+```make
+SRC += matrix.c
+```
+
+## 'lite'
+
+Provides a default implementation for various scanning functions, reducing the boilerplate code when implementing custom matrix.
+To configure it, add this to your `rules.mk`:
+
+```make
+CUSTOM_MATRIX = lite
+```
+
+And implement the following functions in a `matrix.c` file in your keyboard folder:
+
+```c
+void matrix_init_custom(void) {
+    // TODO: initialize hardware here
+}
+
+bool matrix_scan_custom(matrix_row_t current_matrix[]) {
+    bool matrix_has_changed = false;
+
+    // TODO: add matrix scanning routine here
+
+    return matrix_has_changed;
+}
+```
+
+
+## Full Replacement
+
+When more control over the scanning routine is required, you can choose to implement the full scanning routine.
+To configure it, add this to your rules.mk:
+
+```make
+CUSTOM_MATRIX = yes
+```
+
+And implement the following functions in a `matrix.c` file in your keyboard folder:
+
+```c
+matrix_row_t matrix_get_row(uint8_t row) {
+    // TODO: return the requested row data
+}
+
+void matrix_print(void) {
+    // TODO: use print() to dump the current matrix state to console
+}
+
+void matrix_init(void) {
+    // TODO: initialize hardware and global matrix state here
+
+    // Unless hardware debouncing - Init the configured debounce routine
+    debounce_init(MATRIX_ROWS);
+
+    // This *must* be called for correct keyboard behavior
+    matrix_init_quantum();
+}
+
+uint8_t matrix_scan(void) {
+    bool matrix_has_changed = false;
+
+    // TODO: add matrix scanning routine here
+
+    // Unless hardware debouncing - use the configured debounce routine
+    debounce(raw_matrix, matrix, MATRIX_ROWS, changed);
+
+    // This *must* be called for correct keyboard behavior
+    matrix_scan_quantum();
+
+    return matrix_has_changed;
+}
+```
+
+And also provide defaults for the following callbacks:
+
+```c
+__attribute__((weak)) void matrix_init_kb(void) { matrix_init_user(); }
+
+__attribute__((weak)) void matrix_scan_kb(void) { matrix_scan_user(); }
+
+__attribute__((weak)) void matrix_init_user(void) {}
+
+__attribute__((weak)) void matrix_scan_user(void) {}
+```

docs/custom_quantum_functions.md

@@ -4,7 +4,7 @@ For a lot of people a custom keyboard is about more than sending button presses
 
 This page does not assume any special knowledge about QMK, but reading [Understanding QMK](understanding_qmk.md) will help you understand what is going on at a more fundamental level.
 
-## A Word on Core vs Keyboards vs Keymap
+## A Word on Core vs Keyboards vs Keymap :id=a-word-on-core-vs-keyboards-vs-keymap
 
 We have structured QMK as a hierarchy:
 
@@ -34,7 +34,7 @@ enum my_keycodes {
 };
 ```
 
-## Programming the Behavior of Any Keycode
+## Programming the Behavior of Any Keycode :id=programming-the-behavior-of-any-keycode
 
 When you want to override the behavior of an existing key, or define the behavior for a new key, you should use the `process_record_kb()` and `process_record_user()` functions. These are called by QMK during key processing before the actual key event is handled. If these functions return `true` QMK will process the keycodes as usual. That can be handy for extending the functionality of a key rather than replacing it. If these functions return `false` QMK will skip the normal key handling, and it will be up to you to send any key up or down events that are required.
 
@@ -313,7 +313,7 @@ void suspend_wakeup_init_user(void) {
 * Keyboard/Revision: `void suspend_power_down_kb(void)` and `void suspend_wakeup_init_user(void)`
 * Keymap: `void suspend_power_down_kb(void)` and `void suspend_wakeup_init_user(void)`
 
-# Layer Change Code
+# Layer Change Code :id=layer-change-code
 
 This runs code every time that the layers get changed.  This can be useful for layer indication, or custom layer handling.
 
@@ -489,14 +489,24 @@ The `val` is the value of the data that you want to write to EEPROM.  And the `e
 
 # Custom Tapping Term
 
-By default, the tapping term is defined globally, and is not configurable by key.  For most users, this is perfectly fine.  But in come cases, dual function keys would be greatly improved by different timeouts than `LT` keys, or because some keys may be easier to hold than others.  Instead of using custom key codes for each, this allows for per key configurable `TAPPING_TERM`.
+By default, the tapping term and related options (such as `IGNORE_MOD_TAP_INTERRUPT`) are defined globally, and are not configurable by key.  For most users, this is perfectly fine.  But in some cases, dual function keys would be greatly improved by different timeout behaviors 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 timeout behaviors.
 
-To enable this functionality, you need to add `#define TAPPING_TERM_PER_KEY` to your `config.h`, first. 
+There are two configurable options to control per-key timeout behaviors:
+
+- `TAPPING_TERM_PER_KEY`
+- `IGNORE_MOD_TAP_INTERRUPT_PER_KEY`
+
+You need to add `#define` lines to your `config.h` for each feature you want.
+
+```
+#define TAPPING_TERM_PER_KEY
+#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY
+```
 
 
 ## Example `get_tapping_term` Implementation
 
-To change the `TAPPING TERM` based on the keycode, you'd want to add something like the following to your `keymap.c` file: 
+To change the `TAPPING_TERM` based on the keycode, you'd want to add something like the following to your `keymap.c` file:
 
 ```c
 uint16_t get_tapping_term(uint16_t keycode) {
@@ -511,6 +521,21 @@ uint16_t get_tapping_term(uint16_t keycode) {
 }
 ```
 
-### `get_tapping_term` Function Documentation
+## Example `get_ignore_mod_tap_interrupt` Implementation
 
-Unlike many of the other functions here, there isn't a need (or even reason) to have a quantum or keyboard level function. Only a user level function is useful here, so no need to mark it as such.
+To change the `IGNORE_MOD_TAP_INTERRUPT` value based on the keycode, you'd want to add something like the following to your `keymap.c` file:
+
+```c
+bool get_ignore_mod_tap_interrupt(uint16_t keycode) {
+  switch (keycode) {
+    case SFT_T(KC_SPC):
+      return true;
+    default:
+      return false;
+  }
+}
+```
+
+## `get_tapping_term` / `get_ignore_mod_tap_interrupt` Function Documentation
+
+Unlike many of the other functions here, there isn't a need (or even reason) to have a quantum or keyboard level function. Only user level functions are useful here, so no need to mark them as such.

docs/de/_summary.md

@@ -77,7 +77,7 @@
   * [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)
+  * [One Shot Keys](de/one_shot_keys.md)
   * [Pointing Device](de/feature_pointing_device.md)
   * [PS/2 Mouse](de/feature_ps2_mouse.md)
   * [RGB Lighting](de/feature_rgblight.md)
@@ -108,7 +108,7 @@
 * Andere Themen
   * [Eclipse mit QMK](de/other_eclipse.md)
   * [VSCode mit QMK](de/other_vscode.md)
-  * [Support](de/support.md)
+  * [Support](de/getting_started_getting_help.md)
   * [Übersetzungen](de/translating.md)
 
 * QMK Internals (In Progress)

docs/documentation_templates.md

@@ -2,7 +2,7 @@
 
 This page documents the templates you should use when submitting new Keymaps and Keyboards to QMK.
 
-## Keymap `readme.md` Template
+## Keymap `readme.md` Template :id=keyboard-readmemd-template
 
 Most keymaps have an image depicting the layout. You can use [Keyboard Layout Editor](http://keyboard-layout-editor.com) to create an image. Upload it to [Imgur](http://imgur.com) or another hosting service, please do not include images in your Pull Request.
 

docs/eeprom_driver.md

@@ -0,0 +1,50 @@
+# EEPROM Driver Configuration
+
+The EEPROM driver can be swapped out depending on the needs of the keyboard, or whether extra hardware is present.
+
+Driver                      | Description
+--------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+`EEPROM_DRIVER = vendor`    | Uses the on-chip driver provided by the chip manufacturer. For AVR, this is provided by avr-libc. This is supported on ARM for a subset of chips -- STM32F3xx, STM32F1xx, and STM32F072xB will be emulated by writing to flash. Other chips will generally act as "transient" below.
+`EEPROM_DRIVER = i2c`       | Supports writing to I2C-based 24xx EEPROM chips. See the driver section below.
+`EEPROM_DRIVER = transient` | Fake EEPROM driver -- supports reading/writing to RAM, and will be discarded when power is lost.
+
+## Vendor Driver Configuration
+
+No configurable options are available.
+
+## I2C Driver Configuration
+
+Currently QMK supports 24xx-series chips over I2C. As such, requires a working i2c_master driver configuration. You can override the driver configuration via your config.h:
+
+`config.h` override                         | Description                                                                         | Default Value
+------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------
+`#define EXTERNAL_EEPROM_I2C_BASE_ADDRESS`  | Base I2C address for the EEPROM -- shifted left by 1 as per i2c_master requirements | 0b10100000
+`#define EXTERNAL_EEPROM_I2C_ADDRESS(addr)` | Calculated I2C address for the EEPROM                                               | `(EXTERNAL_EEPROM_I2C_BASE_ADDRESS)`
+`#define EXTERNAL_EEPROM_BYTE_COUNT`        | Total size of the EEPROM in bytes                                                   | 8192
+`#define EXTERNAL_EEPROM_PAGE_SIZE`         | Page size of the EEPROM in bytes, as specified in the datasheet                     | 32
+`#define EXTERNAL_EEPROM_ADDRESS_SIZE`      | The number of bytes to transmit for the memory location within the EEPROM           | 2
+`#define EXTERNAL_EEPROM_WRITE_TIME`        | Write cycle time of the EEPROM, as specified in the datasheet                       | 5
+
+Default values and extended descriptions can be found in `drivers/eeprom/eeprom_i2c.h`.
+
+Alternatively, there are pre-defined hardware configurations for available chips/modules:
+
+Module           | Equivalent `#define`            | Source
+-----------------|---------------------------------|------------------------------------------
+CAT24C512 EEPROM | `#define EEPROM_I2C_CAT24C512`  | <https://www.sparkfun.com/products/14764>
+RM24C512C EEPROM | `#define EEPROM_I2C_RM24C512C`  | <https://www.sparkfun.com/products/14764>
+24LC128 EEPROM   | `#define EEPROM_I2C_24LC128`    | <https://www.microchip.com/wwwproducts/en/24LC128>
+24LC256 EEPROM   | `#define EEPROM_I2C_24LC256`    | <https://www.sparkfun.com/products/525>
+MB85RC256V FRAM  | `#define EEPROM_I2C_MB85RC256V` | <https://www.adafruit.com/product/1895>
+
+?> If you find that the EEPROM is not cooperating, ensure you've correctly shifted up your EEPROM address by 1. For example, the datasheet might state the address as `0b01010000` -- the correct value of `EXTERNAL_EEPROM_I2C_BASE_ADDRESS` needs to be `0b10100000`.
+
+## Transient Driver configuration
+
+The only configurable item for the transient EEPROM driver is its size:
+
+`config.h` override             | Description                               | Default Value
+------------------------------- | ----------------------------------------- | -------------
+`#define TRANSIENT_EEPROM_SIZE` | Total size of the EEPROM storage in bytes | 64
+
+Default values and extended descriptions can be found in `drivers/eeprom/eeprom_transient.h`.

docs/es/_summary.md

@@ -77,7 +77,7 @@
   * [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)
+  * [Teclas One Shot](es/one_shot_keys.md)
   * [Dispositivo de apuntado](es/feature_pointing_device.md)
   * [Ratón PS/2](es/feature_ps2_mouse.md)
   * [Iluminación RGB](es/feature_rgblight.md)
@@ -108,7 +108,7 @@
 * Otros temas
   * [Usando Eclipse con QMK](es/other_eclipse.md)
   * [Usando VSCode con QMK](es/other_vscode.md)
-  * [Soporte](es/support.md)
+  * [Soporte](es/getting_started_getting_help.md)
   * [Cómo añadir traducciones](es/translating.md)
 
 * QMK Internals (En progreso)

docs/es/becoming_a_qmk_collaborator.md

@@ -1,9 +0,0 @@
-# Llegar a ser un colaborador QMK
-
-Un colaborador QMK es un maker o diseñador de teclados que tiene interés en ayudar a QMK a crecer y mantener sus teclado(s), y alentar a los usuarios y clientes a presentar herramientas, ideas, y keymaps. Siempre procuramos agregar más teclados y colaboradores, pero pedimos que cumplan los siguientes requisitos:
-
-* **Tener un PCB disponible a la venta.** Desafortunadamente, hay demasiada variación y complicaciones con teclados cableados a mano.
-* **Realizar el mantenimiento de tu teclado en QMK.** Este podría requirir un setup inicial para hacer que tu teclado funcione, pero también podría incluir adaptarse a cambios hecho al base de QMK que podrían descomponer o rendir código superfluo.
-* **Aprobar e incorporar pull requests de keymaps para tu teclado.** Nos gusta alentar a los usuarios a contribuir sus keymaps para que otros los vean y los puedan usar para crear sus propios.
-
-Si sientes que cumples los requisitos, ¡mándanos un email a hello@qmk.fm con una introducción y algunos enlaces para tu teclado!

docs/es/newbs_building_firmware_configurator.md

@@ -4,7 +4,7 @@ El [Configurador QMK](https://config.qmk.fm) es un entorno gráfico online que g
 
 ?> **Por favor sigue estos pasos en orden.**
 
-Ve el [Video tutorial](https://youtu.be/tx54jkRC9ZY)
+Ve el [Video tutorial](https://www.youtube.com/watch?v=-imgglzDMdY)
 
 El Configurador QMK functiona mejor con Chrome/Firefox. 
 

docs/faq.md

@@ -1,6 +0,0 @@
-# Frequently Asked Questions
-
-* [General](faq_general.md)
-* [Building or Compiling QMK](faq_build.md)
-* [Debugging and Troubleshooting QMK](faq_debug.md)
-* [Keymap](faq_keymap.md)

docs/faq_build.md

@@ -87,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.
 
@@ -103,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.
 
@@ -146,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

@@ -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_general.md

@@ -4,6 +4,44 @@
 
 [QMK](https://github.com/qmk), short for Quantum Mechanical Keyboard, is a group of people building tools for custom keyboards. We started with the [QMK firmware](https://github.com/qmk/qmk_firmware), a heavily modified fork of [TMK](https://github.com/tmk/tmk_keyboard).
 
+## I don't know where to start!
+
+If this is the case, then you should start with our [Newbs Guide](newbs.md). There is a lot of great info there, and that should cover everything you need to get started.
+
+If that's an issue, hop onto the [QMK Configurator](https://config.qmk.fm), as that will handle a majority of what you need there.
+
+## How can I flash the firmware I built?
+
+First, head to the [Compiling/Flashing FAQ Page](faq_build.md). There is a good deal of info there, and you'll find a bunch of solutions to common issues there.
+
+## What if I have an issue that isn't covered here?
+
+Okay, that's fine. Then please check the [open issues in our GitHub](https://github.com/qmk/qmk_firmware/issues) to see if somebody is experiencing the same thing (make sure it's not just similar, but actually the same).
+
+If you can't find anything, then please open a [new issue](https://github.com/qmk/qmk_firmware/issues/new)!
+
+## What if I found a bug?
+
+Then please open an [issue](https://github.com/qmk/qmk_firmware/issues/new), and if you know how to fix it, open up a Pull Request on GitHub with the fix.
+
+## But `git` and `GitHub` are intimidating!
+
+Don't worry, we have some pretty nice [Guidelines](newbs_git_best_practices.md) on how to start using `git` and GitHub to make things easier to develop.
+
+Additionally, you can find additional `git` and GitHub related links [here](newbs_learn_more_resources.md).
+
+## I have a Keyboard that I want to add support for
+
+Awesome! Open up a Pull Request for it. We'll review the code, and merge it!
+
+### What if I want to do brand it with `QMK`?
+
+That's amazing! We would love to assist you with that!
+
+In fact, we have a [whole page](https://qmk.fm/powered/) dedicated to adding QMK Branding to your page and keyboard. This covers pretty much everything you need (knowledge and images) to officially support QMK.
+
+If you have any questions about this, open an issue or head to [Discord](https://discord.gg/Uq7gcHh).
+
 ## What Differences Are There Between QMK and TMK?
 
 TMK was originally designed and implemented by [Jun Wako](https://github.com/tmk). QMK started as [Jack Humbert](https://github.com/jackhumbert)'s fork of TMK for the Planck. After a while Jack's fork had diverged quite a bit from TMK, and in 2015 Jack decided to rename his fork to QMK.

docs/faq_keymap.md

@@ -14,6 +14,17 @@ There are 3 standard keyboard layouts in use around the world- ANSI, ISO, and JI
 <!-- Source for this image: http://www.keyboard-layout-editor.com/#/gists/bf431647d1001cff5eff20ae55621e9a -->
 ![Keyboard Layout Image](https://i.imgur.com/5wsh5wM.png)
 
+## How Can I Make Custom Names For Complex Keycodes?
+
+Sometimes, for readability's sake, it's useful to define custom names for some keycodes. People often define custom names using `#define`. For example:
+
+```c
+#define FN_CAPS LT(_FL, KC_CAPSLOCK)
+#define ALT_TAB LALT(KC_TAB)
+```
+
+This will allow you to use `FN_CAPS` and `ALT_TAB` in your keymap, keeping it more readable.
+
 ## Some Of My Keys Are Swapped Or Not Working
 
 QMK has two features, Bootmagic and Command, which allow you to change the behavior of your keyboard on the fly. This includes, but is not limited to, swapping Ctrl/Caps, disabling Gui, swapping Alt/Gui, swapping Backspace/Backslash, disabling all keys, and other behavioral modifications. 
@@ -67,24 +78,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 +125,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

@@ -1,25 +1,4 @@
-# Advanced Keycodes
-
-Your keymap can include keycodes that are more advanced than normal, for example keys that switch layers or send modifiers when held, but send regular keycodes when tapped. This page documents the functions that are available to you.
-
-## Assigning Custom Names
-
-People often define custom names using `#define`. For example:
-
-```c
-#define FN_CAPS LT(_FL, KC_CAPSLOCK)
-#define ALT_TAB LALT(KC_TAB)
-```
-
-This will allow you to use `FN_CAPS` and `ALT_TAB` in your keymap, keeping it more readable.
-
-## Caveats
-
-Currently, `LT()` and `MT()` are limited to the [Basic Keycode set](keycodes_basic.md), meaning you can't use keycodes like `LCTL()`, `KC_TILD`, or anything greater than `0xFF`. Modifiers specified as part of a Layer Tap or Mod Tap's keycode will be ignored. If you need to apply modifiers to your tapped keycode, [Tap Dance](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.
-
-# Switching and Toggling Layers
+# Switching and Toggling Layers :id=switching-and-toggling-layers
 
 These functions allow you to activate layers in various ways. Note that layers are not generally independent layouts -- multiple layers can be activated at once, and it's typical for layers to use `KC_TRNS` to allow keypresses to pass through to lower layers. For a detailed explanation of layers, see [Keymap Overview](keymap.md#keymap-and-layers). When using momentary layer switching with MO(), LM(), TT(), or LT(), make sure to leave the key on the above layers transparent or it may not work as intended.
 
@@ -27,11 +6,17 @@ These functions allow you to activate layers in various ways. Note that layers a
 * `MO(layer)` - momentarily activates *layer*. As soon as you let go of the key, the layer is deactivated. 
 * `LM(layer, mod)` - Momentarily activates *layer* (like `MO`), but with modifier(s) *mod* active. Only supports layers 0-15 and the left modifiers: `MOD_LCTL`, `MOD_LSFT`, `MOD_LALT`, `MOD_LGUI` (note the use of `MOD_` constants instead of `KC_`). These modifiers can be combined using bitwise OR, e.g. `LM(_RAISE, MOD_LCTL | MOD_LALT)`.
 * `LT(layer, kc)` - momentarily activates *layer* when held, and sends *kc* when tapped. Only supports layers 0-15.
-* `OSL(layer)` - momentarily activates *layer* until the next key is pressed. See [One Shot Keys](#one-shot-keys) for details and additional functionality.
+* `OSL(layer)` - momentarily activates *layer* until the next key is pressed. See [One Shot Keys](one_shot_keys.md) for details and additional functionality.
 * `TG(layer)` - toggles *layer*, activating it if it's inactive and vice versa
 * `TO(layer)` - activates *layer* and de-activates all other layers (except your default layer). This function is special, because instead of just adding/removing one layer to your active layer stack, it will completely replace your current active layers, uniquely allowing you to replace higher layers with a lower one. This is activated on keydown (as soon as the key is pressed).
 * `TT(layer)` - Layer Tap-Toggle. If you hold the key down, *layer* is activated, and then is de-activated when you let go (like `MO`). If you repeatedly tap it, the layer will be toggled on or off (like `TG`). It needs 5 taps by default, but you can change this by defining `TAPPING_TOGGLE` -- for example, `#define TAPPING_TOGGLE 2` to toggle on just two taps.
 
+## 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](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.
+
 # Working with Layers
 
 Care must be taken when switching layers, it's possible to lock yourself into a layer with no way to deactivate that layer (without unplugging your keyboard.) We've created some guidelines to help users avoid the most common problems.
@@ -56,7 +41,7 @@ Layers stack on top of each other in numerical order. When determining what a ke
 
 Sometimes, you might want to switch between layers in a macro or as part of a tap dance routine. `layer_on` activates a layer, and `layer_off` deactivates it. More layer-related functions can be found in [action_layer.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action_layer.h).
 
-# Modifier Keys
+# Modifier Keys :id=modifier-keys
 
 These allow you to combine a modifier with a keycode. When pressed, the keydown event for the modifier, then `kc` will be sent. On release, the keyup event for `kc`, then the modifier will be sent.
 
@@ -78,251 +63,18 @@ These allow you to combine a modifier with a keycode. When pressed, the keydown
 
 You can also chain them, for example `LCTL(LALT(KC_DEL))` makes a key that sends Control+Alt+Delete with a single keypress.
 
-# Mod-Tap
+# Legacy Content
 
-The Mod-Tap key `MT(mod, kc)` acts like a modifier when held, and a regular keycode when tapped. In other words, you can have a key that sends Escape when you tap it, but functions as a Control or Shift key when you hold it down.
+This page used to encompass a large set of features. We have moved many sections that used to be part of this page to their own pages. Everything below this point is simply a redirect so that people following old links on the web find what they're looking for.
 
-The modifiers this keycode and `OSM()` accept are prefixed with `MOD_`, not `KC_`:
+## Mod-Tap :id=mod-tap
 
-|Modifier  |Description                             |
-|----------|----------------------------------------|
-|`MOD_LCTL`|Left Control                            |
-|`MOD_LSFT`|Left Shift                              |
-|`MOD_LALT`|Left Alt                                |
-|`MOD_LGUI`|Left GUI (Windows/Command/Meta key)     |
-|`MOD_RCTL`|Right Control                           |
-|`MOD_RSFT`|Right Shift                             |
-|`MOD_RALT`|Right Alt (AltGr)                       |
-|`MOD_RGUI`|Right GUI (Windows/Command/Meta key)    |
-|`MOD_HYPR`|Hyper (Left Control, Shift, Alt and GUI)|
-|`MOD_MEH` |Meh (Left Control, Shift, and Alt)      |
+* [Mod-Tap](mod_tap.md)
 
-You can combine these by ORing them together like so:
+## One Shot Keys :id=one-shot-keys
 
-```c
-MT(MOD_LCTL | MOD_LSFT, KC_ESC)
-```
+* [One Shot Keys](one_shot_keys.md)
 
-This key would activate Left Control and Left Shift when held, and send Escape when tapped.
+## Tap-Hold Configuration Options :id=tap-hold-configuration-options
 
-For convenience, QMK includes some Mod-Tap shortcuts to make common combinations more compact in your keymap:
-
-|Key         |Aliases                                                          |Description                                            |
-|------------|-----------------------------------------------------------------|-------------------------------------------------------|
-|`LCTL_T(kc)`|`CTL_T(kc)`                                                      |Left Control when held, `kc` when tapped               |
-|`LSFT_T(kc)`|`SFT_T(kc)`                                                      |Left Shift when held, `kc` when tapped                 |
-|`LALT_T(kc)`|`ALT_T(kc)`                                                      |Left Alt when held, `kc` when tapped                   |
-|`LGUI_T(kc)`|`LCMD_T(kc)`, `LWIN_T(kc)`, `GUI_T(kc)`, `CMD_T(kc)`, `WIN_T(kc)`|Left GUI when held, `kc` when tapped                   |
-|`RCTL_T(kc)`|                                                                 |Right Control when held, `kc` when tapped              |
-|`RSFT_T(kc)`|                                                                 |Right Shift when held, `kc` when tapped                |
-|`RALT_T(kc)`|`ALGR_T(kc)`                                                     |Right Alt when held, `kc` when tapped                  |
-|`RGUI_T(kc)`|`RCMD_T(kc)`, `RWIN_T(kc)`                                       |Right GUI when held, `kc` when tapped                  |
-|`SGUI_T(kc)`|`SCMD_T(kc)`, `SWIN_T(kc)`                                       |Left Shift and GUI when held, `kc` when tapped         |
-|`LCA_T(kc)` |                                                                 |Left Control and Alt when held, `kc` when tapped       |
-|`LCAG_T(kc)`|                                                                 |Left Control, Alt and GUI when held, `kc` when tapped  |
-|`RCAG_T(kc)`|                                                                 |Right Control, Alt and GUI when held, `kc` when tapped |
-|`C_S_T(kc)` |                                                                 |Left Control and Shift when held, `kc` when tapped     |
-|`MEH_T(kc)` |                                                                 |Left Control, Shift and Alt when held, `kc` when tapped|
-|`HYPR_T(kc)`|`ALL_T(kc)`                                                      |Left Control, Shift, Alt and GUI when held, `kc` when tapped - more info [here](http://brettterpstra.com/2012/12/08/a-useful-caps-lock-key/)|
-
-## Caveats
-
-Unfortunately, these keycodes cannot be used in Mod-Taps or Layer-Taps, since any modifiers specified in the keycode are ignored.
-
-Additionally, you may run into issues when using Remote Desktop Connection on Windows. Because these codes send shift very fast, Remote Desktop may miss the codes.
-
-To fix this, open Remote Desktop Connection, click on "Show Options", open the the "Local Resources" tab. In the keyboard section, change the drop down to "On this Computer". This will fix the issue, and allow the characters to work correctly.
-
-# One Shot Keys
-
-One shot keys are keys that remain active until the next key is pressed, and then are released. This allows you to type keyboard combinations without pressing more than one key at a time. These keys are usually called "Sticky keys" or "Dead keys".
-
-For example, if you define a key as `OSM(MOD_LSFT)`, you can type a capital A character by first pressing and releasing shift, and then pressing and releasing A. Your computer will see the shift key being held the moment shift is pressed, and it will see the shift key being released immediately after A is released.
-
-One shot keys also work as normal modifiers. If you hold down a one shot key and type other keys, your one shot will be released immediately after you let go of the key.
-
-Additionally, hitting keys five times in a short period will lock that key. This applies for both One Shot Modifiers and One Shot Layers, and is controlled by the `ONESHOT_TAP_TOGGLE` define.
-
-You can control the behavior of one shot keys by defining these in `config.h`:
-
-```c
-#define ONESHOT_TAP_TOGGLE 5  /* Tapping this number of times holds the key until tapped once again. */
-#define ONESHOT_TIMEOUT 5000  /* Time (in ms) before the one shot key is released */
-```
-
-* `OSM(mod)` - Momentarily hold down *mod*. You must use the `MOD_*` keycodes as shown in [Mod Tap](#mod-tap), not the `KC_*` codes.
-* `OSL(layer)` - momentary switch to *layer*.
-
-Sometimes, you want to activate a one-shot 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 `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.
-
-!> If you're having issues with OSM translating over Remote Desktop Connection, this can be fixed by opening the settings, going to the "Local Resources" tap, and in the keyboard section, change the drop down to "On this Computer".  This will fix the issue and allow OSM to function properly over Remote Desktop.
-
-## Callbacks
-
-When you'd like to perform custom logic when pressing a one shot key, there are several callbacks you can choose to implement. You could indicate changes in one shot keys by flashing an LED or making a sound, for example.
-
-There is a callback for `OSM(mod)`. It is called whenever the state of any one shot modifier key is changed: when it toggles on, but also when it is toggled off. You can use it like this:
-
-```c
-void oneshot_mods_changed_user(uint8_t mods) {
-  if (mods & MOD_MASK_SHIFT) {
-    println("Oneshot mods SHIFT");
-  }
-  if (mods & MOD_MASK_CTRL) {
-    println("Oneshot mods CTRL");
-  }
-  if (mods & MOD_MASK_ALT) {
-    println("Oneshot mods ALT");
-  }
-  if (mods & MOD_MASK_GUI) {
-    println("Oneshot mods GUI");
-  }
-  if (!mods) {
-    println("Oneshot mods off");
-  }
-}
-```
-
-The `mods` argument contains the active mods after the change, so it reflects the current state.
-
-When you use One Shot Tap Toggle (by adding `#define ONESHOT_TAP_TOGGLE 2` in your `config.h` file), you may lock a modifier key by pressing it the specified amount of times. There's a callback for that, too:
-
-```c
-void oneshot_locked_mods_changed_user(uint8_t mods) {
-  if (mods & MOD_MASK_SHIFT) {
-    println("Oneshot locked mods SHIFT");
-  }
-  if (mods & MOD_MASK_CTRL) {
-    println("Oneshot locked mods CTRL");
-  }
-  if (mods & MOD_MASK_ALT) {
-    println("Oneshot locked mods ALT");
-  }
-  if (mods & MOD_MASK_GUI) {
-    println("Oneshot locked mods GUI");
-  }
-  if (!mods) {
-    println("Oneshot locked mods off");
-  }
-}
-```
-
-Last, there is also a callback for the `OSL(layer)` one shot key:
-
-```c
-void oneshot_layer_changed_user(uint8_t layer) {
-  if (layer == 1) {
-    println("Oneshot layer 1 on");
-  }
-  if (!layer) {
-    println("Oneshot layer off");
-  }
-}
-```
-
-If any one shot layer is switched off, `layer` will be zero. When you're looking to do something on any layer change instead of one shot layer changes, `layer_state_set_user` is a better callback to use.
-
-If you are making your own keyboard, there are also `_kb` equivalent functions:
-
-```c
-void oneshot_locked_mods_changed_kb(uint8_t mods);
-void oneshot_mods_changed_kb(uint8_t mods);
-void oneshot_layer_changed_kb(uint8_t layer);
-```
-
-As with any callback, be sure to call the `_user` variant to allow for further customizability.
-
-# Tap-Hold Configuration Options
-
-While Tap-Hold options are fantastic, they are not without their issues.  We have tried to configure them with reasonal defaults, but that may still cause issues for some people. 
-
-These options let you modify the behavior of the Tap-Hold keys.
-
-## Permissive Hold
-
-As of [PR#1359](https://github.com/qmk/qmk_firmware/pull/1359/), there is a new `config.h` option:
-
-```c
-#define PERMISSIVE_HOLD
-```
-
-This makes tap and hold keys (like Mod Tap) work better for fast typist, or for high `TAPPING_TERM` settings. 
-
-If you press a Mod Tap key, tap another key (press and release) and then release the Mod Tap key, all within the tapping term, it will output the "tapping" function for both keys.
-
-For Instance:
-
-- `SFT_T(KC_A)` Down
-- `KC_X` Down
-- `KC_X` Up
-- `SFT_T(KC_A)` Up
-
-Normally, if you do all this within the `TAPPING_TERM` (default: 200ms) this will be registered as `ax` by the firmware and host system. With permissive hold enabled, this modifies how this is handled by considering the Mod Tap keys as a Mod if another key is tapped, and would registered as `X` (`SHIFT`+`x`). 
-
-?> If you have `Ignore Mod Tap Interrupt` enabled, as well, this will modify how both work. The regular key has the modifier added if the first key is released first or if both keys are held longer than the `TAPPING_TERM`.
-
-## Ignore Mod Tap Interrupt
-
-To enable this setting, add this to your `config.h`:
-
-```c
-#define IGNORE_MOD_TAP_INTERRUPT
-```
-
-Similar to Permissive Hold, this alters how the firmware processes input for fast typist. If you press a Mod Tap key, press another key, release the Mod Tap key, and then release the normal key, it would normally output the "tapping" function for both keys. This may not be desirable for rolling combo keys. 
-
-Setting `Ignore Mod Tap Interrupt` requires  holding both keys for the `TAPPING_TERM` to trigger the hold function (the mod).
-
-For Instance:
-
-- `SFT_T(KC_A)` Down
-- `KC_X` Down
-- `SFT_T(KC_A)` Up
-- `KC_X` Up
-
-Normally, this would send `X` (`SHIFT`+`x`). With `Ignore Mod Tap Interrupt` enabled, holding both keys are required for the `TAPPING_TERM` to register the hold action. A quick tap will output `ax` in this case, while a hold on both will still output `X`  (`SHIFT`+`x`).
-
-
-?> __Note__: This only concerns modifiers and not layer switching keys.
-
-?> If you have `Permissive Hold` enabled, as well, this will modify how both work. The regular key has the modifier added if the first key is released first or if both keys are held longer than the `TAPPING_TERM`.
-
-## Tapping Force Hold
-
-To enable `tapping force hold`, add the following to your `config.h`: 
-
-```c
-#define TAPPING_FORCE_HOLD
-```
-
-When the user holds a key after tap, this repeats the tapped key rather to hold a modifier key.  This allows to use auto repeat for the tapped key.  
-
-Example:
-
-- SFT_T(KC_A) Down
-- SFT_T(KC_A) Up
-- SFT_T(KC_A) Down
-- wait more than tapping term...
-- SFT_T(KC_A) Up
-
-With default settings, `a` will be sent on the first release, then `a` will be sent on the second press allowing the computer to trigger its auto repeat function.
-
-With `TAPPING_FORCE_HOLD`, the second press will be interpreted as a Shift, allowing to use it as a modifier shortly after having used it as a tap.
-
-!> `TAPPING_FORCE_HOLD` will break anything that uses tapping toggles (Such as the `TT` layer keycode, and the One Shot Tapping Toggle).
-
-## Retro Tapping
-
-To enable `retro tapping`, add the following to your `config.h`: 
-
-```c
-#define RETRO_TAPPING
-```
-
-Holding and releasing a dual function key without pressing another key will result in nothing happening. With retro tapping enabled, releasing the key without pressing another will send the original keycode even if it is outside the tapping term.
-
-For instance, holding and releasing `LT(2, KC_SPACE)` without hitting another key will result in nothing happening. With this enabled, it will send `KC_SPACE` instead.
+* [Tap-Hold Configuration Options](tap_hold.md)

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
@@ -111,10 +119,22 @@ When both timers are in use for Audio, the backlight PWM will not use a hardware
 
 To change the behavior of the backlighting, `#define` these in your `config.h`:
 
-|Define               |Default      |Description                                                                                                   |
-|---------------------|-------------|--------------------------------------------------------------------------------------------------------------|
-|`BACKLIGHT_PIN`      |`B7`         |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this |
-|`BACKLIGHT_PINS`     |*Not defined*|experimental: see below for more information                                                                  |
+|Define               |Default      |Description                                                                                                  |
+|---------------------|-------------|-------------------------------------------------------------------------------------------------------------|
+|`BACKLIGHT_PIN`      |`B7`         |The pin that controls the LEDs. Unless you are designing your own keyboard, you shouldn't need to change this|
+|`BACKLIGHT_PINS`     |*Not defined*|experimental: see below for more information                                                                 |
+|`BACKLIGHT_LEVELS`   |`3`          |The number of brightness levels (maximum 31 excluding off)                                                   |
+|`BACKLIGHT_CAPS_LOCK`|*Not defined*|Enable Caps Lock indicator using backlight (for keyboards without dedicated LED)                             |
+|`BACKLIGHT_BREATHING`|*Not defined*|Enable backlight breathing, if supported                                                                     |
+|`BREATHING_PERIOD`   |`6`          |The length of one backlight "breath" in seconds                                                              |
+|`BACKLIGHT_ON_STATE` |`1`          |The state of the backlight pin when the backlight is "on" - `1` for high, `0` for low                        |
+
+### Backlight On State
+
+Most backlight circuits are driven by an N-channel MOSFET or NPN transistor. This means that to turn the transistor *on* and light the LEDs, you must drive the backlight pin, connected to the gate or base, *high*.
+Sometimes, however, a P-channel MOSFET, or a PNP transistor is used. In this case, when the transistor is on, the pin is driven *low* instead.
+
+This functionality is configured at the keyboard level with the `BACKLIGHT_ON_STATE` define.
 
 ### Multiple backlight pins
 
@@ -150,16 +170,16 @@ 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
 
 Currently only hardware PWM is supported, not timer assisted, and does not provide automatic configuration.
 
-?> STMF072 support is being investigated.
+?> Backlight support for STMF072 has had limited testing, YMMV. If unsure, set `BACKLIGHT_ENABLE = no` in your rules.mk.
 
 ### ARM Configuration
 
@@ -172,11 +192,11 @@ To change the behavior of the backlighting, `#define` these in your `config.h`:
 |`BACKLIGHT_PWM_CHANNEL` |`3`          |The PWM channel to use, see ST datasheets for pin to PWM channel mapping. Unless you are designing your own keyboard, you shouldn't need to change this|
 |`BACKLIGHT_PAL_MODE`    |`2`          |The pin alternative function to use, see ST datasheets for pin AF mapping. Unless you are designing your own keyboard, you shouldn't need to change this|
 
-## Software PWM Driver
+## Software PWM Driver :id=software-pwm-driver
 
 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 +220,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

@@ -54,7 +54,7 @@ Hold down the Bootmagic key (Space by default) and the desired hotkey while plug
 |`6`               |Make layer 6 the default layer               |
 |`7`               |Make layer 7 the default layer               |
 
-## Keycodes
+## Keycodes :id=keycodes
 
 |Key                               |Aliases  |Description                                                               |
 |----------------------------------|---------|--------------------------------------------------------------------------|
@@ -121,7 +121,7 @@ If you would like to change the hotkey assignments for Bootmagic, `#define` thes
 |`BOOTMAGIC_KEY_DEFAULT_LAYER_6`         |`KC_6`       |Make layer 6 the default layer                     |
 |`BOOTMAGIC_KEY_DEFAULT_LAYER_7`         |`KC_7`       |Make layer 7 the default layer                     |
 
-# Bootmagic Lite
+# Bootmagic Lite :id=bootmagic-lite
 
 In addition to the full blown Bootmagic feature, is the Bootmagic Lite feature that only handles jumping into the bootloader.  This is great for boards that don't have a physical reset button but you need a way to jump into the bootloader, and don't want to deal with the headache that Bootmagic can cause.
 

docs/feature_encoders.md

@@ -2,23 +2,35 @@
 
 Basic encoders are supported by adding this to your `rules.mk`:
 
-    ENCODER_ENABLE = yes
+```make
+ENCODER_ENABLE = yes
+```
 
 and this to your `config.h`:
 
-    #define ENCODERS_PAD_A { B12 }
-    #define ENCODERS_PAD_B { B13 }
+```c
+#define ENCODERS_PAD_A { B12 }
+#define ENCODERS_PAD_B { B13 }
+```
 
 Each PAD_A/B variable defines an array so multiple encoders can be defined, e.g.:
 
-    #define ENCODERS_PAD_A { encoder1a, encoder2a }
-    #define ENCODERS_PAD_B { encoder1b, encoder2b }
+```c
+#define ENCODERS_PAD_A { encoder1a, encoder2a }
+#define ENCODERS_PAD_B { encoder1b, encoder2b }
+```
 
-If your encoder's clockwise directions are incorrect, you can swap the A & B pad definitions.
+If your encoder's clockwise directions are incorrect, you can swap the A & B pad definitions.  They can also be flipped with a define:
+
+```c
+#define ENCODER_DIRECTION_FLIP
+```
 
 Additionally, the resolution can be specified in the same file (the default & suggested is 4):
 
-    #define ENCODER_RESOLUTION 4
+```c
+#define ENCODER_RESOLUTION 4
+```
 
 ## Split Keyboards
 
@@ -33,27 +45,31 @@ If you are using different pinouts for the encoders on each half of a split keyb
 
 The callback functions can be inserted into your `<keyboard>.c`:
 
-    void encoder_update_kb(uint8_t index, bool clockwise) {
-        encoder_update_user(index, clockwise);
-    }
+```c
+void encoder_update_kb(uint8_t index, bool clockwise) {
+    encoder_update_user(index, clockwise);
+}
+```
 
 or `keymap.c`:
 
-    void encoder_update_user(uint8_t index, bool clockwise) {
-      if (index == 0) { /* First encoder */
+```c
+void encoder_update_user(uint8_t index, bool clockwise) {
+    if (index == 0) { /* First encoder */
         if (clockwise) {
-          tap_code(KC_PGDN);
+            tap_code(KC_PGDN);
         } else {
-          tap_code(KC_PGUP);
+            tap_code(KC_PGUP);
         }
-      } else if (index == 1) { /* Second encoder */  
+        } else if (index == 1) { /* Second encoder */  
         if (clockwise) {
-          tap_code(KC_UP);
+            tap_code(KC_DOWN);
         } else {
-          tap_code(KC_DOWN);
+            tap_code(KC_UP);
         }
-      }
     }
+}
+```
 
 ## Hardware
 

docs/feature_key_lock.md

@@ -16,7 +16,7 @@ First, enable Key Lock by setting `KEY_LOCK_ENABLE = yes` in your `rules.mk`. Th
 
 ## Caveats
 
-Key Lock is only able to hold standard action keys and [One Shot modifier](feature_advanced_keycodes.md#one-shot-keys) keys (for example, if you have your Shift defined as `OSM(KC_LSFT)`).
+Key Lock is only able to hold standard action keys and [One Shot modifier](one_shot_keys.md) keys (for example, if you have your Shift defined as `OSM(KC_LSFT)`).
 This does not include any of the QMK special functions (except One Shot modifiers), or shifted versions of keys such as `KC_LPRN`. If it's in the [Basic Keycodes](keycodes_basic.md) list, it can be held.
 
 Switching layers will not cancel the Key Lock.

docs/feature_leader_key.md

@@ -74,7 +74,7 @@ SEQ_THREE_KEYS(KC_C, KC_C, KC_C) {
 
 ## Strict Key Processing
 
-By default, the Leader Key feature will filter the keycode out of [`Mod-Tap`](feature_advanced_keycodes.md#mod-tap) and [`Layer Tap`](feature_advanced_keycodes.md#switching-and-toggling-layers) functions when checking for the Leader sequences. That means if you're using `LT(3, KC_A)`, it will pick this up as `KC_A` for the sequence, rather than `LT(3, KC_A)`, giving a more expected behavior for newer users.
+By default, the Leader Key feature will filter the keycode out of [`Mod-Tap`](mod_tap.md) and [`Layer Tap`](feature_advanced_keycodes.md#switching-and-toggling-layers) functions when checking for the Leader sequences. That means if you're using `LT(3, KC_A)`, it will pick this up as `KC_A` for the sequence, rather than `LT(3, KC_A)`, giving a more expected behavior for newer users.
 
 While, this may be fine for most, if you want to specify the whole keycode (eg, `LT(3, KC_A)` from the example above) in the sequence, you can enable this by added `#define LEADER_KEY_STRICT_KEY_PROCESSING` to your `config.h` file.  This well then disable the filtering, and you'll need to specify the whole keycode.
 

docs/feature_macros.md

@@ -107,6 +107,16 @@ Would tap `KC_HOME` - note how the prefix is now `X_`, and not `KC_`. You can al
 
 Which would send "VE" followed by a `KC_HOME` tap, and "LO" (spelling "LOVE" if on a newline).
 
+Delays can be also added to the string:
+
+* `SS_DELAY(msecs)` will delay for the specified number of milliseconds.
+
+For example:
+
+    SEND_STRING("VE" SS_DELAY(1000) SS_TAP(X_HOME) "LO");
+
+Which would send "VE" followed by a 1-second delay, then a `KC_HOME` tap, and "LO" (spelling "LOVE" if on a newline, but delayed in the middle).
+
 There's also a couple of mod shortcuts you can use:
 
 * `SS_LCTL(string)`
@@ -154,6 +164,8 @@ SEND_STRING(".."SS_TAP(X_END));
 
 There are some functions you may find useful in macro-writing. Keep in mind that while you can write some fairly advanced code within a macro, if your functionality gets too complex you may want to define a custom keycode instead. Macros are meant to be simple.
 
+?> You can also use the functions described in [Useful function](ref_functions.md) for additional functionality. For example `reset_keyboard()` allows you to reset the keyboard as part of a macro.
+
 ### `record->event.pressed`
 
 This is a boolean value that can be tested to see if the switch is being pressed or released. An example of this is
@@ -198,11 +210,11 @@ This will clear all mods currently pressed.
 
 This will clear all keys besides the mods currently pressed.
 
-## Advanced Example: 
+## Advanced Example:
 
 ### Super ALT↯TAB
 
-This macro will register `KC_LALT` and tap `KC_TAB`, then wait for 1000ms. If the key is tapped again, it will send another `KC_TAB`; if there is no tap, `KC_LALT` will be unregistered, thus allowing you to cycle through windows. 
+This macro will register `KC_LALT` and tap `KC_TAB`, then wait for 1000ms. If the key is tapped again, it will send another `KC_TAB`; if there is no tap, `KC_LALT` will be unregistered, thus allowing you to cycle through windows.
 
 ```c
 bool is_alt_tab_active = false;    # ADD this near the begining of keymap.c
@@ -219,7 +231,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
         if (!is_alt_tab_active) {
           is_alt_tab_active = true;
           register_code(KC_LALT);
-        } 
+        }
         alt_tab_timer = timer_read();
         register_code(KC_TAB);
       } else {
@@ -230,7 +242,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   return true;
 }
 
-void matrix_scan_user(void) {     # The very important timer. 
+void matrix_scan_user(void) {     # The very important timer.
   if (is_alt_tab_active) {
     if (timer_elapsed(alt_tab_timer) > 1000) {
       unregister_code(KC_LALT);
@@ -319,7 +331,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 ```
 
 
-## Advanced Example: 
+## Advanced Example:
 
 ### Single-Key Copy/Paste
 

docs/feature_oled_driver.md

@@ -1,139 +1,142 @@
 # OLED Driver
 
-## OLED Supported Hardware
+## Supported Hardware
 
 OLED modules using SSD1306 or SH1106 driver ICs, communicating over I2C.
 Tested combinations:
 
-| IC driver |   Size | Keyboard Platform | Notes                    |
-|-----------|--------|-------------------|--------------------------|
-| SSD1306   | 128x32 | AVR               | Primary support          |
-| SSD1306   | 128x64 | AVR               | Verified working         |
-| SSD1306   | 128x32 | ARM               |                          |
-| SH1106    | 128x64 | AVR               | No rotation or scrolling |
+|IC       |Size  |Platform|Notes                   |
+|---------|------|--------|------------------------|
+|SSD1306  |128x32|AVR     |Primary support         |
+|SSD1306  |128x64|AVR     |Verified working        |
+|SSD1306  |128x32|Arm     |                        |
+|SH1106   |128x64|AVR     |No rotation or scrolling|
 
-Hardware configurations using ARM-based microcontrollers or different sizes of OLED modules may be compatible, but are untested.
+Hardware configurations using Arm-based microcontrollers or different sizes of OLED modules may be compatible, but are untested.
 
-!> Warning: This OLED Driver currently uses the new i2c_master driver from split common code. If your split keyboard uses I2C to communicate between sides, this driver could cause an address conflict (serial is fine). Please contact your keyboard vendor and ask them to migrate to the latest split common code to fix this. In addition, the display timeout system to reduce OLED burn-in also uses split common to detect keypresses, so you will need to implement custom timeout logic for non-split common keyboards.
+!> Warning: This OLED driver currently uses the new i2c_master driver from Split Common code. If your split keyboard uses I2C to communicate between sides, this driver could cause an address conflict (serial is fine). Please contact your keyboard vendor and ask them to migrate to the latest Split Common code to fix this. In addition, the display timeout system to reduce OLED burn-in also uses Split Common to detect keypresses, so you will need to implement custom timeout logic for non-Split Common keyboards.
 
 ## Usage
 
-To enable the OLED feature, there are three steps. First, when compiling your keyboard, you'll need to set `OLED_DRIVER_ENABLE=yes` in `rules.mk`, e.g.:
+To enable the OLED feature, there are three steps. First, when compiling your keyboard, you'll need to add the following to your `rules.mk`:
 
-```
+```make
 OLED_DRIVER_ENABLE = yes
 ```
 
-This enables the feature and the `OLED_DRIVER_ENABLE` define. Then in your `keymap.c` file, you will need to implement the user task call, e.g:
+Then in your `keymap.c` file, implement the OLED task call. This example assumes your keymap has three layers named `_QWERTY`, `_FN` and `_ADJ`:
 
-```C++
+```c
 #ifdef OLED_DRIVER_ENABLE
 void oled_task_user(void) {
-  // Host Keyboard Layer Status
-  oled_write_P(PSTR("Layer: "), false);
-  switch (get_highest_layer(layer_state)) {
-    case _QWERTY:
-      oled_write_P(PSTR("Default\n"), false);
-      break;
-    case _FN:
-      oled_write_P(PSTR("FN\n"), false);
-      break;
-    case _ADJ:
-      oled_write_P(PSTR("ADJ\n"), false);
-      break;
-    default:
-      // Or use the write_ln shortcut over adding '\n' to the end of your string
-      oled_write_ln_P(PSTR("Undefined"), false);
-  }
+    // Host Keyboard Layer Status
+    oled_write_P(PSTR("Layer: "), false);
 
-  // Host Keyboard LED Status
-  uint8_t led_usb_state = host_keyboard_leds();
-  oled_write_P(led_usb_state & (1<<USB_LED_NUM_LOCK) ? PSTR("NUMLCK ") : PSTR("       "), false);
-  oled_write_P(led_usb_state & (1<<USB_LED_CAPS_LOCK) ? PSTR("CAPLCK ") : PSTR("       "), false);
-  oled_write_P(led_usb_state & (1<<USB_LED_SCROLL_LOCK) ? PSTR("SCRLCK ") : PSTR("       "), false);
+    switch (get_highest_layer(layer_state)) {
+        case _QWERTY:
+            oled_write_P(PSTR("Default\n"), false);
+            break;
+        case _FN:
+            oled_write_P(PSTR("FN\n"), false);
+            break;
+        case _ADJ:
+            oled_write_P(PSTR("ADJ\n"), false);
+            break;
+        default:
+            // Or use the write_ln shortcut over adding '\n' to the end of your string
+            oled_write_ln_P(PSTR("Undefined"), false);
+    }
+
+    // Host Keyboard LED Status
+    led_t led_state = host_keyboard_led_state();
+    oled_write_P(led_state.num_lock ? PSTR("NUM ") : PSTR("    "), false);
+    oled_write_P(led_state.caps_lock ? PSTR("CAP ") : PSTR("    "), false);
+    oled_write_P(led_state.scroll_lock ? PSTR("SCR ") : PSTR("    "), false);
 }
 #endif
 ```
 
 ## Logo Example
 
-In the default font, ranges in the font file are reserved for a QMK Logo. To Render this logo to the oled screen, use the following code example:
+In the default font, certain ranges of characters are reserved for a QMK logo. To render this logo to the OLED screen, use the following code example:
 
-```C++
+```c
 static void render_logo(void) {
-  static const char PROGMEM qmk_logo[] = {
-    0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f,0x90,0x91,0x92,0x93,0x94,
-    0xa0,0xa1,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xab,0xac,0xad,0xae,0xaf,0xb0,0xb1,0xb2,0xb3,0xb4,
-    0xc0,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xcb,0xcc,0xcd,0xce,0xcf,0xd0,0xd1,0xd2,0xd3,0xd4,0};
+    static const char PROGMEM qmk_logo[] = {
+        0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94,
+        0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4,
+        0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0x00
+    };
 
-  oled_write_P(qmk_logo, false);
+    oled_write_P(qmk_logo, false);
 }
 ```
 
 ## Other Examples
 
-In split keyboards, it is very common to have two OLED displays that each render different content and oriented flipped differently. You can do this by switching which content to render by using the return from `is_keyboard_master()` or `is_keyboard_left()` found in `split_util.h`, e.g:
+In split keyboards, it is very common to have two OLED displays that each render different content and are oriented or flipped differently. You can do this by switching which content to render by using the return value from `is_keyboard_master()` or `is_keyboard_left()` found in `split_util.h`, e.g:
 
-```C++
+```c
 #ifdef OLED_DRIVER_ENABLE
 oled_rotation_t oled_init_user(oled_rotation_t rotation) {
-  if (!is_keyboard_master())
-    return OLED_ROTATION_180;  // flips the display 180 degrees if offhand
-  return rotation;
+    if (!is_keyboard_master()) {
+        return OLED_ROTATION_180;  // flips the display 180 degrees if offhand
+    }
+
+    return rotation;
 }
 
 void oled_task_user(void) {
-  if (is_keyboard_master()) {
-    render_status();     // Renders the current keyboard state (layer, lock, caps, scroll, etc)
-  } else {
-    render_logo();       // Renders a statuc logo
-    oled_scroll_left();  // Turns on scrolling
-  }
+    if (is_keyboard_master()) {
+        render_status();  // Renders the current keyboard state (layer, lock, caps, scroll, etc)
+    } else {
+        render_logo();  // Renders a static logo
+        oled_scroll_left();  // Turns on scrolling
+    }
 }
 #endif
 ```
 
+## Basic Configuration
 
- ## Basic Configuration
-
-| Define                     | Default           | Description                                                                                                                |
-|----------------------------|-------------------|----------------------------------------------------------------------------------------------------------------------------|
-| `OLED_DISPLAY_ADDRESS`     | `0x3C`            | The i2c address of the OLED Display                                                                                        |
-| `OLED_FONT_H`              | `"glcdfont.c"`    | The font code file to use for custom fonts                                                                                 |
-| `OLED_FONT_START`          | `0`               | The starting characer index for custom fonts                                                                               |
-| `OLED_FONT_END`            | `224`             | The ending characer index for custom fonts                                                                                 |
-| `OLED_FONT_WIDTH`          | `6`               | The font width                                                                                                             |
-| `OLED_FONT_HEIGHT`         | `8`               | The font height (untested)                                                                                                 |
-| `OLED_TIMEOUT`             | `60000`           | Turns off the OLED screen after 60000ms of keyboard inactivity. Helps reduce OLED Burn-in. Set to 0 to disable.            |
-| `OLED_SCROLL_TIMEOUT`      | `0`               | Scrolls the OLED screen after 0ms of OLED inactivity. Helps reduce OLED Burn-in. Set to 0 to disable.                      |
-| `OLED_SCROLL_TIMEOUT_RIGHT`| *Not defined*     | Scroll timeout direction is right when defined, left when undefined.                                                       |
-| `OLED_IC`                  | `OLED_IC_SSD1306` | Set to `OLED_IC_SH1106` if you're using the SH1106 OLED controller.                                                        |
-| `OLED_COLUMN_OFFSET`       | `0`               | (SH1106 only.) Shift output to the right this many pixels.<br />Useful for 128x64 displays centered on a 132x64 SH1106 IC. |
+|Define                     |Default          |Description                                                                                                               |
+|---------------------------|-----------------|--------------------------------------------------------------------------------------------------------------------------|
+|`OLED_DISPLAY_ADDRESS`     |`0x3C`           |The i2c address of the OLED Display                                                                                       |
+|`OLED_FONT_H`              |`"glcdfont.c"`   |The font code file to use for custom fonts                                                                                |
+|`OLED_FONT_START`          |`0`              |The starting characer index for custom fonts                                                                              |
+|`OLED_FONT_END`            |`223`            |The ending characer index for custom fonts                                                                                |
+|`OLED_FONT_WIDTH`          |`6`              |The font width                                                                                                            |
+|`OLED_FONT_HEIGHT`         |`8`              |The font height (untested)                                                                                                |
+|`OLED_TIMEOUT`             |`60000`          |Turns off the OLED screen after 60000ms of keyboard inactivity. Helps reduce OLED Burn-in. Set to 0 to disable.           |
+|`OLED_SCROLL_TIMEOUT`      |`0`              |Scrolls the OLED screen after 0ms of OLED inactivity. Helps reduce OLED Burn-in. Set to 0 to disable.                     |
+|`OLED_SCROLL_TIMEOUT_RIGHT`|*Not defined*    |Scroll timeout direction is right when defined, left when undefined.                                                      |
+|`OLED_IC`                  |`OLED_IC_SSD1306`|Set to `OLED_IC_SH1106` if you're using the SH1106 OLED controller.                                                       |
+|`OLED_COLUMN_OFFSET`       |`0`              |(SH1106 only.) Shift output to the right this many pixels.<br />Useful for 128x64 displays centered on a 132x64 SH1106 IC.|
 
  ## 128x64 & Custom sized OLED Displays
 
  The default display size for this feature is 128x32 and all necessary defines are precalculated with that in mind. We have added a define, `OLED_DISPLAY_128X64`, to switch all the values to be used in a 128x64 display, as well as added a custom define, `OLED_DISPLAY_CUSTOM`, that allows you to provide the necessary values to the driver.
 
-|Define                 |Default        |Description                                                      |
-|-----------------------|---------------|-----------------------------------------------------------------|
-|`OLED_DISPLAY_128X64`  |*Not defined*  |Changes the display defines for use with 128x64 displays.        |
-|`OLED_DISPLAY_CUSTOM`  |*Not defined*  |Changes the display defines for use with custom displays.<br />Requires user to implement the below defines. |
-|`OLED_DISPLAY_WIDTH`   |`128`          |The width of the OLED display.                                   |
-|`OLED_DISPLAY_HEIGHT`  |`32`           |The height of the OLED display.                                  |
-|`OLED_MATRIX_SIZE`     |`512`          |The local buffer size to allocate.<br />`(OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH)`. |
-|`OLED_BLOCK_TYPE`      |`uint16_t`     |The unsigned integer type to use for dirty rendering. |
-|`OLED_BLOCK_COUNT`     |`16`           |The number of blocks the display is divided into for dirty rendering.<br />`(sizeof(OLED_BLOCK_TYPE) * 8)`. |
-|`OLED_BLOCK_SIZE`      |`32`           |The size of each block for dirty rendering<br />`(OLED_MATRIX_SIZE / OLED_BLOCK_COUNT)`. |
-|`OLED_COM_PINS`        |`COM_PINS_SEQ` |How the SSD1306 chip maps it's memory to display.<br />Options are `COM_PINS_SEQ`, `COM_PINS_ALT`, `COM_PINS_SEQ_LR`, & `COM_PINS_ALT_LR`. |
-|`OLED_SOURCE_MAP`      |`{ 0, ... N }` |Precalculated source array to use for mapping source buffer to target OLED memory in 90 degree rendering.         |
-|`OLED_TARGET_MAP`      |`{ 24, ... N }`|Precalculated target array to use for mapping source buffer to target OLED memory in 90 degree rendering.         |
+|Define               |Default        |Description                                                                                                                             |
+|---------------------|---------------|----------------------------------------------------------------------------------------------------------------------------------------|
+|`OLED_DISPLAY_128X64`|*Not defined*  |Changes the display defines for use with 128x64 displays.                                                                               |
+|`OLED_DISPLAY_CUSTOM`|*Not defined*  |Changes the display defines for use with custom displays.<br>Requires user to implement the below defines.                              |
+|`OLED_DISPLAY_WIDTH` |`128`          |The width of the OLED display.                                                                                                          |
+|`OLED_DISPLAY_HEIGHT`|`32`           |The height of the OLED display.                                                                                                         |
+|`OLED_MATRIX_SIZE`   |`512`          |The local buffer size to allocate.<br>`(OLED_DISPLAY_HEIGHT / 8 * OLED_DISPLAY_WIDTH)`.                                                 |
+|`OLED_BLOCK_TYPE`    |`uint16_t`     |The unsigned integer type to use for dirty rendering.                                                                                   |
+|`OLED_BLOCK_COUNT`   |`16`           |The number of blocks the display is divided into for dirty rendering.<br>`(sizeof(OLED_BLOCK_TYPE) * 8)`.                               |
+|`OLED_BLOCK_SIZE`    |`32`           |The size of each block for dirty rendering<br>`(OLED_MATRIX_SIZE / OLED_BLOCK_COUNT)`.                                                  |
+|`OLED_COM_PINS`      |`COM_PINS_SEQ` |How the SSD1306 chip maps it's memory to display.<br>Options are `COM_PINS_SEQ`, `COM_PINS_ALT`, `COM_PINS_SEQ_LR`, & `COM_PINS_ALT_LR`.|
+|`OLED_SOURCE_MAP`    |`{ 0, ... N }` |Precalculated source array to use for mapping source buffer to target OLED memory in 90 degree rendering.                               |
+|`OLED_TARGET_MAP`    |`{ 24, ... N }`|Precalculated target array to use for mapping source buffer to target OLED memory in 90 degree rendering.                               |
 
 
-### 90 Degree Rotation - Technical Mumbo Jumbo 
+### 90 Degree Rotation - Technical Mumbo Jumbo
 
 !> Rotation is unsupported on the SH1106.
 
-```C
+```c
 // OLED Rotation enum values are flags
 typedef enum {
     OLED_ROTATION_0   = 0,
@@ -143,9 +146,9 @@ typedef enum {
 } oled_rotation_t;
 ```
 
- OLED displays driven by SSD1306 drivers only natively support in hard ware 0 degree and 180 degree rendering. This feature is done in software and not free. Using this feature will increase the time to calculate what data to send over i2c to the OLED. If you are strapped for cycles, this can cause keycodes to not register. In testing however, the rendering time on an `atmega32u4` board only went from 2ms to 5ms and keycodes not registering was only noticed once we hit 15ms. 
- 
- 90 Degree Rotated Rendering is achieved by using bitwise operations to rotate each 8 block of memory and uses two precalculated arrays to remap buffer memory to OLED memory. The memory map defines are precalculated for remap performance and are calculated based on the OLED Height, Width, and Block Size. For example, in the 128x32 implementation with a `uint8_t` block type, we have a 64 byte block size. This gives us eight 8 byte blocks that need to be rotated and rendered. The OLED renders horizontally two 8 byte blocks before moving down a page, e.g:
+OLED displays driven by SSD1306 drivers only natively support in hardware 0 degree and 180 degree rendering. This feature is done in software and not free. Using this feature will increase the time to calculate what data to send over i2c to the OLED. If you are strapped for cycles, this can cause keycodes to not register. In testing however, the rendering time on an ATmega32U4 board only went from 2ms to 5ms and keycodes not registering was only noticed once we hit 15ms.
+
+90 degree rotation is achieved by using bitwise operations to rotate each 8 block of memory and uses two precalculated arrays to remap buffer memory to OLED memory. The memory map defines are precalculated for remap performance and are calculated based on the display height, width, and block size. For example, in the 128x32 implementation with a `uint8_t` block type, we have a 64 byte block size. This gives us eight 8 byte blocks that need to be rotated and rendered. The OLED renders horizontally two 8 byte blocks before moving down a page, e.g:
 
 |   |   |   |   |   |   |
 |---|---|---|---|---|---|
@@ -167,8 +170,8 @@ So those precalculated arrays just index the memory offsets in the order in whic
 
 ## OLED API
 
-```C++
-// OLED Rotation enum values are flags
+```c
+// OLED rotation enum values are flags
 typedef enum {
     OLED_ROTATION_0   = 0,
     OLED_ROTATION_90  = 1,
@@ -218,6 +221,12 @@ void oled_write(const char *data, bool invert);
 // Advances the cursor to the next page, wiring ' ' to the remainder of the current page
 void oled_write_ln(const char *data, bool invert);
 
+// Pans the buffer to the right (or left by passing true) by moving contents of the buffer
+// Useful for moving the screen in preparation for new drawing 
+// oled_scroll_left or oled_scroll_right should be preferred for all cases of moving a static
+// image such as a logo or to avoid burn-in as it's much, much less cpu intensive
+void oled_pan(bool left);
+
 // Writes a PROGMEM string to the buffer at current cursor position
 // Advances the cursor while writing, inverts the pixels if true
 // Remapped to call 'void oled_write(const char *data, bool invert);' on ARM
@@ -232,6 +241,9 @@ 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 single byte into the buffer at the specified index
+void oled_write_raw_byte(const char data, uint16_t index);
+
 // Writes a PROGMEM string to the buffer at current cursor position
 void oled_write_raw_P(const char *data, uint16_t size);
 
@@ -272,26 +284,26 @@ uint8_t oled_max_lines(void);
 
 !> Scrolling and rotation are unsupported on the SH1106.
 
-## SSD1306.h driver conversion guide
+## SSD1306.h Driver Conversion Guide
 
-|Old API                    |Recommended New API                |
-|---------------------------|-----------------------------------|
-|`struct CharacterMatrix`   |*removed - delete all references*  |
-|`iota_gfx_init`            |`oled_init`                        |
-|`iota_gfx_on`              |`oled_on`                          |
-|`iota_gfx_off`             |`oled_off`                         |
-|`iota_gfx_flush`           |`oled_render`                      |
-|`iota_gfx_write_char`      |`oled_write_char`                  |
-|`iota_gfx_write`           |`oled_write`                       |
-|`iota_gfx_write_P`         |`oled_write_P`                     |
-|`iota_gfx_clear_screen`    |`oled_clear`                       |
-|`matrix_clear`             |*removed - delete all references*  |
-|`matrix_write_char_inner`  |`oled_write_char`                  |
-|`matrix_write_char`        |`oled_write_char`                  |
-|`matrix_write`             |`oled_write`                       |
-|`matrix_write_ln`          |`oled_write_ln`                    |
-|`matrix_write_P`           |`oled_write_P`                     |
-|`matrix_write_ln_P`        |`oled_write_ln_P`                  |
-|`matrix_render`            |`oled_render`                      |
-|`iota_gfx_task`            |`oled_task`                        |
-|`iota_gfx_task_user`       |`oled_task_user`                   |
+|Old API                  |Recommended New API              |
+|-------------------------|---------------------------------|
+|`struct CharacterMatrix` |*removed - delete all references*|
+|`iota_gfx_init`          |`oled_init`                      |
+|`iota_gfx_on`            |`oled_on`                        |
+|`iota_gfx_off`           |`oled_off`                       |
+|`iota_gfx_flush`         |`oled_render`                    |
+|`iota_gfx_write_char`    |`oled_write_char`                |
+|`iota_gfx_write`         |`oled_write`                     |
+|`iota_gfx_write_P`       |`oled_write_P`                   |
+|`iota_gfx_clear_screen`  |`oled_clear`                     |
+|`matrix_clear`           |*removed - delete all references*|
+|`matrix_write_char_inner`|`oled_write_char`                |
+|`matrix_write_char`      |`oled_write_char`                |
+|`matrix_write`           |`oled_write`                     |
+|`matrix_write_ln`        |`oled_write_ln`                  |
+|`matrix_write_P`         |`oled_write_P`                   |
+|`matrix_write_ln_P`      |`oled_write_ln_P`                |
+|`matrix_render`          |`oled_render`                    |
+|`iota_gfx_task`          |`oled_task`                      |
+|`iota_gfx_task_user`     |`oled_task_user`                 |

docs/feature_rgb_matrix.md

@@ -199,6 +199,7 @@ enum rgb_matrix_effects {
     RGB_MATRIX_SOLID_COLOR = 1,     // Static single hue, no speed support
     RGB_MATRIX_ALPHAS_MODS,         // Static dual hue, speed is hue for secondary hue
     RGB_MATRIX_GRADIENT_UP_DOWN,    // Static gradient top to bottom, speed controls how much gradient changes
+    RGB_MATRIX_GRADIENT_LEFT_RIGHT,    // Static gradient left to right, speed controls how much gradient changes
     RGB_MATRIX_BREATHING,           // Single hue brightness cycling animation
     RGB_MATRIX_BAND_SAT,        // Single hue band fading saturation scrolling left to right
     RGB_MATRIX_BAND_VAL,        // Single hue band fading brightness scrolling left to right
@@ -379,6 +380,10 @@ These are defined in [`rgblight_list.h`](https://github.com/qmk/qmk_firmware/blo
 #define RGB_MATRIX_LED_FLUSH_LIMIT 16 // limits in milliseconds how frequently an animation will update the LEDs. 16 (16ms) is equivalent to limiting to 60fps (increases keyboard responsiveness)
 #define RGB_MATRIX_MAXIMUM_BRIGHTNESS 200 // limits maximum brightness of LEDs to 200 out of 255. If not defined maximum brightness is set to 255
 #define RGB_MATRIX_STARTUP_MODE RGB_MATRIX_CYCLE_LEFT_RIGHT // Sets the default mode, if none has been set
+#define RGB_MATRIX_STARTUP_HUE 0 // Sets the default hue value, if none has been set
+#define RGB_MATRIX_STARTUP_SAT 255 // Sets the default saturation value, if none has been set
+#define RGB_MATRIX_STARTUP_VAL RGB_MATRIX_MAXIMUM_BRIGHTNESS // Sets the default brightness value, if none has been set
+#define RGB_MATRIX_STARTUP_SPD 127 // Sets the default animation speed, if none has been set
 ```
 
 ## EEPROM storage

docs/feature_split_keyboard.md

@@ -198,10 +198,15 @@ This option changes the startup behavior to detect an active USB connection when
 ?> This setting will stop the ability to demo using battery packs.
 
 ```c
-#define SPLIT_USB_TIMEOUT 2500
+#define SPLIT_USB_TIMEOUT 2000
 ```
 This sets the maximum timeout when detecting master/slave when using `SPLIT_USB_DETECT`.
 
+```c
+#define SPLIT_USB_TIMEOUT_POLL 10
+```
+This sets the poll frequency when detecting master/slave when using `SPLIT_USB_DETECT`
+
 ## Additional Resources
 
 Nicinabox has a [very nice and detailed guide](https://github.com/nicinabox/lets-split-guide) for the Let's Split keyboard, that covers most everything you need to know, including troubleshooting information. 

docs/feature_tap_dance.md

@@ -335,7 +335,7 @@ If you want to implement this in your userspace, then you may want to check out
 
 > 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
+### Example 5: Using tap dance for advanced mod-tap and layer-tap keys :id=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_unicode.md

@@ -193,12 +193,23 @@ By default, when the keyboard boots, it will initialize the input mode to the la
 
 !> Using `UNICODE_SELECTED_MODES` means you don't have to initially set the input mode in `matrix_init_user()` (or a similar function); the Unicode system will do that for you on startup. This has the added benefit of avoiding unnecessary writes to EEPROM.
 
-## `send_unicode_hex_string`
+## `send_unicode_string()`
 
-To type multiple characters for things like (ノಠ痊ಠ)ノ彡┻━┻, you can use `send_unicode_hex_string()` much like `SEND_STRING()` except you would use hex values separate by spaces.
-For example, the table flip seen above would be `send_unicode_hex_string("0028 30CE 0CA0 75CA 0CA0 0029 30CE 5F61 253B 2501 253B")`
+This function is much like `send_string()` but allows you to input UTF-8 characters directly, and supports all code points (provided the selected input method also supports it). Make sure your `keymap.c` is formatted in UTF-8 encoding.
 
-There are many ways to get a hex code, but an easy one is [this site](https://r12a.github.io/app-conversion/). Just make sure to convert to hexadecimal, and that is your string.
+```c
+send_unicode_string("(ノಠ痊ಠ)ノ彡┻━┻");
+```
+
+## `send_unicode_hex_string()`
+
+Similar to `send_unicode_string()`, but the characters are represented by their code point values in ASCII, separated by spaces. For example, the table flip above would be achieved with:
+
+```c
+send_unicode_hex_string("0028 30CE 0CA0 75CA 0CA0 0029 30CE 5F61 253B 2501 253B");
+```
+
+An easy way to convert your Unicode string to this format is by using [this site](https://r12a.github.io/app-conversion/), and taking the result in the "Hex/UTF-32" section.
 
 ## Additional Language Support
 
@@ -228,6 +239,6 @@ AutoHotkey inserts the Text right of `Send, ` when this combination is pressed.
 
 If you enable the US International layout on the system, it will use punctuation to accent the characters.
 
-For instance, typing "`a" will result in à.
+For instance, typing "\`a" will result in à.
 
 You can find details on how to enable this [here](https://support.microsoft.com/en-us/help/17424/windows-change-keyboard-layout).

docs/features.md

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

docs/flashing.md

@@ -1,8 +1,8 @@
 # Flashing Instructions and Bootloader Information
 
-There are quite a few different types of bootloaders that keyboards use, and just about all of the use a different flashing method. Luckily, projects like the [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) aim to be compatible with all the different types without having to think about it much, but this article will describe the different types of bootloaders, and available methods for flashing them.
+There are quite a few different types of bootloaders that keyboards use, and just about all of them use a different flashing method. Luckily, projects like the [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) aim to be compatible with all the different types without having to think about it much, but this article will describe the different types of bootloaders, and available methods for flashing them.
 
-If you have a bootloader selected with the `BOOTLOADER` variable in your `rules.mk`, QMK will automatically calculate if your .hex file is the right size to be flashed to the device, and output the total size in bytes (along with the max). To run this process manually, compile with the target `check-size`, eg `make planck/rev4:default:check-size`.
+If you have a bootloader selected with the `BOOTLOADER` variable in your `rules.mk`, QMK will automatically calculate if your .hex file is the right size to be flashed to the device, and output the total size in bytes (along with the max).
 
 ## DFU
 
@@ -100,7 +100,7 @@ or
     make <keyboard>:<keymap>:avrdude
 
 
-#### Caterina commands
+### Caterina commands
 
 There are a number of DFU commands that you can use to flash firmware to a DFU device:
 
@@ -113,7 +113,7 @@ There are a number of DFU commands that you can use to flash firmware to a DFU d
 
 ## Halfkay
 
-Halfkay is a super-slim protocol developed by PJRC that uses HID, and come on all Teensys (namely the 2.0).
+Halfkay is a super-slim protocol developed by PJRC that uses HID, and comes on all Teensys (namely the 2.0).
 
 To ensure compatibility with the Halfkay bootloader, make sure this block is present your `rules.mk`:
 

docs/fr-fr/_summary.md

@@ -81,7 +81,7 @@
   * [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)
+  * [Touche one-shot](fr-fr/one_shot_keys.md)
   * [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)
@@ -112,7 +112,7 @@
 * 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)
+  * [Support](fr-fr/getting_started_getting_help.md)
   * [Comment ajouter des traductions](fr-fr/translating.md)
 
 * À l’intérieur de QMK (En cours de documentation)

docs/fr-fr/faq_build.md

@@ -86,10 +86,6 @@ Relancer le script d'installation de QMK (`./util/qmk_install.sh` situé dans r
 
 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.
 
-## WINAVR est obsolète
-
-Il n'est plus recommandé et peut causer des problèmes. Voir [TMK Issue #99](https://github.com/tmk/tmk_keyboard/issues/99).
-
 ## 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.
@@ -103,30 +99,6 @@ Vous pouvez acheter un VID:PID unique ici. Je ne pense pas que ce soit nécessai
 - 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`
-
-Ce problème existait avec le GCC 4.8 d'Ubuntu 14.04, la solution a nécessité de mettre à jour vers 4.9 avec ce 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
-
-Votre chaîne d'outils (Toolchain) est trop vieille pour supporter le MCU. Par exemple, WinAVR 20100110 ne supporte pas 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 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.

docs/fr-fr/faq_debug.md

@@ -104,58 +104,6 @@ En C, `1` implique un type [int] qui est [16 bits] pour les AVR, ce qui implique
 
 http://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
 
-## Bootloader Jump ne fonctionne pas
-
-Configurez correctement la taille du bootloader dans le **Makefile**. Une mauvaise taille de section du bootloader empêchera probablement le démarrage avec **Magic command** et **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
-```
-
-La taille de la section de démarrage de AVR est définie par l'option **BOOTSZ** fuse. Vérifiez la fiche technique du MCU. Veuilez noter que les tailles et adresses sont définies en **Word** (2 octets) dans la fiche technique alors que TMK utilise des **Byte**.
-
-La section de boot AVR se trouve à la fin de la mémoire flash, comme suit.
-
-```
-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  +---------------+
-```
-
-Référez-vous à cette discussion pour plus de référence.
-https://github.com/tmk/tmk_keyboard/issues/179
-
-Si vous utilisez un TeensyUSB, il y a un [bug connu](https://github.com/qmk/qmk_firmware/issues/164) qui fait que le bouton reset matériel empêche la touche RESET de fonctionner. Débrancher et rebrancher le clavier devrait résoudre le problème.
-
 ## 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.
@@ -189,25 +137,6 @@ Si vous voulez garder JTAG activé, ajoutez la ligne suivante à votre fichier `
 #define NO_JTAG_DISABLE
 ```
 
-## Adding LED Indicators of Lock Keys
-
-Si vous souhaitez votre propre indicateur LED pour CapsLock, ScrollLock et NumLock alors lisez ce post.
-
-http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-120.html#p191560
-
-## Programmer Arduino Micro/Leonardo
-
-Appuyez sur le bouton reset puis lancez la commande suivante dans les 8 secondes.
-
-```
-avrdude -patmega32u4 -cavr109 -b57600 -Uflash:w:adb_usb.hex -P/dev/ttyACM0
-```
-
-Le nom du périphérique peut varier en fonction de votre système.
-
-http://arduino.cc/en/Main/ArduinoBoardMicro
-https://geekhack.org/index.php?topic=14290.msg1563867#msg1563867
-
 ## Compatibilité USB 3
 
 Il semble que certaines personnes ont eu des problèmes avec les ports USB 3, essayez un port USB 2.

docs/fr-fr/faq_keymap.md

@@ -72,24 +72,7 @@ Des vieux claviers mécaniques ont parfois des touches à verrouillage, mais les
 
 ## Ajouter des caractères spéciaux autres que ASCII comme la cédille 'Ç'
 
-IL N'EXISTE AUCUNE METHODE UNIVERSELLE POUR LES AJOUTER QUI FONCTIONNE SUR TOUS LES SYSTEMES. Vous devez définir une **MACRO** d'une manière spécifique à votre OS ou layout.
-
-Voir ce post pour un exemple de code **MACRO**.
-
-http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-120.html#p195620
-
-Sous **Windows** vous pouvez utiliser la touche `AltGr` ou **Alt code**.
-* http://en.wikipedia.org/wiki/AltGr_key
-* http://en.wikipedia.org/wiki/Alt_code
-
-Sous **Mac OS** définissez une combinaison de touche `Option`.
-* http://en.wikipedia.org/wiki/Option_key#Alternative_keyboard_input
-
-Sous **Xorg** vous pouvez utiliser une touche `compose` à la place.
-* http://en.wikipedia.org/wiki/Compose_key
-
-Et voir ceci pour une entrée **Unicode**.
-* http://en.wikipedia.org/wiki/Unicode_input
+Voir la fonctionnalité [Unicode](feature_unicode.md).
 
 ## Touche `Fn` sur macOS
 
@@ -144,54 +127,6 @@ Cette fonctionnalité permet d'utiliser une touche à la fois comme touche Écha
 
 Voir la fonctionnalité [Grave Escape](feature_grave_esc.md).
 
-## Avoir les touches modificatrices qui ont double usage en flèches directionnelles.
-
-Ceci transforme les touches "modificateur droit" en touches fléchées lorsque les touches sont seulement "tapées" tout en restant des modificateurs lorsqu'elles sont maintenues.
-
-Dans TMK la fonction double rôle s'appelle **TAP**.
-
-```C
-
-#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),
-};
-
-```
-
-Touches double rôle : https://en.wikipedia.org/wiki/Modifier_key#Dual-role_keys
-
 ## Eject sur Mac OSX
 
 Le keycode`KC_EJCT` fonctionne sous OSX. https://github.com/tmk/tmk_keyboard/issues/250

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/fr-fr/newbs_building_firmware_configurator.md

@@ -4,7 +4,7 @@ Le [Configurateur de QMK](https://config.qmk.fm) est une interface graphique en
 
 ?> **S'il vous plaît, suivez les étapes suivantes dans l'ordre.**
 
-Regardez le [Tutoriel vidéo](https://youtu.be/tx54jkRC9ZY)
+Regardez le [Tutoriel vidéo](https://youtu.be/tx54jkRC9ZY)https://www.youtube.com/watch?v=-imgglzDMdY)
 
 Le configurateur de QMK fonctionne mieux avec Chrome et Firefox.
 

docs/getting_started_build_tools.md

@@ -1,140 +0,0 @@
-# Installing Build Tools
-
-This page describes setting up the build environment for QMK. These instructions cover AVR processors (such as the atmega32u4).
-
-<!-- FIXME: We should have ARM instructions somewhere. -->
-
-**Note:** If this is your first time here, check out the [Complete Newbs Guide](newbs.md) page.
-
-Before continuing, double check that your submodules (third-party libraries) are up to date by running `make git-submodule`.
-
-## Linux
-
-To ensure you are always up to date, you can just run `sudo util/qmk_install.sh`. That should always install all the dependencies needed. **This will run `apt-get upgrade`.**
-
-You can also install things manually, but this documentation might not be always up to date with all requirements.
-
-The current requirements are the following, but not all might be needed depending on what you do. Also note that some systems might not have all the dependencies available as packages, or they might be named differently.
-
-```
-build-essential
-gcc
-unzip
-wget
-zip
-gcc-avr
-binutils-avr
-avr-libc
-dfu-programmer
-dfu-util
-gcc-arm-none-eabi
-binutils-arm-none-eabi
-libnewlib-arm-none-eabi
-git
-```
-
-Install the dependencies with your favorite package manager.
-
-Debian / Ubuntu example:
-
-    sudo apt-get update
-    sudo apt-get install gcc unzip wget zip gcc-avr binutils-avr avr-libc dfu-programmer dfu-util gcc-arm-none-eabi binutils-arm-none-eabi libnewlib-arm-none-eabi
-
-Fedora / Red Hat example:
-
-    sudo dnf install gcc unzip wget zip dfu-util dfu-programmer avr-gcc avr-libc binutils-avr32-linux-gnu arm-none-eabi-gcc-cs arm-none-eabi-binutils-cs arm-none-eabi-newlib
-    
-Arch / Manjaro example:
-
-    pacman -S base-devel gcc unzip wget zip avr-gcc avr-binutils avr-libc dfu-util arm-none-eabi-gcc arm-none-eabi-binutils arm-none-eabi-newlib git dfu-programmer dfu-util
-
-## Nix
-
-If you're on [NixOS](https://nixos.org/), or have Nix installed on Linux or macOS, run `nix-shell` from the repository root to get a build environment.
-
-By default, this will download compilers for both AVR and ARM. If you don't need both, disable the `avr` or `arm` arguments, e.g.:
-
-    nix-shell --arg arm false
-
-## macOS
-If you're using [homebrew,](http://brew.sh/) you can use the following commands:
-
-    brew tap osx-cross/avr
-    brew tap PX4/homebrew-px4
-    brew update
-    brew install avr-gcc@8
-    brew link --force avr-gcc@8
-    brew install dfu-programmer
-    brew install dfu-util
-    brew install gcc-arm-none-eabi
-    brew install avrdude
-
-This is the recommended method. If you don't have homebrew, [install it!](http://brew.sh/) It's very much worth it for anyone who works in the command line. Note that the `make` and `make install` portion during the homebrew installation of `avr-gcc@8` can take over 20 minutes and exhibit high CPU usage.
-
-## Windows with msys2 (recommended)
-
-The best environment to use, for Windows Vista through any later version (tested on 7 and 10), is [msys2](http://www.msys2.org).
-
-* Install msys2 by downloading it and following the instructions here: http://www.msys2.org
-* Open the ``MSYS2 MingGW 64-bit`` shortcut
-* Navigate to your QMK repository. For example, if it's in the root of your c drive:
- * `$ cd /c/qmk_firmware`
-* Run `util/qmk_install.sh` and follow the prompts
-
-## Windows 10 (deprecated)
-These are the old instructions for Windows 10. We recommend you use [MSYS2 as outlined above](#windows-with-msys2-recommended).
-
-### Creators Update
-If you have Windows 10 with Creators Update or later, you can build and flash the firmware directly. Before the Creators Update, only building was possible. If you don't have it yet or if are unsure, follow [these instructions](https://support.microsoft.com/en-us/instantanswers/d4efb316-79f0-1aa1-9ef3-dcada78f3fa0/get-the-windows-10-creators-update).
-
-### Windows Subsystem for Linux
-In addition to the Creators Update, you need Windows 10 Subystem for Linux, so install it following [these instructions](http://www.howtogeek.com/249966/how-to-install-and-use-the-linux-bash-shell-on-windows-10/). If you already have the Windows 10 Subsystem for Linux from the Anniversary update it's recommended that you [upgrade](https://betanews.com/2017/04/14/upgrade-windows-subsystem-for-linux/) it to 16.04LTS, because some keyboards don't compile with the toolchains included in 14.04LTS. Note that you need to know what your are doing if you chose the `sudo do-release-upgrade` method.
-
-### Git
-If you already have cloned the repository on your Windows file system you can ignore this section.
-
-You will need to clone the repository to your Windows file system using the normal Git for Windows and **not** the WSL Git. So if you haven't installed Git before, [download](https://git-scm.com/download/win) and install it. Then [set it up](https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup), it's important that you setup the e-mail and user name, especially if you are planning to contribute.
-
-Once Git is installed, open the Git Bash command and change the directory to where you want to clone QMK; note that you have to use forward slashes, and that your c drive is accessed like this `/c/path/to/where/you/want/to/go`. Then run `git clone --recurse-submodules https://github.com/qmk/qmk_firmware`, this will create a new folder `qmk_firmware` as a subfolder of the current one.
-
-### Toolchain Setup
-The Toolchain setup is done through the Windows Subsystem for Linux, and the process is fully automated. If you want to do everything manually, there are no other instructions than the scripts themselves, but you can always open issues and ask for more information.
-
-1. Open "Bash On Ubuntu On Windows" from the start menu.
-2. Go to the directory where you cloned `qmk_firmware`. Note that the paths start with `/mnt/` in the WSL, so you have to write for example `cd /mnt/c/path/to/qmk_firmware`.
-3. Run `util/wsl_install.sh` and follow the on-screen instructions.
-4. Close the Bash command window, and re-open it.
-5. You are ready to compile and flash the firmware!
-
-### Some Important Things to Keep in Mind
-* You can run `util/wsl_install.sh` again to get all the newest updates.
-* Your QMK repository need to be on a Windows file system path, since WSL can't run executables outside it.
-* The WSL Git is **not** compatible with the Windows Git, so use the Windows Git Bash or a windows Git GUI for all Git operations
-* You can edit files either inside WSL or normally using Windows, but note that if you edit makefiles or shell scripts, make sure you are using an editor that saves the files with Unix line endings. Otherwise the compilation might not work.
-
-## Docker
-
-If this is a bit complex for you, Docker might be the turnkey solution you need. After installing [Docker CE](https://docs.docker.com/install/#supported-platforms), run the following command from the `qmk_firmware` directory to build a keyboard/keymap:
-```bash
-util/docker_build.sh keyboard:keymap
-# For example: util/docker_build.sh ergodox_ez:steno
-```
-This will compile the desired keyboard/keymap and leave the resulting `.hex` or `.bin` file in the QMK directory for you to flash. If `:keymap` is omitted, the `default` keymap is used. Note that the parameter format is the same as when building with `make`.
-
-You can also start the script without any parameters, in which case it will ask you to input the build parameters one by one, which you may find easier to use:
-```bash
-util/docker_build.sh
-# Reads parameters as input (leave blank for defaults)
-```
-
-There is also support for building _and_ flashing the keyboard straight from Docker by specifying the `target` as well:
-```bash
-util/docker_build.sh keyboard:keymap:target
-# For example: util/docker_build.sh planck/rev6:default:flash
-```
-If you're on Linux, this should work out of the box. On Windows and macOS, it requires [Docker Machine](http://gw.tnode.com/docker/docker-machine-with-usb-support-on-windows-macos/) to be running. This is tedious to set up, so it's not recommended; use [QMK Toolbox](https://github.com/qmk/qmk_toolbox) instead.
-
-!> Docker for Windows requires [Hyper-V](https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/quick-start/enable-hyper-v) to be enabled. This means that it cannot work on versions of Windows which don't have Hyper-V, such as Windows 7, Windows 8 and **Windows 10 Home**.
-
-## Vagrant
-If you have any problems building the firmware, you can try using a tool called Vagrant. It will set up a virtual computer with a known configuration that's ready-to-go for firmware building. OLKB does NOT host the files for this virtual computer. Details on how to set up Vagrant are in the [vagrant guide](getting_started_vagrant.md).

docs/getting_started_getting_help.md

@@ -1,15 +0,0 @@
-# Getting Help
-
-There are a lot of resources for getting help with QMK.
-
-## Realtime Chat
-
-You can find QMK developers and users on our main [Discord server](https://discord.gg/Uq7gcHh). There are specific channels in the server for chatting about the firmware, Toolbox, hardware, and configurator.
-
-## OLKB Subreddit
-
-The official QMK forum is [/r/olkb](https://reddit.com/r/olkb) on [reddit.com](https://reddit.com).
-
-## Github Issues
-
-You can open an [issue on GitHub](https://github.com/qmk/qmk_firmware/issues). This is especially handy when your issue will require long-term discussion or debugging.

docs/getting_started_github.md

@@ -1,59 +0,0 @@
-# How to Use Github with QMK
-
-Github can be a little tricky to those that aren't familiar with it - this guide will walk through each step of forking, cloning, and submitting a pull request with QMK.
-
-?> This guide assumes you're somewhat comfortable with running things at the command line, and have git installed on your system.
-
-Start on the [QMK Github page](https://github.com/qmk/qmk_firmware), and you'll see a button in the upper right that says "Fork":
-
-![Fork on Github](http://i.imgur.com/8Toomz4.jpg)
-
-If you're a part of an organization, you'll need to choose which account to fork it to. In most circumstances, you'll want to fork it to your personal account. Once your fork is completed (sometimes this takes a little while), click the "Clone or Download" button:
-
-![Download from Github](http://i.imgur.com/N1NYcSz.jpg)
-
-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:
-
-```
-user@computer:~$ git clone 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.
-```
-
-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:
-
-```
-user@computer:~$ git add .
-user@computer:~$ git commit -m "adding my keymap"
-[master cccb1608] adding my keymap
- 1 file changed, 1 insertion(+)
- create mode 100644 keyboards/planck/keymaps/mine/keymap.c
-user@computer:~$ git push
-Counting objects: 1, done.
-Delta compression using up to 4 threads.
-Compressing objects: 100% (1/1), done.
-Writing objects: 100% (1/1), 1.64 KiB | 0 bytes/s, done.
-Total 1 (delta 1), reused 0 (delta 0)
-remote: Resolving deltas: 100% (1/1), completed with 1 local objects.
-To https://github.com/whoeveryouare/qmk_firmware.git
- + 20043e64...7da94ac5 master -> master
-```
-
-Your changes now exist on your fork on Github - if you go back there (`https://github.com/<whoeveryouare>/qmk_firmware`), you can create a "New Pull Request" by clicking this button:
-
-![New Pull Request](http://i.imgur.com/DxMHpJ8.jpg)
-
-Here you'll be able to see exactly what you've committed - if it all looks good, you can finalize it by clicking "Create Pull Request":
-
-![Create Pull Request](http://i.imgur.com/Ojydlaj.jpg)
-
-After submitting, we may talk to you about your changes, ask that you make changes, and eventually accept it! Thanks for contributing to QMK :)

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

@@ -135,7 +135,7 @@ As there is no standard split communication driver for ARM-based split keyboards
 
 `CUSTOM_MATRIX`
 
-Lets you replace the default matrix scanning routine with your own code. You will need to provide your own implementations of matrix_init() and matrix_scan().
+Lets you replace the default matrix scanning routine with your own code. For further details, see the [Custom Matrix page](custom_matrix.md).
 
 `DEBOUNCE_TYPE`
 

docs/hand_wire.md

@@ -1,114 +1,5 @@
 # Hand-Wiring Guide
 
-## Preamble: How a Keyboard Matrix Works (and why we need diodes)
-
-The collapsible section below covers why keyboards are wired the way they are, as outlined in this guide.  It isn't required reading to make your own hand wired keyboard, but provides background information.
-
-<details>
-
-<summary>Click for details</summary>
-
-Without a matrix circuit each switch would require its own wire directly to the controller.
-
-Simply put, when the circuit is arranged in rows and columns, if a key is pressed, a column wire makes contact with a row wire and completes a circuit. The keyboard controller detects this closed circuit and registers it as a key press.
-
-The microcontroller will be setup up via the firmware to send a logical 1 to the columns, one at a time, and read from the rows, all at once - this process is called matrix scanning. The matrix is a bunch of open switches that, by default, don't allow any current to pass through - the firmware will read this as no keys being pressed. As soon as you press one key down, the logical 1 that was coming from the column the keyswitch is attached to gets passed through the switch and to the corresponding row - check out the following 2x2 example:
-
-        Column 0 being scanned     Column 1 being scanned
-                  x                                   x
-                 col0     col1              col0     col1
-                  |        |                 |        |
-        row0 ---(key0)---(key1)    row0 ---(key0)---(key1)
-                  |        |                 |        |
-        row1 ---(key2)---(key3)    row1 ---(key2)---(key3)
-
-The `x` represents that the column/row associated has a value of 1, or is HIGH. Here, we see that no keys are being pressed, so no rows get an `x`. For one keyswitch, keep in mind that one side of the contacts is connected to its row, and the other, its column.
-
-When we press `key0`, `col0` gets connected to `row0`, so the values that the firmware receives for that row is `0b01` (the `0b` here means that this is a bit value, meaning all of the following digits are bits - 0 or 1 - and represent the keys in that column). We'll use this notation to show when a keyswitch has been pressed, to show that the column and row are being connected:
-
-        Column 0 being scanned     Column 1 being scanned
-                  x                                   x
-                 col0     col1              col0     col1
-                  |        |                 |        |
-      x row0 ---(-+-0)---(key1)    row0 ---(-+-0)---(key1)
-                  |        |                 |        |
-        row1 ---(key2)---(key3)    row1 ---(key2)---(key3)
-
-We can now see that `row0` has an `x`, so has the value of 1. As a whole, the data the firmware receives when `key0` is pressed is
-
-    col0: 0b01
-    col1: 0b00
-            │└row0
-            └row1
-
-A problem arises when you start pressing more than one key at a time. Looking at our matrix again, it should become pretty obvious:
-
-        Column 0 being scanned     Column 1 being scanned
-                  x                                   x
-                 col0     col1              col0     col1
-                  |        |                 |        |
-      x row0 ---(-+-0)---(-+-1)  x row0 ---(-+-0)---(-+-1)
-                  |        |                 |        |
-      x row1 ---(key2)---(-+-3)  x row1 ---(key2)---(-+-3)
-
-      Remember that this ^ is still connected to row1
-
-The data we get from that is:
-
-    col0: 0b11
-    col1: 0b11
-            │└row0
-            └row1
-
-Which isn't accurate, since we only have 3 keys pressed down, not all 4. This behavior is called ghosting, and only happens in odd scenarios like this, but can be much more common on a bigger keyboard. The way we can get around this is by placing a diode after the keyswitch, but before it connects to its row. A diode only allows current to pass through one way, which will protect our other columns/rows from being activated in the previous example. We'll represent a dioded matrix like this;
-
-        Column 0 being scanned     Column 1 being scanned
-                    x                                   x
-                  col0      col1              col0     col1
-                    │        │                 |        │
-                 (key0)   (key1)            (key0)   (key1)
-                  ! │      ! │               ! |      ! │
-        row0 ─────┴────────┘ │     row0 ─────┴────────┘ │
-                    │        │                 |        │
-                 (key2)   (key3)            (key2)   (key3)
-                  !        !                 !        !
-        row1 ─────┴────────┘       row1 ─────┴────────┘
-
-In practical applications, the black line of the diode will be placed facing the row, and away from the keyswitch - the `!` in this case is the diode, where the gap represents the black line. A good way to remember this is to think of this symbol: `>|`
-
-Now when we press the three keys, invoking what would be a ghosting scenario:
-
-        Column 0 being scanned     Column 1 being scanned
-                    x                                   x
-                  col0      col1              col0     col1
-                    │        │                 │        │
-                 (┌─┤0)   (┌─┤1)            (┌─┤0)   (┌─┤1)
-                  ! │      ! │               ! │      ! │
-      x row0 ─────┴────────┘ │   x row0 ─────┴────────┘ │
-                    │        │                 │        │
-                 (key2)   (┌─┘3)            (key2)   (┌─┘3)
-                  !        !                 !        !
-        row1 ─────┴────────┘     x row1 ─────┴────────┘
-
-Things act as they should! Which will get us the following data:
-
-    col0: 0b01
-    col1: 0b11
-            │└row0
-            └row1
-
-The firmware can then use this correct data to detect what it should do, and eventually, what signals it needs to send to the OS.
-
-Further reading:
-- [Wikipedia article](https://en.wikipedia.org/wiki/Keyboard_matrix_circuit)
-- [Deskthority article](https://deskthority.net/wiki/Keyboard_matrix)
-- [Keyboard Matrix Help by Dave Dribin (2000)](https://www.dribin.org/dave/keyboard/one_html/)
-- [How Key Matrices Works by PCBheaven](http://pcbheaven.com/wikipages/How_Key_Matrices_Works/) (animated examples)
-- [How keyboards work - QMK documentation](how_keyboards_work.md)
-
-</details>
-
-
 ## Parts list
 
 You will need: (where *x* is the number of keys on your planned keyboard)
@@ -141,29 +32,29 @@ Start by installing the switches and stabilisers in the plate. Depending on the
 
 If you are following a pre-existing handwire guide (e.g. for the keyboards in the [handwire firmware section](https://github.com/qmk/qmk_firmware/tree/master/keyboards/handwired) you can skip this step, just ensure you wire the matrix as described.
 
-What you want to achieve is one leg from each switch being attached to the corresponding switches next to it (rows) and the other leg being attached to the switches above and below it (columns) and a diode to one of the legs, mosy commonly this will be the leg attached to the rows, and the diode will face away from it (Column to Row) i.e. with the wire furthest from the black line on the diode connected to the switch (as current will only travel in one direction through a diode)
+What you want to achieve is one leg from each switch being attached to the corresponding switches next to it (rows) and the other leg being attached to the switches above and below it (columns) and a diode to one of the legs, mosy commonly this will be the leg attached to the rows, and the diode will face away from it (Column to Row) i.e. with the wire furthest from the black line on the diode connected to the switch (as current will only travel in one direction through a diode).
 
 It is fairly simple to plan for an ortholinear keyboard (like a Planck).
 
-![Example planck matrix](https://i.imgur.com/FRShcLD.png)
+![Example Planck matrix](https://i.imgur.com/FRShcLD.png)
 Image from [RoastPotatoes' "How to hand wire a Planck"](https://blog.roastpotatoes.co/guide/2015/11/04/how-to-handwire-a-planck/)
 
 But the larger and more complicated your keyboard, the more complex the matrix.  [Keyboard Firmware Builder](https://kbfirmware.com/) can help you plan your matrix layout (shown here with a basic fullsize ISO keyboard imported from [Keyboard Layout Editor](http://www.keyboard-layout-editor.com).
 
 ![Example ISO matrix](https://i.imgur.com/UlJ4ZDP.png)
 
- Bear in mind that the number of rows plus the number of columns can not exceed the number of I/O pins on your controller.  So the fullsize matrix shown above would be possible on a Proton C or Teensy++, but not on a regular Teensy or Pro Micro
+Bear in mind that the number of rows plus the number of columns can not exceed the number of I/O pins on your controller.  So the fullsize matrix shown above would be possible on a Proton C or Teensy++, but not on a regular Teensy or Pro Micro.
 
-#### Common Microcontroller Boards
+### Common Microcontroller Boards
 
 | Board         | Controller    | # I/O  | Pinout |
 | :------------ |:-------------:| ------:| ------ |
-| Pro Micro*     | ATmega32u4    |     20 | [link](https://learn.sparkfun.com/tutorials/pro-micro--fio-v3-hookup-guide/hardware-overview-pro-micro#Teensy++_2.0)       |
+| Pro Micro*    | ATmega32u4    |     20 | [link](https://learn.sparkfun.com/tutorials/pro-micro--fio-v3-hookup-guide/hardware-overview-pro-micro#Teensy++_2.0)       |
 | Teensy 2.0    | ATmega32u4    |     25 | [link](https://www.pjrc.com/teensy/pinout.html)       |
 | [QMK Proton C](https://qmk.fm/proton-c/)      | STM32F303xC   |     36 | [link 1](https://i.imgur.com/RhtrAlc.png), [2](https://deskthority.net/wiki/QMK_Proton_C)       |
 | Teensy++ 2.0  | AT90USB1286   |     46 | [link](https://www.pjrc.com/teensy/pinout.html#Teensy_2.0)       |
 
-*Elite C is essentially the same as a pro micro with a USB-C instead of Micro-USB
+*Elite C is essentially the same as a Pro Micro with a USB-C instead of Micro-USB
 
 There are also a number of boards designed specifically for handwiring that mount directly to a small number of switches and offer pinouts for the rest.  Though these are generally more expensive and may be more difficult to get hold of.
 
@@ -204,7 +95,7 @@ If you are planning a split keyboard (e.g. Dactyl) each half will require a cont
 
 There are a lot of soldering guides and tips available elsewhere but here are some of the most useful and relevant for hand wiring:
 
-To ensure a strong solder joint you want a good amount of contact between the solder and the 2 peices of metal you are connecting, a good way of doing this (though not required) is looping around pins or twisting wires together before applying solder.
+To ensure a strong solder joint you want a good amount of contact between the solder and the two pieces of metal you are connecting. A good way of doing this (though not required) is looping around pins or twisting wires together before applying solder.
 
 <img src="https://i.imgur.com/eHJjmnU.jpg" alt="Looped around rod" width="200"/> <img src="https://i.imgur.com/8nbxmmr.jpg?1" alt="Looped diode leg" width="200"/>
 
@@ -220,24 +111,11 @@ When you come to apply the solder, hold the soldering iron against the two surfa
 
 Don't hold the iron on the solder/joint longer than necessary. Heat will be conducted through the surfaces and can damage components (melt switch housings etc.).  Also, solder contains flux, which aids in ["wetting"](https://en.m.wikipedia.org/wiki/Wetting).  The longer heat is applied to the solder the more flux will evaporate meaning you may end up with a bad solder joint with peaks which, apart from looking bad, may also increase the risk of electrical shorts.
 
-The following collapsible section describes in detail how to solder rows using the bent diode technique and columns using short lengths of wire.
+#### Soldering the Diodes
 
-<details>
+Starting at the top-left switch, place the diode (with tweezers if you have them) on the switch so that the diode itself is vertically aligned, and the black line is facing toward you. The input lead of the diode should be touching the left contact on the switch, and the bent, output end should be facing to the right and resting on the switch there, like this:
 
-<summary>Click for details</summary>
-
-## Soldering the Diodes
-
-Starting at the top-left switch, place the diode (with tweezers if you have them) on the switch so that the diode itself is vertically aligned, and the black line is facing toward you. The straight end of the diode should be touching the left contact on the switch, and the bent end should be facing to the right and resting on the switch there, like this:
-
-```
-     │o
-    ┌┴┐         o
-    │ │    O
-    ├─┤
-    └┬┘
-     └─────────────
-```
+![soldering-diodes-01.png](https://raw.githubusercontent.com/noroadsleft/qmk_images/master/docs/hand_wire/soldering-diodes-01.png)
 
 Letting the diode rest, grab your solder, and touch both it and the soldering iron to the left contact at the same time - the rosin in the solder should make it easy for the solder to flow over both the diode and the keyswitch contact. The diode may move a little, and if it does, carefully position it back it place by grabbing the bent end of the diode - the other end will become hot very quickly. If you find that it's moving too much, using needle-nose pliers of some sort may help to keep the diode still when soldering.
 
@@ -247,20 +125,13 @@ After soldering things in place, it may be helpful to blow on the joint to push
 
 When the first diode is complete, the next one will need to be soldered to both the keyswitch, and the previous diode at the new elbow. That will look something like this:
 
-```
-     │o               │o
-    ┌┴┐         o    ┌┴┐         o
-    │ │    O         │ │    O
-    ├─┤              ├─┤
-    └┬┘              └┬┘
-     └────────────────┴─────────────
-```
+![soldering-diodes-02.png](https://raw.githubusercontent.com/noroadsleft/qmk_images/master/docs/hand_wire/soldering-diodes-02.png)
 
 After completing a row, use the wire cutters to trim the excess wire from the tops of the diodes, and from the right side on the final switch. This process will need to completed for each row you have.
 
 When all of the diodes are completely soldered, it's a good idea to quickly inspect each one to ensure that your solder joints are solid and sturdy - repairing things after this is possible, but more difficult.
 
-## Soldering the Columns
+#### Soldering the Columns
 
 You'll have some options in the next process - it's a good idea to insulate the column wires (since the diodes aren't), but if you're careful enough, you can use exposed wires for the columns - it's not recommended, though. If you're using single-cored wire, stripping the plastic off of the whole wire and feeding it back on is probably the best option, but can be difficult depending on the size and materials. You'll want to leave parts of the wire exposed where you're going to be solder it onto the keyswitch.
 
@@ -270,9 +141,7 @@ Before beginning to solder, it helps to have your wire pre-bent (if using single
 
 If you're not using any insulation, you can try to keep the column wires elevated, and solder them near the tips of the keyswitch contacts - if the wires are sturdy enough, they won't short out to the row wiring an diodes.
 
-</details>
-
-# Wiring up the controller
+## Wiring up the controller
 
 Now that the matrix itself is complete, it's time to connect what you've done to the microcontroller board.
 
@@ -280,15 +149,16 @@ Place the microcontroller where you want it to be located, give thought to mount
 
 Find the pinout/documentation for your microcontroller board ([links here](#common-microcontroller-boards)) and make a note of all the digital I/O pins on it (note that on some controllers, like the teensy, analogue I/O can double as digital) as these are the pins you want to connect your wires to.
 
-<details>
+----
 
-<summary>Specific instructions for the Teensy 2.0</summary>
+### Specific instructions for the Teensy 2.0
 
- There are some pins on the Teensy that are special, like D6 (the LED on the chip), or some of the UART, SPI, I2C, or PWM channels, but only avoid those if you're planning something in addition to a keyboard. If you're unsure about wanting to add something later, you should have enough pins in total to avoid a couple.
+There are some pins on the Teensy that are special, like D6 (the LED on the chip), or some of the UART, SPI, I2C, or PWM channels, but only avoid those if you're planning something in addition to a keyboard. If you're unsure about wanting to add something later, you should have enough pins in total to avoid a couple.
 
 The pins you'll absolutely have to avoid, as with any controller, are: GND, VCC, AREF, and RST - all the others are usable and accessible in the firmware.
 
-</details>
+----
+
 
 Cut wires to the length of the distance from the a point on each column/row to the controller.  You can solder anywhere along the row, as long as it's after the diode - soldering before the diode (on the keyswitch side) will cause that row not to work.
 
@@ -301,150 +171,32 @@ As you solder the wires to the controller make a note of which row/column is goi
 As you move along, be sure that the controller is staying in place - recutting and soldering the wires is a pain!
 
 
-
-# Getting Some Basic Firmware Set Up
+## Getting Some Basic Firmware Set Up
 
 From here, you should have a working keyboard once you program a firmware.
 
 Simple firmware can be created easily using the [Keyboard Firmware Builder](https://kbfirmware.com/) website.  Recreate your layout using [Keyboard Layout Editor](http://www.keyboard-layout-editor.com), import it and recreate the matrix (if not already done as part of [planning the matrix](#planning-the-matrix).
 
-Go through the rest of the tabs, assigning keys until you get to the last one where you can compile and download your firmware.  The .hex file can be flashed straight onto your keyboard, and the .zip of source files can be modified for advanced functionality and compiled locally using the method described in the collapsable section below, or using the more comprehensive [getting started guide.](newbs_getting_started)
+Go through the rest of the tabs, assigning keys until you get to the last one where you can compile and download your firmware.  The .hex file can be flashed straight onto your keyboard, and the .zip of source files can be modified for advanced functionality and compiled locally using the method described in [Building Your First Firmware](newbs_building_firmware?id=build-your-firmware).
 
+The source given by Keyboard Firmware Builder is QMK, but is based on a version of QMK from early 2017. To compile the code from your .zip file in a modern version of QMK Firmware, you'll need to open the .zip and follow these instructions:
 
-<details>
-
-<summary>Creating and compiling your firmware locally (command line method)</summary>
-
-To start out, download [the firmware](https://github.com/qmk/qmk_firmware/) - We'll be doing a lot from the Terminal/command prompt, so get that open, along with a decent text editor like [Sublime Text](http://www.sublimetext.com/) (paid) or [Visual Studio Code](https://code.visualstudio.com) (free).
-
-The first thing we're going to do is create a new keyboard. In your terminal, run this command, which will ask you some questions and generate a basic keyboard project:
-
-```
-./util/new_keyboard.sh
-```
-
-You'll want to navigate to the `keyboards/<project_name>/` folder by typing, like the print-out from the script specifies:
-
-```
-cd keyboards/<project_name>
-```
-
-### `config.h`
-
-The first thing you're going to want to modify is the `config.h` file. Find `MATRIX_ROWS` and `MATRIX_COLS` and change their definitions to match the dimensions of your keyboard's matrix.
-
-Farther down are `MATRIX_ROW_PINS` and `MATRIX_COL_PINS`. Change their definitions to match how you wired up your matrix (looking from the top of the keyboard, the rows run top-to-bottom and the columns run left-to-right). Likewise, change the definition of `UNUSED_PINS` to match the pins you did not use (this will save power).
-
-### `<project_name>.h`
-
-The next file you'll want to look at is `<project_name>.h`. You're going to want to rewrite the `LAYOUT` definition - the format and syntax here is extremely important, so pay attention to how things are setup. The first half of the definition are considered the arguments - this is the format that you'll be following in your keymap later on, so you'll want to have as many k*xy* variables here as you do keys. The second half is the part that the firmware actually looks at, and will contain gaps depending on how you wired your matrix.
-
-We'll dive into how this will work with the following example. Say we have a keyboard like this:
-
-```
-    ┌───┬───┬───┐
-    │   │   │   │
-    ├───┴─┬─┴───┤
-    │     │     │
-    └─────┴─────┘
-```
-
-This can be described by saying the top row is 3 1u keys, and the bottom row is 2 1.5u keys. The difference between the two rows is important, because the bottom row has an unused column spot (3 v 2). Let's say that this is how we wired the columns:
-
-```
-    ┌───┬───┬───┐
-    │ ┋ │ ┋ │ ┋ │
-    ├─┋─┴─┬─┴─┋─┤
-    │ ┋   │   ┋ │
-    └─────┴─────┘
-```
-
-The middle column is unused on the bottom row in this example. Our `LAYOUT` definition would look like this:
-
-```
-    #define LAYOUT( \
-        k00, k01, k02, \
-          k10,  k11,   \
-    ) \
-    { \
-        { k00, k01,   k02 }, \
-        { k10, KC_NO, k11 }, \
+1. Extract the `kb` folder to `qmk_firmware/keyboards/handwired/`.
+2. Open the extracted `kb` folder, then proceed to the `keymaps/default/` folder, and open `keymap.c`.
+3. Locate and delete the `action_get_macro` code block:
+   ```
+    const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+        ...
+        return MACRO_NONE;
     }
-```
-
-Notice how the top half is spaced to resemble our physical layout - this helps us understand which keys are associated with which columns. The bottom half uses the keycode `KC_NO` where there is no keyswitch wired in. It's easiest to keep the bottom half aligned in a grid to help us make sense of how the firmware actually sees the wiring.
-
-Let's say that instead, we wired our keyboard like this (a fair thing to do):
-
-```
-    ┌───┬───┬───┐
-    │ ┋ │  ┋│ ┋ │
-    ├─┋─┴─┬┋┴───┤
-    │ ┋   │┋    │
-    └─────┴─────┘
-```
-
-This would require our `LAYOUT` definition to look like this:
-
-```
-    #define LAYOUT( \
-        k00, k01, k02, \
-          k10,  k11,   \
-    ) \
-    { \
-        { k00, k01, k02   }, \
-        { k10, k11, KC_NO }, \
-    }
-```
-
-Notice how the `k11` and `KC_NO` switched places to represent the wiring, and the unused final column on the bottom row. Sometimes it'll make more sense to put a keyswitch on a particular column, but in the end, it won't matter, as long as all of them are accounted for. You can use this process to write out the `LAYOUT` for your entire keyboard - be sure to remember that your keyboard is actually backwards when looking at the underside of it.
-
-### `keymaps/<variant>/default.c`
-
-This is the actual keymap for your keyboard, and the main place you'll make changes as you perfect your layout. `default.c` is the file that gets pull by default when typing `make`, but you can make other files as well, and specify them by typing `make handwired/<keyboard>:<variant>`, which will pull `keymaps/<variant>/keymap.c`.
-
-The basis of a keymap is its layers - by default, layer 0 is active. You can activate other layers, the highest of which will be referenced first. Let's start with our base layer.
-
-Using our previous example, let's say we want to create the following layout:
-
-```
-    ┌───┬───┬───┐
-    │ A │ 1 │ H │
-    ├───┴─┬─┴───┤
-    │ TAB │ SPC │
-    └─────┴─────┘
-```
-
-This can be accomplished by using the following `keymaps` definition:
-
-```
-const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
-    [0] = LAYOUT( /* Base */
-      KC_A,  KC_1,  KC_H, \
-        KC_TAB,  KC_SPC   \
-    ),
-};
-```
-
-Note that the layout of the keycodes is similar to the physical layout of our keyboard - this make it much easier to see what's going on. A lot of the keycodes should be fairly obvious, but for a full list of them, check out [Keycodes](keycodes.md) - there are also a lot of aliases to condense your keymap file.
-
-It's also important to use the `LAYOUT` function we defined earlier - this is what allows the firmware to associate our intended readable keymap with the actual wiring.
-
-## Compiling Your Firmware
-
-After you've written out your entire keymap, you're ready to get the firmware compiled and onto your Teensy. Before compiling, you'll need to get your [development environment set-up](getting_started_build_tools.md) - you can skip the dfu-programmer instructions, but you'll need to download and install the [Teensy Loader](https://www.pjrc.com/teensy/loader.html) to get the firmware on your Teensy.
-
-Once everything is installed, running `make` in the terminal should get you some output, and eventually a `<project_name>.hex` file in that folder. If you're having trouble with this step, see the end of the guide for the trouble-shooting section.
-
-Once you have your `<project_name>.hex` file, open up the Teensy loader application, and click the file icon. From here, navigate to your `QMK/keyboards/<project_name>/` folder, and select the `<project_name>.hex` file. Plug in your keyboard and press the button on the Teensy - you should see the LED on the device turn off once you do. The Teensy Loader app will change a little, and the buttons should be clickable - click the download button (down arrow), and then the reset button (right arrow), and your keyboard should be ready to go!
-
-</details>
+   ```
+4. Save and close `keymap.c`.
 
 ## Flashing the Firmware
 
-Install [QMK toolbox](https://github.com/qmk/qmk_toolbox).
+Install [QMK Toolbox](https://github.com/qmk/qmk_toolbox).
 
-![QMK Toolbox](https://i.imgur.com/86Cz30H.png)
+![QMK Toolbox](https://raw.githubusercontent.com/noroadsleft/qmk_images/master/docs/hand_wire/qmk_toolbox.png "QMK Toolbox 0.0.16 on Windows 8.1")
 
 Under "Local File" navigate to your newly created .hex file.  Under "Microcontroller", select the corresponding one for your controller board (common ones available [here](#common-microcontroller-boards)).
 
@@ -453,20 +205,20 @@ Plug in your keyboard and press the reset button (or short the Reset and Ground
 
 ## Testing Your Firmware
 
-Use a website such as [keyboard tester](https://www.keyboardtester.com/tester.html)/[keyboard checker](http://keyboardchecker.com/) or just open a text editor and try typing - you should get the characters that you put into your keymap. Test each key, and make a note of the ones that aren't working. Here's a quick trouble-shooting guide for non-working keys:
+Use a website such as [QMK Configurator's Keyboard Tester](https://config.qmk.fm/#/test), [Keyboard Tester](https://www.keyboardtester.com/tester.html), or [Keyboard Checker](http://keyboardchecker.com/) or just open a text editor and try typing - you should get the characters that you put into your keymap. Test each key, and make a note of the ones that aren't working. Here's a quick trouble-shooting guide for non-working keys:
 
-0. Flip the keyboard back over and short the keyswitch's contacts with a piece wire - this will eliminate the possibility of the keyswitch being bad and needing to be replaced.
-1. Check the solder points on the keyswitch - these need to be plump and whole. If you touch it with a moderate amount of force and it comes apart, it's not strong enough.
-2. Check the solder joints on the diode - if the diode is loose, part of your row may register, while the other may not.
-3. Check the solder joints on the columns - if your column wiring is loose, part or all of the column may not work.
-4. Check the solder joints on both sides of the wires going to/from the Teensy - the wires need to be fully soldered and connect to both sides.
-5. Check the `<project_name>.h` file for errors and incorrectly placed `KC_NO`s - if you're unsure where they should be, instead duplicate a k*xy* variable.
-6. Check to make sure you actually compiled the firmware and flashed the Teensy correctly. Unless you got error messages in the terminal, or a pop-up during flashing, you probably did everything correctly.
-7. Use a multimeter to check that the switch is actually closing when actuated (completing the circuit when pressed down).
+1. Flip the keyboard back over and short the keyswitch's contacts with a piece wire - this will eliminate the possibility of the keyswitch being bad and needing to be replaced.
+2. Check the solder points on the keyswitch - these need to be plump and whole. If you touch it with a moderate amount of force and it comes apart, it's not strong enough.
+3. Check the solder joints on the diode - if the diode is loose, part of your row may register, while the other may not.
+4. Check the solder joints on the columns - if your column wiring is loose, part or all of the column may not work.
+5. Check the solder joints on both sides of the wires going to/from the Teensy - the wires need to be fully soldered and connect to both sides.
+6. Check the `<project_name>.h` file for errors and incorrectly placed `KC_NO`s - if you're unsure where they should be, instead duplicate a k*xy* variable.
+7. Check to make sure you actually compiled the firmware and flashed the Teensy correctly. Unless you got error messages in the terminal, or a pop-up during flashing, you probably did everything correctly.
+8. Use a multimeter to check that the switch is actually closing when actuated (completing the circuit when pressed down).
 
 If you've done all of these things, keep in mind that sometimes you might have had multiple things affecting the keyswitch, so it doesn't hurt to test the keyswitch by shorting it out at the end.
 
-# Finishing up
+## Finishing up
 
 Once you have confirmed that the keyboard is working, if you have used a seperate (non handwire specific) controller you will want to secure it in place.  This can be done in many different ways e.g. hot glue, double sided sticky tape, 3D printed caddy, electrical tape.
 
@@ -474,7 +226,7 @@ If you found this fullfilling you could experiment by adding additional features
 
 There are a lot of possibilities inside the firmware - explore [docs.qmk.fm](http://docs.qmk.fm) for a full feature list, and dive into the different keyboards to see how people use all of them. You can always stop by [the OLKB subreddit](http://reddit.com/r/olkb) or [QMK Discord](https://discord.gg/Uq7gcHh) for help!
 
-# Links to other guides:
+## Links to Other Guides
 
 - [matt3o's step by step guide (BrownFox build)](https://deskthority.net/viewtopic.php?f=7&t=6050) also his [website](https://matt3o.com/hand-wiring-a-custom-keyboard/) and [video guide](https://www.youtube.com/watch?v=LVzpsjFWPP4)
 - [Cribbit's "Modern hand wiring guide - stronger, cleaner, easier"](https://geekhack.org/index.php?topic=87689.0) 
@@ -483,4 +235,10 @@ There are a lot of possibilities inside the firmware - explore [docs.qmk.fm](htt
 - [Masterzen's "Handwired keyboard build log"](http://www.masterzen.fr/2018/12/16/handwired-keyboard-build-log-part-1/)
 
 
+# Legacy Content
 
+This page used to include more content. We have moved a section that used to be part of this page its own page. Everything below this point is simply a redirect so that people following old links on the web find what they're looking for.
+
+## Preamble: How a Keyboard Matrix Works (and why we need diodes) :id=preamble-how-a-keyboard-matrix-works-and-why-we-need-diodes
+
+* [How a Keyboard Matrix Works](how_a_matrix_works.md)

docs/hardware.md

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

docs/hardware_drivers.md

@@ -33,3 +33,7 @@ Support for up to 2 drivers. Each driver impliments 2 charlieplex matrices to in
 ## IS31FL3733
 
 Support for up to a single driver with room for expansion. Each driver can control 192 individual LEDs or 64 RGB LEDs. For more information on how to setup the driver see the [RGB Matrix](feature_rgb_matrix.md) page.
+
+## 24xx series external I2C EEPROM
+
+Support for an external I2C-based EEPROM instead of using the on-chip EEPROM. For more information on how to setup the driver see the [EEPROM Driver](eeprom_driver.md) page.

docs/he-il/_summary.md

@@ -93,7 +93,7 @@
   * [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)
+  * [One Shot Keys](he-il/one_shot_keys.md)
   * [Pointing Device](he-il/feature_pointing_device.md)
   * [PS/2 Mouse](he-il/feature_ps2_mouse.md)
   * [RGB Lighting](he-il/feature_rgblight.md)
@@ -124,7 +124,7 @@
 * נושאים נוספים
   * [שימוש ב - Eclipse עם QMK](he-il/other_eclipse.md)
   * [שימוש ב - VSCode עם QMK](he-il/other_vscode.md)
-  * [תמיכה](he-il/support.md)
+  * [תמיכה](he-il/getting_started_getting_help.md)
   * [כיצד להוסיף תרגום](he-il/translating.md)
 
 * QMK מבפנים (בתהליך)

docs/he-il/becoming_a_qmk_collaborator.md

@@ -1,11 +0,0 @@
-<div dir="rtl" markdown="1">
-# איך להפוך לשותף של QMK
-
-שותף של QMK הוא יצרן מקלדות או מעצב שמעוניין בלעזור ל-QMK לגדול ולתמוך במקלד(ו)ת שלהם, ולעודד את המשתמשים והצרכנים להוסיף יכולות, רעיונות ומיפויים. אנחנו תמיד מחפשים עוד מקלדות ומשתפי פעולה, אבל אנחנו מבקשים שיעמדו בדרישות הבאות:
-
-* **קיום לוח PCB למכירה.** לצערינו, יש יותר מידי הסתבכויות ובעיות עם מקלדות המחווטות ידנית.
-* **תחזוק המקלדת ב-QMK.** זה אולי רק ידרוש הגדרה בסיסית כדי לגרום למקלדת לעבוד, אבל זה גם יכול לכלול התאמה של שינויים בקוד הליבה של QMK שיכול לשבור קוד ייחודי שלכם.
-* **אישור ומיזוג Pull Requests של מיפויי מקלדת עבור המקלדת** אנחנו רוצים לעודד משתמשים לתרום את מיפויי המקלדת שלהם לאחרים כדי לעזור לאחרים להתחיל ליצור את שלהם.
-
-אם אתם עומדים בדרישות הללו, שלחו לנו מייל לכתובת  hello@qmk.fm עם מבוא וקישורים עבור המקלדת שלכם.
-</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/he-il/quantum_keycodes.md

@@ -17,18 +17,8 @@
 |`DEBUG`        |           |Toggle debug mode                                                    |
 |`EEPROM_RESET` |`EEP_RST`  |Resets EEPROM state by reinitializing it                             |
 |`KC_GESC`      |`GRAVE_ESC`|Escape when tapped, <code>&#96;</code> when pressed with Shift or GUI|
-|`KC_LSPO`      |           |Left Shift when held, `(` when tapped                                |
-|`KC_RSPC`      |           |Right Shift when held, `)` when tapped                               |
-|`KC_LCPO`      |           |Left Control when held, `(` when tapped                              |
-|`KC_RCPC`      |           |Right Control when held, `)` when tapped                             |
-|`KC_LAPO`      |           |Left Alt when held, `(` when tapped                                  |
-|`KC_RAPC`      |           |Right Alt when held, `)` when tapped                                 |
-|`KC_SFTENT`    |           |Right Shift when held, Enter when tapped                             |
 |`KC_LEAD`      |           |The [Leader key](feature_leader_key.md)                              |
 |`KC_LOCK`      |           |The [Lock key](feature_key_lock.md)                                  |
-|`FUNC(n)`      |`F(n)`     |Call `fn_action(n)` (deprecated)                                     |
-|`M(n)`         |           |Call macro `n`                                                       |
-|`MACROTAP(n)`  |           |Macro-tap `n` idk FIXME                                              |
 ```
 
 </div>

docs/how_a_matrix_works.md

@@ -0,0 +1,99 @@
+# How a Keyboard Matrix Works
+
+Keyboard switch matrices are arranged in rows and columns. Without a matrix circuit, each switch would require its own wire directly to the controller.
+
+When the circuit is arranged in rows and columns, if a key is pressed, a column wire makes contact with a row wire and completes a circuit. The keyboard controller detects this closed circuit and registers it as a key press.
+
+The microcontroller will be set up via the firmware to send a logical 1 to the columns, one at a time, and read from the rows, all at once - this process is called matrix scanning. The matrix is a bunch of open switches that, by default, don't allow any current to pass through - the firmware will read this as no keys being pressed. As soon as you press one key down, the logical 1 that was coming from the column the keyswitch is attached to gets passed through the switch and to the corresponding row - check out the following 2x2 example:
+
+        Column 0 being scanned     Column 1 being scanned
+                  x                                   x
+                 col0     col1              col0     col1
+                  |        |                 |        |
+        row0 ---(key0)---(key1)    row0 ---(key0)---(key1)
+                  |        |                 |        |
+        row1 ---(key2)---(key3)    row1 ---(key2)---(key3)
+
+The `x` represents that the column/row associated has a value of 1, or is HIGH. Here, we see that no keys are being pressed, so no rows get an `x`. For one keyswitch, keep in mind that one side of the contacts is connected to its row, and the other, its column.
+
+When we press `key0`, `col0` gets connected to `row0`, so the values that the firmware receives for that row is `0b01` (the `0b` here means that this is a bit value, meaning all of the following digits are bits - 0 or 1 - and represent the keys in that column). We'll use this notation to show when a keyswitch has been pressed, to show that the column and row are being connected:
+
+        Column 0 being scanned     Column 1 being scanned
+                  x                                   x
+                 col0     col1              col0     col1
+                  |        |                 |        |
+      x row0 ---(-+-0)---(key1)    row0 ---(-+-0)---(key1)
+                  |        |                 |        |
+        row1 ---(key2)---(key3)    row1 ---(key2)---(key3)
+
+We can now see that `row0` has an `x`, so has the value of 1. As a whole, the data the firmware receives when `key0` is pressed is:
+
+    col0: 0b01
+    col1: 0b00
+            │└row0
+            └row1
+
+A problem arises when you start pressing more than one key at a time. Looking at our matrix again, it should become pretty obvious:
+
+        Column 0 being scanned     Column 1 being scanned
+                  x                                   x
+                 col0     col1              col0     col1
+                  |        |                 |        |
+      x row0 ---(-+-0)---(-+-1)  x row0 ---(-+-0)---(-+-1)
+                  |        |                 |        |
+      x row1 ---(key2)---(-+-3)  x row1 ---(key2)---(-+-3)
+
+      Remember that this ^ is still connected to row1
+
+The data we get from that is:
+
+    col0: 0b11
+    col1: 0b11
+            │└row0
+            └row1
+
+Which isn't accurate, since we only have 3 keys pressed down, not all 4. This behavior is called ghosting, and only happens in odd scenarios like this, but can be much more common on a bigger keyboard. The way we can get around this is by placing a diode after the keyswitch, but before it connects to its row. A diode only allows current to pass through one way, which will protect our other columns/rows from being activated in the previous example. We'll represent a dioded matrix like this;
+
+        Column 0 being scanned     Column 1 being scanned
+                    x                                   x
+                  col0      col1              col0     col1
+                    │        │                 |        │
+                 (key0)   (key1)            (key0)   (key1)
+                  ! │      ! │               ! |      ! │
+        row0 ─────┴────────┘ │     row0 ─────┴────────┘ │
+                    │        │                 |        │
+                 (key2)   (key3)            (key2)   (key3)
+                  !        !                 !        !
+        row1 ─────┴────────┘       row1 ─────┴────────┘
+
+In practical applications, the black line of the diode will be placed facing the row, and away from the keyswitch - the `!` in this case is the diode, where the gap represents the black line. A good way to remember this is to think of this symbol: `>|`
+
+Now when we press the three keys, invoking what would be a ghosting scenario:
+
+        Column 0 being scanned     Column 1 being scanned
+                    x                                   x
+                  col0      col1              col0     col1
+                    │        │                 │        │
+                 (┌─┤0)   (┌─┤1)            (┌─┤0)   (┌─┤1)
+                  ! │      ! │               ! │      ! │
+      x row0 ─────┴────────┘ │   x row0 ─────┴────────┘ │
+                    │        │                 │        │
+                 (key2)   (┌─┘3)            (key2)   (┌─┘3)
+                  !        !                 !        !
+        row1 ─────┴────────┘     x row1 ─────┴────────┘
+
+Things act as they should! Which will get us the following data:
+
+    col0: 0b01
+    col1: 0b11
+            │└row0
+            └row1
+
+The firmware can then use this correct data to detect what it should do, and eventually, what signals it needs to send to the OS.
+
+Further reading:
+- [Wikipedia article](https://en.wikipedia.org/wiki/Keyboard_matrix_circuit)
+- [Deskthority article](https://deskthority.net/wiki/Keyboard_matrix)
+- [Keyboard Matrix Help by Dave Dribin (2000)](https://www.dribin.org/dave/keyboard/one_html/)
+- [How Key Matrices Works by PCBheaven](http://pcbheaven.com/wikipages/How_Key_Matrices_Works/) (animated examples)
+- [How keyboards work - QMK documentation](how_keyboards_work.md)

docs/index.html

@@ -13,8 +13,9 @@
   <meta property="og:image" content="https://i.imgur.com/svjvIrw.jpg">
   <meta property="og:url" content="https://docs.qmk.fm">
   <meta name="twitter:card" content="summary_large_image">
-  <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/vue.css" title="light">
-  <link rel="stylesheet" href="qmk.css" title="dark" disabled>
+  <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/buble.css" title="light">
+  <link rel="stylesheet" href="//unpkg.com/docsify/lib/themes/dark.css" media="(prefers-color-scheme: dark)">
+  <link rel="stylesheet" href="//unpkg.com/docsify-toc@1.0.0/dist/toc.css">
   <link rel="stylesheet" href="sidebar.css" />
 </head>
 <body>
@@ -22,10 +23,26 @@
   <script>
     window.$docsify = {
       alias: {
+        // Translation aliases
         '/en/(.*)': '/$1',
         '/en-us/(.*)': '/$1',
         '/en-gb/(.*)': '/$1',
         '/.*/_langs.md': '/_langs.md',
+
+        // Moved pages
+        '/adding_a_keyboard_to_qmk': '/hardware_keyboard_guidelines',
+        '/build_environment_setup': '/getting_started_build_tools',
+        '/dynamic_macros': '/feature_dynamic_macros',
+        '/feature_common_shortcuts': '/feature_advanced_keycodes',
+        '/glossary': '/reference_glossary',
+        '/key_lock': '/feature_key_lock',
+        '/make_instructions': '/getting_started_make_guide',
+        '/porting_your_keyboard_to_qmk': '/hardware_avr',
+        '/space_cadet_shift': '/feature_space_cadet_shift',
+        '/getting_started_getting_help': '/support',
+        '/tap_dance': '/feature_tap_dance',
+        '/unicode': '/feature_unicode',
+        '/python_development': '/cli_development',
       },
       basePath: '/',
       name: 'QMK Firmware',
@@ -35,6 +52,7 @@
         '/fr-fr/': '/#/fr-fr/',
         '/he-il/': '/#/he-il/',
         '/ja/': '/#/ja/',
+        '/pt-br/': '/#/pt-br/',
         '/ru-ru/': '/#/ru-ru/',
         '/zh-cn/': '/#/zh-cn/',
         '/': '/#/'
@@ -44,12 +62,14 @@
       loadNavbar: '_langs.md',
       mergeNavbar: true,
       auto2top: true,
+      autoHeader: true,
       fallbackLanguages: [
         'de',
         'es',
         'fr-fr',
         'he-il',
         'ja',
+        'pt-br',
         'ru-ru',
         'zh-cn'
       ],
@@ -60,16 +80,48 @@
           '/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
       },
+      markdown: {
+        smartypants: true,
+        smartLists: true,
+      },
+      copyCode: {
+        buttonText: {
+          '/zh-cn/': '点击复制',
+          '/ru/'   : 'Скопировать в буфер обмена',
+          '/de-de/': 'Klicken Sie zum Kopieren',
+          '/es/'   : 'Haga clic para copiar',
+          '/'      : 'Copy to clipboard'
+        },
+        errorText: {
+          '/zh-cn/': '错误',
+          '/ru/'   : 'ошибка',
+          '/'      : 'Error'
+        },
+        successText: {
+          '/zh-cn/': '复制',
+          '/ru/'   : 'Скопировано',
+          '/de-de/': 'Kopiert',
+          '/es/'   : 'Copiado',
+          '/'      : 'Copied'
+        }
+      },
+      toc: {
+        scope: '.markdown-section',
+        headings: 'h1, h2',
+        title: 'Table of Contents',
+      },
       plugins: [
         function (hook, vm) {
           hook.beforeEach(function (html) {
@@ -78,9 +130,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
@@ -92,13 +144,16 @@
   <script src="//unpkg.com/docsify/lib/docsify.min.js"></script>
   <script src="//unpkg.com/docsify/lib/plugins/search.min.js"></script>
   <script src="//unpkg.com/docsify/lib/plugins/emoji.min.js"></script>
+  <script src="//unpkg.com/docsify-copy-code@2"></script>
+  <script src="//unpkg.com/docsify-toc@1.0.0/dist/toc.js"></script>
   <script src="//unpkg.com/prismjs/components/prism-bash.min.js"></script>
   <script src="//unpkg.com/prismjs/components/prism-c.min.js"></script>
   <script src="//unpkg.com/prismjs/components/prism-cpp.min.js"></script>
   <script src="//unpkg.com/prismjs/components/prism-json.min.js"></script>
   <script src="//unpkg.com/prismjs/components/prism-makefile.min.js"></script>
   <script>
-    // Register the offline cache worker
+    // Register the cache worker for offline viewing mode
+    // https://docsify.now.sh/pwa
     if (typeof navigator.serviceWorker !== 'undefined') {
       navigator.serviceWorker.register('sw.js')
     }

docs/isp_flashing_guide.md

@@ -1,6 +1,14 @@
 # ISP Flashing Guide
 
-If you're having trouble flashing/erasing your board, and running into cryptic error messages like any of the following:
+ISP flashing (also known as ICSP flashing) is the process of programming a microcontroller directly.  This allows you to replace the bootloader, or change the "fuses" on the controller, which control a number of hardware- and software-related functions, such as the speed of the controller, how it boots, and other options.  
+
+The main use of ISP flashing for QMK is flashing or replacing the bootloader on your AVR-based controller (Pro Micros, or V-USB chips).  
+
+?> This is only for programming AVR based boards, such as the Pro Micro or other ATmega controllers.  It is not for Arm controllers, such as the Proton C. 
+
+## Dealing with Corrupted Bootloaders
+
+If you're having trouble flashing/erasing your board, and running into cryptic error messages like any of the following for a DFU based controller:
 
     libusb: warning [darwin_transfer_status] transfer error: timed out
     dfu.c:844: -ETIMEDOUT: Transfer timed out, NAK 0xffffffc4 (-60)
@@ -19,16 +27,60 @@ If you're having trouble flashing/erasing your board, and running into cryptic e
     Memory write error, use debug for more info.
     commands.c:360: Error writing memory data. (err -4)
 
-You're likely going to need to ISP flash your board/device to get it working again. Luckily, this process is pretty straight-forward, provided you have any extra programmable keyboard, Pro Micro, or Teensy 2.0/Teensy 2.0++. There are also dedicated ISP flashers available for this, but most cost >$15, and it's assumed that if you are googling this error, this is the first you've heard about ISP flashing, and don't have one readily available (whereas you might have some other AVR board). __We'll be using a Teensy 2.0 or Pro Micro with Windows 10 in this guide__ - if you are comfortable doing this on another system, please consider editing this guide and contributing those instructions!   
+Or, if you see this sort of message for a Pro Micro based controller:
+
+    avrdude: butterfly_recv(): programmer is not responding
+    avrdude: butterfly_recv(): programmer is not responding
+    avrdude: verification error, first mismatch at byte 0x002a
+            0x2b != 0x75
+    avrdude: verification error; content mismatch
+    avrdude: verification error; content mismatch
+
+
+You're likely going to need to ISP flash your board/device to get it working again. 
+
+## Hardware Needed
+
+You'll need one of the following to actually perform the ISP flashing (followed by the protocol they use):
+
+* [SparkFun PocketAVR](https://www.sparkfun.com/products/9825) - (USB Tiny)
+* [USBtinyISP AVR Programmer Kit](https://www.adafruit.com/product/46) - (USB Tiny)
+* [Teensy 2.0](https://www.pjrc.com/store/teensy.html) - (avrisp)
+* [Pro Micro](https://www.sparkfun.com/products/12640)  - (avrisp)
+* [Bus Pirate](https://www.adafruit.com/product/237) - (buspirate)
+
+There are other devices that can be used to ISP flash, but these are the main ones.  Also, all product links are to the official versions. You can source them elsewhere. 
+
+You'll also need something to wire your "ISP Programmer" to the device that you're programming.  Some PCBs may have ISP headers that you can use directly, but this often isn't the case, so you'll likely need to solder to the controller itself or to different switches or other components. 
+
+### The ISP Firmware 
+
+The Teensy and Pro Micro controllers will need you to flash the ISP firmware to the controllers before you can use them as an ISP programmer.  The rest of the hardware should come preprogrammed.  So, for these controllers, download the correct hex file, and flash it first. 
+
+* Teensy 2.0: [`util/teensy_2.0_ISP_B0.hex`](https://github.com/qmk/qmk_firmware/blob/master/util/teensy_2.0_ISP_B0.hex) (`B0`)
+* Pro Micro: [`util/pro_micro_ISP_B6_10.hex`](https://github.com/qmk/qmk_firmware/blob/master/util/pro_micro_ISP_B6_10.hex) (`10/B6`)
+
+Once you've flashed your controller, you won't need this hex file anymore. 
 
 ## Software Needed
 
-* [Teensy Loader](https://www.pjrc.com/teensy/loader.html) (if using a Teensy)
-* QMK Toolbox (flash as usual - be sure to select the correct MCU) or `avrdude` via [WinAVR](http://www.ladyada.net/learn/avr/setup-win.html) (for Teensy & Pro Micro)
+The QMK Toolbox can be used for most (all) of this.  
+
+However, you can grab the [Teensy Loader](https://www.pjrc.com/teensy/loader.html) to flash your Teensy 2.0 board, if you are using that. Or you can use `avrdude` (installed as part of `qmk_install.sh`), or [AVRDUDESS](https://blog.zakkemble.net/avrdudess-a-gui-for-avrdude/) (for Windows) to flash the Pro Micro, and the ISP flashing. 
+
 
 ## Wiring
 
-This is pretty straight-forward - we'll be connecting like-things to like-things in the following manner:
+This is pretty straight-forward - we'll be connecting like-things to like-things in the following manner.
+
+### SparkFun Pocket AVR
+
+    PocketAVR RST  <-> Keyboard RESET
+    PocketAVR SCLK <-> Keyboard B1 (SCLK)
+    PocketAVR MOSI <-> Keyboard B2 (MOSI)
+    PocketAVR MISO <-> Keyboard B3 (MISO)
+    PocketAVR VCC  <-> Keyboard VCC
+    PocketAVR GND  <-> Keyboard GND
 
 ### Teensy 2.0
 
@@ -39,6 +91,8 @@ This is pretty straight-forward - we'll be connecting like-things to like-things
     Teensy VCC <-> Keyboard VCC
     Teensy GND <-> Keyboard GND
     
+!> Note that the B0 pin on the Teensy is wired to the RESET/RST pin on the keyboard's controller.  ***DO NOT*** wire the RESET pin on the Teensy to the RESET on the keyboard. 
+
 ### Pro Micro
 
     Pro Micro 10 (B6)  <-> Keyboard RESET
@@ -48,45 +102,61 @@ This is pretty straight-forward - we'll be connecting like-things to like-things
     Pro Micro VCC      <-> Keyboard VCC
     Pro Micro GND      <-> Keyboard GND
 
-## The ISP Firmware (now pre-compiled)
+!> Note that the 10/B6 pin on the Pro Micro is wired to the RESET/RST pin on the keyboard's controller.  ***DO NOT*** wire the RESET pin on the Pro Micro to the RESET on the keyboard. 
 
-The only difference between the .hex files below is which pin is connected to RESET. You can use them on other boards as well, as long as you're aware of the pins being used. If for some reason neither of these pins are available, [create an issue](https://github.com/qmk/qmk_firmware/issues/new), and we can generate one for you!
 
-* Teensy 2.0: [`util/teensy_2.0_ISP_B0.hex`](https://github.com/qmk/qmk_firmware/blob/master/util/teensy_2.0_ISP_B0.hex) (`B0`)
-* Pro Micro: [`util/pro_micro_ISP_B6_10.hex`](https://github.com/qmk/qmk_firmware/blob/master/util/pro_micro_ISP_B6_10.hex) (`B6/10`)
+## Flashing Your Keyboard 
 
-**Flash your Teenys/Pro Micro with one of these and continue - you won't need the file after flashing your ISP device.**
+After you have your ISP programmer set up, and wired to your keyboard, it's time to flash your keyboard.  
 
-## Just the Bootloader File
+### The Bootloader File
 
-If you just want to get things back to normal, you can flash only a bootloader from [`util/` folder](https://github.com/qmk/qmk_firmware/tree/master/util), and use your normal process to flash the firmware afterwards. Be sure to flash the correct bootloader for your chip:
+The simplest and quickest way to get things back to normal is to flash only a bootloader to the keyboard. Once this is done, you can connect the keyboard normally and flash the keyboard like you normally would. 
+
+You can find the stock bootloaders in the [`util/` folder](https://github.com/qmk/qmk_firmware/tree/master/util). Be sure to flash the correct bootloader for your chip:
 
 * [`atmega32u4`](https://github.com/qmk/qmk_firmware/blob/master/util/bootloader_atmega32u4_1_0_0.hex) - Most keyboards, Planck Rev 1-5, Preonic Rev 1-2
+* [`Pro Micro`](https://github.com/sparkfun/Arduino_Boards/blob/master/sparkfun/avr/bootloaders/caterina/Caterina-promicro16.hex) - The default bootloader for Pro Micro controllers
 * [`at90usb1286`](https://github.com/qmk/qmk_firmware/blob/master/util/bootloader_at90usb128x_1_0_1.hex) - Planck Light Rev 1
-* [`atmega32a`](https://github.com/qmk/qmk_firmware/blob/master/util/bootloader_atmega32a_1_0_0.hex) - jj40
+* [`atmega32a`](https://github.com/qmk/qmk_firmware/blob/master/util/bootloader_atmega32a_1_0_0.hex) - jj40, and other V-USB/ps2avrGB keyboards
 
 If you're not sure what your board uses, look in the `rules.mk` file for the keyboard in QMK. The `MCU =` line will have the value you need. It may differ between different versions of the board.
 
-### Advanced/Production Techniques
+### Production Techniques
 
-If you'd like to flash both the bootloader **and** the regular firmware at the same time, you need to combine the files. 
+If you'd like to flash both the bootloader **and** the regular firmware at the same time, there are two options to do so.  Manually, or with the `:production` target when compiling. 
+
+To do this manually: 
 
 1. Open the original firmware .hex file in a text editor
 2. Remove the last line (which should be `:00000001FF` - this is an EOF message)
 3. Copy the entire bootloader's contents onto a new line (with no empty lines between) and paste it at the end of the original file
 4. Save it as a new file by naming it `<keyboard>_<keymap>_production.hex`
 
-It's possible to use other bootloaders here in the same way, but __you need a bootloader__, otherwise you'll have to use ISP again to write new firmware to your keyboard.
+?> It's possible to use other bootloaders here in the same way, but __you need a bootloader__, otherwise you'll have to use ISP again to write new firmware to your keyboard.
+
+To do this the easy way, you can flash the board using the `:production` target when compiling.  This compiles the firmware, then compiles the QMK DFU bootloader, and then creates a combined image.  Once this is done, you'll see three files: 
+* `<keyboard>_<keymap>.hex`
+* `<keyboard>_<keymap>_bootloader.hex`
+* `<keyboard>_<keymap>_production.hex`
+
+The QMK DFU bootloader has only really been tested on `atmega32u4` controllers (such as the AVR based Planck boards, and the Pro Micro), and hasn't been tested on other controllers.  However, it will definitely not work on V-USB controllers, such as the `atmega32a` or `atmega328p`.
+
+You can flash either the bootloader or the production firmware file. The production firmware file will take a lot longer to flash, since it's flashing a lot more data. 
+
+?> Note: You should stay with the same bootloader. If you're using DFU already, switching to QMK DFU is fine. But flashing QMK DFU onto a Pro Micro, for instance, has additional steps needed.
 
 ## Flashing Your Bootloader/Production File
 
-Make sure your keyboard is unplugged from any device, and plug in your Teensy.
+Make sure your keyboard is unplugged from any device, and plug in your ISP Programmer.
+
+If you want to change bootloader types, You'll need to use the command line. 
 
 ### QMK Toolbox
 
-1. `AVRISP device connected` will show up in yellow
+1. `AVRISP device connected` or `USB Tiny device connected` will show up in yellow
 2. Select the correct bootloader/production .hex file with the `Open` dialog (spaces can't be in the path)
-3. Be sure the correct `Microcontroller` option is selected
+3. Be sure the correct `Microcontroller` option for the keyboard you're flashing (not the ISP programmer) is selected
 4. Hit `Flash`
 5. Wait, as nothing will output for a while, especially with production files
 
@@ -94,7 +164,7 @@ If the verification and fuse checks are ok, you're done! Your board may restart
 
 ### Command Line
 
-Open `cmd` and navigate to your where your modified .hex file is. We'll pretend this file is called `main.hex`, and that your Teensy 2.0 is on the `COM3` port - if you're unsure, you can open your Device Manager, and look for `Ports > USB Serial Device`. Use that COM port here. You can confirm it's the right port with:
+Open a terminal (`cmd` on Windows, for instance) and navigate to your where your modified .hex file is. We'll pretend this file is called `main.hex`, and that your Teensy 2.0 is on the `COM3` port - if you're unsure, you can open your Device Manager, and look for `Ports > USB Serial Device`. Use that COM port here. You can confirm it's the right port with:
 
     avrdude -c avrisp -P COM3 -p atmega32u4
 
@@ -129,4 +199,47 @@ You should see a couple of progress bars, then you should see:
 
 Which means everything should be ok! Your board may restart automatically, otherwise, unplug your Teensy and plug in your keyboard - you can leave your Teensy wired to your keyboard while testing things, but it's recommended that you desolder it/remove the wiring once you're sure everything works.
 
+If you're using a SparkFun PocketAVR Programmer, or another USB Tiny based ISP programmer, you will want to use something like this: 
+
+    avrdude -c usbtiny -P usb -p atmega32u4
+
+#### Advanced: Changing Fuses
+
+If you're switching bootloaders, such as flashing QMK DFU on a Pro Micro, you will need to change the fuses, in additional to flashing the bootloader hex file.  This is because `caterina` (the Pro Micro bootloader) and `dfu` handle the startup routines differently, and that behavior is controlled by the fuses.  
+
+!> This is one area that it is very important to be careful, as changing fuses is one of the ways that you can permanently brick your controller.  
+
+For this, we are assuming the 5V 16MHz versions of the `atmega32u4` (such as the 5V Pro Micro).
+
+For DFU on the `atmega32u4`, these are the fuse settings that you want: 
+
+| Fuse     | Setting          |
+|----------|------------------|
+| Low      | `0x5E`           |
+| High     | `0xD9` or `0x99` |
+| Extended | `0xC3`           |
+
+The High fuse can be 0xD9 or 0x99. The difference is that 0xD9 disables JTAG, which QMK Firmware disables via software as well, while 0x99 doesn't disable JTAG. 
+
+To set this add `-U lfuse:w:0x5E:m -U hfuse:w:0xD9:m -U efuse:w:0xC3:m` to your command.  So the final command should look something like: 
+
+    avrdude -c avrisp -P COM3 -p atmega32u4 -U flash:w:main.hex:i -U lfuse:w:0x5E:m -U hfuse:w:0xD9:m -U efuse:w:0xC3:m
+
+For Caterina on the `atmega32u4`, these are the fuse settings that you want: 
+
+| Fuse     | Setting|
+|----------|--------|
+| Low      | `0xFF` |
+| High     | `0xD9` |
+| Extended | `0xC3` |
+
+To set this add `-U lfuse:w:0xFF:m -U hfuse:w:0xD8:m -U efuse:w:0xC3:m` to your command.  So the final command should look something like: 
+
+    avrdude -c avrisp -P COM3 -p atmega32u4 -U flash:w:main.hex:i -U lfuse:w:0xFF:m -U hfuse:w:0xD8:m -U efuse:w:0xC3:m
+
+
+If you are using a different controller or want different configuration, you can use [this AVR Fuse Calculator](http://www.engbedded.com/fusecalc/) to find a better value for you.
+
+## Help 
+
 If you have any questions/problems, feel free to [open an issue](https://github.com/qmk/qmk_firmware/issues/new)!

docs/ja/README.md

@@ -2,7 +2,7 @@
 
 <!---
   original document: eae21eed7:docs/README.md
-  git diff eae21eed7 HEAD docs/README.md | cat
+  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)

docs/ja/_summary.md

@@ -3,36 +3,41 @@
    * [初めてのファームウェアの構築](ja/newbs_building_firmware.md)
    * [ファームウェアのフラッシュ](ja/newbs_flashing.md)
    * [テストとデバッグ](ja/newbs_testing_debugging.md)
-   * [Gitのベストプラクティス](ja/newbs_best_practices.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 の導入](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)
+   * [QMK への貢献](ja/contributing.md)
+   * [Github の使い方](ja/getting_started_github.md)
    * [ヘルプ](ja/getting_started_getting_help.md)
 
 * [破壊的な変更](ja/breaking_changes.md)
+   * [プルリクエストにフラグが付けられた](ja/breaking_changes_instructions.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)
+   * [一般的な 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)
+   * [Zadig を使ったドライバのインストール](ja/driver_installation_zadig.md)
 
 * 詳細なガイド
    * [ビルドツールのインストール](ja/getting_started_build_tools.md)
-   * [Vagrantのガイド](ja/getting_started_vagrant.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)
+   * [互換性のあるマイクロコントローラ](ja/compatible_microcontrollers.md)
    * [AVR プロセッサ](ja/hardware_avr.md)
    * [ドライバ](ja/hardware_drivers.md)
 
@@ -63,7 +68,7 @@
    * [ブートマジック](ja/feature_bootmagic.md)
    * [コンボ](ja/feature_combo.md)
    * [コマンド](ja/feature_command.md)
-   * [Debounce API](ja/feature_debounce_type.md)
+   * [デバウンス API](ja/feature_debounce_type.md)
    * [DIP スイッチ](ja/feature_dip_switch.md)
    * [動的マクロ](ja/feature_dynamic_macros.md)
    * [エンコーダ](ja/feature_encoders.md)
@@ -77,7 +82,7 @@
    * [マクロ](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)
+   * [One Shot Keys](ja/one_shot_keys.md)
    * [ポインティング デバイス](ja/feature_pointing_device.md)
    * [PS/2 マウス](ja/feature_ps2_mouse.md)
    * [RGB ライト](ja/feature_rgblight.md)
@@ -87,28 +92,32 @@
    * [Stenography](ja/feature_stenography.md)
    * [Swap Hands](ja/feature_swap_hands.md)
    * [タップ ダンス](ja/feature_tap_dance.md)
-   * [Terminal](ja/feature_terminal.md)
+   * [ターミナル](ja/feature_terminal.md)
    * [感熱式プリンタ](ja/feature_thermal_printer.md)
    * [ユニコード](ja/feature_unicode.md)
-   * [Userspace](ja/feature_userspace.md)
+   * [ユーザスペース](ja/feature_userspace.md)
    * [Velocikey](ja/feature_velocikey.md)
 
 * メーカーおよびモッダーのために
-   * [Hand Wiring Guide](ja/hand_wire.md)
-   * [ISP Flashing Guide](ja/isp_flashing_guide.md)
+   * [Hand Wiring ガイド](ja/hand_wire.md)
+   * [ISP 書き込みガイド](ja/isp_flashing_guide.md)
    * [ARM デバッグ ガイド](ja/arm_debugging.md)
+   * [ADC ドライバ](ja/adc_driver.md)
    * [I2C ドライバ](ja/i2c_driver.md)
+   * [WS2812 ドライバ](ja/ws2812_driver.md)
+   * [EEPROM ドライバ](ja/eeprom_driver.md)
    * [GPIO コントロール](ja/internals_gpio_control.md)
+   * [カスタムマトリックス](ja/custom_matrix.md)
    * [Proton C 規約](ja/proton_c_conversion.md)
 
 * より深く知るために
    * [キーボードがどのように動作するか](ja/how_keyboards_work.md)
-   * [QMKの理解](ja/understanding_qmk.md)
+   * [QMK の理解](ja/understanding_qmk.md)
 
 * 他の話題
-   * [EclipseでQMKを使用](ja/other_eclipse.md)
-   * [VSCodeでQMKを使用](ja/other_vscode.md)
-   * [サポート](ja/support.md)
+   * [Eclipse で QMK を使用](ja/other_eclipse.md)
+   * [VSCode で QMK を使用](ja/other_vscode.md)
+   * [サポート](ja/getting_started_getting_help.md)
    * [翻訳を追加する方法](ja/translating.md)
 
 * QMK の内部詳細(作成中)

docs/ja/arm_debugging.md

@@ -2,7 +2,7 @@
 
 <!---
   original document: eae21eed7:docs/arm_debugging.md
-  git diff eae21eed7 HEAD docs/arm_debugging.md | cat
+  git diff eae21eed7 HEAD -- docs/arm_debugging.md | cat
 -->
 
 このページでは、SWD アダプタとオープンソース/フリーツールを使って ARM MCU をデバッグするためのセットアップ方法について説明します。このガイドでは、GNU MCU Eclipse IDE for C/C++ Developers および OpenOCD を必要な依存関係と一緒にインストールします。
@@ -23,7 +23,7 @@ XPM のインストール手順は[ここ](https://www.npmjs.com/package/xpm)で
 
 ### ARM ツールチェーン
 
-XPM を使うと、ARM ツールチェーンをとても簡単にインストールできます。`xpm install --global @gnu-mcu-eclipse/arm-none-eabi-gcc` とコマンドを入力します。
+XPM を使うと、ARM ツールチェーンをとても簡単にインストールできます。`xpm install --global @xpack-dev-tools/arm-none-eabi-gcc` とコマンドを入力します。
 
 ### Windows ビルドツール
 
@@ -38,7 +38,7 @@ ST-Link を持っている場合は、ドライバは[ここ](https://www.st.com
 
 ### OpenOCD
 
-この依存関係により、SWD は GDB からアクセスでき、デバッグに不可欠です。`xpm install --global @gnu-mcu-eclipse/openocd` を実行します。
+この依存関係により、SWD は GDB からアクセスでき、デバッグに不可欠です。`xpm install --global @xpack-dev-tools/openocd` を実行します。
 
 ### Java
 
@@ -50,33 +50,33 @@ Java は Eclipse で必要とされるため、[ここ](https://www.oracle.com/t
 
 ## Eclipse の設定
 
-ダウンロードした Eclipse IDE を開きます。QMK ディレクトリをインポートするために、File -> Import -> C/C++ -> Existing code as Makefile Project を選択します。Next を選択し、Browse を使用して QMK フォルダを選択します。tool-chain リストから ARM Cross GCC を選択し、Finish を選択します。
+ダウンロードした 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 Toolchain Paths を選択します。xPack を押して OK を押します。OpenOCD Path で同じことを繰り返し、Windows の場合は、Build Tool Path でも同じことを繰り返します。Apply and Close を選択します。
+これで、左側に QMK フォルダが表示されます。右クリックして、Properties を選択します。左側で MCU を展開し、ARM Toolchains Paths を選択します。xPack を押して OK を押します。OpenOCD Path で同じことを繰り返し、Windows の場合は、Build Tools Path でも同じことを繰り返します。Apply and Close を選択します。
 
-ここで、必要な MCU パッケージをインストールします。Window -> Open Perspective -> Others -> Packs を選択して、Packs perspective に移動します。Packs タブの横にある黄色のリフレッシュ記号を選択します。これは様々な場所から MCU の定義を要求するため、時間が掛かります。一部のリンクが失敗した場合は、おそらく Ignore を選択できます。
+ここで、必要な MCU パッケージをインストールします。Window -> Perspective -> Open Perspective -> Other... -> Packs を選択して、Packs perspective に移動します。Packs タブの横にある黄色のリフレッシュ記号を選択します。これは様々な場所から MCU の定義を要求するため、時間が掛かります。一部のリンクが失敗した場合は、おそらく Ignore を選択できます。
 
-これが終了すると、ビルドやデバッグする MCU を見つけることができるはずです。この例では、STM32F3 シリーズの MCU を使います。左側で、STMicroelectronics -> STM32F3 Series を選択します。中央のウィンドウに、pack が表示されます。右クリックし、Install を選択します。それが終了したら、Window -> Open Perspective -> Others -> C/C++ を選択してデフォルトのパースペクティブに戻ることができます。
+これが終了すると、ビルドやデバッグする 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 です。
+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 を選択します。
+この間に、Build コマンドもセットアップしましょう。C/C++ Build を選択し、Behavior タブを選択します。build コマンドのところで、`all` を必要な make コマンドに置き換えます。例えば、rev6 Planck の default キーマップの場合、これは `planck/rev6:default` になります。Apply and Close を選択します。
 
 ## ビルド
 
-全て正しくセットアップできていれば、ハンマーボタンを押すとファームウェアがビルドされ、.binファイルが出力されるはずです。
+全て正しくセットアップできていれば、ハンマーボタンを押すとファームウェアがビルドされ、.bin ファイルが出力されるはずです。
 
 ## デバッグ
 
 ### デバッガの接続
 
-ARM MCU は、クロック信号(SWCLK) とデータ信号(SWDIO) で構成される Single Wire Debug (SWD) プロトコルを使います。MCUを 完全に操作するには、この2本のワイヤとグラウンドを接続するだけで十分です。ここでは、キーボードは USB を介して電力が供給されると想定しています。手動でリセットボタンを使えるため、RESET 信号は必要ありません。より高度なセットアップのために printf と scanf をホストに非同期にパイプする SWO 信号を使用できますが、私たちのセットアップでは無視します。
+ARM MCU は、クロック信号(SWCLK) とデータ信号(SWDIO) で構成される Single Wire Debug (SWD) プロトコルを使います。MCU を 完全に操作するには、この2本のワイヤとグラウンドを接続するだけで十分です。ここでは、キーボードは USB を介して電力が供給されると想定しています。手動でリセットボタンを使えるため、RESET 信号は必要ありません。より高度なセットアップのために printf と scanf をホストに非同期にパイプする SWO 信号を使用できますが、私たちのセットアップでは無視します。
 
 注意: SWCLK と SWDIO ピンがキーボードのマトリックスで使われていないことを確認してください。もし使われている場合は、一時的に他のピンに切り替えることができます。
 
 ### デバッガの設定
 
-QMK フォルダを右クリックし、Debug As -> Debug Configuration を選択します。ここで、GDB OpenOCD Debugging をダブルクリックします。Debugger タブを選択し、MCU に必要な設定を入力します。これを見つけるにはいじったりググったりする必要があるかもしれません。STM32F3 用のデフォルトスクリプトは stm32f3discovery.cfg と呼ばれます。OpenOCD に伝えるには、Config options で `-f board/stm32f3discovery.cfg` と入力します。
+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` に編集しました。
 
@@ -86,7 +86,7 @@ Apply and Close を選択します。
 
 キーボードをリセットしてください。
 
-虫アイコンをクリックし、もし全てうまく行けば debug パースペクティブに移動します。ここでは、main 関数の最初でプログラムカウンタが停止するので、Play ボタンを押します。全てのデバッガのほとんどの機能は ARM MCU で動作しますが、正確な詳細については google があなたのお友達です！
+虫アイコンをクリックし、もし全てうまく行けば Debug パースペクティブに移動します。ここでは、main 関数の最初でプログラムカウンタが停止するので、Play ボタンを押します。全てのデバッガのほとんどの機能は ARM MCU で動作しますが、正確な詳細については google があなたのお友達です！
 
 
 ハッピーデバッギング！

docs/ja/cli.md

@@ -0,0 +1,298 @@
+# QMK CLI
+
+<!---
+  original document: 79e6b7866:docs/cli.md
+  git diff 79e6b7866 HEAD -- docs/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>
+```
+
+**キーボードディレクトリでの使い方**:  
+
+default キーマップのあるキーボードディレクトリ、キーボードのキーマップディレクトリ、`--keymap <keymap_name>` で与えられるキーマップディレクトリにいなければなりません。
+```
+qmk compile
+```
+
+**例**:
+```
+$ qmk config compile.keymap=default
+$ cd ~/qmk_firmware/keyboards/planck/rev6
+$ qmk compile
+Ψ Compiling keymap with make planck/rev6:default
+...
+```
+あるいはオプションのキーマップ引数を指定して
+
+```
+$ cd ~/qmk_firmware/keyboards/clueboard/66/rev4
+$ qmk compile -km 66_iso
+Ψ Compiling keymap with make clueboard/66/rev4:66_iso
+...
+```
+あるいはキーマップディレクトリで
+
+```
+$ cd ~/qmk_firmware/keyboards/gh60/satan/keymaps/colemak
+$ qmk compile
+Ψ Compiling keymap with make make gh60/satan:colemak
+...
+```
+
+**レイアウトディレクトリでの使い方**:  
+
+`qmk_firmware/layouts/` 以下のキーマップディレクトリにいなければなりません。
+```
+qmk compile -kb <keyboard_name>
+```
+
+**例**:
+```
+$ cd ~/qmk_firmware/layouts/community/60_ansi/mechmerlin-ansi
+$ qmk compile -kb dz60
+Ψ Compiling keymap with make dz60:mechmerlin-ansi
+...
+```
+
+## `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 [-y] [-n]
+```
+
+**例**:
+
+環境に問題がないか確認し、それらを修正するよう促します:
+
+    qmk doctor
+
+環境を確認し、見つかった問題を自動的に修正します:
+
+    qmk doctor -y
+
+環境を確認し、問題のみをレポートします:
+
+    qmk doctor -n
+
+## `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 list-keymaps`
+
+このコマンドは指定されたキーボード(とリビジョン)の全てのキーマップをリスト化します。
+
+**使用法**:
+
+```
+qmk list-keymaps -kb planck/ez
+```
+
+## `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:docs/cli_configuration.md
+  git diff d598f01cb HEAD -- docs/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

@@ -1,8 +1,8 @@
 # QMK の設定
 
 <!---
-  original document: eae21eed7:docs/config_options.md
-  git diff eae21eed7 HEAD docs/config_options.md | cat
+  original document: 2fe288d01:docs/config_options.md
+  git diff 2fe288d01 HEAD -- docs/config_options.md | cat
 -->
 
 QMK はほぼ無制限に設定可能です。可能なところはいかなるところでも、やりすぎな程、ユーザーがコードサイズを犠牲にしてでも彼らのキーボードをカスタマイズをすることを許しています。ただし、このレベルの柔軟性により設定が困難になります。
@@ -83,7 +83,7 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
 * `#define BACKLIGHT_PIN B7`
    * バックライトのピン
 * `#define BACKLIGHT_LEVELS 3`
-   * バックライトのレベル数 (off を除いて最大15)
+   * バックライトのレベル数 (off を除いて最大31)
 * `#define BACKLIGHT_BREATHING`
    * バックライトのブレスを有効にします
 * `#define BREATHING_PERIOD 6`
@@ -148,10 +148,14 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
 * `#define IGNORE_MOD_TAP_INTERRUPT`
    * 両方のキーに `TAPPING_TERM` を適用することで、ホールド時に他のキーに変換するキーを使ってローリングコンボ (zx) をすることができるようにします
    * 詳細は [Mod tap interrupt](ja/feature_advanced_keycodes.md#ignore-mod-tap-interrupt) を見てください
+* `#define IGNORE_MOD_TAP_INTERRUPT_PER_KEY`
+   * キーごとの `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 TAPPING_FORCE_HOLD_PER_KEY`
+   * キーごとの `TAPPING_FORCE_HOLD` 設定処理を有効にします。
 * `#define LEADER_TIMEOUT 300`
    * リーダーキーがタイムアウトするまでの時間
       * タイムアウトする前にシーケンスを終了できない場合は、タイムアウトの設定を増やす必要があるかもしれません。あるいは、`LEADER_PER_KEY_TIMING` オプションを有効にすると良いでしょう。これは各キーがタップされた後でタイムアウトを再設定します。
@@ -185,7 +189,7 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
 * `#define RGBLIGHT_SPLIT`
    * 分割キーボードの左半分の RGB LED の出力を右半分の RGB LED の入力につなげるかわりに、それぞれの側で個別にコントローラの出力ピンが直接 RGB LED の入力に繋がっているときは、この定義が必要です。
 * `#define RGBLED_SPLIT { 6, 6 }`
-   * 分割キーボードの各半分の `RGB_DI_PIN` に直接配線されている接続されているLEDの数
+   * 分割キーボードの各半分の `RGB_DI_PIN` に直接配線されている接続されている LED の数
    * 最初の値は左半分の LED の数を示し、2番目の値は右半分です。
    * RGBLED_SPLIT が定義されている場合、RGBLIGHT_SPLIT は暗黙的に定義されます。
 * `#define RGBLIGHT_HUE_STEP 12`
@@ -214,7 +218,7 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
 
 ### 左右の設定
 
-一つ覚えておかなければならないことは、USB ポートが接続されている側が常にマスター側であるということです。USB に接続されていない側はスレーブです。
+1つ覚えておかなければならないことは、USB ポートが接続されている側が常にマスター側であるということです。USB に接続されていない側はスレーブです。
 
 分割キーボードの左右を設定するには、幾つかの異なる方法があります (優先度の順にリストされています):
 
@@ -258,7 +262,7 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
 * `#define SELECT_SOFT_SERIAL_SPEED <speed>` (デフォルトの速度は1です)
    * serial 通信を使う時のプロトコルの速度を設定します。
    * 速度:
-      * 0: 約189kbps (実験目的のみ)
+      * 0: 約 189kbps (実験目的のみ)
       * 1: 約 137kbps (デフォルト)
       * 2: 約 75kbps
       * 3: 約 39kbps
@@ -270,9 +274,12 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
    * ARM についてはデフォルトの挙動
    * AVR Teensy については必須
 
-* `#define SPLIT_USB_TIMEOUT 2500`
+* `#define SPLIT_USB_TIMEOUT 2000`
    * `SPLIT_USB_DETECT` を使う時のマスタ/スレーブを検出する場合の最大タイムアウト
 
+* `#define SPLIT_USB_TIMEOUT_POLL 10`
+   * `SPLIT_USB_DETECT` を使う時のマスタ/スレーブを検出する場合のポーリング頻度
+
 # `rules.mk` ファイル
 
 これは、トップレベルの `Makefile` から include される [make](https://www.gnu.org/software/make/manual/make.html) ファイルです。これは特定の機能を有効または無効にするだけでなく、コンパイルする MCU に関する情報を設定するために使われます。
@@ -285,8 +292,26 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
    * ビルドの後でルート `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`
@@ -345,9 +370,6 @@ QMK での全ての利用可能な設定にはデフォルトがあります。
    * キーボードが起動する前に、USB 接続が確立されるのをキーボードに待機させます
 * `NO_USB_STARTUP_CHECK`
    * キーボードの起動後の usb サスペンドチェックを無効にします。通常、キーボードはタスクが実行される前にホストがウェイク アップするのを待ちます。分割キーボードは半分はウェイクアップコールを取得できませんが、マスタにコマンドを送信する必要があるため、役に立ちます。
-* `LINK_TIME_OPTIMIZATION_ENABLE`
-   * キーボードをコンパイルする時に、Link Time Optimization (`LTO`) を有効にします。これは処理に時間が掛かりますが、コンパイルされたサイズを大幅に減らします (そして、ファームウェアが小さいため、追加の時間は分からないくらいです)。ただし、`LTO` が有効な場合、古いマクロと関数の機能が壊れるため、自動的にこれらの機能を無効にします。これは `NO_ACTION_MACRO` と `NO_ACTION_FUNCTION` を自動的に定義することで行われます。
-   * `LINK_TIME_OPTIMIZATION_ENABLE` の代わりに `LTO_ENABLE` を使うことができます。
 
 ## USB エンドポイントの制限
 

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/custom_quantum_functions.md

@@ -0,0 +1,518 @@
+# キーボードの挙動をカスタマイズする方法
+
+<!---
+  original document: 7494490d6:docs/custom_quantum_functions.md
+  git diff 7494490d6 HEAD -- docs/custom_quantum_functions.md | cat
+-->
+
+多くの人にとって、カスタムキーボードはボタンの押下をコンピュータに送信するだけではありません。単純なボタンの押下やマクロよりも複雑なことを実行できるようにしたいでしょう。QMK にはコードを挿入したり、機能を上書きしたり、様々な状況でキーボードの挙動をカスタマイズできるフックがあります。
+
+このページでは、QMK に関する特別な知識は想定していませんが、[QMK の理解](ja/understanding_qmk.md)を読むとより根本的なレベルで何が起きているかを理解するのに役立ちます。
+
+## コア、キーボード、キーマップ階層 :id=a-word-on-core-vs-keyboards-vs-keymap
+
+私たちは QMK を階層として構造化しました:
+
+* コア (`_quantum`)
+   * キーボード/リビジョン (`_kb`)
+      * キーマップ (`_user`)
+
+以下で説明される各関数は `_kb()` サフィックスあるいは `_user()` サフィックスを使って定義することができます。`_kb()` サフィックスはキーボード/リビジョンレベルで使うことを意図しており、一方で `_user()` サフィックスはキーマップレベルで使われるべきです。
+
+キーボード/リビジョンレベルで関数を定義する場合、`_kb()` は他の何かを実行する前に `_user()` を呼び出すよう実装することが重要です。そうでなければ、キーマップレベル関数は呼ばれないでしょう。
+
+# カスタムキーコード
+
+最も一般的なタスクは、既存のキーコードの挙動を変更するか、新しいキーコードを作成することです。コードの観点からは、それぞれの仕組みは非常に似ています。
+
+## 新しいキーコードの定義
+
+独自のカスタムキーコードを作成する最初のステップは、それらを列挙することです。これは、カスタムキーコードに名前を付け、そのキーコードにユニークな番号を割り当てることの両方を意味します。QMK は、カスタムキーコードを固定範囲の番号に制限するのではなく、`SAFE_RANGE` マクロを提供します。カスタムキーコードを列挙する時に `SAFE_RANGE` を使うと、ユニークな番号を取得することが保証されます。
+
+
+これは2つのキーコードを列挙する例です。このブロックを `keymap.c` に追加した後で、キーマップの中で `FOO` と `BAR` を使うことができます。
+
+```c
+enum my_keycodes {
+  FOO = SAFE_RANGE,
+  BAR
+};
+```
+
+## 任意のキーコードの挙動のプログラミング
+
+既存のキーの挙動を上書きしたい場合、あるいは新しいキーについて挙動を定義する場合、`process_record_kb()` および `process_record_user()` 関数を使うべきです。これらは実際のキーイベントが処理される前のキー処理中に QMK によって呼び出されます。これらの関数が `true` を返す場合、QMK はキーコードを通常通りに処理します。これは、キーを置き換えるのではなく、キーの機能を拡張するのに便利です。これらの関数が `false` を返す場合、QMK は通常のキー処理をスキップし、必要なキーのアップまたはダウンイベントを送信するのかはユーザ次第です。
+
+これらの関数はキーが押されるか放されるたびに呼び出されます。
+
+### `process_record_user()` の実装例
+
+この例は2つの事を行います。`FOO` と呼ばれるカスタムキーコードの挙動を定義し、Enter キーが押されるたびに音を再生します。
+
+```c
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case FOO:
+      if (record->event.pressed) {
+        // 押された時に何かをします
+      } else {
+        // 放された時に何かをします
+      }
+      return false; // このキーの以降の処理をスキップします
+    case KC_ENTER:
+      // enter が押された時に音を再生します
+      if (record->event.pressed) {
+        PLAY_NOTE_ARRAY(tone_qwerty);
+      }
+      return true; // QMK に enter のプレスまたはリリースイベントを送信させます
+    default:
+      return true; // 他の全てのキーコードを通常通りに処理します
+  }
+}
+```
+
+### `process_record_*` 関数のドキュメント
+
+* キーボード/リビジョン: `bool process_record_kb(uint16_t keycode, keyrecord_t *record)`
+* キーマップ: `bool process_record_user(uint16_t keycode, keyrecord_t *record)`
+
+`keycode` 引数はキーマップで定義されているものです。例えば `MO(1)`、`KC_L` など。これらのイベントを処理するには `switch...case` ブロックを使うべきです。
+
+`record` 引数は実際のプレスに関する情報を含みます:
+
+```c
+keyrecord_t record {
+  keyevent_t event {
+    keypos_t key {
+      uint8_t col
+      uint8_t row
+    }
+    bool     pressed
+    uint16_t time
+  }
+}
+```
+
+# LED 制御
+
+QMK は HID 仕様で定義された5つの LED の読み取りメソッドを提供します:
+
+* Num Lock
+* Caps Lock
+* Scroll Lock
+* Compose
+* Kana
+
+ロック LED の状態を取得するには2つの方法があります:
+
+* `bool led_update_kb(led_t led_state)` あるいは `_user(led_t led_state)` を実装する、または
+* `led_t host_keyboard_led_state()` を呼び出す
+
+!> `host_keyboard_led_state()` は `led_update_user()` が呼ばれる前に新しい値を既に反映している場合があります。
+
+LED の状態を `uint8_t` として提供する2つの非推奨の関数があります:
+
+* `uint8_t led_set_kb(uint8_t usb_led)` と `_user(uint8_t usb_led)`
+* `uint8_t host_keyboard_leds()`
+
+## `led_update_user()`
+
+この関数はこれら5つの LED のいずれかの状態が変化すると呼ばれます。LED の状態を構造体のパラメータとして受け取ります。
+
+慣例により、`led_update_kb()` にそのコードを実行するようフックさせるために `led_update_user()` から `true` を返し、`led_update_kb()` でコードを実行したくない場合は `false` を返します。
+
+以下はいくつかの例です:
+
+- レイヤー表示のような何かのために LED を使うために LED を上書きする
+   - `_kb()` 関数を実行したくないので、`false`  を返します。これはレイヤーの挙動を上書きするためです。
+- LED がオンあるいはオフになった時に音楽を再生する。
+   - `_kb` 関数を実行したいので、`true` を返します。これはデフォルトの LED の挙動に追加されます。
+
+?> `led_set_*` 関数は `bool` の代わりに `void` を返すため、キーボードの LED 制御を上書きすることができません。従って、代わりに `led_update_*` を使うことをお勧めします。
+
+### `led_update_kb()` の実装例
+
+```c
+bool led_update_kb(led_t led_state) {
+    bool res = led_update_user(led_state);
+    if(res) {
+        // writePin は 1 でピンを high に、0 で low に設定します。
+        // この例では、ピンは反転していて、
+        // low/0 は LED がオンになり、high/1 は LED がオフになります。
+        // この挙動は、LED がピンと VCC の間にあるか、ピンと 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_update_user()` の実装例
+
+この不完全な例は Caps Lock がオンまたはオフになった場合に音を再生します。また LED の状態を保持する必要があるため、`true` を返します。
+
+```c
+#ifdef AUDIO_ENABLE
+  float caps_on[][2] = SONG(CAPS_LOCK_ON_SOUND);
+  float caps_off[][2] = SONG(CAPS_LOCK_OFF_SOUND);
+#endif
+
+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_*` 関数のドキュメント
+
+* キーボード/リビジョン: `bool led_update_kb(led_t led_state)`
+* キーマップ: `bool led_update_user(led_t led_state)`
+
+## `host_keyboard_led_state()`
+
+最後に受信した LED の状態を `led_t` として取得するためにこの関数を呼びます。これは、`led_update_*` の外部から、例えば [`matrix_scan_user()`](#matrix-scanning-code) の中で LED の状態を読み取るのに便利です。
+
+## 物理的な LED の状態の設定
+
+一部のキーボードの実装は、物理的な LED の状態を設定するための便利なメソッドを提供しています。
+
+### Ergodox キーボード
+
+Ergodox の実装は、個々の LED をオンあるいはオフにするために `ergodox_right_led_1`/`2`/`3_on`/`off()` と、インデックスによってそれらをオンあるいはオフにするために `ergodox_right_led_on`/`off(uint8_t led)` を提供します。
+
+さらに、LED の明度を指定することができます。全ての LED に同じ明度を指定するなら `ergodox_led_all_set(uint8_t n)` を使い、個別の LED の明度を指定するなら `ergodox_right_led_1`/`2`/`3_set(uint8_t n)` を使い、LED のインデックスを指定して明度を指定するには  `ergodox_right_led_set(uint8_t led, uint8_t n)` を使います。
+
+Ergodox キーボードは、最低の明度として `LED_BRIGHTNESS_LO` を、最高の輝度(これはデフォルトです)として `LED_BRIGHTNESS_HI` も定義しています。
+
+# キーボードの初期化コード
+
+キーボードの初期化プロセスには幾つかのステップがあります。何をしたいかによって、どの関数を使うべきかに影響します。
+
+3つの主な初期化関数があり、呼び出される順番にリストされています。
+
+* `keyboard_pre_init_*` - ほとんどのものが開始される前に起こります。非常に早くに実行したいハードウェアのセットアップに適しています。
+* `matrix_init_*` - ファームウェアのスタートアッププロセスの途中で起こります。ハードウェアは初期化されますが、機能はまだ初期化されていない場合があります。
+* `keyboard_post_init_*` - ファームウェアのスタートアッププロセスの最後に起こります。これはほとんどの場合、 "カスタマイズ"コードを配置する場所です。
+
+!> ほとんどの人にとって、`keyboard_post_init_user` が呼び出したいものです。例えば、ここで RGB アンダーグローのセットアップを行います。
+
+## キーボードの事前初期化コード
+
+これは USB さえ起動する前の、起動中の非常に早い段階で実行されます。
+
+この直後にマトリックスが初期化されます。
+
+これは主にハードウェア向きの初期化のためであるため、ほとんどのユーザは使うべきではありません。
+
+ただし、初期化が必要なハードウェアがある場合には、これが最適な場所です (LED ピンの初期化など)。
+
+### `keyboard_pre_init_user()` の実装例
+
+この例は、キーボードレベルで、LED ピンとして B0、B1、B2、B3 および B4 をセットアップします。
+
+```c
+void keyboard_pre_init_user(void) {
+  // キーボードの事前初期コードを呼び出します。
+
+  // LED ピンを出力として設定します
+  setPinOutput(B0);
+  setPinOutput(B1);
+  setPinOutput(B2);
+  setPinOutput(B3);
+  setPinOutput(B4);
+}
+```
+
+### `keyboard_pre_init_*` 関数のドキュメント
+
+* キーボード/リビジョン: `void keyboard_pre_init_kb(void)`
+* キーマップ: `void keyboard_pre_init_user(void)`
+
+## マトリックスの初期化コード
+
+これは、マトリックスが初期化され、ハードウェアの一部がセットアップされた後で、ただし機能の多くが初期化される前に、呼び出されます。
+
+他の場所で必要になるかもしれないものをセットアップするのに役立ちますが、ハードウェアに関連するものではなく、開始場所に依存するものでもありません。
+
+
+### `matrix_init_*` 関数のドキュメント
+
+* キーボード/リビジョン: `void matrix_init_kb(void)`
+* キーマップ: `void matrix_init_user(void)`
+
+
+## キーボードの事後初期化コード
+
+キーボードの初期化プロセスの極めて最後のタスクとして実行されます。この時点で初期化される必要があるような、特定の機能を変更したい場合に便利です。
+
+
+### `keyboard_post_init_user()` の実装例
+
+この例は、他の全てのものが初期化された後で実行され、rgb アンダーグローの設定をセットアップします。
+
+```c
+void keyboard_post_init_user(void) {
+  // post init コードを呼びます
+  rgblight_enable_noeeprom(); // 設定を保存せずに Rgb を有効にします
+  rgblight_sethsv_noeeprom(180, 255, 255); // 保存せずに色を青緑/シアンに設定します
+  rgblight_mode_noeeprom(RGBLIGHT_MODE_BREATHING + 3); // 保存せずにモードを高速なブリージングに設定します
+}
+```
+
+### `keyboard_post_init_*` 関数のドキュメント
+
+* キーボード/リビジョン: `void keyboard_post_init_kb(void)`
+* キーマップ: `void keyboard_post_init_user(void)`
+
+# マトリックススキャンコード :id=matrix-scanning-code
+
+可能であれば常に `process_record_*()` を使ってキーボードをカスタマイズし、その方法でイベントをフックし、コードがキーボードのパフォーマンスに悪影響を与えないようにします。ただし、まれにマトリックススキャンにフックする必要があります。これらの関数は1秒あたり少なくとも10回は呼び出されるため、これらの関数のコードのパフォーマンスに非常に注意してください。
+
+### `matrix_scan_*` の実装例
+
+この例は意図的に省略されています。このようなパフォーマンスに敏感な領域にフックする前に、例を使わずにこれを書くために、QMK 内部について十分理解する必要があります。助けが必要であれば、[issue を開く](https://github.com/qmk/qmk_firmware/issues/new) か [Discord で会話](https://discord.gg/Uq7gcHh)してください。
+
+### `matrix_scan_*` 関数のドキュメント
+
+* キーボード/リビジョン: `void matrix_scan_kb(void)`
+* キーマップ: `void matrix_scan_user(void)`
+
+この関数はマトリックススキャンのたびに呼び出されます。これは基本的に MCU が処理できる頻度です。大量に実行されるため、ここに何を置くかについては注意してください。
+
+カスタムマトリックススキャンコードが必要な場合は、この関数を使う必要があります。また、カスタムステータス出力 (LED あるいはディスプレイなど)や、ユーザが入力していない場合でも定期的にトリガーするその他の機能のために使うことができます。
+
+
+# キーボードアイドリング/ウェイクコード
+
+キーボードがサポートしている場合、多くの機能を停止することで"アイドル"にすることができます。これの良い例は、RGB ライトあるいはバックライトです。これにより、電力消費を節約できるか、キーボードの動作が改善されるかもしれません。
+
+これは2つの関数によって制御されます: `suspend_power_down_*` および `suspend_wakeup_init_*`。これらはシステムキーボードがアイドルになった時と、起動した時のそれぞれで呼ばれます。
+
+
+### suspend_power_down_user() と suspend_wakeup_init_user() の実装例
+
+
+```c
+void suspend_power_down_user(void) {
+    rgb_matrix_set_suspend_state(true);
+}
+
+void suspend_wakeup_init_user(void) {
+    rgb_matrix_set_suspend_state(false);
+}
+```
+
+### キーボードサスペンド/ウェイク関数のドキュメント
+
+* キーボード/リビジョン : `void suspend_power_down_kb(void)` および `void suspend_wakeup_init_user(void)`
+* キーマップ: `void suspend_power_down_kb(void)` および `void suspend_wakeup_init_user(void)`
+
+# レイヤー切り替えコード
+
+これはレイヤーが切り替えられるたびにコードを実行します。レイヤー表示あるいはカスタムレイヤー処理に役立ちます。
+
+### `layer_state_set_*` の実装例
+
+この例は、レイヤーに基づいて [RGB アンダーグロー](ja/feature_rgblight.md)を設定する方法を示していて、Planck を例として使っています。
+
+```c
+layer_state_t layer_state_set_user(layer_state_t state) {
+    switch (get_highest_layer(state)) {
+    case _RAISE:
+        rgblight_setrgb (0x00,  0x00, 0xFF);
+        break;
+    case _LOWER:
+        rgblight_setrgb (0xFF,  0x00, 0x00);
+        break;
+    case _PLOVER:
+        rgblight_setrgb (0x00,  0xFF, 0x00);
+        break;
+    case _ADJUST:
+        rgblight_setrgb (0x7A,  0x00, 0xFF);
+        break;
+    default: //  他の全てのレイヤーあるいはデフォルトのレイヤー
+        rgblight_setrgb (0x00,  0xFF, 0xFF);
+        break;
+    }
+  return state;
+}
+```
+### `layer_state_set_*` 関数のドキュメント
+
+* キーボード/リビジョン: `layer_state_t layer_state_set_kb(layer_state_t state)`
+* キーマップ: `layer_state_t layer_state_set_user(layer_state_t state)`
+
+
+[キーマップの概要](ja/keymap.md#keymap-layer-status)で説明されるように、`state` はアクティブなレイヤーのビットマスクです。
+
+
+# 永続的な設定 (EEPROM)
+
+これによりキーボードのための永続的な設定を設定することができます。これらの設定はコントローラの EEPROM に保存され、電源が落ちた後であっても保持されます。設定は `eeconfig_read_kb` および `eeconfig_read_user` を使って読み取ることができ、`eeconfig_update_kb` および `eeconfig_update_user` を使って書きこむことができます。これは切り替え可能な機能 (rgb レイヤーの表示の切り替えなど)に役立ちます。さらに、`eeconfig_init_kb` および `eeconfig_init_user` を使って EEPROM のデフォルト値を設定できます。
+
+ここでの複雑な部分は、EEPROM を介してデータを保存およびアクセスできる方法がたくさんあり、これを行うための"正しい"方法が無いということです。ただし、各関数には DWORD (4 バイト)しかありません。
+
+EEPROM の書き込み回数には制限があることに注意してください。これは非常に高い値ですが、EEPROM に書き込むのはこれだけではなく、もし頻繁に書き込むと、MCU の寿命を大幅に短くする可能性があります。
+
+* この例を理解していない場合は、この機能はかなり複雑なため、この機能を使うことを避けても構いません。
+
+### 実装例
+
+これは、設定を追加し、読み書きする例です。この例では、ユーザキーマップを使っています。これは複雑な機能で、多くのことが行われています。実際、動作のために上記の多くの関数を使います！
+
+
+keymap.c ファイルの中で、先頭にこれを追加します:
+```c
+typedef union {
+  uint32_t raw;
+  struct {
+    bool     rgb_layer_change :1;
+  };
+} user_config_t;
+
+user_config_t user_config;
+```
+
+これは、設定をメモリ内に保存し、EEPROM に書き込むことができる32ビット構造体をセットアップします。これを使うと、この構造体に変数が定義されるため、変数を定義する必要が無くなります。`bool` (boolean) の値は1ビットを使い、`uint8_t` は8ビットを使い、`uint16_t` は16ビットを使うことに注意してください。組み合わせて使うことができますが、順番の変更は読み書きされる値が変更されるため、問題が発生するかもしれません。
+
+`layer_state_set_*` 関数のために `rgb_layer_change` を使い、全てを設定するために `keyboard_post_init_user` および `process_record_user` を使います。
+
+ここで、上の `keyboard_post_init_user` コードを使って、作成したばかりの構造体を設定するために `eeconfig_read_user()` を追加します。そして、この構造体をすぐに使ってキーマップの機能を制御することができます。それは以下のようになります:
+```c
+void keyboard_post_init_user(void) {
+  // キーマップレベルのマトリックスの初期化処理を呼びます
+
+  // EEPROM からユーザ設定を読み込みます
+  user_config.raw = eeconfig_read_user();
+
+  // 有効な場合はデフォルトレイヤーを設定します
+  if (user_config.rgb_layer_change) {
+    rgblight_enable_noeeprom();
+    rgblight_sethsv_noeeprom_cyan();
+    rgblight_mode_noeeprom(1);
+  }
+}
+```
+上記の関数は読み取ったばかりの EEPROM 設定を使い、デフォルトのレイヤーの RGB 色を設定します。その「生の」値は、上で作成した「共用体」に基づいて使用可能な構造に変換されます。
+
+```c
+layer_state_t layer_state_set_user(layer_state_t state) {
+    switch (get_highest_layer(state)) {
+    case _RAISE:
+        if (user_config.rgb_layer_change) { rgblight_sethsv_noeeprom_magenta(); rgblight_mode_noeeprom(1); }
+        break;
+    case _LOWER:
+        if (user_config.rgb_layer_change) { rgblight_sethsv_noeeprom_red(); rgblight_mode_noeeprom(1); }
+        break;
+    case _PLOVER:
+        if (user_config.rgb_layer_change) { rgblight_sethsv_noeeprom_green(); rgblight_mode_noeeprom(1); }
+        break;
+    case _ADJUST:
+        if (user_config.rgb_layer_change) { rgblight_sethsv_noeeprom_white(); rgblight_mode_noeeprom(1); }
+        break;
+    default: //  他の全てのレイヤーあるいはデフォルトのレイヤー
+        if (user_config.rgb_layer_change) { rgblight_sethsv_noeeprom_cyan(); rgblight_mode_noeeprom(1); }
+        break;
+    }
+  return state;
+}
+```
+これにより、値が有効になっていた場合のみ、RGB アンダーグローが変更されます。この値を設定するために、`RGB_LYR` と呼ばれる `process_record_user` 用の新しいキーコードを作成します。さらに、通常の RGB コードを使う場合、上記の例を使ってオフになることを確認します。以下のようになります:
+```c
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case FOO:
+      if (record->event.pressed) {
+        // 押された時に何かをします
+      } else {
+        // 放された時に何かをします
+      }
+      return false; // このキーの以降の処理をスキップします
+    case KC_ENTER:
+        // enter が押された時に音を再生します
+        if (record->event.pressed) {
+            PLAY_NOTE_ARRAY(tone_qwerty);
+        }
+        return true; // QMK に enter のプレスまたはリリースイベントを送信させます
+    case RGB_LYR:  // これにより、アンダーグローをレイヤー表示として、あるいは通常通りに使うことができます。
+        if (record->event.pressed) {
+            user_config.rgb_layer_change ^= 1; // 状態を切り替えます
+            eeconfig_update_user(user_config.raw); // 新しい状態を EEPROM に書き込みます
+            if (user_config.rgb_layer_change) { // レイヤーの状態表示が有効な場合
+                layer_state_set(layer_state);   // すぐにレイヤーの色を更新します
+            }
+        }
+        return false; break;
+    case RGB_MODE_FORWARD ... RGB_MODE_GRADIENT: // 任意の RGB コード に対して(quantum_keycodes.h を見てください。400行目参照)
+        if (record->event.pressed) { // これはレイヤー表示を無効にします。これを変更する場合は、無効にしたいだろうため。
+            if (user_config.rgb_layer_change) {        // 有効な場合のみ
+                user_config.rgb_layer_change = false;  // 無効にします
+                eeconfig_update_user(user_config.raw); // 設定を EEPROM に書き込みます
+            }
+        }
+        return true; break;
+    default:
+      return true; // 他の全てのキーコードを通常通りに処理します
+  }
+}
+```
+最後に、`eeconfig_init_user` 関数を追加して、EEPROM がリセットされた時にデフォルト値、さらにはカスタムアクションを指定できるようにします。EEPROM を強制的にリセットするには、`EEP_RST` キーコードあるいは[ブートマジック](ja/feature_bootmagic.md)機能を使います。例えば、デフォルトで rgb レイヤー表示を設定し、デフォルト値を保存したい場合。
+
+```c
+void eeconfig_init_user(void) {  // EEPROM がリセットされます！
+  user_config.raw = 0;
+  user_config.rgb_layer_change = true; // デフォルトでこれを有効にします
+  eeconfig_update_user(user_config.raw); // デフォルト値を EEPROM に書き込みます
+
+  // これらの値も EEPROM に書き込むためには、noeeprom 以外のバージョンを使います
+  rgblight_enable(); // デフォルトで RGB を有効にします
+  rgblight_sethsv_cyan();  // デフォルトでシアンに設定します
+  rgblight_mode(1); // デフォルトでソリッドに設定します
+}
+```
+
+これで完了です。RGB レイヤー表示は必要な場合にのみ機能します。キーボードを取り外した後でも保存されます。RGB コードのいずれかを使うと、レイヤー表示が無効になり、設定したモードと色がそのままになります。
+
+### 'EECONFIG' 関数のドキュメント
+
+* キーボード/リビジョン: `void eeconfig_init_kb(void)`、`uint32_t eeconfig_read_kb(void)` および `void eeconfig_update_kb(uint32_t val)`
+* キーマップ: `void eeconfig_init_user(void)`、`uint32_t eeconfig_read_user(void)` および `void eeconfig_update_user(uint32_t val)`
+
+`val` は EEPROM に書き込みたいデータの値です。`eeconfig_read_*` 関数は EEPROM から32ビット(DWORD) 値を返します。
+
+# カスタムタッピング期間
+
+デフォルトでは、タッピング期間はグローバルに設定されていて、キーでは設定することができません。ほとんどのユーザにとって、これは全然問題ありません。しかし、場合によっては、`LT` キーとは異なるタイムアウトによって、デュアルファンクションキーが大幅に改善されます。なぜなら、一部のキーは他のキーよりも押し続けやすいためです。それぞれにカスタムキーコードを使う代わりに、キーごとに設定可能な `TAPPING_TERM` を使用できます。
+
+この機能を有効にするには、最初に `config.h` に `#define TAPPING_TERM_PER_KEY` を追加する必要があります。
+
+
+## `get_tapping_term` の実装例
+
+キーコードに基づいて `TAPPING TERM` を変更するには、次のようなものを `keymap.c` ファイルに追加します:
+
+```c
+uint16_t get_tapping_term(uint16_t keycode) {
+  switch (keycode) {
+    case SFT_T(KC_SPC):
+      return TAPPING_TERM + 1250;
+    case LT(1, KC_GRV):
+      return 130;
+    default:
+      return TAPPING_TERM;
+  }
+}
+```
+
+### `get_tapping_term` 関数のドキュメント
+
+ここにある他の多くの関数とは異なり、quantum あるいはキーボードレベルの関数を持つ必要はありません (または理由さえありません)。ここではユーザレベルの関数だけが有用なため、そのようにマークする必要はありません。

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)

docs/ja/faq_build.md

@@ -0,0 +1,160 @@
+# よくあるビルドの質問
+
+<!---
+  original document: 0f43c2652:docs/faq_build.md
+  git diff 0f43c2652 HEAD -- docs/faq_build.md | cat
+-->
+
+このページは QMK のビルドに関する質問を説明します。まだビルドをしていない場合は、[ビルド環境のセットアップ](ja/getting_started_build_tools.md) および [Make 手順](ja/getting_started_make_guide.md)ガイドを読むべきです。
+
+## Linux でプログラムできません
+デバイスを操作するには適切な権限が必要です。Linux ユーザの場合は、以下の `udev` ルールに関する指示を見てください。`udev` に問題がある場合は、回避策は `sudo` コマンドを使うことです。このコマンドに慣れていない場合は、`man sudo` コマンドでマニュアルを確認するか、[この web ページを見てください](https://linux.die.net/man/8/sudo)。
+
+コントローラが ATMega32u4 の場合の `sudo` の使い方の例:
+
+    $ sudo dfu-programmer atmega32u4 erase --force
+    $ sudo dfu-programmer atmega32u4 flash your.hex
+    $ sudo dfu-programmer atmega32u4 reset
+
+あるいは、単純に:
+
+    $ sudo make <keyboard>:<keymap>:dfu
+
+`make` を `sudo` で実行することは一般的には良い考えでは***なく***、可能であれば前者の方法のいずれかを使うべきです。
+
+### Linux の `udev` ルール
+Linux では、MCU にアクセスするには適切な権限が必要です。ファームウェアを書き込む時に `sudo` を使うか、`/etc/udev/rules.d/` にこれらのファイルを配置することで、アクセスすることができます。権限の追加が完了したら、以下を実行します:
+```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-caterina.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"
+```
+
+**注意:** ModemManager フィルタリングは厳格モードでは無い場合のみ動作します。以下のコマンドでその設定を変更することができます:
+```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"
+```
+
+**/etc/udev/rules.d/57-bootloadhid.rules:**
+```
+# bootloadHID
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="05df", MODE:="0666"
+```
+
+### Linux のブートローダモードで Serial デバイスが検知されない
+カーネルがデバイスを適切にサポートしていることを確認してください。デバイスが、Pro Micro (Atmega32u4) のように USB ACM を使う場合、`CONFIG_USB_ACM=y` を含めるようにしてください。他のデバイスは `USB_SERIAL` およびそのサブオプションを必要とするかもしれません。
+
+## DFU ブートローダの不明なデバイス
+
+Windows 上でキーボードを書き込む時に発生する問題は、ブートローダ用に間違ったドライバがインストールされているか、全くインストールされていないかによるものがほとんどです。
+
+QMK インストールスクリプト (MSYS2 あるいは WSL 内の `qmk_firmware` ディレクトリから `./util/qmk_install.sh`) を再実行するか、QMK Toolbox の再インストールでこの問題が解決するかもしれません。別のやり方として、手動で [`qmk_driver_installer`](https://github.com/qmk/qmk_driver_installer) パッケージをダウンロードして実行することができます。
+
+それでもうまく行かない場合は、Zadig をダウンロードして実行する必要があります。詳細な情報は [Zadig を使ったブートローダドライバのインストール](ja/driver_installation_zadig.md)を見てください。
+
+## USB VID と PID
+`config.h` を編集することで任意の ID を使うことができます。おそらく未使用の ID を使っても、他の製品と衝突するとても低い可能性があることを除いて、実際には問題はありません。
+
+QMK のほとんどのキーボードは、vendor ID として、`0xFEED` を使います。他のキーボードを調べて、ユニークな ID を選択してください。
+
+またこれも見てください。
+https://github.com/tmk/tmk_keyboard/issues/150
+
+ここで本当にユニークな VID:PID を買うことができます。個人的な使用にはこれは必要ないと思います。
+- 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
+
+## AVR のための BOOTLOADER_SIZE
+Teensy2.0++ ブートローダのサイズは 2048 バイトであることに注意してください。一部の Makefile には間違ったコメントがあります。
+
+```
+# 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
+```
+
+## MacOS での `avr-gcc: internal compiler error: Abort trap: 6 (program cc1)` 
+これは brew での更新に関する問題で、avr-gcc が依存するシンボリックリンクを壊します。
+
+解決法は全ての影響を受けたモジュールを削除し再インストールすることです。
+
+```
+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@8
+brew install dfu-programmer
+brew install dfu-util
+brew install arm-gcc-bin@8
+brew install avrdude
+brew link --force avr-gcc@8
+brew link --force arm-gcc-bin@8
+```
+
+### `avr-gcc` と LUFA
+
+`avr-gcc` を更新し、LUFA に関連するエラーが表示された場合、例えば:
+
+`lib/lufa/LUFA/Drivers/USB/Class/Device/AudioClassDevice.h:380:5: error: 'const' attribute on function returning 'void'`
+
+今のところ、Homebrew で `avr-gcc` を 8 にロールバックする必要があります。
+
+```
+brew uninstall --force avr-gcc
+brew install avr-gcc@8
+brew link --force avr-gcc@8
+```
+
+### キーボードに書き込んだが何も起こらない、あるいはキーの押下が登録されない - ARM (rev6 planck、clueboard 60、hs60v2 など) でも同じ (Feb 2019)
+ARM ベースのチップ上での EEPROM の動作によって、保存された設定が無効になる場合があります。これはデフォルトレイヤに影響し、まだ調査中の特定の環境下でキーボードが使えなくなる*しれません*。EEPROM のリセットでこれが修正されます。
+
+[Planck rev6 reset EEPROM](https://cdn.discordapp.com/attachments/473506116718952450/539284620861243409/planck_rev6_default.bin) を使って eeprom のリセットを強制することができます。このイメージを書き込んだ後で、通常のファームウェアを書き込むと、キーボードが_通常_ の動作順序に復元されます。
+[Preonic rev3 reset EEPROM](https://cdn.discordapp.com/attachments/473506116718952450/537849497313738762/preonic_rev3_default.bin)
+
+いずれかの形式でブートマジックが有効になっている場合は、これも実行できるはずです (実行方法の詳細については、[ブートマジックドキュメント](feature_bootmagic.md)とキーボード情報を見てください)。

docs/ja/faq_debug.md

@@ -0,0 +1,161 @@
+# デバッグの FAQ
+
+<!---
+  original document: 376419a4f:docs/faq_debug.md
+  git diff 376419a4f HEAD -- docs/faq_debug.md | cat
+-->
+
+このページは、キーボードのトラブルシューティングについての様々な一般的な質問を説明します。
+
+# デバッグコンソール
+
+## `hid_listen` がデバイスを認識できない
+デバイスのデバッグコンソールの準備ができていない場合、以下のように表示されます:
+
+```
+Waiting for device:.........
+```
+
+デバイスが接続されると、*hid_listen* がデバイスを見つけ、以下のメッセージが表示されます:
+
+```
+Waiting for new device:.........................
+Listening:
+```
+
+この 'Listening:' のメッセージが表示されない場合は、[Makefile] を `CONSOLE_ENABLE=yes` に設定してビルドしてみてください
+
+Linux のような OS でデバイスにアクセスするには、権限が必要かもしれません。
+- `sudo hid_listen` を試してください
+
+## コンソールにメッセージが表示されない
+以下を調べてください:
+- *hid_listen* がデバイスを検出する。上記を見てください。
+- **Magic**+d を使ってデバッグを有効にする。[マジックコマンド](https://github.com/tmk/tmk_keyboard#magic-commands)を見てください。
+- `debug_enable=true` を設定します。[テストとデバッグ](ja/newbs_testing_debugging.md#debugging)を見てください
+- デバッグ print の代わりに 'print' 関数を使ってみてください。**common/print.h** を見てください。
+- コンソール機能を持つ他のデバイスを切断します。[Issue #97](https://github.com/tmk/tmk_keyboard/issues/97) を見てください。
+
+## Linux あるいは UNIX のようなシステムはスーパーユーザ権限を必要とします
+権限付きで *hid_listen* を実行するために 'sudo' を使ってください。
+```
+$ sudo hid_listen
+```
+
+または rules ディレクトリにファイルを置いて、TMK デバイスのための *udev rule* を追加します。ディレクトリは各システムで異なるかもしれません。
+
+File: /etc/udev/rules.d/52-tmk-keyboard.rules (Ubuntu の場合)
+```
+# tmk keyboard products     https://github.com/tmk/tmk_keyboard
+SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
+```
+
+***
+
+# 雑多なこと
+## 安全性の考慮
+
+あなたはおそらくキーボードを「文鎮化」したくないでしょう。文鎮化するとファームウェアを書き換えられないようになります。リスクがあまりに高い(そしてそうでないかもしれない)ものの一部のリストを示します。
+
+- キーボードマップに RESET が含まれない場合、DFU モードに入るには、PCB のリセットボタンを押す必要があります。底部のネジを外す必要があります。
+- tmk_core / common にあるファイルを触るとキーボードが操作不能になるかもしれません。
+- .hex ファイルが大きすぎると問題を引き起こします; `make dfu` コマンドはブロックを削除し、
+サイズを検査し(おっと、間違った順序です！)、エラーを出力し、
+キーボードへの書き込みに失敗し、DFU モードのままになります。
+   - この目的のためには、Planck の最大の .hex ファイルサイズは 7000h (10進数で28672)であることに注意してください。
+
+```
+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
+```
+
+- 上のファイルのサイズは 22396/577ch で、28672/7000h より小さいです
+- 適切な替わりの .hex ファイルがある限り、それをロードして再試行することができます
+- あなたがキーボードの Makefile で指定したかもしれない一部のオプションは、余分なメモリを消費します; BOOTMAGIC_ENABLE、MOUSEKEY_ENABLE、EXTRAKEY_ENABLE、CONSOLE_ENABLE、API_SYSEX_ENABLE に注意してください
+- DFU ツールは(オプションの余計なフルーツサラダを投げ込まない限り)ブートローダに書き込むことを許可しないので、
+ここにはリスクはほとんどありません。
+- EEPROM の書き込みサイクルは、約100000です。ファームウェアを繰り返し継続的に書き換えるべきではありません。それは最終的に EEPROM を焼き焦がします。
+
+## NKRO が動作しません
+最初に、**Makefile** 内でビルドオプション `NKRO_ENABLE` を使ってファームウェアをコンパイルする必要があります。
+
+**NKRO** がまだ動作しない場合は、`Magic` **N** コマンド(デフォルトでは `LShift+RShift+N`)を試してみてください。**NKRO** モードと **6KRO** モード間を一時的に切り替えるためにこのコマンドを使うことができます。**NKRO** が機能しない状況、特に BIOS の場合は **6KRO** モードに切り替える必要があります。
+
+ファームウェアを `BOOTMAGIC_ENABLE` でビルドした場合、`ブートマジック` **N** コマンドで切り替える必要があります (デフォルトでは `Space+N`)。この設定は EEPROM に格納され、電源を入れ直しても保持されます。
+
+https://github.com/tmk/tmk_keyboard#boot-magic-configuration---virtual-dip-switch
+
+
+## TrackPoint はリセット回路が必要です (PS/2 マウスサポート)
+リセット回路が無いとハードウェアの不適切な初期化のために一貫性の無い結果になります。TPM754 の回路図を見てください。
+
+- http://geekhack.org/index.php?topic=50176.msg1127447#msg1127447
+- http://www.mikrocontroller.net/attachment/52583/tpm754.pdf
+
+
+## 16 を超えるマトリックの列を読み込めない
+列が 16 を超える場合、[matrix.h] の `read_cols()` 内の `1<<16` の代わりに `1UL<<16` を使ってください。
+
+C では、AVR の場合 `1` は [16 bit] である [int] 型の1を意味し、15 を超えて左にシフトすることはできません。`1<<16` すると予期しないゼロが発生します。`1UL` として [unsigned long] 型を使う必要があります。
+
+http://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
+
+## 特別なエクストラキーが動作しない (システム、オーディオコントロールキー)
+QMK でそれらを使うには、`rules.mk` 内で `EXTRAKEY_ENABLE` を定義する必要があります。
+
+```
+EXTRAKEY_ENABLE = yes          # オーディオ制御とシステム制御
+```
+
+## スリープから復帰しない
+
+Windows では、**デバイスマネージャ**の**電源の管理**タブ内の `このデバイスで、コンピュータのスタンバイ状態を解除できるようにする` 設定を調べてください。また BIOS 設定も調べてください。
+
+スリープ中に任意のキーを押すとホストが起動するはずです。
+
+## Arduino を使っていますか？
+
+**Arduino のピンの命名は実際のチップと異なることに注意してください。** 例えば、Arduino のピン `D0` は `PD0` ではありません。回路図を自身で確認してください。
+
+- http://arduino.cc/en/uploads/Main/arduino-leonardo-schematic_3b.pdf
+- http://arduino.cc/en/uploads/Main/arduino-micro-schematic.pdf
+
+Arduino の Leonardo と micro には **ATMega32U4** が載っていて、TMK 用に使うことができますが、Arduino のブートローダが問題になることがあります。
+
+## JTAG を有効にする
+
+デフォルトでは、キーボードが起動するとすぐに JTAG デバッグインタフェースが無効になります。JTAG 対応 MCU は `JTAGEN` ヒューズが設定された状態で出荷されており、キーボードがスイッチマトリックス、LED などに使用している可能性のある MCU の特定のピンを乗っ取ります。
+
+JTAG を有効にしたままにしたい場合は、単に以下のものを `config.h` に追加します:
+
+```c
+#define NO_JTAG_DISABLE
+```
+
+## USB 3 の互換性
+USB 3 ポートで問題がある人がいると聞きました。USB 2 ポートを試してください。
+
+
+## Mac の互換性
+### OS X 10.11 と Hub
+https://geekhack.org/index.php?topic=14290.msg1884034#msg1884034
+
+
+## リジューム (スリープとウェークアップ)/電源サイクルの問題
+一部の人がキーボードが BIOS で動作しなくなった、またはリジューム(電源サイクル)の後で動作しなくなったと報告しました。
+
+今のところ、この問題の根本は明確ではないですが、幾つかのビルドオプションが関係しているようです。Makefileで、`CONSOLE_ENABLE`、`NKRO_ENABLE`、`SLEEP_LED_ENABLE` あるいは他のオプションを無効にしてみてください。
+
+https://github.com/tmk/tmk_keyboard/issues/266
+https://geekhack.org/index.php?topic=41989.msg1967778#msg1967778
+
+
+
+## FLIP が動作しない
+### `AtLibUsbDfu.dll` が見つかりません
+デバイスマネージャから現在のドライバを削除し、FLIP が提供するものを再インストールします。
+http://imgur.com/a/bnwzy

docs/ja/faq_general.md

@@ -0,0 +1,20 @@
+# よくある質問
+
+<!---
+  original document: d598f01cb:docs/faq_general.md
+  git diff d598f01cb HEAD -- docs/faq_general.md | cat
+-->
+
+## QMK とは何か？
+
+Quantum Mechanical Keyboard の略である [QMK](https://github.com/qmk) は、カスタムキーボードのためのツールをビルドしている人々のグループです。[TMK](https://github.com/tmk/tmk_keyboard) の大幅に修正されたフォークである [QMK ファームウェア](https://github.com/qmk/qmk_firmware)から始まりました。
+
+## QMK と TMK の違いは何か？
+
+TMK は [Jun Wako](https://github.com/tmk) によって設計され実装されました。QMK は [Jack Humbert](https://github.com/jackhumbert) の Planck 用 TMK のフォークとして始まりました。しばらくして、Jack のフォークは TMK からかなり分岐し、2015年に Jack はフォークを QMK に名前を変えることにしました。
+
+技術的な観点から、QMK は幾つかの新しい機能を追加した TMK に基づいています。最も注目すべきことは、QMK は利用可能なキーコードの数を増やし、`S()`、`LCTL()` および `MO()` などの高度な機能を実装するためにこれらを使っています。[キーコード](keycodes.md)でこれらのキーコードの完全なリストを見ることができます。
+
+プロジェクトとコミュニティの管理の観点から、TMK は公式にサポートされている全てのキーボードを自分で管理しており、コミュニティのサポートも少し受けています。他のキーボード用に別個のコミュニティが維持するフォークが存在するか、作成できます。デフォルトでは少数のキーマップのみが提供されるため、ユーザは一般的にお互いにキーマップを共有しません。QMK は集中管理されたリポジトリを介して、キーボードとキーマップの両方を共有することを奨励しており、品質基準に準拠する全てのプルリクエストを受け付けます。これらはほとんどコミュニティで管理されますが、必要な場合は QMK チームも支援します。
+
+どちらのアプローチもメリットとデメリットがあり、理に適う場合は TMK と QMK の間でコードは自由にやり取りされます。

docs/ja/faq_keymap.md

@@ -0,0 +1,149 @@
+# キーマップの FAQ
+
+<!---
+  original document: 376419a4f:docs/faq_keymap.md
+  git diff 376419a4f HEAD -- docs/faq_keymap.md | cat
+-->
+
+このページは人々がキーマップについてしばしば持つ疑問について説明します。まだ読んだことが無い場合には、[キーマップの概要](ja/keymap.md)を最初に読むべきです。
+
+## どのキーコードを使えますか？
+あなたが利用可能なキーコードのインデックスについては、[キーコード](ja/keycodes.md)を見てください。より広範なドキュメントがある場合は、そこからリンクしてあります。
+
+キーコードは実際には [common/keycode.h](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/keycode.h) で定義されています。
+
+## デフォルトのキーコードとは何か？
+
+世界中で使用されている ANSI、ISO および JIS の3つの標準キーボードがあります。北米では主に ANSI が使われ、ヨーロッパおよびアフリカでは主に ISO が使われ、日本では JIS が使われます。言及されていない地域では、ANSI あるいは ISO が使われています。これらのレイアウトに対応するキーコードは以下の通りです:
+
+<!-- Source for this image: http://www.keyboard-layout-editor.com/#/gists/bf431647d1001cff5eff20ae55621e9a -->
+![キーボードのレイアウトイメージ](https://i.imgur.com/5wsh5wM.png)
+
+## 一部のキーが入れ替わっているか、または動作しない
+
+QMK には2つの機能、ブートマジックとコマンドがあり、これによりその場でキーボードの動作を変更することができます。これには Ctrl/Caps の交換、Gui の無効化、Alt/GUI の交換、Backspace/Backslash の交換、全てのキーの無効化およびその他の動作の変更が含まれますが、これらに限定されません。
+
+迅速な解決策として、キーボードを接続している時に `Space`+`Backspace` を押してみてください。これはキーボードに保存されている設定をリセットし、これらのキーを通常の操作に戻します。うまく行かない場合は、以下を見てください:
+
+* [ブートマジック](ja/feature_bootmagic.md)
+* [コマンド](ja/feature_command.md)
+
+## メニューキーが動作しない
+
+ほとんどの最近のキーボードにある、`KC_RGUI` と `KC_RCTL` の間にあるキーは、実際には `KC_APP` と呼ばれます。これは、そのキーが発明された時に、関連する標準にすでに `MENU` という名前のキーが存在していたため、MS はそれを `APP` キーと呼ぶことを選択したためです。
+
+## `KC_SYSREQ` が動作しません
+`KC_SYSREQ` の代わりに、Print Screen(`KC_PSCREEN` あるいは `KC_PSCR`) のキーコードを使ってください。'Alt + Print Screen' のキーの組み合わせは、'システムリクエスト' と認識されます。
+
+[issue #168](https://github.com/tmk/tmk_keyboard/issues/168) と以下を見てください
+* http://en.wikipedia.org/wiki/Magic_SysRq_key
+* http://en.wikipedia.org/wiki/System_request
+
+## 電源キーが動作しません
+
+やや紛らわしいことに、QMK には2つの "Power" キーコードがあります: キーボード/キーパッド HID usage page では `KC_POWER`、Consumer page では `KC_SYSTEM_POWER` (あるいは `KC_PWR`)。
+
+前者は macOS でのみ認識されますが、後者 `KC_SLEP` および `KC_WAKE` は3つの主要なオペレーティングシステム全てでサポートされるため、これらを使うことをお勧めします。Windows ではこれらのキーはすぐに機能しますが、macOS ではそれらはダイアログが表示されるまで押し続ける必要があります。
+
+## ワンショットモディファイア
+私の個人的な 'the' の問題を解決します。'The' ではなく 'the' あるいは 'THe' を間違って入力することがありました。ワンショットシフトはこれを軽減します。
+https://github.com/tmk/tmk_keyboard/issues/67
+
+## モディファイヤ/レイヤスタック
+修飾キーあるいはレイヤは、レイヤの切り替えが適切に設定されていない場合、スタックするかもしれません。
+修飾キーおよびレイヤ切り替えの場合、リリースイベント時に修飾キーの登録を解除する、もしくは前のレイヤに戻るために、目的のレイヤの同じ位置に `KC_TRANS` を配置する必要があります。
+
+* 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
+
+
+## メカニカルロックスイッチのサポート
+
+この機能は [Alps](http://deskthority.net/wiki/Alps_SKCL_Lock) のような*メカニカルロックスイッチ*用です。以下を `config.h` に追加することで有効にすることができます:
+
+```
+#define LOCKING_SUPPORT_ENABLE
+#define LOCKING_RESYNC_ENABLE
+```
+
+この機能を有効にした後で、キーマップでキーコード `KC_LCAP`、`KC_LNUM` および `KC_LSCR` を使います。
+
+古いビンテージメカニカルキーボードにはロックスイッチが付いている場合がありますが、最新のものにはありません。***ほとんどの場合この機能は必要なく、単にキーコード `KC_CAPS`、`KC_NLCK` および `KC_SLCK`*** を使います。
+
+## セディーユ 'Ç' のような ASCII 以外の特別文字の入力
+
+[ユニコード](ja/feature_unicode.md) 機能を見てください。
+
+## macOS での `Fn` キー
+
+ほとんどの Fn キーと異なり、Apple のキーボードの Fn キーには実際には独自のキーコードのようなものがあります。基本的な 6KRO HID レポートの6番目のキーコードの代わりになります -- つまり、Apple キーボードは実際には 5KRO のみです。
+
+QMK にこのキーを送信させることは技術的に可能です。ただし、そうするには Fn キーの状態を追加するためにレポート形式の修正を必要とします。 
+さらに悪いことに、キーボードの VID と PID が実際の Apple のキーボードのものと一致しない限り、認識されません。公式の QMK がこの機能をサポートすることで法的な問題が起きるため、サポートされることはないでしょう。
+
+詳細については、[この issue](https://github.com/qmk/qmk_firmware/issues/2179) を見てください。
+
+## Mac OSX でサポートされるキーは？
+このソースコードから、どのキーコードが OSX でサポートされるかを知ることができます。
+
+`usb_2_adb_keymap` 配列は、キーボード/キーパッドページの Page usages を ADB スキャンコード(OSX 内部キーコード)にマップします。
+
+https://opensource.apple.com/source/IOHIDFamily/IOHIDFamily-606.1.7/IOHIDFamily/Cosmo_USB2ADB.c
+
+`IOHIDConsumer::dispatchConsumerEvent` は Consumer page usages を処理します。
+
+https://opensource.apple.com/source/IOHIDFamily/IOHIDFamily-606.1.7/IOHIDFamily/IOHIDConsumer.cpp
+
+
+## Mac OSX での JIS キー
+`無変換(Muhenkan)`, `変換(Henkan)`, `ひらがな(hiragana)` のような日本語 JIS キーボード固有のキーは OSX では認識されません。**Seil** を使ってこれらのキーを使うことができます。以下のオプションを試してください。
+
+* PC キーボードで NFER キーを有効にする
+* PC キーボードで XFER キーを有効にする
+* PC キーボードで KATAKANA キーを有効にする
+
+https://pqrs.org/osx/karabiner/seil.html
+
+
+## RN-42 Bluetooth が Karabiner で動作しない
+Karabiner - Mac OSX 上のキーマッピングツール - は、デフォルトでは RN-42 モジュールからの入力を無視します。Karabiner をキーボードで動作させるにはこのオプションを有効にする必要があります。
+https://github.com/tekezo/Karabiner/issues/403#issuecomment-102559237
+
+この問題の詳細についてはこれらを見てください。
+https://github.com/tmk/tmk_keyboard/issues/213
+https://github.com/tekezo/Karabiner/issues/403
+
+
+## 単一のキーでの Esc と<code>&#96;</code>
+
+[Grave Escape](feature_grave_esc.md) 機能を見てください。
+
+## Mac OSX での Eject
+`KC_EJCT` キーコードは OSX で動作します。https://github.com/tmk/tmk_keyboard/issues/250
+Windows 10 はコードを無視し、Linux/Xorg は認識しますが、デフォルトではマッピングがありません。
+
+実際の Apple キーボードにある Eject キーコードは実際には分かりません。HHKB は Mac モードでは Eject キー (`Fn+f`) に `F20` を使いますが、これはおそらく Apple の Eject キーコードと同じではありません。
+
+
+## `action_util.c` の `weak_mods` と `real_mods` は何か
+___改善されるべきです___
+
+real_mods は実際の物理的な修飾キーの状態を保持することを目的にしていますが、weak_mods は実際の修飾キーの状態に影響しない仮想あるいは一時的なモディファイアの状態を保持します。
+
+物理的な左シフトキーを押しながら ACTION_MODS_KEY(LSHIFT, KC_A) を入力するとします
+
+weak_mods では、
+* (1) 左シフトキーを押し続ける: real_mods |= MOD_BIT(LSHIFT)
+* (2) ACTION_MODS_KEY(LSHIFT, KC_A) を押す: weak_mods |= MOD_BIT(LSHIFT)
+* (3) ACTION_MODS_KEY(LSHIFT, KC_A) を放す: weak_mods &= ~MOD_BIT(LSHIFT)
+real_mods はモディファイアの状態を維持します。
+
+weak mods 無しでは、
+* (1) 左シフトキーを押し続ける: real_mods |= MOD_BIT(LSHIFT)
+* (2) ACTION_MODS_KEY(LSHIFT, KC_A) を押す: real_mods |= MOD_BIT(LSHIFT)
+* (3) ACTION_MODS_KEY(LSHIFT, KC_A) を放す: real_mods &= ~MOD_BIT(LSHIFT)
+ここで、real_mods は 'physical left shift' '物理的な左シフト' の状態を見失います。
+
+キーボードレポートが送信される時、weak_mods は real_mods と論理和がとられます。
+https://github.com/tmk/tmk_core/blob/master/common/action_util.c#L57

docs/ja/feature_tap_dance.md

@@ -0,0 +1,547 @@
+# タップダンス: 1つのキーが3つ、5つまたは100の異なる動作をします
+
+<!---
+  original document: 634b277b0:docs/feature_tap_dance.md
+  git diff 634b277b0 HEAD -- docs//feature_tap_dance.md | cat
+--> 
+
+## イントロダクション
+
+セミコロンキーを1回叩くと、セミコロンが送信されます。2回素早く叩くと、コロンが送信されます。3回叩くと、あなたのキーボードのLEDが激しく踊るように明滅します。これは、タップダンスでできることの一例です。それは、コミュニティが提案したとても素敵なファームウェアの機能の1つで、[algernon](https://github.com/algernon) がプルリクエスト [#451](https://github.com/qmk/qmk_firmware/pull/451) で考えて作ったものです。algernon が述べる機能は次の通りです:
+
+この機能を使うと、特定のキーが、タップした回数に基づいて異なる振る舞いをします。そして、割り込みがあった時は、割り込み前に上手く処理されます。
+
+## `ACTION_FUNCTION_TAP` との比較について
+
+`ACTION_FUNCTION_TAP` はタップダンスに似た機能を提供しますが、注目すべきいくつかの重要な違いがあります。違いを確認するため、いくつかの設定を調べてみましょう。1つのキーを1回タップすると `Space` キーが送信され、2回タップすると `Enter` キーが送信されるよう設定します。
+
+`ACTION_FUNCTION_TAP` では、これを設定するのはかなり大変で、キーの順番が割り込まれた時に割り込んだキーが最初に送られるという問題に直面します。例えば、`SPC a` は、もし `SPC` と `a` が `TAPPING_TERM` で設定した時間内に両方とも入力された場合、結果として `a SPC` が送信されます。タップダンス機能を使う場合、正しく `SPC a` が送信されます（`TAPPING_TERM` で設定した時間内に `SPC` と `a` を入力した場合であっても）。
+
+割り込みを正しくハンドリングして目的を達成するため、タップダンスの実装ではシステムの2つの部分をフックします: `process_record_quantum()` とマトリックススキャンです。この2つの部分については以下で説明しますが、今注意すべき点は、マトリックススキャンでは、キーが押されていない時でもタップのシーケンスをタイムアウトにできる必要があるということです。そうすれば、`TAPPING_TERM` の時間が経過した後、`SPC` だけがタイムアウトになって登録されます。
+
+## タップダンスの使い方
+
+一般論は十分です。タップダンスの実際の使い方を見てみましょう！
+
+最初に、あなたの `rules.mk` ファイルで `TAP_DANCE_ENABLE=yes` と設定する必要があります。なぜならば、デフォルトでは無効になっているからです。これでファームウェアのサイズが1キロバイトほど増加します。
+
+オプションで、あなたの `config.h` ファイルに次のような設定を追加して、`TAPPING_TERM` の時間をカスタマイズしたほうが良いです。
+
+```
+#define TAPPING_TERM 175
+```
+
+`TAPPING_TERM` の時間は、あなたのタップダンスのキーのタップとタップの間の時間として許可された最大の時間で、ミリ秒単位で計測されます。例えば、もし、あなたがこの上にある `#define` ステートメントを使い、1回タップすると `Space` が送信され、2回タップすると `Enter` が送信されるタップダンスキーをセットアップした場合、175ミリ秒以内に2回キーをタップすれば `ENT` だけが送信されるでしょう。もし、1回タップしてから175ミリ秒以上待ってからもう一度タップすると、`SPC SPC` が送信されます。
+
+次に、いくつかのタップダンスのキーを定義するためには、`TD()` マクロ — `F()` マクロに似ています — を使うのが最も簡単です。これは数字を受け取り、この数字は後で `tap_dance-actions` 配列のインデックスとして使われます。
+
+その後、`tap_dance_actions` 配列を使って、タップダンスキーを押した時のアクションを定義します。現在は、5つの可能なオプションがあります:
+
+* `ACTION_TAP_DANCE_DOUBLE(kc1, kc2)`: 1回タップすると `kc1` キーコードを送信し、2回タップすると `kc2` キーコードを送信します。キーを押し続けているときは、適切なキーコードが登録されます: キーを押し続けた場合は `kc1`、一度タップしてから続けてもう一度キーを押してそのまま押し続けたときは、 `kc2` が登録されます。
+* `ACTION_TAP_DANCE_LAYER_MOVE(kc, layer)`: 1回タップすると `kc` キーコードが送信され、2回タップすると `layer` レイヤーに移動します(これは `TO` レイヤーキーコードのように機能します)。
+    * この機能は `ACTION_TAP_DANCE_DUAL_ROLE` と同じですが、機能が明確になるように関数名を変更しました。どちらの関数名でも実行できます。
+* `ACTION_TAP_DANCE_LAYER_TOGGLE(kc, layer)`: 1回タップすると `kc` キーコードが送信され、2回タップすると `layer` の状態をトグルします(これは `TG` レイヤーキーコードのように機能します)。
+* `ACTION_TAP_DANCE_FN(fn)`: ユーザーキーマップに定義した指定の関数が呼び出されます。タップダンス実行の回数分タップすると、最後の時点で呼び出されます。
+* `ACTION_TAP_DANCE_FN_ADVANCED(on_each_tap_fn, on_dance_finished_fn, on_dance_reset_fn)`: タップする度にユーザーキーマップに定義した最初の関数が呼び出されます。タップダンスの実行が終わった時点で2番目の関数が呼び出され、タップダンスの実行をリセットするときに最後の関数が呼び出されます。
+* `ACTION_TAP_DANCE_FN_ADVANCED_TIME(on_each_tap_fn, on_dance_finished_fn, on_dance_reset_fn, tap_specific_tapping_term)`: これは `ACTION_TAP_DANCE_FN_ADVANCED` と同じように機能します。しかし、`TAPPING_TERM` で事前に定義した時間に代えて、カスタマイズしたタップ時間を使えます。
+
+最初のオプションで、1つのキーに2つの役割を持たせる大抵のケースには十分です。例えば、`ACTION_TAP_DANCE_DOUBLE(KC_SPC, KC_ENT)` は、1回タップすると `Space` を送信し、2回タップすると `Enter` を送信します。
+
+!> ここでは [基本的なキーコード](ja/keycodes_basic.md) だけがサポートされていることを覚えておいてください。カスタムキーコードはサポートされていません。
+
+最初のオプションに似ていますが、2番目のオプションは単純なレイヤー切替のケースに適しています。
+
+これ以上に複雑なケースの場合、3番目か4番目のオプションを使います。（以下でそれらの例を列挙します）
+
+最後に、5番目のオプションは、もし、タップダンスキーをコードに追加した後、非タップダンスキーが奇妙な振る舞いを始めた時に特に役に立ちます。ありうる問題は、あなたがタップダンスキーを使いやすくするために `TAPPING_TERM` の時間を変更した結果、その他のキーが割り込みを処理する方法が変わってしまったというものです。
+
+
+## 実装の詳細
+
+さて、説明の大部分はここまでです！ 以下に挙げているいくつかの例に取り組むことができるようになり、あなた自身のタップダンスの機能を開発できるようになります。しかし、もし、あなたが裏側で起きていることをより深く理解したいのであれば、続けてそれが全てどのように機能するかの説明を読みましょう！
+
+メインエントリーポイントは、`process_tap_dance()` で、`process_record_quantum()` から呼び出されます。これはキーを押すたびに実行され、ハンドラは早期に実行されます。この関数は、押されたキーがタップダンスキーがどうか確認します。
+もし、押されたキーがタップダンスキーではなく、かつ、タップダンスが実行されていたなら、最初にそれを処理し、新しく押されたキーをキューに格納します。
+もし、押されたキーがタップダンスキーであるなら、既にアクティブなタップダンスと同じキーか確認します（もしアクティブなものがある場合、それと）。
+異なる場合、まず、古いタップダンスを処理し、続いて新しいタップダンスを登録します。
+同じ場合、カウンタの値を増やし、タイマーをリセットします。
+
+このことは、あなたは再びキーをタップするまでの時間として `TAPPING_TERM` の時間を持っていることを意味します。そのため、あなたは1つの `TAPPING_TERM` の時間内に全てのタップを行う必要はありません。これにより、キーの反応への影響を最小限に抑えながら、より長いタップ回数を可能にします。 
+
+次は `matrix_scan_tap_dance()` です。この関数はタップダンスキーのタイムアウトを制御します。
+
+柔軟性のために、タップダンスは、キーコードの組み合わせにも、ユーザー関数にもなることができます。後者は、より高度なタップ回数の制御や、LED を点滅させたり、バックライトをいじったり、等々の制御を可能にします。これは、1つの共用体と、いくつかの賢いマクロによって成し遂げられています。
+
+# 実装例
+
+## シンプルな実装例
+
+ここに1つの定義のための簡単な例があります。
+
+1. `rules.mk` に `TAP_DANCE_ENABLE = yes` を追加します。
+2. `config.h` ファイル（`qmk_firmware/keyboards/planck/config.h` からあなたのキーマップディレクトリにコピーできます）に `#define TAPPING_TERM 200` を追加します。
+3. `keymap.c` ファイルに変数とタップダンスの定義を定義し、それからキーマップに追加します。
+
+```c
+// タップダンスの宣言
+enum {
+  TD_ESC_CAPS = 0
+};
+
+// タップダンスの定義
+qk_tap_dance_action_t tap_dance_actions[] = {
+  // 1回タップすると Escape キー、2回タップすると Caps Lock。
+  [TD_ESC_CAPS]  = ACTION_TAP_DANCE_DOUBLE(KC_ESC, KC_CAPS)
+// ほかの宣言もカンマで区切ってここに記述します
+};
+
+// レイヤー定義で、キーコードの代わりにタップダンスキーを追加します
+TD(TD_ESC_CAPS)
+```
+
+## 複雑な実装例
+
+このセクションでは、いくつかの複雑なタップダンスの例を詳しく説明します。
+例で使われている全ての列挙型はこのように宣言します。
+
+```c
+// 全ての例のための列挙型定義
+enum {
+ CT_SE = 0,
+ CT_CLN,
+ CT_EGG,
+ CT_FLSH,
+ X_TAP_DANCE
+};
+```
+### 例1: 1回タップすると `:` を送信し、2回タップすると `;` を送信する
+
+```c
+void dance_cln_finished (qk_tap_dance_state_t *state, void *user_data) {
+  if (state->count == 1) {
+    register_code (KC_RSFT);
+    register_code (KC_SCLN);
+  } else {
+    register_code (KC_SCLN);
+  }
+}
+
+void dance_cln_reset (qk_tap_dance_state_t *state, void *user_data) {
+  if (state->count == 1) {
+    unregister_code (KC_RSFT);
+    unregister_code (KC_SCLN);
+  } else {
+    unregister_code (KC_SCLN);
+  }
+}
+
+// 全てのタップダンス関数はここに定義します。ここでは1つだけ示します。
+qk_tap_dance_action_t tap_dance_actions[] = {
+ [CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finished, dance_cln_reset)
+};
+```
+
+### 例2: 100回タップした後に "Safety Dance!" を送信します
+
+```c
+void dance_egg (qk_tap_dance_state_t *state, void *user_data) {
+  if (state->count >= 100) {
+    SEND_STRING ("Safety dance!");
+    reset_tap_dance (state);
+  }
+}
+
+qk_tap_dance_action_t tap_dance_actions[] = {
+ [CT_EGG] = ACTION_TAP_DANCE_FN (dance_egg)
+};
+```
+
+### 例3: 1つずつ LED を点灯させてから消灯する
+
+```c
+// タップする毎に、LED を右から左に点灯します。
+// 4回目のタップで、右から左に消灯します。
+void dance_flsh_each(qk_tap_dance_state_t *state, void *user_data) {
+  switch (state->count) {
+  case 1:
+    ergodox_right_led_3_on();
+    break;
+  case 2:
+    ergodox_right_led_2_on();
+    break;
+  case 3:
+    ergodox_right_led_1_on();
+    break;
+  case 4:
+    ergodox_right_led_3_off();
+    _delay_ms(50);
+    ergodox_right_led_2_off();
+    _delay_ms(50);
+    ergodox_right_led_1_off();
+  }
+}
+
+// 4回目のタップで、キーボードをフラッシュ状態にセットします。
+void dance_flsh_finished(qk_tap_dance_state_t *state, void *user_data) {
+  if (state->count >= 4) {
+    reset_keyboard();
+    reset_tap_dance(state);
+  }
+}
+
+// もしフラッシュ状態にならない場合、LED を左から右に消灯します。
+void dance_flsh_reset(qk_tap_dance_state_t *state, void *user_data) {
+  ergodox_right_led_1_off();
+  _delay_ms(50);
+  ergodox_right_led_2_off();
+  _delay_ms(50);
+  ergodox_right_led_3_off();
+}
+
+// 全てのタップダンス関数を一緒に表示しています。この例3は "CT_FLASH" です。
+qk_tap_dance_action_t tap_dance_actions[] = {
+  [CT_SE]  = ACTION_TAP_DANCE_DOUBLE (KC_SPC, KC_ENT)
+ ,[CT_CLN] = ACTION_TAP_DANCE_FN_ADVANCED (NULL, dance_cln_finished, dance_cln_reset)
+ ,[CT_EGG] = ACTION_TAP_DANCE_FN (dance_egg)
+ ,[CT_FLSH] = ACTION_TAP_DANCE_FN_ADVANCED (dance_flsh_each, dance_flsh_finished, dance_flsh_reset)
+};
+```
+
+### 例4: クアッドファンクションのタップダンス
+
+[DanielGGordon](https://github.com/danielggordon) によるもの
+
+キーを押す回数と、キーを押し続けるかタップするかによって、1つのキーに4つ（またはそれ以上）の機能を持たせることができるようになります。
+
+以下に例をあげます:
+*  1回タップ = `x` を送信
+*  押し続ける = `Control` を送信
+*  2回タップ = `Escape` を送信
+*  2回タップして押し続ける = `Alt` を送信
+
+## 準備
+
+'クアッドファンクションのタップダンス' を利用できるようにするには、いくつかのものが必要になります。
+
+`keymap.c` ファイルの先頭、つまりキーマップの前に、以下のコードを追加します。
+
+```c
+typedef struct {
+  bool is_press_action;
+  int state;
+} tap;
+
+enum {
+  SINGLE_TAP = 1,
+  SINGLE_HOLD = 2,
+  DOUBLE_TAP = 3,
+  DOUBLE_HOLD = 4,
+  DOUBLE_SINGLE_TAP = 5, //シングルタップを2回送信
+  TRIPLE_TAP = 6,
+  TRIPLE_HOLD = 7
+};
+
+// タップダンスの列挙型
+enum {
+  X_CTL = 0,
+  SOME_OTHER_DANCE
+};
+
+int cur_dance (qk_tap_dance_state_t *state);
+
+//xタップダンスのための関数。キーマップで利用できるようにするため、ここに置きます。
+void x_finished (qk_tap_dance_state_t *state, void *user_data);
+void x_reset (qk_tap_dance_state_t *state, void *user_data);
+
+```
+
+次に、`keymap.c` ファイルの末尾に、次のコードを追加する必要があります。
+
+```c
+/* 実行されるタップダンスの種類に対応する整数を返します。
+ *
+ * タップダンスの状態を判別する方法: 割り込みと押下。
+ *
+ * 割り込み:
+ *   タップダンスの状態が「割り込み」の場合、他のキーがタップ時間中に押されたことを意味します。
+ *   これは通常、キーを「タップ」しようとしていることを示します。
+ *
+ * 押下:
+ *   キーがまだ押されているかどうか。この値が true の場合、タップ時間が終了したことを意味しますが、
+ *   キーはまだ押されたままです。これは通常、キーが「ホールド」されていることを意味します。
+ *
+ * タップダンスに関して、qmk ソフトウェアで現在不可能なことの1つは、"permissive hold" 機能を
+ * 模倣することです。
+ * 一般に、高度なタップダンスは一般的に入力される文字で使われた場合にうまく機能しません。
+ * 例えば "A" の場合。タップダンスは文字の入力中に入力しない文字以外のキーで使うのが最適です。
+ *
+ * 高度なタップダンスを配置するのに適した場所:
+ *   z、q、x、j、k、v、b、ファンクションキー、home/end、コンマ、セミコロン
+ *
+ * タップダンスキーの「最適な配置場所」の基準:
+ *   文章中で頻繁に入力するキーでないこと
+ *   ダブルタップに頻繁に使われるキーでないこと。例えば、'tab' はターミナルやウェブフォームで
+ *   しばしばダブルタップされます。そのため、タップダンスでは 'tab' は良い選択ではありません。
+ *   一般的な単語で2回続けて使われる文字でないこと。例えば 'pepper' 中の 'p'。もしタップダンス機能が
+ *   文字 'p' に存在する場合、'pepper' という単語は入力するのが非常にいらだたしいものになるでしょう。
+ *
+ * 3つ目の点については、'DOUBLE_SINGLE_TAP' が存在しますが、これは完全にはテストされていません
+ *
+ */
+int cur_dance (qk_tap_dance_state_t *state) {
+  if (state->count == 1) {
+    if (state->interrupted || !state->pressed)  return SINGLE_TAP;
+    //キーは割り込まれていませんが、まだ押し続けられています。'HOLD' を送信することを意味します。
+    else return SINGLE_HOLD;
+  }
+  else if (state->count == 2) {
+    /*
+     * DOUBLE_SINGLE_TAP は "pepper" と入力することと、'pp' と入力したときに実際に
+     * ダブルタップしたい場合とを区別するためのものです。
+     * この戻り値の推奨されるユースケースは、'ダブルタップ' 動作やマクロではなく、
+     * そのキーの2つのキー入力を送信したい場合です。
+    */
+    if (state->interrupted) return DOUBLE_SINGLE_TAP;
+    else if (state->pressed) return DOUBLE_HOLD;
+    else return DOUBLE_TAP;
+  }
+  //誰も同じ文字を3回入力しようとしていないと仮定します(少なくとも高速には)。
+  //タップダンスキーが 'KC_W' で、"www." と高速に入力したい場合、ここに例外を追加して
+  //'TRIPLE_SINGLE_TAP' を返し、'DOUBLE_SINGLE_TAP' のようにその列挙型を定義する
+  //必要があります。
+  if (state->count == 3) {
+    if (state->interrupted || !state->pressed)  return TRIPLE_TAP;
+    else return TRIPLE_HOLD;
+  }
+  else return 8; //マジックナンバー。いつかこのメソッドはより多くの押下に対して機能するよう拡張されるでしょう
+}
+
+//'x' タップダンスの 'tap' のインスタンスをインスタンス化します
+static tap xtap_state = {
+  .is_press_action = true,
+  .state = 0
+};
+
+void x_finished (qk_tap_dance_state_t *state, void *user_data) {
+  xtap_state.state = cur_dance(state);
+  switch (xtap_state.state) {
+    case SINGLE_TAP: register_code(KC_X); break;
+    case SINGLE_HOLD: register_code(KC_LCTRL); break;
+    case DOUBLE_TAP: register_code(KC_ESC); break;
+    case DOUBLE_HOLD: register_code(KC_LALT); break;
+    case DOUBLE_SINGLE_TAP: register_code(KC_X); unregister_code(KC_X); register_code(KC_X);
+    //最後の case は高速入力用です。キーが `f` であると仮定します:
+    //例えば、`buffer` という単語を入力するとき、`Esc` ではなく `ff` を送信するようにします。
+    //高速入力時に `ff` と入力するには、次の文字は `TAPPING_TERM` 以内に入力する必要があります。
+    //`TAPPING_TERM` はデフォルトでは 200ms です。
+  }
+}
+
+void x_reset (qk_tap_dance_state_t *state, void *user_data) {
+  switch (xtap_state.state) {
+    case SINGLE_TAP: unregister_code(KC_X); break;
+    case SINGLE_HOLD: unregister_code(KC_LCTRL); break;
+    case DOUBLE_TAP: unregister_code(KC_ESC); break;
+    case DOUBLE_HOLD: unregister_code(KC_LALT);
+    case DOUBLE_SINGLE_TAP: unregister_code(KC_X);
+  }
+  xtap_state.state = 0;
+}
+
+qk_tap_dance_action_t tap_dance_actions[] = {
+  [X_CTL]     = ACTION_TAP_DANCE_FN_ADVANCED(NULL,x_finished, x_reset)
+};
+```
+
+これで、キーマップのどこでも簡単に `TD(X_CTL)` マクロが使えます。
+
+もし、この機能をユーザスペースで実現したい場合、 [DanielGGordon](https://github.com/qmk/qmk_firmware/tree/master/users/gordon) がユーザスペースでどのように実装しているか確認してください。
+
+> この設定の "hold" は、タップダンスのタイムアウト（`ACTION_TAP_DANCE_FN_ADVANCED_TIME` 参照）の **後** に起こります。即座に "hold" を得るためには、条件から `state->interrupted` の確認を除きます。結果として、複数回のタップのための時間をより多く持つことで快適な長いタップの期限を使うことができ、そして、"hold" のために長く待たないようにすることができます(2倍の `TAPPING TERM` で開始してみてください)。
+
+### 例5: タップダンスを高度なモッドタップとレイヤータップキーに使う :id=example-5-using-tap-dance-for-advanced-mod-tap-and-layer-tap-keys
+
+タップダンスは、タップされたコードが基本的なキーコード以外の場合に、 `MT()` と `LT()` マクロをエミュレートするのに利用できます。これは、通常 `Shift` を必要とする '(' や '{' のようなキーや、`Control + X` のように他の修飾されたキーコードをタップされたキーコードとして送信することに役立ちます。
+
+あなたのレイヤーとカスタムキーコードの下に、以下のコードを追加します。
+
+```c
+//タップダンスのキーコード
+enum td_keycodes { 
+  ALT_LP //例: 押していると `LALT`、タップすると `(`。それぞれのタップダンスの追加のキーコードを追加します
+};
+
+//必要な数のタップダンス状態を含むタイプを定義します
+typedef enum {
+  SINGLE_TAP,
+  SINGLE_HOLD,
+  DOUBLE_SINGLE_TAP
+} td_state_t;
+
+//タップダンスの状態の型のグローバルインスタンスを作ります
+static td_state_t td_state;
+
+//タップダンス関数を宣言します:
+
+//現在のタップダンスの状態を特定するための関数
+int cur_dance (qk_tap_dance_state_t *state);
+
+//それぞれのタップダンスキーコードに適用する `finished` と `reset` 関数
+void altlp_finished (qk_tap_dance_state_t *state, void *user_data);
+void altlp_reset (qk_tap_dance_state_t *state, void *user_data);
+```
+
+キーレイアウト（`LAYOUT`）の下に、タップダンスの関数を定義します。
+
+```c
+// 返却するタップダンス状態を特定します
+int cur_dance (qk_tap_dance_state_t *state) {
+  if (state->count == 1) {
+    if (state->interrupted || !state->pressed) { return SINGLE_TAP; }
+    else { return SINGLE_HOLD; }
+  }
+  if (state->count == 2) { return DOUBLE_SINGLE_TAP; }
+  else { return 3; } // 上記で返却する最大の状態の値より大きい任意の数
+}
+ 
+// 定義する各タップダンスキーコードのとりうる状態を制御します:
+
+void altlp_finished (qk_tap_dance_state_t *state, void *user_data) {
+  td_state = cur_dance(state);
+  switch (td_state) {
+    case SINGLE_TAP:
+      register_code16(KC_LPRN);
+      break;
+    case SINGLE_HOLD:
+      register_mods(MOD_BIT(KC_LALT)); // レイヤータップキーの場合、ここでは `layer_on(_MY_LAYER)` を使います
+      break;
+    case DOUBLE_SINGLE_TAP: // タップ時間内に2つの括弧 `((` の入れ子を可能にします
+      tap_code16(KC_LPRN);
+      register_code16(KC_LPRN);
+  }
+}
+
+void altlp_reset (qk_tap_dance_state_t *state, void *user_data) {
+  switch (td_state) {
+    case SINGLE_TAP:
+      unregister_code16(KC_LPRN);
+      break;
+    case SINGLE_HOLD:
+      unregister_mods(MOD_BIT(KC_LALT)); // レイヤータップキーの場合、ここでは `layer_off(_MY_LAYER)` を使います
+      break;
+    case DOUBLE_SINGLE_TAP:
+      unregister_code16(KC_LPRN);
+  }
+}
+
+// 各タップダンスキーコードの `ACTION_TAP_DANCE_FN_ADVANCED()` を定義し、`finished` と `reset` 関数を渡します
+qk_tap_dance_action_t tap_dance_actions[] = {
+  [ALT_LP] = ACTION_TAP_DANCE_FN_ADVANCED(NULL, altlp_finished, altlp_reset)
+};
+```
+
+それぞれのタップダンスキーコードをキーマップに含めるときは、`TD()` マクロでキーコードをラップします。例: `TD(ALT_LP)`
+
+### 例6: タップダンスを一時的なレイヤー切り替えとレイヤートグルキーに使う
+
+タップダンスは、MO(layer) と TG(layer) 機能を模倣することにも使用できます。この例では、1回タップすると `KC_QUOT` 、1回押してそのまま押し続けたら `MO(_MY_LAYER)` 、2回タップしたときは `TG(_MY_LAYER)` として機能するキーを設定します。
+
+最初のステップは、あなたの `keymap.c` ファイルの最初のあたりに以下のコードを追加します。
+
+```c
+typedef struct {
+  bool is_press_action;
+  int state;
+} tap;
+
+//必要な数のタップダンス状態のタイプを定義します
+enum {
+  SINGLE_TAP = 1,
+  SINGLE_HOLD = 2,
+  DOUBLE_TAP = 3
+};
+
+enum {
+  QUOT_LAYR = 0  //カスタムタップダンスキー。他のタップダンスキーはこの列挙型に追加します
+};
+
+//タップダンスキーで使われる関数を宣言します
+
+//全てのタップダンスに関連する関数
+int cur_dance (qk_tap_dance_state_t *state);
+
+//個別のタップダンスに関連する関数
+void ql_finished (qk_tap_dance_state_t *state, void *user_data);
+void ql_reset (qk_tap_dance_state_t *state, void *user_data);
+```
+
+あなたの `keymap.c` ファイルの最後の方に以下のコードを追加します。
+
+```c
+//現在のタップダンスの状態を決定します
+int cur_dance (qk_tap_dance_state_t *state) {
+  if (state->count == 1) {
+    if (!state->pressed) {
+      return SINGLE_TAP;
+    } else {
+      return SINGLE_HOLD;
+    }
+  } else if (state->count == 2) {
+    return DOUBLE_TAP;
+  }
+  else return 8;
+}
+
+//この例のタップダンスキーに関連付けられた "tap" 構造体を初期化します
+static tap ql_tap_state = {
+  .is_press_action = true,
+  .state = 0
+};
+
+//タップダンスキーの動作をコントロールする関数
+void ql_finished (qk_tap_dance_state_t *state, void *user_data) {
+  ql_tap_state.state = cur_dance(state);
+  switch (ql_tap_state.state) {
+    case SINGLE_TAP: 
+      tap_code(KC_QUOT); 
+      break;
+    case SINGLE_HOLD: 
+      layer_on(_MY_LAYER); 
+      break;
+    case DOUBLE_TAP: 
+      //レイヤーが既にセットされているか確認します
+      if (layer_state_is(_MY_LAYER)) {
+        //レイヤーが既にセットされていたら、オフにします。
+        layer_off(_MY_LAYER);
+      } else { 
+        //レイヤーがセットされていなかったら、オンにします。
+        layer_on(_MY_LAYER);
+      }
+      break;
+  }
+}
+
+void ql_reset (qk_tap_dance_state_t *state, void *user_data) {
+  //キーを押し続けていて今離したら、レイヤーをオフに切り替えます。
+  if (ql_tap_state.state==SINGLE_HOLD) {
+    layer_off(_MY_LAYER);
+  }
+  ql_tap_state.state = 0;
+}
+
+//タップダンスキーを機能に関連付けます
+qk_tap_dance_action_t tap_dance_actions[] = {
+  [QUOT_LAYR] = ACTION_TAP_DANCE_FN_ADVANCED_TIME(NULL, ql_finished, ql_reset, 275)
+};
+```
+
+上記のコードは、前の例で使われたコードに似ています。注意する1つのポイントは、必要に応じてレイヤーを切り替えられるように、どのレイヤーがアクティブになっているかいつでも確認できる必要があることです。これを実現するために、引数で与えられた `layer` がアクティブなら `true` を返す `layer_state_is( layer )`  を使います。
+
+`cur_dance()` と `ql_tap_state` の使い方は、上の例と似ています。
+
+`ql_finished` 関数における `case:SINGLE_TAP` は、上の例と似ています。`case:SINGLE_HOLD` は、`ql_reset()` と連動してタップダンスキーを押している間 `_MY_LAYER` に切り替わり、キーを離した時に `_MY_LAYER` から離れます。これは、`MO(_MY_LAYER)` に似ています。`case:DOUBLE_TAP` は、`_MY_LAYER` がアクティブレイヤーかどうかを確認することによって動きます。そして、その結果に基づいてレイヤーのオン・オフをトグルします。これは `TG(_MY_LAYER)` に似ています。
+
+`tap_dance_actions[]` は、上の例に似ています。 `ACTION_TAP_DANCE_FN_ADVANCED()` の代わりに `ACTION_TAP_DANCE_FN_ADVANCED_TIME()` を使ったことに注意してください。
+この理由は、私は、非タップダンスキーを使うにあたり `TAPPING_TERM` が短い(175ミリ秒以内)方が好きなのですが、タップダンスのアクションを確実に完了させるには短すぎるとわかったからです——そのため、ここでは時間を275ミリ秒に増やしています。
+
+最後に、このタップダンスキーを動かすため、忘れずに `TD(QUOT_LAYR)` を `keymaps[]` に加えてください。 

docs/ja/flashing.md

@@ -0,0 +1,247 @@
+# 書き込みの手順とブートローダ情報
+
+<!---
+  original document: 7494490d6:docs/flashing.md
+  git diff 7494490d6 HEAD -- docs/flashing.md | cat
+-->
+
+キーボードが使用するブートローダにはかなり多くの種類があり、ほぼ全てが異なる書き込みの方法を使います。幸いなことに、[QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) のようなプロジェクトは、あまり深く考える必要無しに様々なタイプと互換性を持つことを目指していますが、この文章では様々なタイプのブートローダとそれらを書き込むために利用可能な方法について説明します。
+
+`rules.mk` の `BOOTLOADER` 変数で選択されたブートローダがある場合、QMK は .hex ファイルがデバイスに書き込むのに適切なサイズかどうかを自動的に計算し、合計サイズをバイト単位で(最大値とともに)出力します。この処理を手動で実行するには、`check-size` を付けてコンパイルします。例えば、`make planck/rev4:default:check-size`。
+
+## DFU
+
+Atmel の DFU ブートローダはデフォルトで全ての atmega32u4 チップに搭載されており、PCB (旧 OLKB キーボード、Clueboard) に独自の IC を持つ多くのキーボードで使われています。一部のキーボードは、LUFA の DFU ブートローダ(または QMK のフォーク) (新しい OLKB キーボード)を使う場合もあり、そのハードウェアに固有の追加機能が追加されます。
+
+DFU ブートローダとの互換性を確保するために、以下のブロックが `rules.mk` にあることを確認してください(オプションとして代わりに `lufa-dfu` や `qmk-dfu` が使えます):
+
+```make
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = atmel-dfu
+```
+
+互換性のあるフラッシャ:
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (推奨の GUI)
+* QMK の [dfu-programmer](https://github.com/dfu-programmer/dfu-programmer) / `:dfu` (推奨のコマンドライン)
+* [Atmel の Flip](http://www.microchip.com/developmenttools/productdetails.aspx?partno=flip) (非推奨)
+
+書き込み手順:
+
+1. `RESET` キーコードを押すか、RESET ボタンをタップします(または RST を GND にショートします)。
+2. OS がデバイスを検知するのを待ちます。
+3. メモリを消去します(自動的に実行されるかもしれません)
+4. .hex ファイルを書き込みます
+5. デバイスをアプリケーションモードにリセットします(自動的に実行されるかもしれません)
+
+あるいは:
+
+    make <keyboard>:<keymap>:dfu
+
+### QMK DFU
+
+QMK には LUFA DFU ブートローダのフォークがあり、ブートローダを終了してアプリケーションに戻る時に単純なマトリックススキャンを行うことができます。また、何かが起きた時に、LED を点滅したり、スピーカーでカチカチ音をたてたりします。これらの機能を有効にするには、`config.h` で以下のブロックを有効にします (ブートローダを終了するキーは、ここで定義された INPUT と OUTPUT に接続する必要があります):
+
+    #define QMK_ESC_OUTPUT F1 // 通常 COL
+    #define QMK_ESC_INPUT D5 // 通常 ROW
+    #define QMK_LED E6
+    #define QMK_SPEAKER C6
+
+製造元と製品名は `config.h` から自動的に取得され、製品に「Bootloader」が追加されます。
+
+このブートローダを生成するには、`bootloader` ターゲット、例えば `make planck/rev4:default:bootloader` を使います。
+
+実稼働対応の .hex ファイル(アプリケーションおよびブートローダを含む)を生成するには、`production` ターゲット、例えば `make planck/rev4:default:production` を使います。
+
+### DFU コマンド
+
+ファームウェアを DFU デバイスに書き込むために使用できる DFU コマンドがいくつかあります。
+
+* `:dfu` - これが通常のオプションで、DFU デバイスが使用可能になるまで待機したのちファームウェアを書き込みます。5秒ごとに、DFU デバイスが存在するかチェックしています。
+* `:dfu-ee` - 通常の hex ファイルの代わりに `eep` ファイルを書き込みます。これを使用するのはまれです。
+* `:dfu-split-left` - デフォルトオプション (`:dfu`) と同様に、通常のファームウェアが書き込まれます。ただし、分割キーボードの「左側の」 EEPROM ファイルも書き込まれます。_これは、Elite C ベースの分割キーボードに最適です。_
+* `:dfu-split-right` - デフォルトオプション (`:dfu`) と同様に、通常のファームウェアが書き込まれます。ただし、分割キーボードの「右側の」 EEPROM ファイルも書き込まれます。_これは、Elite C ベースの分割キーボードに最適です。_
+
+## Caterina
+
+Arduino ボードとそのクローンは [Caterina ブートローダ](https://github.com/arduino/ArduinoCore-avr/tree/master/bootloaders/caterina) (Pro Micro またはそのクローンで構築されたキーボード)を使用し、avr109 プロトコルを使って仮想シリアルを介して通信します。[A-Star](https://www.pololu.com/docs/0J61/9) のようなブートローダは Caterina に基づいています。
+
+Caterina ブートローダとの互換性を確保するために、以下のブロックが `rules.mk` にあることを確認してください:
+
+```make
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = caterina
+```
+
+互換性のあるフラッシャ:
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (推奨の GUI)
+* avr109 を使った [avrdude](http://www.nongnu.org/avrdude/) / `:avrdude` (推奨のコマンドライン)
+* [AVRDUDESS](https://github.com/zkemble/AVRDUDESS)
+
+書き込み手順:
+
+1. `RESET` キーコードを押すか、RST をすばやく GND にショートします (入力後7秒で書き込みます)
+2. OS がデバイスを検知するのを待ちます。
+3. .hex ファイルを書き込みます
+4. デバイスが自動的にリセットされるのを待ちます
+
+あるいは
+
+    make <keyboard>:<keymap>:avrdude
+
+
+#### Caterina コマンド
+
+ファームウェアを DFU デバイスに書き込むために使用できる DFU コマンドがいくつかあります。
+
+* `:avrdude` - これが通常のオプションで、Caterina デバイスが(新しい COM ポートを検出して)使用可能になるまで待機し、ファームウェアを書き込みます。
+* `:avrdude-loop` - これは `:avrdude` と同じコマンドを実行します。ただし書き込みが終了すると再び Caterina デバイスの書き込み待ちに戻ります。これは何台ものデバイスへ書き込むのに便利です。_Ctrl+C を押して、手動でこの繰り返しを終了させる必要があります。_
+* `:avrdude-split-left` - デフォルトオプション (`:avrdude`) と同様に通常のファームウェアが書き込まれます。ただし、分割キーボードの「左側の」 EEPROM ファイルも書き込まれます。_これは、Pro Micro ベースの分割キーボードに最適です。_
+* `:avrdude-split-right` - デフォルトオプション (`:avrdude`) と同様に通常のファームウェアが書き込まれます。ただし、分割キーボードの「右側の」 EEPROM ファイルも書き込まれます。_これは、Pro Micro ベースの分割キーボードに最適です。_
+
+
+
+## Halfkay
+
+Halfkay は PJRC によって開発された超スリムなプロトコルであり、HID を使用し、全ての Teensys (つまり 2.0)に搭載されています。
+
+Halfkay ブートローダとの互換性を確保するために、以下のブロックが `rules.mk` にあることを確認してください:
+
+```make
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = halfkay
+```
+
+互換性のあるフラッシャ:
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (推奨の GUI)
+* [Teensy ローダー](https://www.pjrc.com/teensy/loader.html)
+* [Teensy ローダーコマンドライン](https://www.pjrc.com/teensy/loader_cli.html) (推奨のコマンドライン)
+
+書き込み手順:
+
+1. `RESET` キーコードを押すか、RST をすばやく GND にショートします (入力後7秒で書き込みます)
+2. OS がデバイスを検知するのを待ちます。
+3. .hex ファイルを書き込みます
+4. デバイスをアプリケーションモードにリセットします(自動的に実行されるかもしれません)
+
+## USBasploader
+
+USBasploader は matrixstorm によって開発されたブートローダです。V-USB を実行する ATmega328P のような非 USB AVR チップで使われます。
+
+USBasploader ブートローダとの互換性を確保するために、以下のブロックが `rules.mk` にあることを確認してください:
+
+```make
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = USBasp
+```
+
+互換性のあるフラッシャ:
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (推奨の GUI)
+* `usbasp` プログラマを使った [avrdude](http://www.nongnu.org/avrdude/)
+* [AVRDUDESS](https://github.com/zkemble/AVRDUDESS)
+
+書き込み手順:
+
+1. `RESET` キーコードを押すか、RST を GND にすばやくショートしながら、ブートピンを GND にショートしたままにします。
+2. OS がデバイスを検知するのを待ちます。
+3. .hex ファイルを書き込みます
+4. デバイスをアプリケーションモードにリセットします(自動的に実行されるかもしれません)
+
+## BootloadHID
+
+BootloadHID は AVR マイクロコントローラ用の USB ブートローダです。アップローダーツールは Windows でカーネルレベルのドライバを必要としないため、DLL をインストールせずに実行することができます。
+
+bootloadHID ブートローダとの互換性を確保するために、以下のブロックが `rules.mk` にあることを確認してください:
+
+```make
+# Bootloader selection
+#   Teensy       halfkay
+#   Pro Micro    caterina
+#   Atmel DFU    atmel-dfu
+#   LUFA DFU     lufa-dfu
+#   QMK DFU      qmk-dfu
+#   ATmega32A    bootloadHID
+#   ATmega328P   USBasp
+BOOTLOADER = bootloadHID
+```
+
+互換性のあるフラッシャ:
+
+* [HIDBootFlash](http://vusb.wikidot.com/project:hidbootflash) (推奨の Windows GUI)
+* [bootloadhid コマンドライン](https://www.obdev.at/products/vusb/bootloadhid.html) / QMK の `:BootloadHID` (推奨のコマンドライン)
+
+書き込み手順:
+
+1. 以下のいずれかの方法を使ってブートローダに入ります:
+   * `RESET` キーコードをタップします (全てのデバイスでは動作しないかもしれません)
+   * キーボードを接続しながらソルトキーを押し続けます (通常はキーボードの readme に書かれています)
+2. OS がデバイスを検知するのを待ちます。
+3. .hex ファイルを書き込みます
+4. デバイスをアプリケーションモードにリセットします(自動的に実行されるかもしれません)
+
+あるいは:
+
+    make <keyboard>:<keymap>:bootloadHID
+
+## STM32
+
+全ての STM32 チップには、変更も削除もできない工場出荷時のブートローダがプリロードされています。一部の STM32 チップには USB プログラミングが付属していないブートローダがありますが(例えば STM32F103)、プロセスは同じです。
+
+現時点では、STM32 の `rules.mk` には、`BOOTLOADER` 変数は不要です。
+
+互換性のあるフラッシャ:
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox/releases) (推奨の GUI)
+* [dfu-util](https://github.com/Stefan-Schmidt/dfu-util) / `:dfu-util` (推奨のコマンドライン)
+
+書き込み手順:
+
+1. 以下のいずれかの方法を使ってブートローダに入ります:
+   * `RESET` キーコードをタップします (STM32F042 デバイスでは動作しないかもしれません)
+   * リセット回路が存在する場合、RESET ボタンをタップします
+   * それ以外の場合は、(BOOT0 ボタンあるいはブリッジ経由で)BOOT0 を VCC にブリッジし、(REEST ボタンあるいはブリッジ経由で)RESET を GND にショートし、BOOT0 ブリッジを放す必要があります。
+2. OS がデバイスを検知するのを待ちます。
+3. .bin ファイルを書き込みます
+   * DFU 署名に関する警告が表示されます; 無視してください
+4. デバイスをアプリケーションモードにリセットします(自動的に実行されるかもしれません)
+   * コマンドラインからビルドする場合(例えば、`make planck/rev6:default:dfu-util`)、`rules.mk` の中で `:leave` が `DFU_ARGS` 変数に渡されるようにしてください (例えば、`DFU_ARGS = -d 0483:df11 -a 0 -s 0x08000000:leave`)。そうすれば、書き込みの後でデバイスがリセットされます
+
+### STM32 コマンド
+
+ファームウェアを STM32 デバイスに書き込むために使用できる DFU コマンドがいくつかあります。
+
+* `:dfu-util` - STM32 デバイスに書き込むためのデフォルトコマンドで、STM32 ブートローダデバイスが見つかるまで待機します。
+* `:dfu-util-split-left` - デフォルトのオプション (`:dfu-util`) と同様に、通常のファームウェアが書き込まれます。ただし、分割キーボードの「左側の」 EEPROM の設定も行われます。
+* `:dfu-util-split-right` - デフォルトのオプション (`:dfu-util`) と同様に、通常のファームウェアが書き込まれます。ただし、分割キーボードの「右側の」 EEPROM の設定も行われます。
+* `:st-link-cli` - dfu-util ではなく、ST-LINK の CLI ユーティリティを介してファームウェアを書き込めます。

docs/ja/getting_started_build_tools.md

@@ -0,0 +1,146 @@
+# ビルドツールのインストール
+
+<!---
+  original document: 5a02cc00a:docs/getting_started_build_tools.md
+  git diff 5a02cc00a HEAD -- docs/getting_started_build_tools.md | cat
+-->
+
+このページは QMK のためのビルド環境のセットアップを説明します。これらの手順は (atmega32u4 のような) AVR プロセッサを対象としてします。
+
+<!-- FIXME: We should have ARM instructions somewhere. -->
+
+**注意:** ここが初めての場合は、[QMK 初心者ガイド](ja/newbs.md)ページを調べてください。
+
+続ける前に、`make git-submodule` を実行して、サブモジュール(サードパーティライブラリ)が最新であることを再確認してください。
+
+## Linux
+
+常に最新の状態を保つためには、単に `sudo util/qmk_install.sh` を実行してください。全ての必要な依存関係が常にインストールされるはずです。**これは `apt-get upgrade` を実行します。**
+
+手動でインストールすることもできますが、このドキュメントは常に全ての要件を満たしているとは限りません。
+
+現在の要件は以下の通りですが、何をしようとしているかによっては全てが必要とは限りません。また、一部のシステムではパッケージとして全ての依存関係が利用できるとは限らず、あるいは名前が異なる場合があるかもしれません。
+
+```
+build-essential
+gcc
+unzip
+wget
+zip
+gcc-avr
+binutils-avr
+avr-libc
+dfu-programmer
+dfu-util
+gcc-arm-none-eabi
+binutils-arm-none-eabi
+libnewlib-arm-none-eabi
+git
+```
+
+好みのパッケージマネージャを使って依存関係をインストールします。
+
+Debian / Ubuntu の例:
+
+    sudo apt-get update
+    sudo apt-get install gcc unzip wget zip gcc-avr binutils-avr avr-libc dfu-programmer dfu-util gcc-arm-none-eabi binutils-arm-none-eabi libnewlib-arm-none-eabi
+
+Fedora / Red Hat の例:
+
+    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 の例:
+
+    pacman -S base-devel gcc unzip wget zip avr-gcc avr-binutils avr-libc dfu-util arm-none-eabi-gcc arm-none-eabi-binutils arm-none-eabi-newlib git dfu-programmer dfu-util
+
+## Nix
+
+[NixOS](https://nixos.org/) の場合、あるいは Linux または MacOS に Nix をインストールした場合は、ビルド環境を取得するためにリポジトリのルートで `nix-shell` を実行します。
+
+デフォルトでは、これは AVR と ARM の両方のためのコンパイラをダウンロードします。両方が必要ではない場合は、`avr` あるいは `arm` 引数を無効にします。例えば:
+
+    nix-shell --arg arm false
+
+## macOS
+[Homebrew](http://brew.sh/) を使っている場合は、以下のコマンドを使うことができます:
+
+    brew tap osx-cross/avr
+    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 arm-gcc-bin@8
+    brew link --force arm-gcc-bin@8
+    brew install avrdude
+
+これはお勧めの方法です。homebrew が無い場合は、[インストールしてください！](http://brew.sh/) コマンドラインで作業する人にとってとても価値があります。`avr-gcc@8` の homebrew でのインストール中、`make` と `make install` 部分は20分以上かかり、CPU使用率が高くなることに注意してください。
+
+## msys2 を使った Windows (推奨) :id=windows-with-msys2-recommended
+
+Windows Vista 以降のバージョン(7および10でテスト済み)について、使用するのに最適な環境は [msys2](http://www.msys2.org) です。
+
+* msys2 をダウンロードし、こちらの指示に従ってインストールしてください: http://www.msys2.org
+* ``MSYS2 MingGW 64-bit`` のショートカットを開きます
+* QMK リポジトリに移動します。例えば、c ドライブのルートにある場合:
+* `$ cd /c/qmk_firmware`
+* `util/qmk_install.sh` を実行し、指示に従います
+
+## Windows 10 (非推奨)
+Windows 10 の古い手順です。[上記の概要のように MSYS2](#windows-with-msys2-recommended) を使うことをお勧めします。
+
+### Creators Update
+Creators Update 以降の Windows 10 の場合、ファームウェアを直接ビルドして書き込むことができます。Creators Update の前は、ビルドだけが可能でした。まだそうではないか、不明な場合は、[これらの指示](https://support.microsoft.com/en-us/instantanswers/d4efb316-79f0-1aa1-9ef3-dcada78f3fa0/get-the-windows-10-creators-update)に従ってください。
+
+### Linux 用の Windows Subsystem
+Creators Update に加えて、Linux 用の Windows 10 Subystem が必要ですので、[これらの指示](http://www.howtogeek.com/249966/how-to-install-and-use-the-linux-bash-shell-on-windows-10/)に従ってインストールしてください。Anniversary update からの Linux 用の Windows 10 Subsystem が既にある場合、一部のキーボードは 14.04LTS に含まれるツールチェーンを使ってコンパイルしないため、16.04LTS に[アップグレード](https://betanews.com/2017/04/14/upgrade-windows-subsystem-for-linux/)することをお勧めします。`sudo do-release-upgrade` メソッドを選択した場合は、自分が何をしているかを知る必要があることに注意してください。
+
+### Git
+すでに Windows ファイルシステムにリポジトリをクローンしている場合は、この章を無視することができます。
+
+WSL Git では**なく**、Windows 用の通常の Git を使って Windows ファイルシステムにリポジトリをクローンする必要があります。以前に Git をインストールしたことが無ければ、[ダウンロード](https://git-scm.com/download/win)し、インストールしてください。次に[セットアップします](https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup)。特に貢献する予定がある場合は、eメールとユーザ名をセットアップすることが重要です。
+
+Git がインストールされたら、Git Bash コマンドを開き、QMK をクローンしたい場所へディレクトリを変更します: スラッシュを使う必要があり、c ドライブは `/c/path/to/where/you/want/to/go` のようにアクセスされることに注意してください。次に、`git clone --recurse-submodules https://github.com/qmk/qmk_firmware` を実行します。これは現在のフォルダのサブディレクトリとして新しいフォルダ `qmk_firmware` を作成します。
+
+### ツールチェーンのセットアップ
+ツールチェーンのセットアップは Linux 用の Windows サブシステムを介して行われ、手順は完全に自動化されています。全てを手動で行いたい場合は、スクリプト以外の手順はありませんが、常に issue を開いて詳細情報を求めることができます。
+
+1. スタートメニューから "Bash On Ubuntu On Windows" を開いてください。
+2. クローンした `qmk_firmware` ディレクトリに移動します。パスは WSL 内で `/mnt/` から始まることに注意してください。つまり、例えば `cd /mnt/c/path/to/qmk_firmware` と書く必要があります。
+3. `util/wsl_install.sh` を実行し、画面上の手順に従います。
+4. Bash コマンドウィンドウを閉じ、再び開きます。
+5. ファームウェアをコンパイルし書き込む準備ができました！
+
+### 心に留めておくべき幾つかの重要なこと
+* 全ての最新の更新を取得するために `util/wsl_install.sh` を再実行することができます。
+* WSL は外部で実行可能ファイルを実行できないため、QMK リポジトリは Windows ファイルシステム上にある必要があります。
+* WSL Git は Windows の Git と互換性が**無い**ため、全ての Git 操作には、Windows Git Bash あるいは windows Git GUI を使ってください。
+* WSL 内あるいは普通に Windows を使ってファイルを編集できますが、makefile あるいはシェルスクリプトを編集する場合は、行末をUnix形式にしてファイルを保存するエディタを使うようにしてください。そうでなければコンパイルは機能しないかもしれません。
+
+## Docker
+
+これが少し複雑な場合は、Docker があなたが必要とするすぐに使える解決法かもしれません。[Docker CE](https://docs.docker.com/install/#supported-platforms) をインストールした後で、キーボード/キーマップをビルドするために `qmk_firmware` ディレクトリから以下のコマンドを実行します:
+```bash
+util/docker_build.sh keyboard:keymap
+# 例えば: util/docker_build.sh ergodox_ez:steno
+```
+これは目的のキーボード/キーマップをコンパイルし、結果として書き込み用に `.hex` あるいは `.bin` ファイルを QMK ディレクトリの中に残します。`:keymap` が省略された場合は全てのキーマップが使われます。パラメータの形式は、`make` を使ってビルドする時と同じであることに注意してください。
+
+スクリプトをパラメータ無しで開始することもできます。この場合、1つずつビルドパラメータを入力するように求められます。これが使いやすいと思うかもしれません:
+```bash
+util/docker_build.sh
+# パラメータを入力として読み込みます (空白にすると全てのキーボード/キーマップ)
+```
+
+`target` を指定することで Docker から直接キーボードをビルドし_かつ_書き込むためのサポートもあります。
+```bash
+util/docker_build.sh keyboard:keymap:target
+# 例えば: util/docker_build.sh planck/rev6:default:flash
+```
+Linux を使っている場合は、これはそのままで動作するはずです。Windows と macOS では、実行するのに [Docker Machine](http://gw.tnode.com/docker/docker-machine-with-usb-support-on-windows-macos/) が必要です。これはセットアップが面倒なので、お勧めではありません: 代わりに [QMK Toolbox](https://github.com/qmk/qmk_toolbox) を使ってください。
+
+!> Docker for Windows は[Hyper-V](https://docs.microsoft.com/en-us/virtualization/hyper-v-on-windows/quick-start/enable-hyper-v) を有効にする必要があります。これは、Windows 7、Windows 8 および **Windows 10 Home** のような Hyper-V を搭載していない Windows のバージョンでは機能しないことを意味します。
+
+## Vagrant
+ファームウェアをビルドするのに問題がある場合は、Vagrant と呼ばれるツールを試してみることができます。それは、ファームウェアをビルドする準備ができた既知の構成を搭載した仮想コンピュータをセットアップします。OLKB はこの仮想コンピュータのためのファイルをホストしません。Vagrant をセットアップする方法の詳細は、[vagrant ガイド](ja/getting_started_vagrant.md)にあります。

docs/ja/getting_started_getting_help.md

@@ -0,0 +1,20 @@
+# 助けを得る
+
+<!---
+  original document: d598f01cb:docs/getting_started_getting_help.md
+  git diff d598f01cb HEAD -- docs/getting_started_getting_help.md | cat
+-->
+
+QMK に関して助けを得るための多くのリソースがあります。
+
+## リアルタイム チャット
+
+メインの [Discord server](https://discord.gg/Uq7gcHh) で QMK の開発者とユーザを見つけることができます。サーバには、ファームウェア、Toolbox、ハードウェアおよび Configurator についてチャットするための特定のチャンネルがあります。
+
+## OLKB Subreddit
+
+公式の QMK フォーラムは [reddit.com](https://reddit.com) の [/r/olkb](https://reddit.com/r/olkb) です。
+
+## Github Issues
+
+[GitHub で issue](https://github.com/qmk/qmk_firmware/issues) を開くことができます。issue が長期的な議論あるいはデバッグを必要とする場合は、特に便利です。

docs/ja/getting_started_github.md

@@ -0,0 +1,70 @@
+# QMK で Github を使う方法
+
+<!---
+  original document: d598f01cb:docs/getting_started_github.md
+  git diff d598f01cb HEAD -- docs/getting_started_github.md | cat
+-->
+
+Github は慣れていない人には少し注意が必要です - このガイドは、QMK におけるフォーク、クローン、プルリクエストのサブミットの各ステップについて説明します。
+
+?> このガイドでは、あなたがコマンドラインでの実行にある程度慣れており、システムに git がインストールされていることを前提にしています。
+
+[QMK Github ページ](https://github.com/qmk/qmk_firmware)を開くと、右上に "Fork" というボタンが見えます:
+
+![Git でのフォーク](http://i.imgur.com/8Toomz4.jpg)
+
+あなたが組織の一員である場合は、どのアカウントにフォークするかを選択する必要があります。ほとんどの場合、あなたの個人のアカウントにフォークしたいでしょう。フォークが完了したら(しばらく時間が掛かる場合があります)、"Clone or Download" ボタンをクリックします:
+
+![Git からダウンロード](http://i.imgur.com/N1NYcSz.jpg)
+
+必ず "HTTPS" を選択し、リンクを選択してコピーします:
+
+![HTTPS リンク](http://i.imgur.com/eGO0ohO.jpg)
+
+ここから、`git clone --recurse-submodules ` をコマンドラインに入力し、リンクを貼り付けます:
+
+```
+user@computer:~$ git clone --recurse-submodules https://github.com/whoeveryouare/qmk_firmware.git
+Cloning into 'qmk_firmware'...
+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'
+```
+
+ローカルマシンに QMK のフォークができるので、キーマップの追加、コンパイル、キーボードへの書き込みができます。変更に満足したら、以下のようにそれらをフォークへ追加、コミットおよびプッシュすることができます:
+
+```
+user@computer:~$ git add .
+user@computer:~$ git commit -m "adding my keymap"
+[master cccb1608] adding my keymap
+ 1 file changed, 1 insertion(+)
+ create mode 100644 keyboards/planck/keymaps/mine/keymap.c
+user@computer:~$ git push
+Counting objects: 1, done.
+Delta compression using up to 4 threads.
+Compressing objects: 100% (1/1), done.
+Writing objects: 100% (1/1), 1.64 KiB | 0 bytes/s, done.
+Total 1 (delta 1), reused 0 (delta 0)
+remote: Resolving deltas: 100% (1/1), completed with 1 local objects.
+To https://github.com/whoeveryouare/qmk_firmware.git
+ + 20043e64...7da94ac5 master -> master
+```
+
+あなたの変更は今では Github 上のフォークにあります - フォーク (`https://github.com/<whoeveryouare>/qmk_firmware`)に戻ると、"New Pull Request" ボタンをクリックすることで新しいプルリクエストを作成することができます:
+
+![New Pull Request](http://i.imgur.com/DxMHpJ8.jpg)
+
+ここでは、コミットした内容を正確に確認することができます - 全て良いように見える場合は、"Create Pull Request" をクリックすることで最終的に承認することができます:
+
+![Create Pull Request](http://i.imgur.com/Ojydlaj.jpg)
+
+サブミットの後で、私たちはあなたの変更について話し、変更を依頼し、最終的にそれを受け入れるでしょう！QMK に貢献してくれてありがとう :)

docs/ja/getting_started_introduction.md

@@ -0,0 +1,65 @@
+# はじめに
+
+<!---
+  original document: d598f01cb:docs/getting_started_introduction.md
+  git diff d598f01cb HEAD -- docs/getting_started_introduction.md | cat
+-->
+
+このページでは、QMK プロジェクトで作業するために知っておくべき基本的な情報について説明しようと思います。Unix シェルの操作に精通していることを前提としていますが、C について、または make を使ったコンパイルについて精通しているとは想定していません。
+
+## 基本的な QMK の構造
+
+QMK は [Jun Wako](https://github.com/tmk) の [tmk_keyboard](https://github.com/tmk/tmk_keyboard) プロジェクトのフォークです。変更された元の TMK コードは、`tmk_core` フォルダで見つけることができます。プロジェクトへの QMK の追加は、`quantum` フォルダで見つけることができます。キーボードプロジェクトは `handwired` および `keyboard` フォルダで見つけることができます。
+
+### ユーザスペースの構造
+
+`users` フォルダ内は各ユーザのためのディレクトリです。これはユーザがキーボード間で使うかもしれないコードを置くためのフォルダです。詳細は[ユーザスペース機能](ja/feature_userspace.md) のドキュメントを見てください。
+
+### キーボードプロジェクトの構造
+
+`keyboards` フォルダ、そのサブフォルダ `handwired`、ベンダと製品のサブディレクトリ (例えば、`clueboard`) の中には、各キーボードプロジェクトのためのディレクトリ (例えば `qmk_firmware/keyboards/clueboard/2x1800`) があります。その中には、以下の構造があります:
+
+* `keymaps/`: ビルドできる様々なキーマップ
+* `rules.mk`: デフォルトの "make" オプションを設定するファイル。このファイルを直接編集しないでください。代わりにキーマップ固有の `rules.mk` を使ってください。
+* `config.h`: デフォルトのコンパイル時のオプションを設定するファイル。このファイルを直接編集しないでください。代わりにキーマップ固有の `config.h` を使ってください。
+* `info.json`: QMK Configurator のためのレイアウトの設定に使われるファイル。詳細は [Configurator サポート](ja/reference_configurator_support.md)を見てください。
+* `readme.md`: キーボードの簡単な概要
+* `<keyboardName>.h`: このファイルは、キーボードのスイッチマトリックスに対してキーボードレイアウトが定義されるファイルです。
+* `<keyboardName>.c`: このファイルには、キーボードのためのカスタムコードがあります。
+
+プロジェクトの構造についての詳細は、[QMK キーボードガイドライン](ja/hardware_keyboard_guidelines.md)を見てください。
+
+### キーマップ構造
+
+全てのキーマップフォルダには、以下のファイルがあります。`keymap.c` だけが必須で、残りのファイルが見つからない場合は、デフォルトのオプションが選択されます。
+
+* `config.h`: キーマップを設定するためのオプション
+* `keymap.c`: 全てのキーマップコード。必須
+* `rules.mk`: 有効になっている QMK の機能
+* `readme.md`: キーマップの説明。他の人が使う方法および機能の説明。imgur のようなサービスに画像をアップロードしてください。
+
+# `config.h` ファイル
+
+3つの `config.h` の場所が考えられます:
+
+* キーボード (`/keyboards/<keyboard>/config.h`)
+* ユーザスペース (`/users/<user>/config.h`)
+* キーマップ (`/keyboards/<keyboard>/keymaps/<keymap>/config.h`)
+
+ビルドシステムは自動的に上の順に config ファイルを取得します。前の `config.h` で設定された設定を上書きしたい場合は、変更したい設定の準備のために最初に定型コードを置く必要があります。
+
+```
+#pragma once
+```
+
+次に、前の `config.h` ファイルの設定を上書きするために、設定を `#undef` し再び `#define` する必要があります。
+
+定型コードと設定は、以下のようになります:
+
+```
+#pragma once
+
+// ここに上書きします！
+#undef MY_SETTING
+#define MY_SETTING 4
+```

docs/ja/getting_started_make_guide.md

@@ -0,0 +1,153 @@
+# より詳細な `make` 手順
+
+<!---
+  original document: 5f35203d1:docs/getting_started_make_guide.md
+  git diff 5f35203d1 HEAD -- docs/getting_started_make_guide.md | cat
+-->
+
+`make` コマンドの完全な構文は `<keyboard_folder>:<keymap>:<target>` です:
+
+* `<keyboard_folder>` はキーボードのパスです。例えば、`planck`
+   * 全てのキーボードをコンパイルするには `all` を使います。
+   * リビジョンを選択してコンパイルするためのパスを指定します。例えば `planck/rev4` あるいは `planck/rev3`
+   * キーボードにフォルダが無い場合は、省略することができます
+   * デフォルトのフォルダをコンパイルする場合は、省略することができます
+* `<keymap>` はキーマップの名前です。例えば、`algernon`
+   * 全てのキーマップをコンパイルするには `all` を使います。
+* `<target>` の詳細は以下で説明します。
+
+`<target>` は以下を意味します
+* target が指定されない場合は、以下の `all` と同じです
+* `all` は指定されたキーボード/リビジョン/キーマップの可能な全ての組み合わせのコンパイルを行います。例えば、`make planck/rev4:default` は1つの .hex を生成しますが、`make planck/rev4:all` は planck で利用可能な全てのキーマップについて hex を生成します。
+* `flash`、`dfu`、`teensy`、`avrdude`、`dfu-util` または `bootloadHID` はファームウェアをコンパイルし、キーボードにアップロードします。コンパイルが失敗すると、何もアップロードされません。使用するプログラマはキーボードに依存します。ほとんどのキーボードでは `dfu` ですが、ChibiOS キーボードについては `dfu-util` 、標準的な Teensy については `teensy` を使います。キーボードに使うコマンドを見つけるには、キーボード固有の readme をチェックしてください。
+* **注意**: 一部のオペレーティングシステムではこれらのコマンドが機能するためには root アクセスが必要です。その場合、例えば `sudo make planck/rev4:default:flash` を実行する必要があります。
+* `clean` は、全てをゼロからビルドするためにビルド出力フォルダを掃除します。説明できない問題がある場合は、通常のコンパイルの前にこれを実行してください。
+
+make コマンドの最後、つまり target の後に追加のオプションを追加することもできます
+
+* `make COLOR=false` - カラー出力をオフ
+* `make SILENT=true` - エラー/警告以外の出力をオフ
+* `make VERBOSE=true` - 全ての gcc のものを出力 (デバッグする必要が無い限り面白くありません)
+* `make EXTRAFLAGS=-E` - コンパイルせずにコードを前処理 (#define コマンドをデバッグしようとする場合に便利)
+
+make コマンド自体にもいくつかの追加オプションがあります。詳細は `make --help` を入力してください。最も有用なのはおそらく `-jx` です。これは複数の CPU を使ってコンパイルしたいことを指定し、`x` は使用したい CPU の数を表します。設定すると、特に多くのキーボード/キーマップをコンパイルしている場合は、コンパイル時間を大幅に短縮することができます。通常は、コンパイル中に他の作業を行うための余裕をもたせるために、持っている CPU の数より1つ少ない値に設定します。全てのオペレーティングシステムと make バージョンがオプションをサポートしているわけではないことに注意してください。
+
+コマンドの例を幾つか示します
+
+* `make all:all` は、全てをビルドします (全てのキーボードフォルダ、全てのキーマップ)。`root` から単に `make` を実行すると、これを実行します。
+* `make ergodox_infinity:algernon:clean` は、Ergodox Infinity キーボードのビルド出力を掃除します。
+* `make planck/rev4:default:flash COLOR=false` カラー出力なしでキーマップをビルドしアップロードします。
+
+## `rules.mk` オプション
+
+無効にするにはこれらの変数を `no` に設定します。有効にするには `yes` に設定します。
+
+`BOOTMAGIC_ENABLE`
+
+これにより、1つのキーとソルトキー(デフォルトではスペース)を押し続けることで、電力が失われても持続する様々な EEPROM 設定へアクセスできます。誤って設定が変更されることが多く、デバッグするのが難しい混乱した結果を生成するため、これを無効にしておくことをお勧めします。ヘルプセッションで発生する、より一般的な問題の1つです。
+
+`MOUSEKEY_ENABLE`
+
+これにより、キーコード/カスタム関数を介して、カーソルの動きとクリックを制御することができます。
+
+`EXTRAKEY_ENABLE`
+
+これにより、システムとオーディオ制御キーコードを使うことができます。
+
+`CONSOLE_ENABLE`
+
+これにより、[`hid_listen`](https://www.pjrc.com/teensy/hid_listen.html) を使って読むことができるメッセージを出力することができます。
+
+デフォルトで、全てのデバッグ( *dprint* ) 出力 ( *print*、*xprintf* )、およびユーザ出力 ( *uprint* ) メッセージが有効になります。これにより、フラッシュメモリの大部分が消費され、キーボードの .hex ファイルが大きすぎてプログラムできなくなるかもしれません。
+
+デバッグメッセージ( *dprint* ) を無効にし、.hex ファイルのサイズを小さくするには、`config.h` に `#define NO_DEBUG` を含めます。
+
+出力メッセージ( *print*、*xprintf* )とユーザ出力( *uprint* ) を無効にし、.hex のファイルサイズを小さくするには、`config.h` に `#define NO_PRINT` を含めます。
+
+出力メッセージ ( *print*、*xprintf* ) を無効にし、ユーザメッセージ ( *uprint* )を**そのままにする**には、`config.h` に `#define USER_PRINT` を含めます(この場合は、`#define NO_PRINT` も含めないでください)。
+
+テキストを見るには、`hid_listen` を開き、出力メッセージを見るのを楽しんでください。
+
+**注意:** キーマップコード以外の *uprint* メッセージを含めないでください。QMK システムフレームワーク内で使うべきではありません。さもないと、他の人の .hex ファイルが肥大化します。
+
+`COMMAND_ENABLE`
+
+これはマジックコマンドを有効にし、通常はデフォルトのマジックキーの組み合わせ `LSHIFT+RSHIFT+KEY` で起動されます。マジックコマンドは、デバッグメッセージ (`MAGIC+D`) の有効化や NKRO の一時的な切り替え (`MAGIC+N`) を含みます。
+
+`SLEEP_LED_ENABLE`
+
+コンピュータがスリープの間に LED がブレスできるようにします。ここでは Timer1 が使われます。この機能は大部分が未使用でテストされておらず、更新もしくは抽象化が必要です。
+
+`NKRO_ENABLE`
+
+これにより、キーボードはホスト OS に最大 248 個のキーが同時に押されていることを伝えることができます (NKRO 無しのデフォルトは 6 です)。NKRO は、`NKRO_ENABLE` が設定されていたとしても、デフォルトではオフです。config.h に `#define FORCE_NKRO` を追加するか、`MAGIC_TOGGLE_NKRO` をキーにバインドしてキーを押すことで、NKRO を強制することができます。
+
+`BACKLIGHT_ENABLE`
+
+これはスイッチ内の LED のバックライトを有効にします。`config.h` 内に以下を入れることでバックライトピンを指定することができます:
+
+    #define BACKLIGHT_PIN B7
+
+`MIDI_ENABLE`
+
+キーボードで MIDI の送受信を有効にします。MIDI 送信モードに入るためにキーコード `MI_ON` を使うことができ、オフにするために `MI_OFF` を使うことができます。これはほとんどテストされていない機能ですが、詳細については `quantum/quantum.c` ファイルで見つけることができます。
+
+`UNICODE_ENABLE`
+
+これによりキーマップで `UC(<code point>)` を使って Unicode 文字を送信することができます。`0x7FFF` までのコードポイントがサポートされます。これはほとんどの現代言語の文字と記号を対象にしますが、絵文字は対象外です。
+
+`UNICODEMAP_ENABLE`
+
+これによりキーマップで `X(<map index>)` を使って Unicode 文字を送信することができます。キーマップファイル内にマッピングテーブルを保持する必要があります。可能な全てのコードポイント( `0x10FFFF` まで)がサポートされます。
+
+`UCIS_ENABLE`
+
+これにより、送信したい文字に対応するニーモニックを入力することで Unicode 文字を送信することができます。キーマップファイル内にマッピングテーブルを保持する必要があります。可能な全てのコードポイント( `0x10FFFF` まで)がサポートされます。
+
+詳細と制限については、[Unicode ページ](ja/feature_unicode.md) を見てください。
+
+`BLUETOOTH_ENABLE`
+
+これによりキーコードをワイヤレスで送信するために Bluefruit EZ-key と連動することができます。D2 と D3 ピンを使います。
+
+`AUDIO_ENABLE`
+
+C6 ピン(抽象化が必要)でオーディオ出力できます。詳細は[オーディオページ](ja/feature_audio.md)を見てください。
+
+`FAUXCLICKY_ENABLE`
+
+クリック音のあるスイッチをエミュレートするためにブザーを使います。Cherry社製の青軸スイッチの安っぽい模倣です。デフォルトでは、`AUDIO_ENABLE` と同じように C6 ピンを使います。
+
+`VARIABLE_TRACE`
+
+これを使って変数の値の変更をデバッグします。詳細についてはユニットテストのページの[変数のトレース](ja/unit_testing.md#tracing-variables)のセクションを見てください。
+
+`API_SYSEX_ENABLE`
+
+これにより Quantum SYSEX API を使って文字列を送信することができます (どこに？)
+
+`KEY_LOCK_ENABLE`
+
+これは [キーロック](ja/feature_key_lock.md) を有効にします。
+
+`SPLIT_KEYBOARD`
+
+分割キーボード (let's split や bakingpy's boards のようなデュアル MCU) のサポートを有効にし、quantum/split_common にある全ての必要なファイルをインクルードします
+
+`SPLIT_TRANSPORT`
+
+ARM ベースの分割キーボード用の標準分割通信ドライバはまだ無いため、これらのために `SPLIT_TRANSPORT = custom` を使わなければなりません。カスタムの実装が使われるようにすることで、標準の分割キーボード通信コード(AVR 固有)が含まれないようにします。
+
+`CUSTOM_MATRIX`
+
+デフォルトのマトリックス走査ルーチンを独自のコードで置き換えます。詳細については、[カスタムマトリックスページ](ja/custom_matrix.md) を見てください。
+
+`DEBOUNCE_TYPE`
+
+デフォルトのキーデバウンスルーチンを別のものに置き換えます。`custom` の場合、独自の実装を提供する必要があります。
+
+## キーマップごとに Makefile オプションをカスタマイズ
+
+あなたのキーマップディレクトリに `rules.mk` というファイルがある場合、そのファイルで設定した全てのオプションは、あなたのキーボードの他の `rules.mk` オプションよりも優先されます。
+
+あなたのキーボードの `rules.mk` に `BACKLIGHT_ENABLE = yes` があるとします。あなたの特定のキーボードでバックライトが無いようにするには、`rules.mk` というファイルを作成し、`BACKLIGHT_ENABLE = no` を指定します。

docs/ja/getting_started_vagrant.md

@@ -0,0 +1,62 @@
+# Vagrant クイックスタート
+
+<!---
+  original document: 7494490d6:docs/getting_started_vagrant.md
+  git diff 7494490d6 HEAD -- docs/getting_started_vagrant.md | cat
+-->
+
+このプロジェクトは、プライマリオペレーティングシステムに大きな変更を加えることなくキーボードの新しいファームウェアを非常に簡単に構築することができる `Vagrantfile` を含みます。これは、あなたがプロジェクトをクローンしビルドを実行した時に、ビルドのために Vagrantfile を使っている他のユーザと全く同じ環境を持つことも保証します。これにより、人々はあなたが遭遇した問題の解決をより簡単に行えるようになります。
+
+## 必要事項
+
+このリポジトリ内の `Vagrantfile` を使うには、[Vagrant](http://www.vagrantup.com/) およびサポートされるプロバイダがインストールされている必要があります:
+
+* [VirtualBox](https://www.virtualbox.org/) (バージョン 5.0.12 以降)
+   * 'Vagrant を使うために最もアクセスしやすいプラットフォーム' として販売
+* [VMware Workstation](https://www.vmware.com/products/workstation) および [Vagrant VMware プラグイン](http://www.vagrantup.com/vmware)
+   * (有料) VMware プラグインには、ライセンスされた VMware Workstation/Fusion のコピーが必要です。
+* [Docker](https://www.docker.com/)
+
+Vagrant 以外に、適切なプロバイダがインストールされ、その後におそらくコンピュータを再起動すると、このプロジェクトをチェックアウトしたフォルダ内の任意の場所で 'vagrant up' を単純に実行することができ、このプロジェクトをビルドするのに必要な全てのツールが含まれる環境(仮想マシンあるいはコンテナ)が開始されます。Vagrant をうまく始めるためのヒントの投稿がありますが、それ以外に、以下のビルドドキュメントを参照することもできます。
+
+## ファームウェアの書き込み
+
+ファームウェアを書き込む"簡単"な方法は、ホスト OS からツールを使うことです:
+
+* [QMK Toolbox](https://github.com/qmk/qmk_toolbox) (推奨)
+* [Teensy ローダー](https://www.pjrc.com/teensy/loader.html)
+* [Atmel FLIP](http://www.atmel.com/tools/flip.aspx)
+
+コマンドラインでプログラムしたい場合は、Vagranfile の ['modifyvm'] 行のコメントを解除して Linux への USB パススルーを有効にし、dfu-util/dfu-programmer のようなコマンドラインツールを使ってプログラムすることができます。あるいは Teensy CLI バージョンをインストールすることができます。
+
+## Vagrantfile の概要
+開発環境は QMK Docker イメージ、`qmkfm/base_container` を実行するように設定されています。これはシステム間の予測可能性が保証されるだけでなく、CI 環境もミラーされます。
+
+## FAQ
+
+### Virtualbox で問題が発生するのはなぜですか？
+Virtualbox 5 の特定のバージョンはこの Vagrantfile のボックスにインストールされている Virtualbox の拡張機能と互換性が無いようです。/vagrant のマウントで問題が発生した場合は、Virtualbox のバージョンを少なくとも 5.0.12 にアップグレードしてください。**または、以下のコマンドを実行してみることができます:**
+
+```console
+vagrant plugin install vagrant-vbguest
+```
+
+### 既存の環境を削除するにはどうすればいいですか？
+あなたの環境での作業が完了しましたか？このプロジェクトをチェックアウトしたフォルダの中のどこからでも、以下を実行してください:
+
+```console
+vagrant destroy
+```
+
+### Docker を直接使いたい場合はどうしますか？
+仮想マシン無しで Vagrant のワークフローを活用したいですか？Vagrantfile は仮想マシンの実行をバイパスし、コンテナを直接実行するように設定されています。Docker を強制的に使うように環境を立ち上げる場合は、以下を実行してください:
+```console
+vagrant up --provider=docker
+```
+
+### Docker コンテナではなく仮想マシンにアクセスするにはどうすればいいですか？
+以下を実行して、公式の QMK ビルダーイメージから直接起動する `vagrant` ユーザをバイパスするようにします:
+
+```console
+vagrant ssh -c 'sudo -i'
+```