Guides

Game controller to OSC on a Mac

You can send OSC from a game controller on a Mac today, through a bridge. InputConfig does not speak OSC on its own yet, but it already sends MIDI, and the free bridge app Chataigne turns that MIDI into OSC for anything that listens: Resolume, TouchDesigner, QLab, Max, Eos consoles, and more.

Someone on Reddit asked for native OSC, both out and in, and it went straight onto my list. You do not have to wait for it. This guide is how I would set it up today, in about fifteen minutes, plus an honest look at the other options.

InputConfig is free on the Mac App Store. macOS 14 or later, no account, no tracking, open source.

Steps

1. Connect your controller, open InputConfig, and turn on a preset that sends MIDI (the Lighting Desk or Gamepad Synth presets both work).
2. Install Chataigne, which is free and runs natively on Apple silicon.
3. In Chataigne, add a MIDI module and pick InputConfig as its input device.
4. Add an OSC module and set the target to the app you want to control: 127.0.0.1 if it's on the same Mac, plus the port that app listens on.
5. Create a mapping from each MIDI control to an OSC address, and scale 0 to 127 down to 0 to 1 if the receiving app expects that.
6. Move the controller and watch the values arrive in the receiving app.

Why there is a bridge, for now

OSC runs over the network, and InputConfig makes no network connections at all. I care about that, and it is a promise in the app's privacy policy. So when native OSC comes, it will be something you switch on yourself, pointed at the address you choose, and off otherwise.

MIDI, on the other hand, stays entirely on your Mac. InputConfig hands MIDI to the bridge, and the bridge does the network part.

Skip OSCulator for new setups

For years OSCulator was the answer to this exact question, and it is still what a lot of old forum posts recommend; I recommended it too. It shut down at the end of 2024. The last version is Intel only, which means it relies on Rosetta, and Apple has said macOS 27 is the last version to fully support Intel apps. Chataigne is the closest replacement I have found.

Send OSC through Chataigne

Chataigne is free, open source, and runs natively on Apple silicon. It takes MIDI in and sends OSC out, and it can also send DMX, Art-Net, and sACN if you end up doing lights.

Step 1: Send MIDI from InputConfig

• You: Turn on a preset that sends MIDI. The Lighting Desk preset puts faders on the triggers and notes on the buttons; the Gamepad Synth preset covers the sticks too.
• InputConfig: Sends the controller's moves on its MIDI port, named InputConfig.
• Check: The preset shows as running in InputConfig.

Step 2: Read it in Chataigne

• You: In Chataigne, add a MIDI module and choose InputConfig as the device.
• Chataigne: Lists every value that arrives from the port.
• Check: Move a trigger and its value changes in the module.

Step 3: Point OSC at the target

• You: Add an OSC module and set the target: 127.0.0.1 when the receiving app is on the same Mac, or the other computer's IP address if it is on your network, plus the port that app listens on.
• Chataigne: Sends OSC messages to that address and port.
• Check: The port matches the one the receiving app listens on.

Step 4: Map each control

• You: Create a mapping with the MIDI value as the input and an OSC message as the output. Most apps want 0 to 1 instead of 0 to 127, and Chataigne can remap that in the mapping.
• Chataigne: Converts each MIDI move into an OSC message.
• Check: Move the controller and watch the value arrive in the receiving app. A good first test is one trigger to one fader.

OSC target on the same Mac: Type this as the OSC module's host.

127.0.0.1

What happens: Chataigne sends to an app running on this Mac; add that app's port beside it.

Find the OSC addresses

Every app names its controls differently, so check its docs for the addresses it listens to. Resolume, QLab, and ETC's Eos family all document their OSC commands, and TouchDesigner's OSC In CHOP takes whatever you send it. For lights you may not need OSC at all: QLC+ and Lightkey read MIDI directly.

If nothing arrives

Climb this ladder, most common mistake first:

1. Check the port. The receiving app has to listen on the same port the bridge sends to. It is the mistake I make most.
2. Allow Local Network. On macOS 15 and later, apps need permission to reach other devices on your local network. If OSC is not showing up on another computer, allow the bridge app in System Settings, Privacy & Security, Local Network. InputConfig itself does not need this permission, since MIDI never leaves your Mac.
3. Check the scale. If a value arrives but barely moves, the receiving app probably expects 0 to 1; remap it in Chataigne.

Choose CC or pitch bend for smoothness

• MIDI CC. 128 steps, plenty for opacity, volume, or effect amounts.
• Pitch bend. 16,384 steps, for something that needs to be really smooth. The Gamepad Synth preset already puts it on the right stick; map that to your most sensitive control.

MIDI stays inside your Mac, so the bridge adds very little lag. Bluetooth is usually the slowest link in the chain, and a cable helps for shows. Put pitch bend on the control that has to move smoothly.

Other options, honestly

If all you need is a controller sending OSC and nothing else, there are good tools that read game controllers directly: TouchOSC can do it, and so can Chataigne on its own. InputConfig makes sense when you want the same controller doing more than that: keys, the mouse, and MIDI into your DAW, all from one preset that follows you from app to app.

What native OSC could look like

The plan I am leaning toward:

• OSC out. From any button, stick, or trigger.
• OSC in. So another app can press buttons in InputConfig.
• Off by default. All of it off until you turn it on and give it an address.

If that would help you, let me know. Hearing from people who would use it is what moves things up the list.

The short version

• InputConfig sends MIDI. Not OSC, yet.
• Chataigne bridges it. MIDI module in, OSC module out, one mapping per control.
• Check the port first. Then Local Network on macOS 15 and later.

MIDI in, OSC out: the bridge does the network part so InputConfig never has to.

Questions

Related

• Control stage lights with a game controller
• A game controller as a QLab GO button
• Gamepad to MIDI: a game controller as a MIDI instrument
• MIDI output: send MIDI from any controller
• MIDI reference
• A free Bome MIDI Translator alternative for Mac

Free. macOS 14 or later. No account, nothing leaves your Mac. Open source on GitHub.