The Aleph Virux Manual

// 1Overview

Aleph Virux is a ground-up, userspace reimplementation of Access “Virus Control” for the Access Virus TI family — TI, TI2, Snow, Desktop, Keyboard, and Polar. It drives the synth directly over USB with no kernel driver anywhere: no kext or DriverKit on macOS, WinUSB on Windows, libusb on Linux.

• Plugins: VST3 on Windows, Linux, and macOS, plus an AUv3 on macOS — all with the original synth control surface.
• Standalone apps: Virux runs without a DAW on all three desktop platforms. Each standalone is the full editor — device binding, patch sync, Hardware Link — with an on-screen piano keyboard and a monitor output for the synth's USB audio return. An Android control app is also available.
• Audio and MIDI over USB: multi-channel audio streams back from the synth over the same USB cable that carries notes, parameter edits, and patches.
• Two-way patch sync: a background agent and the plugins keep the editor and the hardware's patch banks in step.
• Emulator support: an emulated TI, TI2, or Snow can be used in place of hardware through the OsTIrus DSP Bridge backend.

One plugin instance (or standalone app, or the background sync agent) owns the USB device at a time; ownership is handed over automatically. Run your project at 44.1 kHz or 48 kHz — the synth streams at its own rate and Virux performs no sample-rate conversion.

// 2Getting Started

Install

• macOS (Apple Silicon): install from the Mac App Store, or use the installer package from the Aleph Void store, which installs the standalone Virux.app (with the AUv3 inside) to /Applications alongside the VST3.
• Windows: the MSI installs the VST3 plugin, the standalone Virux.exe (with a Start Menu shortcut), and the Virux Patch Sync service. See Windows Drivers before first use — Virux cannot run alongside the original Access driver.
• Linux: the installer provides the VST3 and virux-standalone, the same editor in an X11 window with an ALSA monitor output.
• Android: install from Google Play on a device with USB host support.

First run

1. Connect the Virus TI over USB and power it on.
2. Open the standalone app once (macOS: this also registers the background agent), or add the Virux plugin to a track in your DAW.
3. Select your synth in the Device menu: Config › System Info › Device.
4. If Patch Sync is enabled, Virux sweeps the synth's RAM/ROM banks into the browser in the background on first connection.
5. Play: send MIDI from your DAW or the on-screen keyboard; the synth's audio streams back over USB into your session or the standalone's monitor output.

// 3Devices & USB Ownership

The Device menu (Config › System Info › Device) always lists every USB Virus and every configured OsTIrus emulator. A backend that cannot be used right now is greyed out rather than hidden, and the list refreshes automatically — you never need to restart the editor after plugging in a synth or starting an emulator server.

• Single-open ownership: one process owns a synth. A device claimed by another plugin instance, another DAW, or a standalone app cannot be selected until it is released. Two Virux tracks can each own a different synth (for example one USB Virus and one OsTIrus instance) at the same time.
• Sync-agent handoff: the background patch-sync agent hands the synth over to a foreground plugin automatically, so its temporary ownership can never lock you out of your own hardware.
• Availability checks: a USB entry is enabled when the device enumerates and its control interface can be accessed without seizing it from another owner — driver and permission failures disable the entry with help available.

Release USB & Reconnect

Config › System Info › Device › Release USB stops audio capture and MIDI, cancels any patch sweep in progress, and closes Virux's USB interfaces so other compatible software can use the synth. The editor and your saved project remain fully available. Choose Reconnect in the same menu to take the synth back.

• The preference applies to that synth across all Virux instances and the background sync agent, and survives closing the DAW or unplugging the synth.
• It follows the device key — normally the USB port. Moving the synth to a different port gives it a new key, so the release no longer applies.
• Reconnect is always explicit; loading a project does not silently clear a release.
• On macOS, releasing makes the vendor interfaces available to other software; it does not install a MIDI driver. On Windows, it does not change the installed USB driver — see Windows Drivers for switching drivers.

Patch Sync

Patch Sync is a global switch on the Config page's System Info card. When it is on, Virux reads the synth's RAM and ROM banks into the browser (a “sweep”) when a device first connects, and keeps the editor and hardware in step from then on. When it is off, no sweep ever starts and the browser shows no device banks — but storing a patch to a RAM slot still works (unsynced occupants are marked “(not synced)”).

