URX Router

A routing planner and unofficial mixer controller (read / write / live sync) for the YAMAHA URX22 / URX44 / URX44V USB audio interfaces.

Based on the official block diagram, it visualizes input/output channels, mixer buses, and output patches as boxes and wires, and constrains the GUI so that only physically routable paths can be wired. Plans are saved/loaded as JSON, and the diagram can be exported as an image.

The URX series has no dspMixFx-style mixer editor — dspMixFx supports the UR-C / URX-C lines, not the URX22 / URX44 / URX44V. Out of the box, the full mixer is only editable on the unit's touch screen: the official Stream Deck plugin covers one-touch operations like level steps, mutes, and processing-block on/off toggles, and the Cubase / Nuendo / MixKey integration screens work only while that software is running. URX Router fills this gap: it reads, writes, and live-syncs the entire mixer from your computer, with or without a DAW — see Device control.

Background — why this tool exists and how it came together, written up as a development note.

日本語版は README.ja.md を参照してください.

Live demo

Runs entirely in your browser — no install required: https://urx-router.semnil.com (the demo has no save dialog or image export; instead you can drop a plan JSON onto the window to open it, share a plan as a URL, and download the plan JSON for the desktop app).

Download

The desktop app is free (Windows 11 / Apple silicon macOS). Get the latest installer from the GitHub releases page, or from BOOTH / Gumroad. Desktop builds auto-update.

Device control

With the Device Center software (included in Yamaha's TOOLS for MGX / URX) running, desktop builds can read the connected interface's current mixer settings into the plan (Device → Fetch from device) and write a plan back to it (Device → Write to device). Live sync starts by reading the interface's settings into the plan and then mirrors each edit as you make it, so a plan you have opened reaches the interface through Write to device, before Live sync is turned on. The parameter mapping and the factory-initial plan are verified on hardware for the URX44V and the URX22; the URX44 is assumed identical to the URX44V and is not verified on hardware. Writing overwrites the device's current settings; see the Disclaimer. External MIDI controllers can be mapped to the console controls (Device → MIDI control). The --experimental flag additionally unlocks the SIM view (the unit's LCD, drawn over the same plan), a destructive-then-restored self-test diagnostic, importing a URX .urxf settings file, and a read-only Compare with device.

The console view shows the same plan as a mixer surface — per-strip faders, mutes, EQ, dynamics, and sends. Edits made here live-sync to the device the same way, and live meters run while Live sync is active.

Claude Code skill

This repo also publishes a Claude Code skill, urx-routing-planner, that turns a plain-language request ("send mic 1 to the stream mix and FX1 for reverb") into a validated URX Router plan plus a ?plan= deep link into the demo. It answers feasibility questions from a bundled per-model route table and never needs any control-protocol detail.

Install it as a plugin from this repo's marketplace:

/plugin marketplace add semnil/urx-router
/plugin install urx-routing-planner@urx-router

The skill's routing data is generated from the same device model the app uses (src/models/), so it stays in lock-step with the app — see UPDATE_SKILL in CLAUDE.md.

Tech stack

• Tauri 2 (desktop shell / Windows 11 and Apple silicon macOS)
• TypeScript + Vite (frontend, zero runtime third-party dependencies)
• Rendering is plain SVG (no node-graph library)
• English-first UI with Japanese localization, switchable at runtime
• Studio-rack aesthetic with dark and light themes (auto-follows your OS color scheme by default) (docs/en/architecture.md)

Development

git submodule update --init   # vendor/urx-lcd-sim; a clone and a new worktree start with it empty
pnpm install
pnpm dev            # browser at http://localhost:5173 (Rust not required)
pnpm tauri dev      # launch as a desktop app (Rust toolchain required)
pnpm build:demo     # build the browser demo bundle (VITE_DEMO=1: no save dialog / image export)
pnpm preview        # serve the demo bundle at http://localhost:4173 — the same build as the live demo

Because the planning UI is pure frontend, you can verify behavior in a browser with pnpm dev even without Rust installed. Desktop builds (pnpm tauri dev / pnpm tauri build) require Rust. pnpm dev runs the full build; to see the reduced demo build locally (what https://urx-router.semnil.com serves), use pnpm build:demo then pnpm preview.

The full command list (unit/e2e tests, formatting, cache cleaning) and development notes live in CLAUDE.md.

The UI is English-first with a Japanese translation, and a control reproduced from one of the unit's own screens is not translated — the URX is English on those screens whichever of its three display languages is selected, so Threshold, Attack, Freq, Pan and the rest read the same in both app languages. That is enforced by the compiler rather than by review: every string in src/i18n/en.ts is wrapped in dev() (device label), fixed() (identical for a reason that is not the device) or tr() (this app's own copy), and a translation of a dev() string fails the build. See CONTRIBUTING.md.

Pass --experimental to enable what is hidden by default — the SIM view, the on-device self-test, .urxf settings-file import, read-only Compare with device, and the Device Center link readout on the status bar:

pnpm tauri dev -- -- --experimental          # dev
open -a 'URX Router' --args --experimental    # built app (macOS)
urx-router.exe --experimental                 # built app (Windows)

To clear the app's persisted UI state (theme, model, meter points, the consent gate, recent files, inspector sections), open the browser app's reset URL or pass a launch flag:

pnpm reset:storage                            # browser: opens http://localhost:5173/?reset
pnpm tauri dev -- -- --reset-storage          # desktop: clears the webview's localStorage

Disclaimer

URX Router talks to the hardware using a control protocol determined by independent analysis, not from official documentation. Every parameter the tool writes has been checked against a connected URX44V and URX22 (the URX44 is not verified on hardware), but sending data to hardware always carries some risk. Writing a plan to the device overwrites its current mixer settings — save anything you want to keep to a scene on the device first.

By using URX Router you accept this risk. The software is provided "as is", without warranty of any kind, and the authors are not liable for any damage to hardware, loss of settings, or other loss arising from its use. The desktop installer shows this notice together with the license and asks you to accept it before installing.

Documentation

English documentation lives under docs/en/; the Japanese translation is under docs/ja/.

• docs/en/architecture.md — application structure and design decisions
• docs/en/device-model.md — the device routing model and connection constraints
• docs/en/console-sends.md — the CONSOLE view's per-strip SENDS rack design
• docs/en/known-issues.md — current limitations

Contributing

Bug reports, feature requests, and pull requests are welcome — see CONTRIBUTING.md. Verification on a URX44 is especially valuable, since the parameters were confirmed on a URX44V and a URX22. Security problems go through SECURITY.md, and participation follows the code of conduct.

License

MIT © semnil

Distributed desktop builds bundle the Tauri runtime and other open-source components; their license notices are included in the build (see docs/en/architecture.md).

Acknowledgments

The URX22 meter mapping was verified on real hardware by @takashyx (#173) — the first meter mapping confirmed on a model other than the URX44V.

Trademark notice

YAMAHA, URX22, URX44, and URX44V are trademarks of Yamaha Corporation. This is an unofficial, independent tool and is not affiliated with, sponsored by, or endorsed by Yamaha.