Falling Leaves and Fresh Features

How time flies, we are already well into autumn, and it has been almost two months since my last post. A whole stack of new developments has accumulated that I really should say a few words about here.

Apart from the usual housekeeping tasks around ControllerBuddy - which I do not cover in these posts - a number of features and improvements to the main application itself have been implemented for version 1.10. Considerable effort has also gone into streamlining the usage of ControllerBuddy on Linux, making it easier than ever before - more on this below.

So let’s dive right in…

Selective Circle to Square Mapping

With the release of ControllerBuddy version 1.10, a new profile feature for axis actions has been introduced. It comes in the form of a checkbox labeled Use Raw Value. When this option is enabled, ControllerBuddy bypasses the so-called Circle to Square Mapping of the corresponding axis for that specific action.

If this doesn’t make sense yet, let me try to explain:

First of all, let us clarify what Circle to Square Mapping means in the context of ControllerBuddy. In short, it is a setting located under the Global Settings tab, and has been part of the application for a long time. When this option is enabled (the default setting), ControllerBuddy maps physical axis values from a circle to a square. This is useful for most game controllers, which feature circular analog sticks - essentially almost every controller on the market. Why is this necessary? Because with a circular stick, it would otherwise be impossible to reach full deflection along both the X and Y axes simultaneously. For example, if this option is disabled on a controller with circular sticks, you cannot apply full elevator and full aileron at the same time.

While the Circle to Square Mapping feature solves this problem, it comes with a drawback: the stick becomes significantly more sensitive near the corners. This is especially problematic for the left stick, which in official profiles is mapped to the yaw and throttle axes. Imagine you have applied full left rudder, then even a slight, unintentional movement along the Y axis will cause a disproportionately strong deflection on the virtual throttle axis.

Traditionally, the official profiles relied on relatively large dead zones on both axes to prevent unintentional inputs. While this helped to a degree, it was far from perfect. In this particular scenario, it is much better to disable Circle to Square Mapping altogether. And that is precisely what the new Use Raw Value option is designed for. Official profiles now have this option enabled by default for throttle, prop-pitch, and mixture axis bindings. If Circle to Square Mapping is disabled globally, this option has no effect.

UI Improvements and JDK 27

The most visible change for users is likely the new lock screen overlay. It features a stylish blur effect rendered over the UI controls whenever ControllerBuddy is actively running. Previously, the UI elements used for editing profiles and global settings were simply disabled, which was often confusing for new users. The lockable tab panels now display a prominent button labeled Stop execution to unlock, making it instantly clear why the UI is locked. Clicking this button directly stops execution without requiring navigation through the main menu, allowing quick access to the controls below.

Another small improvement affects the keystroke editor, which now automatically scrolls to ensure the first matching key is visible as soon as you type into the filter box.

Additionally, two minor edge cases involving the overlay have been resolved:

1. Fixed an issue with the On-Screen Keyboard where switching between light and dark themes left the keyboard styled in the colors of the previous theme.
2. Added small vertical spacing in the overlay between the mode label and horizontal indicators when no vertical indicators are configured, making the overlay look less cluttered.

Finally, Java 27 was released on September 15th. As usual, ControllerBuddy was immediately updated to this new JDK release to take advantage of its latest performance improvements and enhancements.

ControllerBuddy Wrapper Scripts for Linux

I have recently invested a lot of effort into making ControllerBuddy on Linux easier to use and better integrated. On Windows, the installation script handles installing and updating the application, and also invoking the profile configuration scripts that automatically set up supported sims.

While the same installation script runs on Linux, it cannot trigger the configuration scripts the same way it does on Windows. It is strictly meant for installing and updating ControllerBuddy and its profiles because, unlike Windows, on Linux each game usually runs inside its own isolated Wine or Proton prefix.

Furthermore, I now consider the ControllerBuddy Flatpak to be the primary distribution channel for ControllerBuddy on Linux. Flatpak provides a distribution-agnostic way to package, deploy, and run desktop applications safely.

Instead of configuring all games from a single global setup script like on Windows, it is much more effective on Linux to execute configuration scripts dynamically just before launching a game. This approach offers an added benefit: any profile or configuration updates released with ControllerBuddy are automatically applied at game launch. To achieve this, I created two wrapper scripts - one for Proton and one for DOSBox Staging - which are bundled directly into the Flatpak package.

The proton-wrapper.sh script automates the following steps:

• Ensures the Protontricks Flatpak is installed
• Disables native joysticks in the game’s Proton prefix
• Updates the ControllerBuddy Flatpak
• Launches ControllerBuddy with the specified profile
• Ensures PowerShell is installed in the game’s Proton prefix
• Runs the profile’s configuration script inside the game’s Proton prefix
• Launches the game
• Shuts down ControllerBuddy when the game exits

The dosbox-wrapper.sh script automates the following steps:

• Updates the ControllerBuddy Flatpak
• Launches ControllerBuddy with the specified profile
• Forces DOSBox to use ControllerBuddy’s virtual joystick
• Overrides mouse sensitivity in DOSBox if mouse_sensitivity is provided
• Launches DOSBox
• Shuts down ControllerBuddy when DOSBox exits

For Steam/Proton games, all the user needs to do is adjust the Steam Launch Options for a title as outlined in the ControllerBuddy-Flatpak repository. This instructs Steam to run the wrapper script instead of executing the game directly. From there, the script works its magic. By inspecting its execution environment, the script determines which Wine prefix to configure, which configuration script to execute based on the specified profile name, and which Protontricks verbs are needed. The wrapper updates the Flatpak, launches ControllerBuddy with the correct profile, configures the prefix, runs the configuration script, and finally starts the game. Once you exit the game, ControllerBuddy closes automatically. This workflow works seamlessly for both native Steam and non-Steam games and integrates nicely with the SteamOS interface on devices such as the Steam Deck.

