It should probably be an additional button on the piano display.

• Only an active note can be the root
• Only a single note can be the root
• It should be lit automatically when the info provided by the source (expander, poly external scale, scene), or when the knobs are used to pick a scale.

Because OS X 10.13 is a whole TWO YEARS OLD, and Microsoft is a small startup lacking the resources to support legacy products, they are removing support for OS X 10.13 a whole three damn days after I rigged up Pipelines.

After the next release, try replacing the "13" with a "14" and see what happens.

• Doesn't change the date on the LCD
• Doesn't refresh the fortune (regression)

https://community.vcvrack.com/t/aria-salvatrice-signature-series-1-3-0-beta-arcane-atout-aleister-todays-fortune/7734/60?u=aria_salvatrice

No detailed info and no reports from OS X yet

I need to be able to measure the problem more precisely. There has to be an easy gain somewhere obvious.

Here's a place to dump idle thoughts about how to evolve the Darius sequencer. No promises I'll ever do it.

My thoughts:

• Darius was made on a whim and should remain exactly as-is, save for voltage range selection. It's meant to inspire and challenge you to work within its limited but easily understood framework.
• None of the requested features are impossible to achieve right now. It takes a bit of patching, and adds negligible sample latency, but it's rather straightforward. My C++ skills are still limited, so no rushing to get it done ASAP.
• Note selection via knob and tooltip is a huge pain, so let's not add note selection to the original Darius - people know how to use quantizers.
• Just adding every single feature as requested to a new module would mean a super large faceplate and difficult workflow. I want no menu diving.
• Adding more I/O to the existing 32hp faceplate is impossible, it’d be a separate module no matter what.
• Going past 8 steps means too big a possibility space to program manually (8 steps = 36 nodes, 16 steps = 136 nodes, 16 steps = 528 nodes). If you randomized a pattern this big it’d sound no different from pure randomness, without any discernible repeating pattern.
• The network is currently 1 > 2. 1> 3 would also be possible, but much less intuitive to program. It would also call for separate devices.
• Things people might want to program:
  • Pitches, quantized or not
  • Chords
  • Note selection from a chord
  • Modulation / general CV
  • Envelopes
  • Gates
• Types of possible motion - adding them all would be silly, which should make the cut?
  • Random, 1 node forward
  • Random, n nodes forward
  • Force a step up or down, 1 node forward
  • Force a step up or down, n nodes forward
  • Same as above but backwards
  • Reset to step 1
  • Jump to node n
• Could link multiple instances, similar to Splort and Smerge
• Multiple banks would be good but there's no reason to have a ton of them, since it's all about slowly evolving patterns
• Some features have overlap with other modules I have planned and can share code
• The module should not be named in a way that implies it's superior to the original, nor should it set out to make the original obsolete

Excerpts from the VCV forums:

CV controls for the route knobs would allow for some compositional subtlety. I’m using a shift register and a comparator so that a note is only played when consecutive notes are different. If I have the top row set mostly the same and the bottom row set all different it would be great to gradually shift the positions of the direction knobs. Thanks. (dag2099)

Positive/negative voltages (as an add’l option - maybe a few +/- voltage modes in the menu) would be nice. On/off for each step with a probability knob would be cool for a kind of built-in Bernouli gate thing. That, along with a global gate output for triggering envelopes. A built in quantizer with some scales would be neat but not entirely necessary. A global transpose with a CV input (if there were a quantizer built-in with scales, this could transpose the root note). (funkybot)

Hello,
I really like darius module and this morning I was thinking it would be nice to have the possibility to begin the sequence not in the first row but in the second or third or fourth... and like this to have already probability at the beginning of the sequence. So maybe a new knob to cut steps from the beginning of the sequence?
Have a nice day and thanks a lot for your great work.
Matthieu

Compile failure on Mac platform:

src/Splirge.cpp:47:24: error: implicit instantiation of undefined template 'std::__1::array<float, 4>'
                std::array<float, 4> splitVoltages;
                                     ^
