Usb max power (#2502)

* add some comment about Helix customize and auto-setup RGBLIGHT_LIMIT_VAL

* add define USB_MAX_POWER_CONSUMPTION

docs/_summary.md

@@ -3,9 +3,16 @@
   * [Install Build Tools](getting_started_build_tools.md)
     * Alternative: [Vagrant Guide](getting_started_vagrant.md)
   * [Build/Compile Instructions](getting_started_make_guide.md)
-  * [Flashing Instructions](flashing.md)
+  * [Flashing Firmware](flashing.md)
   * [Contributing to QMK](contributing.md)
   * [How to Use Github](getting_started_github.md)
+  * [Getting Help](getting_started_getting_help.md)
+
+* [Complete Newbs Guide](newbs.md)
+  * [Getting Started](newbs_getting_started.md)
+  * [Building Your First Firmware](newbs_building_firmware.md)
+  * [Flashing Firmware](newbs_flashing.md)
+  * [Testing and Debugging](newbs_testing_debugging.md)
 
 * [FAQ](faq.md)
   * [General FAQ](faq_general.md)
@@ -25,6 +32,7 @@
   * [Auto Shift](feature_auto_shift.md)
   * [Backlight](feature_backlight.md)
   * [Bootmagic](feature_bootmagic.md)
+  * [Command](feature_command.md)
   * [Dynamic Macros](feature_dynamic_macros.md)
   * [Grave Escape](feature_grave_esc.md)
   * [Key Lock](feature_key_lock.md)
@@ -37,6 +45,7 @@
   * [RGB Lighting](feature_rgblight.md)
   * [Space Cadet](feature_space_cadet.md)
   * [Stenography](feature_stenography.md)
+  * [Swap Hands](feature_swap_hands.md)
   * [Tap Dance](feature_tap_dance.md)
   * [Terminal](feature_terminal.md)
   * [Thermal Printer](feature_thermal_printer.md)
@@ -64,7 +73,7 @@
   * [Customizing Functionality](custom_quantum_functions.md)
   * [Documentation Best Practices](documentation_best_practices.md)
   * [Documentation Templates](documentation_templates.md)
-  * [Glossary](glossary.md)
+  * [Glossary](reference_glossary.md)
   * [Keymap Overview](keymap.md)
   * [Unit Testing](unit_testing.md)
 

docs/custom_quantum_functions.md

@@ -98,10 +98,10 @@ This allows you to control the 5 LED's defined as part of the USB Keyboard spec.
 * `USB_LED_COMPOSE`
 * `USB_LED_KANA`
 
-### Example `led_set_kb()` Implementation
+### Example `led_set_user()` Implementation
 
 ```
-void led_set_kb(uint8_t usb_led) {
+void led_set_user(uint8_t usb_led) {
     if (usb_led & (1<<USB_LED_NUM_LOCK)) {
         PORTB |= (1<<0);
     } else {
@@ -139,14 +139,13 @@ void led_set_kb(uint8_t usb_led) {
 
 Before a keyboard can be used the hardware must be initialized. QMK handles initialization of the keyboard matrix itself, but if you have other hardware like LED's or i&#xb2;c controllers you will need to set up that hardware before it can be used.
 
-### Example `matrix_init_kb()` Implementation
+### Example `matrix_init_user()` Implementation
 
 This example, at the keyboard level, sets up B1, B2, and B3 as LED pins.
 
 ```
-void matrix_init_kb(void) {
+void matrix_init_user(void) {
   // Call the keymap level matrix init.
-  matrix_init_user();
 
   // Set our LED pins as output
   DDRB |= (1<<1);
@@ -176,3 +175,41 @@ This example has been deliberately omitted. You should understand enough about Q
 This function gets called at every matrix scan, which is basically as often as the MCU can handle. Be careful what you put here, as it will get run a lot.
 
 You should use this function if you need custom matrix scanning code. It can also be used for custom status output (such as LED's or a display) or other functionality that you want to trigger regularly even when the user isn't typing.
+
+
+# Layer Change Code
+
+Thir runs code every time that the layers get changed.  This can be useful for layer indication, or custom layer handling. 
+
+### Example `layer_state_set_*` Implementation
+
+This example shows how to set the [RGB Underglow](feature_rgblight.md) lights based on the layer, using the Planck as an example
+
+```
+uint32_t layer_state_set_user(uint32_t state) {
+    switch (biton32(state)) {
+    case _RAISE:
+        rgblight_setrgb (0x00,  0x00, 0xFF);
+        break;
+    case _LOWER:
+        rgblight_setrgb (0xFF,  0x00, 0x00);
+        break;
+    case _PLOVER:
+        rgblight_setrgb (0x00,  0xFF, 0x00);
+        break;
+    case _ADJUST:
+        rgblight_setrgb (0x7A,  0x00, 0xFF);
+        break;
+    default: //  for any other layers, or the default layer
+        rgblight_setrgb (0x00,  0xFF, 0xFF);
+        break;
+    }
+  return state;
+}
+```
+### `matrix_init_*` Function Documentation
+
+* Keyboard/Revision: `void uint32_t layer_state_set_kb(uint32_t state)`
+* Keymap: `uint32_t layer_state_set_user(uint32_t state)`
+
+The `state` is the bitmask of the active layers, as explained in the [Keymap Overview](keymap.md#keymap-layer-status)

docs/eclipse.md

@@ -1,6 +1,6 @@
 # Setting up Eclipse for QMK Development
 
-[Eclipse](https://en.wikipedia.org/wiki/Eclipse_(software)) is an open-source [Integrated Development Environment](https://en.wikipedia.org/wiki/Integrated_development_environment) (IDE) widely used for Java development, but with an extensible plugin system that allows to customize it for other languages and usages.
+[Eclipse][1] is an open-source [Integrated Development Environment](https://en.wikipedia.org/wiki/Integrated_development_environment) (IDE) widely used for Java development, but with an extensible plugin system that allows to customize it for other languages and usages.
 
 Using an IDE such as Eclipse provides many advantages over a plain text editor, such as:
 * intelligent code completion
@@ -17,7 +17,7 @@ Note that this set-up has been tested on Ubuntu 16.04 only for the moment.
 
 # Prerequisites
 ## Build Environment
-Before starting, you must have followed the [Getting Started](home.md#getting-started) section corresponding to your system. In particular, you must have been able to build the firmware with [the `make` command](../#the-make-command).
+Before starting, you must have followed the [Getting Started](README.md#getting-started) section corresponding to your system. In particular, you must have been able to build the firmware with [the `make` command](../#the-make-command).
 
 ## Java
 Eclipse is a Java application, so you will need to install Java 8 or more recent to be able to run it. You may choose between the JRE or the JDK, the latter being useful if you intend to do Java development.
@@ -84,3 +84,5 @@ We will now configure a make target that cleans the project and builds the keyma
 7. (Optional) Toggle the <kbd>Hide Empty Folders</kbd> icon button above the targets tree to only show your build target.
 8. Double-click the build target you created to trigger a build.
 9. Select the <kbd>Console</kbd> view at the bottom to view the running build.
+
+  [1]: https://en.wikipedia.org/wiki/Eclipse_(software)

docs/faq_build.md

@@ -1,40 +1,25 @@
 # Frequently Asked Build Questions
 
-This page covers questions about building QMK. If you have not yet you should read the [Build Environment Setup](getting_started_build_tools.md) and [Make Instructions](getting_started_make_guide.md) guides.
+This page covers questions about building QMK. If you haven't yet done so, you should read the [Build Environment Setup](getting_started_build_tools.md) and [Make Instructions](getting_started_make_guide.md) guides.
 
 ## Can't Program on Linux
-You will need proper permission to operate a device. For Linux users see udev rules below. Easy way is to use `sudo` command, if you are not familiar with this command check its manual with `man sudo` or this page on line.
+You will need proper permissions to operate a device. For Linux users, see the instructions regarding `udev` rules, below. If you have issues with `udev`, a work-around is to use the `sudo` command. If you are not familiar with this command, check its manual with `man sudo` or [see this webpage](https://linux.die.net/man/8/sudo).
 
-In short when your controller is ATMega32u4,
+An example of using `sudo`, when your controller is ATMega32u4:
 
     $ sudo dfu-programmer atmega32u4 erase --force
     $ sudo dfu-programmer atmega32u4 flash your.hex
     $ sudo dfu-programmer atmega32u4 reset
 
-or just
+or just:
 
     $ sudo make <keyboard>:<keymap>:dfu
 
-But to run `make` with root privilege is not good idea. Use former method if possible.
-
-## WINAVR is Obsolete
-It is no longer recommended and may cause some problem.
-See [TMK Issue #99](https://github.com/tmk/tmk_keyboard/issues/99).
-
-## USB VID and PID
-You can use any ID you want with editing `config.h`. Using any presumably unused ID will be no problem in fact except for very low chance of collision with other product.
-
-Most boards in QMK use `0xFEED` as the vendor ID. You should look through other keyboards to make sure you pick a unique Product ID.
-
-Also see this.
-https://github.com/tmk/tmk_keyboard/issues/150
-
-You can buy a really unique VID:PID here. I don't think you need this for personal use.
-- http://www.obdev.at/products/vusb/license.html
-- http://www.mcselec.com/index.php?page=shop.product_details&flypage=shop.flypage&product_id=92&option=com_phpshop&Itemid=1
+Note that running `make` with `sudo` is generally *not* a good idea, and you should use one of the former methods, if possible.
 
 ## Linux `udev` Rules
-On Linux you need proper privilege to access device file of MCU, you'll have to use `sudo` when flashing firmware. You can circumvent this with placing these files in `/etc/udev/rules.d/`.
+On Linux, you'll need proper privileges to access the MCU. You can either use
+`sudo` when flashing firmware, or place these files in `/etc/udev/rules.d/`.
 
 **/etc/udev/rules.d/50-atmel-dfu.rules:**
 ```
@@ -52,6 +37,21 @@ SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", ATTRS{idProduct}=="2ff0", MODE:="066
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
 ```
 
+## WINAVR is Obsolete
+It is no longer recommended and may cause some problem.
+See [TMK Issue #99](https://github.com/tmk/tmk_keyboard/issues/99).
+
+## USB VID and PID
+You can use any ID you want with editing `config.h`. Using any presumably unused ID will be no problem in fact except for very low chance of collision with other product.
+
+Most boards in QMK use `0xFEED` as the vendor ID. You should look through other keyboards to make sure you pick a unique Product ID.
+
+Also see this.
+https://github.com/tmk/tmk_keyboard/issues/150
+
+You can buy a really unique VID:PID here. I don't think you need this for personal use.
+- http://www.obdev.at/products/vusb/license.html
+- http://www.mcselec.com/index.php?page=shop.product_details&flypage=shop.flypage&product_id=92&option=com_phpshop&Itemid=1
 
 ## Cortex: `cstddef: No such file or directory`
 GCC 4.8 of Ubuntu 14.04 had this problem and had to update to 4.9 with this PPA.
@@ -61,7 +61,6 @@ 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.
 

docs/faq_keymap.md

@@ -14,6 +14,15 @@ 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/9ce023dc6caadc0cf11c88c782350a8c -->
 ![Keyboard Layout Image](https://i.imgur.com/45m4mRf.png)
 
+## Some Of My Keys Are Swapped Or Not Working
+
+QMK has two features, Bootmagic and Command, which allow you to change the behavior of your keyboard on the fly. This includes, but is not limited to, swapping Ctrl/Caps, disabling Gui, swapping Alt/Gui, swapping Backspace/Backslash, disabling all keys, and other behavioral modifications. 
+
+As a quick fix try holding down `Space`+`Backspace` while you plug in your keyboard. This will reset the stored settings on your keyboard, returning those keys to normal operation. If that doesn't work look here:
+
+* [Bootmagic](feature_bootmagic.md)
+* [Command](feature_command.md) 
+
 ## The Menu Key Isn't Working
 
 The key found on most modern keyboards that is located between `KC_RGUI` and `KC_RCTL` is actually called `KC_APP`. This is because when that key was invented there was already a key named `MENU` in the relevant standards, so MS chose to call that the `APP` key.
@@ -22,13 +31,13 @@ The key found on most modern keyboards that is located between `KC_RGUI` and `KC
 Use keycode for Print Screen(`KC_PSCREEN` or `KC_PSCR`) instead of `KC_SYSREQ`. Key combination of 'Alt + Print Screen' is recognized as 'System request'.
 
 See [issue #168](https://github.com/tmk/tmk_keyboard/issues/168) and
-- http://en.wikipedia.org/wiki/Magic_SysRq_key
-- http://en.wikipedia.org/wiki/System_request
+* http://en.wikipedia.org/wiki/Magic_SysRq_key
+* http://en.wikipedia.org/wiki/System_request
 
 ## Power Key Doesn't Work
 Use `KC_PWR` instead of `KC_POWER` or vice versa.
-- `KC_PWR` works with Windows and Linux, not with OSX.
-- `KC_POWER` works with OSX and Linux, not with Windows.
+* `KC_PWR` works with Windows and Linux, not with OSX.
+* `KC_POWER` works with OSX and Linux, not with Windows.
 
 More info: http://geekhack.org/index.php?topic=14290.msg1327264#msg1327264
 
@@ -40,9 +49,9 @@ https://github.com/tmk/tmk_keyboard/issues/67
 Modifier keys or layers can be stuck unless layer switching is configured properly.
 For Modifier keys and layer actions you have to place `KC_TRANS` on same position of destination layer to  unregister the modifier key or return to previous layer on release event.
 
-- https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#31-momentary-switching
-- http://geekhack.org/index.php?topic=57008.msg1492604#msg1492604
-- https://github.com/tmk/tmk_keyboard/issues/248
+* https://github.com/tmk/tmk_core/blob/master/doc/keymap.md#31-momentary-switching
+* http://geekhack.org/index.php?topic=57008.msg1492604#msg1492604
+* https://github.com/tmk/tmk_keyboard/issues/248
 
 
 ## Mechanical Lock Switch Support
@@ -66,17 +75,17 @@ See this post for example **MACRO** code.
 http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-120.html#p195620
 
 On **Windows** you can use `AltGr` key or **Alt code**.
-- http://en.wikipedia.org/wiki/AltGr_key
-- http://en.wikipedia.org/wiki/Alt_code
+* http://en.wikipedia.org/wiki/AltGr_key
+* http://en.wikipedia.org/wiki/Alt_code
 
 On **Mac** OS defines `Option` key combinations.
-- http://en.wikipedia.org/wiki/Option_key#Alternative_keyboard_input
+* http://en.wikipedia.org/wiki/Option_key#Alternative_keyboard_input
 
 On **Xorg** you can use `compose` key, instead.
-- http://en.wikipedia.org/wiki/Compose_key
+* http://en.wikipedia.org/wiki/Compose_key
 
 And see this for **Unicode** input.
-- http://en.wikipedia.org/wiki/Unicode_input
+* http://en.wikipedia.org/wiki/Unicode_input
 
 
 ## Apple/Mac Keyboard `Fn`

docs/feature_advanced_keycodes.md

@@ -116,7 +116,7 @@ These are the values you can use for the `mod` in `MT()` and `OSM()`:
   * MOD_HYPR
   * MOD_MEH
 
-These can also be combined like `MOD_LCTL | MOD_LSFT` e.g. `MT(MOD_LCTL | MOD_LSFT, KC_ESC)` which would activate Control and Shift when held, and send Escape when tapped. Note however, that you cannot mix right and left side modifiers.
+These can also be combined like `MOD_LCTL | MOD_LSFT` e.g. `MT(MOD_LCTL | MOD_LSFT, KC_ESC)` which would activate Control and Shift when held, and send Escape when tapped.
 
 We've added shortcuts to make common modifier/tap (mod-tap) mappings more compact:
 
@@ -129,6 +129,12 @@ We've added shortcuts to make common modifier/tap (mod-tap) mappings more compac
   * `LCAG_T(kc)` - is CtrlAltGui when held and *kc* when tapped
   * `MEH_T(kc)` - is like Hyper, but not as cool -- does not include the Cmd/Win key, so just sends Alt+Ctrl+Shift.
 
+{% hint style='info' %}
+Due to the way that keycodes are structured, any modifiers specified as part of `kc`, such as `LCTL()` or `KC_LPRN`, will only activate when held instead of tapped.
+
+Additionally, if there is at least one right modifier, any other modifiers will turn into their right equivalents, so it is not possible to "mix and match" the two.
+{% endhint %}
+
 # One Shot Keys
 
 One shot keys are keys that remain active until the next key is pressed, and then are 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".

docs/feature_audio.md

@@ -82,7 +82,7 @@ The pitch standard (`PITCH_STANDARD_A`) is 440.0f by default - to change this, a
 
     #define PITCH_STANDARD_A 432.0f
 
-You can completely disable Music Mode as well. This is useful, if you're pressed for space on your controller.  To disable it, add this to your `confid.h`:
+You can completely disable Music Mode as well. This is useful, if you're pressed for space on your controller.  To disable it, add this to your `config.h`:
 
     #define NO_MUSIC_MODE
 

docs/feature_bootmagic.md

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

docs/feature_command.md

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

docs/feature_macros.md

@@ -22,7 +22,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 		switch(keycode) {
 			case MY_CUSTOM_MACRO:
 				SEND_STRING("QMK is the best thing ever!"); // this is our macro!
-				return false; break;
+				return false;
 		}
 	}
 	return true;
@@ -56,10 +56,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 		switch(keycode) {
 			case MY_CUSTOM_MACRO:
 				SEND_STRING("QMK is the best thing ever!");
-				return false; break;
+				return false;
 			case MY_OTHER_MACRO:
 				SEND_STRING(SS_LCTRL("ac")); // selects all and copies
-				return false; break;
+				return false;
 		}
 	}
 	return true;
@@ -97,6 +97,7 @@ There's also a couple of mod shortcuts you can use:
 * `SS_LGUI(string)`
 * `SS_LALT(string)`
 * `SS_LSFT(string)`
+* `SS_RALT(string)`
 
 These press the respective modifier, send the supplied string and then release the modifier.
 They can be used like this:

docs/feature_mouse_keys.md

@@ -5,17 +5,17 @@ Mousekeys is a feature that allows you to emulate a mouse using your keyboard. Y
 
 ## Adding Mousekeys to a Keymap
 
-There are two steps to adding Mousekeys support to your keyboard. You must enable support in the Makefile and you must map mouse actions to keys on your keyboard.
+There are two steps to adding Mousekeys support to your keyboard. You must enable support in the `rules.mk` file and you must map mouse actions to keys on your keyboard.
 
-### Adding Mousekeys Support in the `Makefile`
+### Adding Mousekeys Support in the `rules.mk`
 
-To add support for Mousekeys you simply need to add a single line to your keymap's `Makefile`:
+To add support for Mousekeys you simply need to add a single line to your keymap's `rules.mk`:
 
 ```
 MOUSEKEY_ENABLE = yes
 ```
 
-You can see an example here: https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/keymaps/mouse_keys/Makefile
+You can see an example here: https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/66/keymaps/mouse_keys/rules.mk
 
 ### Mapping Mouse Actions to Keyboard Keys
 
@@ -40,7 +40,7 @@ You can use these keycodes within your keymap to map button presses to mouse act
 |`KC_MS_ACCEL1`  |`KC_ACL1`|Set mouse acceleration to 1|
 |`KC_MS_ACCEL2`  |`KC_ACL2`|Set mouse acceleration to 2|
 
-You can see an example in the `_ML` here: https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/keymaps/mouse_keys/keymap.c#L46
+You can see an example in the `_ML` here: https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/66/keymaps/mouse_keys/keymap.c#L46
 
 ## Configuring the Behavior of Mousekeys
 

docs/feature_swap_hands.md

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

docs/getting_started_build_tools.md

@@ -31,11 +31,15 @@ git
 
 Install the dependencies with your favorite package manager.
 
-Debian/Ubuntu example:
+Debian / Ubuntu example:
 
     sudo apt-get update
     sudo apt-get install gcc unzip wget zip gcc-avr binutils-avr avr-libc dfu-programmer dfu-util gcc-arm-none-eabi binutils-arm-none-eabi libnewlib-arm-none-eabi
 
+Fedora / Red Hat example:
+
+    sudo dnf install gcc unzip wget zip dfu-util dfu-programmer avr-gcc avr-libc binutils-avr32-linux-gnu arm-none-eabi-gcc-cs arm-none-eabi-binutils-cs arm-none-eabi-newlib
+
 ## Nix
 
 If you're on [NixOS](https://nixos.org/), or have Nix installed on Linux or macOS, run `nix-shell` from the repository root to get a build environment.
@@ -128,7 +132,7 @@ docker run -e keymap=gwen -e keyboard=ergodox_ez --rm -v $('pwd'):/qmk:rw edasqu
 On Windows Docker seems to have issues with the VOLUME tag in Dockerfile, and `$('pwd')` won't print a Windows compliant path; use full path instead, like this:
 
 ```bash
-docker run -e keymap=default -e keyboard=ergobox_ez --rm -v D:/Users/Sacapuces/Documents/Repositories/qmk:/qmk:rw edasque/qmk_firmware
+docker run -e keymap=default -e keyboard=ergodox_ez --rm -v D:/Users/Sacapuces/Documents/Repositories/qmk:/qmk:rw edasque/qmk_firmware
 
 ```
 

docs/getting_started_getting_help.md

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

docs/hardware_keyboard_guidelines.md

@@ -4,7 +4,7 @@ We welcome all keyboard projects into QMK, but ask that you try to stick to a co
 
 ## Naming Your Keyboard/Project
 
-All names should be lowercase alphanumeric, and separated by an underscore (`_`), but not begin with one. Your directory and your `.h` and `.c` files should have exactly the same name. All folders should follow the same format.
+All names should be lowercase alphanumeric, and separated by an underscore (`_`), but not begin with one. Your directory and your `.h` and `.c` files should have exactly the same name. All folders should follow the same format. `test`, `keyboard`, and `all` are reserved by make and are not a valid name for a keyboard.
 
 ## `readme.md`
 
@@ -16,6 +16,22 @@ In an effort to keep the repo size down, we're no longer accepting images of any
 
 Any sort of hardware file (plate, case, pcb) can't be stored in qmk_firmware, but we have the [qmk.fm repo](https://github.com/qmk/qmk.fm) where such files (as well as in-depth info) can be stored and viewed on [qmk.fm](http://qmk.fm). Downloadable files are stored in `/<keyboard>/` (name follows the same format as above) which are served at `http://qmk.fm/<keyboard>/`, and pages are generated from `/_pages/<keyboard>/` which are served at the same location (.md files are generated into .html files through Jekyll). Check out the `lets_split` directory for an example.
 
+## Keyboard Defaults
+
+Given the amount of functionality that QMK exposes it's very easy to confuse new users. When putting together the default firmware for your keyboard we recommend limiting your enabled features and options to the minimal set needed to support your hardware. Recommendations for specific features follow.
+
+### Bootmagic and Command
+
+(Bootmagic)[feature_bootmagic.md) and (Command)[feature_command.md) are two related features that allow a user to control their keyboard in non-obvious ways. We recommend you think long and hard about if you're going to enable either feature, and how you will expose this functionality. Keep in mind that users who want this functionality can enable it in their personal keymaps without affecting all the novice users who may be using your keyboard as their first programmable board.
+
+By far the most common problem new users encounter is accidentally triggering Bootmagic while they're plugging in their keyboard. They're holding the keyboard by the bottom, unknowingly pressing in alt and spacebar, and then they find that these keys have been swapped on them. We recommend leaving this feature disabled by default, but if you do turn it on consider setting `BOOTMAGIC_KEY_SALT` to a key that is hard to press while plugging your keyboard in.
+
+If your keyboard does not have 2 shift keys you should provide a working default for `IS_COMMAND`, even when you have set `COMMAND_ENABLE = no`. This will give your users a default to conform to if they do enable Command.
+
+## Custom Keyboard Programming
+
+As documented on (Customizing Functionality)[custom_quantum_functions.md] you can define custom functions for your keyboard. Please keep in mind that your users may want to customize that behavior as well, and make it possible for them to do that. If you are providing a custom function, for example `process_record_kb()`, make sure that your function calls the `_user()` version of the call too. You should also take into account the return value of the `_user()` version, and only run your custom code if the user returns `true`.
+
 ## Keyboard Metadata
 
 As QMK grows so does the ecosystem surrounding QMK. To make it easier for projects in that ecosystem to tie into QMK as we make changes we are developing a metadata system to expose information about keyboards in QMK.

docs/keycodes.md

@@ -366,7 +366,7 @@ This is a reference only. Each group of keys links to the page documenting their
 |`KC_RIGHT_ANGLE_BRACKET`|`KC_GT`/`KC_RABK` |`>`                |
 |`KC_QUESTION`           |`KC_QUES`         |`?`                |
 
-## [Switching and Toggling Layers](feature_common_shortcuts.md#switching-and-toggling-layers)
+## [Switching and Toggling Layers](feature_advanced_keycodes.md#switching-and-toggling-layers)
 
 |Key            |Description                                                                       |
 |---------------|----------------------------------------------------------------------------------|

docs/keymap.md

@@ -33,7 +33,7 @@ The state of the Keymap layer is determined by two 32 bit parameters:
 * **`default_layer_state`** indicates a base keymap layer (0-31) which is always valid and to be referred (the default layer).
 * **`layer_state`** has current on/off status of each layer in its bits.
 
-Keymap layer '0' is usually `default_layer`, wither other layers initially off after booting up the firmware, although this can configured differently in `config.h`. It is useful to change `default_layer` when you completely switch a key layout, for example, if you want to switch to Colemak instead of Qwerty.
+Keymap layer '0' is usually the `default_layer`, with other layers initially off after booting up the firmware, although this can configured differently in `config.h`. It is useful to change `default_layer` when you completely switch a key layout, for example, if you want to switch to Colemak instead of Qwerty.
 
     Initial state of Keymap          Change base layout
     -----------------------          ------------------

docs/newbs.md

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

docs/newbs_building_firmware.md

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

docs/newbs_flashing.md

@@ -0,0 +1,79 @@
+# Flashing Your Keyboard With QMK Toolbox
+
+Now that you've built a custom firmware file you'll want to flash your keyboard. 
+
+## Load The File Into QMK Toolbox
+
+Begin by opening the QMK Toolbox application. You'll want to locate the firmware file in Finder or Explorer. Your keyboard firmware may be in one of two formats- `.hex` or `.bin`. QMK tries to copy the appropriate one for your keyboard into the root `qmk_firmware` directory.
+
+{% hint style='info' %}
+If you are on Windows or macOS there are commands you can use to easily open the current firmware folder in Explorer or Finder.
+
+Windows:
+
+    start .
+
+macOS:
+
+    open .
+{% endhint %}
+
+The firmware file always follows this naming format:
+
+    <keyboard_name>_<keymap_name>.{bin,hex}
+
+For example, the `plank/rev5` with a `default` keymap will have this filename:
+
+    planck_rev5_default.hex
+
+Once you have located your firmware file drag it into the "Local file" box in QMK Toolbox, or click "Open" and navigate to where your firmware file is stored. 
+
+## Put Your Keyboard Into DFU (Bootloader) Mode
+
+In order to flash your custom firmware you have to put your keyboard into a special flashing mode. While it is in this mode you will not be able to type or otherwise use your keyboard. It is very important that you do not unplug your keyboard or otherwise interrupt the flashing process while the firmware is being written.
+
+Different keyboards have different ways to enter this special mode. If your PCB currently runs QMK or TMK and you have not been given specific instructions try the following, in order:
+
+* Hold down both shift keys and press `Pause`
+* Hold down both shift keys and press `B`
+* Unplug your keyboard, hold down the Spacebar and `B` at the same time, plug in your keyboard and wait a second before releasing the keys
+* Press the physical `RESET` button on the bottom of the PCB
+* Locate header pins on the PCB labeled `BOOT0` or `RESET`, short those together while plugging your PCB in
+
+When you are successful you will see a message similar to this in QMK Toolbox:
+
+```
+*** Clueboard - Clueboard 66% HotSwap disconnected -- 0xC1ED:0x2390
+*** DFU device connected
+```
+
+## Flash Your Keyboard
+
+Click the `Flash` button in QMK Toolbox. You will see output similar to the following:
+
+```
+*** Clueboard - Clueboard 66% HotSwap disconnected -- 0xC1ED:0x2390
+*** DFU device connected
+*** Attempting to flash, please don't remove device
+>>> dfu-programmer atmega32u4 erase --force
+    Erasing flash...  Success
+    Checking memory from 0x0 to 0x6FFF...  Empty.
+>>> dfu-programmer atmega32u4 flash /Users/skully/qmk_firmware/clueboard_66_hotswap_gen1_skully.hex
+    Checking memory from 0x0 to 0x55FF...  Empty.
+    0%                            100%  Programming 0x5600 bytes...
+    [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
+    0%                            100%  Reading 0x7000 bytes...
+    [>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]  Success
+    Validating...  Success
+    0x5600 bytes written into 0x7000 bytes memory (76.79%).
+>>> dfu-programmer atmega32u4 reset
+    
+*** DFU device disconnected
+*** Clueboard - Clueboard 66% HotSwap connected -- 0xC1ED:0x2390
+```
+
+## Test It Out!
+
+Congrats! Your custom firmware has been programmed to your keyboard!
+
+Give it a try and make sure everything works the way you want it to. We've written [Testing and Debugging](newbs_testing_debugging.md) to round out this Newbie Guide, so head over there to learn about how to troubleshoot your custom functionality.

docs/newbs_getting_started.md

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

docs/newbs_testing_debugging.md

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

docs/redirects.json

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

docs/reference_glossary.md

@@ -4,7 +4,7 @@
 A line of 32-bit MCU's produced by a number of companies, such as Atmel, Cypress, Kinetis, NXP, ST, and TI.
 
 ## AVR
-A line of 8-bit MCU's produced by [Atmel](http://atmel.com). AVR was the original platform that TMK supported.
+A line of 8-bit MCU's produced by [Atmel](http://www.microchip.com/). AVR was the original platform that TMK supported.
 
 ## AZERTY
 The standard Français (French) keyboard layout. Named for the first 6 keys on the keyboard.

docs/understanding_qmk.md

@@ -77,7 +77,7 @@ At the keyboard level we define a C macro (typically named `KEYMAP()`) which map
 
 Notice how the second block of our `KEYMAP()` macro matches the Matrix Scanning array above? This macro is what will map the matrix scanning array to keycodes. However, if you look at a 17 key numpad you'll notice that it has 3 places where the matrix could have a switch but doesn't, due to larger keys. We have populated those spaces with `KC_NO` so that our keymap definition doesn't have to.
 
-You can also use this macro to handle unusual matrix layouts, for example the [Clueboard rev 2](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/rev2/rev2.h). Explaining that is outside the scope of this document.
+You can also use this macro to handle unusual matrix layouts, for example the [Clueboard rev 2](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/66/rev2/rev2.h). Explaining that is outside the scope of this document.
 
 ##### Keycode Assignment
 
@@ -135,8 +135,8 @@ The `process_record()` function itself is deceptively simple, but hidden within
 * [`void process_record(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/tmk_core/common/action.c#L128)
   * [`bool process_record_quantum(keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L140)
     * [Map this record to a keycode](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L143)
-    * [`bool process_record_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/cluecard.c#L20)
-      * [`bool process_record_user(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/keymaps/default/keymap.c#L58)
+    * [`bool process_record_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/card/card.c#L20)
+      * [`bool process_record_user(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/clueboard/card/keymaps/default/keymap.c#L58)
     * [`bool process_midi(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_midi.c#L102)
     * [`bool process_audio(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_audio.c#L10)
     * [`bool process_music(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_music.c#L69)

keyboards/1up60rgb/1up60rgb.c

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

keyboards/1up60rgb/1up60rgb.h

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

keyboards/1up60rgb/config.h

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

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

@@ -0,0 +1,72 @@
+#include "1up60rgb.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+	KEYMAP(
+		KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_BSPC,
+		KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSLS,
+		KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_ENT,
+		KC_LSFT, KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_RSFT,
+		KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RGUI, MO(1), KC_RCTL),
+
+	KEYMAP(
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+	;
+
+	switch (id) {
+
+	}
+	return MACRO_NONE;
+}
+
+void matrix_init_user(void) {
+}
+
+void matrix_scan_user(void) {
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	return true;
+}
+
+void led_set_user(uint8_t usb_led) {
+
+	if (usb_led & (1 << USB_LED_NUM_LOCK)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
+		DDRB |= (1 << 2); PORTB &= ~(1 << 2);
+	} else {
+		DDRB &= ~(1 << 2); PORTB &= ~(1 << 2);
+	}
+
+	if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_COMPOSE)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_KANA)) {
+
+	} else {
+
+	}
+
+}

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

@@ -0,0 +1,72 @@
+#include "1up60rgb.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+	KEYMAP(
+		KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_BSPC,
+		KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_ENT,
+		KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_NUHS, KC_ENT,
+		KC_LSFT, KC_NUBS, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, KC_RSFT,
+		KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_RALT, KC_RGUI, MO(1), KC_RCTL),
+
+	KEYMAP(
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+	;
+
+	switch (id) {
+
+	}
+	return MACRO_NONE;
+}
+
+void matrix_init_user(void) {
+}
+
+void matrix_scan_user(void) {
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	return true;
+}
+
+void led_set_user(uint8_t usb_led) {
+
+	if (usb_led & (1 << USB_LED_NUM_LOCK)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
+		DDRB |= (1 << 2); PORTB &= ~(1 << 2);
+	} else {
+		DDRB &= ~(1 << 2); PORTB &= ~(1 << 2);
+	}
+
+	if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_COMPOSE)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_KANA)) {
+
+	} else {
+
+	}
+
+}

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

@@ -0,0 +1,72 @@
+#include "1up60rgb.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+	KEYMAP(
+		KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSLS, KC_GRV,
+		KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSPC,
+		KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_ENT,
+		KC_LSFT, KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_RSFT, MO(1),
+		KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, KC_NO, KC_RALT, KC_RGUI, KC_RCTL),
+
+	KEYMAP(
+		RESET, 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,
+		KC_TRNS, BL_TOGG, BL_DEC, BL_INC, BL_STEP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR, KC_UP, 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_LEFT, KC_RGHT, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, RGB_TOG, RGB_MOD, RGB_HUI, RGB_HUD, RGB_SAI, RGB_SAD, RGB_VAI, RGB_VAD, KC_TRNS, KC_DOWN, KC_TRNS, KC_TRNS,
+		KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS)
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+	;
+
+	switch (id) {
+
+	}
+	return MACRO_NONE;
+}
+
+void matrix_init_user(void) {
+}
+
+void matrix_scan_user(void) {
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	return true;
+}
+
+void led_set_user(uint8_t usb_led) {
+
+	if (usb_led & (1 << USB_LED_NUM_LOCK)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_CAPS_LOCK)) {
+		DDRB |= (1 << 2); PORTB &= ~(1 << 2);
+	} else {
+		DDRB &= ~(1 << 2); PORTB &= ~(1 << 2);
+	}
+
+	if (usb_led & (1 << USB_LED_SCROLL_LOCK)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_COMPOSE)) {
+
+	} else {
+
+	}
+
+	if (usb_led & (1 << USB_LED_KANA)) {
+
+	} else {
+
+	}
+
+}

keyboards/1up60rgb/readme.md

@@ -0,0 +1,13 @@
+# 1upkeyboards 60% RGB
+
+Firmware for custom keyboard PCB with 60% key layout.
+
+Keyboard Maintainer: [rempired](https://github.com/rempired)  
+Hardware Supported: 1upkeyboards 60% RGB  
+Hardware Availability: [1upkeyboards](https://1upkeyboards.com/rgb-underglow-1up-pcb.html)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make 1up60rgb:default
+
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/1up60rgb/rules.mk

@@ -0,0 +1,56 @@
+# MCU name
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Boot Section Size in *bytes*
+OPT_DEFS += -DBOOTLOADER_SIZE=4096
+
+
+# Build Options
+#   comment out to disable the options.
+#
+BOOTMAGIC_ENABLE ?= yes	# Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE ?= yes	# Mouse keys(+4700)
+EXTRAKEY_ENABLE ?= yes	# Audio control and System control(+450)
+CONSOLE_ENABLE ?= no	# Console for debug(+400)
+COMMAND_ENABLE ?= no    # Commands for debug and configuration
+SLEEP_LED_ENABLE ?= no  # Breathing sleep LED during USB suspend
+NKRO_ENABLE ?= yes		# USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE ?= yes  # Enable keyboard backlight functionality
+AUDIO_ENABLE ?= no
+RGBLIGHT_ENABLE ?= yes

keyboards/atreus/keymaps/dvorak_42_key/keymap.c

@@ -14,6 +14,19 @@
 
 static bool mouse_lock = false;
 
+enum custom_keycodes {
+  PLACEHOLDER = SAFE_RANGE, // can always be here
+
+  // Cloud9 macros
+  CLOUD9_TAB_LEFT,
+  CLOUD9_TAB_RIGHT,
+  CLOUD9_TAB_CLOSE,
+  CLOUD9_GOTO_SYMBOL,
+  CLOUD9_GOTO_LINE,
+  CLOUD9_NAVIGATE,
+  
+};
+
 // building instructions:
 // make atreus:dvorak_42_key
 
@@ -30,10 +43,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 },	
 
 [KEYNAV] = { 
-  {KC_ESC,      MEH(KC_F9),  RCTL(KC_Z),   RCTL(KC_S), MEH(KC_F10), KC_TRNS,    KC_TRNS,       KC_HOME,    KC_UP,           KC_END,     KC_PGUP, },
-  {MEH(KC_F11), MEH(KC_F12), RSFT(KC_TAB), KC_TAB,     MEH(KC_A),   KC_TRNS,    LCTL(KC_LEFT), KC_LEFT,    KC_DOWN,         KC_RIGHT,   LCTL(KC_RIGHT), },
-  {MEH(KC_B),   MEH(KC_C),   MEH(KC_D),    MEH(KC_E),  MEH(KC_F),   KC_TRNS,    KC_TRNS,       RCTL(KC_C), RCTL(KC_X),      RCTL(KC_V), KC_PGDOWN, },
-  {KC_TRNS,     KC_TRNS,     KC_TRNS,      KC_TRNS,    KC_TRNS,     KC_ENTER,   KC_SPACE,      KC_BSPC,   RCTL(KC_BSPC),    KC_DELETE,  LCTL(KC_DELETE), }
+  {KC_ESC,      CLOUD9_GOTO_LINE,   RCTL(KC_Z),      RCTL(KC_S),       MEH(KC_F10),      KC_TRNS,    KC_TRNS,       KC_HOME,    KC_UP,           KC_END,     KC_PGUP, },
+  {MEH(KC_F11), CLOUD9_GOTO_SYMBOL, RSFT(KC_TAB),    KC_TAB,           MEH(KC_A),        KC_TRNS,    LCTL(KC_LEFT), KC_LEFT,    KC_DOWN,         KC_RIGHT,   LCTL(KC_RIGHT), },
+  {MEH(KC_B),   CLOUD9_NAVIGATE,    CLOUD9_TAB_LEFT, CLOUD9_TAB_RIGHT, CLOUD9_TAB_CLOSE, KC_TRNS,    KC_TRNS,       RCTL(KC_C), RCTL(KC_X),      RCTL(KC_V), KC_PGDOWN, },
+  {KC_TRNS,     KC_TRNS,            KC_TRNS,         KC_TRNS,          KC_TRNS,          KC_ENTER,   KC_SPACE,      KC_BSPC,   RCTL(KC_BSPC),    KC_DELETE,  LCTL(KC_DELETE), }
 },	
 
 [KEYSEL] = { 
@@ -64,6 +77,40 @@ const uint16_t PROGMEM fn_actions[] = {
 
 };
 
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  if(record->event.pressed) {
+    switch (keycode) {
+		// Cloud9 macros
+		case CLOUD9_TAB_LEFT:
+            SEND_STRING(SS_LCTRL("["));
+            return true;		
+			break;
+		case CLOUD9_TAB_RIGHT:
+            SEND_STRING(SS_LCTRL("]"));
+            return true;				
+			break;
+		case CLOUD9_TAB_CLOSE:
+            SEND_STRING(SS_LALT("w"));
+            return true;				
+			break;
+		case CLOUD9_GOTO_SYMBOL:
+            SEND_STRING(SS_LSFT(SS_LCTRL("e")));
+            return true;		
+			break;
+		case CLOUD9_GOTO_LINE:
+            SEND_STRING(SS_LCTRL("g"));
+            return true;						
+			break;
+		case CLOUD9_NAVIGATE:
+            SEND_STRING(SS_LCTRL("e"));
+            return true;
+			break;		
+	}
+  }
+	
+  return true;
+}
+
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 {
   // MACRODOWN only works in this function

keyboards/chimera_ergo/chimera_ergo.c

@@ -0,0 +1,31 @@
+#include "chimera_ergo.h"
+
+void uart_init(void) {
+	SERIAL_UART_INIT();
+}
+
+void led_init(void) {
+	DDRD  |= (1<<1);
+	PORTD |= (1<<1);
+	DDRF  |= (1<<4) | (1<<5);
+	PORTF |= (1<<4) | (1<<5);
+}
+
+
+void matrix_init_kb(void) {
+	// put your keyboard start-up code here
+	// runs once when the firmware starts up
+	matrix_init_user();
+	uart_init();
+	led_init();
+}
+
+void matrix_scan_kb(void) {
+	// put your looping keyboard code here
+	// runs every cycle (a lot)
+	matrix_scan_user();
+}
+
+void led_set_kb(uint8_t usb_led) {
+
+}

keyboards/chimera_ergo/chimera_ergo.h

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

keyboards/chimera_ergo/config.h

@@ -0,0 +1,87 @@
+/*
+Copyright 2012 Jun Wako <wakojun@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6060
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    unknown
+#define PRODUCT         Chimera Ergo
+#define DESCRIPTION     q.m.k. keyboard firmware for Chimera Ergo
+
+/* key matrix size */
+#define MATRIX_ROWS 6
+#define MATRIX_COLS 12
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+//#define BACKLIGHT_LEVELS 3
+
+#define ONESHOT_TIMEOUT 500
+
+
+/* key combination for command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+#define PREVENT_STUCK_MODIFIERS
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION
+
+//UART settings for communication with the RF microcontroller
+#define SERIAL_UART_BAUD 1000000
+#define SERIAL_UART_DATA UDR1
+#define SERIAL_UART_UBRR (F_CPU / (16UL * SERIAL_UART_BAUD) - 1)
+#define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1))
+#define SERIAL_UART_RXD_PRESENT (UCSR1A & _BV(RXC1))
+#define SERIAL_UART_INIT() do { \
+    	/* baud rate */ \
+    	UBRR1L = SERIAL_UART_UBRR; \
+    	/* baud rate */ \
+    	UBRR1H = SERIAL_UART_UBRR >> 8; \
+    	/* enable TX and RX */ \
+    	UCSR1B = _BV(TXEN1) | _BV(RXEN1); \
+    	/* 8-bit data */ \
+    	UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
+  	} while(0)
+
+#endif

keyboards/chimera_ergo/keymaps/default/keymap.c

@@ -0,0 +1,206 @@
+// this is the style you want to emulate.
+// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
+
+#include "chimera_ergo.h"
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+enum chimera_ergo_layers
+{
+	_QWERTY,
+	_CAPS,
+	_NUMPAD,
+	_SYMBOLS,
+	_MACROS,
+	_NAV
+};
+
+#define KC_NMPD TG(_NUMPAD)
+#define KC_SYMB TG(_SYMBOLS)
+#define KC_SPFN LT(_NAV,KC_EQL)
+#define KC_SCTL MT(MOD_LCTL, KC_LBRC)
+#define KC_SCTR MT(MOD_LCTL, KC_RBRC)
+#define KC_SPLT MT(MOD_LALT, KC_MINS)
+#define KC_SPRT MT(MOD_LALT, KC_1)
+#define KC_GBRC MT(MOD_RGUI, KC_RBRC)
+#define KC_GQOT MT(MOD_LGUI, KC_QUOT)
+#define KC_MESC LT(_MACROS, KC_ESC)
+#define KC_INCL M(0)
+#define KC_PULL M(1)
+#define KC_PUSH M(2)
+#define KC_SCAP M(3)
+#define KC_SCOF M(4)
+#define KC_CAD LALT(LCTL(KC_DEL))
+
+#define LONGPRESS_DELAY 150
+//#define LAYER_TOGGLE_DELAY 300
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+#define KC_ KC_TRNS 
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+  [_QWERTY] = KC_KEYMAP(
+  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
+     LBRC, 1  ,SCTL,SPLT,SPFN, 5  ,       6  ,GBRC,SPRT,SCTR, 0  ,RBRC,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+     MESC, Q  , W  , E  , R  , T  ,       Y  , U  , I  , O  , P  ,QUOT,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+     TAB , A  , S  , D  , F  , G  ,       H  , J  , K  , L  ,SCLN,ENT ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+     LSPO, Z  , X  , C  , V  , B  ,       N  , M  ,COMM,DOT ,SLSH,RSPC,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+                         NMPD,BSPC,      SPC ,SYMB
+  // \------------------+----+----/      \---+----+----+--------------/
+  ),
+
+  [_CAPS] = KC_KEYMAP(
+  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
+         ,UNDS,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,COLN,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+     SCOF,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,SCOF,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+                             ,    ,          ,
+  // \------------------+----+----/      \---+----+----+--------------/
+  ),
+
+  [_NUMPAD] = KC_KEYMAP(
+  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
+         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,MINS,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+         ,    ,COLN,    ,    ,    ,          , 7  , 8  , 9  ,ASTR,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+         ,    ,DOT ,    ,    ,    ,          , 4  , 5  , 6  ,PLUS,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,          , 1  , 2  , 3  ,SLSH,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+                             ,    ,          , 0
+  // \------------------+----+----/      \---+----+----+--------------/
+  ),
+
+  [_SYMBOLS] = KC_KEYMAP(
+  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
+         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+         ,EXLM, AT ,HASH,DLR ,PERC,      CIRC,AMPR,ASTR,LPRN,RPRN,BSLS,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+      F1 , F2 , F3 , F4 , F5 , F6 ,      TILD,EQL ,UNDS,LCBR,RCBR,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+      F7 , F8 , F9 ,F10 ,F11 ,F12 ,      GRV ,PLUS,MINS,LBRC,RBRC,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+                         PIPE,    ,          ,
+  // \------------------+----+----/      \---+----+----+--------------/
+  ),
+
+  [_MACROS] = KC_KEYMAP(  
+  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
+         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,          ,    ,INCL,    ,    ,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+         ,    ,    ,CAD ,    ,    ,          ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+     SCAP,    ,    ,    ,    ,    ,          ,    ,PULL,PUSH,    ,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+                             ,    ,          ,    
+  // \------------------+----+----/      \---+----+----+--------------/
+  ),
+
+  [_NAV] = KC_KEYMAP(  
+  //,----+----+----+----+----+----.     ,----+----+----+----+----+----.
+         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,          ,PGUP, UP ,PGDN,PSCR,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,          ,LEFT,DOWN,RGHT,    ,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----|     |----+----+----+----+----+----|
+                             ,DEL ,          ,    
+  // \------------------+----+----/      \---+----+----+--------------/
+  ),
+
+
+};
+
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  switch(id) {
+    /* include some kind of library or header */
+    case 0:
+      if (record->event.pressed) {
+        SEND_STRING("#include <>");
+        return MACRO( T(LEFT), END);
+      }
+      break;
+    case 1:
+      if (record->event.pressed) {
+        SEND_STRING("git pull");
+        return MACRO( T(ENT), END );
+      }
+      break;
+    case 2:
+      if (record->event.pressed){
+        SEND_STRING("git push");
+        return MACRO( T(ENT), END );
+      }
+      break;
+    case 3:
+      if (record->event.pressed){
+        layer_on(_CAPS);
+        register_code(KC_CAPSLOCK);
+        unregister_code(KC_CAPSLOCK);
+      }
+      break;
+    case 4:
+      if (record->event.pressed){
+        layer_off(_CAPS);
+        register_code(KC_CAPSLOCK);
+        unregister_code(KC_CAPSLOCK);
+      }
+      break;
+  }
+  return MACRO_NONE;
+};
+ 
+
+void matrix_scan_user(void) {
+    uint8_t layer = biton32(layer_state);
+    
+    switch (layer) {
+    	case _QWERTY:
+    	    set_led_green;
+    	    break;
+        case _CAPS:
+	    set_led_white;
+	    break;
+        case _NUMPAD:
+            set_led_blue;
+            break;
+        case _SYMBOLS:
+            set_led_red;
+            break;
+        case _NAV:
+	    set_led_magenta;
+	    break;
+        case _MACROS:
+	    set_led_cyan;
+	    break;
+       default:
+            set_led_green;
+            break;
+    }
+};

keyboards/chimera_ergo/matrix.c

@@ -0,0 +1,164 @@
+/*
+Copyright 2012 Jun Wako
+Copyright 2014 Jack Humbert
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <stdint.h>
+#include <stdbool.h>
+#if defined(__AVR__)
+#include <avr/io.h>
+#endif
+#include "wait.h"
+#include "print.h"
+#include "debug.h"
+#include "util.h"
+#include "matrix.h"
+#include "timer.h"
+
+#if (MATRIX_COLS <= 8)
+#    define print_matrix_header()  print("\nr/c 01234567\n")
+#    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop(matrix[i])
+#    define ROW_SHIFTER ((uint8_t)1)
+#elif (MATRIX_COLS <= 16)
+#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF\n")
+#    define print_matrix_row(row)  print_bin_reverse16(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop16(matrix[i])
+#    define ROW_SHIFTER ((uint16_t)1)
+#elif (MATRIX_COLS <= 32)
+#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
+#    define print_matrix_row(row)  print_bin_reverse32(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop32(matrix[i])
+#    define ROW_SHIFTER  ((uint32_t)1)
+#endif
+
+/* matrix state(1:on, 0:off) */
+static matrix_row_t matrix[MATRIX_ROWS];
+
+__attribute__ ((weak))
+void matrix_init_quantum(void) {
+    matrix_init_kb();
+}
+
+__attribute__ ((weak))
+void matrix_scan_quantum(void) {
+    matrix_scan_kb();
+}
+
+__attribute__ ((weak))
+void matrix_init_kb(void) {
+    matrix_init_user();
+}
+
+__attribute__ ((weak))
+void matrix_scan_kb(void) {
+    matrix_scan_user();
+}
+
+__attribute__ ((weak))
+void matrix_init_user(void) {
+}
+
+__attribute__ ((weak))
+void matrix_scan_user(void) {
+}
+
+inline
+uint8_t matrix_rows(void) {
+    return MATRIX_ROWS;
+}
+
+inline
+uint8_t matrix_cols(void) {
+    return MATRIX_COLS;
+}
+
+void matrix_init(void) {
+
+    matrix_init_quantum();
+}
+
+uint8_t matrix_scan(void)
+{
+    SERIAL_UART_INIT();
+
+    uint32_t timeout = 0;
+
+    //the s character requests the RF slave to send the matrix
+    SERIAL_UART_DATA = 's';
+
+    //trust the external keystates entirely, erase the last data
+    uint8_t uart_data[14] = {0};
+
+    //there are 10 bytes corresponding to 10 columns, and an end byte
+    for (uint8_t i = 0; i < 14; i++) {
+        //wait for the serial data, timeout if it's been too long
+        //this only happened in testing with a loose wire, but does no
+        //harm to leave it in here
+        while(!SERIAL_UART_RXD_PRESENT){
+            timeout++;
+            if (timeout > 10000){
+                break;
+            }
+        } 
+        uart_data[i] = SERIAL_UART_DATA;
+    }
+
+    //check for the end packet, the key state bytes use the LSBs, so 0xE0
+    //will only show up here if the correct bytes were recieved
+    if (uart_data[10] == 0xE0)
+    {
+        //shifting and transferring the keystates to the QMK matrix variable
+        for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+            matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 6;
+        }
+    }
+
+
+    matrix_scan_quantum();
+    return 1;
+}
+
+inline
+bool matrix_is_on(uint8_t row, uint8_t col)
+{
+    return (matrix[row] & ((matrix_row_t)1<col));
+}
+
+inline
+matrix_row_t matrix_get_row(uint8_t row)
+{
+    return matrix[row];
+}
+
+void matrix_print(void)
+{
+    print_matrix_header();
+
+    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+        phex(row); print(": ");
+        print_matrix_row(row);
+        print("\n");
+    }
+}
+
+uint8_t matrix_key_count(void)
+{
+    uint8_t count = 0;
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+        count += matrix_bitpop(i);
+    }
+    return count;
+}

keyboards/chimera_ergo/readme.md

@@ -0,0 +1,19 @@
+# Chimera Ergo
+
+![Chimera Ergo](https://imgur.com/AA6ycMQ.jpg)
+
+A split wireless 40% ergonomic keyboard 
+
+Keyboard Maintainer: [William Wilson](https://github.com/GlenPickle)  
+
+
+Hardware Supported: Chimera Ergo PCB, WaveShare core nRF51822
+
+Hardware Availability: [Gerbers](https://github.com/GlenPickle/Chimera/tree/master/ergo/gerbers)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make chimera_ergo:default
+
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
+

keyboards/chimera_ergo/rules.mk

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

keyboards/chimera_ls/chimera_ls.c

@@ -0,0 +1,31 @@
+#include "chimera_ls.h"
+
+void uart_init(void) {
+	SERIAL_UART_INIT();
+}
+
+void led_init(void) {
+	DDRD  |= (1<<1);
+	PORTD |= (1<<1);
+	DDRF  |= (1<<4) | (1<<5);
+	PORTF |= (1<<4) | (1<<5);
+}
+
+
+void matrix_init_kb(void) {
+	// put your keyboard start-up code here
+	// runs once when the firmware starts up
+	matrix_init_user();
+	uart_init();
+	led_init();
+}
+
+void matrix_scan_kb(void) {
+	// put your looping keyboard code here
+	// runs every cycle (a lot)
+	matrix_scan_user();
+}
+
+void led_set_kb(uint8_t usb_led) {
+
+}

keyboards/chimera_ls/chimera_ls.h

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

keyboards/chimera_ls/config.h

@@ -0,0 +1,87 @@
+/*
+Copyright 2012 Jun Wako <wakojun@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6060
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    unknown
+#define PRODUCT         Chimera Lets Split
+#define DESCRIPTION     q.m.k. keyboard firmware for Chimera Lets Split
+
+/* key matrix size */
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 12
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+//#define BACKLIGHT_LEVELS 3
+
+#define ONESHOT_TIMEOUT 500
+
+
+/* key combination for command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+#define PREVENT_STUCK_MODIFIERS
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION
+
+//UART settings for communication with the RF microcontroller
+#define SERIAL_UART_BAUD 1000000
+#define SERIAL_UART_DATA UDR1
+#define SERIAL_UART_UBRR (F_CPU / (16UL * SERIAL_UART_BAUD) - 1)
+#define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1))
+#define SERIAL_UART_RXD_PRESENT (UCSR1A & _BV(RXC1))
+#define SERIAL_UART_INIT() do { \
+    	/* baud rate */ \
+    	UBRR1L = SERIAL_UART_UBRR; \
+    	/* baud rate */ \
+    	UBRR1H = SERIAL_UART_UBRR >> 8; \
+    	/* enable TX and RX */ \
+    	UCSR1B = _BV(TXEN1) | _BV(RXEN1); \
+    	/* 8-bit data */ \
+    	UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
+  	} while(0)
+
+#endif

keyboards/chimera_ls/keymaps/default/keymap.c

@@ -0,0 +1,191 @@
+// this is the style you want to emulate.
+// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
+
+#include "chimera_ls.h"
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+enum chimera_lets_split_layers
+{
+	_QWERTY,
+	_CAPS,
+	_NUMPAD,
+	_SYMBOLS,
+	_MACROS,
+	_NAV
+};
+
+#define KC_NMPD TG(_NUMPAD)
+#define KC_SYMB TG(_SYMBOLS)
+#define KC_SPFN LT(_NAV,KC_EQL)
+#define KC_SCTL MT(MOD_LCTL, KC_BSLS)
+#define KC_SCTR MT(MOD_LCTL, KC_RBRC)
+#define KC_SPLT MT(MOD_LALT, KC_MINS)
+#define KC_MESC LT(_MACROS, KC_ESC)
+#define KC_INCL M(0)
+#define KC_PULL M(1)
+#define KC_PUSH M(2)
+#define KC_SCAP M(3)
+#define KC_SCOF M(4)
+#define KC_CAD LALT(LCTL(KC_DEL))
+
+#define LONGPRESS_DELAY 150
+//#define LAYER_TOGGLE_DELAY 300
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+#define KC_ KC_TRNS 
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+  [_QWERTY] = KC_KEYMAP(
+  //,----+----+----+----+----+----.    ,----+----+----+----+----+----.
+     MESC, Q  , W  , E  , R  , T  ,      Y  , U  , I  , O  , P  ,BSPC,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+     TAB , A  , S  , D  , F  , G  ,      H  , J  , K  , L  ,SCLN, ENT,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+     LSPO, Z  , X  , C  , V  , B  ,      N  , M  ,COMM,DOT ,SLSH,RSPC,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+     SCTL,SPFN,SPLT,AMPR,NMPD,SPC ,     SPC ,SYMB,ASTR,EXLM,LBRC,SCTR
+  //`----+----+----+----+----+----'    `----+----+----+----+----+----'
+  ),
+
+  [_CAPS] = KC_KEYMAP(
+  //,----+----+----+----+----+----.    ,----+----+----+----+----+----.
+         ,    ,    ,    ,    ,    ,         ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,         ,    ,    ,    ,COLN,    ,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,         ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+         ,    ,UNDS,    ,    ,    ,         ,    ,    ,    ,    ,    
+  //`----+----+----+----+----+----'    `----+----+----+----+----+----'
+  ),
+
+
+  [_NUMPAD] = KC_KEYMAP(
+  //,----+----+----+----+----+----.    ,----+----+----+----+----+----.
+         ,    ,    ,    ,    ,    ,         ,  7 ,  8 ,  9 ,MINS,QUOT,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,         ,  4 ,  5 ,  6 ,PLUS, ENT,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+     LSFT,    ,    ,    ,    ,    ,         ,  1 ,  2 ,  3 ,ASTR, EQL,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,BSPC,     SPC ,  0 ,  0 , DOT,SLSH,    
+  //`----+----+----+----+----+----'    `----+----+----+----+----+----'
+  ),
+
+  [_SYMBOLS] = KC_KEYMAP(
+  //,----+----+----+----+----+----.    ,----+----+----+----+----+----.
+         ,EXLM, AT ,HASH,DLR ,PERC,     CIRC,AMPR,ASTR,LPRN,RPRN,QUOT,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+      F1 , F2 , F3 , F4 , F5 , F6 ,     TILD,EQL ,UNDS,LCBR,RCBR,PIPE,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+      F7 , F8 , F9 , F10, F11, F12,     GRV ,PLUS,MINS,LBRC,RBRC,BSLS,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+         ,    ,    ,    , NO ,BSPC,     SPC ,    ,    ,    ,    ,    
+  //`----+----+----+----+----+----'    `----+----+----+----+----+----'
+  ),
+
+  [_NAV] = KC_KEYMAP(
+  //,----+----+----+----+----+----.    ,----+----+----+----+----+----.
+         ,    ,    ,    , DEL,BSPC,         ,HOME, UP , END, INS,PSCR,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+         ,    ,    ,LSFT,LCTL, ENT,         ,LEFT,DOWN,RGHT, DEL,   ,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,         ,PGUP,PGDN,    ,    ,    ,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,DEL ,         ,    ,    ,    ,    ,   
+  //`----+----+----+----+----+----'    `----+----+----+----+----+----'
+  ),
+
+  [_MACROS] = KC_KEYMAP(
+  //,----+----+----+----+----+----.    ,----+----+----+----+----+----.
+         ,    ,    ,    ,    ,    ,         ,    ,INCL,    ,    ,    ,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+         ,    ,    ,CAD ,    ,    ,         ,    ,    ,    ,    ,    ,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+     SCAP,    ,    ,    ,    ,    ,         ,    ,PULL,PUSH,    ,SCAP,
+  //|----+----+----+----+----+----|    |----+----+----+----+----+----|
+         ,    ,    ,    ,    ,    ,         ,    ,    ,    ,    ,   
+  //`----+----+----+----+----+----'    `----+----+----+----+----+----'
+  ),
+
+};
+
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  switch(id) {
+    /* include some kind of library or header */
+    case 0:
+      if (record->event.pressed) {
+        SEND_STRING("#include <>");
+        return MACRO( T(LEFT), END);
+      }
+      break;
+    case 1:
+      if (record->event.pressed) {
+        SEND_STRING("git pull");
+        return MACRO( T(ENT), END );
+      }
+      break;
+    case 2:
+      if (record->event.pressed){
+        SEND_STRING("git push");
+        return MACRO( T(ENT), END );
+      }
+      break;
+    case 3:
+      if (record->event.pressed){
+        layer_on(_CAPS);
+        register_code(KC_CAPSLOCK);
+        unregister_code(KC_CAPSLOCK);
+      }
+      break;
+    case 4:
+      if (record->event.pressed){
+        layer_off(_CAPS);
+        register_code(KC_CAPSLOCK);
+        unregister_code(KC_CAPSLOCK);
+      }
+      break;
+  }
+  return MACRO_NONE;
+};
+ 
+
+void matrix_scan_user(void) {
+    uint8_t layer = biton32(layer_state);
+    
+    switch (layer) {
+    	case _QWERTY:
+    	    set_led_green;
+    	    break;
+        case _CAPS:
+	    set_led_white;
+	    break;
+        case _NUMPAD:
+            set_led_blue;
+            break;
+        case _SYMBOLS:
+            set_led_red;
+            break;
+        case _NAV:
+	    set_led_magenta;
+	    break;
+        case _MACROS:
+	    set_led_cyan;
+	    break;
+       default:
+            set_led_green;
+            break;
+    }
+};

keyboards/chimera_ls/matrix.c

@@ -0,0 +1,168 @@
+/*
+Copyright 2012 Jun Wako
+Copyright 2014 Jack Humbert
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <stdint.h>
+#include <stdbool.h>
+#if defined(__AVR__)
+#include <avr/io.h>
+#endif
+#include "wait.h"
+#include "print.h"
+#include "debug.h"
+#include "util.h"
+#include "matrix.h"
+#include "timer.h"
+
+#if (MATRIX_COLS <= 8)
+#    define print_matrix_header()  print("\nr/c 01234567\n")
+#    define print_matrix_row(row)  print_bin_reverse8(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop(matrix[i])
+#    define ROW_SHIFTER ((uint8_t)1)
+#elif (MATRIX_COLS <= 16)
+#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF\n")
+#    define print_matrix_row(row)  print_bin_reverse16(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop16(matrix[i])
+#    define ROW_SHIFTER ((uint16_t)1)
+#elif (MATRIX_COLS <= 32)
+#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
+#    define print_matrix_row(row)  print_bin_reverse32(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop32(matrix[i])
+#    define ROW_SHIFTER  ((uint32_t)1)
+#elif (MATRIX_COLS <= 64)
+#    define print_matrix_header()  print("\nr/c 0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF\n")
+#    define print_matrix_row(row)  print_bin_reverse64(matrix_get_row(row))
+#    define matrix_bitpop(i)       bitpop64(matrix[i])
+#    define ROW_SHIFTER  ((uint64_t)1)
+#endif
+
+/* matrix state(1:on, 0:off) */
+static matrix_row_t matrix[MATRIX_ROWS];
+
+__attribute__ ((weak))
+void matrix_init_quantum(void) {
+    matrix_init_kb();
+}
+
+__attribute__ ((weak))
+void matrix_scan_quantum(void) {
+    matrix_scan_kb();
+}
+
+__attribute__ ((weak))
+void matrix_init_kb(void) {
+    matrix_init_user();
+}
+
+__attribute__ ((weak))
+void matrix_scan_kb(void) {
+    matrix_scan_user();
+}
+
+__attribute__ ((weak))
+void matrix_init_user(void) {
+}
+
+__attribute__ ((weak))
+void matrix_scan_user(void) {
+}
+
+inline
+uint8_t matrix_rows(void) {
+    return MATRIX_ROWS;
+}
+
+inline
+uint8_t matrix_cols(void) {
+    return MATRIX_COLS;
+}
+
+void matrix_init(void) {
+    matrix_init_quantum();
+}
+
+uint8_t matrix_scan(void)
+{
+    SERIAL_UART_INIT();
+
+    uint32_t timeout = 0;
+
+    //the s character requests the RF slave to send the matrix
+    SERIAL_UART_DATA = 's';
+
+    //trust the external keystates entirely, erase the last data
+    uint8_t uart_data[11] = {0};
+
+    //there are 10 bytes corresponding to 10 columns, and an end byte
+    for (uint8_t i = 0; i < 11; i++) {
+        //wait for the serial data, timeout if it's been too long
+        //this only happened in testing with a loose wire, but does no
+        //harm to leave it in here
+        while(!SERIAL_UART_RXD_PRESENT){
+            timeout++;
+            if (timeout > 10000){
+                break;
+            }
+        } 
+        uart_data[i] = SERIAL_UART_DATA;
+    }
+
+    //check for the end packet, the key state bytes use the LSBs, so 0xE0
+    //will only show up here if the correct bytes were recieved
+    if (uart_data[10] == 0xE0)
+    {
+        //shifting and transferring the keystates to the QMK matrix variable
+        for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+            matrix[i] = (uint16_t) uart_data[i*2] | (uint16_t) uart_data[i*2+1] << 5;
+        }
+    }
+
+
+    matrix_scan_quantum();
+    return 1;
+}
+
+inline
+bool matrix_is_on(uint8_t row, uint8_t col)
+{
+    return (matrix[row] & ((matrix_row_t)1<col));
+}
+
+inline
+matrix_row_t matrix_get_row(uint8_t row)
+{
+    return matrix[row];
+}
+
+void matrix_print(void)
+{
+    print_matrix_header();
+
+    for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
+        phex(row); print(": ");
+        print_matrix_row(row);
+        print("\n");
+    }
+}
+
+uint8_t matrix_key_count(void)
+{
+    uint8_t count = 0;
+    for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
+        count += matrix_bitpop(i);
+    }
+    return count;
+}

keyboards/chimera_ls/readme.md

@@ -0,0 +1,19 @@
+# Chimera LS
+
+![Chimera LS](https://imgur.com/FOGlO4M.jpg)
+
+A wireless version of the let's split: a split 40% ortholinear keyboard 
+
+Keyboard Maintainer: [William Wilson](https://github.com/GlenPickle)  
+
+
+Hardware Supported: Chimera LS PCB, WaveShare core nRF51822
+
+Hardware Availability: [Gerbers](https://github.com/GlenPickle/Chimera/tree/master/ls/gerbers)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make chimera_ls:default
+
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
+

keyboards/chimera_ls/rules.mk

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

keyboards/chimera_ortho/chimera_ortho.h

@@ -49,7 +49,7 @@
 // This a shortcut to help you visually see your layout.
 // The first section contains all of the arguements
 // The second converts the arguments into a two-dimensional array
-#define KEYMAP( \
+#define KC_KEYMAP( \
   k00, k01, k02, k03, k04, k05, k06,      k07, k08, k09, k10, k11, k12, k13, \
   k14, k15, k16, k17, k18, k19, k20,      k21, k22, k23, k24, k25, k26, k27, \
   k28, k29, k31, k32, k33, k34, k35,      k36, k37, k38, k41, k42, k43, k44,\
@@ -63,4 +63,17 @@
 	{ KC_NO,      KC_##k28, KC_##k14, KC_##k00, KC_##k45,      KC_##k48, KC_##k13, KC_##k27, KC_##k44, KC_NO }, \
 }
 
+#define KEYMAP( \
+  k00, k01, k02, k03, k04, k05, k06,      k07, k08, k09, k10, k11, k12, k13, \
+  k14, k15, k16, k17, k18, k19, k20,      k21, k22, k23, k24, k25, k26, k27, \
+  k28, k29, k31, k32, k33, k34, k35,      k36, k37, k38, k41, k42, k43, k44,\
+                      k45, k46,               k47, k48      \
+) \
+{ \
+	{ k01,   k02, k03, k04, k05,      k08, k09, k10, k11, k12   }, \
+	{ k15,   k16, k17, k18, k19,      k22, k23, k24, k25, k26   }, \
+	{ k29,   k31, k32, k33, k34,      k37, k38, k41, k42, k43   }, \
+	{ KC_NO,      k06, k20, k35, k46,      k47, k36, k21, k07, KC_NO },  \
+	{ KC_NO,      k28, k14, k00, k45,      k48, k13, k27, k44, KC_NO }, \
+}
 #endif

keyboards/chimera_ortho/keymaps/default/keymap.c

@@ -44,7 +44,7 @@ enum chimera_ortho_layers
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
-  [_QWERTY] = KEYMAP(  
+  [_QWERTY] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
      MESC, Q  , W  , E  , R  , T  ,SCTL,      SCTR, Y  , U  , I  , O  , P  ,QUOT,
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
@@ -56,7 +56,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // \------------------+----+----+---/       \---+----+----+-------------------/
   ),
 
-  [_CAPS] = KEYMAP(  
+  [_CAPS] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
          ,    ,    ,    ,    ,    ,    ,          ,    ,    ,    ,    ,    ,    ,
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
@@ -68,7 +68,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // \------------------+----+----+---/       \---+----+----+-------------------/
   ),
 
-  [_NUMPAD] = KEYMAP(  
+  [_NUMPAD] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
          ,    ,COLN ,    ,    ,    ,    ,          ,    , 7  , 8  , 9  ,ASTR,MINS,
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
@@ -80,7 +80,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // \------------------+----+----+---/       \---+----+----+-------------------/
   ),
 
-  [_SYMBOLS] = KEYMAP(  
+  [_SYMBOLS] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
          ,EXLM, AT ,HASH,DLR ,PERC,    ,          ,CIRC,AMPR,ASTR,LPRN,RPRN,BSLS,
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
@@ -92,7 +92,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // \------------------+----+----+---/       \---+----+----+-------------------/
   ),
 
-  [_NAV] = KEYMAP(  
+  [_NAV] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
          ,    ,    ,    ,    ,    ,    ,          ,    ,    , UP ,    ,PSCR,    ,
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
@@ -104,7 +104,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // \------------------+----+----+---/       \---+----+----+-------------------/
   ),
 
-  [_MACROS] = KEYMAP(  
+  [_MACROS] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
          ,    ,    ,    ,    ,    ,    ,          ,    ,    ,INCL,    ,    ,    ,
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|

keyboards/chimera_ortho/keymaps/gordon/keymap.c

@@ -206,7 +206,7 @@ qk_tap_dance_action_t tap_dance_actions[] = {
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
-  [_QWERTY] = KEYMAP(
+  [_QWERTY] = KC_KEYMAP(
   //,----+----+----+----+----+----+----.      ,----+----+----+----+----+----+----.
      MESC, Q  ,CSHW,ENAV, R  , T  ,SPC ,       CLPS, Y  , U  ,INAV, O  , P  ,TTT,
   //|----+----+----+----+----+----+----|      |----+----+----+----+----+----+----|
@@ -218,7 +218,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // \------------------+----+----+---/       \---+----+----+-------------------/
   ),
 
-  [_NUMPAD] = KEYMAP(  
+  [_NUMPAD] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
          ,    ,    ,    ,ASTR,    ,    ,          ,    , 7  , 8  , 9  ,ASTR,/**/,
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
@@ -230,7 +230,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // \------------------+----+----+---/       \---+----+----+-------------------/
   ),
 
-  [_SYMBOLS] = KEYMAP(  
+  [_SYMBOLS] = KC_KEYMAP(  
   //,----+----+-----+----+----+----+----.     ,----+----+----+----+----+----+----.
          ,EXLM, AT  ,LCBR,RCBR,HASH,    ,          ,CIRC,AMPR,ASTR,LPRN,RPRN,/**/,
   //|----+----+-----+----+----+----+----|     |----+----+----+----+----+----+----|
@@ -242,7 +242,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // \-------------------+----+----+---/       \---+----+----+-------------------/
   ),
 
-  [_FUNCTION] = KEYMAP(  
+  [_FUNCTION] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
     F6F7 ,F1  ,F2  ,F3  ,ALF4,F5  ,F6  ,      F7  ,F8  ,F9  ,F10 ,F11 ,F12 ,/**/,
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
@@ -254,7 +254,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // \------------------+----+----+---/       \---+----+----+-------------------/
   ),
 
-  [_NAV] = KEYMAP(  
+  [_NAV] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
       ,   ,SNAPLEFT,/**/,SNAPRIGHT,,  ,           ,    ,    , UP ,    ,    ,    ,
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
@@ -266,7 +266,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // \------------------+----+----+---/       \---+----+----+-------------------/
   ),
 
-  [_TEXTNAV] = KEYMAP(  
+  [_TEXTNAV] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
          ,   ,    ,    ,    ,    ,  ,             ,    ,    ,/**/,    ,    ,    ,
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
@@ -278,7 +278,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // \------------------+----+----+---/       \---+----+----+-------------------/
   ),
 
-   [_MOUSE] = KEYMAP(  
+   [_MOUSE] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
          ,    ,    ,MS_UP,   ,   ,    ,      ,    ,    , UP ,    ,    ,    ,/**/
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|
@@ -291,7 +291,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   ), 
 
 
-  [_MACROS] = KEYMAP(  
+  [_MACROS] = KC_KEYMAP(  
   //,----+----+----+----+----+----+----.     ,----+----+----+----+----+----+----.
     /**/,RESET,SECRET_2,SECRET_3,   ,   ,   ,SYSTEM_SLEEP,    ,    ,INCL,    ,    ,    ,
   //|----+----+----+----+----+----+----|     |----+----+----+----+----+----+----|

keyboards/clueboard/60/keymaps/yanfali/keymap.c

@@ -0,0 +1,134 @@
+#include "60.h"
+
+#define _______ KC_TRNS
+
+enum keyboard_layers {
+    _BL,
+    _FL,
+    _CL,
+    _YF
+};
+
+enum custom_keycodes {
+    S_BSKTC = SAFE_RANGE,
+    S_ODEJY,
+    S_RCKBY,
+    S_DOEDR,
+    S_SCALE,
+    S_ONEUP,
+    S_COIN,
+    S_SONIC,
+    S_ZELDA
+};
+
+#ifdef AUDIO_ENABLE
+  float song_basketcase[][2] = SONG(BASKET_CASE);
+  float song_ode_to_joy[][2]  = SONG(ODE_TO_JOY);
+  float song_rock_a_bye_baby[][2]  = SONG(ROCK_A_BYE_BABY);
+  float song_doe_a_deer[][2]  = SONG(DOE_A_DEER);
+  float song_scale[][2]  = SONG(MUSIC_SCALE_SOUND);
+  float song_coin[][2]  = SONG(COIN_SOUND);
+  float song_one_up[][2]  = SONG(ONE_UP_SOUND);
+  float song_sonic_ring[][2]  = SONG(SONIC_RING);
+  float song_zelda_puzzle[][2]  = SONG(ZELDA_PUZZLE);
+#endif
+
+const uint16_t keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    /* Layer 0: Default Layer
+     * ,-----------------------------------------------------------------.
+     * |Esc      |  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|  `|BSp|
+     * |-----------------------------------------------------------------|
+     * |Tab        |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|    \|
+     * |-----------------------------------------------------------------|
+     * |MT(CTL, ESC)|  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '|Enter   |
+     * |-----------------------------------------------------------------|
+     * |Shift         |  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /|Shift |Fn0|
+     * |-----------------------------------------------------------------'
+     * |Ctrl       |Alt|Gui  |         Space         |Alt  |Gui|Fn |Ctrl |
+     * `-----------------------------------------------------------------'
+     */
+    [_BL] = KEYMAP(
+      KC_GESC,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_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,     \
+      MT(MOD_LCTL, KC_ESC),     KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,   KC_L,   KC_SCLN,KC_QUOT,KC_NUHS,  KC_ENT,  \
+      KC_LSFT,  KC_NUBS,KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM,KC_DOT, KC_SLSH,  KC_RSFT,   MO(_YF), \
+      KC_LCTL,  KC_LALT,  KC_LGUI,                        KC_SPC,                      KC_RALT,  KC_RGUI,  MO(_FL),   KC_RCTL),
+    [_FL] = KEYMAP(
+      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, _______,_______,\
+      _______,   _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,     \
+      _______,     _______,MO(_CL),_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,  _______, \
+      _______,  _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,  _______,   MO(_YF), \
+      _______,_______,_______,                        _______,                     _______,  _______,  MO(_FL),   _______),
+    [_CL] = KEYMAP(
+      BL_STEP,S_BSKTC,S_ODEJY,S_RCKBY,S_DOEDR,S_SCALE,S_ONEUP,S_COIN, S_SONIC,S_ZELDA,_______,_______,_______,_______,_______,\
+      _______,   _______,_______,_______,RESET,  _______,_______,_______,_______,_______,_______,_______,_______,_______,     \
+      _______,     _______,MO(_CL),_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,  _______, \
+      _______,  _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,     MO(_YF), \
+      _______,  _______,  _______,                        _______,                     _______,  _______,  MO(_FL),   _______),
+    [_YF] = KEYMAP(
+      _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,\
+      _______,_______,KC_UP  ,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,        \
+      _______,KC_LEFT,KC_DOWN,KC_RIGHT,_______,_______,_______,_______,_______,_______,_______,_______,_______,  _______,     \
+      _______,  _______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,_______,     MO(_YF), \
+      _______,  _______,  _______,                        _______,                     _______,  _______,  MO(_FL),   _______)
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+    switch (keycode) {
+        case S_BSKTC:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_basketcase);
+            }
+            return false;
+        case S_ODEJY:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_ode_to_joy);
+            }
+            return false;
+        case S_RCKBY:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_rock_a_bye_baby);
+            }
+            return false;
+        case S_DOEDR:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_doe_a_deer);
+            }
+            return false;
+        case S_SCALE:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_scale);
+            }
+            return false;
+        case S_ONEUP:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_one_up);
+            }
+            return false;
+        case S_COIN:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_coin);
+            }
+            return false;
+        case S_SONIC:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_sonic_ring);
+            }
+            return false;
+        case S_ZELDA:
+            if (record->event.pressed) {
+                stop_all_notes();
+                PLAY_SONG(song_zelda_puzzle);
+            }
+            return false;
+    }
+    return true;
+}

keyboards/clueboard/60/keymaps/yanfali/readme.md

@@ -0,0 +1,14 @@
+# /u/yanfali keymap for clueboard 60%
+
+Almost the same as default but differs in the following ways
+
+ 1. `Caps Lock` -> `MT(KC_LCTL, KC_ESC)`.
+    I'm a heavy vim user and I prefer escape to be closer than default. I also move `Control` to this key if you hold it.
+ 1. Switch Alt and GUI.
+    I spend most of my time on OSX, so I reverse Alt and GUI to be
+    more comfortable on OSX.
+ 1. Added a custom layer.
+    I use this to map the cursor keys to WASD, the familiar directional
+    gaming keys. As I use a split right shift, this naturally leads
+    to the left hand being used for navigation. This is also the
+    best place to add custom mappings, macros and combo keys.

keyboards/clueboard/66/keymaps/skully/keymap.c

@@ -1,5 +1,9 @@
 #include "66.h"
 
+enum custom_keycodes {
+   M_SHRUG = SAFE_RANGE
+};
+
 // Each layer gets a name for readability, which is then used in the keymap matrix below.
 // The underscores don't mean anything - you can have a layer called STUFF or any other name.
 // Layer names don't all need to be of the same length, obviously, and you can also skip them
@@ -30,9 +34,20 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   /* Keymap _CL: Control layer
    */
 [_CL] = LAYOUT(
-  _______, _______, _______,_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  _______, RGB_TOG,              RGB_VAI,
+  M_SHRUG, _______, _______,_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  _______, RGB_TOG,              RGB_VAI,
   _______, _______, _______,_______,RESET,  _______,_______,_______,_______,_______, _______,  _______,  _______,  _______,                       RGB_VAD,
   _______, _______, MO(_CL),_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  _______,
   MO(_FL), _______, _______,_______,_______,_______,_______,_______,_______,_______, _______,  _______,  _______,  MO(_FL),               RGB_SAI,
   _______, _______, _______,_______,        RGB_MOD,RGB_MOD,                            _______,  _______,  _______,  _______, RGB_HUD,RGB_SAD,RGB_HUI),
 };
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+   if (record->event.pressed) {
+       switch(keycode) {
+           case M_SHRUG:
+               SEND_STRING("/shrug"SS_TAP(X_ENTER));
+               return false; break;
+       }
+   }
+   return true;
+};

keyboards/crawlpad/readme.md

@@ -14,4 +14,4 @@ Make example for this keyboard (after setting up your build environment):
 
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
 
-For those that prefer a GUI tool, the crawlpad.json file in this repo can be used on [kbfirmware.com](http://kbfirmware.com].
+For those that prefer a GUI tool, the crawlpad.json file in this repo can be used on [kbfirmware.com](http://kbfirmware.com).

keyboards/deltasplit75/split_util.h

@@ -2,11 +2,8 @@
 #define SPLIT_KEYBOARD_UTIL_H
 
 #include <stdbool.h>
+#include "eeconfig.h"
 
-#ifdef EE_HANDS
-	#define EECONFIG_BOOTMAGIC_END      (uint8_t *)10
-	#define EECONFIG_HANDEDNESS         EECONFIG_BOOTMAGIC_END
-#endif
 
 #define SLAVE_I2C_ADDRESS           0x32
 

keyboards/dilly/README.md

@@ -0,0 +1,14 @@
+Dilly
+=====
+
+A 3x10 ortholinear keyboard using Kailh PG1350 Lower Profile Choc switches.
+
+Keyboard Maintainer: Keebio  
+Hardware Supported: Dilly PCB, Arduino Pro Micro  
+Hardware Availability: [Keebio](https://keeb.io)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make dilly:default
+
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/dilly/config.h

@@ -0,0 +1,62 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xCB10
+#define PRODUCT_ID      0x113a
+#define DEVICE_VER      0x0100
+#define MANUFACTURER    Keebio
+#define PRODUCT         Dilly
+#define DESCRIPTION     30 percent ortholinear keyboard
+
+/* key matrix size */
+#define MATRIX_ROWS 6
+#define MATRIX_COLS 5
+
+/* key matrix pins */
+#define MATRIX_ROW_PINS { D7, E6, B4, B1, B3, B2 }
+#define MATRIX_COL_PINS { D2, D4, C6, F6, F5 }
+#define UNUSED_PINS
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+/* number of backlight levels */
+#define BACKLIGHT_PIN B5
+#ifdef BACKLIGHT_PIN
+#define BACKLIGHT_LEVELS 3
+#endif
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCING_DELAY 5
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/* key combination for command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+)
+
+/* prevent stuck modifiers */
+#define PREVENT_STUCK_MODIFIERS
+
+
+#ifdef RGB_DI_PIN
+#define RGBLIGHT_ANIMATIONS
+#define RGBLIGHT_HUE_STEP 8
+#define RGBLIGHT_SAT_STEP 8
+#define RGBLIGHT_VAL_STEP 8
+#endif
+#define RGB_DI_PIN D3
+#define RGBLIGHT_TIMER
+#define RGBLED_NUM 10
+#define ws2812_PORTREG  PORTD
+#define ws2812_DDRREG   DDRD
+
+#endif

keyboards/dilly/dilly.c

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

keyboards/dilly/dilly.h

@@ -0,0 +1,31 @@
+#ifndef DILLY_H
+#define DILLY_H
+
+#include "quantum.h"
+
+#define KEYMAP( \
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, \
+    B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, \
+    C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 \
+) { \
+    { A1, A2, A3, A4, A5 }, \
+    { B1, B2, B3, B4, B5 }, \
+    { C1, C2, C3, C4, C5 }, \
+    { A10, A9, A8, A7, A6 }, \
+    { B10, B9, B8, B7, B6 }, \
+    { C10, C9, C8, C7, C6 } \
+}
+
+// Used to create a keymap using only KC_ prefixed keys
+#define KC_KEYMAP( \
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, \
+    B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, \
+    C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 \
+) \
+    KEYMAP( \
+        KC_##A1, KC_##A2, KC_##A3, KC_##A4, KC_##A5, KC_##A6, KC_##A7, KC_##A8, KC_##A9, KC_##A10, \
+        KC_##B1, KC_##B2, KC_##B3, KC_##B4, KC_##B5, KC_##B6, KC_##B7, KC_##B8, KC_##B9, KC_##B10, \
+        KC_##C1, KC_##C2, KC_##C3, KC_##C4, KC_##C5, KC_##C6, KC_##C7, KC_##C8, KC_##C9, KC_##C10 \
+    )
+
+#endif

keyboards/dilly/keymaps/default/config.h

@@ -0,0 +1,6 @@
+#ifndef CONFIG_USER_H
+#define CONFIG_USER_H
+
+#include "../../config.h"
+
+#endif

keyboards/dilly/keymaps/default/keymap.c

@@ -0,0 +1,107 @@
+#include "dilly.h"
+#include "action_layer.h"
+
+extern keymap_config_t keymap_config;
+
+#define _BASE 0
+#define _FN1 1
+#define _FN2 2
+#define _FN3 3
+#define _FN4 4
+#define _FN5 5
+
+#define KC_ KC_TRNS
+#define _______ KC_TRNS
+
+// Tap-Hold keys
+#define KC_ASFT MT(MOD_LSFT, KC_A)
+#define KC_F_L3 LT(_FN3, KC_F)
+#define KC_ZCTL MT(MOD_LCTL, KC_Z)
+#define KC_XALT MT(MOD_LALT, KC_X)
+#define KC_CGUI MT(MOD_LGUI, KC_C)
+#define KC_V_L4 LT(_FN4, KC_V)
+#define KC_SPL2 LT(_FN2, KC_SPC)
+#define KC_B_L1 LT(_FN1, KC_B)
+#define KC_N_L5 LT(_FN5, KC_N)
+#define KC_MALT MT(MOD_RALT, KC_M)
+#define KC_BSCT MT(MOD_RCTL, KC_BSPC)
+#define KC_ENTS MT(MOD_RSFT, KC_ENT)
+#define KC_ESCS MT(MOD_RSFT, KC_ESC)
+
+#define KC_GUIC LGUI(KC_C)
+
+#define KC_RST RESET
+#define KC_BL_S BL_STEP
+#define KC_DBUG DEBUG
+#define KC_RTOG RGB_TOG
+#define KC_RMOD RGB_MOD
+#define KC_RHUI RGB_HUI
+#define KC_RHUD RGB_HUD
+#define KC_RSAI RGB_SAI
+#define KC_RSAD RGB_SAD
+#define KC_RVAI RGB_VAI
+#define KC_RVAD RGB_VAD
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+
+  [_BASE] = KC_KEYMAP(
+  //,----+----+----+----+----+----+----+----+----+----.
+      Q  , W  , E  , R  , T  , Y  , U  , I  , O  , P  ,
+  //|----+----+----+----+----+----+----+----+----+----|
+     ASFT, S  , D  ,F_L3, G  , H  , J  , K  , L  ,ESCS,
+  //|----+----+----+----+----+----+----+----+----+----|
+     ZCTL,XALT,CGUI,V_L4,SPL2,B_L1,N_L5,MALT,BSCT,ENTS
+  //`----+----+----+----+----+----+----+----+----+----'
+  ),
+
+  [_FN1] = KC_KEYMAP(
+  //,----+----+----+----+----+----+----+----+----+----.
+      1  , 2  , 3  , 4  , 5  , 6  , 7  , 8  , 9  , 0  ,
+  //|----+----+----+----+----+----+----+----+----+----|
+      F1 , F2 , F3 , F4 , F5 , F6 , F7 , F8 , F9 ,F10 ,
+  //|----+----+----+----+----+----+----+----+----+----|
+         ,    ,    ,    ,BSPC,    ,    ,    ,    ,    
+  //`----+----+----+----+----+----+----+----+----+----'
+  ),
+
+  [_FN2] = KC_KEYMAP(
+  //,----+----+----+----+----+----+----+----+----+----.
+     EXLM, AT ,HASH,DLR ,PERC,CIRC,AMPR,ASTR,LPRN,RPRN,
+  //|----+----+----+----+----+----+----+----+----+----|
+     F11 ,F12 ,    ,    ,    ,    ,    ,    ,    ,GRV ,
+  //|----+----+----+----+----+----+----+----+----+----|
+         ,    ,    ,    ,    ,DEL ,    ,    ,    ,    
+  //`----+----+----+----+----+----+----+----+----+----'
+  ),
+
+  [_FN3] = KC_KEYMAP(
+  //,----+----+----+----+----+----+----+----+----+----.
+         ,    ,    ,    ,    ,MINS,EQL ,LBRC,RBRC,BSLS,
+  //|----+----+----+----+----+----+----+----+----+----|
+     TAB ,    ,    ,    ,    ,COMM,DOT ,SLSH,SCLN,QUOT,
+  //|----+----+----+----+----+----+----+----+----+----|
+         ,    ,    ,    ,BSPC,    ,LEFT,DOWN, UP ,RGHT
+  //`----+----+----+----+----+----+----+----+----+----'
+  ),
+
+  [_FN4] = KC_KEYMAP(
+  //,----+----+----+----+----+----+----+----+----+----.
+         ,    ,    ,    ,    ,UNDS,PLUS,LCBR,RCBR,PIPE,
+  //|----+----+----+----+----+----+----+----+----+----|
+     TAB ,    ,    ,    ,    , LT , GT ,QUES,COLN,DQUO,
+  //|----+----+----+----+----+----+----+----+----+----|
+         ,    ,GUIC,    ,BSPC,    ,HOME,PGDN,PGUP,END 
+  //`----+----+----+----+----+----+----+----+----+----'
+  ),
+
+  [_FN5] = KC_KEYMAP(
+  //,----+----+----+----+----+----+----+----+----+----.
+     RTOG,RMOD,    ,RST ,RHUI,RSAI,RVAI,    ,    ,    ,
+  //|----+----+----+----+----+----+----+----+----+----|
+         ,    ,DBUG,    ,RHUD,RSAD,RVAD,    ,    ,    ,
+  //|----+----+----+----+----+----+----+----+----+----|
+     BL_S,    ,GUIC,    ,    ,    ,    ,    ,    ,    
+  //`----+----+----+----+----+----+----+----+----+----'
+  )
+
+};

keyboards/dilly/keymaps/default/rules.mk

@@ -0,0 +1 @@
+RGBLIGHT_ENABLE = yes

keyboards/dilly/rules.mk

@@ -0,0 +1,56 @@
+# MCU name
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Boot Section Size in *bytes*
+OPT_DEFS += -DBOOTLOADER_SIZE=4096
+
+
+# Build Options
+#   comment out to disable the options.
+#
+BOOTMAGIC_ENABLE = yes	# Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes	# Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes	# Audio control and System control(+450)
+CONSOLE_ENABLE = no	# Console for debug(+400)
+COMMAND_ENABLE = no    # Commands for debug and configuration
+SLEEP_LED_ENABLE = no  # Breathing sleep LED during USB suspend
+NKRO_ENABLE = yes		# USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE = yes  # Enable keyboard backlight functionality
+AUDIO_ENABLE = no
+RGBLIGHT_ENABLE = yes

keyboards/e6v2/config.h

@@ -0,0 +1,65 @@
+/*
+Copyright 2012 Jun Wako <wakojun@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include "config_common.h"
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6060
+#define DEVICE_VER      0x0002
+#define MANUFACTURER    Exclusive / E-Team
+#define PRODUCT         E6-V2
+#define DESCRIPTION     E6-V2 QMK PCB (Mid-Port)
+
+/* key matrix size */
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 15
+
+/* QMK E6-V2 PCB default pin-out */
+#define MATRIX_ROW_PINS { D0, D1, D2, D3, D5 }
+#define MATRIX_COL_PINS { C7, C6, B5, B4, D7, D6, D4, F6, F7, F5, F4, F1, F0, B0, B1 }
+#define UNUSED_PINS { E6, B2, B3, B7 }
+
+#define RGB_DI_PIN E2
+#ifdef RGB_DI_PIN
+#define RGBLIGHT_ANIMATIONS
+#define RGBLED_NUM 8
+#define RGBLIGHT_HUE_STEP 12
+#define RGBLIGHT_SAT_STEP 12
+#define RGBLIGHT_VAL_STEP 12
+#endif
+
+#define BACKLIGHT_PIN B6
+#ifdef BACKLIGHT_PIN
+#define BACKLIGHT_LEVELS 5
+#define BACKLIGHT_BREAHTING
+#define BREATHING_PERIOD 3
+#endif
+
+#define DIODE_DIRECTION COL2ROW
+#define DEBOUNCING_DELAY 5
+
+#define IS_COMMAND() ( \
+        keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
+    )
+
+
+
+#endif

keyboards/e6v2/e6v2.c

@@ -0,0 +1,53 @@
+#include "e6v2.h"
+
+void matrix_init_kb(void) {
+	// put your keyboard start-up code here
+	// runs once when the firmware starts up
+
+	matrix_init_user();
+}
+
+void matrix_scan_kb(void) {
+	// put your looping keyboard code here
+	// runs every cycle (a lot)
+
+	matrix_scan_user();
+}
+
+bool process_record_kb(uint16_t keycode, keyrecord_t *record) {
+	// put your per-action keyboard code here
+	// runs for every action, just before processing by the firmware
+
+	return process_record_user(keycode, record);
+}
+
+void led_set_kb(uint8_t usb_led) {
+	// put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
+	DDRB |= (1<<6);
+	if (usb_led & (1<<USB_LED_CAPS_LOCK)) {
+			// output low
+			DDRB |= (1<<2);
+			PORTB &= ~(1<<2);
+		} else {
+			// Hi-Z
+			DDRB &= ~(1<<2);
+			PORTB &= ~(1<<2);
+		}
+	// DDRB |= (1<<7);
+	// DDRB |= (1<<1);
+	// DDRB |= (1<<3);
+	// DDRE |= (1<<6);
+	if (usb_led == 0){
+		PORTB |= (1<<6);
+		// PORTB |= (1<<7);
+		// PORTB |= (1<<1);
+		// PORTB |= (1<<3);
+		// PORTE |= (1<<6);
+	}
+	else{
+		PORTB &= ~(1<<6);
+		// PORTB &= ~(1<<7);
+	}
+    
+	led_set_user(usb_led);
+}

keyboards/e6v2/e6v2.h

@@ -0,0 +1,66 @@
+#ifndef E6V2_H
+#define E6V2_H
+
+#include "quantum.h"
+
+#define KEYMAP( \
+    K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C, K0D, K0E, \
+     K10,  K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C,  K1D,   \
+      K20,  K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B,  K2C,  K2D, \
+    K30,  K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B,  K3C,    K3D, \
+    K40,  K41,  K42,                K46,                K4A,  K4B,  K4C,  K4D \
+)\
+{\
+  { K00, K01, K02, K03,   K04,   K05,   K06, K07,   K08,   K09,   K0A, K0B, K0C, K0D, K0E   }, \
+  { K10, K11, K12, K13,   K14,   K15,   K16, K17,   K18,   K19,   K1A, K1B, K1C, K1D, KC_NO }, \
+  { K20, K21, K22, K23,   K24,   K25,   K26, K27,   K28,   K29,   K2A, K2B, K2C, K2D, KC_NO }, \
+  { K30, K31, K32, K33,   K34,   K35,   K36, K37,   K38,   K39,   K3A, K3B, K3C, K3D, KC_NO }, \
+  { K40, K41, K42, KC_NO, KC_NO, KC_NO, K46, KC_NO, KC_NO, KC_NO, K4A, K4B, K4C, K4D, KC_NO }, \
+}
+
+#define KEYMAP_ANSI( \
+    K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C,      K0D, \
+     K10,  K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C,  K1D,   \
+      K20,  K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B,        K2D, \
+     K30,  K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B,      K3C,         \
+    K40,  K41,  K42,                K46,                K4A,  K4B,  K4C,  K4D \
+)\
+{\
+  { K00, K01,   K02, K03,   K04,   K05,   K06, K07,   K08,   K09,   K0A, K0B, K0C,   K0D,   KC_NO }, \
+  { K10, K11,   K12, K13,   K14,   K15,   K16, K17,   K18,   K19,   K1A, K1B, K1C,   K1D,   KC_NO }, \
+  { K20, K21,   K22, K23,   K24,   K25,   K26, K27,   K28,   K29,   K2A, K2B, KC_NO, K2D,   KC_NO }, \
+  { K30, KC_NO, K32, K33,   K34,   K35,   K36, K37,   K38,   K39,   K3A, K3B, K3C,   KC_NO, KC_NO }, \
+  { K40, K41,   K42, KC_NO, KC_NO, KC_NO, K46, KC_NO, KC_NO, KC_NO, K4A, K4B, K4C,   K4D,   KC_NO }, \
+}
+
+#define KEYMAP_HHKB( \
+    K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C,      K0D, \
+     K10,  K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C,  K1D,   \
+      K20,  K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B,       K2D,  \
+        K30,   K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B,   K3C,  K3D,  \
+          K41,  K42,                 K46,                   K4B,  K4C         \
+)\
+{\
+  { K00,   K01,   K02, K03,   K04,   K05,   K06, K07,   K08,   K09,   K0A,   K0B, K0C,   K0D,   KC_NO }, \
+  { K10,   K11,   K12, K13,   K14,   K15,   K16, K17,   K18,   K19,   K1A,   K1B, K1C,   K1D,   KC_NO }, \
+  { K20,   K21,   K22, K23,   K24,   K25,   K26, K27,   K28,   K29,   K2A,   K2B, KC_NO, K2D,   KC_NO }, \
+  { K30,   KC_NO, K32, K33,   K34,   K35,   K36, K37,   K38,   K39,   K3A,   K3B, K3C,   K3D,   KC_NO }, \
+  { KC_NO, K41,   K42, KC_NO, KC_NO, KC_NO, K46, KC_NO, KC_NO, KC_NO, KC_NO, K4B, K4C,   KC_NO, KC_NO }, \
+}
+
+#define KEYMAP_HHKB_SPLITS( \
+    K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, K0C,    K0D, K0E,\
+     K10,  K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, K1C,  K1D,     \
+      K20,  K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B,      K2D,     \
+     K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B,   K3C, K3D,     \
+          K41,  K42,                 K46,                   K4B,  K4C           \
+)\
+{\
+  { K00,   K01, K02, K03,   K04,   K05,   K06, K07,   K08,   K09,   K0A,   K0B, K0C,   K0D,   K0E   }, \
+  { K10,   K11, K12, K13,   K14,   K15,   K16, K17,   K18,   K19,   K1A,   K1B, K1C,   K1D,   KC_NO }, \
+  { K20,   K21, K22, K23,   K24,   K25,   K26, K27,   K28,   K29,   K2A,   K2B, KC_NO, K2D,   KC_NO }, \
+  { K30,   K31, K32, K33,   K34,   K35,   K36, K37,   K38,   K39,   K3A,   K3B, K3C,   K3D,   KC_NO }, \
+  { KC_NO, K41, K42, KC_NO, KC_NO, KC_NO, K46, KC_NO, KC_NO, KC_NO, KC_NO, K4B, K4C,   KC_NO, KC_NO }, \
+}
+
+#endif

