Wooting Developer Portal – The future of analog input keyboards

This one’s been a long time coming. The Wooting Developer Portal is now live! In short, anyone willing now has access to SDK’s (Software Development Kits) for both reading the analog values as well as controlling the RGB LEDs. If you’re a basement coder, now’s your chance to get involved.

In this post, I will talk a little bit about what it is, why it’s taken so long, and what you can do with it. If you want to skip the introductions, you can head straight to the devportal here.

What is the Developer Portal

Simply put, the developer portal consists of two parts:

  1. Access to control the RGB LEDs
  2. Access to read the raw analog values

While playing with the RGB LEDs is fun and cool, the second part (reading the analog values in real time) are what’s really going to make a difference for us in the long run and help push analog keyboards as the industry standard, which has been our goal since we started.

With the developer portal we want to embrace a spirit of community and sharing. This means that all our development tools will be open source and open for contribution. As always, your feedback is what makes our stuff great.

This is a big step for us and we’re really excited to be able to finally announce it. Keep reading if you want to know what you can use it for and why.

Create your own RGB effects

People always want more RGB. It’s a scientifically-proven fact that more RGB = more performance, so we created the RGB SDK. There are two things you can do with it. Firstly – there’s nothing limiting the lighting anymore. There’s only so many lighting effects we can create with our limited time. Luckily, you don’t have to wait for us anymore. Creating custom RGB effects is now possible, within the limitations of your coding skills and creativity.

The second part is perhaps more interesting. With the RGB SDK, it is possible to integrate interactive lighting effects into games. The function row might light up depending on how much HP you have left, and the entire keyboard might flash red when you take a hit. A member of our community, Dommy, already created an integration for ManiaPlanet/TrackMania 2:

FN keys light up based on the car’s RPM, the number row depicts the gear you’re in, the navcluster corners represent wheel traction and arrows light up based on steering and acceleration/deceleration. You can view the GitHub project for it here.

Of course, making functionality like this is pretty time-consuming, and will only work with particular games for which there’s integration built. Luckily, there’s an app that gives you RGB integration functionality in many different games already: Project Aurora. We’ve been working closely with Project Aurora owner Simon, who was awesome enough to include support for our keyboard. Project Aurora already has support for a bunch of games, with more being added all the time.

With RGB integration, games are not the limit. The SDK allows the keyboard and any program share dialogue, which means you can create whatever you want. We used it to create an audio visualizer:

Can you hear the beat?

Analog keyboard control

The second part of our developer portal, analog control, is what really kicks our influence forward. Before the SDK, we had to rely on Xinput or DirectInput to translate the keyboard’s values into something games can understand. While this solution ensures that virtually every game can understand what our keyboard is doing, it sets an annoying limitation: the game is treating the keyboard as a controller.

This is problematic in two ways:

  1. You have to cross-reference the controller- and keyboard keys to build a controller layout that suits you, on the keyboard-face. It’s sometimes a long and arduous process, and we didn’t imagine it like this when we started making analog keyboards. No one wants to spend 15 minutes setting up before indulging in some gaming.
  2. The input handling of some games – Rainbow Six: Siege and TES V: Skyrim being the worst examples – limit the player into one API. This means that when the game detects controller presses, the mouse might stop working, and the other way around.

Here’s where the Analog SDK comes in: it’s an easy way for developers to let the game talk to the keyboard natively, without relying on Xinput or DirectInput as the translating service. You can make the game understand that hidden behind the façade of a keyboard, there is analog goodness. Perfect, fluid functionality, without gimmicks or tricks.

There’s already a game that does this, Fugl.

On the front-end, the user only has to bind keyboard keys, just like with any other game. But the magic happens underneath the surface. Fugl natively understands the keyboard, and can read the analog values without relying on Xinput or DirectInput. User gets to enjoy a hassle-free setup as well as the analog control, without having to fuss over the controller mappings.

While Fugl is an amazing example, you can hardly call the Analog SDK a standard if it’s only in use for one game. This is why we plan to cooperate with many other developers and hopefully get them excited about adding native analog keyboard support into their games.

The best part is, it’s open for all to use – this is crucial. It doesn’t even have to a Wooting keyboard. The SDK is open for everyone to use and implement, regardless of hardware or software, which leads us into the next topic.

Analog input industry standard

As mentioned, we are constantly working towards our ultimate goal of making analog input an industry standard, which is why the Analog SDK is such a big deal. Right now, the first version is out and available, but the work doesn’t stop here.

A lot of you (us included) were pretty excited about open-sourcing everything we do, from Wootility to keyboard firmware. The more we thought about it, the more we realized it doesn’t make sense for us right now. However, we figured that if we were to release SDKs, we’d have to make them open source, which we did!

Open source!

Open sourcing the SDKs allows for a few things that are important in pushing them forward as something that makes an impact in the industry and not just for our products. We wanted for people, be it other companies or individuals, to have an easy time adopting the SDK and to trust in it. While proprietary software allows for more control on our side, we understood that in order for it to make sense as a standard, it needed to be easily adopted and easily improved.

For the SDKs, open sourcing has a couple very important advantages:

  1. Better development process. Everyone is free to contribute to and improve the SDKs. In time, this will mean added functionality and more stability in operation. This in turn, attracts more users – be it individuals, game developers or other companies. And so the cycle will continue
  2. Adaptable and adoptable. The Analog SDK is not only for our products. Anyone can use it with any analog keyboard, should they so choose. This avoids there being competing standards which waste time, resources and effort for all parties involved. Game developers don’t have to decide which analog keyboard to support, they support them all!

By opening our project to everyone from the get-go, we are trying to avoid the classic dilemma portrayed by xkcd:

xkcd: Standards. Comic strip.
The nightmare we want to avoid.

We want analog keyboards to become the standard in the gaming world, so we have no reason to try to lock everyone behind proprietary software that only works with our keyboard. Shooting ourselves in the foot to gain an advantage in the short term will just cause the leg to start hurting more and more in the long term.

What does it mean for Wooting?

While open sourcing the Analog SDK gives other companies an easy way to join the analog revolution, it doesn’t take away the fact that Wooting is its own brand, with its own features. You’re unlikely to see features like DKS (Double Key-Stroke) and such appear in other products too. In other words, the Analog SDK only unifies the way keyboards send – and games interpret – the granular control you get from analog input. It doesn’t mean that all analog keyboards in the future have the same set of features, or that any analog keyboard is indistinguishable from the next.

Our approach

Getting the Analog SDK to the point where it can be called an industry standard is not going to be easy. As with anything, the first step is to get users onboard. We already have a small community developing little projects, which is very important for these first few months for getting feedback and improving the Analog SDK.

But, individuals alone won’t cut it. We need game developers to get excited and start adding integrating the Analog SDK into their games so they can have native support. For this reason, we’re very happy to have Fugl on board with us, leading the charge of the analog revolution. From here, we just need more interested developers to build the support base and help improve the SDK to the point where we can start to attract the attention of other keyboard brands and one day, large game titles.

Feedback

As always, we are open to feedback – especially this time. If you are a game developer, a hardware manufacturer or a basement code-junkie, check out the developer portal and join the discord server. Any feedback, improvement suggestions and collaboration ideas are welcome and greatly appreciated. Otherwise, you can get in touch with us by:

Stay awesome and see you in the next one!

Tino Parkkinen Written by:

Communications & PR @ Wooting. Mechanical keyboard aficionado and a tech lover.

Be First to Comment

Leave a Reply

Your email address will not be published. Required fields are marked *