Route any app’s audio anywhere. On all three desktops.
Build virtual audio devices, feed them from applications, hardware inputs or other virtual devices, wire them channel by channel, and hear the mix while it goes out. One config file and one key on macOS, Windows and Linux.
That product does not exist yet. Audio round-trips through a virtual device on Linux and on macOS — but on macOS that is the driver’s own loopback, not the mix you built, and the Windows driver has never been compiled. There is no download and no checkout.
The routing model, drawn in the app’s own design language. This is a diagram of the data model — not a screenshot of a shipping application, because there is not one.
off unity for a 440 Hz tone round-tripped through a macOS virtual device
peak from the one app we tapped — the app we did not read 0.000000
platforms where audio has actually made the trip
Three measurements, not three adjectives. The third one is the number that matters, and it is the reason this page has an email form instead of a download button — two of three, and on one of the two the audio is the driver’s own loopback rather than a mix you built.
The tool that does this well runs on one operating system
Loopback is $99 and macOS 14.5–26 only. Every commercial per-app-capture product is macOS-only. Every Windows tool is Windows-only, and the two with any application awareness are either free-because-it-sells-headsets or last released in 2018. Nothing in the category is macOS + Windows + Linux under one licence.
Move desks, rebuild everything
The routing you spent an evening on lives inside one vendor's macOS app. On the PC you start again with a different tool and a different mental model.
Nothing to script
On the two platforms where people pay, routing is drag-and-drop only. There is no config file to commit and no command to run before a stream goes live.
The free options are real
BlackHole, VB-Cable, Voicemeeter and PipeWire all exist and all work. A $0 floor on every platform is why this has to be genuinely better, not merely cheaper.
What v1 is, and where each piece stands
This is the whole v1 cut line from the spec — no more. Effects, EQ and recording to disk are a different product and are not coming.
Virtual devices you create
Create, rename, duplicate and delete devices, and set the channel count. Each one appears to the OS as both an input and an output, so anything that records from a microphone can record exactly the mix you built.
One application, not the whole system
Capture a named app's output — the browser without the notifications, the game without the chat. Core Audio process taps on macOS, WASAPI process loopback on Windows, PipeWire monitor ports on Linux.
Hardware inputs and nested devices
A USB microphone, an interface channel, or another virtual device, mixed into the same device as your apps. Nesting is cycle-checked at edit time, so A into B into A is rejected rather than fed back.
Monitors — hear what you are routing
Send the finished mix to one or more real outputs while it is going out. Without this you are streaming deaf, which is why it is a v1 requirement and not a nicety.
Channel-level wiring, with per-wire gain
Drag a wire or edit the matrix. Per-source, per-monitor and per-device volume, and an enable/disable that does not delete — which is the difference between usable live and not.
A routing graph you can put in git
The whole setup is a JSON file, written atomically so a hard kill can never leave a truncated one. It is the same file on all three operating systems, which is the entire point of the product.
A CLI that drives all of it
26 methods over a local JSON-RPC socket and a command-line client on top: create devices, add sources, wire channels, read meters, apply a preset. Stream Deck macros and OBS scene switches become possible.
Licences that verify offline
The key is the licence: an Ed25519 signature carrying its own claims, checked against a public key compiled into the binary. No account, no server call, no grace period that expires on a plane.
Measured on macOS means it has been run against a real driver on a real machine and the number is on this page. Engine works means the code runs and its tests pass, against a fake backend rather than a real audio driver. Needs the drivermeans the feature cannot be exercised until the engine’s mix reaches a virtual device — which it does not yet, on any platform where a driver is needed.
Where we actually are
Seven conditions have to be true on real hardware before a platform ships. Here is every one of them, per platform, checked against the repository.
- LinuxAudio round-trips
Audio goes through the device we asked PipeWire for
440 Hz left and 880 Hz right went into a virtual sink and came back out of the virtual source at unity gain, on PipeWire 1.2.8 in a container with no sound card. A script did it, not the daemon, and the daemon-driven version of that script has never been run. Free permanently.
- macOSPartway
Audio round-trips, but it is the driver's loopback, not your mix
The daemon creates the device, the OS lists it, and 440/880 Hz come back within 0.41 dB of unity with the other tone at least 51.9 dB down, zero stream faults. Tapping afplay reads 0.549321 at the mixer while ControlCenter reads 0.000000. What does not work: the shared-memory path that would carry the engine's mix into the device. On one machine with SIP's filesystem protections off, so loading does not generalise.
- WindowsNot started
The driver has never been through a compiler
It was written on a Mac and has not been built. Shipping it needs an EV certificate and Microsoft attestation as well — a 10–17 business-day chain that has not started, and the longest pole in the project.
| A platform ships when… | macOS | Windows | Linux |
|---|---|---|---|
| 1. The virtual device appears in the OS sound picker, as both input and output | Yesthe daemon created it and system_profiler lists it, 2 in / 2 out. On one machine with SIP partly off | Nodriver never compiled | Yesboth halves seen on PipeWire 1.2.8, in a container |
| 2. Audio played to it is captured from it at unity gain | Partlypeak=0.50000 out for 0.5 in, each tone within 0.41 dB of unity — but through the driver's own loopback, not the engine's mix | No | Yes440 Hz and 880 Hz stayed in their own channels at unity gain — the measurement is below |
| 3. One named application's audio, and only that application's, is captured | Yesafplay reads 0.549321 at the mixer, ControlCenter reads 0.000000 at the same instant | No | No |
| 4. A monitor plays the mix to a real output at the same time | No | No | No |
| 5. The installer installs, upgrades and fully uninstalls the driver, signed | Partlypackage builds, unsigned, and has never been run | No | Partly.deb / .rpm build |
| 6. It survives an 8-hour soak with zero xruns and no drift-induced dropout | No | No | No |
| 7. The UI drives all of the above without the user touching a terminal | PartlyUI works against the daemon; it has never been driven against the real driver | No | No |
Row 2 held on Linux
A three-second stereo tone — 440 Hz left, 880 Hz right — played into the virtual sink and recorded back from the virtual source, then Goertzel-filtered for both tones in each captured channel:
captured 369664 frames (7.70s), peak L=20000 R=20000, input peak was 20000 left channel: 440Hz= 7447.2 880Hz= 26.6 right channel: 440Hz= 43.4 880Hz= 7257.0 ROUND TRIP PASS — 440 Hz stayed left, 880 Hz stayed right, unity gain
Peak out equals peak in, so nothing was attenuated, and each tone sits roughly 200:1 above the other in its own channel, so the channels were neither swapped nor summed. It ran on PipeWire 1.2.8 in a container with no audio hardware at all, which is a stronger result than it sounds: nothing about it depended on a sound card. It is also reproducible anywhere — backends/linux/scripts/roundtrip.sh.
What it cost to learn: PipeWire on its own links nothing. Without a session manager the nodes appear, playback hangs until killed, and the recording is silent — with no error anywhere saying why. Four earlier attempts failed on exactly that.
Rows 1 and 2 held on macOS — through the driver’s loopback
The background service created a virtual device, the operating system listed it, and the same 440/880 Hz tone went in and came back out:
created device 1 "AudioWire round trip" (2 ch @ 48000 Hz) device uid is AudioWire_1 and the OS lists it in SPAudioDataType 144384 frames captured in 3s, peak=0.50000 ch0: 440Hz=0.49315 (-0.12 dB vs sent) 880Hz=0.00050 (leak -59.8 dB) ch1: 880Hz=0.47715 (-0.41 dB vs sent) 440Hz=0.00121 (leak -51.9 dB) capture faults=0 playback faults=0 ROUND TRIP PASS — 440 Hz stayed left, 880 Hz stayed right, unity gain
Each tone is within 0.41 dB of unity on its own channel and at least 51.9 dB down on the other, with zero capture and zero playback faults. The catch is which loopback that is. It is the driver’s own internal one, not the mix you built: the shared-memory path that would carry the engine’s mix into the device never mapped a single segment on any machine, because the driver validated the ring header with read(2) and a POSIX shared-memory descriptor on macOS is not a readable file. That is fixed in the driver source and it compiles — and installing it needs root, which has not been done, so none of it is proven. It also ran on one machine with SIP’s filesystem protections switched off, which is not a configuration anyone should be asked for.
Row 3 held on macOS, through the daemon
A Core Audio process tap on one named application reaches the mixer at peak 0.549321 — which is 18000/32768, exactly the amplitude that went in, so the whole path is unity gain and not merely non-silent. At the same instant, with the tone still playing, tapping a different application gives 0.000000 across all 188 blocks. Not the system mix with one app in it — one process, by name, carried through the same code path a real audio interface uses.
What is still unverified is the shipping path: the consent prompt only fires for a signed binary and there is no signed binary yet.
And what is still not proven
The Windows kernel driver was written on a Mac and has never been through a compiler. Shipping it also needs an EV certificate and Microsoft attestation — a 10–17 business-day chain that has not started, and the longest pole in the whole project.
On macOS the fixed shared-memory driver has never been installed, so the engine has never published a mix into a device. The installer has never been run by anyone. And on Linux, the round-trip script that puts the background service in the loop was written on a Mac and has never been executed — the measurement above came from the script that drives PipeWire directly.
Source of truth: docs/spec.md §7. If this page and that file ever disagree, that file is right.
Three gaps worth building into
Each with the evidence it is real, and with the thing that would make it not real.
One licence, one config, three operating systems
Nothing in the market is macOS + Windows + Linux under one key. Loopback is macOS 14.5–26 only and its vendor retired its one Windows product after 13 years. The single cross-platform contender, AudioRoute, is macOS + Windows, says plainly that Linux is not supported, does not claim per-app capture, and its Windows device is still pending Microsoft attestation.
Keeping it honest: This only counts if a saved graph genuinely opens and works on the other two. If it does not, the price drops to $29 and we are just another Loopback undercut.
Per-app routing on Windows that someone maintains
Windows has had a public per-process loopback API since build 20348, with a Microsoft sample. VB-Cable and Virtual Audio Cable are dumb cables with no application concept. Voicemeeter mixes device strips, not apps. SteelSeries Sonar does route apps — into five fixed channels, behind a vendor account. The one flexible design, SAR, last shipped in April 2018.
Keeping it honest: The reason the gap stayed open is the entry cost: a kernel-mode driver, an EV certificate and Partner Center attestation. That paperwork has not started, and it is the longest pole in the whole project.
Routing you can script, on the platforms where people pay
Rogue Amoeba publishes a scripting API for Audio Hijack and an AppleScript suite for Airfoil — and nothing for Loopback. BlackHole's documented workflow is building a Multi-Output Device by hand in Audio MIDI Setup. Sonar is drag-and-drop only. Linux has all of this via pactl and pw-cli, and Linux is the platform with a $0 ceiling.
Keeping it honest: Narrower than it looks: VB-Audio ships a remote-control DLL and SAR had regex rules. Both are Windows-only. The defensible claim is one config format and one CLI that behave identically on three OSes — which needs the cross-platform core, not a bolted-on feature.
Per-app capture is not one of the gaps and must not be sold as one — both platforms ship it as a public API, and LitLink already sells it at $29. The claim is one key, one config, three OSes.
Against the tools people actually use
Prices and versions checked 8 August 2026. Every source URL is cited in docs/01-competitors.md.
| Feature | Audiowire | Loopback 2.4.10 | BlackHole | VB-CABLE | Voicemeeter |
|---|---|---|---|---|---|
| Ships today | No — in development | Yes | Yes | Yes | Yes |
| Platforms | macOS, Windows, Linux — macOS and Linux round-trip today, Windows does not | macOS 14.5–26 only | macOS only | Windows only | Windows only |
| Per-app capture | Proven on macOS, through the daemon; planned elsewhere | Yes | No — whole-device only | No | No — per device, not per app |
| Max channels per device | 16 in the UI, 64 in the engine | 64 | 2–256 depending on build | 2 | 3 physical + 2 virtual I/O (Banana) |
| Monitoring to a second output | In the engine; never heard through a real driver | Yes | Hand-built Multi-Output Device | No | Yes — A/B bus |
| Portable config file | JSON, works today | No | No | No | XML profiles, Windows only |
| Scriptable local API | JSON-RPC + CLI, works today | No documented API | No | No | Remote-control DLL, Windows only |
| Licence | Proprietary; repo public | Proprietary | GPL-3.0 | Proprietary donationware | Proprietary donationware |
| Price | $39 planned — one-time, all three OSes, 3 machines. Not on sale. | $99 one-time ($49 upgrade) | Free | Donationware — shop lists $5.00 | Free; Potato asks for a donation code |
Priced like a utility, sold like nothing — yet
One-time, not a subscription. Every direct comparable in this category is one-time, and the two vendors who tried a subscription now sell a cheaper perpetual licence beside it.
Free
Route one app anywhere. Forever, and without a card.
Standard
As many devices as your setup needs.
Pro
Scriptable, 64 channels wide.
| Capability | Free$0 | Standard$39 | Pro$79 |
|---|---|---|---|
| Virtual devices | 1 | Unlimited | Unlimited |
| Channels per device | 2 | 16 | 64 |
| Sources per device | 2 | Unlimited | Unlimited |
| Per-app capture | |||
| Hardware inputs and nested devices | |||
| Monitors — hear the mix while it goes out | |||
| Level meters, latency and xrun readout | |||
| Channel wiring with per-wire gain | |||
| Presets — export and import a routing config | |||
| Command line and declarative config | |||
| Local control API (JSON-RPC) | |||
| Machines per key | — | 3 | 5 |
| Linux, with no key at all |
Checkout is not live. No card can be taken, no pre-order can be placed, and no licence key can be issued. These prices are decided and written down so nobody has to guess what it will cost — not so anyone can pay today.
Read the full pricing pageAnswered without spin
Can I buy or download it today?
No. There is no binary for any platform and no way to pay us — checkout does not exist. The prices on /pricing are decided, written down and real, and none of them is chargeable. The only thing this site asks for is an email address.
When will it be released?
There is no date and we will not invent one. macOS is gated on a Developer ID certificate; Windows is gated on an EV certificate plus Microsoft attestation signing, a 10–17 business-day chain that has not started. Neither is shortened by engineering.
What actually works, in one sentence?
Audio goes into a virtual device and comes back out at unity gain with the channels intact, on Linux and on macOS — that is the product's core claim, demonstrated twice. On macOS the daemon also creates and deletes the device, and per-app capture reaches the mixer at unity while a second app reads exactly zero. The gap is that the macOS round trip is the driver's internal loopback: the shared-memory path that would carry your mix into the device is fixed in source and has never been installed. Windows is an engine with no driver behind it.
What is free, and what costs money?
Linux is free permanently and never asks for a key — PipeWire already does this natively, so charging there would be indefensible. On macOS and Windows every install starts with a 14-day trial of the whole app, and after it lapses the free tier keeps one stereo virtual device with one application captured into it, plus monitors and metering. Per-app capture is free on every tier, because it is the reason the product exists. Presets, the command line and the control API are paid. Those free-tier limits are the one thing on this page still being settled.
Why does installing it need an administrator password?
Because a virtual audio device is a driver. On macOS it is an AudioServerPlugIn that has to live in /Library/Audio/Plug-Ins/HAL, which only root can write; on Windows it is a kernel-mode driver installed with pnputil. Linux needs no driver at all — PipeWire already does this in user space. The background service itself never runs as root and is designed so it cannot ask to.
Is this a fork of BlackHole?
No, and deliberately not. BlackHole is GPL-3.0. The macOS driver here was written from Apple's public headers and Apple's own sample drivers only; BlackHole's source was not read, fetched or consulted. That clean-room rule is written into CONTRIBUTING.md and binds everyone who touches a platform backend.
What latency should I expect?
Unknown, honestly. The engine holds its mix budget under 10% of a block period and the design target is one block plus a ring — about 11 ms at 512 frames and 48 kHz. That is a calculated number from the architecture, not a measurement through a real driver, because there is no real driver to measure through yet.
Why should I care, given BlackHole and PipeWire are free?
On Linux you probably should not, which is exactly why Linux is free here permanently and never asks for a key. The argument is for people who work across a Mac and a PC and want one setup that exists on both, and for people who want that setup in a file they can version and script.
Does Audiowire send anything anywhere?
It has no network code, and acquiring any is a decision that would have to be written down and consented to, not a patch. Licences verify offline against a key compiled into the binary, so there is no activation call either. Audio never leaves the machine.
Would you pay $39 for this?
That question is the entire reason this page exists. Before more driver work happens we want to know whether anyone wants the thing at the price — so pick the machine that matters to you and send one email. The only thing we will ever do with it is write back when Audiowire routes audio on that operating system.
This opens a message in your own mail client with the subject and body already written — nothing is sent until you send it, and nothing is stored here either. There is no mailing list yet, so your address goes on a list kept by a human, and the only message you will ever get is the one saying Audiowire routes audio on macOS.
No card, no pre-order, no account. If this machine has no mail client set up, write to support@dfacto.ai with “audiowire” in the subject.