Loomer's Architect

Loomer's Architect https://www.loomer.co.uk/architect.htm is a long awaited MIDI manipulation SW for Mac, Windows and Linux. It is actually a modular MIDI toolkit and music production environment that can be used as a VST and a VST Host.

a-chaos (https://www.kvraudio.com/forum/viewtopic.php?p=7299827#p7299827) is a set of chaos macros for Loomer's Architect implementing chaos- and fractal-related algorithms. The macros can be used in the generation of chaotic series, for sonification purposes, for generating LFO's, to create powerful modulators or for any other purpose. The macros were purposely implemented using the graph part of Architect (and not by simpler LUA scripting) in order to allow me to better learn the Architect syntax. In case the output of the algorithm is "bounded" (on 1, 2 or 3D) the capability of mapping in a certain way (linear, etc) the data to sound parameters (like note height, LFO's, velocity, patches, cutoff, rythm ...) is what makes this type of algorithms a deep source of inspiration.

A nice and visual reference for the algorithms implemented in a-chaos can be found on the page http://paulbourke.net/fractals/. Currently the following algorithms are implemented in the library: a-lorenz (3D), a-henon (2D), a-hopalong (2D), a-dejong (2D), a-clifford (2D), a-duffing (2D), a-logistic (1D) (courtesy of Charles Turner).

This collection is unrelated to A-chaos lib for Max/MSP http://s373.net/code/A-Chaos-Lib/A-Chaos.html.

Musinum (https://reglos.de/musinum/) is an algorithm developed by L. Kindermann, here implemented in Architect (https://www.kvraudio.com/forum/viewtopic.php?p=7379312#p7379312). This is an interesting algorithm, both from a musical as well as a mathematical point of view. Starting from a counter "i" a "number" is produced (from a "start" number and a "step"); the number is the converted in a different "base" and the single digits of the new number are summed up. For example, (from the Musinum site):

decimal binary sum of number number digits Tone 2nd 4th 1 1 1 c 2 10 1 c c 3 11 2 d . 4 100 1 c c c 5 101 2 d . . 6 110 2 d d . 7 111 3 e . . 8 1000 1 c c c 9 1001 2 d . . 10 1010 2 d d . 11 1011 3 e . . 12 1100 2 d d d

Please note the columns 2nd and 4th: here we have a "self-similarity" effect, which is a very interesting property of the output series. The architect implementation implements the following (Matlab/Octave) code (with some limitations):

% example initializationN = 1000;start = 0;step =1;base = 2;
% main loopfor i = 1:N
 num = start + i*step;
 D = dec2base(num,base); L = length(D); temp = 0; for j = 1:L temp = temp + str2num(D(j)); end
 out(i) = temp;
end

Now, if you have Matlab/Octave on your computer try the following:

% in case of base 2:out(1:20)out(2:2:40)out(4:4:80)% in case of base 3:out(1:20)out(3:3:90)out(9:9:180)

and you have identical sequences, i.e. self-similar. The Architect implementation is centered on a macro ("musi_num") which has the following inlets:

  • input: an incremental/decremental number triggered by a Metronome, for example set to 1/8 step: (>=1), as in above code
  • start: starting integer (>=0), as in above code
  • base: numerical base in which the number is converted
  • max range: maximum midi note range in which the algorithm is bounded (def. 66)
  • min range: minimum midi note range on which the algorithm is bounded (def. 46)

The main output is a number (left outlet) that can be easily converted into a midi note, while an experimental output* (right outlet) provides a number between [0-1] that is translated to midi velocity by means of a-linmap macro. These two ouput can then be passed through some midi processing (execution probability, force to scale etc.). Attached there is a simple implementation with 1 Midi channel in output.

Experiment with the different parameters, esp. "step" and "base", but also with increasing and decreasing input numbers ("UP", "DOWN") to get interesting sequences. To this aim, a simple graphical interface is provided, which allows the selection of the main parameters as well as scale, min/max midi velocity and channel probability. The default output is Midi OUT, so you have to attach a midi instrument outside Architect or switch the output to Track<N> (internal to Architect).


*this idea is taken by the Musinum implementation in Pure Data by M. Brinkmann.