• Turning the switch on starts a fresh live RAM read immediately.
• Refresh patches from synth… in a device bank's context menu forces a new live read of the hardware banks at any time (offered when a sweep could start, never mid-sweep, never with Patch Sync off).
• Installers can preset the switch: the Windows MSI has a “Sync patches from a connected Virus after install” checkbox (silent installs: VIRUX_PATCH_SYNC=0), and the Linux installer accepts --no-sync.

// 4OsTIrus Integration (Emulated Virus)

Virux can control an emulated Virus TI, TI2, or Snow through The Usual Suspects' DSP Bridge. MIDI, parameter edits, patch transfer, and all three stereo audio returns use the same session and the same editor as a USB Virus — the emulator simply appears as another entry in the Device menu. No hardware required.

Setup

1. Download the DSP Bridge 2.2.25 server package for your OS from The Usual Suspects or the 2.2.25 release on GitHub. Extract the complete package and keep its OsTIrus server plugin with it.
2. Start dsp56300EmuServer and keep it running. The default connection is 127.0.0.1:56362; allow that local connection if a firewall blocks it. The official server guide covers platform install locations and server configuration.
3. In Virux, open Config › System Info › Device › Add OsTIrus… and select your original TI firmware.bin or a compatible ROM. This creates a TI2 instance by default.
4. Use a 44.1 or 48 kHz project. Wait for the firmware to boot — a cold boot can take several seconds — then select the OsTIrus entry in the Device menu.

Automatic firmware discovery

When no explicit configuration exists, Virux looks for .bin and .rom files in Documents/The Usual Suspects/OsTIrus in your home directory (also ~/.local/share/The Usual Suspects/OsTIrus on Linux) and in the standard Access firmware directory on Windows and macOS. Any other location can be chosen through Add OsTIrus…. (Setting a VIRUX_DATA_DIR override disables the automatic search, which keeps portable installations isolated.)

Configurations, models & remote servers

Each firmware selection creates a small UTF-8 configuration file in the Virux data directory's ostirus/ folder, named by an ID such as 1.cfg. Close any Virux instances using a configuration before editing it by hand:

rom=C:/Synths/Virus/firmware.bin
host=127.0.0.1
port=56362
version=20225
model=5

• Multiple instances: add separate configurations to run independent emulated synths side by side. Each configuration has a stable ostirus-ID key that is saved with your project and belongs to one Virux instance in a process.
• Shared ownership rules: USB devices and OsTIrus configurations share the same Device menu and the same single-owner rules — two tracks can control a USB Virus and an emulator simultaneously, but neither can steal the other's synth.
• Remote servers: the server can run on another machine on your LAN. The server must be trusted — your firmware is sent to it when its cache is empty — and a wired network is recommended for remote audio.
• Project recall: if a saved OsTIrus configuration is still booting when a project opens, Virux falls back to USB automatically and returns to the emulator once it is ready and free. An explicit Device-menu choice always takes precedence over the saved preference.

Behavior & limits

• Audio: the main and auxiliary buses carry USB1, USB2, and USB3. Snow's different channel layout is mapped automatically. Analog output destinations are not captured — route parts to the USB outputs.
• MIDI & patches: notes, parameter edits, and patch replies travel over the bridge exactly as they would over USB.
• Not available on emulators: Hardware Link, physical USB I/O configuration, and the hardware RAM/ROM bank sweep. Import preset banks into Virux instead.
• Real-time only: processing is paced in real time, like the physical USB backend. Use real-time export; faster-than-real-time offline rendering is not supported.
• Crash recovery: if the server fails, Virux reconnects and restores its latest periodic synth snapshot. Up to one second of changes made just before the disconnection may be lost; project save and recall always use Virux's own editor document.
• Audio-thread safety: firmware loading, hashing, networking, and discovery probes all run outside the audio callback, so an emulator that is booting or unreachable never glitches your session.

Availability & troubleshooting

A configured emulator stays greyed out in the Device menu until its server accepts the plugin version, boots the firmware, reports a supported audio format, and supplies a valid audio block — installing files alone does not mark it ready. Failed probes retry automatically and the menu repaints as soon as the emulator becomes usable.

