Bookmark and Share

For FSX and P3D, Developed by Artem Crum and Günter Steiner
Reviewed by Brian Cowell
July 2013

LINDA — what is it?

When reviewing scenery, or an aircraft, or even simming hardware, it is usually fairly safe to assume that the reader is at least vaguely aware of what kind of product is being reviewed. In the case of LINDA, however, it will be necessary to begin by first explaining where it fits in to the simmer’s world, and how and why it came to be, before moving on to describe what it does — and then reviewing how well it does it. So please understand from the outset that this review will be slightly lengthier than would otherwise be the case!

LINDA — who needs it?

If you have been involved in flight simulation for as long as I have, over the years you will have become familiar with the Frequently Recurring Question on various simming forums: “But what do I need FSUIPC for”? Clearly, there are still simmers who have never (or never knowingly, at least) encountered the need for the facilities that FSUIPC provides. And because LINDA is essentially a graphical front-end for the Lua functionality made available by the registered version of FSUIPC, it would be helpful — and, arguably, vital — to put both FSUIPC and LINDA in some sort of context.

A little ancient history

When Bruce Artwick’s subLOGIC Flight Simulator franchise was licensed by Microsoft in the early 1980s, it was used as a demonstration of the first “Color Graphics Adapter” card that was made available for the original IBM PC. I was already using the subLOGIC flight simulator for the Apple ][, and so the “Microsoft Flight Simulator” was a natural next step. (Translation: I was already hooked). But in those early days there were no add-on controls, so you had to control your aircraft using just the keyboard and perhaps the mouse, which we will all agree is certainly not the best way to do it.

So, surprisingly quickly, various hardware devices became available for the growing interest in flight simming on home computers. These early controls initially had to be interfaced via a serial port, since USB hadn’t been invented yet, and came to be categorised along with mice and keyboards as Human Interface Devices, or HIDs. (Notice that term, because we’ll be seeing it again, soon).

Introducing FSUIPC

The factor which made simming controls different was the need to decode a range of possible input values — and for elevators, ailerons, rudders, and throttle as a minimum. These controls were given the generic name “axes”, since each one worked by the human operator moving a wheel or a knob or a lever round its own axis to the required position: interfacing them became slightly easier when USB was introduced in the mid-to-late 1990s. As more and more different makes and models of controls became available, Pete Dowson’s FSUIPC became the standard way for simmers to define the communication with the axes on these devices. And although dealing with the axes was always FSUIPC’s main claim to fame, it could deal with buttons, too — as long as you were willing to edit the fsuipc.ini file in the event that you wanted to do anything that was less than straightforward, such as sending more than one keystroke in response to a single button press, for example.

It was because Pete Dowson recognised that simmers’ needs were becoming ever more complex that he fairly recently decided to incorporate support for a programming language called Lua into FSUIPC. This is a huge improvement: instead of having to grub around editing ini files and calculating hexadecimal values, it’s now possible to write code such as the following:

      -- Turn all fuel pumps off except for left fwd (for the APU)
      NGX_PUMPS1and2_off ()
      NGX_PUMPSCTR_off ()
      NGX_PUMP1_FWD_on ()

That, you must admit, is much easier to read, and to work with. “But”, I hear you cry, “I’m not a programmer, I just want to fly” — which is entirely understandable. And being the expert programmer that he is, Pete Dowson simply provided the interface for anyone who wanted to use it (as long as they could read and understand his documentation) and then let us all get on with it.

The start of LINDA

So it was that a few brave souls began using Lua to code various useful scripts, which were posted on the FSUIPC forum: amongst them was Günter Steiner. Günter also became adept at searching through the developer’s code for a specific add-on aircraft to locate somewhere to hook the Lua code into, so as to be able to press a physical button which flipped a cockpit switch or whatever and achieved the desired effect. He then started working with Artem Crum: Artem had the idea for making a graphical front end to their growing utility, and so it was that LINDA came into being.

LINDA’s claim to fame

The simplest possible way to describe LINDA is to say that it does for buttons what FSUIPC does for axes: in other words it makes them accessible and extremely easy to assign, using a graphical interface. And that’s all that a lot of LINDA’s users use it for — although there’s much more to it.

For example, LINDA also provides a useful tool to enable us to search through and find the “hooks” in the developer’s code for a specific aircraft, using its inbuilt Tracer function.  

So within 24 hours of the PMDG NGX being released, Günter released the first LINDA module for it, which is quite a feat, I have to say! (The current version of the LINDA module for the PMDG NGX exposes seven hundred and thirty-seven different functions for you to use as and when you wish, affecting almost every aspect of the aircraft’s controls). The business of Tracing can get a bit technical and therefore it will never be to everyone’s taste, but happily enough users are willing to take the time to do it that we all are able to benefit from an impressive support list of add-on aircraft, which you can use without having to get involved in anything technical yourself.

It was about that time that VRinsight introduced their “MCP Combo”, an attempt to give the simmer a universal MCP (and EFIS and Comms) hardware unit that could be interfaced to add-on aircraft. Unfortunately — as, for example, in the case of PMDG aircraft — it often didn’t cope at all well, and so LINDA was extended to also incorporate support specifically for that piece of hardware.

When VRinsight introduced v2, LINDA continued to support v1 whilst adding support for the new “Boeing” version of the device, incidentally.

But for the remainder of this review I’m going to concentrate on LINDA’s talents for interfacing buttons and switches, since that’s what most people use it for, most of the time.

What LINDA needs in order to be able to function

The first requirement in order to be able to run LINDA should be pretty obvious from the foregoing — you need a registered current version of FSUIPC v4 (i.e. for fsx), since LINDA is built upon the support that FSUIPC provides for Lua. Yes, that’s true even if you have no intention of getting into Lua programming yourself. (And since Pete Dowson only built Lua support into version 4 of FSUIPC, you obviously need Microsoft’s fsx, too).

The second thing to say is  that (with the exception of the VRinsight Combo, which has rotary encoders that are supported internally by LINDA) it only supports those button devices which show up as HID devices to Windows. So if you can’t see your device in [Start Orb] | Devices and Printers, then it’s unlikely that LINDA can talk to it. (OK, that’s not terribly usual, but it does happen — but as ever, the VRinsight Combo is a special case, so I won’t mention it again….).

Here, for example, you see an extract from my own Devices and Printers screen, and as you will notice the Thrustmaster Warthog Control Units are recognised, along with something that is cryptically identified as “usb pad”, which is in fact a VRinsight TT switch panel. If I right-click its picture and select “Game controller settings” and then click the Properties button, I see the device as Windows sees it (with switch 15 in the On position, in the illustration). Two things worthy of notice are that (a) X Y and Z axes are depicted in spite of the fact that the device has no axes at all (!), and (b) a POV hat is shown — which strangely enough is correct, since four of the buttons on the device are mapped as a hat and can be used in combination to provide any of the eight hat positions. Moral: don’t necessarily trust what you see in Microsoft’s depiction!

But the point I’m really making is this: if, like the “usb pad”, the buttons on your device can be seen working in this view, then LINDA will recognise them: otherwise, it can’t (and therefore won’t).

And please forgive me if I mention — for the last time, I promise — that LINDA is in the buttons business, so that although it will recognise the switches on your Saitek throttle, for example, (including the hidden ones for engine reverse), it will ignore the axes completely — so use FSUIPC for those.

The installation of LINDA could hardly be more straightforward. You simply unzip the latest distribution into the Modules folder of your fsx installation: if you install the version of LINDA which also contains its modules for a number of popular add-on aircraft, they will all be installed at the same time. For full details, see the official LINDA manual that comes with the distribution, although non-techies often prefer to use the “detailed manual” which is currently available from this link —

This is probably a good moment to also mention the LINDA forum and source for downloads, which is on Avsim, here —

So much for the requirements: now at last we can start to look at the goodies which LINDA brings to your simming party.

LINDA — the good news

Let’s begin this section of the review with the news that everyone likes to hear: you don’t have to pay for LINDA! Its authors chose to release it as donationware, so once you have discovered for yourself just how much LINDA can do for you, you can donate whatever you feel is appropriate.

After a respectful pause in honour of that decision, let’s now consider an example of just how easy it is to use LINDA to make your buttons do useful and interesting things for your add-on aircraft of choice.

The first priority (assuming that you’re not starting from scratch and setting out to Trace the code of a recently-released aircraft) is to ensure that you have installed the latest version of the LINDA module for the aircraft you’re using — as well as LINDA itself, of course. In view of its huge popularity I’ll use the PMDG NGX for these examples, but you will find modules for many other add-on aircraft in the Downloads section of the LINDA forum (I’ll give you a list, soon) – and, of course, all the default fsx aircraft are supported “out of the box”. When you start fsx, LINDA will automatically know which aircraft you are currently using, and load the appropriate module.

Assuming that is the case, therefore, and that you have also been through the suggested procedure in the manual(s) to assign and check out the functions for the default aircraft, the rest is easy. I’ll use the same example as the one given in the “detailed manual”, which is the common task of assigning a three-position switch to control the lever which raises and lowers the undercarriage (or “gear” for those on the other side of the Pond) so as to assign to the hardware switch an up, a down, and a central depressurised position. I’ll work through it slowly, so you can see the relevance to LINDA.

Without LINDA, this would be something of a nightmare with a complex add-on aircraft, but if you look through the vast list of functions which have been Traced for the NGX, you will very quickly identify the fact that you somehow want the movements of the switch to utilise the functions —


— to get the effect you want. But how do you achieve that effect in LINDA?

Once fsx is running, the LINDA screen will display the name of the currently-loaded aircraft at the top, and a list of the available switches running from top to bottom, down the left-hand side. It will also display your currently-saved button configuration for this aircraft, with three columns for each movement of the switch or button (a button is simply a switch that won’t hold in the on position):

On Press             Actioned when the button is pressed, or the switch is turned On.
On Repeat          Actioned while the button is held down (or the switch is left in the On position).
On Release         Actioned when the button is released, or the switch is turned Off.

If you look at the Thrustmaster diagram of the three-position switch at the front right-hand corner of the Warthog throttle unit you will see that in fact it comprises two switches, electrically speaking. When the switch is up switch 27 is on; when the switch is down switch 28 is on; and in the middle position both 27 and 28 are both off.

Now consider the sequence of events in the cockpit. Until takeoff, the switch (gear lever) is in the down position (sw 28 on, 27 off). Once a positive rate of climb is established, the switch is moved to the up position (sw 28 off, sw 27 on), and when the flaps are retracted the switch is returned to the centre position (both off). On the approach, the switch is returned to the down position (sw 28 on).

At this point you will be starting to see where this is leading us: in LINDA terms we have the following situation:

  • When the switch is moved from down through the centre position to Up, we have an On Release action from sw 28, followed by an On Press situation from sw 27. (OK, we also have an On Repeat from sw 27, too, but we simply ignore that).

  • When the switch is moved from Up to the centre position, we have an On Release from switch 27.

  • When the switch is moved back to the Down position, we have an On Press from switch 28 (with the On Repeat, which again we ignore).

So using the On Press and On Release columns for those two switches in LINDA, we set things up like this:

LINDA hog throttle - gear lever programming

So when the switch is moved through the mid-position to ‘up’ on leaving the runway, LINDA looks at On Release for sw 28 (which is empty, so nothing happens) and then On Press for sw 27, whereupon it triggers the NGX gear up function. When the switch is moved to the centre position, LINDA detects an On Release for sw 27, which calls the NGX’s gear off function. And when the switch is moved to the down position again for landing, LINDA calls the NGX’s gear down function (On Press for sw 28). Which is what we wanted.

It could hardly be easier — thanks to Artem’s GUI front end for LINDA, and Günter’s excellent work in Tracing the NGX functions for us.

You may have noticed that in the above example I utilised NGX-specific functions, but LINDA also provides a plethora of other functions for you to use. For example, you have a long list of fsx standard controls (increment and decrement flaps, throttle controls — which may not be applicable to advanced add-on aircraft, of course — and brakes. Furthermore, you have similar lists of functions for A2A Map, Aivlasoft EFB, IVAO IVAP, Reality XP, VRinsight, and Weather functions. And if that’s not enough for you, you can also have your own User functions — scripts that you yourself write to create your own Lua functions which can call any of the functions in the other lists.

At this point you are probably beginning to glimpse the amazing amount of power that is available to you within LINDA. Not only can you map any of your existing buttons, but you can map them to a vast range of hitherto-inaccessible internal functions of your aircraft and hardware, too.

Roll your own?

The above phrase derives, of course, from those who prefer to use cigarette paper and tobacco in a small machine to literally roll their own cigarettes, rather than buy the pre-made sort. The applicability to the present discussion is that, as mentioned above, LINDA allows you to write your own Lua functions from scratch (not for the faint hearted, but not complex, either) — or, more commonly, string together functions from elsewhere to achieve the purpose you have in mind.

The partial (this review is already lengthy) example I’ll show here relates to the situation in a 737 when you have started your engines and then need to do a whole list of things such as stopping the APU and so on without (in my home cockpit, at least) a First Officer to assist. I don’t use FS2Crew or anything of that kind, so it’s quite difficult to flip a whole series of switches on the overhead panel and elsewhere whilst simultaneously negotiating a relatively narrow taxyway and trying not to break all the little lamps along the edge. So I wrote a simple function called BC_After_Engine_Start which I assign to a single switch: this provides a perfect solution to the problem.

(There’s more code than is shown above, but you get the idea). As you will also have noticed, one of the other goodies in LINDA that I haven’t yet mentioned is a complete, context-sensitive, colour-coded Editor, which you can use not only to write your own Lua functions, but to check the Lua syntax as you go along. (There are plenty of Lua tutorials on the Internet, and it’s far from being a hard language to learn — also, you don’t need to know much of it to get you started).

Once you’ve strung together as many functions as you need, you simply assign your new all-embracing container function to your designated switch or button: it will appear under “User functions” in LINDA’s list of available functions, as here:

Incidentally, if you’d like a list of the functions — 737 of them, no less — that are available in the current NGX module (v1.9), you can find it in post #310 on this page:

LINDA can really shift

You may feel that three actions for each individual switch (press/repeat/release) is an embarrassment of riches, but in fact LINDA goes the extra mile and even provides you with a way of effectively doubling the number of buttons that you have! On the page of assignments for the buttons on your choice of aircraft and device you will find a small checkbox labelled “Shifted”.

When checked, the column labels for On Press and so on turn red, with an asterisk, and you have a totally new page of assignments for each button or switch. You can assign up to two different buttons to the shift function: one button enables a Local shift, (i.e. the shifted property applies to the nominated device but not to your other devices), whilst the other enables shift Globally (so the shifted property applies to them all).

If you are short of buttons, this is a huge blessing, since it doubles the number (less one or two for the Shift function itself). But although my Warthog stick and throttle unit, combined with the VRinsight TT panel, gives me a very generous number of switches, buttons, and hats, I still use LINDA’s Shift function, since there I can put the functions I would never want to trigger accidentally by pushing the wrong button (engine cut is the most obvious example). Since the Shift button has to be held down whilst accessing the secondary button assignments, this is a useful safety feature.

What if something goes wrong?

LINDA is very stable, but clearly there will be occasions when you (usually) have done something wrong and need to fix it. On such occasions there are at least two places where you can look.

The first is the obvious one — the traditional Windows message box (which may, of course, end up hidden behind your fsx if you are using full screen view, but nonetheless will be awaiting your attention when you exit fsx), whilst the other is LINDA’s Console which you can view any time you wish by pressing F1 — unless you’ve remapped that key — or always by clicking on the link in LINDA’s Settings Window (obviously, you will have to temporarily move to windowed view if you are running fsx full-screen and want to check the Console immediately).










As you can see, the Console gives you a pretty comprehensive log of everything that happens during your LINDA session, should you need to know. Furthermore, if (in spite of the LINDA Editor’s syntax checking) you should have incorporated any syntax errors which prevent a module loading — which tends to happen to me when I have edited the lib-user.lua file using a different editor — you will find helpful diagnostic information on the Console in friendly red letters, along with the location of the error.

(As an aside — be aware, as they say, that the Lua language is case-sensitive: if you want to call NGX_WHEEL_WELL_on but actually type NGX_WHEEL_WELL_ON, that’s a syntax error! And yes, I discovered that the hard way….).

LINDA in action

As we have seen, LINDA provides us with an extremely powerful, and professional, interface to button or switch programming, allowing access to cockpit functions which have hitherto been inaccessible to simmers other than by mouse-clicking on a switch in cockpit view. When you choose an aircraft within fsx, LINDA notices your choice, loads the appropriate module, and assigns your current choice of button mappings. It’s smooth, and it works quietly in the background without you having to worry about the details — once you have assigned your buttons (and I should add that you can, of course, also make your buttons send standard fsx keystrokes, if all else fails).

As I said, basically LINDA does for buttons what FSUIPC does for axes: it’s a professional product at an unprofessional price.

Of course, whether LINDA will work well in your setup depends on whether the particular add-on aircraft you want to use today has a LINDA module already written for it (in other words, someone else has already done the hard work of Tracing the internal calls and mapping them to usable function names). The official, albeit not quite complete, list of supported aircraft, as well as one or two other things, is currently as follows:

● A2A Accusim map controls
● A2A B17
● A2A B377 Captain of the ship
● A2A Spitfire
● Aerosoft Airbus X
● Aerosoft Catalina
● Aerosoft Katana X
● AivlaSoft EFB
● CaptainSim 757
● Carenados (all)
● DA Dornier 27
● FSX default aircraft (all)
● iFly 737
● Level-D 767
● PMDG NGX (with full display sync on the VRinsight Combo unit)
● RealAir Duke Turbine
● VRS F/A-18

The extent of the support provided by the module varies, of course, depending on your choice of aircraft. Since all these aircraft are on the list thanks to someone spending time with the Tracer, the number of functions which have so far been discovered differs in each case. For example, the initial release of the LINDA module for the QualityWings Ultimate 146 Collection is not included in the above list, since although many functions are already established there are still a few MCP functions which are proving difficult to nail down. But if you pop back to the LINDA forum every few weeks, you may discover that there has been an update….

And, of course, if you’re willing to dive into the Tracer, you may be able to interface your choice of add-on aircraft with LINDA by your own efforts. I should, however, mention two caveats here. The first is the obvious one: seeking out internal calls, even with the Tracer’s help, is definitely as much of an art as it is a science, and hence takes a certain amount of practice and research. The second, however, is that very occasionally one may encounter an add-on aircraft which uses methods which seem to defy the Tracing of their internal functions — initially, at least. But, happily for us, this is unusual.


Whilst brilliant in both concept and execution, LINDA is difficult to categorise in view of the fact that people of different skill levels will deploy it in markedly different ways. Those with little technical knowledge may use it only with existing aircraft profiles, and/or for its VRinsight MCP Combo abilities. People with some programming ability will no doubt use it to create their own functions, which probably incorporate functions for their aircraft which have been exposed by others. A few will dive into the Tracer with great glee and use that powerful tool to start interfacing new aircraft, or add to the functions already available. Many will use it as a delightfully straightforward way of assigning button presses to various fsx, aircraft-specific, or other functions.

Its ease of use is impressive, especially when you take into account its power. The advanced functions are kept well away from the assignment screen, so that those who wish to use it as a simple button-assignment tool can do so without being intimidated by the more complex stuff — indeed unless they specifically call it up they may not even be aware that it is there.

LINDA is clearly aimed at the hard-core simmer who has made an investment in external hardware, and it excels at what it does. The fact that it has been released as donationware is amazingly generous to the simming community — although inevitably that also means that support has to be provided via the LINDA forum, and is therefore made available by other users, as well as the developers, as and when they can. Therefore, one clearly cannot anticipate anything like the same level of support as would be put in place for a payware product emanating from a large organisation: all I can say is that my own experience indicates that the LINDA forum does indeed provide helpful support in the event that it is needed — albeit not always in as timely a fashion as one might wish, which is hardly unreasonable given the price paid.

Scoring note

So what is the Mutley review rating for LINDA?

It is, to say the least, unusual to find a donationware/freeware product which offers the usefulness, power, professionalism, and friendliness of LINDA.

This has not been a straightforward decision since there is no single overall score which will be appropriate for everyone. As mentioned above, how many of LINDA’s facilities you use will depend on your technical skill as much as your addiction to fsx and also your ownership of button and switch-laden hardware. But since LINDA is clearly intended for the more advanced simmer, it has to be evaluated on that basis, and therefore the scores are as follows:

Verdict: g
• Ease of Use: 10/10
• Features: 10/10
• Documentation 10/10
• Performance: 10/10
• Value For Money: 10/10
    Mutley's Hangar score of 10/10 - "Outstanding"

Finally: Why is it called LINDA?

I thought you’d never ask.  It’s an acronym for Lua Integrated Non-complex Device Assigning.

So now you know!

Brian Cowell
Review machine Spec:
Intel i5 760 O/C 4GHz | 16GB DDR3 RAM |NVidia GTX670 FTW GFX Card |Windows 7/64