Aria's thread of barely working betas and bug squashing: Modulus Salomonis Regis (soft released)

Heyo hello.

Rather than keeping one single megathread for everything announcement and beta etc, I’m gonna do as suggested, a small announcement thread when I release something new, and this mysteriously auspicious Beta thread just for you, fearless adventurer who dares to install automatic builds off Github.

Download the latest builds for every platform here

I’ll keep the OP clean to edit it with additional info later if needed.

Thank you for testing my art. :dog:

2 Likes

UPDATE: This module is no longer in beta and is part of the library. Release thread here.

UnDuLaR Rack Scroller

I have not tested it thoroughly, and tried it only on Windows. Feel free to report issues either in this thread or on github. Corrections to the documentation are also welcome.

See the post above for downloads.

Disregard the output at the bottom, it’s just for debug.

Here’s a copy-paste of the documentation for it:

Scroll your rack via CV! UnDuLaR adjusts to the size of your rack without any setup. You can also automate cable tension and opacity.

This is particularly useful for live performance with MIDI gear. While you can bind every control, I recommend using only one movement input. Build a rack that is no wider (or no taller) than your screen at your preferred zoom level, bind to MIDI either a trig input pair or a scroll input, then lock the unused axis with its button. You do not want the mental overhead of navigating two dimensions while performing.

  • UP, DOWN, LEFT, RIGHT: Take trigs, and jump around the rack in the corresponding direction, wrapping around when it reaches the end.
    The default vertical jump is 3U - the height of exactly one module.
    The default horizontal jump is 32hp - the width of exactly one module, so long as the module in question happens to be exactly 32hp.
  • Step X, Step Y: Adjust the distance to jump on each trigger.
  • Scroll X, Scroll Y: Take 0V~10V, and smoothly scrolls your rack horizontally or vertically. You might want to invert the input if it feels more natural for you to operate your MIDI controller in the reverse direction.
  • Padding: Overshoots the scrolling a little by the specified amount of pixels at 100% zoom.
  • Zoom: Takes 0V~10V, and zooms your rack in and out from 25% to 400%. Zooming in and out in VCV Rack is neither fast nor reliable enough to ever attempt during live performance. Expect broken graphics, CPU usage spikes, and audio crackles. This is due to VCV’s graphics engine, there is nothing I can do to improve the performance.
  • Alpha (Opacity): Takes 0V~10V, and scrolls your rack horizontally, adapting to its current dimensions.
  • Tnsn. (Tension): Takes 0V~10V, and scrolls your rack horizontally, adapting to its current dimensions.
  • Lock X/Lock Y: By pressing those dangerous buttons, UnDuLaR fully takes over scrolling on that axis, preventing scrolling from the scrollbars, scrollwheels, arrow keys, middle click, or from dragging cables at the edges of the screen. It will be a little bit jittery, I can’t help it. Those locks will only work if the three corresponding cable inputs for that axis are unplugged. If you find yourself unable to scroll back to UnDuLaR, use this menu option temporarily to re-enable scrolling: Engine > Sample Rate > Pause.

Known issue: zooming in and out after locking the rack won’t bring you where you expect, and might allow you to get out of bounds.
Known solution: don’t do that.

You can only use a single instance of UnDuLaR in your patch, as multiple instances would just fight each other for control. Additional instances past the first one do nothing.

Make sure you triple check the module works to your expectations every single time you’re about to take it on the stage, especially after a Rack update! I’ll hear no complaints about botched performances, the module is provided as-is, with zero guarantee it will work with your setup, and zero guarantee that it will continue to work in the future. The only guarantee I offer is that zooming will cause you no end of trouble.

Thanks to Frank Buss’ Shaker for demonstrating it’s possible to do this stuff from a module!

Protip for cool kids only: Never hesitate to attempt all sorts of imbecilic party tricks you will regret immediately, such as connecting an oscillator to the controls, forcing you to use Engine > Sample Rate > Pause before the onset of the seizure.


And if the use case isn’t clear, this is the use case:

This module was spurred by the difficulty to use a pen tablet with VCV. Kind of an esoteric need, and I hope it can help with other unusual setups.

There’s a lot of “wouldn’t it be neat if you could” kinda scenarios with this module, but I will not implement them if they’re suggested, I’ll implement them if there’s a clear use case for an artist out there. I don’t want to put in a lot of polish just in case in a very niche module few people will use.

7 Likes