To display progress indicators or potential error messages during startup, the scripts use zenity, which is included in the Flatpak package.

I have updated the ControllerBuddy-Linux-Guides to reflect these changes. Overall, I am proud to say this implementation makes ControllerBuddy even easier to use and more tightly integrated on Linux than on Windows. While getting everything working required extensive testing - especially around the quirks of the gamescope compositor - the effort has definitely paid off.

A New Profile for DI’s Hind

Since my last post in August, I added a new official profile for the classic 1996 DOS simulator Hind by Digital Integration. I played around with this sim back in the late ’90s when I got it as part of a game collection, but I never got deep into it at the time.

After setting it up in DOSBox and designing a custom ControllerBuddy profile, I played through a few training missions and jumped into the campaigns. While its flight model and avionics cannot compare to modern implementations like the Mi-24 in DCS, this ’90s classic still offers some very enjoyable gameplay even today. Unfortunately, even early campaign missions feature overwhelming ground and air threats, making survival quite a challenge, which is why I haven’t made it very far into the campaign yet.

GitHub Workflow Improvements

All repositories across the ControllerBuddy project (main application, profiles, install script, Flatpak, website, etc.) rely heavily on GitHub Actions workflows for building, testing, and static analysis. Automated workflows make it easy to trigger tasks automatically, such as updating the website’s Profiles section whenever changes are pushed to the profile repository.

Over the past few weeks, I implemented several minor updates and refactorings across these workflows. Two new automations for the ControllerBuddy Flatpak are particularly noteworthy. To explain, I need to go back a bit first.

Flatpaks are built using manifest files; the manifest for ControllerBuddy is maintained in a dedicated repository called ControllerBuddy-Flatpak. Many Flatpak applications are hosted centrally on Flathub, the largest repository in the world of Flatpak. However, due to Flathub’s strict rules regarding release cycles and ControllerBuddy’s rolling-release model, I was unable to include it in the official Flathub repository. Instead, ControllerBuddy can be obtained from its own Flatpak repository. While this requires users to manually add said repository to their system, it gives the project complete independence. The custom Flatpak repository is hosted via GitHub Pages. Whenever the manifest file in the Git repository is updated, a GitHub Actions workflow builds Flatpak packages for both x86-64 and aarch64 architectures and deploys them to GitHub Pages.

To ensure the manifest stays updated whenever a new version of ControllerBuddy is released, I integrated a workflow based on the Flatpak External Data Checker tool, which is maintained by the Flathub community. This tool relies on release-monitoring.org, a project run by the Fedora Project to track upstream software releases. The service regularly polls registered projects to check for new versions and exposes that data through a public API. By authenticating with an API key, we can also trigger on-demand checks for specific projects using API calls. That is exactly what the release workflow for the primary ControllerBuddy application now does. Immediately after a new binary release is published, release-monitoring.org is instructed to run a check and detect the new version.

Next, the release workflow triggers an update workflow in the ControllerBuddy-Flatpak repository, which automatically opens a pull request updating the Flatpak manifest. Once that pull request is approved by me, a build and deployment workflow compiles the Flatpak and publishes the build. The next time users check for updates on their system, they instantly receive the latest release.

You might wonder why we take this route through release-monitoring.org instead of updating the manifest directly or storing it inside the main repository. The simple reason is that I prefer to follow Flathub’s design patterns and adhere to their standards as closely as possible.

Summing Up

If you made it all the way to the end, congratulations! I hope you found these updates interesting and picked up a few helpful takeaways.
At this point, I often share a roadmap or preview of upcoming plans, but right now, there are no immediate features planned.
Thank you for your interest, have a great day, and see you around!

What’s New in ControllerBuddy

As the first half of August already comes to a close, it is time for another status update on the development of ControllerBuddy. Since the last regular update at the end of June, quite a few developments have piled up. As always, I will focus on the major changes and skip the routine housekeeping.

Release of DCS F-14 B(U) and IL-2 Korea

Let us start with two new releases in the flight simulation community.

At the end of July, Heatblur released their updated version of the F-14 Tomcat, the F-14 B(U), for DCS. I quickly overhauled the existing DCS F-14 profiles and added a dedicated profile for the B(U) variant.

Then, on August 4th, 1C Game Studios released the long-awaited IL-2 Korea out of early access. Over the following weekend, I began building the corresponding ControllerBuddy profile. Fortunately, the existing configuration script for IL-2 Great Battles was easily adaptable to IL-2 Korea.
Thanks to a fellow Linux user who devised a patch for vkd3d-proton to fix initial terrain rendering issues, IL-2 Korea now runs flawlessly on my Linux setup, and I have been thoroughly enjoying it.
For the Linux users among you, I already published a guide for setting up the Steam version of IL-2 Korea on Linux for usage with ControllerBuddy as part of my ControllerBuddy-Linux-Guides collection.

I particularly appreciate what 1C did with the new Multimenu - it greatly improves controller usability in general and integrates seamlessly with ControllerBuddy. The menu is ideal for secondary commands that are rarely used during flight, eliminating the need for dedicated ControllerBuddy bindings. For a sim without clickable cockpit controls, this is a very welcome feature.

Refactoring Intervals Into Rates