/home/cschol/src/osxcross/target/bin/../SDK/MacOSX10.13.sdk/usr/include/c++/v1/__tuple:223:64: note: template is declared here
template <class _Tp, size_t _Size> struct _LIBCPP_TEMPLATE_VIS array;
                                                               ^
src/Splirge.cpp:64:24: error: implicit instantiation of undefined template 'std::__1::array<float, 4>'
                std::array<float, 4> mergedVoltages;
                                     ^
/home/cschol/src/osxcross/target/bin/../SDK/MacOSX10.13.sdk/usr/include/c++/v1/__tuple:223:64: note: template is declared here
template <class _Tp, size_t _Size> struct _LIBCPP_TEMPLATE_VIS array;

You are missing an explicit

#include <array>

at the top of the file. This is required for Mac platform only.

In my fixed rack where I lock X, upon reloading VCV Rack, it is offset a little and I have to unlock and manually nudge. This is probably not the behavior anyone wants.

Haven't looked into how to implement it yet

Maximum seems around 130 characters.

Basically,

Weird, was pretty sure it worked

If the collection continues to grow, a github page won't cut it for documentation. I want to make something nicer, using the templates currently in use on https://aria.dog, which uses a homegrown static site generator, but could be adapted to github pages.

Hi,
I like Darius very much but also love to have the ability to repeat the same semi random sequence multiple times. So I would propose to add an external random cv input to be used in up/down decisions. Added a Screenshot implementing it using cv mapping. In this solution probabilities for up and down have to controlled using Seeds of Change. Would be much easier with an ext. rnd input.
The random generator which allows to set a seed (ext. rnd in) to get repeatable random numbers can easily copied from OrangeLine (Mother) source code. So it shouldn't be much work to do it but would make Darius much more usable in my setups.

Regards
Dieter

Regression

hello,

to get your plugin (current vcvrack library submitted git commit hash) compiled natively on linux (aarch64 in my case but it should apply to intel linux as well i guess) i needed the following patch to get it compile: https://github.com/hexdump0815/vcvrack-dockerbuild-v1/blob/master/AriaSalvatrice.aarch64.patch ... maybe i'm doing something wrong or maybe it is really required ...

best wishes - hexdump

Look into the Azure file I adapted to see what that make target entails and whether it's safe to swap it to dist on windows.

To reproduce, patch two different clocks in Back and Forward and observe individual gate outs.

Not sure what's going on here. Repro:

I'm waiting until Arcane hits the library and people start to understand it before I draw attention to this, but currently, the server has a very conservative selection of music scales.

I'll just copy what I say in the source:

# Once people understand what Arcane does, I'd like to have experts help me
# decide which ones to add, which to omit, which weights would be best.
#
# I AM NOT SEEKING TO ADD A FULL LIST OF EVERY CONCEIVABLE SCALE EVER.
# Please re-read the line above.
#
# I'll avoid using a lot of fancy theory words, and just explain the big idea:
# shoving any random shit into the quantizer should sound fun and musical to
# people from most countries.
#
# Until that conversation happens, I'll start out with a very limited, 
# safe curation, and add more exotic scales later.

Here's the relevant part of the script. You don't have to know the language to understand what it does. https://github.com/AriaSalvatrice/Arcane/blob/f698b7f064bc5355f702dae3bdb940222a6bf3f7/arcane.coffee#L53

Hey, love your modules!

Just noticed that today's (2020-02-16) Arcana (13) resulted in the card name not being displayed. Wondering if that's intentional or not, or if it's just... unlucky. Here's the relevant json file.

Not a big deal, initially thought it was part of the slimmed Atout, but it affects Arcane too. At least Arcane shows the art!

Here's a screencap: https://i.imgur.com/iQl4vkJ.gifv and hopefully it's not somehow my fault.

D

I don't have easy constant access to a mac currently. I need to know when things break on other platforms, and make it easier for people to test things by providing development binaries.

It seems that people had success with both Azure and Travis-CI.

To reproduce, build a big rack, send Up/Down pulses, and notice the first/last row can be cut off sometimes, normally it should never happen no matter the settings.

Not sure what's going on, I think it broke with an update.

Code is literally copy-pasted from Darius so there's gotta be something weird going on.

