do a little cleanup

Updates some remaining doc stuff

book.json

@@ -3,12 +3,9 @@
         "summary": "_summary.md"
     },
     "plugins" : [
-      "anchors",
       "edit-link",
       "forkmegithub",
-      "git-author",
       "hints",
-      "numbered-headings",
       "page-toc",
       "terminal",
       "toolbar"
@@ -25,6 +22,11 @@
       "page-toc": {
         "selector": ".markdown-section h1, .markdown-section h2"
       },
+      "terminal": {
+        "copyButtons": true,
+        "fade": false,
+        "style": "flat"
+      },
       "toolbar": {
         "buttons": [
           {

docs/basic_keycodes.md

@@ -51,9 +51,9 @@
 |KC_RSHIFT|KC_RSFT|RightShift|
 |KC_RALT||RightAlt|
 |KC_RGUI||Right GUI(Windows/Apple/Meta key)|
-|KC_LOCKING_CAPS||Locking Caps Lock|
-|KC_LOCKING_NUM||Locking Num Lock|
-|KC_LOCKING_SCROLL||Locking Scroll Lock|
+|KC_LOCKING_CAPS|KC_LCAP|Locking Caps Lock|
+|KC_LOCKING_NUM|KC_LNUM|Locking Num Lock|
+|KC_LOCKING_SCROLL|KC_LSCR|Locking Scroll Lock|
 |KC_INT4|KC_HENK|JIS Henken|
 |KC_INT5|KC_MHEN|JIS Muhenken|
 

docs/custom_quantum_functions.md

@@ -36,16 +36,16 @@ enum my_keycodes {
 
 ## Programming The Behavior Of Any Keycode
 
-When you want to override the behavior of an existing key, or define the behavior for a new key, you should use the `process_keyboard()` and `process_user()` functions. These are called by QMK during key processing before the actual key event is handled. If these functions return `true` QMK will process the keycodes as usual. That can be handy for extending the functionality of a key rather than replacing it. If these functions return `false` QMK will skip the normal key handling, and it will be up you to send any key up or down events that are required.
+When you want to override the behavior of an existing key, or define the behavior for a new key, you should use the `process_record_kb()` and `process_record_user()` functions. These are called by QMK during key processing before the actual key event is handled. If these functions return `true` QMK will process the keycodes as usual. That can be handy for extending the functionality of a key rather than replacing it. If these functions return `false` QMK will skip the normal key handling, and it will be up you to send any key up or down events that are required.
 
 These function are called every time a key is pressed or released.
 
-### Example `process_user()` implementation
+### Example `process_record_user()` implementation
 
 This example does two things. It defines the behavior for a custom keycode called `FOO`, and it supplements our Enter key by playing a tone whenever it is pressed.
 
 ```
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case FOO:
       if (record->event.pressed) {
@@ -53,21 +53,21 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
       } else {
         // Do something else when release
       }
-      return STOP_PROCESSING; // Skip all further processing of this key
+      return false; // Skip all further processing of this key
     case KC_ENTER:
       // Play a tone when enter is pressed
       if (record->event.pressed) {
         PLAY_NOTE_ARRAY(tone_qwerty);
       }
-      return CONTINUE_PROCESSING; // Let QMK send the enter press/release events
+      return true; // Let QMK send the enter press/release events
   }
 }
 ```
 
 ### `process_record_*` Function documentation
 
-* Keyboard/Revision: `level_t process_kb(uint16_t keycode, keyrecord_t *record)` 
-* Keymap: `level_t process_user(uint16_t keycode, keyrecord_t *record)`
+* Keyboard/Revision: `bool process_record_kb(uint16_t keycode, keyrecord_t *record)` 
+* Keymap: `bool process_record_user(uint16_t keycode, keyrecord_t *record)`
 
 The `keycode` argument is whatever is defined in your keymap, eg `MO(1)`, `KC_L`, etc. You should use a `switch...case` block to handle these events.
 

docs/documentation_best_practices.md

@@ -22,6 +22,14 @@ Your page should generally have multiple "H1" headings. Only H1 and H2 headings
 
 You can have styled hint blocks drawn around text to draw attention to it.
 
+```
+{% hint style='info' %}
+This uses `hint style='info'`
+{% endhint %}
+```
+
+### Examples:
+
 {% hint style='info' %}
 This uses `hint style='info'`
 {% endhint %}
@@ -37,3 +45,33 @@ This uses `hint style='danger'`
 {% hint style='working' %}
 This uses `hint style='working'`
 {% endhint %}
+
+# Styled Terminal Blocks
+
+You can present styled terminal blocks by including special tokens inside your text block.
+
+```
+\`\`\`
+**[terminal]
+**[prompt foo@joe]**[path ~]**[delimiter  $ ]**[command ./myscript]
+Normal output line. Nothing special here...
+But...
+You can add some colors. What about a warning message?
+**[warning [WARNING] The color depends on the theme. Could look normal too]
+What about an error message?
+**[error [ERROR] This is not the error you are looking for]
+\`\`\`
+```
+
+### Example
+
+```
+**[terminal]
+**[prompt foo@joe]**[path ~]**[delimiter  $ ]**[command ./myscript]
+Normal output line. Nothing special here...
+But...
+You can add some colors. What about a warning message?
+**[warning [WARNING] The color depends on the theme. Could look normal too]
+What about an error message?
+**[error [ERROR] This is not the error you are looking for]
+```

docs/faq.md

@@ -1,10 +1,16 @@
 # Frequently Asked Questions
 
-## What is QMK?
+## General
+
+### What is QMK?
 
 [QMK](https://github.com/qmk), short for Quantum Mechanical Keyboard, is a group of people building tools for custom keyboards. We started with the [QMK firmware](https://github.com/qmk/qmk_firmware), a heavily modified fork of [TMK](https://github.com/tmk/tmk_keyboard).
 
-## What Differences Are There Between QMK and TMK?
+### Why the name Quantum?
+
+<!-- FIXME -->
+
+### What Differences Are There Between QMK and TMK?
 
 TMK was originally designed and implemented by [Jun Wako](https://github.com/tmk). QMK started as [Jack Humbert's](https://github.com/jackhumbert) fork of TMK for the Planck. After a while Jack's fork had diverged quite a bit from TMK, and in 2015 Jack decided to rename his fork to QMK.
 
@@ -14,8 +20,22 @@ From a project and community management standpoint TMK maintains all the officia
 
 Both approaches have their merits and their drawbacks, and code flows freely between TMK and QMK when it makes sense.
 
-# Debug Console
-## hid_listen can't recognize device
+# Building
+
+## Windows
+
+### I'm on Windows Vista, 7, or 8, how do I setup my build environment?
+
+Follow the build instructions to [install MHV AVR Tools](https://docs.qmk.fm/build_environment_setup.html#windows-vista-and-later).
+
+### I'm on Windows 10 without the Creators Update. Do I have to install it?
+
+No, but if you don't install the creators update you will not be able to build and flash with a single command. You will be able to build but to flash you will have to use a separate program, such as [QMK Flasher](https://github.com/qmk/qmk_flasher).
+
+# Troubleshooting
+
+## Debug Console
+### hid_listen can't recognize device
 When debug console of your device is not ready you will see like this:
 
 ```
@@ -34,7 +54,7 @@ If you can't get this 'Listening:' message try building with `CONSOLE_ENABLE=yes
 You may need privilege to access the device on OS like Linux.
 - try `sudo hid_listen`
 
-## Can't get message on console
+### Can't get message on console
 Check:
 - *hid_listen* finds your device. See above.
 - Enable debug with pressing **Magic**+d. See [Magic Commands](https://github.com/tmk/tmk_keyboard#magic-commands).
@@ -42,7 +62,7 @@ Check:
 - try using 'print' function instead of debug print. See **common/print.h**.
 - disconnect other devices with console function. See [Issue #97](https://github.com/tmk/tmk_keyboard/issues/97).
 
-## Linux or UNIX like system requires Super User privilege
+### Linux or UNIX like system requires Super User privilege
 Just use 'sudo' to execute *hid_listen* with privilege.
 ```
 $ sudo hid_listen
@@ -56,10 +76,9 @@ File: /etc/udev/rules.d/52-tmk-keyboard.rules(in case of Ubuntu)
 SUBSYSTEMS=="usb", ATTRS{idVendor}=="feed", MODE:="0666"
 ```
 
-***
+## Software Issues
 
-# Miscellaneous
-## NKRO Doesn't work
+### NKRO Doesn't work
 First you have to compile frimware with this build option `NKRO_ENABLE` in **Makefile**.
 
 Try `Magic` **N** command(`LShift+RShift+N` by default) when **NKRO** still doesn't work. You can use this command to toggle between **NKRO** and **6KRO** mode temporarily. In some situations **NKRO** doesn't work you need to switch to **6KRO** mode, in particular when you are in BIOS.
@@ -68,15 +87,7 @@ If your firmeare built with `BOOTMAGIC_ENABLE` you need to turn its switch on by
 
 https://github.com/tmk/tmk_keyboard#boot-magic-configuration---virtual-dip-switch
 
-
-## TrackPoint needs reset circuit(PS/2 mouse support)
-Without reset circuit you will have inconsistent reuslt due to improper initialize of the hardware. See circuit schematic of TPM754.
-
-- http://geekhack.org/index.php?topic=50176.msg1127447#msg1127447
-- http://www.mikrocontroller.net/attachment/52583/tpm754.pdf
-
-
-## Can't read column of matrix beyond 16 
+### Can't read column of matrix beyond 16
 Use `1UL<<16` instead of `1<<16` in `read_cols()` in [matrix.h] when your columns goes beyond 16.
 
 In C `1` means one of [int] type which is [16bit] in case of AVR so you can't shift left more than 15. You will get unexpected zero when you say `1<<16`. You have to use [unsigned long] type with `1UL`.
@@ -84,7 +95,7 @@ In C `1` means one of [int] type which is [16bit] in case of AVR so you can't sh
 http://deskthority.net/workshop-f7/rebuilding-and-redesigning-a-classic-thinkpad-keyboard-t6181-60.html#p146279
 
 
-## Bootloader jump doesn't work
+### Bootloader jump doesn't work
 Properly configure bootloader size in **Makefile**. With wrong section size bootloader won't probably start with **Magic command** and **Boot Magic**.
 ```
 # Size of Bootloaders in bytes:
@@ -132,20 +143,28 @@ And see this discussion for further reference.
 https://github.com/tmk/tmk_keyboard/issues/179
 
 
-## Special Extra key doesn't work(System, Audio control keys)
+### Special Extra key doesn't work(System, Audio control keys)
 You need to define `EXTRAKEY_ENABLE` in `rules.mk` to use them in QMK.
 
 ```
 EXTRAKEY_ENABLE = yes          # Audio control and System control
 ```
 
-## Wakeup from sleep doesn't work
+### Wakeup from sleep doesn't work
 
 In Windows check `Allow this device to wake the computer` setting in Power **Management property** tab of **Device Manager**. Also check BIOS setting.
 
 Pressing any key during sleep should wake host.
 
-## Using Arduino?
+## Hardware Issues
+
+### TrackPoint needs reset circuit(PS/2 mouse support)
+Without reset circuit you will have inconsistent reuslt due to improper initialize of the hardware. See circuit schematic of TPM754.
+
+- http://geekhack.org/index.php?topic=50176.msg1127447#msg1127447
+- http://www.mikrocontroller.net/attachment/52583/tpm754.pdf
+
+### Using Arduino?
 
 **Note that Arduino pin naming is different from actual chip.** For example, Arduino pin `D0` is not `PD0`. Check circuit with its schematics yourself.
 
@@ -154,8 +173,7 @@ Pressing any key during sleep should wake host.
 
 Arduino leonardo and micro have **ATMega32U4** and can be used for TMK, though Arduino bootloader may be a problem.
 
-
-## Using PF4-7 pins of USB AVR?
+### Using PF4-7 pins of USB AVR?
 You need to set JTD bit of MCUCR yourself to use PF4-7 as GPIO. Those pins are configured to serve JTAG function by default. MCUs like ATMega*U* or AT90USB* are affeteced with this.
 
 If you are using Teensy this isn't needed. Teensy is shipped with JTAGEN fuse bit unprogrammed to disable the function.
@@ -171,12 +189,7 @@ https://github.com/tmk/tmk_keyboard/blob/master/keyboard/hbkb/matrix.c#L67
 And read **26.5.1 MCU Control Register – MCUCR** of ATMega32U4 datasheet.
 
 
-## Adding LED indicators of Lock keys
-You need your own LED indicators for CapsLock, ScrollLock and NumLock? See this post.
-
-http://deskthority.net/workshop-f7/tmk-keyboard-firmware-collection-t4478-120.html#p191560
-
-## Program Arduino Micro/Leonardo
+### Program Arduino Micro/Leonardo
 Push reset button and then run command like this within 8 seconds.
 
 ```
@@ -188,17 +201,7 @@ Device name will vary depending on your system.
 http://arduino.cc/en/Main/ArduinoBoardMicro
 https://geekhack.org/index.php?topic=14290.msg1563867#msg1563867
 
-
-## USB 3 compatibility
-I heard some people have a problem with USB 3 port, try USB 2 port.
-
-
-## Mac compatibility
-### OS X 10.11 and Hub
-https://geekhack.org/index.php?topic=14290.msg1884034#msg1884034
-
-
-## Problem on BIOS(UEFI)/Resume(Sleep&Wake)/Power cycles
+### Problem on BIOS(UEFI)/Resume(Sleep&Wake)/Power cycles
 Some people reported their keyboard stops working on BIOS and/or after resume(power cycles).
 
 As of now root of its cause is not clear but some build options seem to be related. In Makefile try to disable those options like `CONSOLE_ENABLE`, `NKRO_ENABLE`, `SLEEP_LED_ENABLE` and/or others.
@@ -206,9 +209,8 @@ As of now root of its cause is not clear but some build options seem to be relat
 https://github.com/tmk/tmk_keyboard/issues/266
 https://geekhack.org/index.php?topic=41989.msg1967778#msg1967778
 
+## Flashing Problems
 
+### Can't use dfu-programmer or QMK Flasher to flash on Windows
 
-## FLIP doesn't work
-### AtLibUsbDfu.dll not found
-Remove current driver and reinstall one FLIP provides from DeviceManager.
-http://imgur.com/a/bnwzy
+Windows requires a driver to support the keyboard in DFU mode. You can use [QMK Driver Installer](https://github.com/qmk/qmk_driver_installer/releases) to install the necessary drivers.

docs/glossary.md

@@ -1,29 +1,170 @@
 # Glossary of QMK terms
 
+## ARM
+A line of 32-bit MCU's produced by a number of companies, such as Atmel, Cypress, Kinetis, NXP, ST, and TI.
+
+## AVR
+A line of 8-bit MCU's produced by [Atmel](http://atmel.com). AVR was the original platform that TMK supported.
+
+## AZERTY
+The standard Français (French) keyboard layout. Named for the first 6 keys on the keyboard.
+
+## Backlight
+A generic term for lighting on a keyboard. The backlight is typically, but not always, an array of LED's that shine through keycaps and/or switches.
+
+## Bluetooth
+A short range peer to peer wireless protocol. Most common wireless protocol for a keyboard.
+
+## Bootloader
+A special program that is written to a protected area of your MCU that allows the MCU to upgrade its own firmware, typically over USB.
+
+## Bootmagic
+A feature that allows for various keyboard behavior changes to happen on the fly, such as swapping or disabling common keys.
+
+## C
+A low-level programming language suitable for system code. Most QMK code is written in C.
+
+## Colemak
+An alternative keyboard layout that is gaining in popularity.
+
+## Compile
+The process of turning human readable code into machine code your MCU can run.
+
+## Dvorak
+An alternative keyboard layout developed by Dr. August Dvorak in the 1930's. A shortened form of the Dvorak Simplified Keyboard.
+
 ## Dynamic Macro
 A macro which has been recorded on the keyboard and which will be lost when the keyboard is unplugged or the computer rebooted.
 
+* [Dynamic Macro Documentation](dynamic_macros.html)
+
+## Eclipse
+An IDE that is popular with many C developers.
+
+* [Eclipse Setup Instructions](eclipse.html)
+
+## Firmware
+The software that controls your MCU.
+
+## FLIP
+Software provided by Atmel for flashing AVR devices. We generally recommend [QMK Flasher](https://github.com/qmk/qmk_flasher) instead, but for some advanced use cases FLIP is required.
+
 ## git
 Versioning software used at the commandline
 
+## GitHub
+The website that hosts most of the QMK project. It provides integration with git, issue tracking, and other features that help us run QMK.
+
+## ISP
+In-system programming, a method of programming an AVR chip using external hardware and the JTAG pins.
+
+## hid_listen
+An interface for receiving debugging messages from your keyboard. You can view these messages using [QMK Flasher](https://github.com/qmk/qmk_flasher) or [PJRC's hid_listen](https://www.pjrc.com/teensy/hid_listen.html)
+
 ## Keycode
 A 2-byte number that represents a particular key. `0x00`-`0xFF` are used for [Basic Keycodes](keycodes.html) while `0x100`-`0xFFFF` are used for [Quantum Keycodes](quantum_keycodes.html).
 
+## Key Down
+An event that happens when a key is pressed down, but is completed before a key is released.
+
+## Key Up
+An event that happens when a key is released.
+
 ## Keymap
 An array of keycodes mapped to a physical keyboard layout, which are processed on key presses and releases
 
+## Layer
+An abstraction used to allow a key to serve multiple purposes. The highest active layer takes precedence.
+
+## Leader Key
+A feature that allows you to tap the leader key followed by a sequence of 1, 2, or 3 keys to activate key presses or other quantum features.
+
+* [Leader Key Documentation](leader_key.html)
+
+## LED
+Light Emitting Diode, the most common device used for indicators on a keyboard.
+
+## Make
+Software package that is used to compile all the source files. You run `make` with various options to compile your keyboard firmware.
+
 ## Matrix
-A wiring pattern of columns and rows (and usually diodes) that enables the MCU to detect keypresses with a fewer number of pins
+A wiring pattern of columns and rows that enables the MCU to detect keypresses with a fewer number of pins. The matrix often incorporates diodes to allow for NKRO.
 
 ## Macro
 A feature that lets you send muiltple keypress events (hid reports) after having pressed only a single key.
 
+* [Macro Documentation](macros.html)
+
+## MCU
+Microcontrol Unit, the processor that powers your keyboard.
+
+## Modifier
+A key that is held down while typing another key to modify the action of that key. Examples include Ctrl, Alt, and Shift.
+
 ## Mousekeys
 A feature that lets you control your mouse cursor and click from your keyboard.
 
 * [Mousekeys Documentation](mouse_keys.html)
 
+## N-Key Rollover (NKRO)
+A term that applies to keyboards that are capable of reporting any number of key-presses at once.
+
+## Oneshot Modifier
+A modifier that acts as if it is held down until another key is released, so you can press the mod and then press the key, rather than holding the mod while pressing the key.
+
+## ProMicro
+A low cost AVR development board. Clones of this device are often found on ebay very inexpensively (under $5) but people often struggle with flashing their pro micros.
+
+## Pull Request
+A request to submit code to QMK. We encourage all users to submit Pull Requests for their personal keymaps.
+
+## QWERTY
+The standard English keyboard layout, and often a shortcut for other language's standard layouts. Named for the first 6 letters on the keyboard.
+
+## QWERTZ
+The standard Deutsche (German) keyboard layout. Named for the first 6 letters on the keyboard.
+
+## Rollover
+The term for pressing a key while a key is already held down. Variants include 2KRO, 6KRO, and NKRO.
+
+## Scancode
+A 1 byte number that is sent as part of a HID report over USB that represents a single key. These numbers are documented in the [HID Usage Tables](http://www.usb.org/developers/hidpage/Hut1_12v2.pdf) published by the [USB-IF](http://www.usb.org/).
+
+## Space Cadet Shift
+A special set of shift keys which allow you to type various types of braces by tapping the left or right shift one or more times.
+
+* [Space Cadet Shift Documentation](space_cadet_shift.html)
+
+## Tap
+Pressing and releasing a key. In some situations you will need to distinguish between a key down and a key up event, and Tap always refers to both at once.
+
 ## Tap Dance
 A feature that lets you assign muiltple keycodes to the same key based on how many times you press it.
 
 * [Tap Dance Documentation](tap_dance.html)
+
+## Teensy
+A low-cost AVR development board that is commonly used for hand-wired builds. A teensy is often chosen despite costing a few dollors more due to its halfkay bootloader, which makes flashing very simple.
+
+## Underlight
+A generic term for LEDs that light the underside of the board. These LED's typically shine away from the bottom of the PCB and towards the surface the keyboard rests on.
+
+## Unicode
+In the larger computer world Unicode is a set of encoding schemes for representing characters in any language. As it relates to QMK it means using various OS schemes to send unicode codepoints instead of scancodes.
+
+* [Unicode Documentation](unicode.html)
+
+## Unit Testing
+A framework for running automated tests against QMK. Unit testing helps us be confident that our changes do not break anything.
+
+* [Unit Testing Documentation](unit_testing.html)
+
+## USB
+Universal Serial Bus, the most common wired interface for a keyboard.
+
+## USB Host (or simply Host)
+The USB Host is your computer, or whatever device your keyboard is plugged into.
+
+# Couldn't find the term you're looking for?
+
+[Open an issue](https://github.com/qmk/qmk_firmware/issues) with your question and the term in question could be added here. Better still, open a pull request with the definition. :)  

docs/porting_your_keyboard_to_qmk.md

@@ -20,7 +20,7 @@ For the `DIODE_DIRECTION`, most hand-wiring guides will instruct you to wire the
 
 `BACKLIGHT_LEVELS` is how many levels exist for your backlight - max is 15, and they are computed automatically from this number.
 
-## `/keyboards/<keyboard>/Makefile`
+## `/keyboards/<keyboard>/rules.mk`
 
 The values at the top likely won't need to be changed, since most boards use the `atmega32u4` chip. The `BOOTLOADER_SIZE` will need to be adjusted based on your MCU type. It's defaulted to the Teensy, since that's the most common controller. Below is quoted from the `Makefile`.
 

docs/quantum_keycodes.md

@@ -337,10 +337,10 @@ enum my_keycodes {
 };
 ```
 
-You can then use `process_user()` to do something with your keycode:
+You can then use `process_record_user()` to do something with your keycode:
 
 ```
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case FOO:
       // Do something here

docs/understanding_qmk.md

@@ -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)
-    * [`level_t process_kb(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/keyboards/cluecard/cluecard.c#L20)
-      * [`level_t process_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/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_midi(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_midi.c#L102)
     * [`bool process_audio(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_audio.c#L10)
     * [`bool process_music(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_music.c#L69)
@@ -150,7 +150,7 @@ The `process_record()` function itself is deceptively simple, but hidden within
     * [`bool process_unicode_map(uint16_t keycode, keyrecord_t *record)`](https://github.com/qmk/qmk_firmware/blob/master/quantum/process_keycode/process_unicodemap.c#L47)
     * [Identify and process quantum specific keycodes](https://github.com/qmk/qmk_firmware/blob/master/quantum/quantum.c#L211)
   
-At any step during this chain of events a function (such as `process_kb()`) can `return false` to halt all further processing.
+At any step during this chain of events a function (such as `process_record_kb()`) can `return false` to halt all further processing.
 
 <!--
 #### Mouse Handling

keyboards/amj40/Makefile

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

keyboards/amj40/amj40.c

@@ -0,0 +1,30 @@
+#include "amj40.h"
+#include "led.h"
+
+void matrix_init_kb(void) {
+	// put your keyboard start-up code here
+	// runs once when the firmware starts up
+	matrix_init_user();
+	led_init_ports();
+};
+
+void matrix_scan_kb(void) {
+	// put your looping keyboard code here
+	// runs every cycle (a lot)
+	matrix_scan_user();
+};
+
+void led_init_ports(void) {
+    // * Set our LED pins as output
+    DDRB |= (1<<2);
+}
+
+void led_set_kb(uint8_t usb_led) {
+    if (usb_led & (1<<USB_LED_CAPS_LOCK)) {
+        // Turn capslock on
+        PORTB &= ~(1<<2);
+    } else {
+        // Turn capslock off
+        PORTB |= (1<<2);
+    }
+}

keyboards/amj40/amj40.h

@@ -0,0 +1,38 @@
+#ifndef AMJ40_H
+#define AMJ40_H
+
+#include "quantum.h"
+
+// readability  
+#define XXX KC_NO
+
+/* AMJ40 ver2.0 layout1 配列一
+ * ,-----------------------------------------------------------.
+ * | 00 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 0A | 0B |
+ * |-----------------------------------------------------------|
+ * | 10   | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 1B    |
+ * |-----------------------------------------------------------|
+ * | 20     | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 |  2A | 2B |
+ * |-----------------------------------------------------------|
+ * | 30  | 31 | 32  |   34      |  35         | 39  | 3A | 3B  |
+ * `-----------------------------------------------------------'
+ */
+#define KEYMAP( \
+    k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, \
+    k10, k11, k12, k13, k14, k15, k16, k17, k18, k19,      k1b,  \
+    k20,      k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b,  \
+    k30, k31, k32,      k34, k35,                k39, k3a, k3b  \
+) { \
+    {k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b}, \
+    {k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, XXX, k1b}, \
+    {k20, XXX, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b}, \
+    {k30, k31, k32, XXX, k34, k35, XXX, XXX, XXX, k39, k3a, k3b} \
+}
+
+
+
+
+void matrix_init_user(void);
+void matrix_scan_user(void);
+
+#endif

keyboards/amj40/config.h

@@ -0,0 +1,94 @@
+/*
+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      0x6072
+#define DEVICE_VER      0x0002
+#define MANUFACTURER    Han Chen
+#define PRODUCT         AMJ40
+#define DESCRIPTION     qmk port of AMJ40 v2 PCB
+
+/* key matrix size */
+#define MATRIX_ROWS 4
+#define MATRIX_COLS 12
+
+// ROWS: Top to bottom, COLS: Left to right
+
+#define MATRIX_ROW_PINS { F4, F5, F6, F7}
+#define MATRIX_COL_PINS { F1, F0, E6, C7, C6, B0, D4, B1, B7, B5, B4, D7}
+#define UNUSED_PINS
+
+#define BACKLIGHT_PIN B6
+
+/* COL2ROW or ROW2COL */
+#define DIODE_DIRECTION COL2ROW
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* 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)) \
+)
+
+/* Backlight configuration
+ */
+#define BACKLIGHT_LEVELS 4
+
+/* Underlight configuration
+ */
+
+#define RGB_DI_PIN D3
+#define RGBLIGHT_ANIMATIONS
+#define RGBLED_NUM 4     // Number of LEDs
+#define RGBLIGHT_HUE_STEP 10
+#define RGBLIGHT_SAT_STEP 17
+#define RGBLIGHT_VAL_STEP 17
+
+/*
+ * 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/amj40/keymaps/default/Makefile

@@ -0,0 +1,27 @@
+# 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  = no  # Mouse keys(+4700)
+EXTRAKEY_ENABLE  = yes # Audio control and System control(+450)
+CONSOLE_ENABLE   = no  # Console for debug(+400)
+COMMAND_ENABLE   = yes # Commands for debug and configuration
+NKRO_ENABLE      = 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  = yes  # Enable WS2812 RGB underlight.  Do not enable this with audio at the same time.
+
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
+
+#define ws2812_PORTREG  PORTD
+#define ws2812_DDRREG   DDRD
+
+
+ifndef QUANTUM_DIR
+	include ../../../../Makefile
+endif

keyboards/amj40/keymaps/default/build.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# adjust for cpu 
+# -j 16 gave best result on a hyperthreaded quad core core i7
+
+LIMIT=10
+THREADS="-j 16"
+KMAP=iso_split_rshift
+
+echo "We need sudo later"
+sudo ls 2>&1 /dev/null
+
+function wait_bootloader {
+	echo "Waiting for Bootloader..."
+	local STARTTIME=$(date +"%s")
+	local REMIND=0
+    local EXEC=dfu-programmer
+    local TARGET=atmega32u4
+	while true
+	do
+		sudo $EXEC $TARGET get > /dev/null 2>&1
+		[ $? -eq 0 ] && break
+		ENDTIME=$(date +"%s")
+		DURATION=$(($ENDTIME-$STARTTIME))
+		if [ $REMIND -eq 0 -a $DURATION -gt $LIMIT ]
+		then 
+			echo "Did you forget to press the reset button?"
+			REMIND=1
+		fi
+        sleep 1
+	done
+}
+make clean
+make KEYMAP=${KMAP} ${THREADS}
+if [[ $? -eq 0 ]]
+then
+    echo "please trigger flashing!"
+    wait_bootloader
+    sudo make KEYMAP=${KMAP} dfu ${THREADS}
+else
+    echo "make failed"
+    exit 77
+fi

keyboards/amj40/keymaps/default/keymap.c

@@ -0,0 +1,173 @@
+
+
+// This is the canonical layout file for the Quantum project. If you want to add another keyboard,
+// this is the style you want to emulate.
+
+#include "amj40.h"
+
+// 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 _QWERTY 0
+#define _LOWER 1
+#define _RAISE 2
+#define _ADJUST 3
+
+
+
+enum custom_keycodes {
+  QWERTY = SAFE_RANGE,
+  LOWER,
+  RAISE,
+  ADJUST,
+};
+
+
+
+
+
+// increase readability 
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+        /* Default Layer
+     * ,-----------------------------------------------------------.
+     * | Esc|  Q |  W |  E |  R |  T |  Y |  U |  I |  O |  P | BS |
+     * |-----------------------------------------------------------|
+     * | Tab |  A |  S |  D |  F |  G |  H |  J |  K |  L | Ent    |
+     * |-----------------------------------------------------------|
+     * | LSft   |  Z |  X |  C |  V |  B |  N |  M |  ,  |  . | /? |
+     * |-----------------------------------------------------------|
+     * | LCtl | LGui| LAlt|  spc fn0  |  spc fn1    |fn2|RAlt|RCtl |
+     * `-----------------------------------------------------------'
+     */
+    [_QWERTY] = KEYMAP( \
+        KC_ESC,  KC_Q,   KC_W,   KC_E,   KC_R,   KC_T,   KC_Y,   KC_U,   KC_I,    KC_O,    KC_P,   KC_BSPC,\
+        KC_TAB,  KC_A,   KC_S,   KC_D,   KC_F,   KC_G,   KC_H,   KC_J,   KC_K,    KC_L,    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_LCTL, KC_LGUI, KC_LALT,          F(0),           F(1),        F(2), KC_RALT, KC_RCTL \
+		),
+
+    /* Function Layer 1 HHKB style
+     * ,-----------------------------------------------------------.
+     * |   ~  |   !   |  @  | # | $ | % | ^ | & | * | ( | ) | Bkspc|
+     * |-----------------------------------------------------------|
+     * |   F1   | F2 | F3 | F4 | F5 |  F6 | _ | + | [ | ] |  Pipe  |
+     * |-----------------------------------------------------------|
+     * |    F7    | F8 | F9 |  F10  |  F11 |  F12 | End|PgDn| ↓ |     |    |
+     * |-----------------------------------------------------------|
+     * |     |    |     |           |             | Stop| App|     |
+     * `-----------------------------------------------------------'
+     */
+    [_LOWER] = KEYMAP( \
+        KC_TILD, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC, \
+		KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE, \
+		KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,S(KC_NUHS),S(KC_NUBS),BL_TOGG, BL_INC, BL_DEC, \
+		_______, _______, _______, _______, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT \
+		),
+	
+	/* Function Layer 1 HHKB style
+     * ,-----------------------------------------------------------.
+     * |Caps|    |MSel| ⏮ | ⏯ | ⏭ |PSCR|SkLk|Paus|  ↑ | Ins| Del|
+     * |-----------------------------------------------------------|
+     * |      | 🔇 | ⏏ |    |  * |  / |Hone|PgUp|  ← |  → |       |
+     * |-----------------------------------------------------------|
+     * |        | 🔉 | 🔊 |    |  + |  - | End|PgDn| ↓ |     |    |
+     * |-----------------------------------------------------------|
+     * |     |    |     |           |             | Stop| App|     |
+     * `-----------------------------------------------------------'
+     */
+    [_RAISE] = KEYMAP( \
+        KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC, \
+		KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS, \
+		KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_NUHS, KC_NUBS, _______, _______, KC_DEL, \
+		_______, KC_TRNS, _______, KC_TRNS, KC_TRNS, _______, _______, RGB_TOG \
+		),
+	
+	/* Function Layer 1 HHKB style
+     * ,-----------------------------------------------------------.
+     * |Caps|    |MSel| ⏮ | ⏯ | ⏭ |PSCR|SkLk|Paus|  ↑ | Ins| Del|
+     * |-----------------------------------------------------------|
+     * |      | 🔇 | ⏏ |    |  * |  / |Hone|PgUp|  ← |  → |       |
+     * |-----------------------------------------------------------|
+     * |        | 🔉 | 🔊 |    |  + |  - | End|PgDn| ↓ |     |    |
+     * |-----------------------------------------------------------|
+     * |     |    |     |           |             | Stop| App|     |
+     * `-----------------------------------------------------------'
+     */
+    [_ADJUST] = KEYMAP( \
+        _______, RESET,   _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL, \
+		_______, _______, _______, AU_ON,   AU_OFF,  AG_NORM, AG_SWAP, _______, _______, _______,  _______,  \
+		_______, _______, _______, RGB_TOG,  RGB_MOD,  RGB_HUI,  RGB_HUD,  RGB_SAI,  RGB_SAD,  RGB_VAI,  RGB_VAD, \
+		KC_SYSTEM_SLEEP, _______, _______, _______, _______, _______, _______, _______ \
+		),
+
+    
+
+};
+
+
+		
+
+enum function_id {
+    LAUNCH,
+    RGBLED_TOGGLE,
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+	[0]  = ACTION_LAYER_TAP_KEY(_LOWER, KC_SPC),
+	[1]  = ACTION_LAYER_TAP_KEY(_RAISE, KC_SPC),
+	[2]  = ACTION_LAYER_TAP_KEY(_ADJUST, KC_LGUI),
+
+};
+
+
+
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+    // MACRODOWN only works in this function
+   
+    return MACRO_NONE;
+};
+
+
+
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+ 
+  switch (keycode) {
+    
+    case LOWER:
+      if (record->event.pressed) {
+        layer_on(_LOWER);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_LOWER);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+      break;
+    case RAISE:
+      if (record->event.pressed) {
+        layer_on(_RAISE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_RAISE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+      break;
+    case ADJUST:
+      if (record->event.pressed) {
+        layer_on(_ADJUST);
+      } else {
+        layer_off(_ADJUST);
+      }
+      return false;
+      break;
+  }
+  return true;
+}

keyboards/amj40/keymaps/default/readme.md

@@ -0,0 +1,11 @@
+AMJ40 Default Layout
+=====================
+
+##Quantum MK Firmware
+For the full Quantum feature list, see the parent readme.md.
+
+# Features
+* Based on a combination of the original AMJ40 keymap from the TMK firmware as well as the Planck Ortholinear keyboard's "Lower," "Raise," and "Adjust" layers.
+* View the keymap.c file to understand they layout of the keymap.
+* Has keys to toggle both the switch LEDs and underglow LEDs.
+

keyboards/amj40/keymaps/default/updatemerge.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+git checkout amj60      # gets you on branch amj60
+git fetch origin        # gets you up to date with origin
+git merge origin/master

keyboards/amj40/keymaps/fabian/Makefile

@@ -0,0 +1,27 @@
+# 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   = no  # 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  = yes  # Enable WS2812 RGB underlight.  Do not enable this with audio at the same time.
+
+# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
+SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
+
+#define ws2812_PORTREG  PORTD
+#define ws2812_DDRREG   DDRD
+
+
+ifndef QUANTUM_DIR
+	include ../../../../Makefile
+endif

keyboards/amj40/keymaps/fabian/keymap.c

@@ -0,0 +1,236 @@
+#include "amj40.h"
+
+// Set the custom keymap
+#undef KEYMAP
+#define KEYMAP( \
+    k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b, \
+    k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b,  \
+    k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b,  \
+    k30, k31, k32, k33, k34, k35,                k39, k3a, k3b  \
+) { \
+    {k00, k01, k02, k03, k04, k05, k06, k07, k08, k09, k0a, k0b}, \
+    {k10, k11, k12, k13, k14, k15, k16, k17, k18, k19, k1a, k1b}, \
+    {k20, k21, k22, k23, k24, k25, k26, k27, k28, k29, k2a, k2b}, \
+    {k30, k31, k32, k33, k34, k35, XXX, XXX, XXX, k39, k3a, k3b} \
+}
+
+// Fillers to make layering more clear
+#define _______ KC_TRNS
+#define XXXXXXX KC_NO
+
+// Custom
+#define CTL_ESC CTL_T(KC_ESC)  // Tap for Escape, hold for Control
+#define SFT_ENT SFT_T(KC_ENT)  // Tap for Enter, hold for Shift
+#define SFT_BSP SFT_T(KC_BSPC) // Tap for Backspace, hold for Shift
+#define HPR_TAB ALL_T(KC_TAB)  // Tap for Tab, hold for Hyper (Super+Ctrl+Alt+Shift)
+// #define MEH_GRV MEH_T(KC_GRV)  // Tap for Backtick, hold for Meh (Ctrl+Alt+Shift)
+
+#define _QWERTY 0
+#define _COLEMAK 1
+#define _DVORAK 2
+#define _LOWER 3
+#define _RAISE 4
+#define _ADJUST 16
+
+enum custom_keycodes {
+  QWERTY = SAFE_RANGE,
+  COLEMAK,
+  DVORAK,
+  LOWER,
+  RAISE,
+  ADJUST,
+};
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+/* Qwerty
+ * ,-----------------------------------------------------------------------------------.
+ * | Tab  |   Q  |   W  |   E  |   R  |   T  |   Y  |   U  |   I  |   O  |   P  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Esc  |   A  |   S  |   D  |   F  |   G  |   H  |   J  |   K  |   L  |   ;  |  "   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   Z  |   X  |   C  |   V  |   B  |   N  |   M  |   ,  |   .  |   /  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |Adjust| Ctrl | Alt  | GUI  | Lower and Space | Raise and Bksp | GUI  |AltGr | Ctrl |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_QWERTY] = KEYMAP( \
+  HPR_TAB, KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,    KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC, \
+  CTL_ESC, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,    KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT, \
+  SFT_BSP, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, SFT_ENT , \
+  F(2),    KC_LCTL, KC_LALT, KC_LGUI,          F(0),             F(1),             KC_RGUI, KC_RALT, KC_RCTL \
+),
+
+/* Colemak
+ * ,-----------------------------------------------------------------------------------.
+ * | Tab  |   Q  |   W  |   F  |   P  |   G  |   J  |   L  |   U  |   Y  |   ;  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Esc  |   A  |   R  |   S  |   T  |   D  |   H  |   N  |   E  |   I  |   O  |  "   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   Z  |   X  |   C  |   V  |   B  |   K  |   M  |   ,  |   .  |   /  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |Adjust| Ctrl | Alt  | GUI  | Lower and Space | Raise and Bksp | GUI  |AltGr | Ctrl |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_COLEMAK] = KEYMAP( \
+  HPR_TAB, KC_Q,    KC_W,    KC_F,    KC_P,    KC_G,    KC_J,    KC_L,    KC_U,    KC_Y,    KC_SCLN, KC_BSPC, \
+  CTL_ESC, KC_A,    KC_R,    KC_S,    KC_T,    KC_D,    KC_H,    KC_N,    KC_E,    KC_I,    KC_O,    KC_QUOT, \
+  SFT_BSP, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,    KC_K,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, SFT_ENT , \
+  F(2),    KC_LCTL, KC_LALT, KC_LGUI,          F(0),             F(1),             KC_RGUI, KC_RALT, KC_RCTL \
+),
+
+/* Dvorak
+ * ,-----------------------------------------------------------------------------------.
+ * | Tab  |   "  |   ,  |   .  |   P  |   Y  |   F  |   G  |   C  |   R  |   L  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Esc  |   A  |   O  |   E  |   U  |   I  |   D  |   H  |   T  |   N  |   S  |  /   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * | Shift|   ;  |   Q  |   J  |   K  |   X  |   B  |   M  |   W  |   V  |   Z  |Enter |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |Adjust| Ctrl | Alt  | GUI  | Lower and Space | Raise and Bksp | GUI  |AltGr | Ctrl |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_DVORAK] = KEYMAP( \
+  HPR_TAB, KC_QUOT, KC_COMM, KC_DOT,  KC_P,    KC_Y,    KC_F,    KC_G,    KC_C,    KC_R,    KC_L,    KC_BSPC, \
+  CTL_ESC, KC_A,    KC_O,    KC_E,    KC_U,    KC_I,    KC_D,    KC_H,    KC_T,    KC_N,    KC_S,    KC_SLSH, \
+  SFT_BSP, KC_SCLN, KC_Q,    KC_J,    KC_K,    KC_X,    KC_B,    KC_M,    KC_W,    KC_V,    KC_Z,    SFT_ENT , \
+  F(2),    KC_LCTL, KC_LALT, KC_LGUI,          F(0),             F(1),             KC_RGUI, KC_RALT, KC_RCTL \
+),
+
+/* Lower
+ * ,-----------------------------------------------------------------------------------.
+ * |   ~  |   !  |   @  |   #  |   $  |   %  |   ^  |   &  |   *  |   (  |   )  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Del  |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   _  |   +  |   {  |   }  |  |   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 | MS L | MS D |MS U  | MS R |MS Btn|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |      |      |      | Next | Vol- | Vol+ | Play |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_LOWER] = KEYMAP( \
+  KC_TILD, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC, \
+  KC_DEL,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE, \
+  _______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_MS_L, KC_MS_D, KC_MS_U, KC_MS_R, KC_BTN1, \
+  _______, _______, _______, _______,          _______,          _______,          KC_VOLD, KC_VOLU, KC_MPLY \
+),
+
+/* Raise
+ * ,-----------------------------------------------------------------------------------.
+ * |   `  |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   0  | Bksp |
+ * |------+------+------+------+------+-------------+------+------+------+------+------|
+ * | Del  |  F1  |  F2  |  F3  |  F4  |  F5  |  F6  |   -  |   =  |   [  |   ]  |  \   |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |  F7  |  F8  |  F9  |  F10 |  F11 |  F12 | Left | Down |  Up  | Rght |MS_BN2|
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |      |      |      | Next | Vol- | Vol+ | Play |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_RAISE] = KEYMAP( \
+  KC_GRV,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,    KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC, \
+  KC_DEL,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,   KC_F6,   KC_MINS, KC_EQL,  KC_LBRC, KC_RBRC, KC_BSLS, \
+  _______, KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_F11,  KC_F12,  KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, KC_BTN2, \
+  _______, _______, _______, _______,          _______,          _______,          KC_VOLD, KC_VOLU, KC_MPLY \
+),
+
+/* Adjust (Lower + Raise)
+ * ,-----------------------------------------------------------------------------------.
+ * |Reset |Colemk|Qwerty|Dvorak|      |      |      |      |  MU  |      |      |Reset |
+ * |------+------+------+------+------+------|------+------+------+------+------+------|
+ * |      |AGNorm|AGSwap|      |      |      |      |  ML  |  MD  |  MR  |      |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |AudOn |AudOff|      |      |      |      |MBtn1 |MBtn2 |MBtn3 |      |      |
+ * |------+------+------+------+------+------+------+------+------+------+------+------|
+ * |      |      |      |      |      |      |      |      |      |      |      |      |
+ * `-----------------------------------------------------------------------------------'
+ */
+[_ADJUST] = KEYMAP( \
+  RESET,   COLEMAK, QWERTY,  DVORAK,  _______, _______, _______, _______, KC_MS_U, _______, _______, RESET, \
+  _______, AG_NORM, AG_SWAP, _______, _______, _______, _______, KC_MS_L, KC_MS_D, KC_MS_R, _______, _______, \
+  _______, AU_ON,   AU_OFF,  _______, _______, _______, _______, KC_BTN1, KC_BTN2, KC_BTN3, _______, _______, \
+  _______, _______, _______, _______,          _______,          _______,          _______, _______, _______ \
+)
+
+};
+
+#ifdef AUDIO_ENABLE
+float tone_qwerty[][2]     = SONG(QWERTY_SOUND);
+float tone_dvorak[][2]     = SONG(DVORAK_SOUND);
+float tone_colemak[][2]    = SONG(COLEMAK_SOUND);
+#endif
+
+void persistent_default_layer_set(uint16_t default_layer) {
+  eeconfig_update_default_layer(default_layer);
+  default_layer_set(default_layer);
+}
+
+const uint16_t PROGMEM fn_actions[] = {
+        [0]  = ACTION_LAYER_TAP_KEY(_LOWER, KC_SPC),
+        [1]  = ACTION_LAYER_TAP_KEY(_RAISE, KC_BSPC),
+        [2]  = ACTION_LAYER_TAP_KEY(_ADJUST, KC_LGUI),
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+    return MACRO_NONE;
+};
+
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  switch (keycode) {
+    case QWERTY:
+      if (record->event.pressed) {
+        #ifdef AUDIO_ENABLE
+          PLAY_NOTE_ARRAY(tone_qwerty, false, 0);
+        #endif
+        persistent_default_layer_set(1UL<<_QWERTY);
+      }
+      return false;
+      break;
+    case COLEMAK:
+      if (record->event.pressed) {
+        #ifdef AUDIO_ENABLE
+          PLAY_NOTE_ARRAY(tone_colemak, false, 0);
+        #endif
+        persistent_default_layer_set(1UL<<_COLEMAK);
+      }
+      return false;
+      break;
+    case DVORAK:
+      if (record->event.pressed) {
+        #ifdef AUDIO_ENABLE
+          PLAY_NOTE_ARRAY(tone_dvorak, false, 0);
+        #endif
+        persistent_default_layer_set(1UL<<_DVORAK);
+      }
+      return false;
+      break;
+    case LOWER:
+      if (record->event.pressed) {
+        layer_on(_LOWER);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_LOWER);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+      break;
+    case RAISE:
+      if (record->event.pressed) {
+        layer_on(_RAISE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      } else {
+        layer_off(_RAISE);
+        update_tri_layer(_LOWER, _RAISE, _ADJUST);
+      }
+      return false;
+      break;
+    case ADJUST:
+      if (record->event.pressed) {
+        layer_on(_ADJUST);
+      } else {
+        layer_off(_ADJUST);
+      }
+      return false;
+      break;
+  }
+  return true;
+}

keyboards/amj40/readme.md

@@ -0,0 +1,35 @@
+AMJ40 keyboard firmware
+======================
+DIY/Assembled compact 40% keyboard.
+
+Ported by N.Hou from the original TMK firmware.
+
+*Supports both backlight LEDs as well as RGB underglow. 
+
+*For reference, the AMJ40 uses pin D3 for underglow lighting.
+
+## Quantum MK Firmware
+
+For the full Quantum feature list, see [the parent readme.md](/readme.md).
+
+## Building
+
+Download or clone the whole firmware and navigate to the keyboards/amj40
+folder. Once your dev env is setup, you'll be able to type `make` to generate
+your .hex - you can then use `make dfu` to program your PCB once you hit the
+reset button. 
+
+Depending on which keymap you would like to use, you will have to compile
+slightly differently.
+
+### Default
+To build with the default keymap, simply run `sudo make all`.
+The .hex file will appear in the root of the qmk firmware folder.
+
+
+
+
+### Original tmk firmware
+The original firmware that was used to port to qmk can be found [here](https://github.com/AMJKeyboard/AMJ40).
+
+

keyboards/amj40/rules.mk

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

keyboards/atreus/keymaps/xyverz/keymap.c

@@ -173,31 +173,31 @@ void persistent_default_layer_set(uint16_t default_layer) {
   default_layer_set(default_layer);
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
         case QWERTY:
           if (record->event.pressed) {
             persistent_default_layer_set(1UL<<_QWERTY);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case COLEMAK:
           if (record->event.pressed) {
             persistent_default_layer_set(1UL<<_COLEMAK);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case DVORAK:
           if (record->event.pressed) {
             persistent_default_layer_set(1UL<<_DVORAK);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case DVORMAC:
           if (record->event.pressed) {
             persistent_default_layer_set(1UL<<_DVORMAC);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case LOWER:
           if (record->event.pressed) {
@@ -207,7 +207,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             layer_off(_LOWER);
             update_tri_layer(_LOWER, _RAISE, _ADJUST);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case RAISE:
           if (record->event.pressed) {
@@ -217,8 +217,8 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             layer_off(_RAISE);
             update_tri_layer(_LOWER, _RAISE, _ADJUST);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
       }
-    return CONTINUE_PROCESSING;
+    return true;
 };

keyboards/atreus62/keymaps/atreus52/keymap.c

@@ -78,7 +78,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 
 static uint8_t qw_dv_swap_state = 0;
 
-level_t process_user (uint16_t keycode, keyrecord_t *record) {
+bool process_record_user (uint16_t keycode, keyrecord_t *record) {
     if (keycode == KC_LGUI) {
         if (record->event.pressed)
             qw_dv_swap_state |= 0b00000001;
@@ -95,5 +95,5 @@ level_t process_user (uint16_t keycode, keyrecord_t *record) {
     if (qw_dv_swap_state == 0b00000011) {
         layer_invert(DVORAK);
     }
-    return CONTINUE_PROCESSING;
+    return true;
 }

keyboards/atreus62/keymaps/mneme/keymap.c

@@ -189,7 +189,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 };
 
 // Custom keycodes
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   bool queue = true;
 
   //Cancle one-shot mods.
@@ -201,7 +201,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
       }
       break;
   }
-  return queue ? CONTINUE_PROCESSING : STOP_PROCESSING;
+  return queue;
 }
 
 // TAP DANCE SETTINGS

keyboards/atreus62/keymaps/xyverz/keymap.c

@@ -124,31 +124,31 @@ void persistent_default_layer_set(uint16_t default_layer) {
   default_layer_set(default_layer);
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
         case QWERTY:
           if (record->event.pressed) {
             persistent_default_layer_set(1UL<<_QWERTY);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case COLEMAK:
           if (record->event.pressed) {
             persistent_default_layer_set(1UL<<_COLEMAK);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case DVORAK:
           if (record->event.pressed) {
             persistent_default_layer_set(1UL<<_DVORAK);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case WOW:
           if (record->event.pressed) {
             persistent_default_layer_set(1UL<<_WOW);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case LOWER:
           if (record->event.pressed) {
@@ -158,7 +158,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             layer_off(_LOWER);
             update_tri_layer(_LOWER, _RAISE, _ADJUST);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case RAISE:
           if (record->event.pressed) {
@@ -168,8 +168,8 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             layer_off(_RAISE);
             update_tri_layer(_LOWER, _RAISE, _ADJUST);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
       }
-    return CONTINUE_PROCESSING;
+    return true;
 };

keyboards/bananasplit/Makefile

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

keyboards/bananasplit/README.md

@@ -0,0 +1,29 @@
+# BananaSplit60 keyboard firmware
+
+Ported from evangs/tmk_keyboard
+
+## Quantum MK Firmware
+
+For the full Quantum feature list, see [the parent readme](/).
+
+## Building
+
+Download or clone the whole firmware and navigate to the keyboards/bananasplit folder. Once your dev env is setup, you'll be able to type `make` to generate your .hex - you can then use the Teensy Loader to program your .hex file.
+
+Depending on which keymap you would like to use, you will have to compile slightly differently.
+
+### Default
+
+To build with the default keymap, simply run `make default`.
+
+### Other Keymaps
+
+Several version of keymap are available in advance but you are recommended to define your favorite layout yourself. To define your own keymap create a folder with the name of your keymap in the keymaps folder, and see keymap documentation (you can find in top readme.md) and existant keymap files.
+
+To build the firmware binary hex file with a keymap just do `make` with a keymap like this:
+
+```
+$ make [default|jack|<name>]
+```
+
+Keymaps follow the format **__\<name\>.c__** and are stored in the `keymaps` folder.

keyboards/bananasplit/bananasplit.c

@@ -0,0 +1,28 @@
+#include "bananasplit.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
+
+	led_set_user(usb_led);
+}

keyboards/bananasplit/bananasplit.h

@@ -0,0 +1,107 @@
+/*
+Copyright 2012,2013 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 BANANASPLIT_H
+#define BANANASPLIT_H
+
+#include "quantum.h"
+
+#define KEYMAP(                                                                     \
+    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, K2C,                \
+    K30,      K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D,           \
+    K40, K41, K42,      K44, K45, K46,      K48, K49, K4A, K4B, K4C                 \
+) {                                                                                 \
+    { 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, K2C, KC_NO },     \
+    { K30, KC_NO,    K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D },  \
+    { K40, K41, K42, KC_NO,    K44, K45, K46, KC_NO,    K48, K49, K4A, K4B, K4C }   \
+}
+
+#define KEYMAP_HHKBANANA(                                                           \
+    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, K2C, K2D,           \
+    K30,      K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C,                \
+    K40, K41, K42,      K44, K45, K46,      K48, K49, K4A, K4B, K4C                 \
+) { \
+    { 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, K2C, K2D },       \
+    { K30, KC_NO,   K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, KC_NO }, \
+    { K40, K41, K42, KC_NO,    K44, K45, K46, KC_NO,    K48, K49, K4A, K4B, K4C }   \
+}
+
+#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, K2C,                \
+    K30,      K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C,                \
+    K40, K41, K42,           K45,           K48, K49,      K4B, K4C                 \
+) {                                                                                 \
+    { 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, K2C, KC_NO },     \
+    { K30, KC_NO,   K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, KC_NO }, \
+    { K40, K41, K42, KC_NO,    KC_NO,    K45, KC_NO,    KC_NO,    K48, K49, KC_NO,  K4B, K4C }  \
+}
+
+#define KEYMAP_ISO( \
+    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, K2C, \
+    K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, \
+    K40, K41, K42,           K45,           K48, K49,      K4B, K4C  \
+) { \
+    { 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, K2C, KC_NO }, \
+    { K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, KC_NO }, \
+    { K40, K41, K42, KC_NO,    KC_NO,    K45, KC_NO,    KC_NO,    K48, K49, KC_NO,    K4B, K4C }  \
+}
+
+#define KEYMAP_ALL( \
+    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, K2C, K2D,\
+    K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D,\
+    K40, K41, K42,      K44, K45, K46,      K48, K49, K4A, K4B, K4C  \
+) { \
+    { 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, K2C, K2D }, \
+    { K30, K31, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D }, \
+    { K40, K41, K42, KC_NO,    K44, K45, K46, KC_NO,    K48, K49, K4A, K4B, K4C }  \
+}
+
+#define KEYMAP_HHKB_ARROW( \
+    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, K2C, K2D,\
+    K30,      K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D,\
+    K40, K41, K42,      K44, K45, K46,      K48, K49, K4A, K4B, K4C  \
+) { \
+    { 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, K2C, K2D }, \
+    { K30, KC_NO, K32, K33, K34, K35, K36, K37, K38, K39, K3A, K3B, K3C, K3D }, \
+    { K40, K41, K42, KC_NO,    K44, K45, K46, KC_NO,    K48, K49, K4A, K4B, K4C }  \
+}
+
+
+#endif

keyboards/bananasplit/config.h

@@ -0,0 +1,81 @@
+/*
+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       0xFEAE
+#define PRODUCT_ID      0x8870
+#define DEVICE_VER      0x0001
+#define MANUFACTURER    TheVan Keyboards
+#define PRODUCT         BananaSplit 60
+#define DESCRIPTION     keyboard firmware for BananaSplit 60
+
+/* key matrix size */
+#define MATRIX_ROWS 5
+#define MATRIX_COLS 14
+
+#define MATRIX_ROW_PINS { B0, B2, B4, B5, B6 }
+#define MATRIX_COL_PINS { F5, B1, F0, F1, F4, B3, D7, D6, D4, D5, D3, D2, D1, D0 }
+#define UNUSED_PINS
+
+#define DIODE_DIRECTION ROW2COL
+
+/* define if matrix has ghost */
+//#define MATRIX_HAS_GHOST
+
+/* number of backlight levels */
+#define BACKLIGHT_LEVELS  1
+
+/* Set 0 if debouncing isn't needed */
+#define DEBOUNCING_DELAY  5
+#define TAPPING_TERM      175
+
+/* 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)) \
+)
+
+
+
+/*
+ * 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/bananasplit/keymaps/default/keymap.c

@@ -0,0 +1,25 @@
+#include "bananasplit.h"
+
+#define DEFAULT_LAYER 0
+#define LAYER_1       1
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [DEFAULT_LAYER] = 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_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,  RSFT_T(KC_SLSH),  KC_UP, _______, \
+    KC_LCTL,  KC_LGUI,  KC_LALT, KC_ENT,      MO(LAYER_1),      KC_SPC,  KC_RALT, KC_RCTL,  KC_LEFT, KC_DOWN, KC_RIGHT
+  ),
+
+  [LAYER_1] = KEYMAP( \
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+    _______, _______, _______,          _______, _______, _______,          _______, _______, _______, _______, _______ \
+  ),
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+};

keyboards/bananasplit/keymaps/hhkbanana/keymap.c

@@ -0,0 +1,25 @@
+#include "bananasplit.h"
+
+#define DEFAULT_LAYER 0
+#define LAYER_1       1
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [DEFAULT_LAYER] = KEYMAP_HHKBANANA( \
+    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_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_PSCR, \
+    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_ENT,      MO(LAYER_1),      KC_SPC,  KC_RALT, KC_RCTL,  KC_LEFT, KC_DOWN, KC_RIGHT \
+  ),
+
+  [LAYER_1] = KEYMAP_HHKBANANA( \
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+    _______, _______, _______,          _______, _______, _______,          _______, _______, _______, _______, _______ \
+  ),
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+};

keyboards/bananasplit/keymaps/nic/keymap.c

@@ -0,0 +1,45 @@
+#include "bananasplit.h"
+
+#define DEFAULT_LAYER 0
+#define THUMB_LAYER   1
+#define NORMAN_LAYER  2
+#define MOD_LAYER     3
+
+#define HYPER_TAB ALL_T(KC_TAB)
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [DEFAULT_LAYER] = KEYMAP_HHKB_ARROW( \
+    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_BSLS, \
+    HYPER_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, \
+    CTL_T(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_ENT, KC_DEL, \
+    KC_LSFT,   KC_Z,   KC_X,   KC_C,   KC_V,   KC_B,   KC_N,   KC_M,   KC_COMM,  KC_DOT,  RSFT_T(KC_SLSH),  KC_UP, TG(NORMAN_LAYER), \
+    KC_CAPS,  KC_LALT,  KC_LGUI,  KC_SPC,      MO(THUMB_LAYER),      KC_SPC,  KC_LGUI, KC_LALT,  KC_LEFT, KC_DOWN, KC_RIGHT \
+  ),
+
+  [THUMB_LAYER] = KEYMAP_HHKB_ARROW( \
+    MO(MOD_LAYER), 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_UNDS,   KC_PLUS,   KC_LCBR,   KC_RCBR,   _______, _______, _______, \
+    _______,   _______,   _______,   _______,   _______,   _______,   _______,   KC_MINS,   KC_EQL,   KC_LBRC, KC_RBRC,  _______, _______, _______, \
+    _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,  _______,  _______,  _______, _______, \
+    _______,  _______,  _______, _______,      _______,      _______,  _______, _______,  _______, _______, _______ \
+  ),
+
+  [NORMAN_LAYER] = KEYMAP_HHKB_ARROW( \
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+    _______,  _______,   _______,   KC_D,   KC_F,   KC_K,   KC_J,   KC_U,   KC_R,   KC_L,   KC_SCLN,   _______, _______, _______, \
+    _______,   _______,   _______,   KC_E,   KC_T,  _______,   KC_Y,   KC_N,   KC_I,   KC_O,   KC_H,  _______, _______, _______, \
+    _______,   _______,   _______,   _______,   _______,   _______,   KC_P,   _______,   _______,  _______,  _______,  _______, _______, \
+    _______,  _______,  _______, _______,      _______,      _______,  _______, _______,  _______, _______, _______ \
+  ),
+
+  [MOD_LAYER] = KEYMAP_HHKB_ARROW( \
+    _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
+    _______,  _______,   _______,   _______,  RESET,  _______,   _______,   _______,   _______,   _______,   _______,   _______, _______, _______, \
+    _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,  _______, _______, _______, \
+    _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,   _______,  _______,  _______,  _______, _______, \
+    _______,  _______,  _______, _______,      _______,      _______,  _______, _______,  _______, _______, _______ \
+  ),
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+};

keyboards/bananasplit/rules.mk

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

keyboards/clueboard/keymaps/smt/keymap.c

@@ -156,26 +156,26 @@ void persistent_default_layer_set(uint16_t default_layer) {
   default_layer_set(default_layer);
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case QWERTY:
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<_QWERTY);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case COLEMAK:
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<_COLEMAK);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case DVORAK:
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<_DVORAK);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }

keyboards/cluecard/cluecard.c

@@ -17,11 +17,11 @@ void matrix_scan_kb(void) {
 	matrix_scan_user();
 }
 
-level_t process_kb(uint16_t keycode, keyrecord_t *record) {
+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 CONTINUE_PROCESSING;
+	return process_record_user(keycode, record);
 }
 
 void led_set_kb(uint8_t usb_led) {

keyboards/cluecard/keymaps/default/keymap.c

@@ -55,8 +55,8 @@ void matrix_scan_user(void) {
 
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
-  return CONTINUE_PROCESSING;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
 }
 
 void led_set_user(uint8_t usb_led) {

keyboards/cluecard/keymaps/rgb_effects/keymap.c

@@ -20,8 +20,8 @@ void matrix_scan_user(void) {
 
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
-  return CONTINUE_PROCESSING;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
 }
 
 void led_set_user(uint8_t usb_led) {

keyboards/converter/ibm_terminal/keymaps/priyadi/keymap.c

@@ -261,50 +261,50 @@ void persistent_default_layer_set(uint16_t default_layer) {
   default_layer_set(default_layer);
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     /* layout switcher */
     case LAY_QWE:
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<QWE);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case LAY_COL:
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<COL);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case LAY_WOR:
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<WOR);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case LAY_DVO:
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<DVO);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
 
     /* os switcher */
     case OS_LIN:
       set_unicode_input_mode(UC_LNX);
-      return STOP_PROCESSING;
+      return false;
       break;
     case OS_WIN:
       set_unicode_input_mode(UC_WINC);
-      return STOP_PROCESSING;
+      return false;
       break;
     case OS_MAC:
       set_unicode_input_mode(UC_OSX);
-      return STOP_PROCESSING;
+      return false;
       break;
 
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 void matrix_init_user() {

keyboards/deltasplit75/readme.md

@@ -11,7 +11,7 @@ based boards.
 ## Case Files
 Files are available here: https://github.com/xyxjj/DeltaSplit75-Case-files
 
-#Build Guide
+## Build Guide
 The build guide should be found at https://qmk.fm/deltasplit75
 
 

keyboards/deltasplit75/rules.mk

@@ -73,15 +73,3 @@ USE_I2C ?= yes
 SLEEP_LED_ENABLE ?= no    # Breathing sleep LED during USB suspend
 
 CUSTOM_MATRIX = yes
-
-avrdude: build
-	ls /dev/tty* > /tmp/1; \
-	echo "Reset your Pro Micro now"; \
-	while [[ -z $$USB ]]; do \
-	  sleep 1; \
-	  ls /dev/tty* > /tmp/2; \
-	  USB=`diff /tmp/1 /tmp/2 | grep -o '/dev/tty.*'`; \
-	done; \
-	avrdude -p $(MCU) -c avr109 -P $$USB -U flash:w:$(BUILD_DIR)/$(TARGET).hex
-
-.PHONY: avrdude

keyboards/dk60/keymaps/default/keymap.c

@@ -63,7 +63,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
       )
 };
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case FN:
       if (record->event.pressed) {
@@ -73,8 +73,8 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_FN);
         dk60_esc_led_off();
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }

keyboards/eco/Makefile

@@ -1,4 +1,4 @@
-SUBPROJECT_DEFAULT = rev1
+SUBPROJECT_DEFAULT = rev2
 
 ifndef MAKEFILE_INCLUDED
 	include ../../Makefile

keyboards/eco/config.h

@@ -73,5 +73,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifdef SUBPROJECT_rev1
     #include "rev1/config.h"
 #endif
+#ifdef SUBPROJECT_rev2
+    #include "rev2/config.h"
+#endif
 
 #endif

keyboards/eco/eco.h

@@ -4,6 +4,10 @@
 #ifdef SUBPROJECT_rev1
     #include "rev1.h"
 #endif
+#ifdef SUBPROJECT_rev2
+    #include "rev2.h"
+#endif
+
 
 #include "quantum.h"
 

keyboards/eco/keymaps/that_canadian/keymap.c

@@ -148,7 +148,7 @@ void persistant_default_layer_set(uint16_t default_layer) {
   default_layer_set(default_layer);
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case QWERTY:
       if (record->event.pressed) {
@@ -157,7 +157,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         #endif
         persistant_default_layer_set(1UL<<_QWERTY);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case LOWER:
       if (record->event.pressed) {
@@ -167,7 +167,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_LOWER);
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RAISE:
       if (record->event.pressed) {
@@ -177,10 +177,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_RAISE);
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 void matrix_init_user(void) {

keyboards/eco/readme.md

@@ -10,6 +10,6 @@ Hardware Supported: ECO PCB rev1 Pro Micro
 
 Make example for this keyboard (after setting up your build environment):
 
-    make eco-rev1-that_canadian
+    make eco-rev2-that_canadian
 
 See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.

keyboards/eco/rev2/Makefile

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

keyboards/eco/rev2/config.h

@@ -0,0 +1,30 @@
+/*
+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 REV2_CONFIG_H
+#define REV2_CONFIG_H
+
+#include "../config.h"
+
+#define DEVICE_VER      0x0002
+
+/* ECO V2.1 pin-out */
+#define MATRIX_ROW_PINS { D7, B5, B4, E6 }
+#define MATRIX_COL_PINS { D1, D0, D4, C6, B6, B2, B3, B1, F7, F6, F5, F4, D2, D3 }
+#define UNUSED_PINS
+
+#endif

keyboards/eco/rev2/rev2.c

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

keyboards/eco/rev2/rev2.h

@@ -0,0 +1,24 @@
+#ifndef REV2_H
+#define REV2_H
+
+#include "../eco.h"
+
+//void promicro_bootloader_jmp(bool program);
+#include "quantum.h"
+
+//void promicro_bootloader_jmp(bool program);
+
+#define KEYMAP( \
+	k01, k02, k03, k04, k05, k06, k07, k08, k09, k010, k011, k012, k013, k014, \
+	k11, k12, k13, k14, k15, k16, k17, k18, k19, k110, k111, k112, k113, k114, \
+	k21, k22, k23, k24, k25, k26, k27, k28, k29, k210, k211, k212, k213, k214, \
+	k31, k32, k33, k34, k35, k36, k37, k38, k39, k310, k311, k312, k313, k314  \
+	) \
+	{ \
+		{ k01, k02, k03, k04, k05, k06, k07, k08, k09, k010, k011, k012, k013, k014 }, \
+		{ k11, k12, k13, k14, k15, k16, k17, k18, k19, k110, k111, k112, k113, k114 }, \
+		{ k21, k22, k23, k24, k25, k26, k27, k28, k29, k210, k211, k212, k213, k214 }, \
+		{ k31, k32, k33, k34, k35, k36, k37, k38, k39, k310, k311, k312, k313, k314 }  \
+	}
+
+#endif

keyboards/eco/rev2/rules.mk

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

keyboards/ergodox/ez/keymaps/blakedietz/keymap.c

@@ -258,10 +258,10 @@ void matrix_scan_user(void) {
     }
 };
 
-//level_t process_user(uint16_t keycode, keyrecord_t *record) {
+//bool process_record_user(uint16_t keycode, keyrecord_t *record) {
 //  switch (keycode) {
 //    case QWERTY:
-//    return STOP_PROCESSING
+//    return false
 //    break;
 //    case LOWER:
 //      if (record->event.pressed) {
@@ -271,7 +271,7 @@ void matrix_scan_user(void) {
 //        layer_off(_LOWER);
 //        update_tri_layer(_LOWER, _RAISE, _ADJUST);
 //      }
-//      return STOP_PROCESSING;
+//      return false;
 //      break;
 //    case RAISE:
 //      if (record->event.pressed) {
@@ -281,9 +281,9 @@ void matrix_scan_user(void) {
 //        layer_off(_RAISE);
 //        update_tri_layer(_LOWER, _RAISE, _ADJUST);
 //      }
-//      return STOP_PROCESSING;
+//      return false;
 //      break;
 //  }
-//  return CONTINUE_PROCESSING;
+//  return true;
 //}
 

keyboards/ergodox/ez/keymaps/steno/keymap.c

@@ -267,7 +267,7 @@ void send_chord(void)
   virtser_send(0);
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record)
+bool process_record_user(uint16_t keycode, keyrecord_t *record)
 {
   // We need to track keypresses in all modes, in case the user
   // changes mode whilst pressing other keys.
@@ -275,7 +275,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record)
     pressed_count++;
   else
     pressed_count--;
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)

keyboards/ergodox/keymaps/333fred/keymap.c

@@ -357,23 +357,23 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
     return MACRO_NONE;
 };
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     // dynamically generate these.
     case EPRM:
       if (record->event.pressed) {
         eeconfig_init();
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case VRSN:
       if (record->event.pressed) {
         SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 // Runs just one time when the keyboard initializes.

keyboards/ergodox/keymaps/algernon/keymap.c

@@ -1043,7 +1043,7 @@ const qk_ucis_symbol_t ucis_symbol_table[] = UCIS_TABLE
  UCIS_SYM("tm", 0x2122)
 );
 
-level_t process_user (uint16_t keycode, keyrecord_t *record) {
+bool process_record_user (uint16_t keycode, keyrecord_t *record) {
 #if KEYLOGGER_ENABLE
   if (log_enable) {
     uint8_t layer = biton32(layer_state);
@@ -1086,11 +1086,11 @@ level_t process_user (uint16_t keycode, keyrecord_t *record) {
 
       ang_tap (KC_4, KC_SPC, KC_D, KC_A, KC_Y, KC_S, KC_QUOT, 0);
 
-      return STOP_PROCESSING;
+      return false;
     }
   }
 
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 void qk_ucis_symbol_fallback (void) {

keyboards/ergodox/keymaps/belak/keymap.c

@@ -247,7 +247,7 @@ void matrix_scan_user(void) {
     }
 };
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
     switch (keycode) {
     case BEL_F0:
         if(record->event.pressed){
@@ -260,7 +260,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
                 layer_off(SWPH);
             }
 
-            return STOP_PROCESSING;
+            return false;
         }
         break;
     case BEL_F1:
@@ -268,7 +268,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             layer_off(SYMB);
             layer_off(NUMP);
 
-            return STOP_PROCESSING;
+            return false;
         }
         break;
     case E_SHRUG: // ¯\_(ツ)_/¯
@@ -287,7 +287,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             tap(KC_SLSH);                                   // Arm
             process_unicode((0x00AF|QK_UNICODE), record);   // Hand
         }
-        return STOP_PROCESSING;
+        return false;
         break;
     case E_TFLIP: // (╯°□°)╯ ︵ ┻━┻
         if (record->event.pressed) {
@@ -309,7 +309,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             process_unicode((0x2501|QK_UNICODE), record);   // Table
             process_unicode((0x253B|QK_UNICODE), record);   // Table
         }
-        return STOP_PROCESSING;
+        return false;
         break;
     case E_TSET: // ┬──┬ ノ( ゜-゜ノ)
         if (record->event.pressed) {
@@ -331,11 +331,11 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             tap(KC_0);
             unregister_code(KC_RSFT);
         }
-        return STOP_PROCESSING;
+        return false;
         break;
     }
 
-    return CONTINUE_PROCESSING;
+    return true;
 }
 
 void belak_td_each(qk_tap_dance_state_t *state, void *user_data) {

keyboards/ergodox/keymaps/bryan/keymap.c

@@ -168,20 +168,20 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
     return MACRO_NONE;
 };
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     // dynamically generate these.
     case EPRM:
       if (record->event.pressed) {
         eeconfig_init();
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case VRSN:
       if (record->event.pressed) {
         SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RGB_SLD:
       if (record->event.pressed) {
@@ -189,10 +189,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           rgblight_mode(1);
         #endif
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 // Runs just one time when the keyboard initializes.

keyboards/ergodox/keymaps/default/keymap.c

@@ -165,20 +165,20 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
     return MACRO_NONE;
 };
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     // dynamically generate these.
     case EPRM:
       if (record->event.pressed) {
         eeconfig_init();
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case VRSN:
       if (record->event.pressed) {
         SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RGB_SLD:
       if (record->event.pressed) {
@@ -186,10 +186,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           rgblight_mode(1);
         #endif
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 // Runs just one time when the keyboard initializes.

keyboards/ergodox/keymaps/erez_experimental/keymap.c

@@ -159,7 +159,7 @@ void matrix_init_user(void) {
 };
 
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     // dynamically generate these.
     case RGB_FF00BB:
@@ -170,10 +170,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           rgblight_setrgb(0xff,0x00,0xbb);
         #endif
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 LEADER_EXTERNS();

keyboards/ergodox/keymaps/french_hacker/keymap.c

@@ -0,0 +1,365 @@
+#include "ergodox.h"
+#include "debug.h"
+#include "action_layer.h"
+#include "version.h"
+#include "keymap_french.h"
+
+#define BASE 0 // default Colemak Mod-DH layer
+#define SYMB 1 // symbols
+#define MDIA 2 // media keys
+#define ACC 3 // accented characters
+
+#define QCOPY 0 // Qubes OS VM to VM copy
+#define QPASTE 1 // Qubes OS VM to VM paste
+#define M_ACIRC 2 // â
+#define M_ECIRC 3 // ê
+#define M_ICIRC 4 // î
+#define M_OCIRC 5 // ô
+#define M_UCIRC 6 // û
+#define M_YCIRC 7 // ŷ
+#define M_AUMLT 8 // ä
+#define M_EUMLT 9 // ë
+#define M_IUMLT 10 // ï
+#define M_OUMLT 11 // ö
+#define M_UUMLT 12 // ü
+#define M_YUMLT 13 // ÿ
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+/* Keymap 0: Base Colemak Mod-DH layer
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * | Esc    |   1  |   2  |   3  |   4  |   5  |      |           |      |   6  |   7  |   8  |   9  |   0  |        |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * |        |   Q  |   W  |   F  |   P  |   B  | TO(0)|           |TO(2) |   J  |   L  |   U  |   Y  |   ;  |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * | Tab    |   A  |   R  |   S  |   T  |   G  |------|           |------|   M  |   N  |   E  |   I  |   O  | Bcksp  |
+ * |--------+------+------+------+------+------| TO(1)|           |OSL(3)|------+------+------+------+------+--------|
+ * | LShift |   Z  |   X  |   C  |   D  |   V  |      |           |      |   K  |   H  |   ,  |   .  |   :  | Rshift |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   | Ins  | Caps | Left | Right| MO(2)|                                       | MO(2)| Down |  Up  | PgDn | PgUp  |
+ *   `----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |QCopy | Ralt |       | Ralt |QPaste|
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      | Home |       | End  |      |      |
+ *                                 | Space| Ctrl |------|       |------| Ctrl |Enter |
+ *                                 |      |      | LAlt |       | LAlt |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+  // If it accepts an argument (i.e, is a function), it doesn't need KC_.
+// Otherwise, it needs KC_*
+[BASE] = KEYMAP(  // layer 0 : default
+        // left hand
+        KC_ESC,         KC_1,         KC_2,   KC_3,   KC_4,   KC_5,   KC_TRNS,
+        KC_TRNS,        FR_Q,         FR_W,   KC_F,   KC_P,   KC_B,   TO(BASE),
+        KC_TAB,         FR_A,         KC_R,   KC_S,   KC_T,   KC_G,
+        KC_LSFT,        FR_Z,         KC_X,   KC_C,   KC_D,   KC_V,   TO(SYMB),
+        KC_INS,         KC_CAPS,      KC_LEFT,KC_RIGHT, MO(SYMB),
+                                               M(QCOPY),          KC_RALT,
+                                                                  KC_HOME,
+                                               KC_SPC,KC_LCTRL,   KC_LALT,
+        // right hand
+        KC_TRNS,     KC_6,    KC_7,   KC_8,     KC_9,    KC_0,             KC_TRNS,
+        TO(MDIA),    KC_J,    KC_L,   KC_U,     KC_Y,    FR_SCLN,          KC_TRNS,
+                     FR_M,    KC_N,   KC_E,     KC_I,    KC_O,             KC_BSPC,
+        OSL(ACC),    KC_K,    KC_H,   FR_COMM,  FR_DOT,  FR_COLN,          KC_RSFT,
+        MO(SYMB),    KC_DOWN, KC_UP,  KC_PGDN,  KC_PGUP,
+
+        KC_RALT,        M(QPASTE),
+        KC_END,
+        KC_LALT,KC_RCTL, KC_ENT
+                  ),
+
+
+/* Keymap 1: Symbol Layer
+ * // TODO missing: ¤
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |Version |  F1  |  F2  |  F3  |  F4  |  F5  |      |           |      |  F6  |  F7  |  F8  |  F9  |  F10 |   F11  |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * |        |   §  |   <  |   {  |   \  |   ~  |      |           |      |   %  |   @  |   }  |  >   |  µ   |   F12  |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |   '  |   =  |   -  |   (  |   +  |------|           |------|   *  |   )  |   _  |  /   |   "  |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |   `  |   ?  |   #  |   [  |   |  |      |           |      |   &  |   ]  |   $  |   !  |   ^  |        |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   |   €  |   £  |   $  |      |      |                                       |      |      |      |   ß  |      |
+ *   `----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |      |      |       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       |      |      |      |
+ *                                 |      |      |------|       |------|      |      |
+ *                                 |      |      |      |       |      |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+// SYMBOLS
+[SYMB] = KEYMAP(
+       // left hand
+       M(0),   KC_F1,  KC_F2,  KC_F3,  KC_F4,  KC_F5,  KC_TRNS,
+       KC_TRNS,FR_SECT,FR_LESS,  FR_LCBR,FR_BSLS,FR_TILD,KC_TRNS,
+       KC_TRNS,FR_APOS,FR_EQL, FR_MINS,FR_LPRN,FR_PLUS,
+       KC_TRNS,FR_GRV,FR_QUES,FR_HASH,FR_LBRC,FR_PIPE,KC_TRNS,
+          FR_EURO,FR_PND,FR_DLR,KC_TRNS,KC_TRNS,
+                                       KC_TRNS,KC_TRNS,
+                                               KC_TRNS,
+                               KC_TRNS,KC_TRNS,KC_TRNS,
+       // right hand
+       KC_TRNS, KC_F6,   KC_F7,  KC_F8,   KC_F9,   KC_F10,  KC_F11,
+       KC_TRNS, FR_PERC, FR_AT,  FR_RCBR, FR_GRTR, FR_MU, KC_F12,
+                FR_ASTR,   FR_RPRN, FR_UNDS, FR_SLSH, FR_QUOT, KC_TRNS,
+       KC_TRNS, FR_AMP,  FR_RBRC, FR_DLR,  FR_EXLM,  FR_CIRC, KC_TRNS,
+                         KC_TRNS, KC_TRNS, KC_TRNS,  ALGR(KC_S),  KC_TRNS,
+       KC_TRNS, KC_TRNS,
+       KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_TRNS
+),
+/* Keymap 2: Media and mouse keys
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |        |      |      |      |      |      |      |           |      |      |      |      |      |      |        |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * |        |      |      | MsUp |      |      |      |           |      |      |      |      |      |      |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |      |MsLeft|MsDown|MsRght|      |------|           |------|      | Lclk | Rclk |      |      |  Play  |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |      |      |      |      |      |      |           |      |      |      | Prev | Next |      |        |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   |      |      |      | Lclk | Rclk |                                       |VolUp |VolDn | Mute |      |      |
+ *   `----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |      |      |       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       |      |      |Brwser|
+ *                                 |      |      |------|       |------|      |Back  |
+ *                                 |      |      |      |       |      |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+// MEDIA AND MOUSE
+[MDIA] = KEYMAP(
+       KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_TRNS, KC_MS_U, KC_TRNS, KC_TRNS, 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,
+       KC_TRNS, KC_TRNS, KC_TRNS, KC_BTN1, KC_BTN2,
+                                           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_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
+                 KC_TRNS, KC_BTN1, KC_BTN2, KC_TRNS, KC_TRNS, KC_MPLY,
+       KC_TRNS,  KC_TRNS, KC_TRNS, KC_MPRV, KC_MNXT, KC_TRNS, KC_TRNS,
+                          KC_VOLU, KC_VOLD, KC_MUTE, KC_TRNS, KC_TRNS,
+       KC_TRNS, KC_TRNS,
+       KC_TRNS,
+       KC_TRNS, KC_TRNS, KC_WBAK
+),
+
+/* Keymap 3: accented characters
+ *
+ * ,--------------------------------------------------.           ,--------------------------------------------------.
+ * |        |      |      |      |      |      |      |           |      |      |      |      |      |      |        |
+ * |--------+------+------+------+------+-------------|           |------+------+------+------+------+------+--------|
+ * |        |      |  à   |  â   |  ä   |      |      |           |      |      |      |  î   |  ï   |      |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |  é   |  è   |  ê   |  ë   |      |------|           |------|      |      |  ô   |  ö   |      |        |
+ * |--------+------+------+------+------+------|      |           |      |------+------+------+------+------+--------|
+ * |        |      |  ù   |  û   |  ü   |      |      |           |      |      |      |  ŷ   |  ÿ   |      |        |
+ * `--------+------+------+------+------+-------------'           `-------------+------+------+------+------+--------'
+ *   |      |      |      |      |      |                                       |      |      |      |      |      |
+ *   `----------------------------------'                                       `----------------------------------'
+ *                                        ,-------------.       ,-------------.
+ *                                        |      |      |       |      |      |
+ *                                 ,------|------|------|       |------+------+------.
+ *                                 |      |      |      |       |      |      |      |
+ *                                 |      |      |------|       |------|      |      |
+ *                                 |      |      |      |       |      |      |      |
+ *                                 `--------------------'       `--------------------'
+ */
+// ACCENTED CHARACTERS
+[ACC] = KEYMAP(
+       KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,     KC_TRNS,    KC_TRNS, KC_TRNS,
+
+       KC_TRNS, KC_TRNS, FR_AGRV, M(M_ACIRC),  M(M_AUMLT), KC_TRNS, KC_TRNS,
+       KC_TRNS, FR_EACU, FR_EGRV, M(M_ECIRC),  M(M_EUMLT), KC_TRNS,
+       KC_TRNS, KC_TRNS, FR_UGRV, M(M_UCIRC),  M(M_UUMLT), KC_TRNS, KC_TRNS,
+       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_TRNS, KC_TRNS, M(M_ICIRC), M(M_IUMLT), KC_TRNS, KC_TRNS,
+                 KC_TRNS, KC_TRNS, M(M_OCIRC), M(M_OUMLT), KC_TRNS, KC_TRNS,
+       KC_TRNS,  KC_TRNS, KC_TRNS, M(M_YCIRC), M(M_YUMLT), KC_TRNS, 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 uint16_t PROGMEM fn_actions[] = {
+    [1] = ACTION_LAYER_TAP_TOGGLE(SYMB)                // 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 QCOPY:
+    if (record->event.pressed) {
+      return MACRO(I(255),
+                   D(LCTRL),
+                   T(C),
+                   D(LSFT),
+                   T(C),
+                   U(LCTRL),
+                   U(LSFT),
+                   END);
+    }
+    break;
+  case QPASTE:
+    if (record->event.pressed) {
+      return MACRO(I(255),
+                   D(LCTRL),
+                   D(LSFT),
+                   T(V),
+                   U(LCTRL),
+                   T(INS),
+                   U(LSFT),
+                   END);
+    }
+    break;
+  case M_ACIRC:
+    if (record->event.pressed) {
+      return MACRO(T(LBRC), // FR_CIRC
+                   T(Q), // FR_A
+                   END);
+    }
+    break;
+  case M_ECIRC:
+    if (record->event.pressed) {
+      return MACRO(T(LBRC), // FR_CIRC
+                   T(E),
+                   END);
+    }
+    break;
+  case M_UCIRC:
+    if (record->event.pressed) {
+      return MACRO(T(LBRC), // FR_CIRC
+                   T(U),
+                   END);
+    }
+    break;
+  case M_ICIRC:
+    if (record->event.pressed) {
+      return MACRO(T(LBRC), // FR_CIRC
+                   T(I),
+                   END);
+    }
+    break;
+  case M_OCIRC:
+    if (record->event.pressed) {
+      return MACRO(T(LBRC), // FR_CIRC
+                   T(O),
+                   END);
+    }
+    break;
+  case M_YCIRC:
+    if (record->event.pressed) {
+      return MACRO(T(LBRC), // FR_CIRC
+                   T(Y),
+                   END);
+    }
+    break;
+  case M_AUMLT:
+    if (record->event.pressed) {
+      return MACRO(D(LSFT),
+                   T(LBRC),
+                   U(LSFT),
+                   T(Q),
+                   END);
+    }
+    break;
+  case M_EUMLT:
+    if (record->event.pressed) {
+      return MACRO(D(LSFT),
+                   T(LBRC),
+                   U(LSFT),
+                   T(E),
+                   END);
+    }
+    break;
+  case M_UUMLT:
+    if (record->event.pressed) {
+      return MACRO(D(LSFT),
+                   T(LBRC),
+                   U(LSFT),
+                   T(U),
+                   END);
+    }
+    break;
+  case M_IUMLT:
+    if (record->event.pressed) {
+      return MACRO(D(LSFT),
+                   T(LBRC),
+                   U(LSFT),
+                   T(I),
+                   END);
+    }
+    break;
+  case M_OUMLT:
+    if (record->event.pressed) {
+      return MACRO(D(LSFT),
+                   T(LBRC),
+                   U(LSFT),
+                   T(O),
+                   END);
+    }
+    break;
+  case M_YUMLT:
+    if (record->event.pressed) {
+      return MACRO(D(LSFT),
+                   T(LBRC),
+                   U(LSFT),
+                   T(Y),
+                   END);
+    }
+    break;
+
+  }
+  return MACRO_NONE;
+};
+
+// 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) {
+    case SYMB:
+      ergodox_right_led_1_on();
+      break;
+    case MDIA:
+      ergodox_right_led_2_on();
+      break;
+    case ACC:
+      ergodox_right_led_3_on();
+      break;
+    default:
+      // none
+      break;
+    }
+
+};

keyboards/ergodox/keymaps/french_hacker/readme.md

@@ -0,0 +1,30 @@
+# French hacker layout
+
+## Introduction
+
+[Colemak Mod-DH](https://colemakmods.github.io/mod-dh/) layout for
+users keeping an `azerty` layout configuration on their OS.
+
+This keymap is for users keeping their operating systems configured with
+`azerty` - for typing passwords or in their native languages - but who
+wants a Colemak Mod-DH layout on their mechanical.
+
+The symbols layers was done after analysing various programming
+languages sources codes and should be close to optimal for typing
+confort.
+
+Special macros for [Qubes OS](https://www.qubes-os.org/) are included.
+
+There is an accented characters layer for infrequent typing of french
+accents.
+
+Special macros for [Qubes OS](https://www.qubes-os.org/) are included.
+
+## Build
+
+    cd keyboards/ergodox
+    make french_hacker
+
+## Design explanations
+
+See my [blog post](http://dialectical-computing.de/blog/blog/2017/01/29/a-better-coder-layout-for-the-ergodox-ez-keyboard/).

keyboards/ergodox/keymaps/italian/keymap.c

@@ -165,20 +165,20 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
     return MACRO_NONE;
 };
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     // dynamically generate these.
     case EPRM:
       if (record->event.pressed) {
         eeconfig_init();
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case VRSN:
       if (record->event.pressed) {
         SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RGB_SLD:
       if (record->event.pressed) {
@@ -186,10 +186,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           rgblight_mode(1);
         #endif
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 // Runs just one time when the keyboard initializes.

keyboards/ergodox/keymaps/reset_eeprom/keymap.c

@@ -82,20 +82,20 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
     return MACRO_NONE;
 };
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     // dynamically generate these.
     case EPRM:
       if (record->event.pressed) {
         eeconfig_init();
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case VRSN:
       if (record->event.pressed) {
         SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RGB_SLD:
       if (record->event.pressed) {
@@ -103,10 +103,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           rgblight_mode(1);
         #endif
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 // Runs just one time when the keyboard initializes.

keyboards/ergodox/keymaps/robot_test_layout/keymap.c

@@ -62,7 +62,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 };
 
 bool status_led1_on = false, status_led2_on = false, status_led3_on = false;
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     // dynamically generate these.
     case RGB_FF0000:
@@ -72,7 +72,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           register_code(KC_1); unregister_code(KC_1);
         #endif
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RGB_00FF00:
       if (record->event.pressed) {
@@ -81,7 +81,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           register_code(KC_2); unregister_code(KC_2);
         #endif
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RGB_0000FF:
       if (record->event.pressed) {
@@ -90,7 +90,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           register_code(KC_3); unregister_code(KC_3);
         #endif
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RGB_FFFFFF:
       if (record->event.pressed) {
@@ -99,7 +99,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           register_code(KC_4); unregister_code(KC_4);
         #endif
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RGB_TOGGLE:
       if (record->event.pressed) {
@@ -108,7 +108,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           register_code(KC_EQL); unregister_code(KC_EQL);
         #endif
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case LED1:
       if (record->event.pressed) {
@@ -120,7 +120,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         status_led1_on = true;
         }
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case LED2:
       if (record->event.pressed) {
@@ -132,7 +132,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         status_led2_on = true;
         }
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case LED3:
       if (record->event.pressed) {
@@ -144,8 +144,8 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         status_led3_on = true;
         }
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }

keyboards/ergodox/keymaps/swedish/keymap.c

@@ -189,20 +189,20 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
     return MACRO_NONE;
 };
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     // dynamically generate these.
     case EPRM:
       if (record->event.pressed) {
         eeconfig_init();
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case VRSN:
       if (record->event.pressed) {
         SEND_STRING (QMK_KEYBOARD "/" QMK_KEYMAP " @ " QMK_VERSION);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RGB_SLD:
       if (record->event.pressed) {
@@ -210,10 +210,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           rgblight_mode(1);
         #endif
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 // Runs just one time when the keyboard initializes.

keyboards/frosty_flake/frosty_flake.c

@@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
     matrix_scan_user();
 }
 
-level_t process_kb(uint16_t keycode, keyrecord_t *record) {
+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 CONTINUE_PROCESSING;
+    return process_record_user(keycode, record);
 }
 
 void led_set_kb(uint8_t usb_led) {
@@ -54,8 +54,8 @@ void matrix_scan_user(void) {
 }
 
 __attribute__ ((weak))
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
-  return CONTINUE_PROCESSING;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
 }
 
 __attribute__ ((weak))

keyboards/gherkin/keymaps/default/keymap.c

@@ -132,8 +132,8 @@ void matrix_init_user(void) {
 void matrix_scan_user(void) {
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
-	return CONTINUE_PROCESSING;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	return true;
 }
 
 void led_set_user(uint8_t usb_led) {

keyboards/hadron/hadron.c

@@ -12,11 +12,11 @@ void matrix_scan_kb(void) {
 	matrix_scan_user();
 }
 
-level_t process_kb(uint16_t keycode, keyrecord_t *record) {
+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 CONTINUE_PROCESSING;
+	return process_record_user(keycode, record);
 }
 
 void led_set_kb(uint8_t usb_led) {

keyboards/hadron/keymaps/default/keymap.c

@@ -250,7 +250,7 @@ void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
   }
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case QWERTY:
       if (record->event.pressed) {
@@ -259,7 +259,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         #endif
         persistant_default_layer_set(1UL<<_QWERTY);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case COLEMAK:
       if (record->event.pressed) {
@@ -268,7 +268,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         #endif
         persistant_default_layer_set(1UL<<_COLEMAK);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case LOWER:
       if (record->event.pressed) {
@@ -291,7 +291,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_LOWER);
         update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RAISE:
       if (record->event.pressed) {
@@ -314,7 +314,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         TOG_STATUS = false;
         update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case BACKLIT:
       if (record->event.pressed) {
@@ -325,7 +325,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
       } else {
         unregister_code(KC_RSFT);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RGB_MOD:
       //led operations - RGB mode change now updates the RGB_current_mode to allow the right RGB mode to be set after reactive keys are released
@@ -334,10 +334,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         rgblight_step();
         RGB_current_mode = rgblight_config.mode;
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 void matrix_init_user(void) {

keyboards/hadron/keymaps/side_numpad/keymap.c

@@ -252,7 +252,7 @@ void update_tri_layer_RGB(uint8_t layer1, uint8_t layer2, uint8_t layer3) {
   }
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case QWERTY:
       if (record->event.pressed) {
@@ -261,7 +261,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         #endif
         persistant_default_layer_set(1UL<<_QWERTY);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case LOWER:
       if (record->event.pressed) {
@@ -284,7 +284,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_LOWER);
         update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RAISE:
       if (record->event.pressed) {
@@ -307,7 +307,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         TOG_STATUS = false;
         update_tri_layer_RGB(_LOWER, _RAISE, _ADJUST);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case BACKLIT:
       if (record->event.pressed) {
@@ -318,7 +318,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
       } else {
         unregister_code(KC_RSFT);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
       //my attempt for RGB layer lock indication via changing the mode, still have to figure out how to not have other keypress not override this mode
     case TG_NUMLAY:
@@ -335,7 +335,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         rgblight_mode(RGB_current_mode);  
         layer_off(_NUMLAY); }
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RGB_MOD:
       //led operations - RGB mode change now updates the RGB_current_mode to allow the right RGB mode to be set after reactive keys are released
@@ -344,10 +344,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         rgblight_step();
         RGB_current_mode = rgblight_config.mode;
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 void matrix_init_user(void) {

keyboards/handwired/MS_sculpt_mobile/keymaps/default/keymap.c

@@ -55,8 +55,8 @@ void matrix_scan_user(void) {
 
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
-  return CONTINUE_PROCESSING;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
 }
 
 void led_set_user(uint8_t usb_led) {

keyboards/handwired/MS_sculpt_mobile/keymaps/milestogo/keymap.c

@@ -150,7 +150,7 @@ float tone_colemak[][2]    = SONG(COLEMAK_SOUND);
 #endif
 
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case QWR:
       if (record->event.pressed) {
@@ -159,7 +159,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         #endif
         layer_off(_CDH);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
       
     case CDH:
@@ -169,7 +169,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         #endif
         layer_on(_CDH);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
       
     case SYM:
@@ -178,11 +178,11 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
       } else {
 		layer_off(_SYM);
       }
-     return STOP_PROCESSING;
+     return false;
      break;
      
    }
- return CONTINUE_PROCESSING;
+ return true;
 
 }
  

keyboards/handwired/atreus50/keymaps/default/keymap.c

@@ -152,7 +152,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
   default_layer_set(default_layer);
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
         case QWERTY:
           if (record->event.pressed) {
@@ -161,7 +161,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             #endif
             persistent_default_layer_set(1UL<<_QWERTY);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case COLEMAK:
           if (record->event.pressed) {
@@ -170,7 +170,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             #endif
             persistent_default_layer_set(1UL<<_COLEMAK);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case DVORAK:
           if (record->event.pressed) {
@@ -179,7 +179,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             #endif
             persistent_default_layer_set(1UL<<_DVORAK);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case LOWER:
           if (record->event.pressed) {
@@ -189,7 +189,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             layer_off(_LOWER);
             update_tri_layer(_LOWER, _RAISE, _ADJUST);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case RAISE:
           if (record->event.pressed) {
@@ -199,7 +199,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             layer_off(_RAISE);
             update_tri_layer(_LOWER, _RAISE, _ADJUST);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case BACKLIT:
           if (record->event.pressed) {
@@ -210,10 +210,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           } else {
             unregister_code(KC_RSFT);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
       }
-    return CONTINUE_PROCESSING;
+    return true;
 };
 
 void matrix_init_user(void) {

keyboards/handwired/atreus50/rules.mk

@@ -67,15 +67,3 @@ RGBLIGHT_ENABLE = no        # Enable WS2812 RGB underlight.  Do not enable this
 
 # Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
 SLEEP_LED_ENABLE = no    # Breathing sleep LED during USB suspend
-
-avrdude: build
-	ls /dev/tty* > /tmp/1; \
-	echo "Reset your Pro Micro now"; \
-	while [[ -z $$USB ]]; do \
-	  sleep 1; \
-	  ls /dev/tty* > /tmp/2; \
-	  USB=`diff /tmp/1 /tmp/2 | grep -o '/dev/tty.*'`; \
-	done; \
-	avrdude -p $(MCU) -c avr109 -P $$USB -U flash:w:$(BUILD_DIR)/$(TARGET).hex
-
-.PHONY: avrdude

keyboards/handwired/frenchdev/keymaps/default/keymap.c

@@ -393,8 +393,8 @@ void matrix_scan_user(void) {
 }
 
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
-  return CONTINUE_PROCESSING;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
 }
 
 void led_set_user(uint8_t usb_led) {

keyboards/handwired/gamenum/keymaps/default/keymap.c

@@ -45,7 +45,7 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 };
 
 
-level_t process_user (uint16_t keycode, keyrecord_t *record) {
+bool process_record_user (uint16_t keycode, keyrecord_t *record) {
   switch(keycode) {
   case KC_FN0:
       if (record->event.pressed) {
@@ -64,5 +64,5 @@ level_t process_user (uint16_t keycode, keyrecord_t *record) {
      }
      break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }

keyboards/handwired/kbod/kbod.c

@@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
 	matrix_scan_user();
 }
 
-level_t process_kb(uint16_t keycode, keyrecord_t *record) {
+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 CONTINUE_PROCESSING;
+	return process_record_user(keycode, record);
 }
 
 void led_set_kb(uint8_t usb_led) {

keyboards/handwired/magicforce61/rules.mk

@@ -69,15 +69,3 @@ AUDIO_ENABLE ?= no           # Audio output on port C6
 ifndef QUANTUM_DIR
 	include ../../../Makefile
 endif
-
-avrdude: build
-	ls /dev/tty* > /tmp/1; \
-	echo "Reset your Pro Micro now"; \
-	while [[ -z $$USB ]]; do \
-	  sleep 1; \
-	  ls /dev/tty* > /tmp/2; \
-	  USB=`diff /tmp/1 /tmp/2 | grep -o '/dev/tty.*'`; \
-	done; \
-	avrdude -p $(MCU) -c avr109 -P $$USB -U flash:w:$(BUILD_DIR)/$(TARGET).hex
-
-.PHONY: avrdude

keyboards/handwired/magicforce68/rules.mk

@@ -69,15 +69,3 @@ AUDIO_ENABLE = no           # Audio output on port C6
 ifndef QUANTUM_DIR
 	include ../../../Makefile
 endif
-
-avrdude: build
-	ls /dev/tty* > /tmp/1; \
-	echo "Reset your Pro Micro now"; \
-	while [[ -z $$USB ]]; do \
-	  sleep 1; \
-	  ls /dev/tty* > /tmp/2; \
-	  USB=`diff /tmp/1 /tmp/2 | grep -o '/dev/tty.*'`; \
-	done; \
-	avrdude -p $(MCU) -c avr109 -P $$USB -U flash:w:$(BUILD_DIR)/$(TARGET).hex
-
-.PHONY: avrdude

keyboards/handwired/numpad20/rules.mk

@@ -69,15 +69,3 @@ AUDIO_ENABLE = no           # Audio output on port C6
 ifndef QUANTUM_DIR
 	include ../../../Makefile
 endif
-
-avrdude: build
-	ls /dev/tty* > /tmp/1; \
-	echo "Reset your Pro Micro now"; \
-	while [[ -z $$USB ]]; do \
-	  sleep 1; \
-	  ls /dev/tty* > /tmp/2; \
-	  USB=`diff /tmp/1 /tmp/2 | grep -o '/dev/tty.*'`; \
-	done; \
-	avrdude -p $(MCU) -c avr109 -P $$USB -U flash:w:$(BUILD_DIR)/$(TARGET).hex
-
-.PHONY: avrdude

keyboards/handwired/ortho5x13/keymaps/default/keymap.c

@@ -191,7 +191,7 @@ void persistent_default_layer_set(uint16_t default_layer) {
   default_layer_set(default_layer);
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
         case QWERTY:
           if (record->event.pressed) {
@@ -200,7 +200,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             #endif
             persistent_default_layer_set(1UL<<_QWERTY);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case COLEMAK:
           if (record->event.pressed) {
@@ -209,7 +209,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             #endif
             persistent_default_layer_set(1UL<<_COLEMAK);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case DVORAK:
           if (record->event.pressed) {
@@ -218,7 +218,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             #endif
             persistent_default_layer_set(1UL<<_DVORAK);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case LOWER:
           if (record->event.pressed) {
@@ -228,7 +228,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             layer_off(_LOWER);
             update_tri_layer(_LOWER, _RAISE, _ADJUST);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case RAISE:
           if (record->event.pressed) {
@@ -238,7 +238,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
             layer_off(_RAISE);
             update_tri_layer(_LOWER, _RAISE, _ADJUST);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
         case BACKLIT:
           if (record->event.pressed) {
@@ -249,10 +249,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           } else {
             unregister_code(KC_RSFT);
           }
-          return STOP_PROCESSING;
+          return false;
           break;
       }
-    return CONTINUE_PROCESSING;
+    return true;
 };
 
 void matrix_init_user(void) {

keyboards/handwired/ortho5x13/rules.mk

@@ -69,15 +69,3 @@ AUDIO_ENABLE = no           # Audio output on port C6
 ifndef QUANTUM_DIR
 	include ../../../Makefile
 endif
-
-avrdude: build
-	ls /dev/tty* > /tmp/1; \
-	echo "Reset your Pro Micro now"; \
-	while [[ -z $$USB ]]; do \
-	  sleep 1; \
-	  ls /dev/tty* > /tmp/2; \
-	  USB=`diff /tmp/1 /tmp/2 | grep -o '/dev/tty.*'`; \
-	done; \
-	avrdude -p $(MCU) -c avr109 -P $$USB -U flash:w:$(BUILD_DIR)/$(TARGET).hex
-
-.PHONY: avrdude

keyboards/handwired/pilcrow/keymaps/default/keymap.c

@@ -79,8 +79,8 @@ void matrix_scan_user(void) {
 
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
-  return CONTINUE_PROCESSING;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
 }
 
 void led_set_user(uint8_t usb_led) {

keyboards/handwired/pilcrow/pilcrow.c

@@ -14,11 +14,11 @@ void matrix_scan_kb(void) {
 	matrix_scan_user();
 }
 
-level_t process_kb(uint16_t keycode, keyrecord_t *record) {
+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 CONTINUE_PROCESSING;
+	return process_record_user(keycode, record);
 }
 
 void led_set_kb(uint8_t usb_led) {

keyboards/handwired/promethium/keymaps/priyadi/keymap.c

@@ -1012,7 +1012,7 @@ uint32_t layer_state_set_kb(uint32_t state)
   return state;
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   static bool lshift = false;
   static bool rshift = false;
   static uint8_t layer = 0;
@@ -1059,11 +1059,11 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
     // double-space enter space layer
     case LSPACE:
       process_doublespace(record->event.pressed, &lspace_active, &rspace_active, &lspace_emitted);
-      return STOP_PROCESSING;
+      return false;
       break;
     case RSPACE:
       process_doublespace(record->event.pressed, &rspace_active, &lspace_active, &rspace_emitted);
-      return STOP_PROCESSING;
+      return false;
       break;
 #endif
 
@@ -1116,7 +1116,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           unregister_code(KC_COMM);
         }
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case KC_DOT:
       if (record->event.pressed) {
@@ -1128,7 +1128,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           unregister_code(KC_DOT);
         }
       }
-      return STOP_PROCESSING;
+      return false;
       break;
 
     // layout switchers
@@ -1136,14 +1136,14 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<_QWERTY);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
 #ifdef LAYOUT_DVORAK
     case DVORAK:
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<_DVORAK);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
 #endif
 #ifdef LAYOUT_COLEMAK
@@ -1151,7 +1151,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<_COLEMAK);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
 #endif
 #ifdef LAYOUT_WORKMAN
@@ -1159,7 +1159,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<_WORKMAN);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
 #endif
 #ifdef LAYOUT_NORMAN
@@ -1167,7 +1167,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<_NORMAN);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
 #endif
 
@@ -1181,7 +1181,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
           register_code(keycode);
           unregister_code(keycode);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
 
     // layer switcher
@@ -1199,7 +1199,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_GREEKU);
         layer_off(_GREEKL);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
 
     // OS switchers
@@ -1208,21 +1208,21 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
 #ifdef RGBSPS_ENABLE
       led_set_unicode_input_mode();
 #endif
-      return STOP_PROCESSING;
+      return false;
       break;
     case WIN:
       set_unicode_input_mode(UC_WINC);
 #ifdef RGBSPS_ENABLE
       led_set_unicode_input_mode();
 #endif
-      return STOP_PROCESSING;
+      return false;
       break;
     case OSX:
       set_unicode_input_mode(UC_OSX);
 #ifdef RGBSPS_ENABLE
       led_set_unicode_input_mode();
 #endif
-      return STOP_PROCESSING;
+      return false;
       break;
 
     // glow mode changer
@@ -1236,7 +1236,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         led_reset();
         rgbsps_send();
       }
-      return STOP_PROCESSING;
+      return false;
       break;
 #endif
 
@@ -1258,11 +1258,11 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
 #ifdef RGBSPS_DEMO_ENABLE
     case RGBDEMO:
       led_demo();
-      return STOP_PROCESSING;
+      return false;
       break;
 #endif
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 void set_output_user(uint8_t output) {

keyboards/handwired/traveller/keymaps/default/keymap.c

@@ -294,8 +294,8 @@ void matrix_scan_user(void) {
 }
 
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
-  return CONTINUE_PROCESSING;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
 }
 
 void led_set_user(uint8_t usb_led) {

keyboards/handwired/traveller/traveller.c

@@ -45,11 +45,11 @@ void matrix_scan_kb(void) {
 	matrix_scan_user();
 }
 
-level_t process_kb(uint16_t keycode, keyrecord_t *record) {
+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 CONTINUE_PROCESSING;
+	return process_record_user(keycode, record);
 }
 
 void led_set_kb(uint8_t usb_led) {

keyboards/hhkb/keymaps/cinaeco/keymap.c

@@ -178,9 +178,9 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
 };
 
 // For Dynamic Macros.
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   if (!process_record_dynamic_macro(keycode, record)) {
-    return STOP_PROCESSING;
+    return false;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }

keyboards/hhkb/keymaps/smt/keymap.c

@@ -151,26 +151,26 @@ void persistent_default_layer_set(uint16_t default_layer) {
   default_layer_set(default_layer);
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case QWERTY:
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<_QWERTY);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case COLEMAK:
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<_COLEMAK);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case DVORAK:
       if (record->event.pressed) {
         persistent_default_layer_set(1UL<<_DVORAK);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }

keyboards/infinity60/keymaps/jpetermans/keymap.c

@@ -241,8 +241,8 @@ const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
 };
 
 
-level_t process_user (uint16_t keycode, keyrecord_t *record) {
-  return CONTINUE_PROCESSING;
+bool process_record_user (uint16_t keycode, keyrecord_t *record) {
+  return true;
 }
 
 // Runs just one time when the keyboard initializes.

keyboards/jd45/keymaps/blakedietz/keymap.c

@@ -251,13 +251,13 @@ void persistant_default_layer_set(uint16_t default_layer) {
   default_layer_set(default_layer);
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case QWERTY:
       if (record->event.pressed) {
         default_layer_set(1UL<<_QWERTY);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case LOWER:
       if (record->event.pressed) {
@@ -267,7 +267,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_LOWER);
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RAISE:
       if (record->event.pressed) {
@@ -277,10 +277,10 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_RAISE);
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 /*

keyboards/jd45/keymaps/jeebak/keymap.c

@@ -288,25 +288,25 @@ void persistent_default_layer_set(uint16_t default_layer) {
   default_layer_set(default_layer);
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
   switch (keycode) {
     case QWERTY:
       if (record->event.pressed) {
         default_layer_set(1UL<<_QWERTY);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case COLEMAK:
       if (record->event.pressed) {
         default_layer_set(1UL<<_COLEMAK);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case DVORAK:
       if (record->event.pressed) {
         default_layer_set(1UL<<_DVORAK);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case LOWER:
       if (record->event.pressed) {
@@ -316,7 +316,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_LOWER);
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case RAISE:
       if (record->event.pressed) {
@@ -326,7 +326,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         layer_off(_RAISE);
         update_tri_layer(_LOWER, _RAISE, _ADJUST);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case BACKLIT:
       if (record->event.pressed) {
@@ -337,7 +337,7 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
       } else {
         unregister_code(KC_RSFT);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case PLOVER:
       if (record->event.pressed) {
@@ -352,16 +352,16 @@ level_t process_user(uint16_t keycode, keyrecord_t *record) {
         keymap_config.nkro = 1;
         eeconfig_update_keymap(keymap_config.raw);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
     case EXT_PLV:
       if (record->event.pressed) {
         layer_off(_PLOVER);
       }
-      return STOP_PROCESSING;
+      return false;
       break;
   }
-  return CONTINUE_PROCESSING;
+  return true;
 }
 
 /*

keyboards/kbd75/keymaps/default/keymap.c

@@ -147,8 +147,8 @@ void matrix_init_user(void) {
 void matrix_scan_user(void) {
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
-	return CONTINUE_PROCESSING;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+	return true;
 }
 
 void led_set_user(uint8_t usb_led) {

keyboards/kc60/keymaps/mechmerlin/keymap.c

@@ -0,0 +1,61 @@
+// This is the 60% layout preferred by u/merlin36 the host of the MechMerlin YouTube channel.
+// The layout is highly influenced by the WKL B.Face and KBP V60 standard layouts.
+// Layout designed for use on KC60 with no inswitch or underglow lighting. 
+
+#include "kc60.h"
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+  [0] = KEYMAP( /* Basic QWERTY */
+      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_NO,    KC_ENT,   \
+      KC_LSFT,  KC_NO,    KC_Z,     KC_X,    KC_C,     KC_V,     KC_B,     KC_N,    KC_M,  KC_COMM,  KC_DOT,   KC_SLSH,  KC_NO,    KC_RSFT,  \
+      KC_LCTL,  KC_LGUI,  KC_LALT,                     KC_SPC,                             KC_NO,    MO(2),    KC_RALT,  KC_RGUI,  KC_RCTL \
+      ),
+  [1] = KEYMAP( /* HHKB-ish Base Layout */
+      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_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_DEL,  \
+      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_NO,    KC_ENT,   \
+      KC_LSFT,  KC_NO,    KC_Z,     KC_X,    KC_C,     KC_V,     KC_B,     KC_N,    KC_M,  KC_COMM,  KC_DOT,   KC_SLSH,  KC_NO,    KC_RSFT,  \
+      KC_LCTL,  KC_LGUI,  KC_LALT,                     KC_SPC,                             KC_NO,    MO(3),    KC_RALT,  KC_RGUI,  KC_RCTL \
+      ),
+  [2] = KEYMAP( /* FN Layer 1 - Basic QWERTY */
+      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_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,  RESET,     KC_TRNS,   KC_TRNS,   KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS,  KC_TRNS,  \
+      KC_CAPS,  KC_TRNS,   KC_TRNS,   KC_TRNS,  KC_TRNS,   KC_TRNS,   TO(1),     KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_NO,    KC_TRNS, \
+      KC_TRNS,  KC_NO,     KC_TRNS,   KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,  KC_MUTE,  KC_VOLD,   KC_VOLU,    KC_TRNS,  KC_NO,    KC_PGUP,  \
+      KC_TRNS,  KC_TRNS,   KC_TRNS,                        TG(4),                          KC_NO,    KC_TRNS,   KC_HOME,    KC_PGDN,  KC_END \
+      ),
+  [3] = KEYMAP( /* FN Layer 2 - HHKB-ish Base Layout */
+      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_INS,  \
+      KC_CAPS,  KC_TRNS,   KC_TRNS,   KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,  KC_TRNS,  KC_TRNS,   KC_TRNS,    KC_UP,    KC_TRNS,  KC_BSPC,  \
+      KC_TRNS,  KC_VOLD,   KC_VOLU,   KC_MUTE,  KC_TRNS,   KC_TRNS,   TO(0),     KC_TRNS,  KC_HOME,  KC_PGUP,   KC_LEFT,    KC_RIGHT, KC_NO,    KC_TRNS, \
+      KC_TRNS,  KC_NO,     KC_TRNS,   KC_TRNS,  KC_TRNS,   KC_TRNS,   KC_TRNS,   KC_TRNS,  KC_TRNS,  KC_END,    KC_PGDN,    KC_DOWN,  KC_NO,    KC_TRNS,  \
+      KC_TRNS,  KC_TRNS,   KC_TRNS,                        KC_TRNS,                        KC_NO,    KC_TRNS,   KC_TRNS,    KC_TRNS,  KC_TRNS \
+      ),
+  [4] = KEYMAP( /* Arrow Layers - Basic QWERTY ONLY */
+      KC_TRNS,   KC_TRNS,    KC_TRNS,     KC_TRNS,    KC_TRNS,     KC_TRNS,     KC_TRNS,     KC_TRNS,    KC_TRNS,  KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_TRNS,  KC_TRNS,  \
+      KC_TRNS,   KC_TRNS,    KC_TRNS,     KC_TRNS,    KC_TRNS,     KC_TRNS,     KC_TRNS,     KC_TRNS,    KC_TRNS,  KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_TRNS,  KC_TRNS,  \
+      KC_TRNS,   KC_TRNS,    KC_TRNS,     KC_TRNS,    KC_TRNS,     KC_TRNS,     KC_TRNS,     KC_TRNS,    KC_TRNS,  KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_NO,    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_NO,    KC_UP,  \
+      KC_TRNS,   KC_TRNS,    KC_TRNS,                              KC_TRNS,                              KC_NO,    KC_TRNS,    KC_LEFT,   KC_DOWN,  KC_RIGHT \
+      ),
+  [5] = KEYMAP( /* Blank Layer for later usage */
+      KC_TRNS,   KC_TRNS,    KC_TRNS,     KC_TRNS,    KC_TRNS,     KC_TRNS,     KC_TRNS,     KC_TRNS,    KC_TRNS,  KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_TRNS,  KC_TRNS,  \
+      KC_TRNS,   KC_TRNS,    KC_TRNS,     KC_TRNS,    KC_TRNS,     KC_TRNS,     KC_TRNS,     KC_TRNS,    KC_TRNS,  KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_TRNS,  KC_TRNS,  \
+      KC_TRNS,   KC_TRNS,    KC_TRNS,     KC_TRNS,    KC_TRNS,     KC_TRNS,     KC_TRNS,     KC_TRNS,    KC_TRNS,  KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_NO,    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_NO,    KC_TRNS,  \
+      KC_TRNS,   KC_TRNS,    KC_TRNS,                              KC_TRNS,                              KC_NO,    KC_TRNS,    KC_TRNS,   KC_TRNS,  KC_TRNS \
+      ),
+
+};
+
+const uint16_t PROGMEM fn_actions[] = {
+
+};
+
+const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt)
+{
+  // MACRODOWN only works in this function
+  return MACRO_NONE;
+};

keyboards/kc60/keymaps/mechmerlin/readme.md

@@ -0,0 +1,20 @@
+MechMerlin's KC60 Layout
+======================
+
+This is the 60% layout used by u/merlin36, host of the MechMerlin YouTube channel.
+It has 5 layers, base QWERTY, base HHKB, FN 1, FN 2(HHKB), and an arrows only layer.
+
+Merlin's KC60 was acquired from Massdrop: https://www.massdrop.com/buy/kc60-mechanical-keyboard and is the Co-Star stabilizer version
+
+If you would like to program your KC60 using the manufacturer recommended approach, please follow the guide on keychatter: https://www.keychatter.com/2015/07/05/programming-the-kc60/.
+
+## Keymap Notes
+- Highly influenced by the KBP V60 and WKL B.Face standard layouts
+- Does not support any form of inswitch or underglow lighting as Merlin hates them.
+- Arrow toggle switch is FN + Space
+- Reset is FN + R
+- HHKB keymap is approximate as keyboard is not built like HHKB
+
+
+### Build
+To build this keymap, simply run `make KEYMAP=mechmerlin`.

keyboards/kinesis/alvicstep/alvicstep.c

@@ -78,11 +78,11 @@ void matrix_scan_kb(void) {
 	matrix_scan_user();
 }
 
-level_t process_kb(uint16_t keycode, keyrecord_t *record) {
+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 CONTINUE_PROCESSING;
+	return process_record_user(keycode, record);
 }
 
 void led_set_kb(uint8_t usb_led) {

keyboards/kinesis/keymaps/default/keymap.c

@@ -81,8 +81,8 @@ void matrix_scan_user(void) {
 
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
-  return CONTINUE_PROCESSING;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
 }
 
 void led_set_user(uint8_t usb_led) {

keyboards/kinesis/keymaps/dvorak/keymap.c

@@ -84,8 +84,8 @@ void matrix_scan_user(void) {
 
 }
 
-level_t process_user(uint16_t keycode, keyrecord_t *record) {
-  return CONTINUE_PROCESSING;
+bool process_record_user(uint16_t keycode, keyrecord_t *record) {
+  return true;
 }
 
 void led_set_user(uint8_t usb_led) {