While a run mode is active, ControllerBuddy continuously polls controller hardware for state changes across axes and buttons. Up until version 1.9, polling relied on fixed sleep intervals. Advanced users might be familiar with the Poll Interval setting in the Global Settings tab, which directly controlled the sleep duration between polling iterations.

However, this approach did not account for the execution time ControllerBuddy itself spent processing input. As a result, the effective polling behavior varied depending on profile complexity and system performance. While the practical impact was minimal, this dependency was undesirable from an engineering perspective.

In version 1.9, the fixed sleep interval has been replaced with dynamic calculations based on the actual time elapsed since the previous poll. At the same time, I converted the Poll Interval option into a Polling Rate setting. Instead of specifying milliseconds (e.g., 1 ms), users now configure frequency in Hertz (e.g., 1000 Hz), which is far more intuitive for input devices. For consistency, the Key Repeat Interval in the Profile Settings tab was also refactored to Key Repeat Rate.

Support for Dynamic Polling Rates

Previously, the default poll interval was set to 1 ms - the lowest possible value - resulting in a polling rate of roughly 1000 Hz. Apart from a few high-end custom devices, standard gamepads (such as an Xbox controller) operate at a hardware polling rate of only 125 Hz. Polling at 1000 Hz meant most polls detected no new inputs, unnecessarily wasting CPU cycles.

The main reason the interval was originally kept so low involves output smoothness. Actions that drive relative mouse movements or camera controls depend directly on the dispatch rate to remain smooth, because reading input and making operating system API calls both occur on the main processing thread. While a bump from 125 Hz to 1000 Hz is barely noticeable on a desktop cursor, it makes a substantial difference when panning camera controls in a flight simulator.

To solve this trade-off, I introduced dynamic polling rates. ControllerBuddy can now run at a much lower frequency when high output precision is unnecessary, saving CPU cycles and battery life on handhelds like the Steam Deck or laptops. The moment an action sensitive to output frequency becomes active, ControllerBuddy automatically switches from the minimum rate to the maximum rate. Users can customize these two states via Min. Polling Rate (default: 125 Hz) and Max. Polling Rate (default: 1000 Hz).

While testing at 1000 Hz, I noticed that garbage collection cycles under SerialGC could occasionally cause micro-stalls in the input thread. To eliminate this, I switched back to the default Garbage-First (G1) collector. SerialGC was originally chosen to minimize the memory footprint on small heaps, but modern G1 delivers better pause times with negligible overhead.

Additionally, I further tuned the JVM memory configuration. ControllerBuddy now operates with an initial heap size of 24 MB and a maximum of 48 MB, reducing the overall memory footprint more than ever before.

Client-Server Optimizations

Another simple yet effective improvement targets ControllerBuddy’s networking code.
As mentioned in my previous post, ControllerBuddy was originally designed to operate across a network in client-server mode. Although relatively few users rely on this setup, I continue to maintain it because it fits naturally into the overall architecture.

While refining the polling loop, I realized there was an easy way to drastically reduce network traffic between the server and the client. Previously, the server transmitted state updates on every single poll, even when no inputs had changed - which is especially problematic at fast polling rates. Now, state updates are sent only when an actual change in controller state occurs.
Best of all, this change was entirely server-side and required no modifications to the network protocol or the client.

Preventing Null Pointer Exceptions

To continuously improve code quality and safety, I integrated JSpecify annotations throughout the entire codebase. This was a sizeable effort, but well worth it: in combination with static analysis tools like NullAway, this makes the code more robust and maintainable while helping eliminate a number of redundant null checks that had accumulated over the years.

Mode Switching Improvements

Last but not least, I also refined how ControllerBuddy handles mode switches to eliminate unexpected control delays.

When a button is held down to switch modes - such as using the left stick to look around the cockpit instead of controlling the rudder and throttle axes - ControllerBuddy disables the stick for a moment upon releasing that button. This safety pause gives the analog stick time to snap back to center, preventing an aircraft from violently jerking when primary flight controls are re-engaged.

Previously, this safety pause always enforced a strict one-second timer. If a button was quickly pressed again to jump back into that mode, the stick remained unresponsive until that full second ran out. ControllerBuddy now detects when a mode is re-entered and cancels the safety timer immediately. This maintains protection against accidental inputs when leaving a mode, while ensuring rapid control toggles feel completely seamless.

Looking Back

While so far I have mainly posted development updates, today I felt like doing a different kind of post.

In about two months, ControllerBuddy will celebrate the 12th anniversary of its first line of code being written. When looking at the Git commit history of the ControllerBuddy project, one can see that my first commit in the project was created on Saturday, September 27, 2014, shortly after 2:00 AM. At that point in time, the project was still called RemoteStick - but more on that later…

So get ready and fasten your seatbelts, because in this post I would like to take you on a wild ride back to the origins of ControllerBuddy to explain what influenced its design and how it all started.

An Early Interest in Aviation

From a young age, I have been fascinated by all things aviation-related. My grandfather, who enjoyed building and flying RC model airplanes, was a big influence on me. Even before I reached kindergarten age, I would spend hours in his workshop watching him build and repair his models. Often, I would accompany him to the flying field and watch him fly them.

First Steps in Computing

Shortly before turning seven, I got my first PC, with an Intel 486 DX2-66 running MS-DOS 6.22.
Given my interest in aviation, I quickly got into flight simulators, starting with classic titles such as:

• Secret Weapons of the Luftwaffe
• Dogfight: 80 Years of Aerial Warfare
• TFX
• Microsoft Flight Simulator 5.0
• Shuttle: The Space Flight Simulator
• MiG-29 Fulcrum
• Red Baron
• Apache
• Su-27 Flanker
• Fleet Defender