keyboards/e6v2/keymaps/amnesia0287/config.h

@@ -0,0 +1 @@
+#include "../../config.h"

keyboards/e6v2/keymaps/amnesia0287/keymap.c

@@ -0,0 +1,79 @@
+#include "e6v2.h"
+
+// Each layer gets a name for readability, which is then used in the keymap matrix below.
+// The underscores don't mean anything - you can have a layer called STUFF or any other name.
+// Layer names don't all need to be of the same length, obviously, and you can also skip them
+// entirely and just use numbers.
+#define _BL  0
+#define _HLa 1
+#define _HLb 2
+#define _HL  3  
+#define _XL  4
+
+enum hype_keycodes {
+  FN_HLa = SAFE_RANGE,
+  FN_HLb
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    [_BL] = KEYMAP_HHKB(
+        KC_ESC,  KC_1,    KC_2,    KC_3, KC_4, KC_5, KC_6, KC_7, KC_8,    KC_9,   KC_0,    KC_MINS, KC_EQL,   KC_BSPC,
+        KC_TAB,  KC_Q,    KC_W,    KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I,    KC_O,   KC_P,    KC_LBRC, KC_RBRC,  KC_BSLS,
+        KC_LCTL, KC_A,    KC_S,    KC_D, KC_F, KC_G, KC_H, KC_J, KC_K,    KC_L,   KC_SCLN,     KC_QUOT,       KC_ENT,
+        KC_LSFT, KC_Z,    KC_X,    KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,   KC_DOT,     KC_SLSH,    KC_RSFT,  FN_HLb,
+                KC_LGUI, KC_LALT,               KC_SPACE,                               KC_RALT, FN_HLa
+        ),
+    [_HLa] = KEYMAP_HHKB(
+        KC_GRV,  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_DEL,
+        KC_CAPS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR, KC_SLCK,  KC_PAUS, KC_UP,   KC_TRNS, KC_TRNS,
+        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP,    KC_LEFT,   KC_RGHT,      KC_TRNS,
+        KC_TRNS,          KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PPLS, KC_PMNS, KC_END,   KC_PGDN, KC_DOWN, KC_TRNS, KC_TRNS,
+                 KC_TRNS, KC_TRNS,               KC_MPLY,                               KC_TRNS,  KC_TRNS  
+        ),
+    [_HLb] = KEYMAP_HHKB(
+        KC_GRV,  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_DEL,
+        KC_CAPS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR, KC_SLCK,  KC_PAUS, KC_UP,   KC_TRNS, KC_TRNS,
+        KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PAST, KC_PSLS, KC_HOME, KC_PGUP,    KC_LEFT,   KC_RGHT,      KC_TRNS,
+        KC_TRNS,          KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PPLS, KC_PMNS, KC_END,   KC_PGDN, KC_DOWN, KC_TRNS, KC_TRNS,
+                 KC_TRNS, KC_TRNS,               KC_MPLY,                               KC_TRNS,  KC_TRNS  
+        ),
+    [_HL] = KEYMAP_HHKB(
+        RGB_TOG, RGB_M_P, RGB_RMOD, RGB_MOD, KC_TRNS,  KC_TRNS, KC_TRNS, BL_BRTG, BL_OFF, BL_STEP, BL_ON, BL_DEC, BL_INC, LALT(KC_F4),
+        RESET, RGB_HUI, RGB_SAI,  RGB_VAI, KC_TRNS,  KC_TRNS,  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,   KC_TRNS, KC_TRNS, KC_TRNS,
+        KC_TRNS, RGB_HUD, RGB_SAD,  RGB_VAD, 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, RGB_VAD,  RGB_VAI,  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,        KC_TRNS,   KC_TRNS, KC_TRNS,
+        KC_TRNS, KC_TRNS,                        KC_TRNS,                               KC_TRNS, KC_TRNS
+        ),
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case FN_HLa:
+      if (record->event.pressed)
+      {
+        layer_on(_HLa);
+        update_tri_layer(_HLa, _HLb, _HL);
+      }
+      else
+      {
+        layer_off(_HLa);
+        update_tri_layer(_HLa, _HLb, _HL);
+      }
+      return false;
+      break;
+    case FN_HLb:
+      if (record->event.pressed)
+      {
+        layer_on(_HLb);
+        update_tri_layer(_HLa, _HLb, _HL);
+      }
+      else
+      {
+        layer_off(_HLb);
+        update_tri_layer(_HLa, _HLb, _HL);
+      }
+      return false;
+      break;
+  }
+  return true;
+}