The effect was probably an artifact of nanovg subpixel hinting in the first place. I can probably alter the files automatically to increase the gap.

I do not want to use a font unless the rendering is perfect everywhere: pixel-perfect at every zoom level on every OS, no antialiasing or weird subpixel hinting behavior, visible scanlines or pixel grid but still readable at 100% standard DPI.

Woof Aria,

This is a bit hard to explain but here I go:
When you load the project I attached, it will play a chord sequence, this should be Cm7 Dm7 E#M7 A#(add9), and it is !
When you stop the clock close rack and start rack again, all is still fine.
But...
...when you close rack while playing (the clock is still running), the first chord in Qqqq will change to the chord that was playing when you closed rack.
So when you close rack while it's playing a Dm7 , the first chord in the seq will become a Dm7.

Greetings Peter.

AriaBug.zip

Simple example use case:

No elegant way to send that chord to QQQQ

Forgot where it was posted, but I think pausing the engine is slated for removal in rack v2.

Having a way to stop a misconfigured UnDuLaR instance is crucial, as it could otherwise destroy a patch.

Providing instructions how to edit the JSON yourself in a text editor would be good enough, but I could create a little all-in-one javascript page that automates it, and provide it as part of the plugin.

Aria,

Where can I get the updated Mac version with the Quantizers?

If the first instance added to the rack fails the download, other instances are stuck on the "DOWNLOADING" message, despite those other instances not attempting a download themselves.

What's a better message? It should fit in 11 characters spaces included.

"LOADING"
"WAITING"
"WAIT ON DL"

better ideas?

When the scale is set from an external source in such a way the tonic is known, QQQQ should forward it instead of using its key knob.

There exists no use case for this yet, but it should be fixed to make those use cases possible in the future.

Inconsistent with documentation & how I want it to work.

Received a suggestion via private conversation to add the proposed portable sequence format to Darius. For now I haven't decided.

See also: https://github.com/VCVRack/Rack/issues/1708

Copying my reaction here:

I considered it, but the main problem is that it has a different amount of nodes per step. This is how it represents its steps internally:

const int STEP1START = 0;  //               00        
const int STEP2START = 1;  //             02  01            
const int STEP3START = 3;  //           05  04  03          
const int STEP4START = 6;  //         09  08  07  06        
const int STEP5START = 10; //       14  13  12  11  10      
const int STEP6START = 15; //     20  19  18  17  16  15    
const int STEP7START = 21; //   27  26  25  24  23  22  21  
const int STEP8START = 28; // 35  34  33  32  31  30  29  28

There's two major ways people use it: all probabilities to the center, or strongly biased to a side (I.E., biased to go 00 01 03 06 10 15 21 28).

I just have no idea how to interchange data in a way that'd match people's intuitions. We've got 36 nodes rather than a multiple of 8, and a different amount of potential nodes per step.

I think the least worse behavior for it would be, upon receiving a sequence, to treat it as a 8 step sequence, and assign its values to every node of the corresponding step, and let the user work from here. But I have no idea whatsoever what people would want to export. Exporting only the top or bottom path would encourage a specific way of working with the device and restrict its potential. Exporting a random possible 8 step sequence would be more in the spirit of the module, but would not be intuitive.

I'd like to see how the reference implementations do things and how much enthusiasm users have for it before I decide to do this, Darius has some really messy code due to my lack of experience with C++, so it'd require a very major rewrite, without breaking existing sequences that provide a fixed seed to the PRNG.

They're already fast but they could be even faster

These modules are in part a learning project for me. It's my very first C++ project, and I barely have a clue what I'm doing. A lot of things are implemented the hard way, with a lot of duplication.

Bad code that gets the job done today is better than beautiful code I will "release one day".
But I'd prefer to have clean code that gets the job done. If you have suggestions how and why to improve aspects of the existing code, they are welcome. You can use this issue for that.

Hi just letting you know I was able to build your plugins on Mac as you said you weren't able to test it.

Gonna complicate the code, but worth fixing if I want the library to eventually be reusable by others.

Off by one error somewhere.