At first, I was using a simple, two-axis, two-button joystick called the InterAct PC Mission, which I got for my birthday.
After it broke, I was upgraded to an original Logitech WingMan, which even featured a small thumbwheel for throttle control!

From back then until today, flight simulation has always been an important part of my life. I have spent time with almost every simulator I could get my hands on.

First Steps With RC Aircraft

At around nine years old, I got my first RC model airplane, a Multiplex Panda - a wonderful, beginner-friendly model. Along with it, I also got my first RC transmitter, the Multiplex Europa Sprint.

The reason I am mentioning all this is that the basic layout of RC transmitters, particularly the so-called Mode 2 layout, forms the basis of all my profiles for ControllerBuddy. Mode 2 means that the left stick controls the throttle and rudder, while the right stick controls the ailerons and elevator. It’s worth noting that the left stick’s Y-axis is not spring-loaded, unlike a standard game controller you may be familiar with.

Springs and Broken Hardware

Skipping ahead a few years, during the early 2000s, I started using an original Sony DualShock controller together with a special USB converter. I mainly used the DualShock for RC simulators, such as Aerofly Professional and Aerofly Professional Deluxe. While this felt like a good solution, at least for RC simulators, it had a big drawback: like all game controllers, the DualShock’s sticks had a spring-loaded center position, which made it impossible to hold the throttle at a specific position without constantly applying pressure on the stick.

At the same time, for traditional flight simulators, I was using the legendary Microsoft SideWinder Force Feedback 2 joystick. It was a great device for its time, but it had a very limited number of buttons and switches.
Some of the sims I was flying around that time were:

• Microsoft Flight Simulator series
• Microsoft Combat Flight Simulator
• IL-2 Sturmovik: Forgotten Battles
• Lock On: Modern Air Combat
• Falcon 4.0: Allied Force
• Wings over Vietnam / Europe
• X-Plane 8 / 9

During the late 2000s, I got my first HOTAS setups: first a second-hand Saitek X36 from eBay, and then a Saitek X52. Being second-hand, the X36 was already a bit worn out and broke down after a few months of use. The throttle of the X52 also broke down after less than a year of use and was replaced by Saitek. But even then, the X52 system had a weird issue where if it was used in conjunction with the Saitek mapping software, rapid, repeated button presses would trigger a hardware bug that caused the device to reset itself. When I got the X52, the market for HOTAS setups was quite small compared to today, and the only other main option was the Thrustmaster HOTAS Cougar.

After my rather negative experiences with the Saitek devices, I was not willing to spend any more money on a new HOTAS setup. I bought an original Xbox 360 controller with which I experimented a bit in conjunction with Flight Simulator 2004, but with the mapping options available at the time, it was not really possible to get a good experience with a game controller.
Before moving to a new apartment in 2013, I also had to downsize my setup, and thus used a very cheap and weird-looking Mad Catz Cyborg V.1 joystick for a while. Since I was not flying so much at that time anyway, I did not mind the limitations of the device too much.

War Thunder and X-Plane Lead the Way

In May of 2014, I got interested in War Thunder, which had a very flexible controller mapping system that offered relative axes. A few months earlier, I had also acquired a DualShock 3 controller. Together with War Thunder’s mapping capabilities, it allowed me to get an excellent flying experience after some experimentation.
Basically, I was able to recreate the Mode 2 layout I was familiar with from flying RC planes and expand on it. Using the left stick’s Y-axis for throttle control was no longer a problem in War Thunder because I could map it as a relative axis to overcome the spring loading. Crucially, it was also possible to use modifiers to bind the look axes onto the same stick. While you cannot compare War Thunder with a more sophisticated simulator like DCS, the basic layout behind all ControllerBuddy profiles today was established right then.

After spending a few months with War Thunder, I wanted to get back into traditional flight simulators - especially X-Plane 10, which I had used for years. That’s when I wrote a small X-Plane plugin in C called X-Gamepad. This plugin allowed me to use a game controller with X-Plane 10 in a very similar way to War Thunder, but with a few improvements.

I was so happy with the result that I never wanted to go back to using a HOTAS or joystick again, and I started to think about how I could use a game controller with other flight simulators as well.
At that time, I was using a 2012 MacBook Pro running OS X. While War Thunder and X-Plane 10 ran natively on OS X, I dearly missed a modern combat flight simulator like Lock On, which I had played during the mid-2000s on Windows. Lock On was already more than 10 years old at that time and ran reasonably well within a Windows virtual machine. This meant I could run it on my MacBook, but I couldn’t control it the way I wanted…

The RemoteStick Prototype

So, I came up with a plan to take what I had built specifically for X-Plane, split it up into generic building blocks, and make it universally usable with every simulator.

The central goals for my new project were:

1. Support any flight simulator running on Windows.
2. Support any game controller on any host operating system (in my case, OS X).
3. Provide a graphical user interface to build and edit profiles.

Part of the solution to the first problem came in the form of vJoy, which was developed by Shaul Eizikovich as open-source software. It is a virtual joystick driver for Windows that allows you to create virtual joysticks and feed them input from any source. Instead of targeting a specific game, my new approach would emulate joystick, keyboard, and mouse inputs. This would make it usable with every simulator out there.

Since I was using the DualShock 3 controller connected via Bluetooth to my MacBook Pro, I needed a way to get the input from the controller into Windows. Looping the Bluetooth connection through the virtual machine was not possible at that time, so I needed a way to send the inputs over the network. I decided on a two-part solution consisting of a server application running on the host operating system, which would read the input from the controller, apply the necessary mappings, and send the resulting data to a client application running on Windows. The client would then feed that input into vJoy and the Windows API to simulate input events.

