u/danja

https://strandz.it/jigdaw/simple.html

I've been working on a specification for web-native plugins. To kick the tyres, with considerable AI assistant help I'm building a browser-based DAW. But it's really early days, big job.

However, given that a small screen isn't much use for a full DAW, I've made a mini player. The first preset is chiptunes, based on a port of the 8astard chip emulator. After loading the preset you can scroll down to change the parameters. The beat & tune are generated algorithmically, there are a lot of knobs to play with.

It can be installed locally but will need network whenever a new plugin is to be loaded.

The Jig plugin spec is over here : https://danja.github.io/jigdaw/

I've been making VST plugins and find myself rather ambivalent over the UI component to use for analog controls. The skeuomorphic rotary knobs look good, but seem a bit unnatural in use. With sliders it's easier to see their current position, but mine at least all tend to look naff.

What are opinions here? Any tips on design?

What alternatives are there?

I'm currently working on a specification for Web-native plugins "JigDAW" and to sanity check I want to create a variety of plugins that exercise different parts of the system. I've already got a handful that do the basic midi & audio operations but now need to try things that may be more demanding.

For testing I've got a simple browser-based DAW (the main target of this kind of plugin), a minimal native Linux DAW which I originally put together to make generative systems out of plugins, and a VST wrapper which allows the JigDAW plugins to be run in a regular DAW - I use Reaper.

To give an example of what I'm looking for, today I'm trying to get a NAM/IR processor working. It worked fine in the browser DAW but fell apart when it came to the native one (the WebAssembly runtime I was using wasn't up to it, I'm having to swap for another).

Any suggestions?

In case anyone's curious, the spec is at : https://danja.github.io/jigdaw/

https://danja.github.io/jigdaw/

JigDAW is a specification for audio plugins that run natively in a browser but which is also designed to build on the substantial ecosystem of tools and code targeting native/desktop DAWs. A plugin is identified by a single dereferenceable IRI. Fetching it returns a description of what the plugin is, what it needs from a host, and where its code lives, each resource carrying an integrity digest a host verifies before running it. There is no separate installer and no registry; publishing a plugin is putting these files somewhere a browser can fetch them.

Why

Native plugin formats such as VST3 and LV2 separate identity, discovery and delivery into different mechanisms: a class ID, a catalogue entry, an installer. The web has not had an equivalent for a plugin whose processing is real code, distributed by URL and verified before it runs. Web Audio Modules cover part of this gap; JigDAW adds identity, verification, capability negotiation and an RDF description a catalogue can query, and interoperates with WAM rather than replacing it.

Security

A plugin is arbitrary code from an origin the host does not control. A host fetches, parses and validates the profile before fetching anything the profile names; verifies a SHA-384 digest on every resource before it is instantiated, with no continue-anyway path past a failed one; and, where a plugin carries its own user interface, loads it into a sandboxed cross-origin frame rather than the host's own document.

Linked Data

A profile is RDF. Its musical description (role, the signals it accepts and produces) is written in the trn: vocabulary already published by the plugin-universe catalogue, so a JigDAW plugin is a valid entry there without translation. Its parameters are plain LV2 (lv2:), so an existing LV2 plugin's port descriptions carry over unchanged. Only the terms specific to running a plugin in a browser, jig:, belong to JigDAW, published at http://purl.org/stuff/jigdaw/ and dereferenceable like everything else here.

Relation to other specifications

• LV2: a plugin's parameters are LV2 ports, not a JigDAW-specific format.
• plugin-universe / transmissions (trn:): the musical vocabulary, shared rather than forked. jig:WebPlugin is a subclass of trn:PluginProfile, so an existing catalogue entry becomes loadable by extension, not by being rewritten.
• Web Audio Modules: a JigDAW plugin can be packaged as a WAM 2.0 module, and JigDAW can host a foreign WAM under stricter isolation and explicit user consent than the WAM API itself requires.
• REAPER JSFX: an importer converts a JSFX effect's script to bytecode run by a shared WebAssembly interpreter, so an existing JSFX effect becomes a JigDAW plugin without being rewritten by hand.
• VST3 / CLAP / LV2 (native): an optional portable module ABI lets a plugin with no JavaScript engine around it be loaded directly by a native host. A reference adapter built on it loads JigDAW plugins into a desktop DAW.

For DAW developers

Loading a plugin you did not write is an ordered sequence, documented in for-hosts.md: fetch the profile, parse it, validate it against the published SHACL shapes, check what the plugin requires against what the host offers, fetch and verify its resources, register and construct its AudioWorkletNode, then send init and wait for ready before connecting it into the graph. A minimal, standalone reference host renders real audio from a plugin's IRI to a WAV file with no browser at all.

For plugin developers