• OsTIrus help is built into the editor (in the Device menu, and shown automatically whenever no backend can be used). It works offline and includes a firmware selector and the current failure reason — check it first.
• Emulator never becomes selectable: confirm dsp56300EmuServer is running and reachable on the configured host/port, the firewall allows the connection, and the version in the configuration matches the installed server.
• Instance boots but stays silent: confirm the project runs at 44.1 or 48 kHz and the part's output routes to USB1–USB3, not an analog destination.
• A cold firmware boot takes several seconds; the entry enables itself when the emulator is ready.

// 5The Editor

The editor is the original Virus control surface — oscillators, filters, envelopes, LFOs, the modulation matrix, arpeggiator, effects, and the multi/part pages — built from the documented Access parameter model. Every knob edit is sent straight to the synth (hardware or emulated), and the patch state saves with your project.

Oscillator pages

• The oscillator page provides named wave selection and a position readout for Wavetable, Wave PWM, Grain Simple/Complex, and Formant Simple/Complex oscillators.
• Classic oscillators use the hardware's own spectral-wave names: Sine, Triangle, Wave 3–64. The wave selector always draws the selected contour, while the main preview follows the Shape knob as it blends spectral wave → saw → pulse (and follows pulse width).
• The Sub Osc square/triangle buttons choose the separate sub-oscillator's waveform — they are not Shape's destination.
• HyperSaw has rotary density and local-detune controls plus one central X-Sync dial; its preview follows density and detune.
• Wavetable oscillators show an honest position marker (“Position N / 127”) instead of an invented waveform. All previews are illustrative displays driven by the parameters, not captured hardware audio.

Preset browser & bank editing

• The browser shows synced device banks (RAM/ROM) and your local banks in two panes, with program numbers and category tags.
• Drag to rearrange: drag a patch within an editable bank to move it to the destination row, or onto empty space to move it to the end — this works even when both panes show the same bank. Dragging between different banks copies the patch.
• Moving preserves every patch and the occupied program slots, switches the bank's panes to program order, and supports Undo last bank edit, MIDI export, and project recall.
• Duplicate device banks for local editing: rearranging a draft never writes the hardware banks or overwrites source files.
• Storing a patch to a RAM slot offers all four RAM banks, even while Patch Sync is off.

Live Mode & Hardware Link

• Live Mode is a send gate: while engaged, knob movements update the editor without sending parameter changes to the synth. The button sits immediately left of Hardware Link. (If knobs seem to do nothing on the hardware, check this first.)
• Hardware Link (HW Link) puts the synth's own panel and the editor in step for hands-on editing. While HW Link is engaged, notes and controllers from a keyboard plugged into the Virus's DIN MIDI IN are forwarded back to the synth — channels, sustain, pitch bend, pressure, program changes and all — so an external controller keeps playing in remote mode without DAW monitoring.
• Loading a preset onto a part first sends Sustain Off, All Sound Off, and All Notes Off on that part's channel (the same sequence as PANIC), so held voices can't survive a patch change. Other parts are unaffected.

// 6Studio Tools

Open Studio in the editor's bottom bar. Studio edits the current edit buffer — it never stores changes into the synth's RAM banks by itself. History, checkpoints, morph corners, macro routes, and MIDI assignments are all saved in your project state.

• History: grouped undo/redo, up to 32 named checkpoints, parameter comparisons, and restoration of one parameter, a section, or a whole patch. Loading a patch and renaming a loaded patch can also be undone.
• Mutate: pick parameter groups and an intensity, generate a bounded variation, then undo it or keep a checkpoint. Modes, hardware configuration, routing, and locked sections/parts are protected from mutation.
• Morph: capture A/B for a slider or A/B/C/D for an XY pad, choose groups and a curve, and sweep between captured sounds. Discrete modes stay fixed unless midpoint switching is enabled.
• Macros: eight named controls, each with up to 16 destinations across parts. Every route has two endpoints (reversed ranges included) and a curve. Studio/Macro 1–8 are exposed to host automation, and MIDI Learn binds a channel and CC per macro (matching CCs are consumed; everything else passes through).
• Modulation inspector: search the matrix, fixed LFO, filter-envelope, velocity, key-follow, and macro routes by source or destination, and edit amounts in place. These are configured routes, not live signal measurements.