I chose to write the server application in Java since it was fast, a good fit for cross-platform support, and the language I had the most experience with. For the smaller client, I went with C# because vJoy came with examples for it and it felt the most natural for accessing Windows APIs.

Within a few weeks, I had cobbled together a rough prototype of both applications, which I named RemoteStick Server and RemoteStick Client - that was in the autumn of 2014. Then after the new semester at university started, work on RemoteStick stalled.

The Impetus

A short time later, I became quite annoyed with the declining quality of OS X, as well as the sub-par performance I was experiencing with X-Plane and other games on my MacBook, so I decided it was time to switch systems again. I settled on a ZOTAC mini-PC, the ZBOX EN760, running Linux and was quite happy for a while. For the better part of a year, I mainly ran X-Plane and War Thunder on my new Linux PC, gradually improving X-Gamepad and expanding upon it (for example, by adding support for helicopters and add-on aircraft that required specific commands).

Then, after visiting the Jet World Masters 2015 in Leutkirch, the itch to fly some modern military jets got me again. I decided to give DCS World a try on my new system. Since this was by no means a powerful gaming PC, it barely ran DCS. Luckily, only a short time later, version 1.5 of DCS was released, which greatly improved performance with the introduction of Direct3D 11. Also, because this was well before the recent rise of Linux as a gaming platform, I grudgingly had to switch over to Windows to enjoy DCS.
But merely switching to Windows was not enough, I also needed a way to fly in DCS with my preferred control scheme.

Two Intense Weeks

So, I dug out the RemoteStick prototype I had written almost a year earlier and began to extend it. Basically, I wanted to get rid of the C# client and have it all in a single application that could run as a single instance feeding directly to vJoy when operating locally. Nevertheless, I decided to keep the client-server mode alive as an option. Now, however, the client and server would be the exact same Java application running in different modes.

While much of the foundation was already there, I worked incredibly hard on it for about two weeks, and what came out in the end was the first version of ControllerBuddy. Since the main focus of the application was no longer remote control, I changed the name from RemoteStick to ControllerBuddy. All of this happened between the end of August and the beginning of September 2015.

This initial version of ControllerBuddy worked great for me. I used it extensively with DCS at first, and then began diving back into other simulators such as IL-2 Sturmovik: Cliffs of Dover and IL-2 Sturmovik: Battle of Stalingrad.

Building an Ecosystem

Compared to the software today, the 2015 version of ControllerBuddy still had many rough edges. It was designed purely for my personal use and lacked not only many features it has today - like the Overlay or Profile Visualizations - but it also did not come with any documentation.

While browsing flightsim subreddits, I occasionally encountered people looking for advice on how to use a game controller for flying. I knew I had the exact tool they needed, but setting it up, configuring the simulators for it, and explaining the concepts behind ControllerBuddy would have been incredibly time-consuming.
So, over the following years, I refined not only the application itself but also the whole ecosystem around it to make it accessible to everyone.
Essential components like the website you are on now, the Install-Script, and the videos came into being.
On the profile side, while I started out with a handful of profiles for DCS modules, I gradually expanded the official profile repository to support more and more simulators, both new and old. Today, the repository counts a total of 94 profiles!

While I still see myself as the primary user of ControllerBuddy, quite a few features and enhancements over the years were directly based on feedback from a slowly growing user base. I cannot tell exactly how many people use ControllerBuddy, but based on release download statistics, I estimate there are probably at least a few hundred long-term users.
This might be a good point to say: if you are a user and enjoy ControllerBuddy, let me know! Drop a line on Discord. While most people join the Discord to get technical help - which was the main intention behind it - it is always wonderful to hear from people who are simply enjoying what I built.

Ten Years and 33,000 Lines Later

When I wrote the first line of code for this hobby project back in 2014, I would never have guessed that I would still be working on it more than a decade later, nor would I have believed that I would put more than 10,000 hours into this side project, which now spans more than 33,000 lines of code.

All in all, I am still very happy with the technical foundation I chose back then. Java has proven to be a solid choice for this project.
While Java may seem like an unusual choice for a gaming tool, I couldn’t be happier with the decision. In fact, over the last ten years, there have been countless improvements to the platform that make it better suited than ever for developing desktop applications and small utilities.
For a long time now, ControllerBuddy has been shipped as a self-contained application with a download size of about 30 MB. In an era where shipping desktop apps at sizes of hundreds of megabytes is the norm, that’s a number I can live with.
The same goes for memory consumption: after a few recent optimizations, ControllerBuddy uses about 100 to 150 MB of RAM - an amount that is completely negligible, even on low-end systems.

Many of the architectural choices, like the client-server architecture, have also proven to be highly powerful and extensible over the years. While I have refactored many essential parts and switched out underlying libraries more than once, the basic architecture remains the same as it was in 2014 because it simply works.

I still work on ControllerBuddy almost every day in one way or another. While there are periods with relatively little change, during which only dependencies get updated, there are also times when I have grander ideas. These include user interface overhauls or even monumental tasks like switching out the underlying input system from GLFW to SDL3, which I undertook in early 2025. Most of the time, such ideas just come to me on a whim when I learn something new or get excited to try out a promising technology.
Next to working on the core application, there are always things to improve or expand upon on the website or the Install-Script, or a new simulator module gets released and a profile has to be created for it. All I’m saying is that it never gets boring…

Finishing Line

