How do I build external PAPI lights for Microsoft Flight Simulator using an Arduino?

We build external PAPI lights for Microsoft Flight Simulator by using an Arduino as an LED controller and a small PC-side bridge that reads aircraft data from MSFS. The big catch is that MSFS does not usually expose a ready-made “PAPI lamp output”, so we normally calculate the red and white indication ourselves and send that pattern to four light units.

Can Microsoft Flight Simulator drive real PAPI lights directly?

Not in the simple, plug-and-play way most cockpit builders hope for. Microsoft Flight Simulator shows PAPI lights visually in the scenery, but that does not mean it provides a direct hardware output saying “lamp 1 white, lamp 2 red” for an external Arduino panel.

In practice, we usually do one of two things:

• Compute a PAPI indication from aircraft position relative to the runway threshold or aiming point.
• Approximate the PAPI from glidepath deviation if we are flying an ILS or other guided approach.

The first method is more realistic. The second is easier to build.

What is the easiest way to build Arduino PAPI lights for MSFS?

If you want something that behaves like a real external PAPI bar beside your monitor or cockpit shell, we recommend the runway geometry-based method.

Parts you need

• Arduino Uno or Nano is enough for four light units.
• Four red/white light units. The simplest option is four bi-colour LEDs. A more realistic option is eight separate LEDs, one red and one white in each housing.
• Resistors for every LED channel.
• Transistors or logic-level MOSFETs if you use high-brightness LEDs, LED modules or anything powered from an external supply.
• 5V or 12V power supply depending on the lights you choose.
• USB cable from the PC to the Arduino.
• Wire, perfboard or breadboard.
• Light housings, hoods or a small enclosure if you want the PAPI to look convincing.

For a simple desktop trainer, standard LEDs are fine. For a visible cockpit-side unit, brighter LEDs with proper drivers and diffusers usually look much better.

How to wire the Arduino PAPI lights

The electrical side is straightforward. The Arduino only needs to switch each lamp state on command from the PC.

1. Decide on your light design. You can use four bi-colour LEDs, or four separate red/white pairs. Separate LEDs give you more control over colour balance and brightness.
2. Assign one output per colour channel. If each of the four PAPI boxes has one red LED and one white LED, that means up to eight outputs.
3. Add the correct resistor to each LED. Do not connect LEDs straight to Arduino pins.
4. Use transistors or MOSFETs for higher loads. If the lights draw more current than an Arduino pin should handle, switch them from an external supply and let the Arduino control the transistor gate or base.
5. Join the grounds. The Arduino ground and the external LED power supply ground need a common reference, otherwise switching can behave erratically.
6. Mount the lights in four separate housings. A real PAPI is four side-by-side units, so spacing and shielding matter if you want the visual effect to feel right.

If you are only building a proof of concept, you can start with four LEDs on a breadboard and add the realistic housings later.

How do you connect the Arduino to MSFS?

The Arduino does not talk to Microsoft Flight Simulator on its own. We need the PC to sit in the middle.

1. Connect the Arduino by USB so it appears as a serial device.
2. Run a small bridge application on the same PC as MSFS. That application reads flight data from the simulator through SimConnect.
3. Calculate the required PAPI state in the bridge app.
4. Send a simple serial command to the Arduino, such as WWWW, WWWR, WWRR, WRRR or RRRR.
5. Have the Arduino switch the LEDs based on that four-character pattern.

This is the cleanest design because the PC handles the maths and the Arduino only handles the lamps. It also makes troubleshooting much easier.

Why not calculate everything on the Arduino?

You can, but there is little advantage. MSFS flight data already lives on the PC, and the runway calculations are easier there. Keeping the Arduino as a simple output controller also makes it easier to swap hardware later.

What logic should the PAPI use?

A real PAPI uses four precisely aimed light units, each with its own transition angle. That means the red/white pattern changes as your eye line moves above or below the intended approach slope. For a home build, we usually model the result rather than the optical system itself.

A practical training approximation for a nominal 3-degree approach looks like this:

That is the behaviour pilots expect: two white, two red means you are on the proper path.

If you are coding the realistic geometry-based version, your bridge app needs to work out:

