How it works

How JackMoebius works: a per-app AudioServerPlugIn virtual driver plus a daemon bridging CoreAudio to JACK. The modern successor to JackRouter, broken on macOS since Catalina.

The problem

Most macOS apps speak CoreAudio, not JACK. And ever since macOS Catalina removed the old AudioHardwarePlugIn API in October 2019 (the change that broke the original JackRouter and left it abandoned on modern macOS), there has been no supported way to take Safari’s playback, a video call’s microphone, or a DAW’s helper process and route it through a JACK graph. CoreAudio apps and JACK have lived in separate worlds.

JackMoebius changes that: it bridges the two, per application and in both directions, without touching the app itself.

JackMoebius bridges each app’s CoreAudio stream into the JACK graph, and back.

JackMoebius bridges each app’s CoreAudio stream into the JACK graph, and back.

The pieces

JackMoebius is two components (plus a CLI):

  • The driver: an AudioServerPlugIn virtual audio device (JackMoebius), plus a device of its own for an app when you ask for one. It runs inside coreaudiod, in userspace: no kernel extension, no SIP changes. It presents the routing endpoints that apps and the daemon attach to.
  • The daemon: jackmoebiusd, a Swift process that exchanges audio with the driver through shared memory, registers per-app clients in JACK, and keeps everything in sync. It runs only while a JACK server is up and self-stops when JACK goes away.
  • The CLI: jackmoebius, a control tool that talks to the daemon over a local socket (the same IPC protocol a GUI like JackMate uses).

The forward path: an app’s output into JACK

When you expose an app:

  1. The app’s CoreAudio output is routed onto the JackMoebius device, or onto a device of its own (see below).
  2. The daemon reads it and publishes a JACK client box for that app, with output ports on reserved channels.
  3. Anything in your JACK graph can now read the app’s audio: patch it into a recorder, an effect, a DAW, another app.

The channel reservation is persistent: an app that stops and restarts audio comes back on the same channels, so a saved patchbay restores itself.

Volume: two gain stages that stack

Loudness in a JackMoebius chain runs through two independent gain stages, and they multiply:

  1. JackMoebius: each exposed app plays into the JackMoebius device, which carries its own CoreAudio volume.
  2. The output JACK feeds: system:playback drives your real output device (interface or speakers), which has its own volume too.

Turn either one down and the app gets quieter, which is easy to mistake for a routing problem. That’s why JackMate puts these volumes on screen: a slider for the output JACK feeds plus a per-app slider for every exposed app, so you balance both stages finely and fast, in one place, with no trip to System Settings or Audio MIDI Setup.

The reverse path: JACK into an app’s input

The bridge is bidirectional. Exposing an app’s input makes JACK audio its microphone: either through the shared input (the ports shared_input_1/2, which every app in that mode reads) or through a device of its own, JackMoebius for <App>, fed by JACK. The app selects it as its microphone, and now JACK audio becomes the app’s input: process a live instrument through your JACK effects and send the result straight into a video call.

Two ways to connect an app: shared, or its own device

Every app has two sides: its output (the sound it plays) and its input (the microphone it listens to). For each side you choose how it reaches JACK.

Shared: the simple way. The app keeps using the Mac’s normal sound settings, and JackMoebius is there as one ordinary audio device named JackMoebius. There is nothing to change inside the app.

  • For its output, each app still gets a stereo pair of its own in JACK: two apps playing at the same time are not mixed together.
  • For its input, every app in this mode hears the same two channels. That is how macOS works: an input device is the same for everyone who listens to it.

Its own device: more channels, and a private input. JackMoebius creates a virtual sound device just for that app, named JackMoebius for <App>. It shows up in the app’s device menu like a real sound card, with anything from 1 to 64 channels in each direction, and those channels belong to that app alone. You select it in the app’s audio settings, and its channels appear in JACK as separate ports.

If the app… Choose
has no device menu (browsers, dictation, many small apps) shared: it follows the Mac’s default input and output
lets you pick its input or output device, and you want several channels, or an input of its own its own device: select JackMoebius for <App> in the app
has one device setting for both input and output either leave both sides shared and select JackMoebius, or give both sides their own device

The CLI reference shows how to choose, and JackMate does it with a menu per app.

A few things worth knowing about specific apps.

  • REAPER does not open its audio device until it plays or records when Close audio device when stopped and application inactive is ticked, so JackMoebius sees nothing before the first play. Play once, or untick the option.
  • Audacity reads its list of devices at start. After you create a device for it, or change its number of channels, use Transport, Rescan Audio Devices and select the device again.

Room to grow

Each app can have a device of its own with up to 64 channels in each direction: enough for a full multichannel session. Across all your apps, the two buses carry 254 channels each way (the system device JackMoebius keeps the other two). An app that uses the shared device takes two output channels; on the input side, the shared stereo input comes on top of those 254.

The 254 channels are shared by every app. jackmoebius status shows how many are used, JackMate shows it as a gauge, and jackmoebius doctor warns when a bus is nearly full. If channels stay reserved after you removed one side of an app, jackmoebius rebuild <App> frees them.

Event-driven, no polling

The daemon watches CoreAudio (apps launching/quitting, starting/stopping audio, switching devices) and JACK, and reconciles the graph as things change. It exposes a persistent subscribe channel over the IPC socket that pushes invalidations when something moves, so a front-end stays in sync without polling, and knows instantly if the daemon stops (the connection closes).

Lifecycle

Daemon running ⟺ JACK up. Start a JACK server (via JackMate), activate JackMoebius, and the devices appear in the system selectors; stop JACK and they vanish. The daemon is normally launched through a per-user LaunchAgent (which JackMate kick-starts), so it runs in the right session with its own identity.

One account at a time. JackMoebius serves a single account on a Mac: the audio devices belong to the whole system and the transport between the driver and the daemon has one place. If another account is already using JackMoebius, jackmoebius status and jackmoebius doctor tell you which one. Before leaving a shared Mac, quit JACK (or log out), so the next person can use JackMoebius.

→ Next: the IPC protocol and the CLI reference.

Back to top