Text presets (.vxp.txt)

Load a patch, then choose Export patch text. The .vxp.txt file is a versioned, human-readable UTF-8 format with stable ordering and no timestamps — ideal for diffing, sharing, and version control:

virux-patch 1
data_size = 512
name = "Warm Pad  "

[parameters]
"Filter 1/Cutoff" = 64 # display label

A complete file also carries every remaining payload byte (including unmodeled bytes in a [bytes] section), so nothing is lost round-tripping. Import patch text validates the whole file before changing anything: unknown parameters, duplicate coordinates, unsupported versions, incomplete payloads, and out-of-range values are rejected. A checkpoint is saved before import when space is available, and import participates in undo history. A text preset contains one synth patch — not the Studio workspace or its cross-part macros.

Share Preset (GitHub)

1. Install the GitHub CLI if needed, then choose Connect to discover signed-in github.com accounts — or Sign in / add account to run GitHub CLI's browser sign-in from inside Virux.
2. Choose Unlisted Gist, Public Gist, or Repository. For repositories, Virux lists your writable, non-archived repos and their default branches.
3. Capture current patch, review the captured text, pick a filename, and Publish captured preset. Later edits don't change the captured text — capture again to include them.
4. Open the returned GitHub URL. Publishing to a repository creates a new file on the shown branch; an existing filename produces an error rather than an overwrite.

Unlisted Gists are readable by anyone with the link. Credentials are managed by GitHub CLI; Virux holds a selected credential only in memory and never writes it into preset files or project state. Note that sandboxed macOS hosts may block external CLI execution — use a permitted standalone/VST3 host, or export the text file instead.

Patch Assistant (Codex / Claude)

Studio › Assistant connects the editor to the installed Codex CLI or Claude Code, using that provider's own account and credentials (provider usage limits and billing apply). Install a current CLI via Install / help, then Connect to use an existing login or Sign in to authenticate. If your host can't complete a browser flow, run codex login or claude auth login in a terminal first.

1. Load a patch — its current edits and complete text representation are the starting point. Start from an initialized patch to build a sound from scratch.
2. Choose Ask about patch for questions (“Why does this have such a sharp attack?”) or Create / edit patch for an idea (“Make a warm evolving pad with a slow attack and subtle chorus”).
3. Enter your request and Send. This sends the current patch text, parameter reference, and recent chat to the selected provider.
4. Review changes shows old and new parameter values side by side; Apply proposal edits only the captured part. A changed part/patch or a locked parameter prevents the whole apply.
5. Undo restores the previous edit, and a “Before assistant” checkpoint is saved when space allows. Use text export or Share Preset afterwards to keep the result.

Safety rails: Ask mode can never apply changes; generated edits must name valid sound parameters with in-range integer values; device, session, and routing controls are rejected; responses never write to the synth or hardware RAM automatically. The assistant sees parameter data, not audio. Conversations and pending proposals live in memory only and are excluded from preset exports and project state, as are credentials. The provider CLIs run locked down — read-only, with shell, web, and tools disabled. Apply is unavailable in Live Mode or while USB ownership is released.

// 7Standalone Apps & OSC Remote Control

The standalone apps are the full editor without a DAW. Each binds the synth, runs patch sync and Hardware Link, and plays the synth's USB audio return through a chosen monitor output (Core Audio on macOS, WASAPI on Windows, ALSA on Linux). A bottom-drawer piano keyboard (macOS/Windows: View › Piano Keyboard, Ctrl/⌘+K) offers per-part channel buttons — tracking the connected model's part count, so a Snow shows channels 1–4 — and an octave slider; the selection persists across launches. On Linux, a missing or failing audio device drops the app to an internal clock instead of ending the session, so MIDI, OSC, and edits keep working.

Enabling the OSC server

The standalones (not the plugins) can run an OSC server so TouchOSC, Max/MSP, Pd, SuperCollider, or your own scripts can set any synth parameter and play notes over the network. It is off by default and receive-only (no OSC feedback is sent).