• Aircraft position in latitude and longitude
• Aircraft altitude
• Runway threshold or aiming point position
• Runway elevation
• Horizontal distance to the reference point
• Resulting approach angle

The basic idea is the usual angle formula: angle = arctangent(vertical difference / horizontal distance). Once you have the angle, you map it to one of the five PAPI states above.

For better realism, use the runway's published PAPI angle if you know it. If you do not, a 3-degree target is a sensible starting point for a home simulator.

Do you need runway data for every airport?

For the realistic method, yes. The bridge app needs to know where the runway threshold is and what elevation to use. If it does not have runway data, it cannot calculate a true PAPI indication.

There are three sensible ways around that:

• Support only a few runways you use often, with their coordinates hard-coded.
• Build a training-only unit that works from glidepath deviation rather than runway geometry.
• Use a generic target slope for your own practice runway and ignore exact airport fidelity.

If this is your first Arduino aviation project, starting with one runway is usually the smartest route.

Simple serial protocol for the Arduino

Keep the message format very simple. We would use a text command the Arduino can parse reliably, for example:

• WWWW
• WWWR
• WWRR
• WRRR
• RRRR

The Arduino sketch only needs to read the four characters and set the outputs for each lamp. If a lamp character is W, turn on the white LED for that unit and turn off the red one. If it is R, do the opposite.

That is much easier to maintain than sending separate pin commands from the PC.

How to make the external PAPI look believable

Raw LEDs on a board will work, but they will not really feel like a PAPI. A few physical details make a big difference.

• Use separate lamp boxes rather than a single strip.
• Add hoods or shrouds so the lights have directionality.
• Diffuse the LEDs slightly so they look like lamps, not pinpoints.
• Match brightness carefully. White LEDs often overpower red ones.
• Use PWM dimming if you want day and night brightness modes.
• Angle the light faces consistently so the visual transition is neat when viewed from the cockpit seat.

If you want to imitate the look of an airfield installation, place the four boxes in a straight line and keep the spacing even.

Testing and calibration in Microsoft Flight Simulator

This is the part that decides whether the project feels useful or gimmicky. Even a nicely built lamp bar is not much help if the transition bands are wrong.

1. Test on a stable straight-in final at a familiar runway.
2. Start with a nominal 3-degree path if you are not using runway-specific data.
3. Fly above, on and below the path and check that the display changes in the expected order.
4. Tune the thresholds until WWRR appears where you would genuinely expect to be on slope.
5. Check at different distances from the runway so the logic does not feel too jumpy close in.
6. Test in daylight and darkness and adjust brightness if needed.

If the indication flips too rapidly near the threshold, add a little smoothing or hysteresis in the bridge app so minor altitude noise does not make the lights chatter.

Common problems

All the lights stay one colour

This usually means the serial command is not being parsed correctly, or the PC bridge is not updating. First prove the Arduino can switch each pattern without MSFS connected, then add the simulator link back in.

The white and red LEDs are both faintly on

That is normally a wiring issue, wrong common-anode/common-cathode assumptions, or leakage through the driver stage. Check the LED type and confirm each channel is genuinely off when commanded off.

The lights flicker on approach

That often comes from noisy data or threshold bands that are too tight. Smoothing the input and adding a small deadband between state changes usually fixes it.

The PAPI feels wrong compared with the runway in the sim

This is expected if you are using the glidepath-based method or a generic 3-degree model. The on-screen scenery PAPI may be tied to the runway installation, while your external unit is using approximate logic.

Should you build a true runway PAPI or a training approximation?

For most home users, a training approximation is enough. It teaches the meaning of four white, three white one red, two white two red and so on, and it is much quicker to wire and code.

If you want your cockpit hardware to mirror a specific runway approach as closely as possible, then build the runway geometry-based version. It takes more setup, but it is the proper way to do it.

Bottom line

The practical way to build external PAPI lights for Microsoft Flight Simulator with Arduino is to let the PC read MSFS data through SimConnect, calculate the PAPI state, and send a simple serial pattern to the Arduino. Keep the Arduino as the lamp driver, use proper LED switching hardware, and start with a 3-degree two-white two-red calibration before chasing full runway-specific realism.