Razer Orbweaver Chroma MCU mod

[a_marmot]

Hey all, I just completed a mod of a Razer Orbweaver Chroma, replacing the stock controller with a RP2040 and QMK.  It allows the device to have multiple programmable key layers with permanent OS-independent on-board memory (no Razer software needed to control the keymap or RGB). New switches and keycaps as well. The following posts break down the mod into sections, with step by step instructions, a component buylist, and QMK resources to program the controller. Continuously updated as I tinker with the best way to do the mod. Enjoy.

[suicidal_orange]

This is the perfect place to post the instructions - great mod! 

[a_marmot]

1) First, why the mod? 

There are basically two issues.  The first is that the Orbweaver (as well as other Razer products) lack on-board memory.  So you are dependent on Razer's software to operate the device. This is particularly challenging when working across multiple platforms (PC, mac, linux), all of which need their own system extensions, and a connection to Razer cloud for keyboard profiles.  The second (and maybe more serious) problem is that Razer does not reliably support their products. The software is generally buggy, they do not update the software for older products, and they have essentially abandoned macOS, making the device useless except for PC.

In contrast, I have had great experience with Logitech G502 and Wooting 60HE, both of which have onboard memories, allowing the devices to operate without system extensions.  Of course these devices still have software to program them.  But once they are programmed (in any OS), they can work across platforms without ongoing need of software support or a cloud connection.

So basically my objective with this mod was to replace the stock Razer MCU with my own Raspberry Elite-Pi RP2040 microcontroller running QMK.

[a_marmot]

2) What makes the mod possible?

Most companies use custom integrated PCBs with proprietary OEM components.  Had Razer done that in this case, the mod would be impossible, since access to the key matrix and RGB LEDs would require tapping into traces on the PCB.  Maybe that's possible, but certainly beyond my limited abilities! 

However, in the case of the Orbweaver Chroma, Razer (luckily) didn't do that.  Instead they used 3 separate PCBs, one for the proprietary MCU, another hosting the keyboard and RGB diode matrixes, and a third with the thumb pad key matrix. They also used a stock RGB LED matrix controller (IS31FL3731) for the LEDs, which they placed on the same PCB as the keyboard. These satellite boards communicate with the MCU through an 18-pin ribbon connector and an 8-pin JST connector.  In other words, all the components we would need for a hand-wired keyboard, thumb pad, and RGB matrix are conveniently provided by Razer!  All we have to do is tap into them with our own MCU. 

The image below summarizes the wiring on the two satellite boards (which I traced using a Fluke multimeter and/or oscilloscope). The keyboard PCB has a 18-pin ribbon connector (R1~R18), which provides direct access to the 4 rows (R17, R16, R15, R14) and 5 columns (R13, R12, R11, R10, R9) of the keyboard diode matrix.  This ribbon also hosts a I2C serial interface (R2, R3 = SDA, SCL) for communication with the IS31 RGB matrix controller (which independently controls the RGB LED matrix). The keyboard also requires 5V, GND (R4, R1) and 3.3V (R8) for the I2C pull-up resistors (which are also conveniently provided on the PCB!). The thumb pad PCB has a 8-pin JST connector (J1~J8), providing access to two additional rows of dioded keys: J2 (ALT, LEFT, RIGHT, DOWN, UP) and J3 (Spacebar, null, null, null, null). These keys share the same columns as the main keyboard on lines J4, J5, J6, J7, and J8. Thus it is possible to add up to 4 additional buttons without adding additional rows or columns to the overall 6 row x 5 column key matrix.

[a_marmot]

3) What will you need.

Tools:

• Fine screwdrivers and spudger for disassembly/reassembly of the Orbweaver.
• Soldering iron
• Solder sucker (probably a desoldering gun if you plan to replace the key switches!).
• Scroll saw or other means to cut out a section of a standard PCB breadboard.
• Cutting tools for plastic (razor blade, x-acto knife, wire dykes).
• Fine file for smoothing/rounding edges of PCBs.
• Epoxy, ideally Scotch Weld 2216.

Parts:

• Raspberry Elite-Pi RP2040. I got one from Keebio (https://keeb.io/collections/diy-parts/products/elite-pi-usb-c-pro-micro-replacement-rp2040). This version of the RP2040 has the perfect form factor for this mod, as it is short enough to fit sideways below the keyboard with USB-C port aligned with the existing hole for a USB cable.
• 18-pin 0.5 mm ribbon breakout board: (https://www.amazon.com/dp/B09VPKGF7L)
• 8-pin JST connector and wire leads. You can make up your own, or buy pre-crimped (https://www.amazon.com/dp/B09F3TMG52). Alternatively you can just tap the appropriate wires from the 14 pin JST running from the thumb assembly to the main unit.
• 8 rows x 4 terminal section of solder breadboard (https://www.amazon.com/dp/B081MSKJJX). I used a scroll saw to cut out the 8x4 section.  But you could probably also score and break the board as needed. Space is tight, so you want to remove as much unused board as possible. 
• Optional: new MX-style switches. Get ones with alignment pins since the switches are soldered directly to the keyboard PCB (there is no plate). I prefer linear switches like the Gateron yellows (https://www.amazon.com/dp/B0BBPPP7HD)
• Optional: supply of 4-pin R-C-B-G common-anode diodes (https://www.ebay.com/itm/323454847919). To replace the key switches you must first desolder the LEDs. It is easier to replace them than to resolder used LEDs.  In principle you could use R-C-G-B (the more common configuration), but would need to switch blue and green in QMK software.
• Optional. I added an extra switch to the side of the Orbweaver for cycling keyboard profiles. As shown below I used an arcade microswitch and diode: (https://www.amazon.com/dp/B074868HZV, https://keeb.io/collections/diy-parts/products/1n4148-diodes). To actuate the switch I used a black plastic button removed from a PCB tactile switch (https://www.amazon.com/dp/B0722LBKV7).
• Optional: If you can get a hold of an original monochrome green Orbweaver, it shares the same frame as the Chroma, but the top piece is made of black molded plastic instead of white plastic with black paint.  This makes it much easier to remove webbing for a keycap replacement.  It's also a great source of spare parts in case you lose any from your Chroma. 

[a_marmot]

4) Disassembly.

It's a pain to take an Orbweaver apart. There are lots of interconnected pieces that are hard to disassemble in a clear step by step process. The following geekhack post has lots of pictures: https://geekhack.org/index.php?topic=48771.0  I also found the following Youtube videos very useful:

Schematix:

Tuffrabit:

General advice:

• Be patient, take your time, and don't try to force anything.
• There are two ball bearings with springs used for the adjustable pads. These can (and will) go flying!  So you may wish to do the initial disassembly in a contained area like a dry bucket until you know where those components are and can make arrangements to extract or contain them. Some discussion about the ball bearings can be found here: https://geekhack.org/index.php?topic=48771.0
• Keep the pieces organized for later reassembly. I used a sheet of clean clear polypropylene to store the sticky pads. 
• When removing the keyboard PCB, be very careful not to break the ABS plastic tabs that hold it down.  They are not very flexible, and break easily.
• The cosmetic sticker on the thumb pad must be removed to get the thumb assembly apart. I gave up on trying to save it. But YMMV.

[a_marmot]

5) Modifying the plastic parts.

To make room for the RP2040 and ribbon breakout board, you'll need to remove some of the ABS plastic on the bottom tray.  To accomplish this I used a combination of tools including wire dykes, x-acto chisel, and razor blade. The pictures below show before and after images of the tray, pointing out in RED where the plastic must be cut. The rightmost picture shows where the new components will go. In order to fit, the corner of the RP2040 board must be rounded slightly with a file (2 millimeters). But leave enough material to support the USB housing. Note the upside-down placement of the ribbon breakout board - this is the orientation it will have when connected to the keyboard above it by a folded (but not twisted) ribbon cable.  Also note the 1cm wide section of plastic removed from the fin separating the MCU and breakout board - this is needed for the wire bundles running between the MCU and the breakout board.

Also shown is the placement of the (optional) lever microswitch, used as a dedicated mode toggle. It also plays a secondary role in confining the RP2040 to a fitted rectangular area, making it MUCH easier to secure in place, and more resistant to movement when the USB cable is plugged-in an un-plugged.

[a_marmot]

6) Wiring.

Shown below is a wiring diagram for the mod.  The terminals marked "GPX" refer to the terminal position on the microcontroller (this is the nomenclature used by QMK - in the RP2040 documentation they are marked as "DX": https://docs.keeb.io/elite-pi-guide?utm_source=store).  GP 2, 3 are SDA and SCL for the I2C. GP 4~7 are the rows of the keypad. GP 12~16 are the columns. GP 8 & 9 are rows 5 & 6 (for the thumb pad keys).  Also required are 5V, GND, and 3.3 V (for the I2C pull-up resistors).

There is not enough room under the keyboard for a pin header, so I recommend direct wire connections among the RP2040, IS31 interface board, and breadboard. The 8 row x 4 pin section of stripboard fits nicely under the palm rest area just inside the hole for the wire bundle running to/from the thumb pad. In the original unit this wire bundle ends in a 14 pin JST connector, which can be cut off to gain access to the correct wires (GND, TRQ, PNK, WHT, GRY PRP, BLU, GRN). 

The photo below shows how it should look after wiring everything together (warning: some of the wire colors in this photo differ from the circuit diagram due to lack of some colors in my wire inventory).  Note that the ribbon breakout board must be flipped upside down in the final assembly to avoid twisting the ribbon.  For this reason, it is best to feed the wires from the bottom, so they enter from the top when it is flipped upside-down.

[a_marmot]

7) MCU Retainer and optional mode switch. 

I wanted to avoid dedicating any regular keys or thumb buttons (or defining key combos) to toggle keymaps. So I added an optional mode switch. As shown in the first set of figures, this required drilling a hole in the side of the Orbweaver for a button stem, which actuates a micro arcade lever switch. I used epoxy to fix the switch in place.  In subsequent versions of the mod I also glued a piece of PC board (¼" x ½" ) on the top of the switch to help align the movement of the mode button and keep it from falling out of the hole. The mode switch is incorporated into the rest of the key matrix by wiring one end to row 6 (GP 9) on the stripboard, and the other (via diode) to column 2 (GP13).

As shown in the pictures, this piece of PC board also  to prevent the retainer plate from sliding out of the dovetail joint.   

You will also need to make a retainer plate for holding the Elite Pi in place.  Fortunately Razer provided the perfect part for this in the original unit!  It's a small plastic plate with a notch and a cylindrical plastic pin (used originally to hold the USB cable in place).  Unfortunately we had to remove the two screw mounts for this plate to make room for the RP2040. But that's OK, because it turns out the micro arcade switch described above is in the perfect size (¼" x ⅜" x ¾") to support one side of the plate (while the other is supported by the original plastic dovetail).

Cut the length of the plastic pin on the retainer plate to 3.5 mm, and then add layers of 3 mm EPP foam (commonly used as packing foam) to both sides, and glue in place with CA glue or epoxy.  Position the switch (or alternatively a block of wood or plastic of the same size) just to the right of the RP2040, such that the MCU cannot slide around laterally.  Then glue the switch (or block) in place with epoxy.  After the glue hardens, glue a piece of PC board (¼" x ½" ) on the top of the block to prevent the retainer plate from sliding out of the dovetail joint. (If you installed a switch, this is the same PC board you installed to confine the button.)  As shown in the pictures, when the retainer plate is put in place, the foam on top of the plate brings it's net height up to the bottom plane of the keyboard, such that the retainer plate is held down by the keyboard once it is installed. The 3.5 mm plastic pin points downward, making contact to the top of the USB3 connector, holding down the RP2040 very securely (while the downward facing foam gently limits lateral motion). 

This type of switch also has the added benefit of boxing in the RP2040, making it MUCH easier to secure in place.  In fact

The mode switch is incorporated into the rest of the key matrix by wiring one end to row 6 (GP 9) on the stripboard, and the other (via diode) to column 2 (GP13). 

[PlayBox]

that's a very quality post for a newcomer tbh

[a_marmot]

#8) Optional keycap mod. 

Others have discussed this previously (in particular Tuffrabit on Youtube). But the Orbweaver uses nonstandard keycaps with shallow shells.  In order to swap to normal keycaps, you must remove the plastic webbing and rim that surrounds the switches in the plastic top piece.  The photo below shows what it needs to look like after you are done. 

The the top piece is made of a very hard plastic that is difficult to carve, so you'll need to be patient and take care not to cut yourself, or break the piece. I found the best tool for this is 45 degree angle knips of the kind used for flush cutting soldered components. See photo.  It's best to remove the vertical pieces extending downward below the piece, then work you way around the rim removing plastic all the back to the edge of the key basin.

The plastic itself is bright white, so try not to scratch the black paint. (Tip: if you do scratch the black coating, india ink does a pretty good job of masking it.) Another option is to get the same part from an original Razer Orbweaver (not Chroma) Model RZ07-0074.  The top piece from this model is from the same mold, but made of black colored plastic.

Note the webbing hosts two of the screw mounts anchoring it to the base tray.  So the device loses some structural integrity by doing this (you can feel the added flexibility if you lift up on the top piece after reassembly). I have not it found this to be an issue in practice, but... I'm currently investigating ways to anchor the top piece to the tray more securely, especially in the upper right area of the keyboard. 

[a_marmot]

9) QMK

The RP2040 microcontroller is supported by QMK firmware.  However, a modded Orbweaver is essentially a handwired custom board, and thus is not configurable using the QMK online configurator tool or VIA. If you want full control over the keymaps and RGB color, You'll need to get a copy of the QMK programming environment and compile the firmware yourself. 

The good news is you don't have to start from scratch.  I have created a folder on the QMK Github repository which contains generic source code to define the key layers and set static colors for the keys in each layer (https://github.com/qmk/qmk_firmware/tree/master/keyboards/handwired/orbweaver). That's as far as I have taken it.  But QMK is incredibly powerful, so if you want to do additional things like dynamic RGB effects and RGB animation, you probably can. If you decide you want to build new features, the QMK folks are very helpful and respond quickly on the QMK discord channel.

To use QMK, you'll first need to download the QMK programming environment.  Follow instructions at https://docs.qmk.fm/#/newbs (exact procedure depends on your OS).  This will create a local copy of the QMK compiler and all the files you'll need (including the orbweaver-specific files).

Then, under keyboards/handwired/orbweaver/keymaps/default, you'll find a file entitled keymap.c.  This is the file you need to edit or replace to set your keymaps and key colors.  The default keymap just has two layers (0, 1).  But you can add more (I currently use 4).  The default layer 0 is set to the Razer default keys.  Here's what it looks like in the code:

[Layer 0] = LAYOUT_keypad(
        KC_ESC, KC_1, KC_2, KC_3, KC_4,
        KC_TAB, KC_Q, KC_W, KC_E, KC_R,
        KC_CAPS, KC_A, KC_S, KC_D, KC_F,
        KC_LSFT, KC_Z, KC_X, KC_C, KC_V,
        KC_LALT, KC_LEFT, KC_RIGHT, KC_DOWN, KC_UP,
        KC_SPACE, TO(1)

Here TO(1) is assigned to the optional extra side button described above. This button toggles to layer 1, which has a key to toggle back to layer 0, etc. The key nomenclature can be found at https://github.com/qmk/qmk_firmware/blob/master/docs/keycodes.md.

They colors for each key layer are defined in the section below the key maps, and look like this:

         {
      {0x00, 0x00, 0xFF},{0xE7, 0xFF, 0x00},{0xE7, 0xFF, 0x00},{0xE7, 0xFF, 0x00},{0xE7, 0xFF, 0x00},
      {0xFF, 0x70, 0x00},{0x00, 0xFF, 0xFF},{0x80, 0x00, 0xFF},{0x00, 0xFF, 0xFF},{0x00, 0xFF, 0xFF},
      {0xFF, 0x70, 0x00},{0x80, 0x00, 0xFF},{0x80, 0x00, 0xFF},{0x80, 0x00, 0xFF},{0x00, 0xFF, 0xFF},
      {0xFF, 0x70, 0x00},{0x00, 0xFF, 0xFF},{0x00, 0xFF, 0xFF},{0x00, 0xFF, 0xFF},{0x00, 0xFF, 0xFF}
   },


These are the RGB levels in hexidecimal (0~255) for {R, G, B} for each key (top view).  The color maps are listed in order for layers 0, 1 (more if you add them).  Note that if you replaced the Razer R-C-B-G diodes with more standard R-C-G-B diodes, this is where you would need to switch green and blue.

Once you have the keys and colors defined, you can open a shell in the QMK programming environment, and type the command:

$ qmk compile -kb /handwired/orbweaver -km default

This will create a firmware file entitled orbweaver_default.uf2 in the qmk_firmware folder in your user folder.  Plug the PR2040 into a USB and put it into bootloader mode (how depends on platform), and copy the firmware to the MCU.  It should immediately appear as an available input device with RGB lighting corresponding to the default keymap.

Maybe if one of you is a programming whiz you can come up with more sophisticated firmware with an app to control it (like wooting or logitech). This is beyond my limited programming abilities.

[a_marmot]

10) Reassembly

Carefully reassemble the Orbweaver, placing the boards where they need to be.  I found it helpful to use heatshrink tubing around bundles of wires to keep them tidy. I also used a few drops of Scotch Weld 2216 to secure the boards in place. The OP shows a picture of the final product in operation!

Any questions, please do not hesitate!

[a_marmot]

I decided to embrace the RGB...

With QMK, calls to rgb matrix effects are built in. So it's actually a convenient way to manage key-layer specific color maps.  But it also provides a programming environment for custom animations (in this case based on the key-layer specific color maps). 

[anawilliam850]

Hi! thank you for the information

[Lostdotfish]

Just registered to say this is awesome!  I'd been thinking about how best to make a keypad that was independant from Razer's software for the last couple of months.  No other vendor seems to offer the amount of control on the thumb that Razer's products do, so I was just starting to look at the possiblity of modding them with a QMK MCU.

I wonder if a custom PCB could be designed in the same footprint as the original Razer MCU board to try and eliminate the breakout board and breadboard.  It should be possible to make a carrier for the Elite-Pi RP2040 then move the FCC and JST connector over to the new PCB making it a little more plug and play... (you could of course go the whole hog and design the whole RP2040 onto a custom PCB but that would be a much bigger design task...)

How is the pad in day to day use?  Am I right in understanding that there is no reprogramming of the keys/rgb without recompiling the firmware?

[Lostdotfish]

Just registered to say this is awesome!  I'd been thinking about how best to make a keypad that was independant from Razer's software for the last couple of months.  No other vendor seems to offer the amount of control on the thumb that Razer's products do, so I was just starting to look at the possiblity of modding them with a QMK MCU.

I wonder if a custom PCB could be designed in the same footprint as the original Razer MCU board to try and eliminate the breakout board and breadboard.  It should be possible to make a carrier for the Elite-Pi RP2040 then move the FCC and JST connector over to the new PCB making it a little more plug and play... (you could of course go the whole hog and design the whole RP2040 onto a custom PCB but that would be a much bigger design task...)

How is the pad in day to day use?  Am I right in understanding that there is no reprogramming of the keys/rgb without recompiling the firmware?

RE - custom PCB - something similar to this project

https://github.com/Ayehavgunne/pypad

[mmrvn]

I decided to embrace the RGB...

With QMK, calls to rgb matrix effects are built in. So it's actually a convenient way to manage key-layer specific color maps.  But it also provides a programming environment for custom animations (in this case based on the key-layer specific color maps).

could you drop the code in the github?

[shifttymike]

Excellent mod! I just got my hands on the non chroma and intend to do something similar. I may add a screen in lieu of RGB.
One question I had, does the non chroma version have the same 18pin FPC cable? I want to order a breakout before I start, but don’t want to have to disassemble it just to confirm, especially if someone else has already

[shifttymike]

Curiosity got the better of me, I stripped the unit and replaced one key switch and LED as a test. My non-Chroma unit had Razer key switches which could be a rebrand, but more likely just cheap generics. They’re very inconsistent in feel and clicky and I don’t like them.
- The non-chroma also uses an 18pin ribbon cable. Currently waiting for that to arrive, eta 6 weeks if I’m lucky
- I don’t see any mention of the LEDs on the thumb cluster. I want to use them as layer indicators. When I’ve established the pinout then I’ll drop that info here
- I plan on adding 2 buttons. One for layer switching and one for boot loader. I have micro switches of different heights so I may make the bootloader one flush with the case to prevent accidental presses

[xXw1l]

Hello,  Thank you for your time creating this mod for these beautiful keypads. I attempted the mod, the only issue that I am running on is with the LEDs. The lights are not coming on after flashing the software created with QMK, everything else works, all the keys and the extra switch, just the not LEDs. I have not replaced the LEDs or the switches.

[a_marmot]

I wonder if a custom PCB could be designed in the same footprint as the original Razer MCU board to try and eliminate the breakout board and breadboard.  It should be possible to make a carrier for the Elite-Pi RP2040 then move the FCC and JST connector over to the new PCB making it a little more plug and play... (you could of course go the whole hog and design the whole RP2040 onto a custom PCB but that would be a much bigger design task...)

How is the pad in day to day use?  Am I right in understanding that there is no reprogramming of the keys/rgb without recompiling the firmware?

Yes, A custom PC board is the proper way to do it.  But it's hard to justify if only doing a few of them.

My experience day to day has been is awesome (and both my kids too!).  But I haven't had to recompile very often.  The RP has such a massive memory I could include a half dozen key layers covering various use cases, and haven't really needed to change.  (Usually games and apps have sufficient key remapping that at least one of the current maps will do).  But if this were a commercial project, the better way to do things is to have an app that edits an onboard file with the keymaps. I will never go back to software-based keymapping. 

[a_marmot]

could you drop the code in the github?

Unfortunately some of the animations required modifying core QMK code, which the folks at QMK rejected for general users.  But after the dust settles with their latest versions, I will try to re-create.  It's a project, and I haven't had time recently to work on it.

[a_marmot]

Excellent mod! I just got my hands on the non chroma and intend to do something similar. I may add a screen in lieu of RGB.
One question I had, does the non chroma version have the same 18pin FPC cable? I want to order a breakout before I start, but don’t want to have to disassemble it just to confirm, especially if someone else has already

Nope, it uses a 12 pin ribbon.  Also, it has no rgb matrix controller.  All the LEDs are wired together, so you can only change the brightness of the LEDs (you can't address individual LEDs). 

Row   Ribbon Pin (left to right)
1 (top)   R11
2   R10
3   R09
4 (bot)   R08

Column   Ribbon Pin (left to right)
1 (lft)   R7
2   R6
3   R5
4   R4
5 (rgt)   R3

LED+   R2 (via 560 ohm resistor)  4.5 V at 100%
LED-   R1, R12 (both grounded)

This is basically the Chroma, but 6 pins to the left and 5V moved to R2 instead of R4.

[Deathwish]

This is just what I was looking for. Thank you for taking the time to post instructions and the video resources.

I was thinking of doing the same thing you did but with KMK instead because I like python.

Have you though of 3D prining the bottom half of the Orbweaver's case with custom mounts for the 2040?

Any chance you have multiple modded Orbweavers and you would be willing to part with one? I was gung ho about starting this project but after it took me two days just to register on here I think I may be in a little above my head, lol. 

[Lostdotfish]

What are the unused wires on the original thumb JST connector for?  Are they from the 3 mode LEDs?

I'm just working on another project before I intend to design a plug and play drop in RP2040 board for this.

[Lostdotfish]

Right, lets get started on this then...

[Lostdotfish]

Pico carrier?

[Lostdotfish]

The rabbit hole is deep...

[Lostdotfish]

So the order is in... I'll probably move to a separate thread once they arrive.  I have several plans for improvements and iterations.

[blondie]

I just got an Orbweaver Chroma. Not sure if I'll ever have the time to do this mod, but I surely can dream.

[Lostdotfish]

I just got an Orbweaver Chroma. Not sure if I'll ever have the time to do this mod, but I surely can dream.

Well, I'll have a few spare boards if they work.  Should be fairly plug and play and it's not hard to teardown to the MCU board.  The thumb portion is fiddly but I've worked out the correct order to ensure that springs and small parts don't fly out - but for the initial mod - there is no need to touch it.

If they work out as planned, I'll post on here if I have spares available.  It would be good to recoup some manufacturing costs so that I can work on some other projects related to these devices.

[Lostdotfish]

I wonder if a custom PCB could be designed in the same footprint as the original Razer MCU board to try and eliminate the breakout board and breadboard.  It should be possible to make a carrier for the Elite-Pi RP2040 then move the FCC and JST connector over to the new PCB making it a little more plug and play... (you could of course go the whole hog and design the whole RP2040 onto a custom PCB but that would be a much bigger design task...)

How is the pad in day to day use?  Am I right in understanding that there is no reprogramming of the keys/rgb without recompiling the firmware?

Yes, A custom PC board is the proper way to do it.  But it's hard to justify if only doing a few of them.

My experience day to day has been is awesome (and both my kids too!).  But I haven't had to recompile very often.  The RP has such a massive memory I could include a half dozen key layers covering various use cases, and haven't really needed to change.  (Usually games and apps have sufficient key remapping that at least one of the current maps will do).  But if this were a commercial project, the better way to do things is to have an app that edits an onboard file with the keymaps. I will never go back to software-based keymapping.

Not sure if you check this thread ever... but wanted to share this.