• macOS: Virux › Settings… (⌘,) — toggle Enable OSC server and pick a UDP port (1024–65535, default 9000).
• Windows: File › Settings… (Ctrl+,) — the same switch, port field, status dot, and activity line, plus the monitor-output picker.
• Linux: start with the --osc flag.

The status dot shows green with “Listening on UDP port N” when live, and the line under it echoes the last message handled — the quickest way to verify a controller mapping. Transport is OSC 1.0 over UDP, one packet per datagram; bundles are dispatched on arrival, ints and floats are interchangeable (TouchOSC's floats just work), and address wildcards are not supported.

Parameters

/param/<Section>/<Name> <value>            set on the editor's current part
/param/<Section>/<Name> <part> <value>     set on part 1–16

• Addresses are the Section/Name paths from the Access parameter database with spaces replaced by _, matched case-insensitively: Filter 1 / Cutoff → /param/Filter_1/Cutoff. All 587 addresses with their ranges are one click away: the Settings pane's Copy Full Address List button puts the list on the clipboard.
• Integers are raw device values, clamped to the parameter's range (e.g. Oscillator_1/Semitone is 16–112 with 64 = center — the hardware's own numbers).
• Floats in 0.0–1.0 are normalized across the range: 0.5 on Semitone → 64. Floats outside 0–1 are treated as raw values and rounded.
• Parameter messages drive the on-screen editor — knobs move, and the change reaches the synth through the same path a GUI edit takes. Without a part argument the message targets the focused part.

MIDI notes, audio output & recovery

/midi/noteon  <ch> <note> [vel]     ch 1–16, note 0–127, vel 0–127 (default 100)
/midi/noteoff <ch> <note> [vel]
/midi/note    <ch> <note> <vel>     vel 0 acts as note off
/midi/<ch>/noteon  <note> [vel]     channel-in-address variants

Channels map to multi parts one-to-one (part N listens on channel N; the app re-asserts this routing on connect and after preset loads). OSC-triggered notes feed the per-part activity meters just like the on-screen keyboard.

/audio/output <name|index|automatic>   switch the monitor output (substring match ok)
/audio/reroute                          re-assert per-part USB routing on all 16 parts
/audio/reboot                           full USB audio reboot (blocking seconds of USB I/O)

