Skip to content

Instantly share code, notes, and snippets.

@bedwards
Last active April 9, 2026 23:33
Show Gist options
  • Select an option

  • Save bedwards/4aad9ef1e0dcb8fe762bbd36514dd187 to your computer and use it in GitHub Desktop.

Select an option

Save bedwards/4aad9ef1e0dcb8fe762bbd36514dd187 to your computer and use it in GitHub Desktop.
Bitwig + Orca + SunVox + Automatonism + Mididash + BlackHole: a zero-VST musical hello world wiring external MIDI generation, MIDI in/out of Bitwig, and virtual audio return

Bitwig Hello World — Orca / Sonic Pi / TidalCycles → Bitwig → SunVox / Automatonism

A true musical hello world that wires up three independent external MIDI generators, Bitwig as the hub, two external software synths, and virtual audio return — all free and open source, zero VST plugins inside Bitwig.

The cast

Tool Role Format
Orca Esoteric livecoding MIDI generator (grid language) Electron app
Sonic Pi Ruby-based livecoding environment, MIDI out Standalone app
TidalCycles Haskell pattern livecoding, plays via SuperDirt tidal lib + SuperCollider + VS Code extension
Mididash Virtual MIDI router between apps (node GUI + Lua) Standalone
Bitwig Studio Hub / sequencer / mixer / FX DAW
SunVox Tracker/modular synth (melody voice) Standalone
Automatonism 81-module synth inside Pure Data (bass/drone) Pd patch
BlackHole 16ch Virtual audio driver (16-channel return bus) CoreAudio driver

Signal flow

  ┌─ MIDI sources ─────────┐
  │ Orca                   │──┐
  │ Sonic Pi               │──┤      ┌─ Mididash ─────────────────────────────┐
  │ TidalCycles (via SC)   │──┤      │                                         │
  └────────────────────────┘  └─────→│→ Bitwig (MIDI IN, Generic Controller)   │
                                     │                                         │
                                     │  Bitwig HW Instrument ── MIDI ──────────┤→ SunVox
                                     │                                         │
                                     │  Bitwig HW Instrument ── MIDI ──────────┤→ Pd (Automatonism)
                                     └─────────────────────────────────────────┘

      SunVox audio ────┐
                       ├── BlackHole 16ch ── Bitwig Audio Track (input)
      Pd audio ────────┤
                       │
      SC/SuperDirt ────┘   (Tidal outputs audio via SuperCollider directly)

