torstenanders

I understand that builtin functions of Opusmodus are not working on this level of abstraction / expressive power, as it would be a rather steep learning curve for users, but using and defining functions at this flexibility level reduces the length of your code substantially, which then helps to solve bigger problems by very small teams or individuals. I try to have my own libraries work at this kind of level. 😅

> I would like to SORT an (single-event)-list by pitch...
 
Apologies for a late response. 
 
Anyway, such functionality is actually built into Common Lisp. Hardly any coding required. Just specify a key attribute to the builtin sort function to tell it what data to look at for the sorting -- and specify a sort function.
 
(setf events '((e e4 mf) (e a4 mf) (e d5 mf) (e g5 mf) (e b5 mf) (e d6 mf)                (e b4 mf 2c) (e e5 mf 2c) (e a5 mf 2c) (e d6 mf 2c) (e fs6 mf 2c)                (e a6 mf 2c) (e e5 mf) (e a5 mf) (e d6 mf) (e g6 mf) (e b6 mf)                (e d7 mf) (e gs5 mf -14c) (e cs6 mf -14c) (e fs6 mf -14c)                (e b6 mf -14c) (e eb7 mf -14c) (e fs7 mf -14c) (e b5 mf 2c)                (e e6 mf 2c) (e a6 mf 2c) (e d7 mf 2c) (e fs7 mf 2c) (e a7 mf 2c)                (e d6 mf -31c) (e g6 mf -31c) (e c7 mf -31c) (e f7 mf -31c)                (e a7 mf -31c) (e c8 mf -31c) (e e6 mf) (e a6 mf) (e d7 mf)                (e g7 mf) (e b7 mf) (e d8 mf))) (sort events #'<       :key #'(lambda (event) (pitch-to-integer (second event))))  
See also 
CLHS: Function SORT, STABLE-SORT
CLHS.LISP.SE  
 
Note that this high level of programming and flexibility is what makes programming with Lisp so fun and productive. There are a bunch of other functions builtin doing other sequence operations on the same high level, like count (http://clhs.lisp.se/Body/f_countc.htm ), find (http://clhs.lisp.se/Body/f_find_.htm ) etc.   
 
 

I am aiming for some state-of-the-art microtonal/xenharmonic support for Opusmodus. Here is a first preview.

It has been easier than expected to do what I planned when using some unifying ideas proposed by tuning math guys around 20 years ago. The core idea is that just intonation (JI), arbitrary equal temperaments (subdividing the octave or other intervals) and very many other tunings (https://en.xen.wiki/w/Tour_of_Regular_Temperaments ) can all be expressed as regular temperaments. You can find an informal discussion of regular temperaments, its context and motivation -- how it extends/generalises many other tone systems -- at this link: http://x31eq.com/paradigm.html

Importantly, regular temperaments can all be mapped to JI. Therefore, they can also all by notated by pitch notation capable of notating JI for arbitrary prime limits. So, as a unifying pitch notation for all these temperaments I am using such a JI notation. Many recent JI staff notations (I found so far 5 of them, one highly developed one is http://sagittal.org ) are all based on the same fundamental idea, which I am also using: the traditional pitch nominals (A, B, C...) and the traditional accidentals (sharp, double-sharp, flat...) are denoting Pythagorean tuning (when the notation is read as a JI notation), i.e. they notate all the pitches we can reach when stacking just fifths (plus their octaves).

We can express this in OMN with our standard pitch notation. Here is a dominant seventh chord, which in a JI interpretation would be tuned in Pythagorean tuning.
(setf pythagorean-seventh '(h c4e4g4bb4))
We can play this chord in JI with the new macro def-tempered-score, which does pretty much what the Opusmodus builtin def-score does, but it receives a temperament as one of its arguments. Also, there are multiple MIDI channels specified here, as simultaneous tones are played on different MIDI channels, so they can be tuned individually by pitch bend (I am simply using the def-score tuning argument in the background). Using multiple channels instead of multiple ports is more widely supported by existing MIDI MPE-supporting plugins. 
(def-tempered-score score-name     (:temperament '11-limit-JI      :time-signature '(4 4))     (instr1     :omn pythagorean-seventh     :channel '(1 2 3 4)         :sound 'gm))
OK, how about instead of the Pythagorean third we want to use a just major third -- and also a harmonic seventh. All pitches that go beyond Pythagorean tuning are expressed using new JI accidentals that express some microtonal inflection. The core idea of all the above-mentioned JI pitch notations is to introduce a new accidental for every prime limit (https://en.wikipedia.org/wiki/Limit_(music) ) comma (https://en.wikipedia.org/wiki/Comma_(music) ). These different notations mainly differ in what kind of symbols they propose for these commas. 

When extending OMN by microtonal accidentals, I am restricted to plain ASCII letters and numbers (most of the ASCII special characters are already used for something else, and OMN does also not really support unicode). So, I suggest to use the letter K for denoting that something is a Komma (similar to the Greek kappa, from where the word comma comes -- the letter C is already used for cent values) and then simply complement that letter with the prime of the comma in question. So, the 5-limit comma (syntonic comma, https://en.wikipedia.org/wiki/Syntonic_comma) is notated 5K and the 7-limit comma is 7K. These accidentals raise the pitch by that comma, for a comma flat, put a minus in front of the accidental. So, here is how we can notate and play the just harmonic seventh chord (1K is the natural sign and multiple accidental attributes for a chord are assigned in ascending order of chord tones).
(setf 7-limit-seventh '(h c4e4g4bb4 1K+-5K+1K+-7K)) (def-tempered-score score-name     (:temperament '11-limit-JI      :time-signature '(4 4))     (instr1     :omn 7-limit-seventh     :channel '(1 2 3 4)         :sound 'gm))
JI leads to an infinite number of different pitches. Temperaments reduce that number. So, how about we want to play the above chord in, say, 22-tone equal temperament (https://en.xen.wiki/w/22edo ). For that, we only need to define that temperament. Each regular temperament (including equal temperaments and also JI) is specified by only two settings: a small number of generator intervals, and a val for each generator. The vals together specify how each prime (up to the prime limit of the temperament) it is mapped to JI. I will explain these details in a later message and for now simply show the definition of 22-EDO, which is pretty brief. 
(deftemperament 7-limit-22-EDO    ;; List of vals     (list (list 22         (+ 13 22)         (+ 7 (* 2 22))         (+ 18 (* 2 22))))   ;; List of generators   (list (/ 1200.0 22)))
Now, we can play the above chord (and any other 7-limit OMN intervals) in 22-EDO.
(def-tempered-score score-name     (:temperament '7-limit-22-EDO      :time-signature '(4 4))     (instr1     :omn 7-limit-seventh     :channel '(1 2 3 4)         :sound 'gm))
Similarily, we can define arbitrary other regular temperaments by simply specifying their vals and generators.
 

The function LENGTH-DIVIDE and friends are a useful device for introducing some rhythmic variation to some material. However, when the processed sequence is a full OMN expression (see example below), then the added notes cause all other parameters to shift forward (additional parameters are added at the end by looping). For introducing only a slight variation to some existing material (e.g., motif) these functions are therefore not so useful, because this shift of all parameters to basically "fill" the new added notes with pitches etc. greatly change the varied material for a listener.
(length-divide 1 2 '(q f3 leg+m1 q ab3 leg e c4 leg bb3 leg ab3 leg g3))  
Basically, this is the opposite situation of the situation addressed by swallowing. Swallowing (e.g., with GEN-SWALLOW and the swallow argument of many other functions) avoids the shift of parameters like pitch etc. that would result from removing notes and turning them into rests. For addressing the situation above properly we would need something like the opposite of swallowing, some way to fill in parameters like pitch etc. for new notes to avoid shifting existing notes. I hope my explanation makes sense and you can see why something like the opposite of swallowing would be useful for functions that add notes to some input material.
 
Now, the tricky question is of course, what parameters (pitch etc.) should be added in such cases. Musically useful and common in the classical literature would be, e.g., repeating the parameters (pitch etc.) of the predecessor note (though that might be a bit too simplistic and annoying at times) or somehow interpolating some pitch gap between the previous and next note with a little scale or arpeggio and only repeating the other parameters like articulations (resulting in some variation that is likely most similar to the input material, so it would be good to have that as an option).  If the pitch interval between the two original notes is too small to add some pitch in between for the new now (or as an option in general for variety), it would also be good  to add some ornamentation (e.g., using PITCH-ORNAMENT), but for a close similarity between the original material and the variation it would be best as an option to apply such ornamentation only to the newly added notes, not all notes. Of course, other options could also be useful for variations that vary the input material a bit more strongly, e.g., some random pitch for the new notes within certain interval bounds.
 
Does some function that kind of is the opposite of GEN-SWALLOW in that it adds parameters like pitches for subdivided rhythmic values (to avoid the shifting) sound like a good idea?
 
The idea with the interpolation of gaps could be implemented by turning the original duration values and pitches into some envelope and then reading that envelope with the new rhythmic values. So, that is rather strait forward. However, that would not allow for some ornamentation, because such algorithm would not recognise which notes are new that should be ornamented.
 
Any other idea perhaps? Thanks! 

Briefly sharing some news: I started to work on greatly improving Opusmodus' support for microtonal/xenharmonic music. I am aiming for supporting arbitrary equal temperaments (both equal divisions of the octave and other intervals), just intonation (JI) for arbitrary prime limits, and arbitrary regular temperaments (https://en.xen.wiki/w/Tour_of_Regular_Temperaments ). I aim to have this whole tuning universe controlled by a single uniform notation embedded in OMN. Still, I try to keep things relatively clear and simple by introducing only a single actual new accidental symbol, and that symbol will then be combined with numbers (for prime limits) to express arbitrary JI pitches, which are then mapped to all the possible tunings. I also aim for some support for dynamic temperaments, so that the tuning can change during the course of a piece.
 
Now, this is all claiming rather a lot, and the result may not necessarily be perfect (e.g., controlling a non-octave-repeating equal temperament with a notation suitable for JI is possible and may actually work well for some situations, but is perhaps not to everyones liking). Anyway, I already have some rather solid foundation for all this. Will update you on more details at a later time. 
 
(Technically, pitch deflections will be expressed by articulations, as I cannot change the underlying OMN pitch format. All this depends of course on getting the cent articulations working properly, but I trust that will be sorted at some stage. 😅)
 
Best,
Torsten

here it is:

After our recent Opusmodus Convention I have been asked whether there would be any Opusmodus tutorials for the libraries I shared. 
While there is no bespoke Opusmodus tutorial for any of them (you might consider my presentation at he Opusmodus convention as that tutorial, and additionally there are some nods to Opusmodus in the docs here and there), these libraries are all documented. For all libraries I write I tend to create detailed reference documentation for my own good 🙂  Much of the documentation is simply at the Common Lisp level, but that means in Opusmodus it would be largely used the same way. 

 
Fenv (Function Envelopes)
 
There is some short intro doc at the github project page of this library at https://github.com/tanders/fenv for plain Common Lisp but with a few Opusmodus-specific notes. In the fenv library, pretty much every definition has a very short docstring (e.g., see https://github.com/tanders/fenv/blob/master/sources/fenv.lisp ). These docstrings were also used for creating some HTML documentation. Check out the doc directory in this library. Further, there is a test file, which can also be considered a file with a bunch of examples, though without further documentation (see https://github.com/tanders/fenv/blob/master/tests/test-fenv.lisp ).
 
 
 
Cluster Engine and Cluster Rules
 
Concerning the constraint libraries, the situation is a bit more complex. The Github landing page of Cluster Engine (https://github.com/tanders/cluster-engine ) also starts with something like a mini tutorial and some very brief consideration of Opusmodus, like the fenv library. Nevertheless, these libraries where originally written for PWGL and they are still best documented when used from within PWGL.
 
You might want start looking into these libraries by watching some video tutorial I did for my students (as part of a collection/playlist of videos on PWGL) where I am showing them how to get started with these libraries in PWGL at
 
Both libraries feature some PWGL tutorial that consists of a number of PWGL patches accessible from the PWGL docs menu after installing and loading them.  These PWGL tutorials go much further than I do in the above-mentioned video.
 
Beyond these PWGL tutorials, there is also some reference doc for the top-level Cluster Engine functions (e.g.,  the rule applicators) and the predefined rules in Cluster Rules, again written as docstrings but also part of HTML docs of these libraries, but these are best understood after you followed the PWGL tutorials.
 
So, unfortunately I have to encourage you to check these libraries out in PWGL first, that is still more easy. You can then rather easily port your first PWGL Cluster Engine patches to Opusmodus, as the boxes in PWGL and the functions for Opusmodus at called the same, as long as you only used definitions from the Cluster Engine package.
 
Note that unfortunately, the original PWGL site is meanwhile down (this software is not developed any further), but it seems that some version of the software can still be downloaded at
fdsdbmascagni
SITES.GOOGLE.COM  
Apologies that there are no bespoke Opusmodus tutorials. Janusz already also mentioned some interest in these libraries, so I may give some dedicated talk on those at some later stage (e.g., as part of our next convention). I would likely cover largely what is already covered in the above-mentioned docs, only from within Opusmodus then.
 

TOT
 
Again, this library has a github landing page with some initial documentation (https://github.com/tanders/tot ) and some detailed reference documentation in HTML in the doc folder (https://tanders.github.io/tot/ ). This reference documentation features many examples that can be directly executed within Opusmodus. In some earlier version of Opusmodus, the HTML doc files could also be directly opened and the code could be evaluated without copying, but that is currently not possible any more (due to some changes by Apple as I understand, sigh). 

Note that all of these libraries might have some problems here and there. I try to test all my definitions carefully (for Cluster Engine I even defined a suit of regression tests), but things on which these libraries depends can change (e.g., some updates of Opusmodus break some TOT code every now and then). Anyway, if case you run into problems just get in touch. I have currently rather little time to look into these matters and thus may not be very response, but I will try to help at some stage... 
 
Best,
Torsten
 

After our recent Opusmodus Convention I have been asked whether there would be any Opusmodus tutorials for the libraries I shared. 
While there is no bespoke Opusmodus tutorial for any of them (you might consider my presentation at he Opusmodus convention as that tutorial, and additionally there are some nods to Opusmodus in the docs here and there), these libraries are all documented. For all libraries I write I tend to create detailed reference documentation for my own good 🙂  Much of the documentation is simply at the Common Lisp level, but that means in Opusmodus it would be largely used the same way. 

 
Fenv (Function Envelopes)
 
There is some short intro doc at the github project page of this library at https://github.com/tanders/fenv for plain Common Lisp but with a few Opusmodus-specific notes. In the fenv library, pretty much every definition has a very short docstring (e.g., see https://github.com/tanders/fenv/blob/master/sources/fenv.lisp ). These docstrings were also used for creating some HTML documentation. Check out the doc directory in this library. Further, there is a test file, which can also be considered a file with a bunch of examples, though without further documentation (see https://github.com/tanders/fenv/blob/master/tests/test-fenv.lisp ).
 
 
 
Cluster Engine and Cluster Rules
 
Concerning the constraint libraries, the situation is a bit more complex. The Github landing page of Cluster Engine (https://github.com/tanders/cluster-engine ) also starts with something like a mini tutorial and some very brief consideration of Opusmodus, like the fenv library. Nevertheless, these libraries where originally written for PWGL and they are still best documented when used from within PWGL.
 
You might want start looking into these libraries by watching some video tutorial I did for my students (as part of a collection/playlist of videos on PWGL) where I am showing them how to get started with these libraries in PWGL at
 
Both libraries feature some PWGL tutorial that consists of a number of PWGL patches accessible from the PWGL docs menu after installing and loading them.  These PWGL tutorials go much further than I do in the above-mentioned video.
 
Beyond these PWGL tutorials, there is also some reference doc for the top-level Cluster Engine functions (e.g.,  the rule applicators) and the predefined rules in Cluster Rules, again written as docstrings but also part of HTML docs of these libraries, but these are best understood after you followed the PWGL tutorials.
 
So, unfortunately I have to encourage you to check these libraries out in PWGL first, that is still more easy. You can then rather easily port your first PWGL Cluster Engine patches to Opusmodus, as the boxes in PWGL and the functions for Opusmodus at called the same, as long as you only used definitions from the Cluster Engine package.
 
Note that unfortunately, the original PWGL site is meanwhile down (this software is not developed any further), but it seems that some version of the software can still be downloaded at
fdsdbmascagni
SITES.GOOGLE.COM  
Apologies that there are no bespoke Opusmodus tutorials. Janusz already also mentioned some interest in these libraries, so I may give some dedicated talk on those at some later stage (e.g., as part of our next convention). I would likely cover largely what is already covered in the above-mentioned docs, only from within Opusmodus then.
 

TOT
 
Again, this library has a github landing page with some initial documentation (https://github.com/tanders/tot ) and some detailed reference documentation in HTML in the doc folder (https://tanders.github.io/tot/ ). This reference documentation features many examples that can be directly executed within Opusmodus. In some earlier version of Opusmodus, the HTML doc files could also be directly opened and the code could be evaluated without copying, but that is currently not possible any more (due to some changes by Apple as I understand, sigh). 

Note that all of these libraries might have some problems here and there. I try to test all my definitions carefully (for Cluster Engine I even defined a suit of regression tests), but things on which these libraries depends can change (e.g., some updates of Opusmodus break some TOT code every now and then). Anyway, if case you run into problems just get in touch. I have currently rather little time to look into these matters and thus may not be very response, but I will try to help at some stage... 
 
Best,
Torsten
 

After our recent Opusmodus Convention I have been asked whether there would be any Opusmodus tutorials for the libraries I shared. 
While there is no bespoke Opusmodus tutorial for any of them (you might consider my presentation at he Opusmodus convention as that tutorial, and additionally there are some nods to Opusmodus in the docs here and there), these libraries are all documented. For all libraries I write I tend to create detailed reference documentation for my own good 🙂  Much of the documentation is simply at the Common Lisp level, but that means in Opusmodus it would be largely used the same way. 

 
Fenv (Function Envelopes)
 
There is some short intro doc at the github project page of this library at https://github.com/tanders/fenv for plain Common Lisp but with a few Opusmodus-specific notes. In the fenv library, pretty much every definition has a very short docstring (e.g., see https://github.com/tanders/fenv/blob/master/sources/fenv.lisp ). These docstrings were also used for creating some HTML documentation. Check out the doc directory in this library. Further, there is a test file, which can also be considered a file with a bunch of examples, though without further documentation (see https://github.com/tanders/fenv/blob/master/tests/test-fenv.lisp ).
 
 
 
Cluster Engine and Cluster Rules
 
Concerning the constraint libraries, the situation is a bit more complex. The Github landing page of Cluster Engine (https://github.com/tanders/cluster-engine ) also starts with something like a mini tutorial and some very brief consideration of Opusmodus, like the fenv library. Nevertheless, these libraries where originally written for PWGL and they are still best documented when used from within PWGL.
 
You might want start looking into these libraries by watching some video tutorial I did for my students (as part of a collection/playlist of videos on PWGL) where I am showing them how to get started with these libraries in PWGL at
 
Both libraries feature some PWGL tutorial that consists of a number of PWGL patches accessible from the PWGL docs menu after installing and loading them.  These PWGL tutorials go much further than I do in the above-mentioned video.
 
Beyond these PWGL tutorials, there is also some reference doc for the top-level Cluster Engine functions (e.g.,  the rule applicators) and the predefined rules in Cluster Rules, again written as docstrings but also part of HTML docs of these libraries, but these are best understood after you followed the PWGL tutorials.
 
So, unfortunately I have to encourage you to check these libraries out in PWGL first, that is still more easy. You can then rather easily port your first PWGL Cluster Engine patches to Opusmodus, as the boxes in PWGL and the functions for Opusmodus at called the same, as long as you only used definitions from the Cluster Engine package.
 
Note that unfortunately, the original PWGL site is meanwhile down (this software is not developed any further), but it seems that some version of the software can still be downloaded at
fdsdbmascagni
SITES.GOOGLE.COM  
Apologies that there are no bespoke Opusmodus tutorials. Janusz already also mentioned some interest in these libraries, so I may give some dedicated talk on those at some later stage (e.g., as part of our next convention). I would likely cover largely what is already covered in the above-mentioned docs, only from within Opusmodus then.
 

TOT
 
Again, this library has a github landing page with some initial documentation (https://github.com/tanders/tot ) and some detailed reference documentation in HTML in the doc folder (https://tanders.github.io/tot/ ). This reference documentation features many examples that can be directly executed within Opusmodus. In some earlier version of Opusmodus, the HTML doc files could also be directly opened and the code could be evaluated without copying, but that is currently not possible any more (due to some changes by Apple as I understand, sigh). 

Note that all of these libraries might have some problems here and there. I try to test all my definitions carefully (for Cluster Engine I even defined a suit of regression tests), but things on which these libraries depends can change (e.g., some updates of Opusmodus break some TOT code every now and then). Anyway, if case you run into problems just get in touch. I have currently rather little time to look into these matters and thus may not be very response, but I will try to help at some stage... 
 
Best,
Torsten
 

After our recent Opusmodus Convention I have been asked whether there would be any Opusmodus tutorials for the libraries I shared. 
While there is no bespoke Opusmodus tutorial for any of them (you might consider my presentation at he Opusmodus convention as that tutorial, and additionally there are some nods to Opusmodus in the docs here and there), these libraries are all documented. For all libraries I write I tend to create detailed reference documentation for my own good 🙂  Much of the documentation is simply at the Common Lisp level, but that means in Opusmodus it would be largely used the same way. 

 
Fenv (Function Envelopes)
 
There is some short intro doc at the github project page of this library at https://github.com/tanders/fenv for plain Common Lisp but with a few Opusmodus-specific notes. In the fenv library, pretty much every definition has a very short docstring (e.g., see https://github.com/tanders/fenv/blob/master/sources/fenv.lisp ). These docstrings were also used for creating some HTML documentation. Check out the doc directory in this library. Further, there is a test file, which can also be considered a file with a bunch of examples, though without further documentation (see https://github.com/tanders/fenv/blob/master/tests/test-fenv.lisp ).
 
 
 
Cluster Engine and Cluster Rules
 
Concerning the constraint libraries, the situation is a bit more complex. The Github landing page of Cluster Engine (https://github.com/tanders/cluster-engine ) also starts with something like a mini tutorial and some very brief consideration of Opusmodus, like the fenv library. Nevertheless, these libraries where originally written for PWGL and they are still best documented when used from within PWGL.
 
You might want start looking into these libraries by watching some video tutorial I did for my students (as part of a collection/playlist of videos on PWGL) where I am showing them how to get started with these libraries in PWGL at
 
Both libraries feature some PWGL tutorial that consists of a number of PWGL patches accessible from the PWGL docs menu after installing and loading them.  These PWGL tutorials go much further than I do in the above-mentioned video.
 
Beyond these PWGL tutorials, there is also some reference doc for the top-level Cluster Engine functions (e.g.,  the rule applicators) and the predefined rules in Cluster Rules, again written as docstrings but also part of HTML docs of these libraries, but these are best understood after you followed the PWGL tutorials.
 
So, unfortunately I have to encourage you to check these libraries out in PWGL first, that is still more easy. You can then rather easily port your first PWGL Cluster Engine patches to Opusmodus, as the boxes in PWGL and the functions for Opusmodus at called the same, as long as you only used definitions from the Cluster Engine package.
 
Note that unfortunately, the original PWGL site is meanwhile down (this software is not developed any further), but it seems that some version of the software can still be downloaded at
fdsdbmascagni
SITES.GOOGLE.COM  
Apologies that there are no bespoke Opusmodus tutorials. Janusz already also mentioned some interest in these libraries, so I may give some dedicated talk on those at some later stage (e.g., as part of our next convention). I would likely cover largely what is already covered in the above-mentioned docs, only from within Opusmodus then.
 

TOT
 
Again, this library has a github landing page with some initial documentation (https://github.com/tanders/tot ) and some detailed reference documentation in HTML in the doc folder (https://tanders.github.io/tot/ ). This reference documentation features many examples that can be directly executed within Opusmodus. In some earlier version of Opusmodus, the HTML doc files could also be directly opened and the code could be evaluated without copying, but that is currently not possible any more (due to some changes by Apple as I understand, sigh). 

Note that all of these libraries might have some problems here and there. I try to test all my definitions carefully (for Cluster Engine I even defined a suit of regression tests), but things on which these libraries depends can change (e.g., some updates of Opusmodus break some TOT code every now and then). Anyway, if case you run into problems just get in touch. I have currently rather little time to look into these matters and thus may not be very response, but I will try to help at some stage... 
 
Best,
Torsten
 

I am sharing here the score of some piece I did some time ago with Opusmodus and which I will touch upon in my presentation at the forthcoming Opusmodus convention. 
 
Unfortunately, I only have a score for this and no recording. 
 
Torsten
Torsten Anders - 2017 - Aschenputtel - for Flute Solo.pdf

I am sharing here the score of some piece I did some time ago with Opusmodus and which I will touch upon in my presentation at the forthcoming Opusmodus convention. 
 
Unfortunately, I only have a score for this and no recording. 
 
Torsten
Torsten Anders - 2017 - Aschenputtel - for Flute Solo.pdf

I am sharing here the score of some piece I did some time ago with Opusmodus and which I will touch upon in my presentation at the forthcoming Opusmodus convention. 
 
Unfortunately, I only have a score for this and no recording. 
 
Torsten
Torsten Anders - 2017 - Aschenputtel - for Flute Solo.pdf

Okay, it works easily and well with my setup: simply copy the "emacs-opusmodus.el" into your local quicklisp directory and modify Emacs's init.el to add
 
(load (expand-file-name "$HOME/quicklisp/emacs-opusmodus.el")) (load-opusmodus-slime) (opusmodus-options)  
This allows me to run up a REPL against SBCL (M-x slime) or against OM (M-x slime-connect)

I've tried a bit Ircam instruments2 but still feel a lack of dynamics variety...
S.

i have been working with conTimbre for a long time and it is exactly what i was looking for. playing techniques can easily be done by OPMO or SIBELIUS (vst3) via program changes. it has a great many different playing techniques. I always found IRCAM_LIB to be very inadequate, as there were not enough playing techniques etc. / you can also control CT via OSC (and as standalone or via MAXMSP). when I wrote for ensemble with additional e-player, CT-live always worked very well.
 
(The only negative point I could say is that there are a few SAMPLES that weren't played / recorded very well. But with the size of the library, that's okay with me)

A possibility is to use plogue Bidule to create a kind of meta-instrument with keyswitch to switch from classical to extended techniques.
 
I will have a look.
 
S.

For some recent is not working if in Extensions folder.

Thanks a lot Torsten. The *do-verbose* trick works for me.
 
- Rangarajan

Concerning own GUI applications: you can already do that. This is independent of Opusmodus. 
 
For example, on a Mac CCL (the Lisp compiler on which Opusmodus is built) has a built-in Cocoa Interface  and Objective-C bridge. There also exist other GUI libraries for Lisp. For example, check out 
GUI toolkits
LISPCOOKBOOK.GITHUB.IO A collection of examples of using Common Lisp  

I cannot answer this for Janusz, but I can provide some further reflection on this.
 
You could investigate how the Emacs-Slime interface talks to the CCL compiler, on which Opusmodus is based, and then use that same protocol for your purposes. Of course, this will always only work if on the machine in question Opusmodus is installed. Also, Opusmodus must be started first (which currently always starts the full IDE as well, AFAIK -- at least it does for me, and I use Opusmodus meanwhile mainly via  the Slime interface). It is likely possible in principle to get around starting the full IDE each time and instead only start CCL with the relevant Opusmodus definitions, but users of your plugins or custom applications will always need to buy Opusmodus themselves, so this is pretty much a niche in a niche market...
 
Not sure whether there is a market here for Opusmodus Inc. to spend development resources, which would make this more suitable for your purposes. Obviously, this company is not someone like Apple. It cannot afford  throwing out development tools for free, I guess.😅 
 
Perhaps Opusmodus Inc. could ask for a licence fee from developers who build applications based on Opusmodus definitions. That might open a market that would pay Opusmodus for investing the necessary development resources for something like that. If there are a few developers willing to pay such a fee, this might actually be quite workable for both sides, the developers and Opusmodus Inc. It then might be possible to use Opusmodus definitions in a "normal" Common Lisp application (perhaps even supporting tools like roswell for easy executable creation). 
 
Just my 2 Euro-cent on this question...

I just noted that the code I shared above depends on other definitions in my library (e.g., the function preview-score). Below is an update that instead uses only builtin Opusmodus functions. Holler in case this is not working for you, as the code on my machine is a bit different, and I did not test the code below... (specifically, the version below only works for the scores with instruments from the ps set gm, while my own code is more flexible, but then again depends on other custom definitions).
 
 
;; Emacs lisp code: put into your Emacs init file, e.g., ~/.emacs ;; Custom function for previewing Openmusic snippets etc (defun slime-eval-and-preview-opmo-snippet-before-point () "Evaluate the Openmusic snippet (an expression) preceding point and preview that snippet." (interactive) (let* ((score (slime-last-expression)) (full-expr (concat "(ps 'gm (list :treble " score "))")) ) ;; (print (concat "debug: " full-expr)) (slime-interactive-eval full-expr))) (defun slime-eval-and-preview-opmo-score-before-point () "Evaluate the score (an expression in the tot score format) preceding point and preview that score (notation and playback)." (interactive) (let* ((score (slime-last-expression)) (full-expr (concat "(ps 'gm " score ")")) ) (slime-interactive-eval full-expr))) (defun slime-stop-opmo-playback () "Stop the currently playing Openmusic sound playback." (interactive) (slime-interactive-eval "(sequencer:sequencer-stop *audition-sequencer*)")) (defun slime-opmo-midi-playback () "(Re-)play the last Opusmodus score with a separate MIDI playback window." (interactive) (slime-interactive-eval "(display-midi *last-score* :display :window)")) (add-hook 'lisp-mode-hook (lambda () (local-set-key (kbd "<A-f2>") #'slime-eval-and-preview-opmo-snippet-before-point) (local-set-key (kbd "<A-f3>") #'slime-eval-and-preview-opmo-score-before-point) (local-set-key (kbd "<A-f4>") #'slime-opmo-midi-playback) (local-set-key (kbd "<A-f1>") #'slime-stop-opmo-playback) )) ;; Creating a new "Opusmodus" menu in the menu bar to the right of "Lisp" menu. ;; This new menu is only shown when in lisp-mode (define-key-after lisp-mode-map [menu-bar opusmodus] (cons "Opusmodus" (make-sparse-keymap "hoot hoot")) 'lisp) ;; Creating a menu item, under the menu by the id “[menu-bar opusmodus]” (define-key lisp-mode-map [menu-bar opusmodus preview-score] '("Preview score cmd-f3" . slime-eval-and-preview-opmo-score-before-point)) (define-key lisp-mode-map [menu-bar opusmodus preview-snippet] '("Preview snippet cmd-f2" . slime-eval-and-preview-opmo-snippet-before-point)) (define-key lisp-mode-map [menu-bar opusmodus stop-playback] '("Stop playback cmd-f1" . slime-stop-opmo-playback)) (define-key lisp-mode-map [menu-bar opusmodus replay-score] '("(Re)play last score cmd-f4" . slime-opmo-midi-playback))  

I cannot answer for the builtin Opusmodus Slime functionality, but I developed something similar some time ago on my own, which works in Aquamacs for me. Try copying the Emacs Lisp code below into your Emacs initialisation file (e.g., ~/.emacs), start Aquamacs again and open a Lisp file.
 
The code below adds to Emacs buffers in Lisp mode an Opusmodus menu with some standard commands like for previewing a snippet, stopping the playback etc. together with shortcuts shown in the menu. 
 
It is all a bit hacky, but works for me and perhaps also for others 😉  It should also be easy to add menu items and keyboard shortcuts for any other commands (like plotting) that work from Lisp. 
 
;; Custom function for previewing Openmusic snippets etc (defun slime-eval-and-preview-opmo-snippet-before-point () "Evaluate the Openmusic snippet (an expression) preceding point and preview that snippet." (interactive) (let* ((score (slime-last-expression)) ;; wrap call to preview-score around the score before point (full-expr (concat "(preview-score (list :snippet " score "))"))) (slime-interactive-eval full-expr))) (defun slime-eval-and-preview-opmo-score-before-point () "Evaluate the score (an expression in the tot score format) preceding point and preview that score (notation and playback)." (interactive) (let* ((score (slime-last-expression)) ;; wrap call to preview-score around the score before point (full-expr (concat "(preview-score " score ")"))) (slime-interactive-eval full-expr))) (defun slime-stop-opmo-playback () "Stop the currently playing Openmusic sound playback." (interactive) (slime-interactive-eval "(sequencer:sequencer-stop *audition-sequencer*)")) (defun slime-opmo-midi-playback () "(Re-)play the last Opusmodus score with a separate MIDI playback window." (interactive) (slime-interactive-eval "(display-midi *last-score* :display :window)")) (add-hook 'lisp-mode-hook (lambda () (local-set-key (kbd "<A-f2>") #'slime-eval-and-preview-opmo-snippet-before-point) (local-set-key (kbd "<A-f3>") #'slime-eval-and-preview-opmo-score-before-point) (local-set-key (kbd "<A-f4>") #'slime-opmo-midi-playback) (local-set-key (kbd "<A-f1>") #'slime-stop-opmo-playback) )) ;; Creating a new "Opusmodus" menu in the menu bar to the right of "Lisp" menu. ;; This new menu is only shown when in lisp-mode (define-key-after lisp-mode-map [menu-bar opusmodus] (cons "Opusmodus" (make-sparse-keymap "hoot hoot")) 'lisp) ;; Creating a menu item, under the menu by the id “[menu-bar opusmodus]” (define-key lisp-mode-map [menu-bar opusmodus preview-score] '("Preview score cmd-f3" . slime-eval-and-preview-opmo-score-before-point)) (define-key lisp-mode-map [menu-bar opusmodus preview-snippet] '("Preview snippet cmd-f2" . slime-eval-and-preview-opmo-snippet-before-point)) (define-key lisp-mode-map [menu-bar opusmodus stop-playback] '("Stop playback cmd-f1" . slime-stop-opmo-playback)) (define-key lisp-mode-map [menu-bar opusmodus replay-score] '("(Re)play last score cmd-f4" . slime-opmo-midi-playback))  

2.1.26015
 
– New:
SCALE-NUMBERS

– Changes and Additions (check the documentation for each of the functions below):

GEN-CHORD-SERIES
GEN-COLLECT – tuplet grouping.
GEN-FRAGMENT – tuplet grouping.
GEN-INTERLEAVE – tuplet grouping.
GEN-MORPH – tuplet grouping.
CHORD-INVERSION – extended functionality.
DECHORD
PS – preserve pitch names (composers intend).
COUNTERPOINT – dictum addition: :tempo and :harmony, new voice symbol * (Pedal Point).
DICTUM-TEMPO

– Fixes:
Tempo :length - tempo mark in the middle of a measure.
TIE-BARS – with argument :section and :exclude.
and same minor once.
 
– Documentation:
New score examples in Howto Utilities.
 
– Note:
The Check for Updates... should work and recognise your macOS system and install the correct update for your system.
Please let me know if it works. If dose not work for you please download the update from the Forums Downloads page.
Possibly the download here is safer. 🚦

Best wishes,
Janusz

P.S. Later this week I will make an Announcement on Howto to setup and use Supercollider in Opusmodus.

Yes you can.