• /audio/output re-enumerates devices on every message, so hot-plugged interfaces are addressable; the choice persists across launches and reboots.
• If the USB audio return goes silent mid-set (loading a patch overwrites that part's Output Select), try /audio/reroute first; escalate to /audio/reboot only if the return stays at the noise floor. The app also detects and runs this recovery itself. Recovery commands are paced to one every 30 seconds, since the port is unauthenticated UDP.
• Every handled or rejected message is mirrored to the log with the reason for rejection. macOS: log stream --predicate 'subsystem == "com.alephvoid.virux" AND category == "osc"'. Windows: %TEMP%\virux.log, prefixed [osc]. The first Windows launch may raise a firewall prompt — allow it for controllers on other machines (localhost is never blocked).

// 8Windows Drivers

On Windows, Virux talks to the synth through its own WinUSB driver, and the original Access Virus TI driver claims the same device. Ownership is exclusive: the two driver stacks cannot be installed for the synth at the same time, and Virux will never force a live driver replacement while the Access driver is bound — doing so can crash Windows.

Moving from the Access driver to Virux

1. Close all DAWs and Virus Control applications.
2. Disconnect every Virus USB cable.
3. Run the Virux Windows MSI and select Uninstall original driver. (Silent installs: pass VIRUX_REMOVE_ORIGINAL_DRIVER=1.)
4. Restart Windows, then reconnect the Virus, open Virux, and choose Install Virus USB driver.

The removal option appears whenever original driver components are detected, requires all Virus devices to be disconnected, and removes the original USB/audio/MIDI driver packages, services, and ASIO registrations — leaving Microsoft and unrelated drivers untouched. The restart is mandatory; the installer refuses further driver changes until Windows has rebooted. Your Virus Control patches are not touched.

Switching back to the Access driver

Config › System Info › Switch to Access driver… runs the reverse migration. Disconnect every Virus USB cable first. The helper stops and disables Virux Patch Sync, removes Virux's WinUSB packages and stale device entries, and reports any cleanup failure. Success means the WinUSB cleanup finished — then close Virux and all DAWs, install or repair the Access Virus TI software, and restart Windows before reconnecting. Returning to Virux later requires the migration above again.

Virux USB ASIO

The Windows installer also installs Virux USB ASIO, an ASIO driver that presents the synth to any 64-bit ASIO host — a DAW, a sampler, a recorder — without the Virux plugin. Like the original Virus USB ASIO driver, it turns the Virus into the host's audio interface for the synth's USB audio.

Where it appears. Only inside ASIO hosts: open your DAW's audio settings, choose the ASIO driver type, and pick Virux USB ASIO from the device list. An ASIO driver is a plug-in library the host loads, not a Windows device driver, so it has no entry in Device Manager, in Settings › Sound, or in Apps & features. To confirm it is installed, open Help › Virux USB ASIO status… in the editor: it reports installed (with the driver file, C:\Program Files\Virux\ViruxASIO.dll), file missing or not registered, and names the repair — Settings › Apps › Installed apps › Virux › Repair, or running the installer again.

Channels, seen from the DAW. ASIO names channels from the computer's side, which is the reverse of the synth's labels:

So the “six inputs” are the three stereo pairs the Virus sends to the computer, recorded like the plugin's three output buses; a part routed to USB 3/4 on the synth arrives on inputs 3–4 only. The two outputs stream only after you enable them in the driver's control panel (the ASIO panel button in your DAW), and the synth must be set to Global USB IO Configuration 2 (“3 Outs + Input”) to listen to them. Sample rates 44.1, 48, 88.2, 96, 176.4 and 192 kHz; buffers of 64–2048 samples (256 preferred).

// 9Licensing (Aleph Void store VST3)

VST3 builds purchased from the Aleph Void store (Gumroad) use a license key; Mac App Store and Google Play builds are licensed by their stores and need none of this. Your key is shown on the Gumroad receipt/download page.

1. Install the downloaded .vst3 (the installer does this, or unzip into C:\Program Files\Common Files\VST3\ on Windows / /Library/Audio/Plug-Ins/VST3/ on macOS).
2. Place the license-key string in a plain-text license.key file (the installer can write it for you):

On first launch the plugin verifies the key online against the store, then writes a machine-bound cache next to it. After that, launches are offline: the cache is trusted for its re-check window (default 7 days), then re-verified online; if the store is unreachable at re-check time, the cache is honored for a further grace period (default 14 days). An invalid license (no key, refunded, or disputed purchase) keeps the editor from opening the synth and the audio path emits silence.

// 10Troubleshooting

• Knobs move but the synth doesn't change: check Live Mode — it gates every parameter send while the GUI looks normal. Its button is immediately left of Hardware Link.
• Can't select the synth: another process owns it — a second DAW, a standalone app, or another plugin instance. Close the other owner, or check whether Release USB is active for that device (Config › System Info › Device › Reconnect).
• No audio return, notes still sounding: a patch load can overwrite a part's Output Select. Re-route the part to USB1 L+R, or in a standalone send /audio/reroute; the apps also detect and repair this themselves.
• No device banks in the browser: Patch Sync is off (Config page, System Info card), or the first sweep hasn't completed. Use Refresh patches from synth… on a device bank to force a live read.
• Wrong or no sample rate: Virux follows the host rate — 44.1 and 48 kHz natively, 88.2, 96, 176.4 and 192 kHz through its built-in sample-rate converter. If audio stops after a rate change, restart playback or reload the plugin so the host re-announces the rate.
• Can't find Virux USB ASIO (Windows): it is listed only inside ASIO hosts, never in Device Manager or Settings. Help › Virux USB ASIO status… confirms whether it is installed; see Virux USB ASIO.
• Text in an editable field is tiny (Windows): fixed in the release after 0.1.116 — the inline edit box now scales its text with the editor size and display scaling.
• Emulator trouble: see OsTIrus troubleshooting; the built-in OsTIrus help page shows the current failure reason.
• Help pages: USB help and OsTIrus help are built into the editor and work offline; both appear automatically whenever no backend can be used.

Still stuck? Open an issue on the GitHub tracker or email via the Support page — include your hardware model, OS version, host/DAW, Virux version, and steps to reproduce.