keyboards/e6v2/keymaps/amnesia0287/readme.md

@@ -0,0 +1,8 @@
+amnesia0287's Keymap
+===
+
+Keymap Maintainer: [Jason Gorman](https://github.com/amnesia0287)
+
+Difference from base layout: Primarily the HHKB-ness
+
+Intended usage: Daily driver for programming 

keyboards/e6v2/keymaps/default/config.h

@@ -0,0 +1 @@
+#include "../../config.h"

keyboards/e6v2/keymaps/default/keymap.c

@@ -0,0 +1,18 @@
+#include "e6v2.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [0] = KEYMAP_ANSI(
+      KC_ESC,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,      KC_9,    KC_0,    KC_MINS, KC_EQL,   KC_BSPC,
+      KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,      KC_O,    KC_P,    KC_LBRC, KC_RBRC,  KC_BSLS,
+      KC_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,      KC_L,    KC_SCLN, KC_QUOT,       KC_ENT,
+      KC_LSFT,     KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM,   KC_DOT,  KC_SLSH, KC_RSFT,
+      KC_LCTL, KC_LGUI, KC_LALT,               KC_SPACE,                        KC_RALT, MO(1),   KC_MENU, KC_RCTL
+      ),
+  [1] = KEYMAP_ANSI(
+      KC_GRV,  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_DEL,
+      RESET, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PSCR,   KC_SLCK, KC_PAUS, KC_UP,   KC_TRNS, KC_TRNS,
+      KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PAST, KC_PSLS, KC_HOME,   KC_PGUP, KC_LEFT, KC_RGHT,      KC_TRNS,
+      KC_TRNS,     KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_PPLS, KC_PMNS,   KC_END,  KC_PGDN, KC_DOWN, KC_TRNS,
+      KC_TRNS, KC_TRNS, KC_TRNS,               KC_MPLY,                         KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
+      ),
+};

