DSSI: Which S is for 'Simple'...? 
In a forum thread on the Renoise board, the question about DSSI support came up, which prompted me to have a look at the DSSI specification. Thought I might as well post my opinion about it here. Sorry for this little rant.
A DSSI plugin UI is a separate standalone program, that communicates with the host (not directly with the plugin) via Open Sound Control messages. (Thus ducking out of the GUI toolkit compatibility question altogether, ensuring that the plugin is always correctly automatable by the host, and in principle permitting plugins to be controlled by other OSC clients as well.)

Sounds complicated enough, splitting the plugin up into separate "plugin dll" and "gui executable" parts, which both have to know plugin internals; and communicating to the host using OSC, over UDP (!) as required by DSSI. (I know it sounds cool that you might be able to have your DSSI plugin running in Renoise on one machine, and control it from a GUI running on another machine. But show me just one person who is actually doing this. Or at least, name one use case for this. And no, "sounds cool" is not a use case. Besides, if you really want to do this, use ssh -X.)

But it gets funnier:
The mechanism by which a host locates and starts the UI for a plugin is host-dependent, and this section is only a recommendation.

Next follows a "recommendation" how the GUI executable corresponding to the plugin might possibly be found (or possibly not). I. e. there is no defined way to even locate, and start the UI.

Oh, and have you checked out the licence:
Note that liblo is distributed under a different licence from DSSI and so might not be a legal option for certain DSSI implementations.

I won't go into the stupidity of using a network protocol to communicate data between a UI and a real-time audio app which is supposed to have ultra-low latency, it's just too idiotic. Not mentioning the bloat and dependencies it adds.

Now the parameter passing from host to GUI and back is done by parsing strings (like the "base path"), which is, of course, the safest, easiest and most efficient possible method to pass some information which you actually don't need (hint: just pass the parameters to the process/function/whatever-place it belongs, using a numeric ID for each parameter; no need for a "base path"). Some of these parameters are:
<base path>/midi

Send an arbitrary MIDI event to the plugin. Takes a four-byte MIDI string. This is expected to be used for note data generated from a test panel on the UI, for example. It should not be used for program or controller changes, sysex data, etc. A host should feel free to drop any values it doesn't wish to pass on. No guarantees are provided about timing accuracy, etc, of the MIDI communication. (optional method)

"Optional method". Right. Expect lots of confused users clicking on a keyboard control in the UI and not hearing any output, because it's "optional".

# <base path>/show

Show the UI, if it's a graphical interface in a window or some other type that it makes sense to show or hide. If the UI is already visible, bring it to the front if possible. No arguments. (optional method for UIs in general, but it would be bad form to implement a graphical UI without it)

Which reminds me about the usability problems with separate GUI apps. Think about fullscreen mode: Click anywhere on the Renoise window; Plugin GUI window will be hidden. Bring Plugin GUI window to the foreground with some key combination; it will be visible, but only until you use Renoise again. Next, click the "Show Editor" button and wonder why the editor is not shown (it will be HIDDEN by clicking the button, because it was actually visible, just obscured by the fullscreen Renoise window). Also, window managers will show their taskbars et cetera when a non-fullscreen window is shown, overlapping the Renoise window. In any case, you can't use both Renoise and the Plugin GUI at the same time. This will completely disrupt the workflow - just like with current Standalone Synth apps - unless maybe if the plugin gui code uses some clever X11 magic to exclude the gui window from taskbars and also make it topmost, which MIGHT work on SOME window managers - and then you'd have a topmost window which isn't hidden when you switch away from Renoise, which is, probably, also annoying. (The way Renoise currently handles native VST editor windows, presumably using some kind of reparenting, won't work with separate GUI apps because neither Renoise nor the GUI app know about each others' window IDs.)

Etc, etc, etc. All this sounds to me like, "Hey, let's make a plugin API for Linux. But let's make it as complicated, bloated, hard to use for developers and users alike, and inefficient as possible. Also, let's introduce lots of nodes where stuff can easily break. After all, we're dealing with Linux users here. These people LOVE fixing broken stuff."

I'd love to have a decent plugin API for Linux, but I think DSSI is not it.
Hopefully LV2 is more sane. I haven't looked into it yet...

Comments are not available for this entry.