Congratulations on making it this far, and thank you very much for your interest!

I have no idea how many people actually read these posts. If I had to guess, I’d say the number is probably very small.
That’s why I’d love to hear from you! I want to know what kind of posts you find interesting and learn a bit more about my audience. Your feedback helps me decide how many technical details to include and whether it’s worth my time to continue writing posts like this one. The best way to reach me is via Discord.

Sun, Sweat, and Status Reports

With a major heatwave currently sweeping across Central Europe, summer is well and truly here. But despite the sweltering temperatures, I am keeping up with my resolution to post regular updates on the development of ControllerBuddy. Here is a look at the most important news and changes from June and the better part of May 2026.

Assignments Tab Overhaul

In the May 2026 Status Update, I reported on the refinements I worked on for the Component Editor. During the last few weeks, I took it upon myself to overhaul the Assignments tab.

While the overall layout and functionality did not change, the aesthetics changed quite a bit. Although the old look was very functional, it clearly lacked the outline of a controller.
The previous iteration of this central part of the user interface was introduced in 2018. At that time, ControllerBuddy did not yet have a userbase to speak of. Consequently, looks were really not that important back then. In fact, at that point in time, ControllerBuddy did not even use the FlatLaf Look And Feel, which was introduced during 2019.

All in all, I hope the new look catches on with people. As always, when reworking older sections, small bugs and inconsistencies get fixed, and as a result, the overall quality of the codebase improves - it was no different in this case.

Reducing Memory Footprint

Motivated by the seemingly never-ending surge in computer hardware costs, I took some time to reduce the memory footprint of ControllerBuddy. While ControllerBuddy was never a resource hog to begin with - before my efforts, it typically consumed between 200 and 300 MB of RAM - it now sits at about 180 to 200 MB.

The reduction in RAM usage comes primarily from the fact that I disabled the C2 compiler of the JVM. While in theory this reduces the optimization level that long-running code in the JVM can reach and thus theoretically increases the CPU footprint, ControllerBuddy is in no way CPU-bound and typically uses less than 1% of CPU anyway. Therefore, there is no measurable drawback to giving up a tiny bit of runtime optimization in exchange for reducing the memory footprint by nearly one-third.

Issues with Controller Detection

One of the most regular issues encountered by people using ControllerBuddy involves controller detection problems. Very often, these issues concern third-party Xbox controllers. This sometimes results in lengthy troubleshooting sessions with users I am trying to help. Recently, I had another one of these sessions with a new user who had trouble getting their PDP Afterglow controller to work.

Under the hood, ControllerBuddy relies on SDL3 for controller abstraction. Depending on the operating system and the particular controller model, SDL uses different APIs to communicate with the controller hardware. On Windows, for Xbox-compatible controllers, this is usually XInput.

In this particular case, the solution to the problem was to force SDL to fall back to other APIs by disabling XInput via a special environment variable. While this fixed the problem for this user, explaining to non-computer-savvy users how to create an environment variable - which may or may not solve the issue for them - can be a pretty lengthy process.
Thus, in order to simplify things, I added a new setting to ControllerBuddy that allows disabling XInput specifically for the application via a checkbox in the Global Settings tab. I hope that this new option will help people self-troubleshoot similar issues in the future.

DCS F-100D, Legacy Sims, and IL-2 Korea

June 2026 also saw the release of the Grinnelli Designs F-100D Super Sabre for DCS. I was really looking forward to this new module, and I have to say I have not been disappointed at all. Flying the F-100D has been great fun so far, and waiting for it was well worth the time. For a first commercial release, the Grinnelli folks really did an awesome job!
After the module was released on June 12th, I quickly got to work and was able to provide an official ControllerBuddy profile for it merely a few hours later.

Before jumping into the F-100D, I spent some of my time diving back into old sims from the 90s on my Steam Deck. I particularly enjoyed my time with the recent Steam re-release of F-22: Air Dominance Fighter and with the classic F-15 Strike Eagle III, Falcon 3.0, and my childhood favorite Jetfighter III.
As a result, the profiles for these games have received some tweaks and improvements.

Finally, I am looking forward to the upcoming release of IL-2 Korea in August. While this new entry to the IL-2 series is already available in early access, I decided to wait for its release on Steam. After getting hold of it, I plan to quickly come up with a profile and configuration script for it, assuming the current issues it has when running on Linux with Proton are solved by then.

Aloha!

It has been a few months since the February update, and while the weather is warming up, the development pace for ControllerBuddy hasn’t cooled down.

The slight delay in getting this post out was for a very special reason: my recent trip to Hawaii, where my wife and I officially tied the knot! We had a truly wonderful time celebrating our marriage and enjoyed the break immensely after a busy start to the new year.

As always, work on ControllerBuddy has continued with a variety of updates and enhancements. Here are the details on what has changed since my last news post.

Refining the Component Editor

A major focus since the last news post was a significant overhaul of the Component Editor dialog to make profile creation more intuitive. The goal was to add documentation for the different types of Actions and integrate it directly into the interface. To achieve this, a contextual help system for Actions and their properties was added, providing immediate guidance where it’s needed most.

Furthermore, UTF-8 symbols for each Action type and property were added to make them more recognizable at a glance and to make the dialog less monotonous. Moreover, the layout of the entire dialog was improved for better flow and clarity. Finally, the descriptions of the assigned Actions are now displayed directly within the Assigned Actions list, which is especially helpful when multiple Actions of the same type are assigned simultaneously.

Flexible Action Delays