BTW - this module has by nature a very limited audience, so I greatly appreciate anyone testing it despite not intending to use it.

A few things I’d particularly like tested before I shove it into unsuspecting libraries:

  • How much did you figure out from the faceplate alone before using the manual?
  • Do the default values feel good to use?
  • Does it work as expected on HDPI? On Mac? On Linux?
  • Does it feel good or janky to use?
  • Any weird race condition that would arise in the wild?
2 Likes

Just spent five minute with it on Linux. Super fun. Easy to use. UI makes all the sense. Put up Lapsus driving Knock and Slap (all from Vult). Slap’s output inverted and then into the cable tension input. Tweaked the attenuverter’s knobs a bit (Bogaudio), and the cables looked like a side view of the kick drum head, dipping down on every kick drum beat. Added Darius, a vca (fundamental), and a quantizer (Rewin) into Lindenburg Research’s MicroWolde, into Tangents (Vult) and finally Slap for a nice bass line.

No crashes, no odd behavior whatsoever.

I could have watched and listened for an hour, but really wanted to get my report to you. Thanks for the awesome modules!!!

1 Like

Works on my Mac. I read over your instructions last night and then tried to figure out the UI today. I was able to get things going without too much confusion. My midi controller options are limited and ATM rack is refusing to cooperate with my 2nd-hand (and rather janky) trigger finger, so I just used my keystep through MIDI-Gate. It made for a rather daft setup that no one would really want to use in a performance, but it worked (even when I arpeggiated the mapped notes at a rapid tempo*). For the hell of it, i did hook up a (not slow enough) LFO to the zoom*. Took me a while to make it stop, but I didn’t puke or have a seizure and nothing caught fire, so i think you’re covered.**

*Imbecilic party tricks, as advised
**Not legal advice.

1 Like

Thanks for testing. The update has been submitted to the library since I confirmed it isn’t horribly broken for anyone. There’s a few things I still want to tweak, but I’ll get more reports whether it works or not with people’s setups once it’s pushed to the library.

1 Like

You will find a WIP version of Darius in the development branch. Automatic builds available from the link in OP. Please use this thread for feedback on the dev branch to keep github issues for released versions.

If you can test it with existing patches, please do so, I want to ensure the next update won’t break most patches. Let’s see you break this thing.

  • Added an attenuator to the CV output.
  • Can now start the sequence on any step. The “Steps” knob is now known as the “Last step” knob. Existing patches should not be broken by this change.
  • Added undo support for the two “Randomize” buttons.
  • Right-click options to reset CV and Routes separately.
  • The quantizer is not implemented yet. There’s only the UI, it does nothing.
  • Support for portable sequences planned.
2 Likes

Yay!

At default settings, with each route a coin flip, on step 8, Darius results in a normal distribution. Anyone knows the math to make the outputs uniformly likely, so I can offer it as a right click preset? (And if the math is any sort of complicated, giving me the values in addition to how they are obtained would rule)

[Edit: problem solved]

I‘m not convinced right now that this is the only solution: Adjust the probabilities in such way you effectively get a binary tree, so all nodes on the „levels“ with 3, 5, 6 or 7 nodes need to go deterministic one way.

1 Like

Essentially I’d like to offer a preset where every single end node is as likely to be picked, which might entail different settings if the user made the path shorter than 8 total steps. I can fudge decent settings that more or less do that, but I’d rather offer something mathematically correct.

But of course I’m more concerned about the results being musically useful than with the maths being elegant.

It is mathematically correct.