A plugin is a profile, a processor, and usually a WebAssembly module doing the signal processing; for-plugin-authors.md covers writing all three, the real-time rules a processor must follow, and generating integrity digests as part of a build rather than by hand. The module is optional: a plugin simple enough for plain JavaScript declares none. Two shortcuts exist for a plugin that already exists elsewhere: one importer converts a REAPER JSFX effect, another packages a JigDAW plugin for a WAM 2.0 host.

What is implemented

The specification is complete and normative. A browser host implements it and runs 9 worked plugins: a subtractive synthesiser, a reverb, a compressor/expander/limiter/clipper with a sidechain input, a transport-synced bass line generator, the firmware of a three-chip synthesiser compiled unmodified from C++, three REAPER JSFX effects, and a plugin whose entire signal path is JavaScript. A native VST3/CLAP/LV2 adapter fetches, verifies and sounds the plugins that declare a portable ABI. The session format saves and reopens carrying the IRIs that make it portable. Plugin user interfaces of their own, as opposed to a panel generated from declared parameters, are specified and not yet implemented.

Source and specification: github.com/danja/jigdaw. Apache 2.0.

Valis is a standalone app and a DAW plugin for building virtual analog circuits. Free, open source. Built on JUCE so should support a variety of systems, but currently only tested on Linux.

https://danja.github.io/valis/

It can be viewed as a factory for instruments and effects processors. Existing examples include :

• SH-101 style monosynth
• TR-909 drum voices
• Klon Centaur guitar overdrive
• Massive synth "scream" filter
• Clarinet voice (digital waveguide model)

These are all simplified to some extent, but good enough to be fun, imho.

Valis is at an alpha stage of development, I'm still testing/working through bugs, builds are still rather hit & miss. But I wanted to post about it now to ask for suggestions for things to try, any other thoughts..?

The circuits are built from compiled elements, functional blocks at around the same level of abstraction as synth modules. Circuit topologies are defined in RDF/Turtle. The same circuit is presented through three views : a regular plugin view Controls with knobs etc, a node-and-arc network of components Circuit and a syntax-highlighted Turtle editor Code.

Functionality is also supported through MCP, so an LLM can drive every operation the UI can. You can ask AI to design and build circuits. The core of this system is the Valis ontology https://github.com/danja/valis/blob/main/vocabs/valis.ttl

A short demo video from a few days ago (much has changed): https://www.youtube.com/watch?v=iwrzSXKTRcY

This afternoon I had a play in the music room. Got as far as something I quite liked, but wasn't sure what to do with it next.

So over to you...

https://github.com/danja/stems#stems

140 BPM electronic instrumental, quite melodic, fairly conventional instrument grouping.

I really like collaborations, but I live in a tiny village, my only opportunity in person here is with a guitarist friend.

But, damnit, there's the web!

This first thing is 8 tracks of stereo stems, about 3:30, as 16bit? .wav files. Git clone would be the easiest way to get them, but they can be downloaded one at a time.

Let me know if anything I can do to improve the collab potential. Also any suggestions for the kind of sounds you'd like me to deliver this way. And any other thoughts...

I do have some (ancient) history around noise/industrial music, but recently I've been playing with generative stuff on the computer which usually comes out more conventional.

Today however the computer was busy (working on https://danja.github.io/valis/ ) so I went DAWless, this was the result.

Good fun!

Intro sounds familiar

Three tunes taking turns in my head today. "White Room", Cream, is one, "Devil's Answer", Atomic Rooster another. "Knife Edge" by ELP.

Jeez, how old am I? Also basslines.

It's hybrid, most the sequencing is coming from generative VST plugins via midi2cv. Nothing pre-recorded (apart from a clock beat, and the patch).

https://danja.github.io/downspout/

I've been making some VSTs recently. Chatting with a friend who's a Web Dev, asked if they could run with WebAudio.

That's almost certainly a big no as it stands.

But I wonder - what about a WASM-based VST host, that could reach to the native bits? Or a compile of the plugins that allowed JS and/or HTTP control?

The latter seems kinda viable - for a different reason (mcp) I have a web server embedded in this plugin: https://danja.github.io/downspout/plugins/campione/

Dunno, a Web-based DAW that can do VSTs? Thoughts?

I've recently been working on an audio sampler built as a VST plugin. I'm trying to automate some of the workflows that can be tedious to do by hand. There are a few that need knowledge of the kind of sound.

A good example, a common requirement is to take a selection of drum sounds and associate them with specific standard General MIDI notes, it's something like C2 kick, D2 snare...

I've had a look at some of the classifier algorithms available, there are several that use quite sophisticated machine learning. But these seem to be overkill for this role (and probably too demanding on compute).

I'm wondering if something like an FFT followed by a heuristics -based selector might be feasible, or failing that using a fairly shallow neural net.

Thoughts and/or pointers?

https://danja.github.io/downspout/plugins/campione/