A seemingly small but powerful new feature is the introduction of customizable action delays. Previously, Actions that had the Delayed Action property enabled featured a fixed delay of 1 second, meaning a button had to be held down for at least that long before the Action triggered. A new property called Delay was added, which is a freely configurable time interval. This offers far more precision for specific controller or simulator needs, allowing for much more flexibility in how inputs are processed.

Leveraging Agents for Documentation and Tests

Like most people in software, I’ve started using AI coding agents recently to handle the kind of tedious work that usually falls by the wayside. This has allowed me to tackle codebase improvements that would have simply taken too much time to do manually.

To start, an AGENTS.md file was added to the repository. This file is specifically designed to help coding agents navigate the project structure and understand the coding standards more effectively.

Until recently, the codebase of ControllerBuddy contained no documentation at all. With the help of AI, Javadoc comments were added to the entire codebase. While these were mostly generated using the aforementioned agents, they provide essential context for every class and method, making the project easier to navigate and maintain in the future.

In the same vein, the codebase lacked any tests. Over a few days, leveraging AI, nearly 600 tests were created, including unit tests and tests of the complete input pipeline. These tests have already uncovered a few minor bugs that were promptly fixed, and they are primarily meant to prevent potential regressions in the future.

The above changes significantly improve the overall maturity of the codebase, and would never have been implemented if I had to write them all by hand due to the massive time investment required. While the usage of agents made these additions feasible in the first place, a significant amount of time still had to go into reviewing and tweaking the vast amount of code that was generated. At this point in time, the testing code alone comprises nearly 10,000 lines!

Java, Profile, and Install Script Updates

Continuing the tradition of staying up-to-date with the Java ecosystem, a switch from JDK 25 to the newly released JDK 26 was made to utilize the latest performance improvements and JVM features.

A small update of the Install Script was necessary to support Git for Windows version 2.54.0. If you’ve been having trouble with a fresh install, this update should clear things right up.

On the profile side, a new profile was added for the Steam re-release of the classic F-22: Air Dominance Fighter.
To celebrate its release, I created a quick video to showcase how well the F-22 ADF works with ControllerBuddy on the Steam Deck.

As always, various small improvements to several existing profiles were also implemented.

A New Year, New Updates

How time flies… we are now well into February, and it has already been a busy start to the year. Since my last post in early December, I have been working on several updates and improvements to ControllerBuddy and its broader ecosystem, the details of which I would like to share here.

Linux Guides Published

As announced in my previous post, I have been writing detailed setup guides to assist users interested in running ControllerBuddy on Linux. These guides have now been published in the ControllerBuddy-Linux-Guides repository on GitHub.

The repository currently includes guides for:

• DCS World
• EF2000 V2.0
• Falcon 3.0
• Jane’s Fighters Anthology
• IL-2 Sturmovik: 1946
• IL-2 Sturmovik: Great Battles
• Strike Fighters

A guide for Falcon BMS is currently in the works and will be added in the future.

ControllerBuddy Development Updates

Next to the usual smaller bug fixes and optimizations, I have been working on a few larger features and improvements for ControllerBuddy itself, which I would like to highlight here:

Activation Intervals

I have redefined the meaning of the activation interval for single-immediate and single-on-release actions. Previously, this interval was ill-defined for these action types and offered little practical utility. With this change, the activation interval now directly controls the precise duration a joystick button, key, or mouse button is held down in all cases, enabling outputs to be performed over a defined, prolonged time interval.

Visualization Tab

Profile visualizations now feature a dedicated legend to clearly depict the meaning of the various symbols used in the depiction. Additionally, I have implemented panning support, allowing users to move the visualization when zoomed in. This should make it significantly easier to navigate and analyze complex profiles.

Packaging

I have implemented packaging optimizations that reduced the overall size of the .zip and .tgz archives by a few megabytes. Depending on the platform, this results in an archive size of approximately 30 to 34 MB, which is quite reasonable compared to some other modern applications.

Wayland Support

I have begun work on native Wayland support for Linux, leveraging the JetBrains Runtime. This is an ongoing effort, and you can track the current progress and technical milestones in a dedicated GitHub issue. While ControllerBuddy currently works well on Wayland via XWayland, native support remains a long-term goal that depends on developments within the Wayland, JetBrains Runtime, and Wakefield projects.

New Profiles and Install Script Improvements

Two new profiles have been added to the ControllerBuddy-Profiles repository:

1. Nuclear Option
2. F-15 profile for Falcon BMS (This was requested by multiple users, so I have finally taken the time to create it.)

In addition, as always, I have been making minor adjustments and improvements to existing profiles and the configuration scripts to ensure they remain up-to-date and continue to provide the best possible experience for users.

Last but not least, I have made various smaller improvements to the install script, including better error handling.

The News Section Debuts!

A long-term goal since ControllerBuddy’s inception 11 years ago has been to make it more accessible and better documented. While the software was always perfectly usable, the addition of the website, tutorial videos, and install script over the past years have steadily made it easier for a wider audience to set it up. As a direct result, the number of users from all over the world has steadily increased over the last few years.

In the same vein, in order to communicate new features and changes more effectively, I decided to introduce a dedicated news section on the website, which you are reading right now! If all goes well, I plan to post regular updates about new releases, features, and other relevant topics here in the future.

With the year coming to an end, I naturally tend to reflect on the progress made over the past twelve months, making it the perfect theme for this very first news post.
So, without further ado, let’s dive into what was achieved in the past months:

The Year of the Linux Desktop

For me, 2025 was somewhat of a turning point with my switch to Linux (I use Arch, by the way) as my daily driver.