{
  "id": 17,
  "plugin": "AriaSalvatrice",
  "version": "1.4.0",
  "model": "Darius",
  "params": [
    {
      "id": 0,
      "value": 5.0
    },
    {
      "id": 1,
      "value": 5.0
    },
    {
      "id": 2,
      "value": 5.0
    },
    {
      "id": 3,
      "value": 5.0
    },
    {
      "id": 4,
      "value": 5.0
    },
    {
      "id": 5,
      "value": 5.0
    },
    {
      "id": 6,
      "value": 5.0
    },
    {
      "id": 7,
      "value": 5.0
    },
    {
      "id": 8,
      "value": 5.0
    },
    {
      "id": 9,
      "value": 5.0
    },
    {
      "id": 10,
      "value": 5.0
    },
    {
      "id": 11,
      "value": 5.0
    },
    {
      "id": 12,
      "value": 5.0
    },
    {
      "id": 13,
      "value": 5.0
    },
    {
      "id": 14,
      "value": 5.0
    },
    {
      "id": 15,
      "value": 5.0
    },
    {
      "id": 16,
      "value": 5.0
    },
    {
      "id": 17,
      "value": 5.0
    },
    {
      "id": 18,
      "value": 5.0
    },
    {
      "id": 19,
      "value": 5.0
    },
    {
      "id": 20,
      "value": 5.0
    },
    {
      "id": 21,
      "value": 5.0
    },
    {
      "id": 22,
      "value": 5.0
    },
    {
      "id": 23,
      "value": 5.0
    },
    {
      "id": 24,
      "value": 5.0
    },
    {
      "id": 25,
      "value": 5.0
    },
    {
      "id": 26,
      "value": 5.0
    },
    {
      "id": 27,
      "value": 5.0
    },
    {
      "id": 28,
      "value": 5.0
    },
    {
      "id": 29,
      "value": 5.0
    },
    {
      "id": 30,
      "value": 5.0
    },
    {
      "id": 31,
      "value": 5.0
    },
    {
      "id": 32,
      "value": 5.0
    },
    {
      "id": 33,
      "value": 5.0
    },
    {
      "id": 34,
      "value": 5.0
    },
    {
      "id": 35,
      "value": 5.0
    },
    {
      "id": 36,
      "value": 0.5
    },
    {
      "id": 37,
      "value": 0.0
    },
    {
      "id": 38,
      "value": 1.0
    },
    {
      "id": 39,
      "value": 0.5
    },
    {
      "id": 40,
      "value": 0.5
    },
    {
      "id": 41,
      "value": 0.5
    },
    {
      "id": 42,
      "value": 0.0
    },
    {
      "id": 43,
      "value": 0.0
    },
    {
      "id": 44,
      "value": 1.0
    },
    {
      "id": 45,
      "value": 1.0
    },
    {
      "id": 46,
      "value": 0.0
    },
    {
      "id": 47,
      "value": 1.0
    },
    {
      "id": 48,
      "value": 0.5
    },
    {
      "id": 49,
      "value": 0.0
    },
    {
      "id": 50,
      "value": 1.0
    },
    {
      "id": 51,
      "value": 0.0
    },
    {
      "id": 52,
      "value": 0.5
    },
    {
      "id": 53,
      "value": 0.0
    },
    {
      "id": 54,
      "value": 1.0
    },
    {
      "id": 55,
      "value": 0.5
    },
    {
      "id": 56,
      "value": 0.995500028
    },
    {
      "id": 57,
      "value": 0.5
    },
    {
      "id": 58,
      "value": 0.5
    },
    {
      "id": 59,
      "value": 0.5
    },
    {
      "id": 60,
      "value": 0.5
    },
    {
      "id": 61,
      "value": 0.5
    },
    {
      "id": 62,
      "value": 0.5
    },
    {
      "id": 63,
      "value": 0.5
    },
    {
      "id": 64,
      "value": 0.0
    },
    {
      "id": 65,
      "value": 0.0
    },
    {
      "id": 66,
      "value": 0.0
    },
    {
      "id": 67,
      "value": 0.0
    },
    {
      "id": 68,
      "value": 0.0
    },
    {
      "id": 69,
      "value": 0.0
    },
    {
      "id": 70,
      "value": 0.0
    },
    {
      "id": 71,
      "value": 0.0
    },
    {
      "id": 72,
      "value": 0.0
    },
    {
      "id": 73,
      "value": 1.0
    },
    {
      "id": 74,
      "value": 0.0
    },
    {
      "id": 75,
      "value": 8.0
    },
    {
      "id": 76,
      "value": 0.0
    },
    {
      "id": 77,
      "value": 0.0
    },
    {
      "id": 78,
      "value": 0.0
    },
    {
      "id": 79,
      "value": 0.0
    }
  ],
  "data": {
    "step": 0,
    "node": 0,
    "lastNode": 0,
    "lastGate": 0,
    "pathTraveled": [
      0,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1,
      -1
    ]
  }
}
2 Likes

Nice! Think there would be a solution where no node is skipped?

Makes me think maybe I should run a check to disable the jack LEDs for outputs that are 100% impossible to reach.

Also, any suggestions for other musically useful presets/alterations to provide in the right-click menu? Darius will be able to quantize stuff so I can operate on pitches.