keyboards/e6v2/keymaps/default/readme.md

@@ -0,0 +1,8 @@
+Default Keymap
+===
+
+Super simple default keymap with only a base layer.
+
+Keymap Maintainer: [Jason Gorman](https://github.com/amnesia0287)
+
+Intended usage: This is mostly provided for testing before you build your own keymap and as a reference to a stock(ish) configuration

keyboards/e6v2/readme.md

@@ -0,0 +1,18 @@
+E6-V2
+===
+
+These docs are for the QMK version of the PCB. [More info on qmk.fm](http://qmk.fm/)
+
+Keyboard Maintainer: [Jason Gorman](https://github.com/amnesia0287)
+Hardware Supported: E6-V2 Mid Port rev.qmk
+Hardware Availability: [geekhack.org/index.php?topic=90787.0](https://geekhack.org/index.php?topic=90787.0)
+
+Make example for this keyboard (after setting up your build environment):
+
+    make e6v2:default
+
+Or to make and flash:
+
+    make e6v2:default:dfu
+
+See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/e6v2/rules.mk

@@ -0,0 +1,68 @@
+# MCU name
+#MCU = at90usb1287
+MCU = atmega32u4
+
+# Processor frequency.
+#     This will define a symbol, F_CPU, in all source code files equal to the
+#     processor frequency in Hz. You can then use this symbol in your source code to
+#     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
+#     automatically to create a 32-bit value in your source code.
+#
+#     This will be an integer division of F_USB below, as it is sourced by
+#     F_USB after it has run through any CPU prescalers. Note that this value
+#     does not *change* the processor frequency - it should merely be updated to
+#     reflect the processor speed set externally so that the code can use accurate
+#     software delays.
+F_CPU = 16000000
+
+
+#
+# LUFA specific
+#
+# Target architecture (see library "Board Types" documentation).
+ARCH = AVR8
+
+# Input clock frequency.
+#     This will define a symbol, F_USB, in all source code files equal to the
+#     input clock frequency (before any prescaling is performed) in Hz. This value may
+#     differ from F_CPU if prescaling is used on the latter, and is required as the
+#     raw input clock is fed directly to the PLL sections of the AVR for high speed
+#     clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
+#     at the end, this will be done automatically to create a 32-bit value in your
+#     source code.
+#
+#     If no clock division is performed on the input clock inside the AVR (via the
+#     CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
+F_USB = $(F_CPU)
+
+# Interrupt driven control endpoint task(+60)
+OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
+
+
+# Boot Section Size in *bytes*
+#   Teensy halfKay   512
+#   Teensy++ halfKay 1024
+#   Atmel DFU loader 4096
+#   LUFA bootloader  4096
+#   USBaspLoader     2048
+OPT_DEFS += -DBOOTLOADER_SIZE=4096
+
+
+# Build Options
+#   change yes to no to disable
+#
+BOOTMAGIC_ENABLE = no      # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+CONSOLE_ENABLE = no        # Console for debug(+400)
+COMMAND_ENABLE = no        # Commands for debug and configuration
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
+# if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+NKRO_ENABLE = yes           # USB Nkey Rollover
+BACKLIGHT_ENABLE = yes       # Enable keyboard backlight functionality on B7 by default
+RGBLIGHT_ENABLE = yes
+MIDI_ENABLE = no            # MIDI controls
+UNICODE_ENABLE = no         # Unicode
+BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
+AUDIO_ENABLE = no           # Audio output on port C6

keyboards/ergodox_ez/keymaps/bepo_tm_style/readme.md

@@ -19,4 +19,4 @@ make ergodox_ez:bepo_tm_style:all
 ## Debug
 
 See https://github.com/tmk/tmk_keyboard#magic-commands for command that can help
-debug, together with the hid_listen tool (https://docs.qmk.fm/faq_debug.html).
+debug, together with the [hid_listen tool](https://docs.qmk.fm/faq_debug.html).

keyboards/ergodox_ez/keymaps/drashna/keymap.c

@@ -19,6 +19,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
 
+//enum more_custom_keycodes {
+//    KC_P00 = NEW_SAFE_RANGE
+//};
+
 
 //define layer change stuff for underglow indicator
 bool skip_leds = false;
@@ -49,20 +53,20 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  *                                 `---------------------'       `---------------------'
  */
   [_QWERTY] = LAYOUT_ergodox_wrapper(
-                KC_EQL,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    TT(_MOUS),
+                KC_EQL,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    OSL(_MOUS),
                 KC_TAB,  _________________QWERTY_L1_________________, TG(_DIABLO),
                 KC_BSPC, _________________QWERTY_L2_________________,
-                KC_LSFT, _________________QWERTY_L3_________________, TG(_GAMEPAD),
+                KC_MLSF, _________________QWERTY_L3_________________, TG(_GAMEPAD),
        LT(_SYMB,KC_GRV), ___________ERGODOX_BOTTOM_LEFT_____________,
                 
                                             ALT_T(KC_APP),   KC_LGUI,
                                                              KC_HOME,
                                            KC_SPACE,KC_BSPC, KC_END,
                                     
-           TT(_MOUS),    KC_6,    KC_7,    KC_8,    KC_9,     KC_0,   KC_MINS,
+           OSL(_MOUS),    KC_6,    KC_7,    KC_8,    KC_9,     KC_0,   KC_MINS,
            TG(_DIABLO),  _________________QWERTY_R1_________________, KC_BSLS,
                          _________________QWERTY_R2_________________, GUI_T(KC_QUOT),
-           TG(_GAMEPAD), _________________QWERTY_R3_________________, KC_RSFT,
+           TG(_GAMEPAD), _________________QWERTY_R3_________________, KC_MRSF,
                          ___________ERGODOX_BOTTOM_RIGHT____________, TT(_SYMB),
            KC_RGUI,      CTL_T(KC_ESCAPE),
            KC_PGUP,
@@ -93,19 +97,19 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 // Otherwise, it needs KC_*
 [_COLEMAK] = LAYOUT_ergodox_wrapper(  
         // left hand
-                KC_EQL,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    TT(_MOUS),
+                KC_EQL,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    OSL(_MOUS),
                 KC_TAB,  _________________COLEMAK_L1________________, TG(_DIABLO),
                 KC_BSPC, _________________COLEMAK_L2________________,
-                KC_LSFT, _________________COLEMAK_L3________________, TG(_GAMEPAD),
+                KC_MLSF, _________________COLEMAK_L3________________, TG(_GAMEPAD),
        LT(_SYMB,KC_GRV), ___________ERGODOX_BOTTOM_LEFT_____________,
                                             ALT_T(KC_APP),   KC_LGUI,
                                                              KC_HOME,
                                            KC_SPACE,KC_BSPC, KC_END,
         // right hand
-           TT(_MOUS),    KC_6,    KC_7,    KC_8,    KC_9,     KC_0,   KC_MINS,
+           OSL(_MOUS),    KC_6,    KC_7,    KC_8,    KC_9,     KC_0,   KC_MINS,
            TG(_DIABLO),  _________________COLEMAK_R1________________, KC_BSLS,
                          _________________COLEMAK_R2________________, GUI_T(KC_QUOT),
-           TG(_GAMEPAD), _________________COLEMAK_R3________________, KC_RSFT,
+           TG(_GAMEPAD), _________________COLEMAK_R3________________, KC_MRSF,
                          ___________ERGODOX_BOTTOM_RIGHT____________, TT(_SYMB),
            KC_RGUI,      CTL_T(KC_ESCAPE),
            KC_PGUP,
@@ -136,19 +140,19 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 // Otherwise, it needs KC_*
 [_DVORAK] = LAYOUT_ergodox_wrapper(  
         // left hand
-                KC_EQL,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    TT(_MOUS),
+                KC_EQL,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    OSL(_MOUS),
                 KC_TAB,  _________________DVORAK_L1_________________, TG(_DIABLO),
                 KC_BSPC, _________________DVORAK_L2_________________,
-                KC_LSFT, _________________DVORAK_L3_________________, TG(_GAMEPAD),
+                KC_MLSF, _________________DVORAK_L3_________________, TG(_GAMEPAD),
        LT(_SYMB,KC_GRV), ___________ERGODOX_BOTTOM_LEFT_____________,
                                             ALT_T(KC_APP),   KC_LGUI,
                                                              KC_HOME,
                                            KC_SPACE,KC_BSPC, KC_END,
         // right hand
-           TT(_MOUS),    KC_6,    KC_7,    KC_8,    KC_9,     KC_0,   KC_BSLS,
+           OSL(_MOUS),    KC_6,    KC_7,    KC_8,    KC_9,     KC_0,   KC_BSLS,
            TG(_DIABLO),  _________________DVORAK_R1_________________, KC_SLSH,
                          _________________DVORAK_R2_________________, GUI_T(KC_MINS),
-           TG(_GAMEPAD), _________________DVORAK_R3_________________, KC_RSFT,
+           TG(_GAMEPAD), _________________DVORAK_R3_________________, KC_MRSF,
                          ___________ERGODOX_BOTTOM_RIGHT____________, TT(_SYMB),
            KC_RGUI,      CTL_T(KC_ESCAPE),
            KC_PGUP,
@@ -179,19 +183,19 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 // Otherwise, it needs KC_*
 [_WORKMAN] = LAYOUT_ergodox_wrapper(  
         // left hand
-                KC_EQL,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    TT(_MOUS),
+                KC_EQL,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    OSL(_MOUS),
                 KC_TAB,  _________________WORKMAN_L1________________, TG(_DIABLO),
                 KC_BSPC, _________________WORKMAN_L2________________,
-                KC_LSFT, _________________WORKMAN_L3________________, TG(_GAMEPAD),
+                KC_MLSF, _________________WORKMAN_L3________________, TG(_GAMEPAD),
        LT(_SYMB,KC_GRV), ___________ERGODOX_BOTTOM_LEFT_____________,
                                             ALT_T(KC_APP),   KC_LGUI,
                                                              KC_HOME,
                                            KC_SPACE,KC_BSPC, KC_END,
         // right hand
-           TT(_MOUS),    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS,
+           OSL(_MOUS),    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_MINS,
            TG(_DIABLO),  _________________WORKMAN_R1________________, KC_BSLS,
                          _________________WORKMAN_R2________________, GUI_T(KC_QUOT),
-           TG(_GAMEPAD), _________________WORKMAN_R3________________, KC_RSFT,
+           TG(_GAMEPAD), _________________WORKMAN_R3________________, KC_MRSF,
                          ___________ERGODOX_BOTTOM_RIGHT____________, TT(_SYMB),
            KC_RGUI,      CTL_T(KC_ESCAPE),
            KC_PGUP,
@@ -202,7 +206,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                 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,
-                OSM(MOD_LSFT),KC_TRNS,    KC_TRNS,    KC_TRNS,    KC_TRNS,      KC_TRNS,      KC_TRNS,
+                KC_LSFT,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,
@@ -211,7 +215,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                 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,      OSM(MOD_RSFT),
+                KC_TRNS,    KC_TRNS,      KC_TRNS,      KC_TRNS,      KC_TRNS,      KC_TRNS,      KC_RSFT,
                                           KC_TRNS,      KC_TRNS,      KC_TRNS,      KC_TRNS,      KC_TRNS,
                 KC_TRNS,    KC_TRNS,
                 KC_TRNS,
@@ -241,9 +245,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 */
   [_SYMB] = LAYOUT_ergodox(
                 EPRM,           KC_F1,      KC_F2,      KC_F3,      KC_F4,      KC_F5,      TG(_MODS),
-                VRSN,           KC_EXLM,    KC_AT,      KC_LCBR,    KC_RCBR,    KC_PIPE,    KC_WORKMAN,
+                KC_RESET,       KC_EXLM,    KC_AT,      KC_LCBR,    KC_RCBR,    KC_PIPE,    KC_WORKMAN,
                 KC_MAKE,        KC_HASH,    KC_DLR,     KC_LPRN,    KC_RPRN,    KC_GRAVE,
-                KC_RESET,       KC_PERC,    KC_CIRC,    KC_LBRACKET,KC_RBRACKET,KC_TILD,    KC_COLEMAK,
+                VRSN,           KC_PERC,    KC_CIRC,    KC_LBRACKET,KC_RBRACKET,KC_TILD,    KC_COLEMAK,
                 KC_TRNS,        KC_AMPR,    KC_ASTR,    KC_COLN,    KC_SCOLON,
                                                                   RGB_SMOD, KC_RGB_T,
                                                                   RGB_HUI,
@@ -387,12 +391,24 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 };
 
 
-
 bool process_record_keymap(uint16_t keycode, keyrecord_t *record) {
+
+  //switch (keycode) {
+  //  case KC_P00:
+  //    if (!record->event.pressed) {
+  //      register_code(KC_KP_0);
+  //      unregister_code(KC_KP_0);
+  //      register_code(KC_KP_0);
+  //      unregister_code(KC_KP_0);
+  //    }
+  //    return false;
+  //    break;
+  //}
   return true;
 }
 
 
+
 void matrix_init_keymap(void) { // Runs boot tasks for keyboard
 };
 

keyboards/ergodox_ez/keymaps/drashna/rules.mk

@@ -1,6 +1,7 @@
 TAP_DANCE_ENABLE  = yes
 SLEEP_LED_ENABLE  = no  # Breathing sleep LED during USB suspend
-COMMAND_ENABLE    = no  # Commands for debug and configuration
+COMMAND_ENABLE    = yes  # Commands for debug and configuration
 RGBLIGHT_ENABLE   = yes
 CONSOLE_ENABLE    = no
+BOOTMAGIC_ENABLE  = yes
 

keyboards/ergodox_ez/keymaps/dvorak_42_key/keymap.c

@@ -7,6 +7,12 @@
 // to build this keymap
 // make ergodox_ez:dvorak_42_key:teensy
 
+// keeping fork up to date:
+// https://help.github.com/articles/configuring-a-remote-for-a-fork/
+// https://help.github.com/articles/syncing-a-fork/
+// pushing dev branch
+// git push origin dev:dev
+
 static bool mouse_lock = false;
 
 enum custom_keycodes {
@@ -17,6 +23,7 @@ enum custom_keycodes {
   // shell nav macros
   SHELL_LS,
   SHELL_LSLTR,
+  SHELL_LSLA, 
   SHELL_CDPRE,
   SHELL_LESS,
   SHELL_PLESS,
@@ -31,6 +38,15 @@ enum custom_keycodes {
   SHELL_SCREEN_LIST,
   SHELL_MKE,
   SHELL_HTCSTATUS,
+  
+  // Cloud9 macros
+  CLOUD9_TAB_LEFT,
+  CLOUD9_TAB_RIGHT,
+  CLOUD9_TAB_CLOSE,
+  CLOUD9_GOTO_SYMBOL,
+  CLOUD9_GOTO_LINE,
+  CLOUD9_NAVIGATE,
+  
 };
 
 
@@ -39,8 +55,11 @@ enum custom_keycodes {
 #define KEYSEL       2 // arrow navigation + shift (allow text selection)
 #define SHELL_NAV    3 // bash shortcuts
 #define SHELL_SCREEN 4 // linux screen shortcuts
-#define MOUSE        5 // mouse layer (can be locked with lock key)
-#define COMBINED     6 // combined numbers and symbols layer
+#define SCREEN_NAV   5 // navigate between linux screen tabs 
+#define MOUSE        6 // mouse layer (can be locked with lock key), unmapped for now
+#define BROWSER_CONTROL 7 // control browser and mouse
+#define COMBINED      	8 // combined numbers and symbols layer
+
 
 // macros
 #define MOUSE_TOGGLE 1
@@ -64,7 +83,18 @@ enum custom_keycodes {
 #define SCREEN_8 20
 #define SCREEN_9 21
 #define SCREEN_DETACH 22
-#define SHELL_RECALL_LAST_ARG_REMOVE_FIRST_COMMAND 30
+#define SCREEN_UP_JUMP 23
+#define SCREEN_DOWN_JUMP 24
+#define SCREEN_READREG_1 25
+#define SCREEN_READREG_2 26
+#define SCREEN_READREG_3 27
+#define SCREEN_PASTEREG_1 28
+#define SCREEN_PASTEREG_2 29
+#define SCREEN_PASTEREG_3 30
+#define SHELL_WRITE_LOGPATTERN 31
+#define SHELL_WRITE_TRANPATTERN 32
+#define SHELL_EXPAND_PATTERN 33
+
 
 
 #define MACRO_SCREEN_NUM(MACRO_NAME,NUM) \
@@ -73,16 +103,50 @@ enum custom_keycodes {
                 return MACRO( D(LCTL), T(A), U(LCTL), T(NUM), END);\
             }\
         break;\
+		
+#define MACRO_SCREEN_REG(MACRO_NAME,NUM) \
+        case MACRO_NAME:\
+             if (record->event.pressed) {\
+                return MACRO( D(LCTL), T(A), U(LCTL), D(LSFT), T(SCOLON), U(LSFT),\
+                              T(R),\
+                              T(E),\
+                              T(A),\
+                              T(D),\
+                              T(R),\
+                              T(E),\
+							  T(G),\
+                              T(SPC),\
+							  T(NUM),\
+							  T(ENTER),\
+                             END);\
+            }\
+        break;\
+
+#define MACRO_SCREEN_PASTE(MACRO_NAME,NUM)\
+        case MACRO_NAME:\
+             if (record->event.pressed) {\
+                return MACRO( D(LCTL), T(A), U(LCTL), D(LSFT), T(SCOLON), U(LSFT),\
+                              T(P),\
+                              T(A),\
+                              T(S),\
+                              T(T),\
+                              T(E),\
+                              T(SPC),\
+							  T(NUM),\
+							  T(ENTER),\
+                             END);\
+            }\
+        break;\
 
 const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 
   [BASE] = KEYMAP(
       // left hand
       KC_ESC,            KC_F1,         KC_F2,      KC_F3,        KC_F4,   KC_F5,   KC_F6,
-      KC_TAB,            KC_QUOTE,      KC_COMMA,   KC_DOT,       KC_P,    KC_Y,    MEH(KC_2),
+      OSL(SCREEN_NAV),   KC_QUOTE,      KC_COMMA,   KC_DOT,       KC_P,    KC_Y,    MEH(KC_2),
       OSL(SHELL_NAV),    KC_A,          KC_O,       KC_E,         KC_U,    KC_I,
       OSL(SHELL_SCREEN), KC_SCOLON,     KC_Q,       KC_J,         KC_K,    KC_X,    MEH(KC_3),
-      MEH(KC_1),         OSM(MOD_LSFT), OSM(MOD_LCTL), M(MOUSE_TOGGLE), MO(KEYSEL),
+      MEH(KC_1),         OSM(MOD_LSFT), OSM(MOD_LCTL), MO(KEYSEL), MO(BROWSER_CONTROL),
       
       // left thumb cluster
                 MEH(KC_4),      MEH(KC_5),
@@ -91,8 +155,8 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       
       // right hand
       KC_F7,     KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, MEH(KC_9),
-      MEH(KC_7), KC_F,  KC_G,  KC_C,   KC_R,   KC_L,   MEH(KC_F1),
-                 KC_D,  KC_H,  KC_T,   KC_N,   KC_S,   MEH(KC_F2),
+      MEH(KC_7), KC_F,  KC_G,  KC_C,   KC_R,   KC_L,   KC_TAB,
+                 KC_D,  KC_H,  KC_T,   KC_N,   KC_S,   RCTL(KC_BSPC),
       MEH(KC_8), KC_B,  KC_M,  KC_W,   KC_V,   KC_Z,   MEH(KC_F3),
       KC_BSPC,   RCTL(KC_BSPC), KC_CAPSLOCK, OSM(MOD_LSFT),MEH(KC_F4),
     
@@ -103,11 +167,11 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   
   [KEYNAV] = KEYMAP(
     // left hand
-    KC_TRNS,KC_TRNS,     KC_TRNS,     KC_TRNS,      KC_TRNS,    KC_TRNS,     KC_TRNS,
-    KC_TRNS,KC_ESC,      MEH(KC_F9),  RCTL(KC_Z),   RCTL(KC_S), MEH(KC_F10), KC_TRNS,
-    KC_TRNS,MEH(KC_F11), MEH(KC_F12), RSFT(KC_TAB), KC_TAB,     MEH(KC_A),
-    KC_TRNS,MEH(KC_B),   MEH(KC_C),   MEH(KC_D),    MEH(KC_E),  MEH(KC_F),   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_ESC,      CLOUD9_GOTO_LINE,   RCTL(KC_Z),      RCTL(KC_S),       MEH(KC_F10),      KC_TRNS,
+    KC_TRNS,KC_LSFT,     CLOUD9_GOTO_SYMBOL, RSFT(KC_TAB),    KC_TAB,           MEH(KC_A),
+    KC_TRNS,MEH(KC_B),   CLOUD9_NAVIGATE,    CLOUD9_TAB_LEFT, CLOUD9_TAB_RIGHT, CLOUD9_TAB_CLOSE, KC_TRNS,
+    KC_TRNS,KC_TRNS,     KC_TRNS,            KC_TRNS,         KC_TRNS,
     // left thumb cluster
     KC_TRNS,KC_TRNS,KC_TRNS,TO(MOUSE),KC_TRNS,KC_TRNS,
     
@@ -130,7 +194,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
            KC_TRNS,MEH(KC_L), MEH(KC_M),MEH(KC_N), MEH(KC_O), MEH(KC_P),
            KC_TRNS,MEH(KC_Q), MEH(KC_R),MEH(KC_S), MEH(KC_T), MEH(KC_U), KC_TRNS,
                    // bottom row
-                   KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,
+                   RESET,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,
                                            // thumb cluster
                                            KC_TRNS,KC_TRNS,
                                                    KC_TRNS,
@@ -151,9 +215,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
   // shell navigation layer
   [SHELL_NAV] = KEYMAP(
        // left hand
-       KC_TRNS,KC_TRNS,           KC_TRNS,        KC_TRNS,          KC_TRNS,     KC_TRNS,         KC_TRNS,
+       KC_NO,  KC_TRNS,           KC_TRNS,        KC_TRNS,          KC_TRNS,     KC_TRNS,         KC_TRNS,
        KC_TRNS,KC_TRNS,           SHELL_PGREP,    SHELL_PLESS,      SHELL_LESS,  KC_TRNS,         SHELL_H3,
-       KC_TRNS,SHELL_MKE,         SHELL_CDPRE,    SHELL_LSLTR,      SHELL_LS,    SHELL_PWD,
+       KC_TRNS,SHELL_MKE,         SHELL_CDPRE,    SHELL_LSLTR,      SHELL_LS,    SHELL_LSLA,
        KC_TRNS,SHELL_SCREEN_LIST, SHELL_SCREENRD, SHELL_SCREEN_NEW, SHELL_TAILF, SHELL_HTCSTATUS, SHELL_AMMCOLO,
                // bottom row
                KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,
@@ -162,10 +226,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
                                                KC_TRNS,
                                KC_TRNS,KC_TRNS,KC_TRNS,
        // right hand
-       KC_TRNS,    KC_TRNS,    KC_TRNS,             KC_TRNS,         KC_TRNS,    KC_TRNS,    M(SWITCH_NDS),
-       RCTL(KC_L), RCTL(KC_W), KC_HOME,             KC_UP,           KC_END,     KC_TRNS,    RCTL(KC_R),
-                   LALT(KC_B), KC_LEFT,             KC_DOWN,         KC_RIGHT,   LALT(KC_F), LALT(KC_DOT),
-       RCTL(KC_C), RCTL(KC_U), M(SCREEN_COPY_MODE), M(SCREEN_PASTE), MEH(KC_V),  RCTL(KC_K), M(SHELL_RECALL_LAST_ARG_REMOVE_FIRST_COMMAND),
+       KC_TRNS,    KC_TRNS,    KC_TRNS,             KC_TRNS,         KC_TRNS,    KC_TRNS,    M(SHELL_WRITE_TRANPATTERN),
+       RCTL(KC_L), RCTL(KC_W), KC_HOME,             KC_UP,           KC_END,     KC_TRNS,    M(SHELL_WRITE_LOGPATTERN),
+                   LALT(KC_B), KC_LEFT,             KC_DOWN,         KC_RIGHT,   LALT(KC_F), RCTL(KC_W),
+       RCTL(KC_C), RCTL(KC_U), LALT(KC_DOT),        RCTL(KC_R),      MEH(KC_V),  RCTL(KC_K), M(SHELL_EXPAND_PATTERN),
                    // bottom row (match functionality of base layer)
                    KC_BSPC,    RCTL(KC_W),          KC_DELETE,       LALT(KC_D), RCTL(KC_U),
        // thumb cluster
@@ -178,7 +242,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     // linux screen layer
   [SHELL_SCREEN] = KEYMAP(
        // left hand
-       KC_TRNS,KC_TRNS,    KC_TRNS,     KC_TRNS,     KC_TRNS,     KC_TRNS,   KC_TRNS,
+       KC_NO,  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,
@@ -201,6 +265,35 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
        KC_TRNS, KC_TRNS, KC_TRNS
   ),
 
+  // navigation within screen (for copy/paste)
+  [SCREEN_NAV] = KEYMAP(
+       // left hand
+       // left hand
+       KC_NO,  KC_TRNS,    KC_TRNS,              KC_TRNS,     		  KC_TRNS,               KC_TRNS,   KC_TRNS,
+       KC_TRNS,KC_TRNS,    M(SCREEN_READREG_3),  M(SCREEN_READREG_2),  M(SCREEN_READREG_1),   KC_TRNS,   KC_TRNS,
+       KC_TRNS,KC_TRNS,    M(SCREEN_PASTEREG_3), M(SCREEN_PASTEREG_2), M(SCREEN_PASTEREG_1),  KC_TRNS,
+       KC_TRNS,KC_TRNS,    KC_TRNS,     		 KC_TRNS,     	      KC_TRNS,               KC_TRNS,   KC_TRNS,
+               // bottom row
+               KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,
+                                       // thumb cluster
+                                       KC_TRNS,KC_TRNS,
+                                               KC_TRNS,
+                               KC_TRNS,KC_TRNS,KC_TRNS,
+       // right hand
+       KC_TRNS,    KC_TRNS,    KC_TRNS,        KC_TRNS,         KC_TRNS,         KC_TRNS,    		  KC_TRNS,
+       KC_TRNS,    KC_TRNS,    KC_0,           KC_UP,           KC_DLR,          M(SCREEN_UP_JUMP),   KC_TRNS,
+                   KC_B,       KC_LEFT,        KC_DOWN,         KC_RIGHT,   	 KC_W,       		  M(SCREEN_COPY_MODE),
+       KC_TRNS,    KC_TRNS,    S(KC_W),        S(KC_Y),         M(SCREEN_PASTE), M(SCREEN_DOWN_JUMP), MEH(KC_V),
+                   // bottom row (match functionality of base layer)
+                   KC_TRNS,    KC_TRNS,        KC_TRNS,         KC_TRNS,    KC_TRNS,
+       // thumb cluster
+       KC_TRNS, KC_TRNS,
+       KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_TRNS
+  ),
+  
+
+
   
   [COMBINED] = KEYMAP(
   
@@ -222,7 +315,9 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
     // bottom row 
                           KC_0,    KC_DOT,  KC_PIPE, KC_BSLS,     MEH(KC_P),
     // thumb cluster
-    KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS),
+    KC_TRNS,KC_TRNS,
+	KC_TRNS,
+	KC_TRNS,KC_TRNS,KC_TAB),
   
   
     [MOUSE] = KEYMAP(
@@ -246,6 +341,30 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
            KC_TRNS,
            KC_TRNS, KC_BTN1, KC_BTN2
     ),  
+	
+    [BROWSER_CONTROL] = KEYMAP(
+		   // left hand
+           KC_TRNS, KC_TRNS,      KC_TRNS,       KC_TRNS,       KC_TRNS,      KC_TRNS, KC_TRNS,
+           KC_TRNS, KC_TRNS,      KC_BTN3,       KC_MS_U,       KC_BTN1,      KC_BTN2, KC_TRNS,
+           KC_TRNS, KC_TRNS,      KC_MS_L,       KC_MS_D,       KC_MS_R,      KC_TRNS,
+           KC_TRNS, KC_TRNS,      KC_TRNS,       KC_TRNS,       KC_TRNS,      KC_TRNS, KC_TRNS,
+		   // bottom row
+           KC_TRNS, KC_TRNS,      KC_TRNS,       KC_TRNS,       KC_TRNS,
+           
+                                               KC_TRNS, KC_TRNS,
+                                                        KC_TRNS,
+                                      KC_TRNS, KC_TRNS, KC_TRNS,
+          // right hand
+           KC_TRNS,  KC_TRNS,   KC_TRNS,            KC_TRNS,      KC_TRNS,       KC_TRNS,       KC_TRNS,
+           KC_TRNS,  KC_UP,     KC_PGUP,            KC_PGDN,      KC_MS_WH_UP,   KC_TRNS,       KC_TRNS,
+                     KC_DOWN,   RSFT(RCTL(KC_TAB)), RCTL(KC_TAB), KC_MS_WH_DOWN, LALT(KC_LEFT), KC_TRNS,
+           KC_TRNS,  KC_TRNS,   RCTL(KC_1),         RCTL(KC_9),   KC_F6,         KC_F5,         KC_TRNS,
+                                // bottom row
+                                KC_TRNS,            KC_TRNS,      KC_TRNS,       KC_TRNS,       KC_TRNS,
+           KC_TRNS, KC_TRNS,
+           KC_TRNS,
+           KC_TRNS, RCTL(KC_W), RCTL(KC_T)
+    ),  	
     
 
 };
@@ -317,6 +436,14 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
             }                                
         break;        
 
+		MACRO_SCREEN_REG(SCREEN_READREG_1,1);
+		MACRO_SCREEN_REG(SCREEN_READREG_2,2);
+		MACRO_SCREEN_REG(SCREEN_READREG_3,3);
+		
+		MACRO_SCREEN_PASTE(SCREEN_PASTEREG_1,1);
+		MACRO_SCREEN_PASTE(SCREEN_PASTEREG_2,2);
+		MACRO_SCREEN_PASTE(SCREEN_PASTEREG_3,3);
+
         MACRO_SCREEN_NUM(SCREEN_0,0);
         MACRO_SCREEN_NUM(SCREEN_1,1);
         MACRO_SCREEN_NUM(SCREEN_2,2);
@@ -328,6 +455,18 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
         MACRO_SCREEN_NUM(SCREEN_8,8);
         MACRO_SCREEN_NUM(SCREEN_9,9);
         
+		case SCREEN_UP_JUMP:
+            if (record->event.pressed) {
+                return MACRO( T(5), T(UP), END);
+            }		
+		break;
+		
+		case SCREEN_DOWN_JUMP:
+            if (record->event.pressed) {
+                return MACRO( T(5), T(DOWN), END);
+            }		
+		break;		
+		
         case SCREEN_COPY_MODE:
             if (record->event.pressed) {
                 return MACRO( D(LCTL), T(A), U(LCTL), T(ESC), END);
@@ -338,23 +477,39 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
                 return MACRO( D(LCTL), T(A), U(LCTL), T(RBRC), END); 
             }
         break;        
-        case SWITCH_NDS:
+		
+		case SHELL_WRITE_LOGPATTERN:
             if (record->event.pressed) {
-                return MACRO( D(LSFT), 
-                              T(F11), 
-                              U(LSFT), 
-                              W(255), 
-                              D(LALT), 
-                              T(TAB), 
-                              U(LALT), 
-                              END); 
-            }                                
-        break;        
-        case SHELL_RECALL_LAST_ARG_REMOVE_FIRST_COMMAND:
+                return MACRO( D(LSFT),
+							  T(8), 
+				              T(8), 
+							  U(LSFT),
+							  T(L),  
+							  T(O), 
+							  T(G), 
+							  T(LEFT), 
+							  T(LEFT), 
+							  T(LEFT), 
+							  T(LEFT), 
+							  END); 
+            }		
+		break;
+		
+		case SHELL_WRITE_TRANPATTERN:
             if (record->event.pressed) {
-                return MACRO( T(UP), T(HOME), D(LALT), T(D), U(LALT), END);
-            }
-        break;                                
+                return MACRO( D(LSFT),
+							  T(8), 
+				              T(8), 
+							  U(LSFT), T(T), T(R), T(A), T(N), T(LEFT), T(LEFT), T(LEFT), T(LEFT), T(LEFT), END); 
+            }		
+		break;		
+		
+		case SHELL_EXPAND_PATTERN:
+            if (record->event.pressed) {
+                return MACRO( D(LALT), T(F), U(LALT), D(LCTL), T(X), U(LCTL), D(LSFT), T(8), D(LSFT), END); 
+            }		
+		break;				
+   
       }
     return MACRO_NONE;
 };
@@ -393,6 +548,10 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
             SEND_STRING("ls -ltr\n");
             return true;
             break;
+        case SHELL_LSLA:
+            SEND_STRING("ls -la\n");
+            return true;
+            break;
         case SHELL_CDPRE:
             SEND_STRING("cd ..\n");
             return true;
@@ -445,6 +604,32 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
             SEND_STRING("htcStatus -j ");
             return true;
             break;               
+		// Cloud9 macros
+		case CLOUD9_TAB_LEFT:
+            SEND_STRING(SS_LCTRL("["));
+            return true;		
+			break;
+		case CLOUD9_TAB_RIGHT:
+            SEND_STRING(SS_LCTRL("]"));
+            return true;				
+			break;
+		case CLOUD9_TAB_CLOSE:
+            SEND_STRING(SS_LALT("w"));
+            return true;				
+			break;
+		case CLOUD9_GOTO_SYMBOL:
+            SEND_STRING(SS_LSFT(SS_LCTRL("e")));
+            return true;		
+			break;
+		case CLOUD9_GOTO_LINE:
+            SEND_STRING(SS_LCTRL("g"));
+            return true;						
+			break;
+		case CLOUD9_NAVIGATE:
+            SEND_STRING(SS_LCTRL("e"));
+            return true;
+			break;
+  		
     }
   }
   
@@ -474,9 +659,11 @@ void matrix_scan_user(void) {
         case SHELL_SCREEN:
         case KEYNAV:
         case KEYSEL:
+		case SCREEN_NAV:
             ergodox_right_led_3_on();
             break;
         case MOUSE:
+		case BROWSER_CONTROL:
             ergodox_right_led_2_on();
             ergodox_right_led_3_on();
             break;

keyboards/ergodox_ez/keymaps/smurmann/keymap.c

@@ -0,0 +1,228 @@
+#include QMK_KEYBOARD_H
+#include "debug.h"
+#include "action_layer.h"
+#include "version.h"
+
+#define BASE 0 // default layer
+#define MDIA 1 // media keys
+
+#define _______ KC_TRNS
+
+enum custom_keycodes {
+  PLACEHOLDER = SAFE_RANGE, // can always be here
+  EPRM,
+  VRSN,
+  RGB_SLD
+};
+
+bool capsOn = false;
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+/* Keymap 0: Basic layer
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * | Esc    |   1  |   2  |   3  |   4  |   5  |   6  |           |   7  |   8  |   9  |   0  |   -  |   =  |  Bksp  |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * | Tab    |   Q  |   W  |   E  |   R  |   T  |  {   |           |  }   |   Y  |   U  |   I  |   O  |   P  |   \    |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |HyperCaps|  A  |   S  |   D  |   F  |   G  |------|           |------|   H  |   J  |   K  |   L  |; / L1| Enter  |
+ * |--------+------+------+------+------+------| Alt  |           |  L1  |------+------+------+------+------+--------|
+ * | LShift | Z/L1 |   X  |   C  |   V  |   B  |      |           |      |   N  |   M  |   ,  |   .  |   ?  | RShift |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   |lCrtr |   [  |   ]  |   `  |   '  |                                       | Left |  Up  | Down | Right| PlayWin |
+ *   `----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |PRTSRN| Win  |       | Home | End  |
+ *                                 ,------|------|------|       |------+--------+------.
+ *                                 |      |      | Ins  |       | PgUp |        |      |
+ *                                 | Space|Backsp|------|       |------|  Enter |Space |
+ *                                 |      |ace   | Del  |       | PgDn |        |      |
+ *                                 `--------------------'       `----------------------'
+ */
+// If it accepts an argument (i.e, is a function), it doesn't need KC_.
+// Otherwise, it needs KC_*
+[BASE] = LAYOUT_ergodox(  // layer 0 : default
+        // left hand
+        KC_ESC,         KC_1,         KC_2,   KC_3,   KC_4,   KC_5,   KC_6,
+        KC_TAB,         KC_Q,         KC_W,   KC_E,   KC_R,   KC_T,   KC_LCBR,
+        ALL_T(KC_CAPS), KC_A,         KC_S,   KC_D,   KC_F,   KC_G,
+        KC_LSFT,        LT(MDIA,KC_Z),  KC_X,   KC_C,   KC_V,   KC_B,   KC_LALT,
+        KC_LCTRL,       KC_LBRC,      KC_RBRC,        KC_GRV, KC_QUOT,
+                                                     KC_PSCR, KC_LGUI,
+                                                              KC_INS,
+                                               KC_SPC,KC_BSPC,KC_DEL,
+        // right hand
+                 KC_7,    KC_8,   KC_9,  KC_0,KC_MINS, KC_EQL,             KC_BSPC,
+              KC_RCBR,    KC_Y,   KC_U,  KC_I,   KC_O,   KC_P,             KC_BSLS,
+                          KC_H,   KC_J,  KC_K,   KC_L,   LT(MDIA, KC_SCLN),KC_ENT,
+             TG(MDIA),    KC_N,   KC_M,  KC_COMM,KC_DOT, KC_SLSH,          KC_RSFT,
+                                  KC_LEFT, KC_UP,KC_DOWN,KC_RGHT,          GUI_T(KC_MPLY),
+             KC_HOME,        KC_END,
+             KC_PGUP,
+             KC_PGDN,KC_ENT, KC_SPC
+    ),
+/* Keymap 1: Media and mouse keys
+ *
+ * ,---------------------------------------------------.           ,--------------------------------------------------.
+ * |Version  |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |           |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 |        |
+ * |---------+------+------+------+------+------+------|           |------+------+------+------+------+------+--------|
+ * |BootLoad |      | Lclk | MsUp | Rclk |      |      |           |      |      |      |  Up  |      |      |        |
+ * |---------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |         |      |MsLeft|MsDown|MsRght|      |------|           |------|      | Left | Down | Right|      |        |
+ * |---------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |         |      |MsAcl0|MsAcl1|MsAcl2|      |      |           |      |      |      | Mute | Mute |      |        |
+ * `---------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   |       |      |      |      |      |                                       | Prev |VolUp |VolDn | Next |      |
+ *   `-----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |      |      |       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       |      |      |      |
+ *                                 |      |      |------|       |------|      |      |
+ *                                 |      |      |      |       |      |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+// Functions
+[MDIA] = LAYOUT_ergodox(
+       // left hand
+          VRSN,  KC_F1,  KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_F6,
+         RESET,_______,KC_BTN1,KC_MS_U,KC_BTN2,_______,_______,
+       _______,_______,KC_MS_L,KC_MS_D,KC_MS_R,_______,
+       _______,_______,KC_ACL0,KC_ACL1,KC_ACL2,_______,_______,
+        _______,_______,_______,_______,_______,
+                                       _______,_______,
+                                               _______,
+                               _______,_______,_______,
+       // right hand
+         KC_F7, KC_F8,  KC_F9, KC_F10,  KC_F11, KC_F12,_______,
+       _______,_______,_______, KC_UP ,_______,_______,_______,
+               _______,KC_LEFT,KC_DOWN,KC_RGHT,_______,_______,
+       _______,_______,_______,KC_MUTE,KC_MUTE,_______,_______,
+                       KC_MPRV,KC_VOLU,KC_VOLD,KC_MNXT,_______,
+       _______, _______,
+       _______,
+       _______, _______, _______
+),
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+    [1] = ACTION_LAYER_TAP_TOGGLE(MDIA)                // FN1 - Momentary Layer 1 (Symbols)
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  // MACRODOWN only works in this function
+  switch(id) {
+    case 0:
+      if (record->event.pressed) {
+        SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
+      }
+      break;
+    case 1:
+      if (record->event.pressed) { // For resetting EEPROM
+        eeconfig_init();
+      }
+      break;
+  }
+  return MACRO_NONE;
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    // dynamically generate these.
+    case EPRM:
+      if (record->event.pressed) {
+        eeconfig_init();
+      }
+      return false;
+      break;
+    case VRSN:
+      if (record->event.pressed) {
+        SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
+      }
+      return false;
+      break;
+    case RGB_SLD:
+      if (record->event.pressed) {
+        #ifdef RGBLIGHT_ENABLE
+          rgblight_mode(1);
+        #endif
+      }
+      return false;
+      break;
+  }
+  return true;
+}
+
+// Runs just one time when the keyboard initializes.
+void matrix_init_user(void) {
+#ifdef RGBLIGHT_COLOR_LAYER_0
+  rgblight_setrgb(RGBLIGHT_COLOR_LAYER_0);
+#endif
+};
+
+// Runs constantly in the background, in a loop.
+void matrix_scan_user(void) {
+   uint8_t layer = biton32(layer_state);
+
+   if(layer == 1)
+   {
+      ergodox_right_led_2_on();
+      ergodox_right_led_3_on();
+
+      ergodox_right_led_2_set (LED_BRIGHTNESS_HI);
+      ergodox_right_led_3_set (LED_BRIGHTNESS_HI);
+   }
+
+   if(capsOn)
+   {
+      ergodox_right_led_1_set (LED_BRIGHTNESS_HI);
+      ergodox_right_led_1_on ();
+   }
+
+  if(keyboard_report->mods & MOD_BIT(KC_LSFT))
+  { 
+      ergodox_right_led_1_set (LED_BRIGHTNESS_HI);
+      ergodox_right_led_1_on ();
+  } else {
+      ergodox_right_led_1_set (LED_BRIGHTNESS_LO);
+
+      if(!capsOn)
+      {
+        ergodox_right_led_1_off ();
+      }
+  }
+
+  if(keyboard_report->mods & MOD_BIT(KC_LALT))
+  {
+      ergodox_right_led_2_set (LED_BRIGHTNESS_HI);
+      ergodox_right_led_2_on ();
+  } else {
+      ergodox_right_led_2_set (LED_BRIGHTNESS_LO);
+     if(layer != 1)
+     {
+       ergodox_right_led_2_off ();
+     }
+  }
+
+  if(keyboard_report->mods & MOD_BIT(KC_LCTRL))
+  { 
+      ergodox_right_led_3_set (LED_BRIGHTNESS_HI);
+      ergodox_right_led_3_on ();
+  } else {
+      ergodox_right_led_3_set (LED_BRIGHTNESS_LO);
+     if(layer != 1)
+     {
+       ergodox_right_led_3_off ();
+     }
+  }
+};
+
+void led_set_user(uint8_t usb_led){
+ if (usb_led & (1 << USB_LED_CAPS_LOCK)) 
+   {
+      capsOn = true;
+   }else {
+      capsOn = false;
+   }
+}

keyboards/ergodox_infinity/keymaps/halfkeyboard/config.h

@@ -0,0 +1,105 @@
+/*
+Copyright 2015 Jun Wako <wakojun@gmail.com>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef INFINITY_ERGODOX_CONFIG_H
+#define INFINITY_ERGODOX_CONFIG_H
+
+
+/* USB Device descriptor parameter */
+#define VENDOR_ID       0xFEED
+#define PRODUCT_ID      0x6464
+#define DEVICE_VER      0x0001
+/* in python2: list(u"whatever".encode('utf-16-le')) */
+/*   at most 32 characters or the ugly hack in usb_main.c borks */
+#define MANUFACTURER "TMK"
+#define USBSTR_MANUFACTURER    'T', '\x00', 'M', '\x00', 'K', '\x00', ' ', '\x00'
+#define PRODUCT "Infinity keyboard/TMK"
+#define USBSTR_PRODUCT         'I', '\x00', 'n', '\x00', 'f', '\x00', 'i', '\x00', 'n', '\x00', 'i', '\x00', 't', '\x00', 'y', '\x00', ' ', '\x00', 'k', '\x00', 'e', '\x00', 'y', '\x00', 'b', '\x00', 'o', '\x00', 'a', '\x00', 'r', '\x00', 'd', '\x00', '/', '\x00', 'T', '\x00', 'M', '\x00', 'K', '\x00'
+
+#define MOUSEKEY_INTERVAL       20
+#define MOUSEKEY_DELAY          0
+#define MOUSEKEY_TIME_TO_MAX    60
+#define MOUSEKEY_MAX_SPEED      7
+#define MOUSEKEY_WHEEL_DELAY 0
+
+#define TAPPING_TOGGLE  1
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+#define TAPPING_TERM    200
+#define IGNORE_MOD_TAP_INTERRUPT // this makes it possible to do rolling combos (zx) with keys that convert to other keys on hold (z becomes ctrl when you hold it, and when this option isn't enabled, z rapidly followed by x actually sends Ctrl-x. That's bad.)
+
+/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
+#define LOCKING_SUPPORT_ENABLE
+/* Locking resynchronize hack */
+#define LOCKING_RESYNC_ENABLE
+
+/* key combination for command */
+#define IS_COMMAND() ( \
+    keyboard_report->mods == (MOD_BIT(KC_LCTL) | MOD_BIT(KC_RCTL)) || \
+    keyboard_report->mods == (MOD_BIT(KC_LSFT) | MOD_BIT(KC_RSFT)) \
+)
+
+/* key matrix size */
+#define MATRIX_ROWS 18
+#define MATRIX_COLS 5
+#define LOCAL_MATRIX_ROWS 9
+
+/* number of backlight levels */
+#define BACKLIGHT_LEVELS 3
+
+#define LED_BRIGHTNESS_LO       100
+#define LED_BRIGHTNESS_HI       255
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCE    5
+
+#define SERIAL_LINK_BAUD 562500
+#define SERIAL_LINK_THREAD_PRIORITY (NORMALPRIO - 1)
+
+#define VISUALIZER_USER_DATA_SIZE 16
+/*
+ * music mode options
+ * midi enabled
+ * keymask disabled
+ * so typing normally will result in music
+ *
+ */
+#define MUSIC_MASK keycode != KC_NO
+/*
+ * Feature disable options
+ *  These options are also useful to firmware size reduction.
+ */
+
+/* disable debug print */
+//#define NO_DEBUG
+
+/* disable print */
+//#define NO_PRINT
+
+/* disable action features */
+//#define NO_ACTION_LAYER
+//#define NO_ACTION_TAPPING
+//#define NO_ACTION_ONESHOT
+//#define NO_ACTION_MACRO
+//#define NO_ACTION_FUNCTION
+
+#endif

keyboards/ergodox_infinity/keymaps/halfkeyboard/keymap.c

@@ -2,15 +2,19 @@
 #include "debug.h"
 #include "action_layer.h"
 #include "version.h"
-
-#define QWERTY 0 // qwerty layer 
-#define HALFQWERTY 1 // mirrored qwerty layer 
-#define DVORAK 2 // dvorak layer 
-#define HALFDVORAK 3 // mirrored dvorak layer 
+#include "keymap_steno.h"
+#ifndef MIDI_ENABLE
+#error "Midi is not enabled"
+#endif
+#define QWERTY 0 // qwerty layer
+#define HALFQWERTY 1 // mirrored qwerty layer
+#define DVORAK 2 // dvorak layer
+#define HALFDVORAK 3 // mirrored dvorak layer
 #define SYMB 5 // symbols
 #define HALFSYMB 6 // media keys
 #define PLVR 7 // steno plover layout
 #define SHORTCUTS 8 //layer with shortcut keys
+#define MDIA 9
 
 
 enum custom_keycodes {
@@ -37,7 +41,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  *                                        ,-------------.       ,-------------.
  *                                        |Symbol|Dvorak|       |Plover|HalfSymb|
  *                                 ,------|------|------|       |------+--------+------.
- *                                 |      |      | Home |       | PgUp |        |      |
+ *                                 |      |      |MU_TOG|       | PgUp |        |      |
  *                                 | Space|DELETE|------|       |------|  Tab   |Enter |
  *                                 |mirror|      | End  |       | PgDn |        |mirror|
  *                                 `--------------------'       `----------------------'
@@ -52,16 +56,16 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         KC_LSFT,        KC_Z,  		  KC_X,   KC_C,   KC_V,   KC_B,   KC_MINUS,
         KC_LCTRL, 		KC_LALT,	  LCTL(LSFT(KC_TAB)),LCTL(KC_TAB),  MO(SHORTCUTS),
                                               TG(SYMB),  TG(DVORAK),
-                                                              KC_HOME,
+                                                              MU_ON,
                                          LT(HALFQWERTY, KC_SPACE),KC_DEL,KC_END,
         // right hand
              KC_BSLS,     KC_6,   KC_7,  KC_8,   KC_9,   KC_0,             KC_BSPC,
              KC_RBRC,    KC_Y,   KC_U,  KC_I,   KC_O,   KC_P,             KC_SLASH,
                           KC_H,   KC_J,  KC_K,   KC_L,   KC_SCLN,		   KC_ENT,
              KC_EQL,KC_N,   KC_M,  KC_COMM,KC_DOT, KC_SLASH,   	   KC_RSFT,
-                                  KC_RGUI, KC_UP,KC_DOWN,KC_RALT,           KC_RCTRL,
-             TG(PLVR),        TG(HALFSYMB),
-             KC_PGUP,
+                                  MO(MDIA), KC_UP,KC_DOWN,KC_RALT,           KC_RCTRL,
+             TG(PLVR),        TG(MDIA),
+             MU_OFF,
              KC_PGDN,KC_TAB, LT(HALFQWERTY, KC_ENT)
     ),
 /* Keymap 1: mirrored qwerty
@@ -95,16 +99,16 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         KC_LSFT,        KC_SLASH,  	  KC_DOT, KC_COMM,KC_M,   KC_N,   KC_EQL,
         KC_LCTRL, 		KC_LALT,	   LCTL(LSFT(KC_TAB)),LCTL(KC_TAB),  KC_TRNS,
                                               KC_TRNS,  KC_TRANSPARENT,
-                                                              KC_HOME,
+                                                              KC_TRNS,
                                          KC_TRANSPARENT,KC_DEL,KC_END,
         // right hand
              KC_GRAVE,     KC_5,   KC_4,  KC_3,   KC_2,   KC_1,             KC_BSPC,
              KC_LBRC,    KC_T,   KC_R,  KC_E,   KC_W,   KC_Q,             KC_BSLS,
                           KC_G,   KC_F,  KC_D,   KC_S,   KC_A,  		   KC_ENT,
              KC_MINUS,KC_B,   KC_V,  KC_C,   KC_X,   KC_Z,		   	   KC_RSFT,
-                                  KC_RGUI, KC_UP,KC_DOWN,KC_RALT,           KC_RCTRL,
+                                  KC_TRNS, KC_UP,KC_DOWN,KC_RALT,           KC_RCTRL,
              KC_TRANSPARENT,        KC_TRNS,
-             KC_PGUP,
+             KC_TRNS,
              KC_PGDN,KC_TAB, KC_TRANSPARENT
     ),
 /* Keymap 3: dvorak
@@ -118,7 +122,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |--------+------+------+------+------+------| -    |           | =    |------+------+------+------+------+--------|
  * | LShift |   ;  |   Q  |   J  |   K  |   X  |      |           |      |   B  |   M  |   W  |   V  |  Z   | RShift |
  * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
- *   |LCTRL|ALT  |CTLShTab|CTL-TAB| LGui|                                       |  RGui| UP   | DOWN |  ALT | RCTRL  |
+ *   |LCTRL|ALT  |CTLShTab|CTL-TAB| LGui|                                       | Mouse| UP   | DOWN |  ALT | RCTRL  |
  *   `----------------------------------'                                       `----------------------------------'
  *                                        ,-------------.       ,-------------.
  *                                        | Alt  |      |       |      |Alt   |
@@ -138,16 +142,16 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         KC_LSFT,        KC_SCLN,	  KC_Q,   KC_J,   KC_K,   KC_X,   KC_MINUS,
         KC_LCTRL, 		KC_LALT,	  LCTL(LSFT(KC_TAB)),LCTL(KC_TAB),  KC_TRNS,
                                               TG(SYMB),  KC_TRANSPARENT,
-                                                              KC_HOME,
+                                                              KC_TRNS,
                               LT(HALFDVORAK, KC_SPACE),KC_DEL,KC_END,
         // right hand
              KC_BSLS,     KC_6,   KC_7,  KC_8,   KC_9,   KC_0,             KC_BSPC,
              KC_RBRC,    KC_F,   KC_G,  KC_C,   KC_R,   KC_L,             KC_SLASH,
                           KC_D,   KC_H,  KC_T,   KC_N,   KC_S,		   KC_ENT,
              KC_EQL,KC_B,   KC_M,  KC_W,	 KC_V,	 KC_Z,		   	   KC_RSFT,
-                                  KC_RGUI, KC_UP,KC_DOWN,KC_RALT,           KC_RCTRL,
-             KC_TRANSPARENT,        TG(HALFSYMB),
-             KC_PGUP,
+                                  KC_TRNS, KC_UP,KC_DOWN,KC_RALT,           KC_RCTRL,
+             KC_TRANSPARENT,        TG(MDIA),
+             KC_TRNS,
              KC_PGDN,KC_TAB, LT(HALFDVORAK, KC_ENT)
     ),
 /* Keymap 3: mirrored dvorak
@@ -161,7 +165,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
  * |--------+------+------+------+------+------| =    |           | -    |------+------+------+------+------+--------|
  * | LShift |   Z  |   V  |   W  |   M  |   B  |      |           |      |   X  |   K  |   J  |   Q  |   ;  | RShift |
  * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
- *   |LCTRL|ALT  |CTLShTab|CTL-TAB| LGui|                                       |  RGui| UP   | DOWN |  ALT | RCTRL  |
+ *   |LCTRL|ALT  |CTLShTab|CTL-TAB| LGui|                                       | MOUSE| UP   | DOWN |  ALT | RCTRL  |
  *   `----------------------------------'                                       `----------------------------------'
  *                                        ,-------------.       ,-------------.
  *                                        | Alt  |      |       |      |Alt   |
@@ -181,16 +185,16 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
         KC_LSFT,        KC_Z,  		  KC_V,   KC_W,   KC_M,   KC_B,   KC_EQL,
         KC_LCTRL, 		KC_LALT,	  LCTL(LSFT(KC_TAB)),LCTL(KC_TAB),  KC_TRNS,
                                               KC_TRANSPARENT,  KC_TRANSPARENT,
-                                                              KC_HOME,
+                                                              KC_TRNS,
                                          KC_TRANSPARENT,KC_DEL,KC_END,
         // right hand
              KC_GRAVE,     KC_5,   KC_4,  KC_3,   KC_2,   KC_5,             KC_ESC,
              KC_LBRC,    KC_Y,   KC_P,  KC_DOT, KC_COMM,KC_P,             KC_TAB,
                           KC_I,   KC_U,  KC_E,   KC_O,   KC_A,		 	   KC_BSPC,
              KC_MINUS,KC_X,   KC_K,  KC_J,	 KC_Q,   KC_SCLN,	   	   KC_RSFT,
-                                  KC_RGUI, KC_UP,KC_DOWN,KC_RALT,           KC_RCTRL,
+                                  KC_TRNS, KC_UP,KC_DOWN,KC_RALT,           KC_RCTRL,
              KC_TRANSPARENT,        KC_TRNS,
-             KC_PGUP,
+             KC_TRNS,
              KC_PGDN,KC_TAB, KC_TRANSPARENT
     ),
 /* Keymap 5: Symbol Layer
@@ -230,7 +234,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
        KC_NO, KC_UP, KC_KP_7, KC_KP_8,  KC_KP_9,KC_KP_ASTERISK, KC_KP_SLASH,
             KC_DOWN, KC_KP_4, KC_KP_5,  KC_KP_6,  KC_KP_MINUS, KC_KP_ENTER,
        KC_NO,KC_AMPR,KC_KP_1, KC_KP_2,  KC_KP_3,   KC_KP_PLUS, KC_NO,
-                         KC_NO,KC_DOT,  KC_0,    KC_KP_EQUAL,  KC_NO,
+                         KC_TRNS,KC_DOT,  KC_0,    KC_KP_EQUAL,  KC_NO,
        KC_NO, KC_TRNS,
        KC_NO,
        KC_NO, KC_NO, LT(HALFSYMB, KC_ENT)
@@ -265,16 +269,16 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
        KC_NO,KC_NO,KC_KP_1, KC_KP_2, KC_KP_3,KC_KP_PLUS,KC_KP_ENTER,
           EPRM,KC_NO,KC_KP_0,KC_KP_DOT,KC_KP_EQUAL,
                                          KC_TRNS,KC_NO,
-                                               KC_NO,
+                                               KC_TRNS,
                           KC_TRANSPARENT,KC_NO,KC_NO,
        // right hand
        KC_F6, KC_F5,   KC_F4,  KC_F3,   KC_F2,   KC_F1,  KC_BSPC,
        KC_NO,KC_PIPE,KC_LCBR,KC_RCBR, KC_SLASH, KC_BSLS, KC_NO,
              KC_GRV,KC_LPRN,KC_RPRN,  KC_SCLN, KC_QUOT, KC_NO,
        KC_NO, KC_TILD,KC_LBRC,KC_RBRC, KC_EQL,  KC_MINUS, KC_NO,
-                         KC_NO,KC_NO,  KC_NO,    KC_NO,  KC_NO,
+                         KC_TRNS,KC_NO,  KC_NO,    KC_NO,  KC_NO,
        KC_NO, KC_TRNS,
-       KC_NO,
+       KC_TRNS,
        KC_NO, KC_NO, KC_TRANSPARENT
 ),
 
@@ -303,22 +307,107 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 [PLVR] = LAYOUT_ergodox(  // layout: layer 4: Steno for Plover
         // left hand
         KC_NO, KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,
-        KC_NO,  KC_1,   KC_2,   KC_3,   KC_4,   KC_5,   KC_TRNS,
-        KC_NO,  KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,
-        KC_NO,  KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_NO,
+        STN_N1, STN_N2, STN_N3, STN_N4, STN_N5, STN_N6, KC_NO,
+        STN_FN, STN_S1, STN_TL, STN_PL, STN_HL, STN_ST1,
+        KC_NO,  STN_S2, STN_KL, STN_WL, STN_RL, STN_ST2,   KC_NO,
         KC_NO,  KC_NO,  KC_NO,  KC_NO,  KC_NO,
-                                      KC_FN4, KC_NO,
-                                           KC_NO,
-                                 KC_C,   KC_V,   KC_NO,
+                                      KC_TRNS, KC_TRNS,
+                                           KC_TRNS,
+                                 STN_A,   STN_O,   KC_NO,
         // right hand
-             KC_TRNS,  KC_NO,   KC_NO,   KC_NO,  KC_NO,   KC_NO,   KC_TRNS,
-             KC_TRNS,   KC_6,    KC_7,    KC_8,   KC_9,    KC_0,   KC_TRNS,
-                        KC_Y,   KC_U,    KC_I,    KC_O,   KC_P,    KC_LBRC,
-               KC_NO,   KC_H,    KC_J,    KC_K,   KC_L, KC_SCLN,   KC_QUOT,
+             KC_TRNS,  KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_NO,   KC_TRNS,
+             KC_TRNS, STN_N7,  STN_N8,  STN_N9,  STN_NA,  STN_NB,   STN_NC,
+                     STN_ST3,  STN_FR,  STN_PR,  STN_LR,  STN_TR,   STN_DR,
+               KC_NO,STN_ST4,  STN_RR,  STN_BR,  STN_GR,  STN_SR,   STN_ZR,
                               KC_TRNS, KC_TRNS,  KC_NO,   KC_NO,     KC_NO,
         KC_TRNS, KC_TRNS,
         KC_TRNS,
-        KC_NO,  KC_N,   KC_M
+        KC_NO,  STN_E,   STN_U
+),
+/* Keymap 8: shortcuts
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |  ESC   |   1  |   2  |   3  |   4  |   5  | LEFT |           | RIGHT|   6  |   7  |   8  |   9  |   0  |  BSPC  |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * | TAB    |   Q  |   W  |   E  |   R  |   T  |  L1  |           |  L1  |   Y  |   U  |   I  |   O  |   P  |   \    |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * | BkSp   |   A  |   S  |   D  |   F  |   G  |------|           |------|   H  |   J  |   K  |   L  |   ;  |ENTER   |
+ * |--------+------+------+------+------+------| -    |           | =    |------+------+------+------+------+--------|
+ * | LShift |   Z  |   X  |   C  |   V  |   B  |      |           |      |   N  |   M  |   ,  |   .  |   /  | RShift |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   |LCTRL|ALT  |CTLShTab|CTL-TAB|     |                                       |  RGui| UP   | DOWN |  ALT | RCTRL  |
+ *   `----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        | Alt  |Dvorak|       |Plover|Alt   |
+ *                                 ,------|------|------|       |------+--------+------.
+ *                                 |      |      | Home |       | PgUp |        |      |
+ *                                 | Space|DELETE|------|       |------|  Tab   |Enter |
+ *                                 |mirror|      | End  |       | PgDn |        |mirror|
+ *                                 `--------------------'       `----------------------'
+ */
+// If it accepts an argument (i.e, is a function), it doesn't need KC_.
+// Otherwise, it needs KC_*
+[SHORTCUTS] = LAYOUT_ergodox(  // layer 0 : default
+        // left hand
+        KC_ESC,         KC_1,         KC_2,   KC_3,   KC_4,   KC_5,   KC_NO,
+        KC_TAB,   LCTL(KC_Q),   LCTL(KC_W),LCTL(KC_E),LCTL(KC_R),LCTL(KC_T),   KC_NO,
+        KC_BSPC,  LCTL(KC_A),   LCTL(KC_S),LCTL(KC_D),LCTL(KC_F),LCTL(KC_G),
+        KC_LSFT,  LCTL(KC_Z),  	LCTL(KC_X),LCTL(KC_C),LCTL(KC_V),LCTL(KC_B),   KC_MINUS,
+        KC_LCTRL, 		KC_LALT,	  LCTL(LSFT(KC_TAB)),LCTL(KC_TAB),  KC_TRANSPARENT,
+                                              KC_NO,  KC_NO,
+
+                                                              KC_NO,
+                                         KC_NO,KC_NO,KC_NO,
+        // right hand
+             KC_RGHT,     KC_6,   KC_7,  KC_8,   KC_9,   KC_0,             KC_BSPC,
+             TG(SYMB),    KC_Y,   KC_U,  KC_I,   KC_O,   KC_P,             KC_BSLS,
+                          KC_H,   KC_J,  KC_K,   KC_L,   KC_SCLN,		   KC_ENT,
+             KC_EQL,KC_N,   KC_M,  KC_COMM,KC_DOT, KC_SLASH,   	   KC_RSFT,
+                                  KC_TRNS, KC_UP,KC_DOWN,KC_RALT,           KC_RCTRL,
+             KC_NO,        KC_TRNS,
+             KC_NO,
+             KC_NO,KC_NO, KC_NO
+    ),
+    /* Keymap 2: Media and mouse keys
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |        |      |      |      |      |      |      |           |      |      |      |      |      |      |        |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * |        |      |LClick| MsUp |RClick|      |      |           |      |      |LClick| MsUp |RClick|      |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |      |MsLeft|MsDown|MsRght|      |------|           |------|      |MsLeft|MsDown|MsRght|      |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |      |      |      |      |      |      |           |      |      |      |      |      |      |        |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   |      |      |      |      |      |                                       |      |      |      |      |      |
+ *   `----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |      |      |       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       |      |      |      |
+ *                                 |      |      |------|       |------|      |      |
+ *                                 |      |      |      |       |      |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+// MEDIA AND MOUSE
+[MDIA] = LAYOUT_ergodox(
+       KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_BTN1, KC_MS_U, KC_BTN2, KC_TRNS, KC_WH_U,
+       KC_TRNS, KC_TRNS, KC_MS_L, KC_MS_D, KC_MS_R, KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_WH_D,
+       KC_TRNS, KC_TRNS, KC_TRNS, KC_BTN1, KC_BTN2,
+                                           KC_TRNS, KC_TRNS,
+                                                    KC_TRNS,
+                                  KC_WH_L, KC_WH_R, KC_TRNS,
+    // right hand
+       KC_TRNS,  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+       KC_WH_U,  KC_TRNS, KC_BTN1, KC_MS_U, KC_BTN2, KC_TRNS, KC_TRNS,
+                 KC_TRNS, KC_MS_L, KC_MS_D, KC_MS_R, KC_TRNS, KC_TRNS,
+       KC_WH_D,  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_WH_L, KC_WH_R
 ),
 /* Keymap 8: shortcuts
  *
@@ -418,7 +507,7 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 
 // Runs just one time when the keyboard initializes.
 void matrix_init_user(void) {
-
+  steno_set_mode(STENO_MODE_GEMINI); // or STENO_MODE_BOLT
 };
 
 

keyboards/ergodox_infinity/keymaps/halfkeyboard/rules.mk

@@ -0,0 +1,91 @@
+# project specific files
+SRC =	matrix.c \
+	led.c
+
+## chip/board settings
+# - the next two should match the directories in
+#   <chibios>/os/hal/ports/$(MCU_FAMILY)/$(MCU_SERIES)
+# - For Teensies, FAMILY = KINETIS and SERIES is either
+#   KL2x (LC) or K20x (3.0,3.1,3.2).
+# - For Infinity KB, SERIES = K20x
+MCU_FAMILY = KINETIS
+MCU_SERIES = K20x
+
+# Linker script to use
+# - it should exist either in <chibios>/os/common/ports/ARMCMx/compilers/GCC/ld/
+#   or <this_dir>/ld/
+# - NOTE: a custom ld script is needed for EEPROM on Teensy LC
+# - LDSCRIPT =
+#   - MKL26Z64 for Teensy LC
+#   - MK20DX128 for Teensy 3.0
+#   - MK20DX256 for Teensy 3.1 and 3.2
+#   - MK20DX128BLDR4 for Infinity 60% with Kiibohd bootloader
+#   - MK20DX256BLDR8 for Infinity ErgoDox with Kiibohd bootloader
+MCU_LDSCRIPT = MK20DX256BLDR8
+
+# Startup code to use
+#  - it should exist in <chibios>/os/common/ports/ARMCMx/compilers/GCC/mk/
+# - STARTUP =
+#   - kl2x for Teensy LC
+#   - k20x5 for Teensy 3.0 and Infinity 60%
+#   - k20x7 for Teensy 3.1, 3.2 and Infinity ErgoDox
+MCU_STARTUP = k20x7
+
+# Board: it should exist either in <chibios>/os/hal/boards/
+#  or <this_dir>/boards
+# - BOARD =
+#   - PJRC_TEENSY_LC for Teensy LC
+#   - PJRC_TEENSY_3 for Teensy 3.0
+#   - PJRC_TEENSY_3_1 for Teensy 3.1 or 3.2
+#   - MCHCK_K20 for Infinity KB
+#BOARD = MCHCK_K20
+BOARD = PJRC_TEENSY_3_1
+
+# Cortex version
+# Teensy LC is cortex-m0; Teensy 3.x are cortex-m4
+MCU  = cortex-m4
+
+# ARM version, CORTEX-M0/M1 are 6, CORTEX-M3/M4/M7 are 7
+# I.e. 6 for Teensy LC; 7 for Teensy 3.x
+ARMV = 7
+
+# Vector table for application
+# 0x00000000-0x00001000 area is occupied by bootlaoder.*/
+# The CORTEX_VTOR... is needed only for MCHCK/Infinity KB
+OPT_DEFS += -DCORTEX_VTOR_INIT=0x00002000
+
+# Build Options
+#   comment out to disable the options.
+#
+
+BOOTMAGIC_ENABLE = no  # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE  = yes # Mouse keys(+4700)
+EXTRAKEY_ENABLE  = yes # Audio control and System control(+450)
+CONSOLE_ENABLE   = no  # Console for debug(+400)
+COMMAND_ENABLE   = yes # Commands for debug and configuration
+CUSTOM_MATRIX    = yes # Custom matrix file for the ErgoDox EZ
+SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend
+NKRO_ENABLE      = yes # USB Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+UNICODE_ENABLE   = yes # Unicode
+ONEHAND_ENABLE   = yes # Allow swapping hands of keyboard
+STENO_ENABLE = yes  #enable plover steno mode
+CUSTOM_MATRIX = yes # Custom matrix file
+SERIAL_LINK_ENABLE = yes
+VISUALIZER_ENABLE = yes
+LCD_ENABLE = yes
+BACKLIGHT_ENABLE = yes
+LCD_BACKLIGHT_ENABLE = yes
+MIDI_ENABLE = yes
+MIDI_ADVANCED = yes
+MUSIC_MODE = yes
+RGBLIGHT_ENABLE = no
+
+LCD_DRIVER = st7565
+LCD_WIDTH = 128
+LCD_HEIGHT = 32
+
+LED_DRIVER = is31fl3731c
+LED_WIDTH = 7
+LED_HEIGHT = 7
+
+LAYOUTS = ergodox

keyboards/ergodox_infinity/keymaps/halfkeyboard/visualizer.c

@@ -12,7 +12,140 @@ You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "simple_visualizer.h"
+#include "visualizer.h"
+#include "gfx.h"
+#include "math.h"
+#include "default_animations.h"
+#include "led_backlight_keyframes.h"
+
+#define ONESIDESCAN 9
+#define BOTHSIDESCAN 16
+#define FULL_ON LUMA2COLOR(255)
+#define THREE_QUARTER LUMA2COLOR(200)
+#define HALF_ON LUMA2COLOR(150)
+#define ONE_QUARTER LUMA2COLOR(50)
+#define CROSSFADE_TIME 8000
+bool KITT_scan_one_side_left_to_right(keyframe_animation_t* animation, visualizer_state_t* state);
+bool KITT_scan_one_side_right_to_left(keyframe_animation_t* animation, visualizer_state_t* state);
+keyframe_animation_t Fade_in_all_leds = {
+    .num_frames = 1,
+    .loop = false,
+    .frame_lengths = {
+        CROSSFADE_TIME,
+    },
+    .frame_functions = {
+        led_backlight_keyframe_fade_in_all,
+    },
+};
+/*
+ *  one set left to right.  then reverse to go back.
+ *  |    left side              |       right side          |       |
+    |---|---|---|---|---|---|---|:-:|---|---|---|---|---|---|-------|
+    | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 6 | 5 | 4 | 3 | 2 | 1 | 0 | phase |
+    _________________________________________________________________
+    | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0     |
+    | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1     |
+    | 2 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2     |
+    | 1 | 2 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 3     |
+    | 0 | 1 | 2 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 4     |
+    | 0 | 0 | 1 | 2 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 5     |
+    | 0 | 0 | 0 | 1 | 2 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 6     |
+    | 0 | 0 | 0 | 0 | 1 | 2 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 7     |
+    | 0 | 0 | 0 | 0 | 0 | 1 | 2 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 8     |
+    | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 2 | 3 | 0 | 0 | 0 | 0 | 0 | 9     |
+    | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 2 | 3 | 0 | 0 | 0 | 0 | 10    |
+    | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 2 | 3 | 0 | 0 | 0 | 11    |
+    | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 2 | 3 | 0 | 0 | 12    |
+    | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 2 | 3 | 0 | 13    |
+    | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 2 | 3 | 14    |
+    | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 2 | 15    |
+    | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 16    |
+  */
+
+#ifdef MASTER_IS_ON_RIGHT /*right side*/
+
+keyframe_animation_t KITT_Scanner_animation = {
+    .num_frames = 2,
+    .loop = true,
+    .frame_lengths = {
+        CROSSFADE_TIME * BOTHSIDESCAN,
+        CROSSFADE_TIME * BOTHSIDESCAN,
+    },
+    .frame_functions = {
+        KITT_scan_one_side_left_to_right,
+        KITT_scan_one_side_right_to_left,
+    },
+};
+
+bool KITT_scan_one_side_left_to_right(keyframe_animation_t* animation, visualizer_state_t* state) {
+    (void)state;
+    float frame_length = animation->frame_lengths[animation->current_frame];
+    float current_pos = frame_length - animation->time_left_in_frame;
+    int phase = current_pos/(frame_length/BOTHSIDESCAN);
+    int row = 0;
+    gdispGClear(LED_DISPLAY, ONE_QUARTER);
+    gdispGDrawPixel(LED_DISPLAY, 14-phase, row, FULL_ON);
+    gdispGDrawPixel(LED_DISPLAY, 15-phase, row, THREE_QUARTER);
+    gdispGDrawPixel(LED_DISPLAY, 16-phase, row, HALF_ON);
+    gdispGDrawPixel(LED_DISPLAY, 6, row, ONE_QUARTER);
+    return true;
+}
+
+bool KITT_scan_one_side_right_to_left(keyframe_animation_t* animation, visualizer_state_t* state) {
+    (void)state;
+    float frame_length = animation->frame_lengths[animation->current_frame];
+    float current_pos = frame_length - animation->time_left_in_frame;
+    int phase = current_pos/(frame_length/BOTHSIDESCAN);
+    int row = 0;
+    gdispGClear(LED_DISPLAY, ONE_QUARTER);
+    gdispGDrawPixel(LED_DISPLAY, phase, row, FULL_ON);
+    gdispGDrawPixel(LED_DISPLAY, phase-1, row, THREE_QUARTER);
+    gdispGDrawPixel(LED_DISPLAY, phase-2, row, HALF_ON);
+    gdispGDrawPixel(LED_DISPLAY, 6, row, ONE_QUARTER);
+    return true;
+}
+#else /*left side*/
+keyframe_animation_t KITT_Scanner_animation = {
+    .num_frames = 2,
+    .loop = true,
+    .frame_lengths = {
+        CROSSFADE_TIME * BOTHSIDESCAN,
+        CROSSFADE_TIME * BOTHSIDESCAN,
+    },
+    .frame_functions = {
+        KITT_scan_one_side_left_to_right,
+        KITT_scan_one_side_right_to_left,
+    },
+};
+
+bool KITT_scan_one_side_left_to_right(keyframe_animation_t* animation, visualizer_state_t* state) {
+    (void)state;
+    float frame_length = animation->frame_lengths[animation->current_frame];
+    float current_pos = frame_length - animation->time_left_in_frame;
+    int phase = current_pos/(frame_length/BOTHSIDESCAN);
+    int row = 0;
+    gdispGClear(LED_DISPLAY, ONE_QUARTER);
+    gdispGDrawPixel(LED_DISPLAY, phase, row, FULL_ON);
+    gdispGDrawPixel(LED_DISPLAY, phase-1, row, THREE_QUARTER);
+    gdispGDrawPixel(LED_DISPLAY, phase-2, row, HALF_ON);
+    gdispGDrawPixel(LED_DISPLAY, 6, row, ONE_QUARTER);
+    return true;
+}
+
+bool KITT_scan_one_side_right_to_left(keyframe_animation_t* animation, visualizer_state_t* state) {
+    (void)state;
+    float frame_length = animation->frame_lengths[animation->current_frame];
+    float current_pos = frame_length - animation->time_left_in_frame;
+    int phase = current_pos/(frame_length/BOTHSIDESCAN);
+    int row = 0;
+    gdispGClear(LED_DISPLAY, ONE_QUARTER);
+    gdispGDrawPixel(LED_DISPLAY, (14 - phase), row, FULL_ON);
+    gdispGDrawPixel(LED_DISPLAY, 14 - (phase-1), row, THREE_QUARTER);
+    gdispGDrawPixel(LED_DISPLAY, 14 - (phase-2), row, HALF_ON);
+    gdispGDrawPixel(LED_DISPLAY, 6, row, ONE_QUARTER);
+    return true;
+}
+#endif
 
 #define RED 0
 #define ORANGE 21
@@ -37,13 +170,19 @@ static void get_visualizer_layer_and_color(visualizer_state_t* state) {
     /* if (state->status.leds & (1u << USB_LED_CAPS_LOCK)) {
         saturation = 255;
     } */
-    if (state->status.layer & 0x100) {
+    if (state->status.layer & 0x200) {
+        state->target_lcd_color = LCD_COLOR(GREEN, saturation, 0xFF);
+        state->layer_text = "MOUSE";
+    }
+    else if (state->status.layer & 0x100) {
         state->target_lcd_color = LCD_COLOR(MAGENTA, saturation, 0xFF);
         state->layer_text = "Shortcuts Layer";
     }
     else    if (state->status.layer & 0x80) {
         state->target_lcd_color = LCD_COLOR(VIOLET, saturation, 0xFF);
         state->layer_text = "Plover";
+        start_keyframe_animation(&KITT_Scanner_animation);
+
     }
     else if (state->status.layer & 0x40) {
         state->target_lcd_color = LCD_COLOR(RASPBERRY, saturation, 0xFF);
@@ -68,5 +207,7 @@ static void get_visualizer_layer_and_color(visualizer_state_t* state) {
     else {
         state->target_lcd_color = LCD_COLOR(YELLOW, saturation, 0xFF);
         state->layer_text = "Qwerty";
+        stop_keyframe_animation(&KITT_Scanner_animation);
+        start_keyframe_animation(&Fade_in_all_leds);
     }
-}
+}

keyboards/ergodox_infinity/keymaps/halfkeyboard/visualizer.h

@@ -0,0 +1,125 @@
+/* Copyright 2017 Fred Sundvik
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef VISUALIZER_H_
+#define VISUALIZER_H_
+
+// Currently we are assuming that both the backlight and LCD are enabled
+// But it's entirely possible to write a custom visualizer that use only
+// one of them
+#ifndef LCD_BACKLIGHT_ENABLE
+#error This visualizer needs that LCD backlight is enabled
+#endif
+
+#ifndef LCD_ENABLE
+#error This visualizer needs that LCD is enabled
+#endif
+
+#include "visualizer.h"
+#include "visualizer_keyframes.h"
+#include "lcd_keyframes.h"
+#include "lcd_backlight_keyframes.h"
+#include "system/serial_link.h"
+#include "led.h"
+#include "default_animations.h"
+
+static const uint32_t logo_background_color = LCD_COLOR(0x00, 0x00, 0xFF);
+static const uint32_t initial_color = LCD_COLOR(0, 0, 0);
+
+static bool initial_update = true;
+
+// Feel free to modify the animations below, or even add new ones if needed
+extern keyframe_animation_t KITT_Scanner_animation;
+
+static keyframe_animation_t lcd_layer_display = {
+    .num_frames = 1,
+    .loop = false,
+    .frame_lengths = {gfxMillisecondsToTicks(0)},
+    .frame_functions = {lcd_keyframe_display_layer_and_led_states}
+};
+
+// The color animation animates the LCD color when you change layers
+static keyframe_animation_t color_animation = {
+    .num_frames = 2,
+    .loop = false,
+    // Note that there's a 200 ms no-operation frame,
+    // this prevents the color from changing when activating the layer
+    // momentarily
+    .frame_lengths = {gfxMillisecondsToTicks(200), gfxMillisecondsToTicks(500)},
+    .frame_functions = {keyframe_no_operation, lcd_backlight_keyframe_animate_color},
+};
+
+void initialize_user_visualizer(visualizer_state_t* state) {
+    // The brightness will be dynamically adjustable in the future
+    // But for now, change it here.
+    lcd_backlight_brightness(130);
+    state->current_lcd_color = initial_color;
+    state->target_lcd_color = logo_background_color;
+    initial_update = true;
+    start_keyframe_animation(&default_startup_animation);
+}
+
+
+// This function should be implemented by the keymap visualizer
+// Don't change anything else than state->target_lcd_color and state->layer_text as that's the only thing
+// that the simple_visualizer assumes that you are updating
+// Also make sure that the buffer passed to state->layer_text remains valid until the previous animation is
+// stopped. This can be done by either double buffering it or by using constant strings
+static void get_visualizer_layer_and_color(visualizer_state_t* state);
+
+void update_user_visualizer_state(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
+    // Add more tests, change the colors and layer texts here
+    // Usually you want to check the high bits (higher layers first)
+    // because that's the order layers are processed for keypresses
+    // You can for check for example:
+    // state->status.layer
+    // state->status.default_layer
+    // state->status.leds (see led.h for available statuses)
+
+    uint32_t prev_color = state->target_lcd_color;
+    const char* prev_layer_text = state->layer_text;
+
+    get_visualizer_layer_and_color(state);
+
+    if (initial_update || prev_color != state->target_lcd_color) {
+        start_keyframe_animation(&color_animation);
+    }
+
+    if (initial_update || prev_layer_text != state->layer_text) {
+        start_keyframe_animation(&lcd_layer_display);
+    }
+    // You can also stop existing animations, and start your custom ones here
+    // remember that you should normally have only one animation for the LCD
+    // and one for the background. But you can also combine them if you want.
+
+}
+
+void user_visualizer_suspend(visualizer_state_t* state) {
+    state->layer_text = "Suspending...";
+    uint8_t hue = LCD_HUE(state->current_lcd_color);
+    uint8_t sat = LCD_SAT(state->current_lcd_color);
+    state->target_lcd_color = LCD_COLOR(hue, sat, 0);
+    start_keyframe_animation(&default_suspend_animation);
+}
+
+void user_visualizer_resume(visualizer_state_t* state) {
+    state->current_lcd_color = initial_color;
+    state->target_lcd_color = logo_background_color;
+    initial_update = true;
+    start_keyframe_animation(&default_startup_animation);
+}
+
+#endif /* VISUALIZER_H_ */

keyboards/ergodox_infinity/keymaps/trulyergonomic/README.md

@@ -0,0 +1,3 @@
+# Truly Ergonomic like layout
+
+A basic ErgoDox layout that imitates the Truly Ergonomic keyboard layout.

keyboards/ergodox_infinity/keymaps/trulyergonomic/keymap.c

@@ -0,0 +1,177 @@
+#include QMK_KEYBOARD_H
+#include "debug.h"
+#include "action_layer.h"
+#include "version.h"
+
+#define BASE  0 // default layer
+#define EXTRA 1 // extra
+
+enum custom_keycodes {
+  PLACEHOLDER = SAFE_RANGE, // can always be here
+  EPRM,
+  VRSN,
+  RGB_SLD
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+/* Keymap 0: Basic layer
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |  ESC   |   1  |   2  |   3  |   4  |   5  | LGui |           | LGui |   6  |   7  |   8  |   9  |   0  |   -    |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * | Tab    |   Q  |   W  |   E  |   R  |   T  |  Del |           | Tab  |   Y  |   U  |   I  |   O  |   P  |   =    |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * | LShift |   A  |   S  |   D  |   F  |   G  |------|           |------|   H  |   J  |   K  |   L  |   ;  | RShift |
+ * |--------+------+------+------+------+------| Back |           | Back |------+------+------+------+------+--------|
+ * | LCtrl  |   Z  |   X  |   C  |   V  |   B  | space|           | space|   N  |   M  |   ,  |   .  |   '  | RCtrl  |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   | LAlt | Home | PgUp | PgDn |  End |                                       | Left |  Up  | Down | Rigth| RAlt |
+ *   `----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.        ,-------------.
+ *                                        |  ~   |   |  |        |   [  |   ]  |
+ *                                 ,------|------|------|        |------+------+------.
+ *                                 |      |      |  L1  |        | Grv  |      |      |
+ *                                 | Space|Enter |------|        |------| Enter|Space |
+ *                                 |      |      |  /   |        |   \  |      |      |
+ *                                 `--------------------'        `--------------------'
+ */
+// If it accepts an argument (i.e, is a function), it doesn't need KC_.
+// Otherwise, it needs KC_*
+[BASE] = LAYOUT_ergodox(  // layer 0 : default
+        // left hand
+        KC_ESC,    KC_1,      KC_2,      KC_3,      KC_4,     KC_5,   KC_LGUI,
+        KC_TAB,    KC_Q,      KC_W,      KC_E,      KC_R,     KC_T,   KC_DELT,
+        KC_LSFT,   KC_A,      KC_S,      KC_D,      KC_F,     KC_G,
+        KC_LCTL,   KC_Z,      KC_X,      KC_C,      KC_V,     KC_B,   KC_BSPC,
+        KC_LALT,   KC_HOME,   KC_PGUP,   KC_PGDN,   KC_END,
+                                                    KC_TILD,  KC_PIPE,
+                                                              TG(EXTRA),
+                                         KC_SPC,    KC_ENT,   KC_SLSH,
+        // right hand
+             KC_LGUI,   KC_6,      KC_7,      KC_8,      KC_9,      KC_0,      KC_MINS,
+             KC_TAB,    KC_Y,      KC_U,      KC_I,      KC_O,      KC_P,      KC_EQL,
+                        KC_H,      KC_J,      KC_K,      KC_L,      KC_SCLN,   KC_RSFT,
+             KC_BSPC,   KC_N,      KC_M,      KC_COMM,   KC_DOT,    KC_QUOT,   KC_RCTL,
+                                   KC_LEFT,   KC_UP,     KC_DOWN,   KC_RGHT,   KC_RALT,
+             KC_LBRC,   KC_RBRC,
+             KC_GRV,
+             KC_BSLS,   KC_ENT,    KC_SPC
+    ),
+/* Keymap 1: Extra Layer
+ *
+ * ,---------------------------------------------------.           ,--------------------------------------------------.
+ * |         |  F1  |  F2  |  F3  |  F4  |  F5  |      |           | PSCR |  F6  |  F7  |  F8  |  F9  |  F10 |   F11  |
+ * |---------+------+------+------+------+------+------|           |------+------+------+------+------+------+--------|
+ * |         |   !  |   @  |   {  |   }  |   |  |      |           |      |   Up |   7  |   8  |   9  |   *  |   F12  |
+ * |---------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |  Caps   |   #  |   $  |   (  |   )  |   `  |------|           |------| Down |   4  |   5  |   6  |   +  |        |
+ * |---------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |         |   %  |   ^  |   [  |   ]  |   ~  |      |           |      |   &  |   1  |   2  |   3  |   \  |        |
+ * `---------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   |       |      |      |      |      |                                       |   0  |   ,  |   .  |   =  |      |
+ *   `-----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |VolUp |VolDn |       | Prev | Next |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       | Stop |Bright|Bright|
+ *                                 | Mute |Pause |------|       |------|ness- |ness+ |
+ *                                 |      |      |      |       | Play |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+// SYMBOLS
+[EXTRA] = LAYOUT_ergodox(
+       // left hand
+       KC_TRNS,KC_F1,  KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_TRNS,
+       KC_TRNS,KC_EXLM,KC_AT,  KC_LCBR,KC_RCBR,KC_PIPE,KC_TRNS,
+       KC_CAPS,KC_HASH,KC_DLR, KC_LPRN,KC_RPRN,KC_GRV,
+       KC_TRNS,KC_PERC,KC_CIRC,KC_LBRC,KC_RBRC,KC_TILD,KC_TRNS,
+       KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,KC_TRNS,
+                                       KC_VOLU,KC_VOLD,
+                                               KC_TRNS,
+                               KC_MUTE,KC_PAUS,KC_TRNS,
+       // right hand
+       KC_PSCR, KC_F6,   KC_F7,  KC_F8,   KC_F9,   KC_F10,  KC_F11,
+       KC_TRNS, KC_UP,   KC_7,   KC_8,    KC_9,    KC_ASTR, KC_F12,
+                KC_DOWN, KC_4,   KC_5,    KC_6,    KC_PLUS, KC_TRNS,
+       KC_TRNS, KC_AMPR, KC_1,   KC_2,    KC_3,    KC_BSLS, KC_TRNS,
+                         KC_0,   KC_COMM, KC_DOT,  KC_EQL,  KC_TRNS,
+       KC_MPRV, KC_MNXT,
+       KC_STOP,
+       KC_MPLY, RGB_VAD, RGB_VAI
+),
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  // MACRODOWN only works in this function
+      switch(id) {
+        case 0:
+        if (record->event.pressed) {
+          SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
+        }
+        break;
+        case 1:
+        if (record->event.pressed) { // For resetting EEPROM
+          eeconfig_init();
+        }
+        break;
+      }
+    return MACRO_NONE;
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    // dynamically generate these.
+    case EPRM:
+      if (record->event.pressed) {
+        eeconfig_init();
+      }
+      return false;
+      break;
+    case VRSN:
+      if (record->event.pressed) {
+        SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
+      }
+      return false;
+      break;
+    case RGB_SLD:
+      if (record->event.pressed) {
+        #ifdef RGBLIGHT_ENABLE
+          rgblight_mode(1);
+        #endif
+      }
+      return false;
+      break;
+  }
+  return true;
+}
+
+// Runs just one time when the keyboard initializes.
+void matrix_init_user(void) {
+
+};
+
+
+// Runs constantly in the background, in a loop.
+void matrix_scan_user(void) {
+
+    uint8_t layer = biton32(layer_state);
+
+    ergodox_board_led_off();
+    ergodox_right_led_1_off();
+    ergodox_right_led_2_off();
+    ergodox_right_led_3_off();
+    switch (layer) {
+      // TODO: Make this relevant to the ErgoDox EZ.
+        case 1:
+            ergodox_right_led_1_on();
+            break;
+        case 2:
+            ergodox_right_led_2_on();
+            break;
+        default:
+            // none
+            break;
+    }
+
+};

keyboards/fc980c/README.md

@@ -155,8 +155,8 @@ Datasheets
 - AD5258: http://www.analog.com/media/en/technical-documentation/data-sheets/AD5258.pdf
 - JST S5B-PH-SM4: http://www.jst-mfg.com/product/pdf/eng/ePH.pdf
 - Hirose UX60SC-MB-5S8: https://www.hirose.com/product/en/products/UX/UX60SC-MB-5S8%2880%29/
-- TYU TU1252WNR-05S: http://php2.twinner.com.tw/files/tyu/TU1252series.pdf
 - Tr(E42) for LED?: http://cj-elec.com/txUpfile/2013614923661845.pdf
+- TYU TU1252WNR-05S: http://php2.twinner.com.tw/files/goodjob/TY1252series.pdf
 
 
 3.3V power supply

keyboards/gherkin/keymaps/wanleg/config.h

@@ -49,6 +49,13 @@
 /*tap dance definition */
 #define TAPPING_TERM 200
 
+//Mousekeys Settings
+#define MOUSEKEY_INTERVAL 1
+#define MOUSEKEY_DELAY 0
+#define MOUSEKEY_TIME_TO_MAX 1
+#define MOUSEKEY_MAX_SPEED 15
+#define MOUSEKEY_WHEEL_DELAY 0
+
 
 #ifdef RGB_DI_PIN
 #define RGBLIGHT_ANIMATIONS

keyboards/gherkin/keymaps/wanleg/keymap.c

@@ -173,14 +173,14 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 // * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
 // * | left   |  down  | right  | PrScr  | SHIFT  |  CTRL  | PgDn   | END    |  [     |  ]     |
 // * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
-// * |        |        |        |        |        |        |        |        | ALT    |  /     |
+// * | P-Brk  |        |        |        |        |        |        | RGUI   | ALT    |  /     |
 // * '-----------------------------------------------------------------------------------------'
 // */
 //
 [DIR] = KEYMAP( /* Directional Modifiers */
   KC_TAB,  KC_UP,   KC_TRNS, KC_INS,  KC_LCTL, KC_RSFT, KC_PGUP, KC_HOME, KC_MINS, KC_EQL  ,
   KC_LEFT, KC_DOWN, KC_RGHT, KC_PSCR, KC_LSFT, KC_RCTL, KC_PGDN, KC_END,  KC_LBRC, KC_RBRC ,
-  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_RALT, KC_SLSH
+  KC_PAUS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_RGUI, KC_LALT, KC_SLSH
 ),
 //
 // /*
@@ -205,17 +205,17 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
 //  /*
 //   *  ETC
 //   * .-----------------------------------------------------------------------------------------.
-//   * |  `     |        |        |        |        |        |        |        |        |  \     |
+//   * |  `     | mUP    |        |        |        | SHIFT  | mUp    | mDown  |        |  \     |
 //   * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
-//   * | CAPS   | P-Brk  |        |        |        |        |        |        |  ;     |  '     |
+//   * | mLeft  | mDown  | mRight |        | SHIFT  |        | mBtn1  | mBtn2  |  ;     |  '     |
 //   * |--------+--------+--------+--------+--------+--------+--------+--------+--------+--------|
-//   * | SHIFT  |        |        |        |        | C-A-D  |        | GUI    |        |  DEL   |
+//   * | Sft//Cp|        |        |        |        | C-A-D  |        |        | ALT    |  DEL   |
 //   * '-----------------------------------------------------------------------------------------'
 //   */
 //
 [ETC] = KEYMAP( /* ETC */
-  KC_GRV,  KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_BSLS ,
-  KC_CAPS, KC_PAUS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_SCLN, KC_QUOT ,
-  KC_LSFT, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LALT(LCTL(KC_DEL)), KC_TRNS, KC_RGUI, KC_TRNS, KC_DEL
+  KC_GRV,  KC_MS_U, _______, _______, _______, KC_RSFT, KC_WH_U, KC_WH_D, _______, KC_BSLS ,
+  KC_MS_L, KC_MS_D, KC_MS_R, KC_TRNS, KC_LSFT, KC_TRNS, KC_BTN1, KC_BTN2, KC_SCLN, KC_QUOT ,
+  TD(TD_SFT_CAPS), KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, LALT(LCTL(KC_DEL)), KC_TRNS, KC_TRNS, KC_LALT, KC_DEL
  ),
 };

keyboards/gherkin/keymaps/wanleg/readme.md

@@ -1,12 +1,47 @@
-![Gherkin Wanleg Layout Image](https://i.imgur.com/RpN5N42.png)
+![Gherkin Wanleg Layout Image](https://i.imgur.com/mXsgoro.png)
 
 # Gherkin Wanleg Layout
-
 Here is the layout I came up with to preserve a standard QWERTY layout as much as possible, in as few layers as possible for a 30 key board.
-I originally set up a few Tap Dance keys, but eventually dropped most of them in favor of chorded versions, since in actual use, they tended to impede typing speed more than their (current) two-key versions.
+I originally set up a few Tap Dance keys, but dropped half of them in favor of chorded versions, since in actual use, they tended to impede typing speed more than their (current) two-key versions.
 I've left them in my layout ready for use if anyone wants to try them out:
-Single tap - Double tap - Hold
-space - enter - shift
-backspace - delete - control
-shift - caps lock - XXXX
-KC_Q - escape - XXXX
+
+Legend Name | Single Tap | Double Tap | Hold
+--- | --- | --- | ---
+*null* | space | enter | shift
+*null* | backspace | delete | control
+Sft//Cp | shift | caps lock | *null*
+Q//Esc | KC_Q | escape | *null*
+
+# Gherkin Flashing
+## Linux
+The ProMicro doesn't like dfu-programmer, so we have to use AVRdude. What follows below are instructions for Linux taken from https://deskthority.net/workshop-f7/how-to-use-a-pro-micro-as-a-cheap-controller-converter-like-soarer-s-t8448.html
+
+`ls /dev/tty*`
+
+Next, plug in your device and re-run the command, the same as before:
+
+`ls /dev/tty*`
+
+There should be one more output device than was seen previously. For me, it's /dev/ttyACM0.
+To flash the device, you need to have AVRdude installed. On Linux, you can do this with your normal package manager.
+Once you have AVRdude set up, navigate to the directory with your .hex file in it. Then, run the following:
+
+`avrdude -p atmega32u4 -P YOUR_SERIAL_PORT  -c avr109  -U flash:w:YOUR_FILENAME.hex`
+
+Of course, replace YOUR_SERIAL_PORT with your serial port's device name, and YOUR_FILENAME.hex with the appropriate filename. For me, this line looks like this:
+
+`avrdude -p atmega32u4 -P /dev/ttyACM0  -c avr109  -U flash:w:Soarer_at2usb_v1.12_atmega32u4.hex`
+
+If it says ''device not in sync'' or similar, your device is no longer in bootloader mode. Unplug it, and get it back into bootloader mode like you did in the previous step (or short the reset pin), and try again.
+If this still doesn't work, try running the command again as root
+
+`sudo avrdude -p atmega32u4 -P /dev/ttyACM0  -c avr109  -U flash:w:Soarer_at2usb_v1.12_atmega32u4.hex`
+
+## Windows
+1. Install the latest version of AVRdude for Windows from http://savannah.nongnu.org/projects/avrdude/  
+Test that it installed correctly by running "avrdude" from Command Prompt. It should display a usage message with version information at the end  
+2. Open Device Manager and take a look at your "Ports (COM & LPT)" section  
+3. Plug in the Gherkin and short the RESET pin on the microcontroller to Ground to put it into bootloader mode. Take note of the new COM device that shows up. After 8 seconds or so the microcontroller will leave bootloader mode and it will disappear from that section  
+4. Open Command Prompt and run the following (substituting "com7" with whatever port you saw earlier)  
+
+`avrdude -p atmega32u4 -P com7  -c avr109  -U flash:w:YOURHEX.hex`

keyboards/gonnerd/keymaps/gam3cat/config.h

@@ -0,0 +1,7 @@
+#include "../../config.h"
+//GRAVE_ESC override for CTRL+SHIFT+ESC Windows task manager shortcut.
+#define GRAVE_ESC_CTRL_OVERRIDE
+#define PREVENT_STUCK_MODIFIERS
+
+//Delay matrix scan for tap dance, reduce to activate modifier keys faster.
+//#define TAPPING_TERM 200

keyboards/gonnerd/keymaps/gam3cat/keymap.c

@@ -0,0 +1,288 @@
+#include "gonnerd.h"
+#include "version.h"
+
+enum layers {
+    _BL = 0,    // Base Layer
+    _WL,        // Workman Layer
+    _NL,        // Norman Layer
+    _DL,        // Dvorak Layer
+    _CL,        // Base Layer
+    _FL,        // Function Layer
+    _AL,        // Adjust Layer
+};
+
+enum gonnerd_keycodes {
+    DYNAMIC_MACRO_RANGE = SAFE_RANGE,
+};
+
+#include "dynamic_macro.h"
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+#define FN_CAPS LT(_FL, KC_CAPS)
+#define KC_DMR1 DYN_REC_START1
+#define KC_DMR2 DYN_REC_START2
+#define KC_DMP1 DYN_MACRO_PLAY1
+#define KC_DMP2 DYN_MACRO_PLAY2
+#define KC_DMRS DYN_REC_STOP
+
+static uint8_t current_layer;
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    /* _BL: Base Layer, mostly standard TKL QWERTY layout.
+    *  .-----------------------------------------------------------------------.
+    *  |Esc||||| F1| F2| F3| F4||| F5| F6| F7| F8||| F9|F10|F11|F12|PSc|SLk|Pau|
+    *  |-----------------------------------------------------------|-----------|
+    *  |  ~|  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|Backsp |Ins|Hom|PgU|
+    *  |-----------------------------------------------------------|-----------|
+    *  |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|    \|Del|End|PgD|
+    *  |-----------------------------------------------------------|-----------|
+    *  |FnCaps|  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '|Return  |           |
+    *  |-----------------------------------------------------------|-----------|
+    *  |Shift   |  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /|Shift     |   | Up|   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |Ctrl |||||Win  |      Space                |RAlt |||||Ctrl |Lft|Dwn|Rgt|
+    *  *-----------------------------------------------------------------------*
+    */
+    [_BL] = KEYMAP_TKL( \
+        KC_ESC,           KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_PSCR, KC_SLCK, KC_PAUS, \
+        KC_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_BSPC, KC_INS,  KC_HOME, 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_DEL,  KC_END,  KC_PGDN, \
+        FN_CAPS, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, XXXXXXX, KC_ENT,                             \
+        KC_LSFT, XXXXXXX, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_RSFT, MO(_FL),          KC_UP,            \
+        KC_LCTL, KC_LALT, KC_LGUI,                            KC_SPC,                             KC_RGUI, KC_RALT, MO(_FL), KC_RCTL, KC_LEFT, KC_DOWN, KC_RGHT \
+    ),
+
+    /* _WL: Workman Layer.
+    *  .-----------------------------------------------------------------------.
+    *  |   |||||   |   |   |   |||   |   |   |   |||   |   |   |   |   |   |   |
+    *  .-----------------------------------------------------------|-----------|
+    *  |   |   |   |   |   |   |   |   |   |   |   |  -|  =|       |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |     |  Q|  D|  R|  W|  B|  J|  F|  U|  P|  ;|  [|  ]|    \|   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |      |  A|  S|  H|  T|  G|  Y|  N|  E|  O|  I|  '|        |           |
+    *  |-----------------------------------------------------------|-----------|
+    *  |        |  Z|  X|  M|  C|  V|  K|  L|  ,|  .|  /|      |   |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |     |||||     |                           |     |||||     |   |   |   |
+    *  *-----------------------------------------------------------------------*
+    */
+    [_WL] = KEYMAP_TKL( \
+        _______,          _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+        _______, KC_Q   , KC_D   , KC_R   , KC_W   , KC_B   , KC_J   , KC_F   , KC_U   , KC_P   , KC_SCLN, _______, _______, _______, _______, _______, _______, \
+        _______, KC_A   , KC_S   , KC_H   , KC_T   , KC_G   , KC_Y   , KC_N   , KC_E   , KC_O   , KC_I   , _______, _______, _______,                            \
+        _______, _______, KC_Z   , KC_X   , KC_M   , KC_C   , KC_V   , KC_K   , KC_L   , KC_COMM, KC_DOT , KC_SLSH, _______, _______,          _______,          \
+        _______, _______, _______,                            _______,                            _______, _______, _______, _______, _______, _______, _______ \
+    ),
+
+    /* _NL: Norman Layer.
+    *  .-----------------------------------------------------------------------.
+    *  |   |||||   |   |   |   |||   |   |   |   |||   |   |   |   |   |   |   |
+    *  .-----------------------------------------------------------|-----------|
+    *  |   |   |   |   |   |   |   |   |   |   |   |  -|  =|       |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |     |  Q|  W|  D|  F|  K|  J|  U|  R|  L|  ;|  [|  ]|    \|   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |      |  A|  S|  E|  T|  G|  Y|  N|  I|  O|  H|  '|        |           |
+    *  |-----------------------------------------------------------|-----------|
+    *  |        |  Z|  X|  C|  V|  B|  P|  M|  ,|  .|  /|      |   |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |     |||||     |                           |     |||||     |   |   |   |
+    *  *-----------------------------------------------------------------------*
+    */
+    [_NL] = KEYMAP_TKL( \
+        _______,          _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+        _______, KC_Q   , KC_W   , KC_D   , KC_F   , KC_K   , KC_J   , KC_U   , KC_R   , KC_L   , KC_SCLN, _______, _______, _______, _______, _______, _______, \
+        _______, KC_A   , KC_S   , KC_E   , KC_T   , KC_G   , KC_Y   , KC_N   , KC_I   , KC_O   , KC_H   , _______, _______, _______,                            \
+        _______, _______, KC_Z   , KC_X   , KC_C   , KC_V   , KC_B   , KC_P   , KC_M   , KC_COMM, KC_DOT , KC_SLSH, _______, _______,          _______,          \
+        _______, _______, _______,                            _______,                            _______, _______, _______, _______, _______, _______, _______ \
+    ),
+
+    /* _DL: Dvorak Layer.
+    *  .-----------------------------------------------------------------------.
+    *  |   |||||   |   |   |   |||   |   |   |   |||   |   |   |   |   |   |   |
+    *  .-----------------------------------------------------------|-----------|
+    *  |   |   |   |   |   |   |   |   |   |   |   |  [|  ]|       |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |     |  '|  ,|  .|  P|  Y|  F|  G|  C|  R|  L|  /|  =|    \|   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |      |  A|  O|  E|  U|  I|  D|  H|  T|  N|  S|  -|        |           |
+    *  |-----------------------------------------------------------|-----------|
+    *  |        |  ;|  Q|  J|  K|  X|  B|  M|  W|  V|  Z|      |   |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |     |||||     |                           |     |||||     |   |   |   |
+    *  *-----------------------------------------------------------------------*
+    */
+    [_DL] = KEYMAP_TKL( \
+        _______,          _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_LBRC, KC_RBRC, _______, _______, _______, _______, \
+        _______, KC_QUOT, KC_COMM, KC_DOT , KC_P   , KC_Y   , KC_F   , KC_G   , KC_C   , KC_R   , KC_L   , KC_SLSH, KC_EQL , _______, _______, _______, _______, \
+        _______, KC_A   , KC_O   , KC_E   , KC_U   , KC_I   , KC_D   , KC_H   , KC_T   , KC_N   , KC_S   , KC_MINS, _______, _______,                            \
+        _______, _______, KC_SCLN, KC_Q   , KC_J   , KC_K   , KC_X   , KC_B   , KC_M   , KC_W   , KC_V   , KC_Z   , _______, _______,          _______,          \
+        _______, _______, _______,                            _______,                            _______, _______, _______, _______, _______, _______, _______ \
+    ),
+
+    /* _CL: Colmak Layer.
+    *  .-----------------------------------------------------------------------.
+    *  |   |||||   |   |   |   |||   |   |   |   |||   |   |   |   |   |   |   |
+    *  .-----------------------------------------------------------|-----------|
+    *  |   |   |   |   |   |   |   |   |   |   |   |  -|  =|       |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |     |  Q|  W|  F|  P|  G|  J|  L|  U|  Y|  ;|  [|  ]|    \|   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |      |  A|  R|  S|  T|  D|  H|  N|  E|  I|  O|  '|        |           |
+    *  |-----------------------------------------------------------|-----------|
+    *  |        |  Z|  X|  C|  V|  B|  K|  M|  ,|  .|  /|      |   |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |     |||||     |                           |     |||||     |   |   |   |
+    *  *-----------------------------------------------------------------------*
+    */
+    [_CL] = KEYMAP_TKL( \
+        _______,          _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+        _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+        _______, KC_Q   , KC_W   , KC_F   , KC_P   , KC_G   , KC_J   , KC_L   , KC_U   , KC_Y   , KC_SCLN, _______, _______, _______, _______, _______, _______, \
+        _______, KC_A   , KC_R   , KC_S   , KC_T   , KC_D   , KC_H   , KC_N   , KC_E   , KC_I   , KC_O   , _______, _______, _______,                            \
+        _______, _______, KC_Z   , KC_X   , KC_C   , KC_V   , KC_B   , KC_K   , KC_M   , KC_COMM, KC_DOT , KC_SLSH, _______, _______,          _______,          \
+        _______, _______, _______,                            _______,                            _______, _______, _______, _______, _______, _______, _______ \
+    ),
+
+    /* _FL: Function Layer.
+    *  M0 opens Chrome
+    *  .-----------------------------------------------------------------------.
+    *  |   |||||   |   |   |   |||   |   |   |   |||   |VlM|VlD|VlU|   |   |   |
+    *  .-----------------------------------------------------------|-----------|
+    *  | M0|   |   |   |   |   |   |   |   |   |   |   |   |       |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |Fn_AL|   |   |   |   |   |   |   |   |   |   |   |   |     |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |FnCaps|   |   |   |   |   |   |Lft|Dwn|Up |Rgt|   |        |           |
+    *  |-----------------------------------------------------------|-----------|
+    *  |        |   |   |   |   |   |   |   |   |   |   |      |   |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |     |||||     |                           |     |||||     |WBk|   |WFw|
+    *  *-----------------------------------------------------------------------*
+    */
+    [_FL] = KEYMAP_TKL( \
+        XXXXXXX,          XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_MUTE, KC_VOLD, KC_VOLU, XXXXXXX, XXXXXXX, XXXXXXX, \
+        M(0),    XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, \
+        MO(_AL), XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, \
+        _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                            \
+        XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______,          XXXXXXX,          \
+        XXXXXXX, XXXXXXX, KC_MENU,                            M(1),                               XXXXXXX, _______, XXXXXXX, XXXXXXX, KC_WBAK, XXXXXXX, KC_WFWD \
+    ),
+
+    /* _AL: Adjust Layer.
+    *  Default keymap, RGB Underglow, LED backlight, and Dynamic Macro settings.
+    *  .-----------------------------------------------------------------------.
+    *  |Rst|||||   |   |   |   |||   |   |   |   |||   |   |   |   |   |   |   |
+    *  .-----------------------------------------------------------|-----------|
+    *  |Ver|Tog|Mod|H- |H+ |S- |S+ |V- |V+ |   |BLT|BL-|BL+|       |   |MR1|MP1|
+    *  |-----------------------------------------------------------|-----------|
+    *  |Fn_AL|_BL|_WL|   |   |   |   |   |   |   |   |   |   |     | MS|MR2|MP2|
+    *  |-----------------------------------------------------------|-----------|
+    *  |FnCaps|   |   |_DL|   |   |   |   |   |   |   |   |        |           |
+    *  |-----------------------------------------------------------|-----------|
+    *  |        |   |   |_CL|   |_BL|_NL|   |   |   |   |      |   |   |   |   |
+    *  |-----------------------------------------------------------|-----------|
+    *  |     |||||     |                           |     |||||     |   |   |   |
+    *  *-----------------------------------------------------------------------*
+    */
+    [_AL] = KEYMAP_TKL( \
+        RESET,            XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, \
+        F(0),    RGB_TOG, RGB_MOD, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, RGB_VAD, RGB_VAI, XXXXXXX, BL_TOGG, BL_DEC,  BL_INC,  XXXXXXX, XXXXXXX, KC_DMR1, KC_DMP1, \
+        _______, DF(_BL), DF(_WL), XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_DMRS, KC_DMR2, KC_DMP2, \
+        _______, XXXXXXX, XXXXXXX, DF(_DL), XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                            \
+        XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, DF(_CL), XXXXXXX, DF(_BL), DF(_NL), XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______,          XXXXXXX,          \
+        _______, XXXXXXX, XXXXXXX,                            XXXXXXX,                            XXXXXXX, _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX \
+    ),
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
+    switch(id) {
+        case 0:
+            if (record->event.pressed) {
+                return MACRO(I(0), D(LGUI), T(R), U(LGUI), END);
+            }
+            else {
+                SEND_STRING("chrome.exe\n");
+                return false;
+            }
+        break;
+        case 1:
+            if (record->event.pressed) {
+                return MACRO(I(0), T(SPC), T(SPC), T(SPC), T(SPC), END);
+            }
+            else {
+                return false;
+            }
+        break;
+    }
+    return MACRO_NONE;
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+    [0] = ACTION_FUNCTION(0),
+};
+
+void action_function(keyrecord_t *record, uint8_t id, uint8_t opt) {
+    switch (id) {
+        case 0:
+            if (record->event.pressed) {
+                SEND_STRING ("[QMK:" QMK_KEYBOARD ":" QMK_KEYMAP ":" QMK_VERSION "]");
+            }
+        break;
+    }
+}
+
+void matrix_init_user(void) {
+    #ifdef BACKLIGHT_ENABLE
+        backlight_level(0);
+    #endif
+}
+
+// Runs constantly in the background, in a loop.
+void matrix_scan_user(void) {
+    uint8_t layer = biton32(layer_state);
+
+    if (current_layer == layer) {
+    }
+    else {
+        current_layer = layer;
+        switch (layer) {
+            case 0:
+                backlight_level(0);
+                break;
+            case 1:
+                backlight_level(1);
+                break;
+            case 2:
+                backlight_level(1);
+                break;
+            case 3:
+                backlight_level(1);
+                break;
+            case 4:
+                backlight_level(1);
+                break;
+            case 5:
+                backlight_level(2);
+                break;
+            case 6:
+                backlight_level(3);
+                break;
+            default:
+                backlight_level(0);
+                break;
+        }
+    }
+}
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+    // Enable Dynamic Macros.
+    if (!process_record_dynamic_macro(keycode, record)) {
+        return false;
+    }
+    return true;
+}

keyboards/gonnerd/keymaps/gam3cat/readme.md

@@ -0,0 +1,120 @@
+# Keymap Maintainer: Gam3cat
+make gonnerd:gam3cat
+## Layout Config:
+2u backspace, 2.25u left shift/enter, 1.75u right shift.
+2x1.5u, 1x7.0u, 2x1.5u, 3x1u bottom row.
+
+    FN_CAPS = MO(_FL) when held, CAPS when tapped.
+    GRAVE_ESC + GUI = `
+    GRAVE_ESC + SHIFT = ~
+
+## Base Layer Selection:
+(Caps+TAB+(  )): (Q)WERTY, (W)orkman, (N)orman, (D)vorak, (C)olmak
+
+### Base Layer Options:
+    _BL: Base Layer, mostly standard TKL QWERTY layout.
+    .-----------------------------------------------------------------------.
+    |Esc||||| F1| F2| F3| F4||| F5| F6| F7| F8||| F9|F10|F11|F12|PSc|SLk|Pau|
+    |-----------------------------------------------------------|-----------|
+    |  ~|  1|  2|  3|  4|  5|  6|  7|  8|  9|  0|  -|  =|Backsp |Ins|Hom|PgU|
+    |-----------------------------------------------------------|-----------|
+    |Tab  |  Q|  W|  E|  R|  T|  Y|  U|  I|  O|  P|  [|  ]|    \|Del|End|PgD|
+    |-----------------------------------------------------------|-----------|
+    |FnCaps|  A|  S|  D|  F|  G|  H|  J|  K|  L|  ;|  '|Return  |           |
+    |-----------------------------------------------------------|-----------|
+    |Shift   |  Z|  X|  C|  V|  B|  N|  M|  ,|  .|  /|Shift     |   | Up|   |
+    |-----------------------------------------------------------|-----------|
+    |Ctrl |||||Win  |      Space                |RAlt |||||Ctrl |Lft|Dwn|Rgt|
+    *-----------------------------------------------------------------------*
+    
+    _WL: Workman Layer.
+    .-----------------------------------------------------------------------.
+    |   |||||   |   |   |   |||   |   |   |   |||   |   |   |   |   |   |   |
+    .-----------------------------------------------------------|-----------|
+    |   |   |   |   |   |   |   |   |   |   |   |  -|  =|       |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |     |  Q|  D|  R|  W|  B|  J|  F|  U|  P|  ;|  [|  ]|    \|   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |      |  A|  S|  H|  T|  G|  Y|  N|  E|  O|  I|  '|        |           |
+    |-----------------------------------------------------------|-----------|
+    |        |  Z|  X|  M|  C|  V|  K|  L|  ,|  .|  /|      |   |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |     |||||     |                           |     |||||     |   |   |   |
+    *-----------------------------------------------------------------------*
+    
+    _NL: Norman Layer.
+    .-----------------------------------------------------------------------.
+    |   |||||   |   |   |   |||   |   |   |   |||   |   |   |   |   |   |   |
+    .-----------------------------------------------------------|-----------|
+    |   |   |   |   |   |   |   |   |   |   |   |  -|  =|       |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |     |  Q|  W|  D|  F|  K|  J|  U|  R|  L|  ;|  [|  ]|    \|   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |      |  A|  S|  E|  T|  G|  Y|  N|  I|  O|  H|  '|        |           |
+    |-----------------------------------------------------------|-----------|
+    |        |  Z|  X|  C|  V|  B|  P|  M|  ,|  .|  /|      |   |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |     |||||     |                           |     |||||     |   |   |   |
+    *-----------------------------------------------------------------------*
+    
+    _DL: Dvorak Layer.
+    .-----------------------------------------------------------------------.
+    |   |||||   |   |   |   |||   |   |   |   |||   |   |   |   |   |   |   |
+    .-----------------------------------------------------------|-----------|
+    |   |   |   |   |   |   |   |   |   |   |   |  [|  ]|       |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |     |  '|  ,|  .|  P|  Y|  F|  G|  C|  R|  L|  /|  =|    \|   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |      |  A|  O|  E|  U|  I|  D|  H|  T|  N|  S|  -|        |           |
+    |-----------------------------------------------------------|-----------|
+    |        |  ;|  Q|  J|  K|  X|  B|  M|  W|  V|  Z|      |   |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |     |||||     |                           |     |||||     |   |   |   |
+    *-----------------------------------------------------------------------*
+    
+    _CL: Colmak Layer.
+    .-----------------------------------------------------------------------.
+    |   |||||   |   |   |   |||   |   |   |   |||   |   |   |   |   |   |   |
+    .-----------------------------------------------------------|-----------|
+    |   |   |   |   |   |   |   |   |   |   |   |  -|  =|       |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |     |  Q|  W|  F|  P|  G|  J|  L|  U|  Y|  ;|  [|  ]|    \|   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |      |  A|  R|  S|  T|  D|  H|  N|  E|  I|  O|  '|        |           |
+    |-----------------------------------------------------------|-----------|
+    |        |  Z|  X|  C|  V|  B|  K|  M|  ,|  .|  /|      |   |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |     |||||     |                           |     |||||     |   |   |   |
+    *-----------------------------------------------------------------------*
+    
+    _FL: Function Layer.
+    M0 opens Chrome
+    .-----------------------------------------------------------------------.
+    |   |||||   |   |   |   |||   |   |   |   |||   |VlM|VlD|VlU|   |   |   |
+    .-----------------------------------------------------------|-----------|
+    | M0|   |   |   |   |   |   |   |   |   |   |   |   |       |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |     |   |   |   |   |   |   |   |   |   |   |   |   |     |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |      |   |   |   |   |   |   |Lft|Dwn|Up |Rgt|   |        |           |
+    |-----------------------------------------------------------|-----------|
+    |        |   |   |   |   |   |   |   |   |   |   |      |   |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |     |||||     |                           |     |||||     |WBk|   |WFw|
+    *-----------------------------------------------------------------------*
+    
+    _AL: Adjust Layer.
+    Default keymap, RGB Underglow, LED backlight, and Dynamic Macro settings.
+    .-----------------------------------------------------------------------.
+    |Rst|||||   |   |   |   |||   |   |   |   |||   |   |   |   |   |   |   |
+    .-----------------------------------------------------------|-----------|
+    |Ver|Tog|Mod|H- |H+ |S- |S+ |V- |V+ |   |BLT|BL-|BL+|       |   |MR1|MP1|
+    |-----------------------------------------------------------|-----------|
+    |Fn_AL|_BL|_WL|   |   |   |   |   |   |   |   |   |   |     | MS|MR2|MP2|
+    |-----------------------------------------------------------|-----------|
+    |FnCaps|   |   |_DL|   |   |   |   |   |   |   |   |        |           |
+    |-----------------------------------------------------------|-----------|
+    |        |   |   |_CL|   |_BL|_NL|   |   |   |   |      |   |   |   |   |
+    |-----------------------------------------------------------|-----------|
+    |     |||||     |                           |     |||||     |   |   |   |
+    *-----------------------------------------------------------------------*

keyboards/gonnerd/keymaps/gam3cat/rules.mk

@@ -0,0 +1,21 @@
+# Build Options
+#   change to "no" to disable the options, or define them in the Makefile in
+#   the appropriate keymap folder that will get included automatically
+#
+BOOTMAGIC_ENABLE = no       # Virtual DIP switch configuration(+1000)
+MOUSEKEY_ENABLE = yes       # Mouse keys(+4700)
+EXTRAKEY_ENABLE = yes       # Audio control and System control(+450)
+CONSOLE_ENABLE = yes        # Console for debug(+400)
+COMMAND_ENABLE = yes        # Commands for debug and configuration
+NKRO_ENABLE = yes           # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
+BACKLIGHT_ENABLE = yes       # Enable keyboard backlight functionality
+MIDI_ENABLE = no            # MIDI controls
+AUDIO_ENABLE = no           # Audio output on port C6
+UNICODE_ENABLE = no         # Unicode
+BLUETOOTH_ENABLE = no       # Enable Bluetooth with the Adafruit EZ-Key HID
+RGBLIGHT_ENABLE = no        # Enable WS2812 RGB underlight.  Do not enable this with audio at the same time.
+SLEEP_LED_ENABLE = no       # Breathing sleep LED during USB suspend
+
+ifndef QUANTUM_DIR
+	include ../../../../Makefile
+endif

keyboards/handwired/CMD60/README.md

@@ -10,7 +10,7 @@ achieve a higher level of productivity if you take the time to learn its functio
 
 ## Quantum MK Firmware
 
-For the full Quantum feature list, see [the parent readme.md](/doc/readme.md).
+For the full Quantum feature list, see [the parent readme.md](/docs/README.md).
 
 ## Building
 

keyboards/handwired/fivethirteen/README.md

@@ -3,7 +3,7 @@ fivethirteen keyboard firmware
 
 ## Quantum MK Firmware
 
-For the full Quantum feature list, see [the parent readme.md](/doc/readme.md).
+For the full Quantum feature list, see [the parent readme.md](/doc/README.md).
 
 ## Building
 

keyboards/handwired/gamenum/README.md

@@ -76,7 +76,7 @@ This is the code for the KC_FN1 button. Notice how we check against what key is
 
 ## Quantum MK Firmware
 
-For the full Quantum feature list, see [the parent readme.md](/doc/readme.md).
+For the full Quantum feature list, see [the parent readme.md](/docs/README.md).
 
 ## Building