Having used Linux for gaming and simming on and off during the mid-2000s, I’m by no means a novice to Linux as a desktop operating system. Over the past few years, mainly due to Valve Software’s initiatives, gaming on Linux has become easier than ever. Compatibility and performance have improved by leaps and bounds, reaching the point where Linux is now a viable alternative to Windows, for most flight simulators.

Although Linux support is now more prominent, ControllerBuddy will of course continue to fully support Windows as well as a first-class citizen.

January: Enhancing Linux Support

ControllerBuddy has supported Linux for quite some time, but a major obstacle was the inability to run the configuration scripts within Wine / Proton. This was because they required Windows PowerShell 5.1 to run, and while PowerShell 7+ works great with Wine, there is no feasible way to get older releases working.

Therefore, I decided to update all configuration scripts to support PowerShell 7+ while maintaining compatibility with PowerShell 5.1 for a seamless out-of-the-box experience on Windows.
Additionally, a few minor changes were necessary to support the virtual joystick device on Linux.

While launching the scripts within a Wine prefix on Linux is a bit more involved than on Windows, the functionality offered is now exactly the same on both platforms.

February: The Shift to SDL3

A recurring theme throughout the year was my continuous effort to reduce ControllerBuddy’s direct dependencies, either by eliminating them or replacing them with more modern alternatives.

For handling input devices, ControllerBuddy had relied on GLFW for several years. This was coupled with a lot of custom code to support advanced features of Sony controllers via a proprietary HID driver. On Windows, jxinput was used for native XInput controller support, and on Linux, more custom code was needed to implement what was frankly pretty poor rumble support.

With the release of SDL3 in January and its support arriving shortly thereafter in LWJGL, I saw an opportunity to switch ControllerBuddy to this brand-new backend. This move effectively reduced the amount of code required for handling all these different controller types to zero, while simultaneously improving compatibility.

The only negative consequence of the switch to SDL3 was that I had to strip support for OpenVR-based overlays. While this is certainly a shame, I doubt it significantly affected many users. OpenVR has largely been replaced by OpenXR, and supporting the latter is a completely different challenge.

All in all, the switch to SDL3 was probably the biggest change to ControllerBuddy this year, and I couldn’t be happier with it. SDL is a joy to work with, and its APIs and documentation are simply superb!

March: Adopting the FFM API

Continuing my quest to reduce dependencies, the next goal was to eliminate the JNA library, which allows convenient access to native functions from within Java.

• On Windows, JNA was used by ControllerBuddy primarily to communicate with the vJoy driver and the Windows API.
• On Linux, JNA was used as part of linuxio4j to communicate with the UINPUT module.

While JNA is easy to use, a modern alternative, the Function and Memory (FFM) API, was finalized with Java 22. It represents the future-proof and most efficient way to access native APIs from within the JVM.
Since I constantly strive to keep ControllerBuddy up-to-date with current Java releases and utilize new language and JVM features as soon as possible, I completely replaced JNA with FFM and eliminated linuxio4j entirely by writing my own FFM-based UINPUT interface.
While likely not noticeable to users, the switch to FFM made calling native code within ControllerBuddy measurably more efficient and state-of-the-art.

July: Modernizing the Build System

My efforts to remove third-party dependencies also extended to the Gradle build script.

I relied on multiple plugins, which occasionally made it harder for me to update to the latest Gradle versions. With the imminent release of Gradle 9, I decided to remove all plugins that are no longer actively developed.

Additionally, I took this opportunity to port the entire build script from Groovy to Kotlin.

August: New Tutorial Videos

During August, I tackled a topic I had been avoiding for a long time: the creation of up-to-date video tutorials to guide new users through installing and using ControllerBuddy. I had put this task off for so long because I’m simply not very proficient in video production.

After getting to grips with kdenlive, I was able to produce new videos that, while certainly not Oscar-worthy, should lower the barrier to entry for new users significantly.

November: Overlay and Button Action Improvements

November saw the introduction of horizontal overlay axis indicators.
I was able to put this feature to good use immediately with the release of the C-130J module for DCS. The C-130J uses a horizontal relative axis for the nose wheel steering tiller, and a horizontal indicator made perfect sense for displaying its exact position in the overlay.

Also during November, with the 1.6 release of ControllerBuddy, button actions were enhanced to also support single immediate and on-release activations.

December: SVG Rendering and First Donation

At the beginning of this month, I replaced the previously used Apache Batik library with the more modern jsvg alternative.
jsvg is used to render the SVG visualizations of profiles.
While I had to introduce more custom code to handle the correct sizing of the viewBox (i.e., the viewport of an SVG), the switch had the benefit of reducing the overall size of the entire ControllerBuddy folder by about 3 to 4 MB, depending on the platform.

Also, in fact just yesterday, I was very happily surprised with the first donation I received from a ControllerBuddy user, who pressed the donation button that I first introduced a few months ago.
I am so grateful for this wonderful gesture, as it perfectly validates the appreciation for the long hours I have poured into this project over the last decade. Thank you!

Future Plans

With my switch to Linux, I also started documenting how I personally set up my flight simulators on Linux with Proton in conjunction with ControllerBuddy.
At first, I only created rough notes intended to allow me to easily reproduce my results in the future. Recently, I decided to start turning these notes into fine, detailed guides that, in the future, other people will be able to follow to start simming on Linux the ControllerBuddy way.

Thank You and Happy Holidays

Thank you for using ControllerBuddy, for following its journey, and for reading this annual review.
I look forward to sharing more updates with you in the new year.
Until then, happy holidays and all the best for 2026! 🎁🎄🎆