Here’s the revised UI I’m considering (most of it is not implemented yet). Trying to strike a balance between the most common requests I received, and wanting to keep it simple and backwards compatible with most existing patches, so I don’t have to make make a separate Mk.II version.

Since nobody liked Arcane, I’m shoving its LCD on Darius to force you to look at it :smiley:

In general I stick to my policy that μMap exists, so there is no reason to provide CV in for every single knob.

The LCD will give you info about the knob you’re currently turning depending the modes you’re in, so while quantized it’ll tell you which note you’re dialing. I’d also like to show you the relative and absolute probability of reaching a node, e.g.,

. . .
60% 9%
40% 6%

I’ll provide built-in scales and support for external scales using a poly cable, where any value above 0V enables a semitone (12TET only). I will make a separate module to turn custom scales to a poly cable, but you can also craft it like in the picture above. This should have all sorts of interesting musical implication.

Creating all these components is also laying some groundwork for a planned gesture sequencer, still in the design phase.

The UI is not set in stone yet, so please let me know if you have concerns or if something doesn’t seem intuitive.

5 Likes

Okies, now the quantizer is ready to play with! Tested on Windows only.

I’d like to know if it breaks any patch, and which scales you think would be good for the quantizer.

Since there will be support for arbitrary 12TET scales, I’m not adding every scale ever, just things I think will feel musical and fun to play with whether you know theory or not. I’m adding both the major scale and the natural minor, but I think adding other modes you can obtain by changing the key would be clutter. What do you think?

Note that currently the Slide knob, External input, and Gate output do nothing. Also, the LCD easily gets into broken states due to modes I haven’t implemented yet.

Download the automatic builds from the link in OP as always.

1 Like

I’d love major and minor blues scales.

It’s already in! Here’s the curation so far:

		case MAJOR:	 			return "Major";
		case NATURAL_MINOR:		return "Natural Minor";
		case MELODIC_MINOR:		return "Melodic Minor";
		case HARMONIC_MINOR:	return "Harmonic Minor";
		case PENTATONIC_MAJOR:	return "Pentatonic Major";
		case PENTATONIC_MINOR:	return "Pentatonic Minor";
		case BLUES_MAJOR:		return "Blues Major";
		case BLUES_MINOR:		return "Blues Minor";
		case BEBOP_MAJOR:		return "Bebop Major";
		case SPANISH_GYPSY:		return "Spanish Gypsy";

Anything added to Darius will be added to Arcane and will be part of future planned modules too. I’m focusing on instant satisfaction kinda settings rather than on providing every single scale someone gave a name to.

1 Like

Now with a visual representation of nodes that are impossible to reach, and absolute probability of reaching any node! I’ll add your binary tree idea as a right-click preset.

2 Likes

With the latest automatic build, external scale support was added, and it’s a great way to use Darius as an arpeggiator. Until I eventually make a dedicated module for this, here’s how you send it a chord or scale: on a 12 channel poly cable, anything over 0V enables the semitone.

And here’s my thinking how to implement Portable Sequences - tagging @Squinky.Labs for feedback on this. Since this module is very unorthodox, I don’t think any behavior can satisfy every use case.

On export: Export one random possible path, a different one each export, unless an external random seed is provided from the Rnd input. The length of the sequence is that of the Darius range - from 1.0 to 8.0. Each note is of length: 1.0. There is no way to export multiple loops at once - it’s up to other modules in the portable sequence ecosystem to offer concatenation if users want that. When in bipolar CV mode, still export the pitch in unipolar mode.

On import: Import to the selected range up to the first 8 events it sees, without regard for their length or start, since all bets are off if the user is trying to import polyphonic data anyway. Clone the value to every node of a step - e.g., on the third step, import the third event to all 3 knobs. It’s assumed the user will edit them.

One interesting implication of this possible implementation is that exporting and re-importing allows you to treat a random sequence as a new point of departure to edit.

4 Likes

I like that idea. I especially like the export idea. On import, if I understand Darius correctly, I think the result is that Darius would play the first 8 notes, but it would be up to the user to then add some interest by making some of the note options different? That seems nice and predictable, and maybe what a user would expect? It might be more “fun” to take the first 31 pitches and pour them into all the note slots (I’m guessing that there are 31)? But, as you say, no one answer is going to always be the right one, so I think our proposal would be great.

Some of the other “portable” people are a little more creative than I. Maybe @marc_boule or @Richie will have something useful.

1 Like