I pushed an emergency fix to the server - corrected today's fortune, and made it so the Fool can't be drawn. I will revert the latter change a week after a fix for Arcane is in the library.

I ran into this yesterday on Linux. I think it's a relatively easy fix because it's simply freeing the same memory twice. I'll build a version with debugging turned on and maybe I can suggest a patch.

*** Error in `./Rack': double free or corruption (out): 0x0000000002b7e880 ***
======= Backtrace: =========
/lib64/libc.so.6(+0x81679)[0x7fb79f461679]
./Rack(rack::engine::Module::~Module()+0x56)[0x5bb4c6]
/home/kwilliams/.Rack/plugins-v1/AriaSalvatrice/plugin.so(Darius::~Darius()+0x17)[0x7fb79289ca01]
./Rack(rack::app::ModuleWidget::~ModuleWidget()+0x1f)[0x5a285f]
/home/kwilliams/.Rack/plugins-v1/AriaSalvatrice/plugin.so(DariusWidget::~DariusWidget()+0x17)[0x7fb79289c931]
./Rack(rack::app::RackWidget::clear()+0x1b1)[0x5ac923]
./Rack(rack::app::RackWidget::~RackWidget()+0x19)[0x5ae80f]
./Rack(rack::widget::Widget::clearChildren()+0x11d)[0x5b556d]
./Rack(rack::widget::Widget::~Widget()+0x1c)[0x5b5594]
./Rack(rack::widget::ZoomWidget::~ZoomWidget()+0x10)[0x5b48a2]
./Rack(rack::widget::Widget::clearChildren()+0x11d)[0x5b556d]
./Rack(rack::widget::Widget::clearChildren()+0x91)[0x5b54e1]
./Rack(rack::widget::Widget::~Widget()+0x1c)[0x5b5594]
./Rack(rack::app::RackScrollWidget::~RackScrollWidget()+0x10)[0x5b1020]
./Rack(rack::widget::Widget::clearChildren()+0x11d)[0x5b556d]
./Rack(rack::widget::Widget::~Widget()+0x1c)[0x5b5594]
./Rack(rack::app::Scene::~Scene()+0x2f)[0x5a7b1f]
./Rack(rack::App::~App()+0x18)[0x56efd4]
./Rack(rack::appDestroy()+0x15)[0x56f0d1]
./Rack(main+0x509)[0x4e6359]
/lib64/libc.so.6(__libc_start_main+0xf5)[0x7fb79f402505]
./Rack(_start+0x29)[0x4eb1f9]

It sounds like a pain to fix, so I won't do it unless someone shows me their setup where it's a pain point.

The revised docs assume it does.

Will be fixed next version

Should also probably be the default.

Build fails on multiple platforms when compiling QuickJS using an environment like the official build system.

Unfortunately, I don't have time today to troubleshoot this further.

I am attaching the build log: aria.log

Received private reports. Will update when I collate & figure out repro conditions.

https://vcvrack.com/manual/VoltageStandards#timing
https://github.com/MarcBoule/ImpromptuModular/#on-resets-clocks-and-run-states-

The simplicity (and formal beauty) of the WTFPL served me well while the collection was a bunch of small hacks, but it's now polished software, I want to avoid having it used commercially without giving back to the community.

Given that RMS is no longer in charge of the FSF, I have insufficient long-term trust that the values of the FSF will remain what they have been in the past.
I do not want to use the "any later version" clause when I have no way to know that future licenses won't become less restrictive.

However, I think I'm gonna keep my re-usable components under the WTFPL so the VCV community can benefit from them in commercial & GPL-incompatible modules.

Just gonna license on a file-by-file basis, with a clear boilerplate which is which on each. In general, module = GPL, re-usable library = WTFPL.

Simply documenting my decision here, as there's nothing to debate, since it's a solo project I get to do whatever I want.

Via private conversation.

can't seem to tell how to reproduce beyond "spamming direction inputs" - it seems to happen if you end the sequence with a "down" then begin the next with an "up" or vice versa

See #8 for plans to possibly make a more featured device.

• Voltage range selection
• Accept polyphonic triggers