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

A test patch I altered to prove it’s not too hard to implement, I didn’t want to immediately refuse a feature request without verifying it’s not necessary.

The design of the module requires that individual gate outputs stay up until the very sample the next step starts, so some external processing will always be required.

BTW, I’m glad it was possible to figure out the module without a manual! But since I won’t do the docs for a few days probably, if someone plays with it, 4 things to know:

  • The nodes’ inputs do nothing until a step input is accepted. Then, a 1ms window will open, during which any signal over 0V on that output triggers it. It is impossible to send multiple triggers during that window. Multiple triggers add up, so a trigger to Add 3 and Add 1 will add 4 scale degrees. Pushbuttons work at all times, window or not.
  • Simultaneous (exact same sample) step inputs have the following priority: Queue > Teleport > Walk > Back > Forward. Only one type can happen at the same time. The most recent build has revised UI to show the priority.
  • If nothing is enqueued, the Queue step input has no fallback - it will not open an input window. To have a fallback, patch one explicitly. If multiple steps are enqueued, it picks one at random. If the rocker switch is set to reset, it will also clear the queue.
  • Here’s what the stuff on each column means:
- - -
- Enqueue -
-1 octave + 1 octave
-3 scale degrees +3 scale degrees
-2 scale degrees +2 scale degrees
-1 scale degree +1 scale degree
Play = current step Segment display (* = #)
Queue indicator Delay indicator (runs 1 step late)
-1 scale degree +1 scale degree
- Toggle queue
Gate (guaranteed) Random gate (50% chance to happen)
- V/oct of node
Latch (every other time node plays) Delay (guaranteed one step later)
1 Like

There is now a little Chord <=> Scale conversion device, called Quale, in the dev builds. It’s very simple but an important piece to realize the system of modules I have in mind.

Here’s the manual:

Quatherina’s Quale

Quatherina the Quantum Duck doesn’t experience the existence of multiple octaves, and quavers at those who purport to. She makes no distinction between chords and scales. It’s all voltage to her.

With some qualms, she humors your fancies, offering Quale: a little 3hp module to convert scales (as expressed in Qqqq’s polyphonic data bus format) to chords, and the other way around.

When you patch the Scale Input, it’s expressed on the Chord Output as a polyphonic chord on the fourth octave (0V to 0.91667V).

When you in a polyphonic V/Oct signal on the Chord Input, it’s folded to a single octave and expressed on the Scale Output in the Qqqq format, compatible with the rest of my collection.

Quale can be used as an expander with the entire Qqqq family: when Quale is placed to the left of Qqqq, its Scale Output is forwarded to Qqqq. When Quale is placed to the right of Qqqq, the scale from Qqqq is expressed as a chord on Quale’s Chord Output.

Protip for cool kids only: Quatherina has recently taken to calling people who claim to subjectively experience the existence of multiple octaves Q-Zombies.

Lemme know what you think! Downloads from the usual place: https://github.com/AriaSalvatrice/AriaVCVModules/releases/tag/AzureCI

All my modules that work with scales support Qqqq’s representation of them: as a 12-channel polyphonic cable, where enabled semitones have a value above 0V. While the performance of encoding it as a voltage on a single-channel data bus would be higher, this polyphonic representation has the benefit of being easily user-hackable, which is much more important to me. I encourage interested developers to interoperate with this way of representing scales.

Unfortunately, integration in the library is still proving difficult, since I learned that Prototype is compiled manually rather than cross-platform, so the problem of compiling QuickJs under osxcross remains.

After I fix a few bugs I will probably do an interim forum-only announcement / stable manual install release (without the Solomon series still in development).

2 Likes

I noticed the add3/sub3 inputs transpose the pitch way more than 3 notes. I’m not a programmer so I could be mistaking, but shouldn’t these be 3 instead of 8/9?

    void applyTransposes() {
        for(size_t i = 0; i < NODES; i++) {
            if (sub1Sd[i] ) subSd(i, 1);
            if (sub2Sd[i] ) subSd(i, 2);
            if (sub3Sd[i] ) subSd(i, 8); //here
            if (sub1Oct[i]) subOct(i);
            if (add1Sd[i] ) addSd(i, 1);
            if (add2Sd[i] ) addSd(i, 2);
            if (add3Sd[i] ) addSd(i, 9); //and here
            if (add1Oct[i]) addOct(i);
        }
        clearTransposes();
    }

Edit: Sorry, I forgot to mention that I’m talking about Solomon.

1 Like

Oh right, just some stray test values I used to debug a problem and didn’t revert! My bad, pushing a fix, will be built in a few minutes.

2 Likes

You’re my hero!

Last few days, I’ve been working on the documentation for my modules, to replace the github README.

I’m particularly happy how I’m simulating patchcables in the browser, showing you exactly what the jacks do as you scroll:

I’ll be honest with ya, my effort was 1000% overkill compared to what’s necessary, my module docs were more of a use case for me to learn more about the vue.js ecosystem (it’s nuxt.js under the hood). I got most of the basics in place, needs a bit of polish.

If you wanna give it a spin, lemme know what you think, but please note, only the pages for Arcane and Darius exist for now, every other page will just give you an error. And for now, it only works on a big screen, it will break on phones or if the window isn’t maximized, and it consumes more CPU than it ought to.

It’s here:

https://aria.dog/modules/

And the source:

6 Likes

Unsurprisingly, I’m finding out that Modulus Salomonis Regis works much better with self-patching patterns simple enough you can follow how they change.

A few interesting techniques I discovered:

  • Because a gate to a + and its corresponding - cancel out each other, you can use that to slow down the rate of change
  • By sending gates to “Queue” twice as fast as “Forward”, you can create interesting rhythmic patterns. By setting a single output to trigger many queues, and staying in Keep mode, you can make the pattern accelerate for a few steps.

Test beat, with also some QQQQ tricks in SD transpose mode

4 Likes

First quirky interesting excellent modules and now equally excellent docs? NICE! Great job on a very unique doc site!

2 Likes

Modulus Salomonis Regis is close to finished.

Only a few features are missing:

  • No documentation yet… Embrace the mystery! (look at the previous posts for some explanations)
  • No portable sequence I/O yet
  • LCD not fully implemented yet, it’s a bit wonky but you can set the key and scale.

I encourage everyone to please start testing it heavily, and report. Lemme know if it works for you (I need a report from an OS X user!), and what you think about it.

Be sure to report any weird behavior, just be prepared for me to tell you they’re intended. For example, if you change the scale, it doesn’t re-quantize the nodes until they’re changed. That’s by design.

Automatic builds from the usual place: https://github.com/AriaSalvatrice/AriaVCVModules/releases/tag/AzureCI

This version also includes a fix for the QQQQ crash when importing long chord progressions.

2 Likes

I ran into a bug that surprised me so much I decided to canonize it. When sending both a Walk and another type of input, there was a chance to repeat the note! This was not intended, because you can already set up this kind of behavior through self-patching, so I fixed it, but I thought it’d still be useful to expose that possibility:

image

In Teleport mode, it has 1 / Total nodes enabled chances to repeat. In Walk mode, 1 / 3 chance (then the direction is 1 / 2 ). The New/Any has no effect on other modes.

Once I release this module, I will NOT consider feature requests. It is intentionally challenging and surprising to use, to the point I feel I’ve barely started to discover myself all the fun tricks it makes possible. I want us to explore its potential before exposing more options.

So if you want to argue for changes in its behavior, do it now.

And reminder: I need confirmation it works from a Mac user.

Also, since I am writing the credits for the docs right now, I’m reminded of this, for the segment display, I’m using the DSEG font - and take a look at the author’s page, they also created a lot of cute DIY synth hardware :smiley:

4 Likes

Hi, Aria. There’s a flicker in the display of the active step:

if you want to argue for changes in its behavior, do it now.

Okay, I was kinda hoping that triggering the reset, would reset to the first step. (Instead of doing a pitch reset) And that maybe we could have that “pitch reset” as separate inputs for each step (I know that one might be too much changes with the ui). Whatever you think is best. I love it no matter what! Amazing work. Keep it up.

Log file? log.txt (100.2 KB)

The behavior in the video is intentional. The play button isn’t eye-catching enough to visualize the current step once the module is heavily self-patched.

I figure that one is best left for queues.

In general my thinking for this module is to provide well curated defaults that produce musically surprising results instead of a lot of toggles. Things are already sufficiently intimidating as they are. The more options I add, the more I restrict how many people will dare learn how to use it.

1 Like

I figure that one is best left for queues.

How did I not think of that! Thank you!

This was intended, it not happening was a bug, fixed, thanks. As of the last build, the LCD is also fully implemented.

1 Like

I have added the following right-click options:

image

With that, I consider Modulus Salomonis Regis complete. Work on the documentation will start now.

Please test it and let me know what you think.

Builds: https://github.com/AriaSalvatrice/AriaVCVModules/releases/tag/AzureCI

Reminder, I need someone to test it on the Mac

2 Likes

Sanity testing on my MacBook running MacOS 10.15.5 looks good!

1 Like

Thanks for testing on the mac!

The first part of the documentation is ready, it’s not complete but it should help if people had trouble figuring out how to get started: https://aria.dog/modules/modulus

2 Likes

Whoa - I don’t really know what I’m doing, just patching stuff but I’m getting very cool evolving melodies. Seems very powerful and unique! I’m going to investigate more…

EDIT:

Played with it some more. It’s not as intimidating as it first appears with all those patch points - the design is super smart and very unique, I don’t think I’ve ever used a sequencer quite like it. If I had to describe it, it’s like a sequencer with a brain that you can program. So cool!

As an aside, it looks really great in lights off mode.

2 Likes

And the manual is now finished! https://aria.dog/modules/modulus

We still haven’t figured out how to get my stuff to build again in the library, but I’ll be doing a manual release soon. If you got feedback, don’t delay!

I have added one more feature: right-click option to quantize upon reset input.

3 Likes

The module is now soft-released, beta-testers just can’t keep up with my pace lol.

I’ll just do a 1.6.1 if stuff breaks.

Stable downloads: https://github.com/AriaSalvatrice/AriaVCVModules/releases/tag/1.6.0

I submitted it to the library, but we haven’t solved the build issue yet, so for now it’s a manual install.

Still gotta finish up the doc site & collection video intro, then I’ll make an announcement thread.

4 Likes