Any of the three livecoding sources (Orca, Sonic Pi, Tidal) can clock themselves and emit MIDI into Mididash. Bitwig receives them on one track and forwards them out two HW Instrument tracks — one to SunVox, one to Automatonism. Their audio returns through BlackHole 16ch into Bitwig audio tracks where you mix/record/FX. TidalCycles is special: it both generates patterns (Haskell) and produces its own audio (through SuperCollider's SuperDirt), so for Tidal you can skip the MIDI route entirely and just capture SuperCollider's audio into Bitwig via BlackHole.

One-time setup

1. Install BlackHole 2ch

brew install blackhole-2ch

Reboot CoreAudio or log out/in. Verify it appears in Audio MIDI Setup.

2. Create an Aggregate Device (so Bitwig sees your speakers and BlackHole)

  • Open Audio MIDI Setup+Create Aggregate Device
  • Check your output (e.g. MacBook Speakers) and BlackHole 2ch
  • Name it "Bitwig Aggregate"
  • In Bitwig: Settings → Audio → Output Device = Bitwig Aggregate
  • Add stereo Input Bus in Bitwig audio settings mapped to BlackHole channels 1–2

3. Launch Mididash

Open /Applications/Mididash.app. It exposes virtual MIDI ports that every other app will see in CoreMIDI. Leave it running.

4. Bitwig controllers (MIDI IN from Orca)

  • Settings → Controllers → Add → Generic → Generic MIDI Keyboard
  • Set MIDI input to a Mididash port (e.g. Mididash In 1)
  • This is how external MIDI (Orca) reaches Bitwig tracks.

The hello world project

Track 1 — "Orca In" (Instrument track, MIDI receiver)

  • Input: the Generic Controller you just added
  • Arm for record
  • No instrument — it only forwards MIDI out to another track via Note FX → Note Receiver, or simply records the incoming notes as clips.

Track 2 — "SunVox Out" (HW Instrument)

  • Add device: HW Instrument
  • MIDI Out: Mididash In 2 (or any free Mididash port), channel 1
  • Audio In: Bitwig stereo input bus → BlackHole 1–2
  • This is a real round trip: MIDI leaves Bitwig, audio comes back.

Track 3 — "Pd Out" (HW Instrument)

  • Add device: HW Instrument
  • MIDI Out: Mididash In 3, channel 1
  • Audio In: same BlackHole bus (sum with Track 2, or use a second BlackHole instance for separation)

About HW CV Instrument: Skip it. That device sends analog control voltage out a DC-coupled audio interface to real Eurorack/Moog hardware. With software-only synths, HW Instrument (MIDI) is the right tool. HW CV Instrument only enters the picture when you wire an actual jack into physical gear.

Configure the external synths

SunVox

  • Launch /Applications/SunVox.app
  • Preferences → MIDI controller → Input → select Mididash In 2
  • Preferences → Audio → Driver/device → BlackHole 2ch
  • Load or create a synth module (Generator → Output). Click the module so it's selected — selected module receives incoming MIDI.

Automatonism (in Pure Data)

  • Launch /Applications/Pd-0.56-2.app
  • File → Open~/Documents/Pd/Automatonism 3.1/main.pd
  • Media → MIDI settings → Input deviceMididash In 3
  • Media → Audio settings → Output device → BlackHole 2ch, DSP on (Ctrl+/)
  • In main.pd, drop a MIDI-IN module, connect to an OSC, then to OUTPUT. Or load a demo patch from the quick guide.

MIDI source option A — Orca

Launch /Applications/Orca.app.

  • Cmd+,MIDI Output → pick Mididash In 1
  • Paste a minimal generator:
    .......8D...
    .......:03C.
    ............
    
    8 = clock divider (every 8 frames), D = bang, : = MIDI output on channel 0, octave 3, note C. Run it (Space to play).
  • Or the classic:
    aTCAFE
    .:03C.
    
    T tracks across a row of notes driven by a (incrementing A).

MIDI source option B — Sonic Pi

Launch /Applications/Sonic Pi.app.

  • Preferences → IO → MIDI → Default MIDI output → pick Mididash In 1
  • In the buffer:
    live_loop :drip do
      midi (scale :c3, :minor_pentatonic).choose, channel: 1
      sleep 0.25
    end
  • Cmd+R to run. Ruby → MIDI notes → Mididash → Bitwig.

MIDI source option C — TidalCycles

TidalCycles normally plays its own audio through SuperCollider/SuperDirt, so the MIDI-into-Bitwig route is optional. Full setup (one-time):

  1. Launch SuperCollider, install SuperDirt:
    Quarks.checkForUpdates({Quarks.install("SuperDirt", "v1.7.3"); thisProcess.recompile()})
    
  2. After recompile: SuperDirt.start (downloads sample packs first time).
  3. In VS Code, open a new file hello.tidal. The vscode-tidalcycles extension will auto-boot ghci + tidal. (Set Tidalcycles › Ghci: Base Path to ~/.ghcup/bin/ghci in settings.)
  4. Paste and Shift+Enter:
    d1 $ sound "bd sn hh cp"
    
  5. hush to stop.
  6. Audio comes out of SuperCollider → route SC's output device to BlackHole 16ch (in SC: s.options.outDevice_("BlackHole 16ch"); s.reboot;) and capture it in Bitwig on an audio track.

For MIDI-only Tidal (to drive SunVox/Pd instead of SuperDirt), use the tidal-midi connection pattern — heavier setup, skip for hello world.

Wire it up in Mididash

Open Mididash's node canvas and draw these cables:

[Input: Mididash In 1] ──→ [Output: Mididash In 1]   (Orca → Bitwig)
[Input: Mididash In 2] ──→ [Output: Mididash In 2]   (Bitwig → SunVox)
[Input: Mididash In 3] ──→ [Output: Mididash In 3]   (Bitwig → Pd)

(On macOS a single IAC/virtual port is bidirectional — one side is "input" to one app and "output" to the other. Mididash just needs the node cables drawn so routing is explicit and loggable.)

Make sound

  1. Start Orca playing (Space). Notes flow → Bitwig Track 1 lights up.
  2. On Track 1, enable Note FX → Note Receiver on Tracks 2 and 3, or duplicate the MIDI clip onto them. Both HW Instrument tracks now send MIDI out via Mididash.
  3. SunVox and Pd receive the notes and play.
  4. Their audio lands on the BlackHole input bus → Bitwig Audio tracks show levels.
  5. Record-arm the audio tracks and hit record. You are now capturing a generative patch driven by Orca, voiced by two external synths, summed and mixed inside Bitwig — with Bitwig adding zero instruments of its own.

What you just proved

  • MIDI IN to Bitwig from three different non-keyboard sources (Orca grids, Sonic Pi Ruby, Tidal patterns)
  • MIDI OUT of Bitwig via HW Instrument to two apps in parallel
  • Audio return from external software via a virtual driver (BlackHole 16ch)
  • Routing topology managed explicitly in a single place (Mididash)
  • Zero VST plugins loaded inside Bitwig — the DAW is the mixer/recorder/clock hub

From here you can swap Orca for a Bitwig clip, replace SunVox with Cardinal (the one thing that would live as a VST inside Bitwig), add effects, automate, record performances, and so on. The plumbing is the same.

Mac Studio Livecoding Rig Setup

Instructions for a Claude (or anyone) to reproduce Brian's generative / livecoding / external-synth rig on a fresh Mac Studio (Apple Silicon, arm64). Everything here is free and open source. No Homebrew — direct installers, source builds, or official installer scripts only.

Goal

End state: a working setup where Bitwig is the hub, external apps generate MIDI algorithmically (Orca, Sonic Pi, TidalCycles) and external apps receive MIDI and make sound (SunVox, Automatonism / Pure Data, TidalCycles via SuperCollider). MIDI routing happens in Mididash. Audio comes back into Bitwig through BlackHole 16ch. Zero VST plugins loaded inside Bitwig.

See also: https://gist.github.com/bedwards/4aad9ef1e0dcb8fe762bbd36514dd187 for the minimal "hello world" flow using Orca + SunVox + Pd.

Prereqs already assumed present

  • Bitwig Studio (user installs separately)
  • Xcode + command line tools (xcode-select --install if missing — required for BlackHole build)
  • Node.js + npm (nvm recommended — required for Orca Electron build)
  • git, curl, gh (GitHub CLI)
  • VS Code (/Applications/Visual Studio Code.app, with code CLI on PATH)

Check: which node npm git gh code xcodebuild

Components overview

# Tool What it does Install method
1 Mididash Virtual MIDI router between apps (node-based GUI + Lua) GitHub release dmg
2 BlackHole 16ch Virtual audio driver for app→Bitwig audio return Build from source (no brew)
3 SunVox Tracker/modular synth Direct zip download
4 Pure Data (vanilla) Dataflow audio environment (hosts Automatonism) Direct dmg download
5 Automatonism 3.1 81-module synth running inside Pd Zip into ~/Documents/Pd/
6 Orca (Hundred Rabbits, Electron) Esoteric livecoding sequencer with GUI Clone repo, build .app with electron-packager
7 Sonic Pi Ruby livecoding music environment Direct dmg download
8 SuperCollider Audio server + sclang, backend for TidalCycles Direct dmg download
9 SuperDirt Sample playback engine for Tidal, a SuperCollider quark Run inside sclang (manual)
10 GHCup → GHC + cabal Haskell toolchain (needed for Tidal) Official get-ghcup installer
11 tidal lib The Haskell tidal package cabal install tidal --lib
12 vscode-tidalcycles VS Code extension, Tidal editor integration code --install-extension

1. Mididash

# Latest release as of 2026-04: v0.4.2
cd /tmp
gh release download v0.4.2 -R tiagolr/mididash -p 'Mididash_0.4.2_aarch64.dmg'
hdiutil attach -nobrowse -quiet Mididash_0.4.2_aarch64.dmg
cp -R "/Volumes/Mididash/Mididash.app" /Applications/
hdiutil detach /Volumes/Mididash -quiet
xattr -dr com.apple.quarantine /Applications/Mididash.app
rm Mididash_0.4.2_aarch64.dmg

Launch once to let it register virtual MIDI ports with CoreMIDI.

2. BlackHole 16ch (build from source — NO BREW)

Brian explicitly does not want Homebrew used. Build the driver from source:

mkdir -p ~/src && cd ~/src
git clone --depth 1 https://github.com/ExistentialAudio/BlackHole.git
cd BlackHole
xcodebuild -project BlackHole.xcodeproj -configuration Release \
  GCC_PREPROCESSOR_DEFINITIONS='$GCC_PREPROCESSOR_DEFINITIONS kNumber_Of_Channels=16 kPlugIn_BundleID=\"audio.existential.BlackHole16ch\" kDevice_Name=\"BlackHole16ch\" kPlugIn_Icon=\"BlackHole16ch.icns\"' \
  CODE_SIGN_IDENTITY="-"

Then install the resulting driver (sudo required — user runs this):

sudo cp -R ~/src/BlackHole/build/Release/BlackHole.driver /Library/Audio/Plug-Ins/HAL/BlackHole16ch.driver
sudo chown -R root:wheel /Library/Audio/Plug-Ins/HAL/BlackHole16ch.driver
# On SIP-enabled systems, `killall coreaudiod` may fail. Logout/login picks it up.
sudo killall -9 coreaudiod 2>/dev/null || true

Verify in Audio MIDI Setup that BlackHole 16ch appears. If Brian had an old BlackHole 2ch or a leftover Microsoft Teams audio driver, also:

sudo rm -rf /Library/Audio/Plug-Ins/HAL/BlackHole2ch.driver
sudo rm -rf /Library/Audio/Plug-Ins/HAL/MSTeamsAudioDevice.driver
sudo pkgutil --forget audio.existential.BlackHole2ch 2>/dev/null || true
sudo pkgutil --forget com.microsoft.MSTeamsAudioDevice 2>/dev/null || true
sudo pkgutil --forget com.microsoft.teams2 2>/dev/null || true

3. SunVox

cd /tmp
curl -sL -o sunvox.zip https://warmplace.ru/soft/sunvox/sunvox-2.1.4d.zip
unzip -q sunvox.zip
cp -R /tmp/sunvox/sunvox/macos/SunVox.app /Applications/
xattr -dr com.apple.quarantine /Applications/SunVox.app
rm -rf /tmp/sunvox /tmp/sunvox.zip

SunVox on macOS is standalone only — there is no AU/VST version for Mac (the AUv3 build is iOS-only). MIDI into SunVox comes from Mididash; audio out goes to BlackHole.

4. Pure Data (vanilla)

cd /tmp
curl -sL -o pd.zip https://msp.ucsd.edu/Software/pd-0.56-2.macos.zip
unzip -q pd.zip
hdiutil attach -nobrowse -quiet Pd-0.56-2.dmg
cp -R "/Volumes/Pd-0.56-2/Pd-0.56-2.app" /Applications/
hdiutil detach /Volumes/Pd-0.56-2 -quiet
xattr -dr com.apple.quarantine /Applications/Pd-0.56-2.app
rm /tmp/Pd-0.56-2.dmg /tmp/pd.zip

5. Automatonism 3.1 (Pd patch library)

mkdir -p ~/Documents/Pd
cd ~/Documents/Pd
curl -sL -o auto.zip https://www.automatonism.com/s/Automatonism-31.zip
unzip -q auto.zip
rm -rf __MACOSX auto.zip

Opens via Pd → File → Open → ~/Documents/Pd/Automatonism 3.1/main.pd. In Pd: Media → MIDI Settings → pick a Mididash port; Media → Audio Settings → output BlackHole 16ch; turn DSP on (Ctrl+/).

6. Orca (Hundred Rabbits, Electron GUI)

The Orca GUI is distributed via itch.io (browser-gated). Build an .app bundle from source so Spotlight finds it.

mkdir -p ~/src && cd ~/src
git clone --depth 1 https://github.com/hundredrabbits/Orca.git
cd Orca/desktop
npm install
# On Apple Silicon use --arch=arm64 (Brian's current Intel machine used --arch=x64)
npx --yes @electron/packager . Orca --platform=darwin --arch=arm64 --out=/tmp/orca-build --overwrite
cp -R /tmp/orca-build/Orca-darwin-arm64/Orca.app /Applications/
xattr -dr com.apple.quarantine /Applications/Orca.app
rm -rf /tmp/orca-build
mdimport /Applications/Orca.app

First launch: Cmd+, → set MIDI Output to a Mididash port. Space to play.

7. Sonic Pi

# Apple Silicon build (use x64 on Intel)
cd /tmp
curl -sL -o sonicpi.dmg https://sonic-pi.net/files/releases/v4.6.0/Sonic-Pi-for-Mac-arm64-v4-6-0.dmg
yes | PAGER=cat hdiutil attach -nobrowse sonicpi.dmg  # EULA prompt
cp -R "/Volumes/Sonic Pi for Apple Silicon Mac arm64 v4.6.0/Sonic Pi.app" /Applications/  # verify actual volume name
hdiutil detach "/Volumes/Sonic Pi for Apple Silicon Mac arm64 v4.6.0" -quiet
xattr -dr com.apple.quarantine "/Applications/Sonic Pi.app"
rm /tmp/sonicpi.dmg

Sonic Pi can send MIDI out via Preferences → IO → MIDI → pick a Mididash port.

8. SuperCollider

cd /tmp
# For Apple Silicon native, check https://supercollider.github.io/downloads for the non-legacy arm64 dmg
curl -sL -o sc.dmg https://github.com/supercollider/supercollider/releases/download/Version-3.14.1/SuperCollider-3.14.1-macOS-arm64.dmg
yes | PAGER=cat hdiutil attach -nobrowse sc.dmg
cp -R /Volumes/SuperCollider/SuperCollider.app /Applications/
hdiutil detach /Volumes/SuperCollider -quiet
xattr -dr com.apple.quarantine /Applications/SuperCollider.app
rm /tmp/sc.dmg
mdimport /Applications/SuperCollider.app

Note: as of 2026-04 SuperCollider 3.14.1 publishes an arm64 build and a legacy x64 build. Verify the exact asset name on the release page before running the curl.

9. SuperDirt (manual step inside SuperCollider)

This cannot be scripted from the shell — it must run inside sclang.

  1. Launch /Applications/SuperCollider.app.
  2. In the code editor pane, paste and evaluate (Shift+Return on each block):
    Quarks.checkForUpdates({Quarks.install("SuperDirt", "v1.7.3"); thisProcess.recompile()})
    
  3. Wait for the status bar to finish compiling.
  4. Evaluate to boot audio + download sample packs (first run only):
    SuperDirt.start
    

Leave SuperCollider running whenever using Tidal. SuperDirt listens on OSC port 57120 and plays whatever Tidal sends.

10. GHCup + GHC + cabal

Non-interactive install of the Haskell toolchain:

export BOOTSTRAP_HASKELL_NONINTERACTIVE=1
export BOOTSTRAP_HASKELL_MINIMAL=1
export BOOTSTRAP_HASKELL_ADJUST_BASHRC=P
curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh

export PATH="$HOME/.ghcup/bin:$HOME/.cabal/bin:$PATH"
ghcup install ghc recommended --set
ghcup install cabal recommended --set

As of 2026-04 this installs GHC 9.6.7 + cabal-install 3.14.2. Add the PATH export to ~/.zshrc for persistence.

11. tidal Haskell library

export PATH="$HOME/.ghcup/bin:$HOME/.cabal/bin:$PATH"
cabal update
cabal install tidal --lib

Takes several minutes; pulls in ~50 dependencies.

12. VS Code TidalCycles extension

code --install-extension tidalcycles.vscode-tidalcycles

Then in VS Code Settings (Cmd+,) search tidalcycles ghci and set:

  • Tidalcycles › Ghci: Base Path = /Users/<user>/.ghcup/bin/ghci

(Required because VS Code's PATH doesn't inherit shell PATH.)


Verification checklist

After everything is installed, verify:

ls -d /Applications/{Mididash,SunVox,Pd-0.56-2,Orca,SuperCollider}.app "/Applications/Sonic Pi.app"
ls /Library/Audio/Plug-Ins/HAL/BlackHole16ch.driver
ls ~/Documents/Pd/Automatonism\ 3.1/main.pd
export PATH="$HOME/.ghcup/bin:$HOME/.cabal/bin:$PATH"
ghc --version
cabal --version
ghc-pkg --simple-output list tidal
code --list-extensions | grep tidalcycles

All should succeed. Then open Audio MIDI Setup and confirm BlackHole 16ch is present (and that any leftover BlackHole 2ch / MS Teams audio driver is gone).

The signal flow this enables

  ┌─ MIDI sources ─┐           ┌─ Mididash ─┐         ┌─ MIDI sinks ──────┐
  │ Orca            │──────────→│            │─────────→ Bitwig (Generic) │
  │ Sonic Pi        │──────────→│  routing   │─────────→ SunVox           │
  │ TidalCycles     │──────────→│    GUI     │─────────→ Pd / Automatonism│
  │ Bitwig HW Instr │──────────→│            │─────────→ (any of above)   │
  └─────────────────┘           └────────────┘         └───────────────────┘

  ┌─ Audio sources (into BlackHole 16ch) ─┐
  │ SunVox                                 │
  │ Pd / Automatonism                      │──→ Bitwig Audio tracks (inputs)
  │ SuperCollider / SuperDirt (Tidal)      │
  └────────────────────────────────────────┘
  • Orca, Sonic Pi, Tidal are three independent livecoding MIDI sources. They don't have to run at the same time — pick whichever fits the mood.
  • SunVox and Automatonism are the external software instruments.
  • SuperCollider / SuperDirt both hosts Tidal and produces its audio — so Tidal is a full "MIDI in, audio out" loop in one app.
  • Mididash is the single place where all routing is visible and editable.
  • BlackHole 16ch is the single audio return path from any external app into Bitwig.
  • HW CV Instrument in Bitwig is not used — it's only for sending analog control voltage out a DC-coupled interface to real hardware synths. Everything here is software.

Lessons learned (read before installing!)

These are gotchas hit during the original session. Future Claude: don't repeat them.

TidalCycles install — cabal install --lib traps

  1. Don't run bare cabal install tidal --lib. Cabal prints a warning about global GHC environment files and silently does nothing (exit code 0, no install). Always use --package-env=default so it actually writes the env file.
  2. Even with --package-env=default, the env file only contains base + tidal — not transitive deps. ghc-pkg called without --package-db will say "cannot find package tidal" because it doesn't read GHC environment files at all.
  3. The cabal store uses vowel-stripped unit-id directory names (tdl-1.10.1-..., clck-..., ntwrk-...). This is normal — they're truncated hashes, not corrupted names. The actual package metadata still says name: tidal.

vscode-tidalcycles needs a wrapper directory, not a wrapper file

The extension's Tidalcycles › Ghci: Base Path setting expects a directory containing both ghci and ghc-pkg executables. It joins /ghc-pkg onto the base path. Solution Brian uses:

~/.local/bin/tidal-ghc/
├── ghci      (script that exports GHC_PACKAGE_PATH then execs real ghci)
└── ghc-pkg   (same wrapper for ghc-pkg)

Both wrappers set:

export GHC_PACKAGE_PATH="$HOME/.local/state/cabal/store/ghc-9.6.7/package.db:"

The trailing colon means "plus the global db". Without this, ghc-pkg can't see tidal even though ghci can (via the env file).

SuperDirt — the SuperDirt.default trap

SuperDirt.start (as of v1.7.3) does not automatically set SuperDirt.default. You must run once per SC session:

SuperDirt.default = ~dirt;

Without it, any direct event-style trigger like (type: \dirt, s: \bd).play will fail with "no dirt instance found". Tidal-via-OSC works without this, because Tidal sends OSC straight to port 57120 — the OSC handler doesn't care about SuperDirt.default. But the SC-side debugging tests do.

Add this to ~/Library/Application Support/SuperCollider/startup.scd to avoid it forever:

SuperDirt.start;
~dirt.notNil.if({ SuperDirt.default = ~dirt; });

SuperDirt — s: parameter must be a Symbol

When testing from SC directly, write s: \bd (Symbol) not s: "bd" (String). The dirt event handler uses Symbol equality. From Tidal this is moot — Tidal serializes correctly.

SuperDirt — duplicate node ID errors

If you s.reboot while Tidal is still sending patterns from VS Code, SuperDirt re-creates orbit groups while Tidal is asking for old IDs → spam of FAILURE IN SERVER /g_new duplicate node ID. Always:

  1. hush in VS Code first
  2. s.reboot in SC
  3. SuperDirt.start in SC
  4. Resume Tidal patterns

BlackHole — distribution is gated, build from source

existential.audio gates the .pkg downloads behind an email form. The GitHub releases page has no binary assets. The clean path on a no-brew machine is to clone and xcodebuild with kNumber_Of_Channels=16 plus the bundle-id/device-name overrides, then sudo cp the resulting .driver into /Library/Audio/Plug-Ins/HAL/. Multiple BlackHole driver bundles can coexist (2ch, 16ch, 64ch) — they have distinct bundle IDs.

macOS coreaudiod can't be killed under SIP

sudo killall -9 coreaudiod returns "Operation not permitted" on SIP-enabled systems. This is harmless — coreaudiod will pick up new HAL drivers on next logout/login or when an audio device is toggled. Don't try to disable SIP just for this.

Spotlight reindex after installs

New .app bundles in /Applications may not appear in Spotlight immediately. Force with:

mdimport /Applications/<app>.app

If still missing, check System Settings → Siri & Spotlight → Spotlight Privacy for stale exclusions of /Applications.

Quarantine attribute strips on every direct download

Anything not from the App Store or notarized comes down with com.apple.quarantine attached and Gatekeeper will block it. Run after every install:

xattr -dr com.apple.quarantine /Applications/<app>.app

itch.io, gated downloads, and Electron apps from source

Some tools (notably the Hundred Rabbits Orca GUI) are distributed only via itch.io with a browser-gated download. The clean answer on a CLI-driven setup is to clone the repo and build a .app bundle yourself:

npx --yes @electron/packager . Orca --platform=darwin --arch=arm64 --out=/tmp/orca-build --overwrite

Use --arch=arm64 on Mac Studio (Apple Silicon). The bundle goes in /Applications/ and Spotlight indexes it normally.

npm-launched Electron apps don't show in Spotlight

npm start from a source checkout runs an Electron dev process — not an installed app — so Spotlight won't index it. If you want it Spotlight-searchable, package it with @electron/packager.

Pure Data (vanilla) is fine; don't install Pd-extended

Pd-extended is abandoned. Pure Data Vanilla from puredata.info (or msp.ucsd.edu) is the actively maintained one. Automatonism 3.1 runs on vanilla.

macOS deployment target warnings during xcodebuild

The BlackHole xcodeproj sets MACOSX_DEPLOYMENT_TARGET = 10.10, which is older than Xcode 26 supports. Warnings are harmless — the build still produces a working driver. Ignore them.

SunVox on macOS is standalone-only — no plugin

There is no AU/VST/VST3 build of SunVox for macOS. The "AU plugin" mentioned on warmplace.ru is iOS only and cannot be loaded into a Mac DAW (not even on Apple Silicon — iOS app sandboxing prevents it). SunVox on Mac integrates via virtual MIDI (Mididash) and virtual audio (BlackHole).

Mididash replaces IAC

Brian standardized on Mididash for all virtual MIDI routing. Do not suggest the macOS built-in IAC Driver as an alternative. Mididash gives a node-graph view of routing, Lua scripting hooks, and avoids confusion when multiple apps need different topology.

HW CV Instrument vs HW Instrument in Bitwig

These are not interchangeable:

  • HW Instrument = MIDI out of Bitwig to anything (virtual MIDI port, USB MIDI device, etc.). Use for SunVox, Pd, etc.
  • HW CV Instrument = analog control voltage out a DC-coupled audio interface to physical Eurorack/Moog gear. Skip it for software-only setups.

Don't confuse Brian by suggesting HW CV Instrument when the target is software.

Conventions learned this session

  • No Homebrew — direct downloads, source builds, or official installer scripts.
  • Prefer .app bundles in /Applications over npm start-from-source so Spotlight can index them.
  • After installing to /Applications, run mdimport to force Spotlight reindex.
  • Strip quarantine attr (xattr -dr com.apple.quarantine) on anything not notarized, or it won't launch.
  • All MIDI between Mac apps flows through Mididash virtual ports, not the macOS built-in IAC driver.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment