Writing code can be fun when you want to do it, and crushingly not-fun when you don't want to do it. Not wanting to write code shouldn't stop you from doing cool stuff with technology.

Mechanical keyboards are great. They used to be everywhere in the early days of computing but they died out a little through the 90s and 2000s. Around 2008 they started to regain their popularity, with communities springing up around building and collecting mechanical boards. To a lot of people, they're a bit of an obsession.

Fans of mechanical keyboards tend to be on the more technical end of the spectrum, many are comfortable on the command line and know what "Red Hat" is besides fashionable headware. This proclivity for programming extends to their mechanical keyboards - in fact, it's one of the reasons the mechanical keyboard community can exist - talented programmers build fantastically feature-rich firmwares that make many mechanical keyboards tick.

With these fancy firmwares, you can make your keyboard do almost anything. You can make it enter a character when you press a key, type out a sentence or key combo when you press a key, play a song, pump-up the volume, turn the keyboards backlighting up or down, and a whole bunch of stuff besides. They also let you have multiple layers of keys, meaning your 10-key keyboard can turn into a 100-key keyboard if you program it right. Think about it like homescreens on your phone, you can only fit a handful of app icons on one screen, but swipe to the left and you get a whole 'nother screen.

Sounds great, and it is, but telling the firmware what to do when you press a key and getting it onto your keyboard is a little *involved* right now though.

Right now, you have to:

1 - Make sure your computer has a development environment set up so you can edit and compile your firmware

2 - Install a USB device-firmware-update tool, and the drivers to make it work if you're on windows

3 - Open up your text editor & edit your keymap.c file to include the keycodes and macros you want your keys to enter

4 - Arrange your keymap.c file into layers if you want your keyboard to have multiple layers

5 - Go to the command line and type 'make clean TARGET=myAwesomeKeyboard'

6 - When the compiler outputs a .hex file, type 'make dfu' to DFU-load the firmware to your keyboard

7 - Profit (or cry)

People have taken shots at building online keymap file building tools, or online firmware compilers, or simple dfu-loader apps, but each of them only takes on one part of the puzzle, and all of them require you to know how they keyboard works and how to get a firmware onto it.

Simplicity is king

So we figured, enough with this, coding is fun but I don't want to have to compile C code to make my keyboard into a media controller, I have better things to do. So, we bundled the configuration, compiler and dfu-loader tools up together and put it all behind a super-simple user interface so you can configure your keyboard visually, compile the firmware in the cloud, and program it all with the push of a button.



What it can do

The configurator supports pretty much everything the QMK keyboard firmware framework does. It supports all the same keycodes, covering a good chunk of they keys you'd want to type. It supports up to 11 layers, giving you space to lay out all of your keys. It has board actions, so you can turn your backlight up down or off. It supports media keys & system keys so you can turn your computer off from your keyboard. It even supports mouse emulation, so you can have your keyboard move your mouse and click.

But there's one feature we're particularly proud of that nobody has really tried to take on visually yet, and that's Macros.

Macros

Macros are chains of keys you want to be entered in order when you push a key on your keyboard. They can be made up of any of the keys you can usually press on your keyboard, so for exmaple, if you wanted to bind a key to press control alt delete, you could totally do that. Of you could make a key type "Hello, world! It's a great day" all in one go.

Macros are incredibly powerful but until now, they've been a little difficult to understand and create, we tried to make creating macros visually as simple as possible, and we think we did a pretty decent job. Keys can have one of three actions - down, up and type. Down holds the key down like keeping your finger on a key, up releases a key like lifting your finger off the key, and type pushes a key down and then releases it just like typing a key. Here's an example:


If we read the above keys, left to right, we see a shift key with a down action, so you push down the shift key. Next, we get a H key with a type action, so we push the H key down and release it, and since the shift key is held down too, it gets capitalized. Then we get a shift key with the up action, so we release the shift key. Next up, we get E, L, L & O, all with a type action so they're all typed like regular keys. And finally we see an exclamation mark with a type action, so it gets typed too.

So after that long and boring explanation, we get the string "Hello!" typed out when we press the key. It makes way more sense to just look at it and see it visually rather than explaining it or writing it in code, you can tell just with a look what the macro will do when you press it, and you can add, remove or edit keys just by clicking them.

Ongoing project

Right now the configurator is an experimental project - it works well enough to use day-to-day to configure your keyboard, but there'll be bugs here and there, and features missing that could be added. We're going to keep working on it, fixing bugs and adding features as we find the time to, so if you have any feature requests or notice any bugs, feel free to email them to us and we'll add them to our list.

We have a bit of a list of features we'd like to add already, so you'll see them show up as we work on them, and we'll keep the configurator up to date with new keyboards as we release them. And in the end, if you can't get the configurator to do something you want it to, you can always fall back to tinkering with the firmware code and uploading it yourself, so you won't be stuck out in the cold if the configurator crashes.

Making complex things simple is hard, and getting it right first time is even harder.

We still have a lot of work to do on the configurator, but we're pretty proud of what we've built so far. The code is a hot mess, but it's our hot mess, and it'll only improve over time. It opens up customizable keyboards to a whole new group of people who wouldn't have been able to make their keyboard do different things before, and it saves a buttload of time for people who know how to compile firmware but don't want to.